Return to keymaps.c CVS log

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

Initial revision

    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: }