home *** CD-ROM | disk | FTP | other *** search
/ OpenStep 4.2J (Developer) / os42jdev.iso / NextDeveloper / Source / GNU / debug / gdb / readline / keymaps.c < prev    next >
C/C++ Source or Header  |  1995-07-28  |  4KB  |  191 lines
  1. /* keymaps.c -- Functions and keymaps for the GNU Readline library. */
  2.  
  3. /* Copyright (C) 1988, 1989, 1991 Free Software Foundation, Inc.
  4.  
  5.    This file is part of GNU Readline, a library for reading lines
  6.    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 2 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 this program; if not, write to the Free Software
  20.    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  21.  
  22. #include "sysdep.h"
  23. #include <stdio.h>
  24. #include "readline.h"
  25. #include "keymaps.h"
  26. #include "emacs_keymap.c"
  27.  
  28. #ifdef VI_MODE
  29. #include "vi_keymap.c"
  30. #endif
  31.  
  32. /* Remove these declarations when we have a complete libgnu.a. */
  33. /* #define STATIC_MALLOC */
  34. #if !defined (STATIC_MALLOC)
  35. extern char *xmalloc (), *xrealloc ();
  36. #else
  37. static char *xmalloc (), *xrealloc ();
  38. #endif /* STATIC_MALLOC */
  39.  
  40. /* **************************************************************** */
  41. /*                                    */
  42. /*              Functions for manipulating Keymaps.        */
  43. /*                                    */
  44. /* **************************************************************** */
  45.  
  46.  
  47. /* Return a new, empty keymap.
  48.    Free it with free() when you are done. */
  49. Keymap
  50. rl_make_bare_keymap ()
  51. {
  52.   register int i;
  53.   Keymap keymap = (Keymap)xmalloc (KEYMAP_SIZE * sizeof (KEYMAP_ENTRY));
  54.  
  55.   for (i = 0; i < KEYMAP_SIZE; i++)
  56.     {
  57.       keymap[i].type = ISFUNC;
  58.       keymap[i].function = (Function *)NULL;
  59.     }
  60.  
  61.   for (i = 'A'; i < ('Z' + 1); i++)
  62.     {
  63.       keymap[i].type = ISFUNC;
  64.       keymap[i].function = rl_do_lowercase_version;
  65.     }
  66.  
  67.   return (keymap);
  68. }
  69.  
  70. /* Return a new keymap which is a copy of MAP. */
  71. Keymap
  72. rl_copy_keymap (map)
  73.      Keymap map;
  74. {
  75.   register int i;
  76.   Keymap temp = rl_make_bare_keymap ();
  77.  
  78.   for (i = 0; i < KEYMAP_SIZE; i++)
  79.     {
  80.       temp[i].type = map[i].type;
  81.       temp[i].function = map[i].function;
  82.     }
  83.   return (temp);
  84. }
  85.  
  86. /* Return a new keymap with the printing characters bound to rl_insert,
  87.    the uppercase Meta characters bound to run their lowercase equivalents,
  88.    and the Meta digits bound to produce numeric arguments. */
  89. Keymap
  90. rl_make_keymap ()
  91. {
  92.   extern int rl_insert (), rl_rubout ();
  93.   register int i;
  94.   Keymap newmap;
  95.  
  96.   newmap = rl_make_bare_keymap ();
  97.  
  98.   /* All ASCII printing characters are self-inserting. */
  99.   for (i = ' '; i < 126; i++)
  100.     newmap[i].function = rl_insert;
  101.  
  102.   newmap[TAB].function = rl_insert;
  103.   newmap[RUBOUT].function = rl_rubout;
  104.   newmap[CTRL('H')].function = rl_rubout;
  105.  
  106. #if KEYMAP_SIZE > 128
  107.   /* Printing characters in some 8-bit character sets. */
  108.   for (i = 128; i < 160; i++)
  109.     newmap[i].function = rl_insert;
  110.  
  111.   /* ISO Latin-1 printing characters should self-insert. */
  112.   for (i = 160; i < 256; i++)
  113.     newmap[i].function = rl_insert;
  114. #endif /* KEYMAP_SIZE > 128 */
  115.  
  116.   return (newmap);
  117. }
  118.  
  119. /* Free the storage associated with MAP. */
  120. rl_discard_keymap (map)
  121.      Keymap (map);
  122. {
  123.   int i;
  124.  
  125.   if (!map)
  126.     return;
  127.  
  128.   for (i = 0; i < KEYMAP_SIZE; i++)
  129.     {
  130.       switch (map[i].type)
  131.     {
  132.     case ISFUNC:
  133.       break;
  134.  
  135.     case ISKMAP:
  136.       rl_discard_keymap ((Keymap)map[i].function);
  137.       break;
  138.  
  139.     case ISMACR:
  140.       free ((char *)map[i].function);
  141.       break;
  142.     }
  143.     }
  144. }
  145.  
  146. #if defined (STATIC_MALLOC)
  147.  
  148. /* **************************************************************** */
  149. /*                                    */
  150. /*            xmalloc and xrealloc ()                     */
  151. /*                                    */
  152. /* **************************************************************** */
  153.  
  154. static void memory_error_and_abort ();
  155.  
  156. static char *
  157. xmalloc (bytes)
  158.      int bytes;
  159. {
  160.   char *temp = (char *)malloc (bytes);
  161.  
  162.   if (!temp)
  163.     memory_error_and_abort ();
  164.   return (temp);
  165. }
  166.  
  167. static char *
  168. xrealloc (pointer, bytes)
  169.      char *pointer;
  170.      int bytes;
  171. {
  172.   char *temp;
  173.  
  174.   if (!pointer)
  175.     temp = (char *)malloc (bytes);
  176.   else
  177.     temp = (char *)realloc (pointer, bytes);
  178.  
  179.   if (!temp)
  180.     memory_error_and_abort ();
  181.   return (temp);
  182. }
  183.  
  184. static void
  185. memory_error_and_abort ()
  186. {
  187.   fprintf (stderr, "readline: Out of virtual memory!\n");
  188.   abort ();
  189. }
  190. #endif /* STATIC_MALLOC */
  191.