home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / octa21fs.zip / octave / readline / isearch.c < prev    next >
C/C++ Source or Header  |  2000-01-15  |  11KB  |  419 lines
  1. /* **************************************************************** */
  2. /*                                    */
  3. /*            I-Search and Searching                */
  4. /*                                    */
  5. /* **************************************************************** */
  6.  
  7. /* Copyright (C) 1987,1989 Free Software Foundation, Inc.
  8.  
  9.    This file contains the Readline Library (the Library), a set of
  10.    routines for providing Emacs style line input to programs that ask
  11.    for it.
  12.  
  13.    The Library is free software; you can redistribute it and/or modify
  14.    it under the terms of the GNU General Public License as published by
  15.    the Free Software Foundation; either version 1, or (at your option)
  16.    any later version.
  17.  
  18.    The Library is distributed in the hope that it will be useful, but
  19.    WITHOUT ANY WARRANTY; without even the implied warranty of
  20.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21.    General Public License for more details.
  22.  
  23.    The GNU General Public License is often shipped with GNU software, and
  24.    is generally kept in a file called COPYING or LICENSE.  If you do not
  25.    have a copy of the license, write to the Free Software Foundation,
  26.    675 Mass Ave, Cambridge, MA 02139, USA. */
  27. #define READLINE_LIBRARY
  28.  
  29. #if defined (HAVE_CONFIG_H)
  30. #  include <config.h>
  31. #endif
  32.  
  33. #include <sys/types.h>
  34.  
  35. #include <stdio.h>
  36.  
  37. #if defined (HAVE_UNISTD_H)
  38. #  include <unistd.h>
  39. #endif
  40.  
  41. #if defined (HAVE_STDLIB_H)
  42. #  include <stdlib.h>
  43. #else
  44. #  include "ansi_stdlib.h"
  45. #endif
  46.  
  47. #include "rldefs.h"
  48. #include "readline.h"
  49. #include "history.h"
  50.  
  51. /* Variables imported from other files in the readline library. */
  52. extern Keymap _rl_keymap;
  53. extern HIST_ENTRY *saved_line_for_history;
  54. extern int rl_line_buffer_len;
  55. extern int rl_point, rl_end;
  56. extern char *rl_line_buffer;
  57.  
  58. extern void _rl_save_prompt ();
  59. extern void _rl_restore_prompt ();
  60.  
  61. extern int rl_execute_next ();
  62. extern void rl_extend_line_buffer ();
  63.  
  64. extern int _rl_input_available ();
  65.  
  66. extern char *xmalloc (), *xrealloc ();
  67.  
  68. static int rl_search_history ();
  69.  
  70. /* Last line found by the current incremental search, so we don't `find'
  71.    identical lines many times in a row. */
  72. static char *prev_line_found;
  73.  
  74. /* Search backwards through the history looking for a string which is typed
  75.    interactively.  Start with the current line. */
  76. int
  77. rl_reverse_search_history (sign, key)
  78.      int sign, key;
  79. {
  80.   return (rl_search_history (-sign, key));
  81. }
  82.  
  83. /* Search forwards through the history looking for a string which is typed
  84.    interactively.  Start with the current line. */
  85. int
  86. rl_forward_search_history (sign, key)
  87.      int sign, key;
  88. {
  89.   return (rl_search_history (sign, key));
  90. }
  91.  
  92. /* Display the current state of the search in the echo-area.
  93.    SEARCH_STRING contains the string that is being searched for,
  94.    DIRECTION is zero for forward, or 1 for reverse,
  95.    WHERE is the history list number of the current line.  If it is
  96.    -1, then this line is the starting one. */
  97. static void
  98. rl_display_search (search_string, reverse_p, where)
  99.      char *search_string;
  100.      int reverse_p, where;
  101. {
  102.   char *message;
  103.   int msglen, searchlen;
  104.  
  105.   searchlen = (search_string && *search_string) ? strlen (search_string) : 0;
  106.  
  107.   message = xmalloc (searchlen + 33);
  108.   msglen = 0;
  109.  
  110. #if defined (NOTDEF)
  111.   if (where != -1)
  112.     {
  113.       sprintf (message, "[%d]", where + history_base);
  114.       msglen = strlen (message);
  115.     }
  116. #endif /* NOTDEF */
  117.  
  118.   message[msglen++] = '(';
  119.  
  120.   if (reverse_p)
  121.     {
  122.       strcpy (message + msglen, "reverse-");
  123.       msglen += 8;
  124.     }
  125.  
  126.   strcpy (message + msglen, "i-search)`");
  127.   msglen += 10;
  128.  
  129.   if (search_string)
  130.     {
  131.       strcpy (message + msglen, search_string);
  132.       msglen += searchlen;
  133.     }
  134.  
  135.   strcpy (message + msglen, "': ");
  136.  
  137.   rl_message ("%s", message, 0);
  138.   free (message);
  139.   (*rl_redisplay_function) ();
  140. }
  141.  
  142. /* Search through the history looking for an interactively typed string.
  143.    This is analogous to i-search.  We start the search in the current line.
  144.    DIRECTION is which direction to search; >= 0 means forward, < 0 means
  145.    backwards. */
  146. static int
  147. rl_search_history (direction, invoking_key)
  148.      int direction, invoking_key;
  149. {
  150.   /* The string that the user types in to search for. */
  151.   char *search_string;
  152.  
  153.   /* The current length of SEARCH_STRING. */
  154.   int search_string_index;
  155.  
  156.   /* The amount of space that SEARCH_STRING has allocated to it. */
  157.   int search_string_size;
  158.  
  159.   /* The list of lines to search through. */
  160.   char **lines, *allocated_line;
  161.  
  162.   /* The length of LINES. */
  163.   int hlen;
  164.  
  165.   /* Where we get LINES from. */
  166.   HIST_ENTRY **hlist;
  167.  
  168.   register int i;
  169.   int orig_point, orig_line, last_found_line;
  170.   int c, found, failed, sline_len;
  171.  
  172.   /* The line currently being searched. */
  173.   char *sline;
  174.  
  175.   /* Offset in that line. */
  176.   int line_index;
  177.  
  178.   /* Non-zero if we are doing a reverse search. */
  179.   int reverse;
  180.  
  181.   orig_point = rl_point;
  182.   last_found_line = orig_line = where_history ();
  183.   reverse = direction < 0;
  184.   hlist = history_list ();
  185.   allocated_line = (char *)NULL;
  186.  
  187.   /* Create an arrary of pointers to the lines that we want to search. */
  188.   maybe_replace_line ();
  189.   i = 0;
  190.   if (hlist)
  191.     for (i = 0; hlist[i]; i++);
  192.  
  193.   /* Allocate space for this many lines, +1 for the current input line,
  194.      and remember those lines. */
  195.   lines = (char **)xmalloc ((1 + (hlen = i)) * sizeof (char *));
  196.   for (i = 0; i < hlen; i++)
  197.     lines[i] = hlist[i]->line;
  198.  
  199.   if (saved_line_for_history)
  200.     lines[i] = saved_line_for_history->line;
  201.   else
  202.     {
  203.       /* Keep track of this so we can free it. */
  204.       allocated_line = xmalloc (1 + strlen (rl_line_buffer));
  205.       strcpy (allocated_line, &rl_line_buffer[0]);
  206.       lines[i] = allocated_line;
  207.     }
  208.  
  209.   hlen++;
  210.  
  211.   /* The line where we start the search. */
  212.   i = orig_line;
  213.  
  214.   _rl_save_prompt ();
  215.  
  216.   /* Initialize search parameters. */
  217.   search_string = xmalloc (search_string_size = 128);
  218.   *search_string = '\0';
  219.   search_string_index = 0;
  220.   prev_line_found = (char *)0;        /* XXX */
  221.  
  222.   /* Normalize DIRECTION into 1 or -1. */
  223.   direction = (direction >= 0) ? 1 : -1;
  224.  
  225.   rl_display_search (search_string, reverse, -1);
  226.  
  227.   sline = rl_line_buffer;
  228.   sline_len = strlen (sline);
  229.   line_index = rl_point;
  230.  
  231.   found = failed = 0;
  232.   for (;;)
  233.     {
  234.       Function *f = (Function *)NULL;
  235.  
  236.       /* Read a key and decide how to proceed. */
  237.       c = rl_read_key ();
  238.  
  239.       if (_rl_keymap[c].type == ISFUNC)
  240.     {
  241.       f = _rl_keymap[c].function;
  242.  
  243.       if (f == rl_reverse_search_history)
  244.         c = reverse ? -1 : -2;
  245.       else if (f == rl_forward_search_history)
  246.         c =  !reverse ? -1 : -2;
  247.     }
  248.  
  249.       /* Let NEWLINE (^J) terminate the search for people who don't like
  250.      using ESC.  ^M can still be used to terminate the search and
  251.      immediately execute the command. */
  252.       if (c == ESC || c == NEWLINE)
  253.     {
  254.       /* ESC still terminates the search, but if there is pending
  255.          input or if input arrives within 0.1 seconds (on systems
  256.          with select(2)) it is used as a prefix character
  257.          with rl_execute_next.  WATCH OUT FOR THIS!  This is intended
  258.          to allow the arrow keys to be used like ^F and ^B are used
  259.          to terminate the search and execute the movement command. */
  260.       if (c == ESC && _rl_input_available ())    /* XXX */
  261.         rl_execute_next (ESC);
  262.       break;
  263.     }
  264.  
  265.       if (c >= 0 && (CTRL_CHAR (c) || META_CHAR (c) || c == RUBOUT))
  266.     {
  267.       rl_execute_next (c);
  268.       break;
  269.     }
  270.  
  271.       switch (c)
  272.     {
  273.     case -1:
  274.       if (search_string_index == 0)
  275.         continue;
  276.       else if (reverse)
  277.         --line_index;
  278.       else if (line_index != sline_len)
  279.         ++line_index;
  280.       else
  281.         ding ();
  282.       break;
  283.  
  284.       /* switch directions */
  285.     case -2:
  286.       direction = -direction;
  287.       reverse = direction < 0;
  288.       break;
  289.  
  290.     case CTRL ('G'):
  291.       strcpy (rl_line_buffer, lines[orig_line]);
  292.       rl_point = orig_point;
  293.       rl_end = strlen (rl_line_buffer);
  294.       _rl_restore_prompt();
  295.       rl_clear_message ();
  296.       if (allocated_line)
  297.         free (allocated_line);
  298.       free (lines);
  299.       return 0;
  300.  
  301.     default:
  302.       /* Add character to search string and continue search. */
  303.       if (search_string_index + 2 >= search_string_size)
  304.         {
  305.           search_string_size += 128;
  306.           search_string = xrealloc (search_string, search_string_size);
  307.         }
  308.       search_string[search_string_index++] = c;
  309.       search_string[search_string_index] = '\0';
  310.       break;
  311.     }
  312.  
  313.       for (found = failed = 0;;)
  314.     {
  315.       int limit = sline_len - search_string_index + 1;
  316.  
  317.       /* Search the current line. */
  318.       while (reverse ? (line_index >= 0) : (line_index < limit))
  319.         {
  320.           if (STREQN (search_string, sline + line_index, search_string_index))
  321.         {
  322.           found++;
  323.           break;
  324.         }
  325.           else
  326.         line_index += direction;
  327.         }
  328.       if (found)
  329.         break;
  330.  
  331.       /* Move to the next line, but skip new copies of the line
  332.          we just found and lines shorter than the string we're
  333.          searching for. */
  334.       do
  335.         {
  336.           /* Move to the next line. */
  337.           i += direction;
  338.  
  339.           /* At limit for direction? */
  340.           if (reverse ? (i < 0) : (i == hlen))
  341.         {
  342.           failed++;
  343.           break;
  344.         }
  345.  
  346.           /* We will need these later. */
  347.           sline = lines[i];
  348.           sline_len = strlen (sline);
  349.         }
  350.       while ((prev_line_found && STREQ (prev_line_found, lines[i])) ||
  351.          (search_string_index > sline_len));
  352.  
  353.       if (failed)
  354.         break;
  355.  
  356.       /* Now set up the line for searching... */
  357.       line_index = reverse ? sline_len - search_string_index : 0;
  358.     }
  359.  
  360.       if (failed)
  361.     {
  362.       /* We cannot find the search string.  Ding the bell. */
  363.       ding ();
  364.       i = last_found_line;
  365.       continue;         /* XXX - was break */
  366.     }
  367.  
  368.       /* We have found the search string.  Just display it.  But don't
  369.      actually move there in the history list until the user accepts
  370.      the location. */
  371.       if (found)
  372.     {
  373.       int line_len;
  374.  
  375.       prev_line_found = lines[i];
  376.       line_len = strlen (lines[i]);
  377.  
  378.       if (line_len >= rl_line_buffer_len)
  379.         rl_extend_line_buffer (line_len);
  380.  
  381.       strcpy (rl_line_buffer, lines[i]);
  382.       rl_point = line_index;
  383.       rl_end = line_len;
  384.       last_found_line = i;
  385.       rl_display_search (search_string, reverse, (i == orig_line) ? -1 : i);
  386.     }
  387.     }
  388.  
  389.   /* The searching is over.  The user may have found the string that she
  390.      was looking for, or else she may have exited a failing search.  If
  391.      LINE_INDEX is -1, then that shows that the string searched for was
  392.      not found.  We use this to determine where to place rl_point. */
  393.  
  394.   /* First put back the original state. */
  395.   strcpy (rl_line_buffer, lines[orig_line]);
  396.  
  397.   _rl_restore_prompt ();
  398.  
  399.   /* Free the search string. */
  400.   free (search_string);
  401.  
  402.   if (last_found_line < orig_line)
  403.     rl_get_previous_history (orig_line - last_found_line);
  404.   else
  405.     rl_get_next_history (last_found_line - orig_line);
  406.  
  407.   /* If the string was not found, put point at the end of the line. */
  408.   if (line_index < 0)
  409.     line_index = strlen (rl_line_buffer);
  410.   rl_point = line_index;
  411.   rl_clear_message ();
  412.  
  413.   if (allocated_line)
  414.     free (allocated_line);
  415.   free (lines);
  416.  
  417.   return 0;
  418. }
  419.