Return to keymaps.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / readline

Annotation of embedaddon/readline/keymaps.c, revision 1.1

1.1     ! misho       1: /* keymaps.c -- Functions and keymaps for the GNU Readline library. */
        !             2: 
        !             3: /* Copyright (C) 1988,1989-2009 Free Software Foundation, Inc.
        !             4: 
        !             5:    This file is part of the GNU Readline Library (Readline), a library
        !             6:    for reading lines of text with interactive input and history editing.      
        !             7: 
        !             8:    Readline is free software: you can redistribute it and/or modify
        !             9:    it under the terms of the GNU General Public License as published by
        !            10:    the Free Software Foundation, either version 3 of the License, or
        !            11:    (at your option) any later version.
        !            12: 
        !            13:    Readline is distributed in the hope that it will be useful,
        !            14:    but WITHOUT ANY WARRANTY; without even the implied warranty of
        !            15:    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        !            16:    GNU General Public License for more details.
        !            17: 
        !            18:    You should have received a copy of the GNU General Public License
        !            19:    along with Readline.  If not, see <http://www.gnu.org/licenses/>.
        !            20: */
        !            21: 
        !            22: #define READLINE_LIBRARY
        !            23: 
        !            24: #if defined (HAVE_CONFIG_H)
        !            25: #  include <config.h>
        !            26: #endif
        !            27: 
        !            28: #if defined (HAVE_STDLIB_H)
        !            29: #  include <stdlib.h>
        !            30: #else
        !            31: #  include "ansi_stdlib.h"
        !            32: #endif /* HAVE_STDLIB_H */
        !            33: 
        !            34: #include <stdio.h>     /* for FILE * definition for readline.h */
        !            35: 
        !            36: #include "readline.h"
        !            37: #include "rlconf.h"
        !            38: 
        !            39: #include "emacs_keymap.c"
        !            40: 
        !            41: #if defined (VI_MODE)
        !            42: #include "vi_keymap.c"
        !            43: #endif
        !            44: 
        !            45: #include "xmalloc.h"
        !            46: 
        !            47: /* **************************************************************** */
        !            48: /*                                                                 */
        !            49: /*                   Functions for manipulating Keymaps.           */
        !            50: /*                                                                 */
        !            51: /* **************************************************************** */
        !            52: 
        !            53: 
        !            54: /* Return a new, empty keymap.
        !            55:    Free it with free() when you are done. */
        !            56: Keymap
        !            57: rl_make_bare_keymap ()
        !            58: {
        !            59:   register int i;
        !            60:   Keymap keymap;
        !            61: 
        !            62:   keymap = (Keymap)xmalloc (KEYMAP_SIZE * sizeof (KEYMAP_ENTRY));
        !            63:   for (i = 0; i < KEYMAP_SIZE; i++)
        !            64:     {
        !            65:       keymap[i].type = ISFUNC;
        !            66:       keymap[i].function = (rl_command_func_t *)NULL;
        !            67:     }
        !            68: 
        !            69: #if 0
        !            70:   for (i = 'A'; i < ('Z' + 1); i++)
        !            71:     {
        !            72:       keymap[i].type = ISFUNC;
        !            73:       keymap[i].function = rl_do_lowercase_version;
        !            74:     }
        !            75: #endif
        !            76: 
        !            77:   return (keymap);
        !            78: }
        !            79: 
        !            80: /* Return a new keymap which is a copy of MAP.  Just copies pointers, does
        !            81:    not copy text of macros or descend into child keymaps. */
        !            82: Keymap
        !            83: rl_copy_keymap (map)
        !            84:      Keymap map;
        !            85: {
        !            86:   register int i;
        !            87:   Keymap temp;
        !            88: 
        !            89:   temp = rl_make_bare_keymap ();
        !            90:   for (i = 0; i < KEYMAP_SIZE; i++)
        !            91:     {
        !            92:       temp[i].type = map[i].type;
        !            93:       temp[i].function = map[i].function;
        !            94:     }
        !            95:   return (temp);
        !            96: }
        !            97: 
        !            98: /* Return a new keymap with the printing characters bound to rl_insert,
        !            99:    the uppercase Meta characters bound to run their lowercase equivalents,
        !           100:    and the Meta digits bound to produce numeric arguments. */
        !           101: Keymap
        !           102: rl_make_keymap ()
        !           103: {
        !           104:   register int i;
        !           105:   Keymap newmap;
        !           106: 
        !           107:   newmap = rl_make_bare_keymap ();
        !           108: 
        !           109:   /* All ASCII printing characters are self-inserting. */
        !           110:   for (i = ' '; i < 127; i++)
        !           111:     newmap[i].function = rl_insert;
        !           112: 
        !           113:   newmap[TAB].function = rl_insert;
        !           114:   newmap[RUBOUT].function = rl_rubout; /* RUBOUT == 127 */
        !           115:   newmap[CTRL('H')].function = rl_rubout;
        !           116: 
        !           117: #if KEYMAP_SIZE > 128
        !           118:   /* Printing characters in ISO Latin-1 and some 8-bit character sets. */
        !           119:   for (i = 128; i < 256; i++)
        !           120:     newmap[i].function = rl_insert;
        !           121: #endif /* KEYMAP_SIZE > 128 */
        !           122: 
        !           123:   return (newmap);
        !           124: }
        !           125: 
        !           126: /* Free the storage associated with MAP. */
        !           127: void
        !           128: rl_discard_keymap (map)
        !           129:      Keymap map;
        !           130: {
        !           131:   int i;
        !           132: 
        !           133:   if (map == 0)
        !           134:     return;
        !           135: 
        !           136:   for (i = 0; i < KEYMAP_SIZE; i++)
        !           137:     {
        !           138:       switch (map[i].type)
        !           139:        {
        !           140:        case ISFUNC:
        !           141:          break;
        !           142: 
        !           143:        case ISKMAP:
        !           144:          rl_discard_keymap ((Keymap)map[i].function);
        !           145:          xfree ((char *)map[i].function);
        !           146:          break;
        !           147: 
        !           148:        case ISMACR:
        !           149:          xfree ((char *)map[i].function);
        !           150:          break;
        !           151:        }
        !           152:     }
        !           153: }
        !           154: 
        !           155: /* Convenience function that discards, then frees, MAP. */
        !           156: void
        !           157: rl_free_keymap (map)
        !           158:      Keymap map;
        !           159: {
        !           160:   rl_discard_keymap (map);
        !           161:   xfree ((char *)map);
        !           162: }