home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 22 gnu / 22-gnu.zip / readline.zip / readline-2.1 / macro.c < prev    next >
C/C++ Source or Header  |  1996-06-27  |  7KB  |  278 lines
  1. /* macro.c -- keyboard macros for readline. */
  2.  
  3. /* Copyright (C) 1994 Free Software Foundation, Inc.
  4.  
  5.    This file is part of the GNU Readline Library, a library for
  6.    reading lines of text with interactive input and history editing.
  7.  
  8.    The GNU Readline Library is free software; you can redistribute it
  9.    and/or modify it under the terms of the GNU General Public License
  10.    as published by the Free Software Foundation; either version 1, or
  11.    (at your option) any later version.
  12.  
  13.    The GNU Readline Library is distributed in the hope that it will be
  14.    useful, but WITHOUT ANY WARRANTY; without even the implied warranty
  15.    of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16.    GNU General Public License for more details.
  17.  
  18.    The GNU General Public License is often shipped with GNU software, and
  19.    is generally kept in a file called COPYING or LICENSE.  If you do not
  20.    have a copy of the license, write to the Free Software Foundation,
  21.    675 Mass Ave, Cambridge, MA 02139, USA. */
  22. #define READLINE_LIBRARY
  23.  
  24. #if defined (HAVE_CONFIG_H)
  25. #  include <config.h>
  26. #endif
  27.  
  28. #include <sys/types.h>
  29.  
  30. #if defined (HAVE_UNISTD_H)
  31. #  include <unistd.h>           /* for _POSIX_VERSION */
  32. #endif /* HAVE_UNISTD_H */
  33.  
  34. #if defined (HAVE_STDLIB_H)
  35. #  include <stdlib.h>
  36. #else
  37. #  include "ansi_stdlib.h"
  38. #endif /* HAVE_STDLIB_H */
  39.  
  40. #include <stdio.h>
  41.  
  42. /* System-specific feature definitions and include files. */
  43. #include "rldefs.h"
  44.  
  45. /* Some standard library routines. */
  46. #include "readline.h"
  47. #include "history.h"
  48.  
  49. #define SWAP(s, e)  do { int t; t = s; s = e; e = t; } while (0)
  50.  
  51. /* Forward definitions. */
  52. void _rl_push_executing_macro (), _rl_pop_executing_macro ();
  53. void _rl_add_macro_char ();
  54.  
  55. /* Extern declarations. */
  56. extern int rl_explicit_arg;
  57. extern int rl_key_sequence_length;
  58.  
  59. extern void _rl_abort_internal ();
  60.  
  61. extern char *xmalloc (), *xrealloc ();
  62.  
  63. /* **************************************************************** */
  64. /*                                    */
  65. /*            Hacking Keyboard Macros             */
  66. /*                                    */
  67. /* **************************************************************** */
  68.  
  69. /* Non-zero means to save keys that we dispatch on in a kbd macro. */
  70. int _rl_defining_kbd_macro = 0;
  71.  
  72. /* The currently executing macro string.  If this is non-zero,
  73.    then it is a malloc ()'ed string where input is coming from. */
  74. char *_rl_executing_macro = (char *)NULL;
  75.  
  76. /* The offset in the above string to the next character to be read. */
  77. static int executing_macro_index;
  78.  
  79. /* The current macro string being built.  Characters get stuffed
  80.    in here by add_macro_char (). */
  81. static char *current_macro = (char *)NULL;
  82.  
  83. /* The size of the buffer allocated to current_macro. */
  84. static int current_macro_size;
  85.  
  86. /* The index at which characters are being added to current_macro. */
  87. static int current_macro_index;
  88.  
  89. /* A structure used to save nested macro strings.
  90.    It is a linked list of string/index for each saved macro. */
  91. struct saved_macro {
  92.   struct saved_macro *next;
  93.   char *string;
  94.   int sindex;
  95. };
  96.  
  97. /* The list of saved macros. */
  98. static struct saved_macro *macro_list = (struct saved_macro *)NULL;
  99.  
  100. /* Set up to read subsequent input from STRING.
  101.    STRING is free ()'ed when we are done with it. */
  102. void
  103. _rl_with_macro_input (string)
  104.      char *string;
  105. {
  106.   _rl_push_executing_macro ();
  107.   _rl_executing_macro = string;
  108.   executing_macro_index = 0;
  109. }
  110.  
  111. /* Return the next character available from a macro, or 0 if
  112.    there are no macro characters. */
  113. int
  114. _rl_next_macro_key ()
  115. {
  116.   if (_rl_executing_macro == 0)
  117.     return (0);
  118.  
  119.   if (_rl_executing_macro[executing_macro_index] == 0)
  120.     {
  121.       _rl_pop_executing_macro ();
  122.       return (_rl_next_macro_key ());
  123.     }
  124.  
  125.   return (_rl_executing_macro[executing_macro_index++]);
  126. }
  127.  
  128. /* Save the currently executing macro on a stack of saved macros. */
  129. void
  130. _rl_push_executing_macro ()
  131. {
  132.   struct saved_macro *saver;
  133.  
  134.   saver = (struct saved_macro *)xmalloc (sizeof (struct saved_macro));
  135.   saver->next = macro_list;
  136.   saver->sindex = executing_macro_index;
  137.   saver->string = _rl_executing_macro;
  138.  
  139.   macro_list = saver;
  140. }
  141.  
  142. /* Discard the current macro, replacing it with the one
  143.    on the top of the stack of saved macros. */
  144. void
  145. _rl_pop_executing_macro ()
  146. {
  147.   struct saved_macro *macro;
  148.  
  149.   if (_rl_executing_macro)
  150.     free (_rl_executing_macro);
  151.  
  152.   _rl_executing_macro = (char *)NULL;
  153.   executing_macro_index = 0;
  154.  
  155.   if (macro_list)
  156.     {
  157.       macro = macro_list;
  158.       _rl_executing_macro = macro_list->string;
  159.       executing_macro_index = macro_list->sindex;
  160.       macro_list = macro_list->next;
  161.       free (macro);
  162.     }
  163. }
  164.  
  165. /* Add a character to the macro being built. */
  166. void
  167. _rl_add_macro_char (c)
  168.      int c;
  169. {
  170.   if (current_macro_index + 1 >= current_macro_size)
  171.     {
  172.       if (current_macro == 0)
  173.     current_macro = xmalloc (current_macro_size = 25);
  174.       else
  175.     current_macro = xrealloc (current_macro, current_macro_size += 25);
  176.     }
  177.  
  178.   current_macro[current_macro_index++] = c;
  179.   current_macro[current_macro_index] = '\0';
  180. }
  181.  
  182. void
  183. _rl_kill_kbd_macro ()
  184. {
  185.   if (current_macro)
  186.     {
  187.       free (current_macro);
  188.       current_macro = (char *) NULL;
  189.     }
  190.   current_macro_size = current_macro_index = 0;
  191.  
  192.   if (_rl_executing_macro)
  193.     {
  194.       free (_rl_executing_macro);
  195.       _rl_executing_macro = (char *) NULL;
  196.     }
  197.   executing_macro_index = 0;
  198.  
  199.   _rl_defining_kbd_macro = 0;
  200. }
  201.  
  202. /* Begin defining a keyboard macro.
  203.    Keystrokes are recorded as they are executed.
  204.    End the definition with rl_end_kbd_macro ().
  205.    If a numeric argument was explicitly typed, then append this
  206.    definition to the end of the existing macro, and start by
  207.    re-executing the existing macro. */
  208. int
  209. rl_start_kbd_macro (ignore1, ignore2)
  210.      int ignore1, ignore2;
  211. {
  212.   if (_rl_defining_kbd_macro)
  213.     {
  214.       _rl_abort_internal ();
  215.       return -1;
  216.     }
  217.  
  218.   if (rl_explicit_arg)
  219.     {
  220.       if (current_macro)
  221.     _rl_with_macro_input (savestring (current_macro));
  222.     }
  223.   else
  224.     current_macro_index = 0;
  225.  
  226.   _rl_defining_kbd_macro = 1;
  227.   return 0;
  228. }
  229.  
  230. /* Stop defining a keyboard macro.
  231.    A numeric argument says to execute the macro right now,
  232.    that many times, counting the definition as the first time. */
  233. int
  234. rl_end_kbd_macro (count, ignore)
  235.      int count, ignore;
  236. {
  237.   if (_rl_defining_kbd_macro == 0)
  238.     {
  239.       _rl_abort_internal ();
  240.       return -1;
  241.     }
  242.  
  243.   current_macro_index -= rl_key_sequence_length - 1;
  244.   current_macro[current_macro_index] = '\0';
  245.  
  246.   _rl_defining_kbd_macro = 0;
  247.  
  248.   return (rl_call_last_kbd_macro (--count, 0));
  249. }
  250.  
  251. /* Execute the most recently defined keyboard macro.
  252.    COUNT says how many times to execute it. */
  253. int
  254. rl_call_last_kbd_macro (count, ignore)
  255.      int count, ignore;
  256. {
  257.   if (current_macro == 0)
  258.     _rl_abort_internal ();
  259.  
  260.   if (_rl_defining_kbd_macro)
  261.     {
  262.       ding ();        /* no recursive macros */
  263.       current_macro[--current_macro_index] = '\0';    /* erase this char */
  264.       return 0;
  265.     }
  266.  
  267.   while (count--)
  268.     _rl_with_macro_input (savestring (current_macro));
  269.   return 0;
  270. }
  271.  
  272. void
  273. rl_push_macro_input (macro)
  274.      char *macro;
  275. {
  276.   _rl_with_macro_input (macro);
  277. }
  278.