PageRenderTime 121ms CodeModel.GetById 19ms app.highlight 87ms RepoModel.GetById 1ms app.codeStats 0ms

/src/bin/gdb/readline/histexpand.c

http://github.com/Barrett17/Haiku-services-branch
C | 1491 lines | 1073 code | 195 blank | 223 comment | 326 complexity | 70d07c63277ae5f29f79b8d32fb96df0 MD5 | raw file
   1/* histexpand.c -- history expansion. */
   2
   3/* Copyright (C) 1989, 1992 Free Software Foundation, Inc.
   4
   5   This file contains the GNU History Library (the Library), a set of
   6   routines for managing the text of previously typed lines.
   7
   8   The Library 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, or (at your option)
  11   any later version.
  12
  13   The Library is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16   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   59 Temple Place, Suite 330, Boston, MA 02111 USA. */
  22
  23#define READLINE_LIBRARY
  24
  25#if defined (HAVE_CONFIG_H)
  26#  include <config.h>
  27#endif
  28
  29#include <stdio.h>
  30
  31#if defined (HAVE_STDLIB_H)
  32#  include <stdlib.h>
  33#else
  34#  include "ansi_stdlib.h"
  35#endif /* HAVE_STDLIB_H */
  36
  37#if defined (HAVE_UNISTD_H)
  38#  ifndef _MINIX
  39#    include <sys/types.h>
  40#  endif
  41#  include <unistd.h>
  42#endif
  43
  44#include "rlmbutil.h"
  45
  46#include "history.h"
  47#include "histlib.h"
  48
  49#include "rlshell.h"
  50#include "xmalloc.h"
  51
  52#define HISTORY_WORD_DELIMITERS		" \t\n;&()|<>"
  53#define HISTORY_QUOTE_CHARACTERS	"\"'`"
  54
  55typedef int _hist_search_func_t PARAMS((const char *, int));
  56
  57extern int rl_byte_oriented;	/* declared in mbutil.c */
  58
  59static char error_pointer;
  60
  61static char *subst_lhs;
  62static char *subst_rhs;
  63static int subst_lhs_len;
  64static int subst_rhs_len;
  65
  66static char *get_history_word_specifier PARAMS((char *, char *, int *));
  67static char *history_find_word PARAMS((char *, int));
  68
  69static char *quote_breaks PARAMS((char *));
  70
  71/* Variables exported by this file. */
  72/* The character that represents the start of a history expansion
  73   request.  This is usually `!'. */
  74char history_expansion_char = '!';
  75
  76/* The character that invokes word substitution if found at the start of
  77   a line.  This is usually `^'. */
  78char history_subst_char = '^';
  79
  80/* During tokenization, if this character is seen as the first character
  81   of a word, then it, and all subsequent characters upto a newline are
  82   ignored.  For a Bourne shell, this should be '#'.  Bash special cases
  83   the interactive comment character to not be a comment delimiter. */
  84char history_comment_char = '\0';
  85
  86/* The list of characters which inhibit the expansion of text if found
  87   immediately following history_expansion_char. */
  88char *history_no_expand_chars = " \t\n\r=";
  89
  90/* If set to a non-zero value, single quotes inhibit history expansion.
  91   The default is 0. */
  92int history_quotes_inhibit_expansion = 0;
  93
  94/* Used to split words by history_tokenize_internal. */
  95char *history_word_delimiters = HISTORY_WORD_DELIMITERS;
  96
  97/* If set, this points to a function that is called to verify that a
  98   particular history expansion should be performed. */
  99rl_linebuf_func_t *history_inhibit_expansion_function;
 100
 101/* **************************************************************** */
 102/*								    */
 103/*			History Expansion			    */
 104/*								    */
 105/* **************************************************************** */
 106
 107/* Hairy history expansion on text, not tokens.  This is of general
 108   use, and thus belongs in this library. */
 109
 110/* The last string searched for by a !?string? search. */
 111static char *search_string;
 112
 113/* The last string matched by a !?string? search. */
 114static char *search_match;
 115
 116/* Return the event specified at TEXT + OFFSET modifying OFFSET to
 117   point to after the event specifier.  Just a pointer to the history
 118   line is returned; NULL is returned in the event of a bad specifier.
 119   You pass STRING with *INDEX equal to the history_expansion_char that
 120   begins this specification.
 121   DELIMITING_QUOTE is a character that is allowed to end the string
 122   specification for what to search for in addition to the normal
 123   characters `:', ` ', `\t', `\n', and sometimes `?'.
 124   So you might call this function like:
 125   line = get_history_event ("!echo:p", &index, 0);  */
 126char *
 127get_history_event (string, caller_index, delimiting_quote)
 128     const char *string;
 129     int *caller_index;
 130     int delimiting_quote;
 131{
 132  register int i;
 133  register char c;
 134  HIST_ENTRY *entry;
 135  int which, sign, local_index, substring_okay;
 136  _hist_search_func_t *search_func;
 137  char *temp;
 138
 139  /* The event can be specified in a number of ways.
 140
 141     !!   the previous command
 142     !n   command line N
 143     !-n  current command-line minus N
 144     !str the most recent command starting with STR
 145     !?str[?]
 146	  the most recent command containing STR
 147
 148     All values N are determined via HISTORY_BASE. */
 149
 150  i = *caller_index;
 151
 152  if (string[i] != history_expansion_char)
 153    return ((char *)NULL);
 154
 155  /* Move on to the specification. */
 156  i++;
 157
 158  sign = 1;
 159  substring_okay = 0;
 160
 161#define RETURN_ENTRY(e, w) \
 162	return ((e = history_get (w)) ? e->line : (char *)NULL)
 163
 164  /* Handle !! case. */
 165  if (string[i] == history_expansion_char)
 166    {
 167      i++;
 168      which = history_base + (history_length - 1);
 169      *caller_index = i;
 170      RETURN_ENTRY (entry, which);
 171    }
 172
 173  /* Hack case of numeric line specification. */
 174  if (string[i] == '-')
 175    {
 176      sign = -1;
 177      i++;
 178    }
 179
 180  if (_rl_digit_p (string[i]))
 181    {
 182      /* Get the extent of the digits and compute the value. */
 183      for (which = 0; _rl_digit_p (string[i]); i++)
 184	which = (which * 10) + _rl_digit_value (string[i]);
 185
 186      *caller_index = i;
 187
 188      if (sign < 0)
 189	which = (history_length + history_base) - which;
 190
 191      RETURN_ENTRY (entry, which);
 192    }
 193
 194  /* This must be something to search for.  If the spec begins with
 195     a '?', then the string may be anywhere on the line.  Otherwise,
 196     the string must be found at the start of a line. */
 197  if (string[i] == '?')
 198    {
 199      substring_okay++;
 200      i++;
 201    }
 202
 203  /* Only a closing `?' or a newline delimit a substring search string. */
 204  for (local_index = i; c = string[i]; i++)
 205#if defined (HANDLE_MULTIBYTE)
 206    if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
 207      {
 208	int v;
 209	mbstate_t ps;
 210
 211	memset (&ps, 0, sizeof (mbstate_t));
 212	/* These produce warnings because we're passing a const string to a
 213	   function that takes a non-const string. */
 214	_rl_adjust_point (string, i, &ps);
 215	if ((v = _rl_get_char_len (string + i, &ps)) > 1)
 216	  {
 217	    i += v - 1;
 218	    continue;
 219	  }
 220      }
 221    else
 222#endif /* HANDLE_MULTIBYTE */
 223      if ((!substring_okay && (whitespace (c) || c == ':' ||
 224	  (history_search_delimiter_chars && member (c, history_search_delimiter_chars)) ||
 225	  string[i] == delimiting_quote)) ||
 226	  string[i] == '\n' ||
 227	  (substring_okay && string[i] == '?'))
 228	break;
 229
 230  which = i - local_index;
 231  temp = (char *)xmalloc (1 + which);
 232  if (which)
 233    strncpy (temp, string + local_index, which);
 234  temp[which] = '\0';
 235
 236  if (substring_okay && string[i] == '?')
 237    i++;
 238
 239  *caller_index = i;
 240
 241#define FAIL_SEARCH() \
 242  do { \
 243    history_offset = history_length; free (temp) ; return (char *)NULL; \
 244  } while (0)
 245
 246  /* If there is no search string, try to use the previous search string,
 247     if one exists.  If not, fail immediately. */
 248  if (*temp == '\0' && substring_okay)
 249    {
 250      if (search_string)
 251        {
 252          free (temp);
 253          temp = savestring (search_string);
 254        }
 255      else
 256        FAIL_SEARCH ();
 257    }
 258
 259  search_func = substring_okay ? history_search : history_search_prefix;
 260  while (1)
 261    {
 262      local_index = (*search_func) (temp, -1);
 263
 264      if (local_index < 0)
 265	FAIL_SEARCH ();
 266
 267      if (local_index == 0 || substring_okay)
 268	{
 269	  entry = current_history ();
 270	  history_offset = history_length;
 271	
 272	  /* If this was a substring search, then remember the
 273	     string that we matched for word substitution. */
 274	  if (substring_okay)
 275	    {
 276	      FREE (search_string);
 277	      search_string = temp;
 278
 279	      FREE (search_match);
 280	      search_match = history_find_word (entry->line, local_index);
 281	    }
 282	  else
 283	    free (temp);
 284
 285	  return (entry->line);
 286	}
 287
 288      if (history_offset)
 289	history_offset--;
 290      else
 291	FAIL_SEARCH ();
 292    }
 293#undef FAIL_SEARCH
 294#undef RETURN_ENTRY
 295}
 296
 297/* Function for extracting single-quoted strings.  Used for inhibiting
 298   history expansion within single quotes. */
 299
 300/* Extract the contents of STRING as if it is enclosed in single quotes.
 301   SINDEX, when passed in, is the offset of the character immediately
 302   following the opening single quote; on exit, SINDEX is left pointing
 303   to the closing single quote. */
 304static void
 305hist_string_extract_single_quoted (string, sindex)
 306     char *string;
 307     int *sindex;
 308{
 309  register int i;
 310
 311  for (i = *sindex; string[i] && string[i] != '\''; i++)
 312    ;
 313
 314  *sindex = i;
 315}
 316
 317static char *
 318quote_breaks (s)
 319     char *s;
 320{
 321  register char *p, *r;
 322  char *ret;
 323  int len = 3;
 324
 325  for (p = s; p && *p; p++, len++)
 326    {
 327      if (*p == '\'')
 328	len += 3;
 329      else if (whitespace (*p) || *p == '\n')
 330	len += 2;
 331    }
 332
 333  r = ret = (char *)xmalloc (len);
 334  *r++ = '\'';
 335  for (p = s; p && *p; )
 336    {
 337      if (*p == '\'')
 338	{
 339	  *r++ = '\'';
 340	  *r++ = '\\';
 341	  *r++ = '\'';
 342	  *r++ = '\'';
 343	  p++;
 344	}
 345      else if (whitespace (*p) || *p == '\n')
 346	{
 347	  *r++ = '\'';
 348	  *r++ = *p++;
 349	  *r++ = '\'';
 350	}
 351      else
 352	*r++ = *p++;
 353    }
 354  *r++ = '\'';
 355  *r = '\0';
 356  return ret;
 357}
 358
 359static char *
 360hist_error(s, start, current, errtype)
 361      char *s;
 362      int start, current, errtype;
 363{
 364  char *temp;
 365  const char *emsg;
 366  int ll, elen;
 367
 368  ll = current - start;
 369
 370  switch (errtype)
 371    {
 372    case EVENT_NOT_FOUND:
 373      emsg = "event not found";
 374      elen = 15;
 375      break;
 376    case BAD_WORD_SPEC:
 377      emsg = "bad word specifier";
 378      elen = 18;
 379      break;
 380    case SUBST_FAILED:
 381      emsg = "substitution failed";
 382      elen = 19;
 383      break;
 384    case BAD_MODIFIER:
 385      emsg = "unrecognized history modifier";
 386      elen = 29;
 387      break;
 388    case NO_PREV_SUBST:
 389      emsg = "no previous substitution";
 390      elen = 24;
 391      break;
 392    default:
 393      emsg = "unknown expansion error";
 394      elen = 23;
 395      break;
 396    }
 397
 398  temp = (char *)xmalloc (ll + elen + 3);
 399  strncpy (temp, s + start, ll);
 400  temp[ll] = ':';
 401  temp[ll + 1] = ' ';
 402  strcpy (temp + ll + 2, emsg);
 403  return (temp);
 404}
 405
 406/* Get a history substitution string from STR starting at *IPTR
 407   and return it.  The length is returned in LENPTR.
 408
 409   A backslash can quote the delimiter.  If the string is the
 410   empty string, the previous pattern is used.  If there is
 411   no previous pattern for the lhs, the last history search
 412   string is used.
 413
 414   If IS_RHS is 1, we ignore empty strings and set the pattern
 415   to "" anyway.  subst_lhs is not changed if the lhs is empty;
 416   subst_rhs is allowed to be set to the empty string. */
 417
 418static char *
 419get_subst_pattern (str, iptr, delimiter, is_rhs, lenptr)
 420     char *str;
 421     int *iptr, delimiter, is_rhs, *lenptr;
 422{
 423  register int si, i, j, k;
 424  char *s;
 425#if defined (HANDLE_MULTIBYTE)
 426  mbstate_t ps;
 427#endif
 428
 429  s = (char *)NULL;
 430  i = *iptr;
 431
 432#if defined (HANDLE_MULTIBYTE)
 433  memset (&ps, 0, sizeof (mbstate_t));
 434  _rl_adjust_point (str, i, &ps);
 435#endif
 436
 437  for (si = i; str[si] && str[si] != delimiter; si++)
 438#if defined (HANDLE_MULTIBYTE)
 439    if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
 440      {
 441	int v;
 442	if ((v = _rl_get_char_len (str + si, &ps)) > 1)
 443	  si += v - 1;
 444	else if (str[si] == '\\' && str[si + 1] == delimiter)
 445	  si++;
 446      }
 447    else
 448#endif /* HANDLE_MULTIBYTE */
 449      if (str[si] == '\\' && str[si + 1] == delimiter)
 450	si++;
 451
 452  if (si > i || is_rhs)
 453    {
 454      s = (char *)xmalloc (si - i + 1);
 455      for (j = 0, k = i; k < si; j++, k++)
 456	{
 457	  /* Remove a backslash quoting the search string delimiter. */
 458	  if (str[k] == '\\' && str[k + 1] == delimiter)
 459	    k++;
 460	  s[j] = str[k];
 461	}
 462      s[j] = '\0';
 463      if (lenptr)
 464	*lenptr = j;
 465    }
 466
 467  i = si;
 468  if (str[i])
 469    i++;
 470  *iptr = i;
 471
 472  return s;
 473}
 474
 475static void
 476postproc_subst_rhs ()
 477{
 478  char *new;
 479  int i, j, new_size;
 480
 481  new = (char *)xmalloc (new_size = subst_rhs_len + subst_lhs_len);
 482  for (i = j = 0; i < subst_rhs_len; i++)
 483    {
 484      if (subst_rhs[i] == '&')
 485	{
 486	  if (j + subst_lhs_len >= new_size)
 487	    new = (char *)xrealloc (new, (new_size = new_size * 2 + subst_lhs_len));
 488	  strcpy (new + j, subst_lhs);
 489	  j += subst_lhs_len;
 490	}
 491      else
 492	{
 493	  /* a single backslash protects the `&' from lhs interpolation */
 494	  if (subst_rhs[i] == '\\' && subst_rhs[i + 1] == '&')
 495	    i++;
 496	  if (j >= new_size)
 497	    new = (char *)xrealloc (new, new_size *= 2);
 498	  new[j++] = subst_rhs[i];
 499	}
 500    }
 501  new[j] = '\0';
 502  free (subst_rhs);
 503  subst_rhs = new;
 504  subst_rhs_len = j;
 505}
 506
 507/* Expand the bulk of a history specifier starting at STRING[START].
 508   Returns 0 if everything is OK, -1 if an error occurred, and 1
 509   if the `p' modifier was supplied and the caller should just print
 510   the returned string.  Returns the new index into string in
 511   *END_INDEX_PTR, and the expanded specifier in *RET_STRING. */
 512static int
 513history_expand_internal (string, start, end_index_ptr, ret_string, current_line)
 514     char *string;
 515     int start, *end_index_ptr;
 516     char **ret_string;
 517     char *current_line;	/* for !# */
 518{
 519  int i, n, starting_index;
 520  int substitute_globally, want_quotes, print_only;
 521  char *event, *temp, *result, *tstr, *t, c, *word_spec;
 522  int result_len;
 523#if defined (HANDLE_MULTIBYTE)
 524  mbstate_t ps;
 525
 526  memset (&ps, 0, sizeof (mbstate_t));
 527#endif
 528
 529  result = (char *)xmalloc (result_len = 128);
 530
 531  i = start;
 532
 533  /* If it is followed by something that starts a word specifier,
 534     then !! is implied as the event specifier. */
 535
 536  if (member (string[i + 1], ":$*%^"))
 537    {
 538      char fake_s[3];
 539      int fake_i = 0;
 540      i++;
 541      fake_s[0] = fake_s[1] = history_expansion_char;
 542      fake_s[2] = '\0';
 543      event = get_history_event (fake_s, &fake_i, 0);
 544    }
 545  else if (string[i + 1] == '#')
 546    {
 547      i += 2;
 548      event = current_line;
 549    }
 550  else
 551    {
 552      int quoted_search_delimiter = 0;
 553
 554      /* If the character before this `!' is a double or single
 555	 quote, then this expansion takes place inside of the
 556	 quoted string.  If we have to search for some text ("!foo"),
 557	 allow the delimiter to end the search string. */
 558#if defined (HANDLE_MULTIBYTE)
 559      if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
 560	{
 561	  int c, l;
 562	  l = _rl_find_prev_mbchar (string, i, MB_FIND_ANY);
 563	  c = string[l];
 564	  /* XXX - original patch had i - 1 ???  If i == 0 it would fail. */
 565	  if (i && (c == '\'' || c == '"'))
 566	    quoted_search_delimiter = c;
 567	}
 568      else
 569#endif /* HANDLE_MULTIBYTE */	  
 570	if (i && (string[i - 1] == '\'' || string[i - 1] == '"'))
 571	  quoted_search_delimiter = string[i - 1];
 572
 573      event = get_history_event (string, &i, quoted_search_delimiter);
 574    }
 575	  
 576  if (event == 0)
 577    {
 578      *ret_string = hist_error (string, start, i, EVENT_NOT_FOUND);
 579      free (result);
 580      return (-1);
 581    }
 582
 583  /* If a word specifier is found, then do what that requires. */
 584  starting_index = i;
 585  word_spec = get_history_word_specifier (string, event, &i);
 586
 587  /* There is no such thing as a `malformed word specifier'.  However,
 588     it is possible for a specifier that has no match.  In that case,
 589     we complain. */
 590  if (word_spec == (char *)&error_pointer)
 591    {
 592      *ret_string = hist_error (string, starting_index, i, BAD_WORD_SPEC);
 593      free (result);
 594      return (-1);
 595    }
 596
 597  /* If no word specifier, than the thing of interest was the event. */
 598  temp = word_spec ? savestring (word_spec) : savestring (event);
 599  FREE (word_spec);
 600
 601  /* Perhaps there are other modifiers involved.  Do what they say. */
 602  want_quotes = substitute_globally = print_only = 0;
 603  starting_index = i;
 604
 605  while (string[i] == ':')
 606    {
 607      c = string[i + 1];
 608
 609      if (c == 'g')
 610	{
 611	  substitute_globally = 1;
 612	  i++;
 613	  c = string[i + 1];
 614	}
 615
 616      switch (c)
 617	{
 618	default:
 619	  *ret_string = hist_error (string, i+1, i+2, BAD_MODIFIER);
 620	  free (result);
 621	  free (temp);
 622	  return -1;
 623
 624	case 'q':
 625	  want_quotes = 'q';
 626	  break;
 627
 628	case 'x':
 629	  want_quotes = 'x';
 630	  break;
 631
 632	  /* :p means make this the last executed line.  So we
 633	     return an error state after adding this line to the
 634	     history. */
 635	case 'p':
 636	  print_only++;
 637	  break;
 638
 639	  /* :t discards all but the last part of the pathname. */
 640	case 't':
 641	  tstr = strrchr (temp, '/');
 642	  if (tstr)
 643	    {
 644	      tstr++;
 645	      t = savestring (tstr);
 646	      free (temp);
 647	      temp = t;
 648	    }
 649	  break;
 650
 651	  /* :h discards the last part of a pathname. */
 652	case 'h':
 653	  tstr = strrchr (temp, '/');
 654	  if (tstr)
 655	    *tstr = '\0';
 656	  break;
 657
 658	  /* :r discards the suffix. */
 659	case 'r':
 660	  tstr = strrchr (temp, '.');
 661	  if (tstr)
 662	    *tstr = '\0';
 663	  break;
 664
 665	  /* :e discards everything but the suffix. */
 666	case 'e':
 667	  tstr = strrchr (temp, '.');
 668	  if (tstr)
 669	    {
 670	      t = savestring (tstr);
 671	      free (temp);
 672	      temp = t;
 673	    }
 674	  break;
 675
 676	/* :s/this/that substitutes `that' for the first
 677	   occurrence of `this'.  :gs/this/that substitutes `that'
 678	   for each occurrence of `this'.  :& repeats the last
 679	   substitution.  :g& repeats the last substitution
 680	   globally. */
 681
 682	case '&':
 683	case 's':
 684	  {
 685	    char *new_event;
 686	    int delimiter, failed, si, l_temp;
 687
 688	    if (c == 's')
 689	      {
 690		if (i + 2 < (int)strlen (string))
 691		  {
 692#if defined (HANDLE_MULTIBYTE)
 693		    if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
 694		      {
 695			_rl_adjust_point (string, i + 2, &ps);
 696			if (_rl_get_char_len (string + i + 2, &ps) > 1)
 697			  delimiter = 0;
 698			else
 699			  delimiter = string[i + 2];
 700		      }
 701		    else
 702#endif /* HANDLE_MULTIBYTE */
 703		      delimiter = string[i + 2];
 704		  }
 705		else
 706		  break;	/* no search delimiter */
 707
 708		i += 3;
 709
 710		t = get_subst_pattern (string, &i, delimiter, 0, &subst_lhs_len);
 711		/* An empty substitution lhs with no previous substitution
 712		   uses the last search string as the lhs. */
 713		if (t)
 714		  {
 715		    FREE (subst_lhs);
 716		    subst_lhs = t;
 717		  }
 718		else if (!subst_lhs)
 719		  {
 720		    if (search_string && *search_string)
 721		      {
 722			subst_lhs = savestring (search_string);
 723			subst_lhs_len = strlen (subst_lhs);
 724		      }
 725		    else
 726		      {
 727			subst_lhs = (char *) NULL;
 728			subst_lhs_len = 0;
 729		      }
 730		  }
 731
 732		FREE (subst_rhs);
 733		subst_rhs = get_subst_pattern (string, &i, delimiter, 1, &subst_rhs_len);
 734
 735		/* If `&' appears in the rhs, it's supposed to be replaced
 736		   with the lhs. */
 737		if (member ('&', subst_rhs))
 738		  postproc_subst_rhs ();
 739	      }
 740	    else
 741	      i += 2;
 742
 743	    /* If there is no lhs, the substitution can't succeed. */
 744	    if (subst_lhs_len == 0)
 745	      {
 746		*ret_string = hist_error (string, starting_index, i, NO_PREV_SUBST);
 747		free (result);
 748		free (temp);
 749		return -1;
 750	      }
 751
 752	    l_temp = strlen (temp);
 753	    /* Ignore impossible cases. */
 754	    if (subst_lhs_len > l_temp)
 755	      {
 756		*ret_string = hist_error (string, starting_index, i, SUBST_FAILED);
 757		free (result);
 758		free (temp);
 759		return (-1);
 760	      }
 761
 762	    /* Find the first occurrence of THIS in TEMP. */
 763	    si = 0;
 764	    for (failed = 1; (si + subst_lhs_len) <= l_temp; si++)
 765	      if (STREQN (temp+si, subst_lhs, subst_lhs_len))
 766		{
 767		  int len = subst_rhs_len - subst_lhs_len + l_temp;
 768		  new_event = (char *)xmalloc (1 + len);
 769		  strncpy (new_event, temp, si);
 770		  strncpy (new_event + si, subst_rhs, subst_rhs_len);
 771		  strncpy (new_event + si + subst_rhs_len,
 772			   temp + si + subst_lhs_len,
 773			   l_temp - (si + subst_lhs_len));
 774		  new_event[len] = '\0';
 775		  free (temp);
 776		  temp = new_event;
 777
 778		  failed = 0;
 779
 780		  if (substitute_globally)
 781		    {
 782		      si += subst_rhs_len;
 783		      l_temp = strlen (temp);
 784		      substitute_globally++;
 785		      continue;
 786		    }
 787		  else
 788		    break;
 789		}
 790
 791	    if (substitute_globally > 1)
 792	      {
 793		substitute_globally = 0;
 794		continue;	/* don't want to increment i */
 795	      }
 796
 797	    if (failed == 0)
 798	      continue;		/* don't want to increment i */
 799
 800	    *ret_string = hist_error (string, starting_index, i, SUBST_FAILED);
 801	    free (result);
 802	    free (temp);
 803	    return (-1);
 804	  }
 805	}
 806      i += 2;
 807    }
 808  /* Done with modfiers. */
 809  /* Believe it or not, we have to back the pointer up by one. */
 810  --i;
 811
 812  if (want_quotes)
 813    {
 814      char *x;
 815
 816      if (want_quotes == 'q')
 817	x = sh_single_quote (temp);
 818      else if (want_quotes == 'x')
 819	x = quote_breaks (temp);
 820      else
 821	x = savestring (temp);
 822
 823      free (temp);
 824      temp = x;
 825    }
 826
 827  n = strlen (temp);
 828  if (n >= result_len)
 829    result = (char *)xrealloc (result, n + 2);
 830  strcpy (result, temp);
 831  free (temp);
 832
 833  *end_index_ptr = i;
 834  *ret_string = result;
 835  return (print_only);
 836}
 837
 838/* Expand the string STRING, placing the result into OUTPUT, a pointer
 839   to a string.  Returns:
 840
 841  -1) If there was an error in expansion.
 842   0) If no expansions took place (or, if the only change in
 843      the text was the de-slashifying of the history expansion
 844      character)
 845   1) If expansions did take place
 846   2) If the `p' modifier was given and the caller should print the result
 847
 848  If an error ocurred in expansion, then OUTPUT contains a descriptive
 849  error message. */
 850
 851#define ADD_STRING(s) \
 852	do \
 853	  { \
 854	    int sl = strlen (s); \
 855	    j += sl; \
 856	    if (j >= result_len) \
 857	      { \
 858		while (j >= result_len) \
 859		  result_len += 128; \
 860		result = (char *)xrealloc (result, result_len); \
 861	      } \
 862	    strcpy (result + j - sl, s); \
 863	  } \
 864	while (0)
 865
 866#define ADD_CHAR(c) \
 867	do \
 868	  { \
 869	    if (j >= result_len - 1) \
 870	      result = (char *)xrealloc (result, result_len += 64); \
 871	    result[j++] = c; \
 872	    result[j] = '\0'; \
 873	  } \
 874	while (0)
 875
 876int
 877history_expand (hstring, output)
 878     char *hstring;
 879     char **output;
 880{
 881  register int j;
 882  int i, r, l, passc, cc, modified, eindex, only_printing;
 883  char *string;
 884
 885  /* The output string, and its length. */
 886  int result_len;
 887  char *result;
 888
 889#if defined (HANDLE_MULTIBYTE)
 890  char mb[MB_LEN_MAX];
 891  mbstate_t ps;
 892#endif
 893
 894  /* Used when adding the string. */
 895  char *temp;
 896
 897  if (output == 0)
 898    return 0;
 899
 900  /* Setting the history expansion character to 0 inhibits all
 901     history expansion. */
 902  if (history_expansion_char == 0)
 903    {
 904      *output = savestring (hstring);
 905      return (0);
 906    }
 907    
 908  /* Prepare the buffer for printing error messages. */
 909  result = (char *)xmalloc (result_len = 256);
 910  result[0] = '\0';
 911
 912  only_printing = modified = 0;
 913  l = strlen (hstring);
 914
 915  /* Grovel the string.  Only backslash and single quotes can quote the
 916     history escape character.  We also handle arg specifiers. */
 917
 918  /* Before we grovel forever, see if the history_expansion_char appears
 919     anywhere within the text. */
 920
 921  /* The quick substitution character is a history expansion all right.  That
 922     is to say, "^this^that^" is equivalent to "!!:s^this^that^", and in fact,
 923     that is the substitution that we do. */
 924  if (hstring[0] == history_subst_char)
 925    {
 926      string = (char *)xmalloc (l + 5);
 927
 928      string[0] = string[1] = history_expansion_char;
 929      string[2] = ':';
 930      string[3] = 's';
 931      strcpy (string + 4, hstring);
 932      l += 4;
 933    }
 934  else
 935    {
 936#if defined (HANDLE_MULTIBYTE)
 937      memset (&ps, 0, sizeof (mbstate_t));
 938#endif
 939
 940      string = hstring;
 941      /* If not quick substitution, still maybe have to do expansion. */
 942
 943      /* `!' followed by one of the characters in history_no_expand_chars
 944	 is NOT an expansion. */
 945      for (i = 0; string[i]; i++)
 946	{
 947#if defined (HANDLE_MULTIBYTE)
 948	  if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
 949	    {
 950	      int v;
 951	      v = _rl_get_char_len (string + i, &ps);
 952	      if (v > 1)
 953		{
 954		  i += v - 1;
 955		  continue;
 956		}
 957	    }
 958#endif /* HANDLE_MULTIBYTE */
 959
 960	  cc = string[i + 1];
 961	  /* The history_comment_char, if set, appearing at the beginning
 962	     of a word signifies that the rest of the line should not have
 963	     history expansion performed on it.
 964	     Skip the rest of the line and break out of the loop. */
 965	  if (history_comment_char && string[i] == history_comment_char &&
 966	      (i == 0 || member (string[i - 1], history_word_delimiters)))
 967	    {
 968	      while (string[i])
 969		i++;
 970	      break;
 971	    }
 972	  else if (string[i] == history_expansion_char)
 973	    {
 974	      if (!cc || member (cc, history_no_expand_chars))
 975		continue;
 976	      /* If the calling application has set
 977		 history_inhibit_expansion_function to a function that checks
 978		 for special cases that should not be history expanded,
 979		 call the function and skip the expansion if it returns a
 980		 non-zero value. */
 981	      else if (history_inhibit_expansion_function &&
 982			(*history_inhibit_expansion_function) (string, i))
 983		continue;
 984	      else
 985		break;
 986	    }
 987	  /* XXX - at some point, might want to extend this to handle
 988		   double quotes as well. */
 989	  else if (history_quotes_inhibit_expansion && string[i] == '\'')
 990	    {
 991	      /* If this is bash, single quotes inhibit history expansion. */
 992	      i++;
 993	      hist_string_extract_single_quoted (string, &i);
 994	    }
 995	  else if (history_quotes_inhibit_expansion && string[i] == '\\')
 996	    {
 997	      /* If this is bash, allow backslashes to quote single
 998		 quotes and the history expansion character. */
 999	      if (cc == '\'' || cc == history_expansion_char)
1000		i++;
1001	    }
1002	}
1003	  
1004      if (string[i] != history_expansion_char)
1005	{
1006	  free (result);
1007	  *output = savestring (string);
1008	  return (0);
1009	}
1010    }
1011
1012  /* Extract and perform the substitution. */
1013  for (passc = i = j = 0; i < l; i++)
1014    {
1015      int tchar = string[i];
1016
1017      if (passc)
1018	{
1019	  passc = 0;
1020	  ADD_CHAR (tchar);
1021	  continue;
1022	}
1023
1024#if defined (HANDLE_MULTIBYTE)
1025      if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1026	{
1027	  int k, c;
1028
1029	  c = tchar;
1030	  memset (mb, 0, sizeof (mb));
1031	  for (k = 0; k < MB_LEN_MAX; k++)
1032	    {
1033	      mb[k] = (char)c;
1034	      memset (&ps, 0, sizeof (mbstate_t));
1035	      if (_rl_get_char_len (mb, &ps) == -2)
1036		c = string[++i];
1037	      else
1038		break;
1039	    }
1040	  if (strlen (mb) > 1)
1041	    {
1042	      ADD_STRING (mb);
1043	      break;
1044	    }
1045	}
1046#endif /* HANDLE_MULTIBYTE */
1047
1048      if (tchar == history_expansion_char)
1049	tchar = -3;
1050      else if (tchar == history_comment_char)
1051	tchar = -2;
1052
1053      switch (tchar)
1054	{
1055	default:
1056	  ADD_CHAR (string[i]);
1057	  break;
1058
1059	case '\\':
1060	  passc++;
1061	  ADD_CHAR (tchar);
1062	  break;
1063
1064	case '\'':
1065	  {
1066	    /* If history_quotes_inhibit_expansion is set, single quotes
1067	       inhibit history expansion. */
1068	    if (history_quotes_inhibit_expansion)
1069	      {
1070		int quote, slen;
1071
1072		quote = i++;
1073		hist_string_extract_single_quoted (string, &i);
1074
1075		slen = i - quote + 2;
1076		temp = (char *)xmalloc (slen);
1077		strncpy (temp, string + quote, slen);
1078		temp[slen - 1] = '\0';
1079		ADD_STRING (temp);
1080		free (temp);
1081	      }
1082	    else
1083	      ADD_CHAR (string[i]);
1084	    break;
1085	  }
1086
1087	case -2:		/* history_comment_char */
1088	  if (i == 0 || member (string[i - 1], history_word_delimiters))
1089	    {
1090	      temp = (char *)xmalloc (l - i + 1);
1091	      strcpy (temp, string + i);
1092	      ADD_STRING (temp);
1093	      free (temp);
1094	      i = l;
1095	    }
1096	  else
1097	    ADD_CHAR (string[i]);
1098	  break;
1099
1100	case -3:		/* history_expansion_char */
1101	  cc = string[i + 1];
1102
1103	  /* If the history_expansion_char is followed by one of the
1104	     characters in history_no_expand_chars, then it is not a
1105	     candidate for expansion of any kind. */
1106	  if (member (cc, history_no_expand_chars))
1107	    {
1108	      ADD_CHAR (string[i]);
1109	      break;
1110	    }
1111
1112#if defined (NO_BANG_HASH_MODIFIERS)
1113	  /* There is something that is listed as a `word specifier' in csh
1114	     documentation which means `the expanded text to this point'.
1115	     That is not a word specifier, it is an event specifier.  If we
1116	     don't want to allow modifiers with `!#', just stick the current
1117	     output line in again. */
1118	  if (cc == '#')
1119	    {
1120	      if (result)
1121		{
1122		  temp = (char *)xmalloc (1 + strlen (result));
1123		  strcpy (temp, result);
1124		  ADD_STRING (temp);
1125		  free (temp);
1126		}
1127	      i++;
1128	      break;
1129	    }
1130#endif
1131
1132	  r = history_expand_internal (string, i, &eindex, &temp, result);
1133	  if (r < 0)
1134	    {
1135	      *output = temp;
1136	      free (result);
1137	      if (string != hstring)
1138		free (string);
1139	      return -1;
1140	    }
1141	  else
1142	    {
1143	      if (temp)
1144		{
1145		  modified++;
1146		  if (*temp)
1147		    ADD_STRING (temp);
1148		  free (temp);
1149		}
1150	      only_printing = r == 1;
1151	      i = eindex;
1152	    }
1153	  break;
1154	}
1155    }
1156
1157  *output = result;
1158  if (string != hstring)
1159    free (string);
1160
1161  if (only_printing)
1162    {
1163      add_history (result);
1164      return (2);
1165    }
1166
1167  return (modified != 0);
1168}
1169
1170/* Return a consed string which is the word specified in SPEC, and found
1171   in FROM.  NULL is returned if there is no spec.  The address of
1172   ERROR_POINTER is returned if the word specified cannot be found.
1173   CALLER_INDEX is the offset in SPEC to start looking; it is updated
1174   to point to just after the last character parsed. */
1175static char *
1176get_history_word_specifier (spec, from, caller_index)
1177     char *spec, *from;
1178     int *caller_index;
1179{
1180  register int i = *caller_index;
1181  int first, last;
1182  int expecting_word_spec = 0;
1183  char *result;
1184
1185  /* The range of words to return doesn't exist yet. */
1186  first = last = 0;
1187  result = (char *)NULL;
1188
1189  /* If we found a colon, then this *must* be a word specification.  If
1190     it isn't, then it is an error. */
1191  if (spec[i] == ':')
1192    {
1193      i++;
1194      expecting_word_spec++;
1195    }
1196
1197  /* Handle special cases first. */
1198
1199  /* `%' is the word last searched for. */
1200  if (spec[i] == '%')
1201    {
1202      *caller_index = i + 1;
1203      return (search_match ? savestring (search_match) : savestring (""));
1204    }
1205
1206  /* `*' matches all of the arguments, but not the command. */
1207  if (spec[i] == '*')
1208    {
1209      *caller_index = i + 1;
1210      result = history_arg_extract (1, '$', from);
1211      return (result ? result : savestring (""));
1212    }
1213
1214  /* `$' is last arg. */
1215  if (spec[i] == '$')
1216    {
1217      *caller_index = i + 1;
1218      return (history_arg_extract ('$', '$', from));
1219    }
1220
1221  /* Try to get FIRST and LAST figured out. */
1222
1223  if (spec[i] == '-')
1224    first = 0;
1225  else if (spec[i] == '^')
1226    first = 1;
1227  else if (_rl_digit_p (spec[i]) && expecting_word_spec)
1228    {
1229      for (first = 0; _rl_digit_p (spec[i]); i++)
1230	first = (first * 10) + _rl_digit_value (spec[i]);
1231    }
1232  else
1233    return ((char *)NULL);	/* no valid `first' for word specifier */
1234
1235  if (spec[i] == '^' || spec[i] == '*')
1236    {
1237      last = (spec[i] == '^') ? 1 : '$';	/* x* abbreviates x-$ */
1238      i++;
1239    }
1240  else if (spec[i] != '-')
1241    last = first;
1242  else
1243    {
1244      i++;
1245
1246      if (_rl_digit_p (spec[i]))
1247	{
1248	  for (last = 0; _rl_digit_p (spec[i]); i++)
1249	    last = (last * 10) + _rl_digit_value (spec[i]);
1250	}
1251      else if (spec[i] == '$')
1252	{
1253	  i++;
1254	  last = '$';
1255	}
1256#if 0
1257      else if (!spec[i] || spec[i] == ':')
1258	/* check against `:' because there could be a modifier separator */
1259#else
1260      else
1261	/* csh seems to allow anything to terminate the word spec here,
1262	   leaving it as an abbreviation. */
1263#endif
1264	last = -1;		/* x- abbreviates x-$ omitting word `$' */
1265    }
1266
1267  *caller_index = i;
1268
1269  if (last >= first || last == '$' || last < 0)
1270    result = history_arg_extract (first, last, from);
1271
1272  return (result ? result : (char *)&error_pointer);
1273}
1274
1275/* Extract the args specified, starting at FIRST, and ending at LAST.
1276   The args are taken from STRING.  If either FIRST or LAST is < 0,
1277   then make that arg count from the right (subtract from the number of
1278   tokens, so that FIRST = -1 means the next to last token on the line).
1279   If LAST is `$' the last arg from STRING is used. */
1280char *
1281history_arg_extract (first, last, string)
1282     int first, last;
1283     const char *string;
1284{
1285  register int i, len;
1286  char *result;
1287  int size, offset;
1288  char **list;
1289
1290  /* XXX - think about making history_tokenize return a struct array,
1291     each struct in array being a string and a length to avoid the
1292     calls to strlen below. */
1293  if ((list = history_tokenize (string)) == NULL)
1294    return ((char *)NULL);
1295
1296  for (len = 0; list[len]; len++)
1297    ;
1298
1299  if (last < 0)
1300    last = len + last - 1;
1301
1302  if (first < 0)
1303    first = len + first - 1;
1304
1305  if (last == '$')
1306    last = len - 1;
1307
1308  if (first == '$')
1309    first = len - 1;
1310
1311  last++;
1312
1313  if (first >= len || last > len || first < 0 || last < 0 || first > last)
1314    result = ((char *)NULL);
1315  else
1316    {
1317      for (size = 0, i = first; i < last; i++)
1318	size += strlen (list[i]) + 1;
1319      result = (char *)xmalloc (size + 1);
1320      result[0] = '\0';
1321
1322      for (i = first, offset = 0; i < last; i++)
1323	{
1324	  strcpy (result + offset, list[i]);
1325	  offset += strlen (list[i]);
1326	  if (i + 1 < last)
1327	    {
1328      	      result[offset++] = ' ';
1329	      result[offset] = 0;
1330	    }
1331	}
1332    }
1333
1334  for (i = 0; i < len; i++)
1335    free (list[i]);
1336  free (list);
1337
1338  return (result);
1339}
1340
1341#define slashify_in_quotes "\\`\"$"
1342
1343/* Parse STRING into tokens and return an array of strings.  If WIND is
1344   not -1 and INDP is not null, we also want the word surrounding index
1345   WIND.  The position in the returned array of strings is returned in
1346   *INDP. */
1347static char **
1348history_tokenize_internal (string, wind, indp)
1349     const char *string;
1350     int wind, *indp;
1351{
1352  char **result;
1353  register int i, start, result_index, size;
1354  int len, delimiter;
1355
1356  /* If we're searching for a string that's not part of a word (e.g., " "),
1357     make sure we set *INDP to a reasonable value. */
1358  if (indp && wind != -1)
1359    *indp = -1;
1360
1361  /* Get a token, and stuff it into RESULT.  The tokens are split
1362     exactly where the shell would split them. */
1363  for (i = result_index = size = 0, result = (char **)NULL; string[i]; )
1364    {
1365      delimiter = 0;
1366
1367      /* Skip leading whitespace. */
1368      for (; string[i] && whitespace (string[i]); i++)
1369	;
1370      if (string[i] == 0 || string[i] == history_comment_char)
1371	return (result);
1372
1373      start = i;
1374      
1375      if (member (string[i], "()\n"))
1376	{
1377	  i++;
1378	  goto got_token;
1379	}
1380
1381      if (member (string[i], "<>;&|$"))
1382	{
1383	  int peek = string[i + 1];
1384
1385	  if (peek == string[i] && peek != '$')
1386	    {
1387	      if (peek == '<' && string[i + 2] == '-')
1388		i++;
1389	      i += 2;
1390	      goto got_token;
1391	    }
1392	  else
1393	    {
1394	      if ((peek == '&' && (string[i] == '>' || string[i] == '<')) ||
1395		  ((peek == '>') && (string[i] == '&')) ||
1396		  ((peek == '(') && (string[i] == '$')))
1397		{
1398		  i += 2;
1399		  goto got_token;
1400		}
1401	    }
1402	  if (string[i] != '$')
1403	    {
1404	      i++;
1405	      goto got_token;
1406	    }
1407	}
1408
1409      /* Get word from string + i; */
1410
1411      if (member (string[i], HISTORY_QUOTE_CHARACTERS))
1412	delimiter = string[i++];
1413
1414      for (; string[i]; i++)
1415	{
1416	  if (string[i] == '\\' && string[i + 1] == '\n')
1417	    {
1418	      i++;
1419	      continue;
1420	    }
1421
1422	  if (string[i] == '\\' && delimiter != '\'' &&
1423	      (delimiter != '"' || member (string[i], slashify_in_quotes)))
1424	    {
1425	      i++;
1426	      continue;
1427	    }
1428
1429	  if (delimiter && string[i] == delimiter)
1430	    {
1431	      delimiter = 0;
1432	      continue;
1433	    }
1434
1435	  if (!delimiter && (member (string[i], history_word_delimiters)))
1436	    break;
1437
1438	  if (!delimiter && member (string[i], HISTORY_QUOTE_CHARACTERS))
1439	    delimiter = string[i];
1440	}
1441
1442    got_token:
1443
1444      /* If we are looking for the word in which the character at a
1445	 particular index falls, remember it. */
1446      if (indp && wind != -1 && wind >= start && wind < i)
1447        *indp = result_index;
1448
1449      len = i - start;
1450      if (result_index + 2 >= size)
1451	result = (char **)xrealloc (result, ((size += 10) * sizeof (char *)));
1452      result[result_index] = (char *)xmalloc (1 + len);
1453      strncpy (result[result_index], string + start, len);
1454      result[result_index][len] = '\0';
1455      result[++result_index] = (char *)NULL;
1456    }
1457
1458  return (result);
1459}
1460
1461/* Return an array of tokens, much as the shell might.  The tokens are
1462   parsed out of STRING. */
1463char **
1464history_tokenize (string)
1465     const char *string;
1466{
1467  return (history_tokenize_internal (string, -1, (int *)NULL));
1468}
1469
1470/* Find and return the word which contains the character at index IND
1471   in the history line LINE.  Used to save the word matched by the
1472   last history !?string? search. */
1473static char *
1474history_find_word (line, ind)
1475     char *line;
1476     int ind;
1477{
1478  char **words, *s;
1479  int i, wind;
1480
1481  words = history_tokenize_internal (line, ind, &wind);
1482  if (wind == -1 || words == 0)
1483    return ((char *)NULL);
1484  s = words[wind];
1485  for (i = 0; i < wind; i++)
1486    free (words[i]);
1487  for (i = wind + 1; words[i]; i++)
1488    free (words[i]);
1489  free (words);
1490  return s;
1491}