1 //hist.c - history expansion

     2 //

     3 // © Portions Copyright (c) Symbian Software Ltd 2007. All rights reserved.

     4 //

     5 /*

     6  * This file is part of zsh, the Z shell.

     7  *

     8  * Copyright (c) 1992-1997 Paul Falstad

     9  * All rights reserved.

    10  *

    11  * Permission is hereby granted, without written agreement and without

    12  * license or royalty fees, to use, copy, modify, and distribute this

    13  * software and to distribute modified versions of this software for any

    14  * purpose, provided that the above copyright notice and the following

    15  * two paragraphs appear in all copies of this software.

    16  *

    17  * In no event shall Paul Falstad or the Zsh Development Group be liable

    18  * to any party for direct, indirect, special, incidental, or consequential

    19  * damages arising out of the use of this software and its documentation,

    20  * even if Paul Falstad and the Zsh Development Group have been advised of

    21  * the possibility of such damage.

    22  *

    23  * Paul Falstad and the Zsh Development Group specifically disclaim any

    24  * warranties, including, but not limited to, the implied warranties of

    25  * merchantability and fitness for a particular purpose.  The software

    26  * provided hereunder is on an "as is" basis, and Paul Falstad and the

    27  * Zsh Development Group have no obligation to provide maintenance,

    28  * support, updates, enhancements, or modifications.

    29  *

    30  */

    31 

    32 #include "zsh.mdh"

    33 #include "hist.pro"

    34 

    35 #ifdef __SYMBIAN32__

    36 #ifdef __WINSCW__

    37 #pragma warn_unusedarg off

    38 #pragma warn_possunwant off

    39 #endif//__WINSCW__

    40 #endif//__SYMBIAN32__

    41 

    42 

    43 /* Functions to call for getting/ungetting a character and for history

    44  * word control. */

    45 

    46 /**/

    47 mod_export int (*hgetc) _((void));

    48 

    49 /**/

    50 void (*hungetc) _((int));

    51 

    52 /**/

    53 void (*hwaddc) _((int));

    54 

    55 /**/

    56 void (*hwbegin) _((int));

    57 

    58 /**/

    59 void (*hwend) _((void));

    60 

    61 /**/

    62 void (*addtoline) _((int));

    63 

    64 /* != 0 means history substitution is turned off */

    65  

    66 /**/

    67 mod_export int stophist;

    68 

    69 /* if != 0, we are expanding the current line */

    70 

    71 /**/

    72 mod_export int expanding;

    73 

    74 /* these are used to modify the cursor position during expansion */

    75 

    76 /**/

    77 mod_export int excs, exlast;

    78 

    79 /*

    80  * Current history event number

    81  *

    82  * Note on curhist: with history inactive, this points to the

    83  * last line actually added to the history list.  With history active,

    84  * the line does not get added to the list until hend(), if at all.

    85  * However, curhist is incremented to reflect the current line anyway

    86  * and a temporary history entry is inserted while the user is editing.

    87  * If the resulting line was not added to the list, a flag is set so

    88  * that curhist will be decremented in hbegin().

    89  */

    90  

    91 /**/

    92 mod_export zlong curhist;

    93 

    94 /**/

    95 struct histent curline;

    96 

    97 /* current line count of allocated history entries */

    98 

    99 /**/

   100 zlong histlinect;

   101 

   102 /* The history lines are kept in a hash, and also doubly-linked in a ring */

   103 

   104 /**/

   105 HashTable histtab;

   106 /**/

   107 mod_export Histent hist_ring;

   108  

   109 /* capacity of history lists */

   110  

   111 /**/

   112 zlong histsiz;

   113  

   114 /* desired history-file size (in lines) */

   115  

   116 /**/

   117 zlong savehistsiz;

   118  

   119 /* if = 1, we have performed history substitution on the current line *

   120  * if = 2, we have used the 'p' modifier                              */

   121  

   122 /**/

   123 int histdone;

   124  

   125 /* state of the history mechanism */

   126  

   127 /**/

   128 int histactive;

   129 

   130 /* Current setting of the associated option, but sometimes also includes

   131  * the setting of the HIST_SAVE_NO_DUPS option. */

   132 

   133 /**/

   134 int hist_ignore_all_dups;

   135 

   136 /* What flags (if any) we should skip when moving through the history */

   137 

   138 /**/

   139 mod_export int hist_skip_flags;

   140 

   141 /* Bits of histactive variable */

   142 #define HA_ACTIVE	(1<<0)	/* History mechanism is active */

   143 #define HA_NOSTORE	(1<<1)	/* Don't store the line when finished */

   144 #define HA_NOINC	(1<<2)	/* Don't store, curhist not incremented */

   145 

   146 /* Array of word beginnings and endings in current history line. */

   147 

   148 /**/

   149 short *chwords;

   150 

   151 /* Max, actual position in chwords.

   152  * nwords = chwordpos/2 because we record beginning and end of words.

   153  */

   154 

   155 /**/

   156 int chwordlen, chwordpos;

   157 

   158 /* the last l for s/l/r/ history substitution */

   159  

   160 /**/

   161 char *hsubl;

   162 

   163 /* the last r for s/l/r/ history substitution */

   164  

   165 /**/

   166 char *hsubr;

   167  

   168 /* pointer into the history line */

   169  

   170 /**/

   171 mod_export char *hptr;

   172  

   173 /* the current history line */

   174  

   175 /**/

   176 mod_export char *chline;

   177 

   178 /* true if the last character returned by hgetc was an escaped bangchar *

   179  * if it is set and NOBANGHIST is unset hwaddc escapes bangchars        */

   180 

   181 /**/

   182 int qbang;

   183  

   184 /* max size of histline */

   185  

   186 /**/

   187 int hlinesz;

   188  

   189 /* default event (usually curhist-1, that is, "!!") */

   190  

   191 static zlong defev;

   192 

   193 /* add a character to the current history word */

   194 

   195 static void

   196 ihwaddc(int c)

   197 {

   198     /* Only if history line exists and lexing has not finished. */

   199     if (chline && !(errflag || lexstop)) {

   200 	/* Quote un-expanded bangs in the history line. */

   201 	if (c == bangchar && stophist < 2 && qbang)

   202 	    /* If qbang is not set, we do not escape this bangchar as it's *

   203 	     * not mecessary (e.g. it's a bang in !=, or it is followed    *

   204 	     * by a space). Roughly speaking, qbang is zero only if the    *

   205 	     * history interpreter has already digested this bang and      *

   206 	     * found that it is not necessary to escape it.                */

   207 	    hwaddc('\\');

   208 	*hptr++ = c;

   209 

   210 	/* Resize history line if necessary */

   211 	if (hptr - chline >= hlinesz) {

   212 	    int oldsiz = hlinesz;

   213 

   214 	    chline = realloc(chline, hlinesz = oldsiz + 64);

   215 	    hptr = chline + oldsiz;

   216 	}

   217     }

   218 }

   219 

   220 /* This function adds a character to the zle input line. It is used when *

   221  * zsh expands history (see doexpandhist() in zle_tricky.c). It also     *

   222  * calculates the new cursor position after the expansion. It is called  *

   223  * from hgetc() and from gettok() in lex.c for characters in comments.   */

   224 

   225 /**/

   226 void

   227 iaddtoline(int c)

   228 {

   229     if (!expanding || lexstop)

   230 	return;

   231     if (qbang && c == bangchar && stophist < 2) {

   232 	exlast--;

   233 	spaceinline(1);

   234 	line[cs++] = '\\';

   235     }

   236     if (excs > cs) {

   237 	excs += 1 + inbufct - exlast;

   238 	if (excs < cs)

   239 	    /* this case could be handled better but it is    *

   240 	     * so rare that it does not worth it              */

   241 	    excs = cs;

   242     }

   243     exlast = inbufct;

   244     spaceinline(1);

   245     line[cs++] = itok(c) ? ztokens[c - Pound] : c;

   246 }

   247 

   248 static int

   249 ihgetc(void)

   250 {

   251     int c = ingetc();

   252 

   253     qbang = 0;

   254     if (!stophist && !(inbufflags & INP_ALIAS)) {

   255 	/* If necessary, expand history characters. */

   256 	c = histsubchar(c);

   257 	if (c < 0) {

   258 	    /* bad expansion */

   259 	    errflag = lexstop = 1;

   260 	    return ' ';

   261 	}

   262     }

   263     if ((inbufflags & INP_HIST) && !stophist) {

   264 	/* the current character c came from a history expansion          *

   265 	 * (inbufflags & INP_HIST) and history is not disabled            *

   266 	 * (e.g. we are not inside single quotes). In that case, \!       *

   267 	 * should be treated as ! (since this \! came from a previous     *

   268 	 * history line where \ was used to escape the bang). So if       *

   269 	 * c == '\\' we fetch one more character to see if it's a bang,   *

   270 	 * and if it is not, we unget it and reset c back to '\\'         */

   271 	qbang = 0;

   272 	if (c == '\\' && !(qbang = (c = ingetc()) == bangchar))

   273 	    safeinungetc(c), c = '\\';

   274     } else if (stophist || (inbufflags & INP_ALIAS))

   275 	/* If the result is a bangchar which came from history or alias  *

   276 	 * expansion, we treat it as an escaped bangchar, unless history *

   277 	 * is disabled. If stophist == 1 it only means that history is   *

   278 	 * temporarily disabled by a !" which won't appear in in the     *

   279 	 * history, so we still have an escaped bang. stophist > 1 if    *

   280 	 * history is disabled with NOBANGHIST or by someone else (e.g.  *

   281 	 * when the lexer scans single quoted text).                     */

   282 	qbang = c == bangchar && (stophist < 2);

   283     hwaddc(c);

   284     addtoline(c);

   285 

   286     return c;

   287 }

   288 

   289 /**/

   290 static void

   291 safeinungetc(int c)

   292 {

   293     if (lexstop)

   294 	lexstop = 0;

   295     else

   296 	inungetc(c);

   297 }

   298 

   299 /**/

   300 void

   301 herrflush(void)

   302 {

   303     inpopalias();

   304 

   305     while (!lexstop && inbufct && !strin)

   306 	hwaddc(ingetc());

   307 }

   308 

   309 /* extract :s/foo/bar/ delimiters and arguments */

   310 

   311 /**/

   312 static int

   313 getsubsargs(char *subline)

   314 {

   315     int del;

   316     char *ptr1, *ptr2;

   317 

   318     del = ingetc();

   319     ptr1 = hdynread2(del);

   320     if (!ptr1)

   321 	return 1;

   322     ptr2 = hdynread2(del);

   323     if (strlen(ptr1)) {

   324 	zsfree(hsubl);

   325 	hsubl = ptr1;

   326     }

   327     zsfree(hsubr);

   328     hsubr = ptr2;

   329     if (hsubl && !strstr(subline, hsubl)) {

   330 	herrflush();

   331 	zerr("substitution failed", NULL, 0);

   332 	return 1;

   333     }

   334     return 0;

   335 }

   336 

   337 /* Get the maximum no. of words for a history entry. */

   338 

   339 /**/

   340 static int

   341 getargc(Histent ehist)

   342 {

   343     return ehist->nwords ? ehist->nwords-1 : 0;

   344 }

   345 

   346 /* Perform history substitution, returning the next character afterwards. */

   347 

   348 /**/

   349 static int

   350 histsubchar(int c)

   351 {

   352     int farg, evset = -1, larg, argc, cflag = 0, bflag = 0;

   353     zlong ev;

   354     static int marg = -1;

   355     static zlong mev = -1;

   356     char buf[256], *ptr;

   357     char *sline;

   358     Histent ehist;

   359 

   360     /* look, no goto's */

   361     if (isfirstch && c == hatchar) {

   362 	/* Line begins ^foo^bar */

   363 	isfirstch = 0;

   364 	inungetc(hatchar);

   365 	if (!(ehist = gethist(defev))

   366 	    || !(sline = getargs(ehist, 0, getargc(ehist)))

   367 	    || getsubsargs(sline) || !hsubl)

   368 	    return -1;

   369 	subst(&sline, hsubl, hsubr, 0);

   370     } else {

   371 	/* Line doesn't begin ^foo^bar */

   372 	if (c != ' ')

   373 	    isfirstch = 0;

   374 #ifndef __SYMBIAN32__	

   375 	if (c == '\\') {

   376 	    int g = ingetc();

   377 

   378 	    if (g != bangchar)

   379 		safeinungetc(g);

   380 	    else {

   381 		qbang = 1;

   382 		return bangchar;

   383 	    }

   384 	}

   385 #endif //__SYMBIAN32__	

   386 	if (c != bangchar)

   387 	    return c;

   388 	*hptr = '\0';

   389 	if ((c = ingetc()) == '{') {

   390 	    bflag = cflag = 1;

   391 	    c = ingetc();

   392 	}

   393 	if (c == '\"') {

   394 	    stophist = 1;

   395 	    return ingetc();

   396 	}

   397 	if ((!cflag && inblank(c)) || c == '=' || c == '(' || lexstop) {

   398 	    safeinungetc(c);

   399 	    return bangchar;

   400 	}

   401 	cflag = 0;

   402 	ptr = buf;

   403 

   404 	/* get event number */

   405 

   406 	queue_signals();

   407 	if (c == '?') {

   408 	    for (;;) {

   409 		c = ingetc();

   410 		if (c == '?' || c == '\n' || lexstop)

   411 		    break;

   412 		else

   413 		    *ptr++ = c;

   414 	    }

   415 	    if (c != '\n' && !lexstop)

   416 		c = ingetc();

   417 	    *ptr = '\0';

   418 	    mev = ev = hconsearch(hsubl = ztrdup(buf), &marg);

   419 	    evset = 0;

   420 	    if (ev == -1) {

   421 		herrflush();

   422 		unqueue_signals();

   423 		zerr("no such event: %s", buf, 0);

   424 		return -1;

   425 	    }

   426 	} else {

   427 	    zlong t0;

   428 

   429 	    for (;;) {

   430 		if (inblank(c) || c == ';' || c == ':' || c == '^' ||

   431 		    c == '$' || c == '*' || c == '%' || c == '}' ||

   432 		    c == '\'' || c == '"' || c == '`' || lexstop)

   433 		    break;

   434 		if (ptr != buf) {

   435 		    if (c == '-')

   436 			break;

   437 		    if ((idigit(buf[0]) || buf[0] == '-') && !idigit(c))

   438 			break;

   439 		}

   440 		*ptr++ = c;

   441 		if (c == '#' || c == bangchar) {

   442 		    c = ingetc();

   443 		    break;

   444 		}

   445 		c = ingetc();

   446 	    }

   447 	    *ptr = 0;

   448 	    if (!*buf) {

   449 		if (c != '%') {

   450 		    if (isset(CSHJUNKIEHISTORY))

   451 			ev = addhistnum(curhist,-1,HIST_FOREIGN);

   452 		    else

   453 			ev = defev;

   454 		    if (c == ':' && evset == -1)

   455 			evset = 0;

   456 		    else

   457 			evset = 1;

   458 		} else {

   459 		    if (marg != -1)

   460 			ev = mev;

   461 		    else

   462 			ev = defev;

   463 		    evset = 0;

   464 		}

   465 	    } else if ((t0 = zstrtol(buf, NULL, 10))) {

   466 		ev = (t0 < 0) ? addhistnum(curhist,t0,HIST_FOREIGN) : t0;

   467 		evset = 1;

   468 	    } else if ((unsigned)*buf == bangchar) {

   469 		ev = addhistnum(curhist,-1,HIST_FOREIGN);

   470 		evset = 1;

   471 	    } else if (*buf == '#') {

   472 		ev = curhist;

   473 		evset = 1;

   474 	    } else if ((ev = hcomsearch(buf)) == -1) {

   475 		herrflush();

   476 		unqueue_signals();

   477 		zerr("event not found: %s", buf, 0);

   478 		return -1;

   479 	    } else

   480 		evset = 1;

   481 	}

   482 

   483 	/* get the event */

   484 

   485 	if (!(ehist = gethist(defev = ev))) {

   486 	    unqueue_signals();

   487 	    return -1;

   488 	}

   489 	/* extract the relevant arguments */

   490 

   491 	argc = getargc(ehist);

   492 	if (c == ':') {

   493 	    cflag = 1;

   494 	    c = ingetc();

   495 	    if (c == '%' && marg != -1) {

   496 		if (!evset) {

   497 		    ehist = gethist(defev = mev);

   498 		    argc = getargc(ehist);

   499 		} else {

   500 		    herrflush();

   501 		    unqueue_signals();

   502 		    zerr("Ambiguous history reference", NULL, 0);

   503 		    return -1;

   504 		}

   505 

   506 	    }

   507 	}

   508 	if (c == '*') {

   509 	    farg = 1;

   510 	    larg = argc;

   511 	    cflag = 0;

   512 	} else {

   513 	    inungetc(c);

   514 	    larg = farg = getargspec(argc, marg, evset);

   515 	    if (larg == -2) {

   516 		unqueue_signals();

   517 		return -1;

   518 	    }

   519 	    if (farg != -1)

   520 		cflag = 0;

   521 	    c = ingetc();

   522 	    if (c == '*') {

   523 		cflag = 0;

   524 		larg = argc;

   525 	    } else if (c == '-') {

   526 		cflag = 0;

   527 		larg = getargspec(argc, marg, evset);

   528 		if (larg == -2) {

   529 		    unqueue_signals();

   530 		    return -1;

   531 		}

   532 		if (larg == -1)

   533 		    larg = argc - 1;

   534 	    } else

   535 		inungetc(c);

   536 	}

   537 	if (farg == -1)

   538 	    farg = 0;

   539 	if (larg == -1)

   540 	    larg = argc;

   541 	if (!(sline = getargs(ehist, farg, larg))) {

   542 	    unqueue_signals();

   543 	    return -1;

   544 	}

   545 	unqueue_signals();

   546     }

   547 

   548     /* do the modifiers */

   549 

   550     for (;;) {

   551 	c = (cflag) ? ':' : ingetc();

   552 	cflag = 0;

   553 	if (c == ':') {

   554 	    int gbal = 0;

   555 

   556 	    if ((c = ingetc()) == 'g') {

   557 		gbal = 1;

   558 		c = ingetc();

   559 	    }

   560 	    switch (c) {

   561 	    case 'p':

   562 		histdone = HISTFLAG_DONE | HISTFLAG_NOEXEC;

   563 		break;

   564 	    case 'h':

   565 		if (!remtpath(&sline)) {

   566 		    herrflush();

   567 		    zerr("modifier failed: h", NULL, 0);

   568 		    return -1;

   569 		}

   570 		break;

   571 	    case 'e':

   572 		if (!rembutext(&sline)) {

   573 		    herrflush();

   574 		    zerr("modifier failed: e", NULL, 0);

   575 		    return -1;

   576 		}

   577 		break;

   578 	    case 'r':

   579 		if (!remtext(&sline)) {

   580 		    herrflush();

   581 		    zerr("modifier failed: r", NULL, 0);

   582 		    return -1;

   583 		}

   584 		break;

   585 	    case 't':

   586 		if (!remlpaths(&sline)) {

   587 		    herrflush();

   588 		    zerr("modifier failed: t", NULL, 0);

   589 		    return -1;

   590 		}

   591 		break;

   592 	    case 's':

   593 		if (getsubsargs(sline))

   594 		    return -1; /* fall through */

   595 	    case '&':

   596 		if (hsubl && hsubr)

   597 		    subst(&sline, hsubl, hsubr, gbal);

   598 		else {

   599 		    herrflush();

   600 		    zerr("no previous substitution", NULL, 0);

   601 		    return -1;

   602 		}

   603 		break;

   604 	    case 'q':

   605 		quote(&sline);

   606 		break;

   607 	    case 'Q':

   608 		{

   609 		    int one = noerrs, oef = errflag;

   610 

   611 		    noerrs = 1;

   612 		    parse_subst_string(sline);

   613 		    noerrs = one;

   614 		    errflag = oef;

   615 		    remnulargs(sline);

   616 		    untokenize(sline);

   617 		}

   618 		break;

   619 	    case 'x':

   620 		quotebreak(&sline);

   621 		break;

   622 	    case 'l':

   623 		downcase(&sline);

   624 		break;

   625 	    case 'u':

   626 		upcase(&sline);

   627 		break;

   628 	    default:

   629 		herrflush();

   630 		zerr("illegal modifier: %c", NULL, c);

   631 		return -1;

   632 	    }

   633 	} else {

   634 	    if (c != '}' || !bflag)

   635 		inungetc(c);

   636 	    if (c != '}' && bflag) {

   637 		zerr("'}' expected", NULL, 0);

   638 		return -1;

   639 	    }

   640 	    break;

   641 	}

   642     }

   643 

   644     /*

   645      * Push the expanded value onto the input stack,

   646      * marking this as a history word for purposes of the alias stack.

   647      */

   648 

   649     lexstop = 0;

   650     /* this function is called only called from hgetc and only if      *

   651      * !(inbufflags & INP_ALIAS). History expansion should never be    *

   652      * done with INP_ALIAS (to prevent recursive history expansion and *

   653      * histoty expansion of aliases). Escapes are not removed here.    *

   654      * This is now handled in hgetc.                                   */

   655     inpush(sline, INP_HIST, NULL); /* sline from heap, don't free */

   656     histdone |= HISTFLAG_DONE;

   657     if (isset(HISTVERIFY))

   658 	histdone |= HISTFLAG_NOEXEC | HISTFLAG_RECALL;

   659 

   660     /* Don't try and re-expand line. */

   661     return ingetc();

   662 }

   663 

   664 /* unget a char and remove it from chline. It can only be used *

   665  * to unget a character returned by hgetc.                     */

   666 

   667 static void

   668 ihungetc(int c)

   669 {

   670     int doit = 1;

   671 

   672     while (!lexstop && !errflag) {

   673 	if (hptr[-1] != (char) c && stophist < 4 &&

   674 	    hptr > chline + 1 && hptr[-1] == '\n' && hptr[-2] == '\\')

   675 	    hungetc('\n'), hungetc('\\');

   676 

   677 	if (expanding) {

   678 	    cs--;

   679 	    ll--;

   680 	    exlast++;

   681 	}

   682 	DPUTS(hptr <= chline, "BUG: hungetc attempted at buffer start");

   683 	hptr--;

   684 	DPUTS(*hptr != (char) c, "BUG: wrong character in hungetc() ");

   685 	qbang = (c == bangchar && stophist < 2 &&

   686 		 hptr > chline && hptr[-1] == '\\');

   687 	if (doit)

   688 	    inungetc(c);

   689 	if (!qbang)

   690 	    return;

   691 	doit = !stophist && ((inbufflags & INP_HIST) ||

   692 				 !(inbufflags & INP_ALIAS));

   693 	c = '\\';

   694     }

   695 }

   696 

   697 /* begin reading a string */

   698 

   699 /**/

   700 mod_export void

   701 strinbeg(int dohist)

   702 {

   703     strin++;

   704     hbegin(dohist);

   705     lexinit();

   706 }

   707 

   708 /* done reading a string */

   709 

   710 /**/

   711 mod_export void

   712 strinend(void)

   713 {

   714     hend(NULL);

   715     DPUTS(!strin, "BUG: strinend() called without strinbeg()");

   716     strin--;

   717     isfirstch = 1;

   718     histdone = 0;

   719 }

   720 

   721 /* dummy functions to use instead of hwaddc(), hwbegin(), and hwend() when

   722  * they aren't needed */

   723 

   724 static void

   725 nohw(UNUSED(int c))

   726 {

   727 }

   728 

   729 static void

   730 nohwe(void)

   731 {

   732 }

   733 

   734 /* these functions handle adding/removing curline to/from the hist_ring */

   735 

   736 static void

   737 linkcurline(void)

   738 {

   739     if (!hist_ring)

   740 	hist_ring = curline.up = curline.down = &curline;

   741     else {

   742 	curline.up = hist_ring;

   743 	curline.down = hist_ring->down;

   744 	hist_ring->down = hist_ring->down->up = &curline;

   745 	hist_ring = &curline;

   746     }

   747     curline.histnum = ++curhist;

   748 }

   749 

   750 static void

   751 unlinkcurline(void)

   752 {

   753     curline.up->down = curline.down;

   754     curline.down->up = curline.up;

   755     if (hist_ring == &curline) {

   756 	if (!histlinect)

   757 	    hist_ring = NULL;

   758 	else

   759 	    hist_ring = curline.up;

   760     }

   761     curhist--;

   762 }

   763 

   764 /* initialize the history mechanism */

   765 

   766 /**/

   767 mod_export void

   768 hbegin(int dohist)

   769 {

   770     isfirstln = isfirstch = 1;

   771     errflag = histdone = 0;

   772     if (!dohist)

   773 	stophist = 2;

   774     else if (dohist != 2)

   775 	stophist = (!interact || unset(SHINSTDIN)) ? 2 : 0;

   776     else

   777 	stophist = 0;

   778     if (stophist == 2 || (inbufflags & INP_ALIAS)) {

   779 	chline = hptr = NULL;

   780 	hlinesz = 0;

   781 	chwords = NULL;

   782 	chwordlen = 0;

   783 	hgetc = ingetc;

   784 	hungetc = inungetc;

   785 	hwaddc = nohw;

   786 	hwbegin = nohw;

   787 	hwend = nohwe;

   788 	addtoline = nohw;

   789     } else {

   790 	chline = hptr = zshcalloc(hlinesz = 64);

   791 	chwords = zalloc((chwordlen = 64) * sizeof(short));

   792 	hgetc = ihgetc;

   793 	hungetc = ihungetc;

   794 	hwaddc = ihwaddc;

   795 	hwbegin = ihwbegin;

   796 	hwend = ihwend;

   797 	addtoline = iaddtoline;

   798 	if (!isset(BANGHIST))

   799 	    stophist = 4;

   800     }

   801     chwordpos = 0;

   802 

   803     if (hist_ring && !hist_ring->ftim)

   804 	hist_ring->ftim = time(NULL);

   805     if ((dohist == 2 || (interact && isset(SHINSTDIN))) && !strin) {

   806 	histactive = HA_ACTIVE;

   807 	attachtty(mypgrp);

   808 	linkcurline();

   809 	defev = addhistnum(curhist, -1, HIST_FOREIGN);

   810     } else

   811 	histactive = HA_ACTIVE | HA_NOINC;

   812 }

   813 

   814 /**/

   815 void

   816 histreduceblanks(void)

   817 {

   818     int i, len, pos, needblank, spacecount = 0;

   819 

   820     if (isset(HISTIGNORESPACE))

   821 	while (chline[spacecount] == ' ') spacecount++;

   822 

   823     for (i = 0, len = spacecount; i < chwordpos; i += 2) {

   824 	len += chwords[i+1] - chwords[i]

   825 	     + (i > 0 && chwords[i] > chwords[i-1]);

   826     }

   827     if (chline[len] == '\0')

   828 	return;

   829 

   830     for (i = 0, pos = spacecount; i < chwordpos; i += 2) {

   831 	len = chwords[i+1] - chwords[i];

   832 	needblank = (i < chwordpos-2 && chwords[i+2] > chwords[i+1]);

   833 	if (pos != chwords[i]) {

   834 	    memcpy(chline + pos, chline + chwords[i], len + needblank);

   835 	    chwords[i] = pos;

   836 	    chwords[i+1] = chwords[i] + len;

   837 	}

   838 	pos += len + needblank;

   839     }

   840     chline[pos] = '\0';

   841 }

   842 

   843 /**/

   844 void

   845 histremovedups(void)

   846 {

   847     Histent he, next;

   848     for (he = hist_ring; he; he = next) {

   849 	next = up_histent(he);

   850 	if (he->flags & HIST_DUP)

   851 	    freehistnode((HashNode)he);

   852     }

   853 }

   854 

   855 /**/

   856 mod_export zlong

   857 addhistnum(zlong hl, int n, int xflags)

   858 {

   859     int dir = n < 0? -1 : n > 0? 1 : 0;

   860     Histent he = gethistent(hl, dir);

   861 			     

   862     if (!he)

   863 	return 0;

   864     if (he->histnum != hl)

   865 	n -= dir;

   866     if (n)

   867 	he = movehistent(he, n, xflags);

   868     if (!he)

   869 	return dir < 0? firsthist() - 1 : curhist + 1;

   870     return he->histnum;

   871 }

   872 

   873 /**/

   874 mod_export Histent

   875 movehistent(Histent he, int n, int xflags)

   876 {

   877     while (n < 0) {

   878 	if (!(he = up_histent(he)))

   879 	    return NULL;

   880 	if (!(he->flags & xflags))

   881 	    n++;

   882     }

   883     while (n > 0) {

   884 	if (!(he = down_histent(he)))

   885 	    return NULL;

   886 	if (!(he->flags & xflags))

   887 	    n--;

   888     }

   889     checkcurline(he);

   890     return he;

   891 }

   892 

   893 /**/

   894 mod_export Histent

   895 up_histent(Histent he)

   896 {

   897     return he->up == hist_ring? NULL : he->up;

   898 }

   899 

   900 /**/

   901 mod_export Histent

   902 down_histent(Histent he)

   903 {

   904     return he == hist_ring? NULL : he->down;

   905 }

   906 

   907 /**/

   908 mod_export Histent

   909 gethistent(zlong ev, int nearmatch)

   910 {

   911     Histent he;

   912 

   913     if (!hist_ring)

   914 	return NULL;

   915 

   916     if (ev - hist_ring->down->histnum < hist_ring->histnum - ev) {

   917 	for (he = hist_ring->down; he->histnum < ev; he = he->down) ;

   918 	if (he->histnum != ev) {

   919 	    if (nearmatch == 0

   920 	     || (nearmatch < 0 && (he = up_histent(he)) == NULL))

   921 		return NULL;

   922 	}

   923     }

   924     else {

   925 	for (he = hist_ring; he->histnum > ev; he = he->up) ;

   926 	if (he->histnum != ev) {

   927 	    if (nearmatch == 0

   928 	     || (nearmatch > 0 && (he = down_histent(he)) == NULL))

   929 		return NULL;

   930 	}

   931     }

   932 

   933     checkcurline(he);

   934     return he;

   935 }

   936 

   937 static void

   938 putoldhistentryontop(short keep_going)

   939 {

   940     static Histent next = NULL;

   941     Histent he = keep_going? next : hist_ring->down;

   942     next = he->down;

   943     if (isset(HISTEXPIREDUPSFIRST) && !(he->flags & HIST_DUP)) {

   944 	static zlong max_unique_ct = 0;

   945 	if (!keep_going)

   946 	    max_unique_ct = savehistsiz;

   947 	do {

   948 	    if (max_unique_ct-- <= 0 || he == hist_ring) {

   949 		max_unique_ct = 0;

   950 		he = hist_ring->down;

   951 		next = hist_ring;

   952 		break;

   953 	    }

   954 	    he = next;

   955 	    next = he->down;

   956 	} while (!(he->flags & HIST_DUP));

   957     }

   958     if (he != hist_ring->down) {

   959 	he->up->down = he->down;

   960 	he->down->up = he->up;

   961 	he->up = hist_ring;

   962 	he->down = hist_ring->down;

   963 	hist_ring->down = he->down->up = he;

   964     }

   965     hist_ring = he;

   966 }

   967 

   968 /**/

   969 Histent

   970 prepnexthistent(void)

   971 {

   972     Histent he; 

   973     int curline_in_ring = hist_ring == &curline;

   974 

   975     if (curline_in_ring)

   976 	unlinkcurline();

   977     if (hist_ring && hist_ring->flags & HIST_TMPSTORE) {

   978 	curhist--;

   979 	freehistnode((HashNode)hist_ring);

   980     }

   981 

   982     if (histlinect < histsiz) {

   983 	he = (Histent)zshcalloc(sizeof *he);

   984 	if (!hist_ring)

   985 	    hist_ring = he->up = he->down = he;

   986 	else {

   987 	    he->up = hist_ring;

   988 	    he->down = hist_ring->down;

   989 	    hist_ring->down = he->down->up = he;

   990 	    hist_ring = he;

   991 	}

   992 	histlinect++;

   993     }

   994     else {

   995 	putoldhistentryontop(0);

   996 	freehistdata(hist_ring, 0);

   997 	he = hist_ring;

   998     }

   999     he->histnum = ++curhist;

  1000     if (curline_in_ring)

  1001 	linkcurline();

  1002     return he;

  1003 }

  1004 

  1005 /* A helper function for hend() */

  1006 

  1007 static int

  1008 should_ignore_line(Eprog prog)

  1009 {

  1010     if (isset(HISTIGNORESPACE)) {

  1011 	if (*chline == ' ' || aliasspaceflag)

  1012 	    return 1;

  1013     }

  1014 

  1015     if (!prog)

  1016 	return 0;

  1017 

  1018     if (isset(HISTNOFUNCTIONS)) {

  1019 	Wordcode pc = prog->prog;

  1020 	wordcode code = *pc;

  1021 	if (wc_code(code) == WC_LIST && WC_LIST_TYPE(code) & Z_SIMPLE

  1022 	 && wc_code(pc[2]) == WC_FUNCDEF)

  1023 	    return 1;

  1024     }

  1025 

  1026     if (isset(HISTNOSTORE)) {

  1027 	char *b = getjobtext(prog, NULL);

  1028 	int saw_builtin;

  1029 	if (*b == 'b' && strncmp(b,"builtin ",8) == 0) {

  1030 	    b += 8;

  1031 	    saw_builtin = 1;

  1032 	} else

  1033 	    saw_builtin = 0;

  1034 	if (*b == 'h' && strncmp(b,"history",7) == 0 && (!b[7] || b[7] == ' ')

  1035 	 && (saw_builtin || !shfunctab->getnode(shfunctab,"history")))

  1036 	    return 1;

  1037 	if (*b == 'r' && (!b[1] || b[1] == ' ')

  1038 	 && (saw_builtin || !shfunctab->getnode(shfunctab,"r")))

  1039 	    return 1;

  1040 	if (*b == 'f' && b[1] == 'c' && b[2] == ' ' && b[3] == '-'

  1041 	 && (saw_builtin || !shfunctab->getnode(shfunctab,"fc"))) {

  1042 	    b += 3;

  1043 	    do {

  1044 		if (*++b == 'l')

  1045 		    return 1;

  1046 	    } while (ialpha(*b));

  1047 	}

  1048     }

  1049 

  1050     return 0;

  1051 }

  1052 

  1053 /* say we're done using the history mechanism */

  1054 

  1055 /**/

  1056 mod_export int

  1057 hend(Eprog prog)

  1058 {

  1059     int flag, save = 1;

  1060     char *hf;

  1061 

  1062     DPUTS(stophist != 2 && !(inbufflags & INP_ALIAS) && !chline,

  1063 	  "BUG: chline is NULL in hend()");

  1064     queue_signals();

  1065     if (histdone & HISTFLAG_SETTY)

  1066 	settyinfo(&shttyinfo);

  1067     if (!(histactive & HA_NOINC))

  1068 	unlinkcurline();

  1069     if (histactive & (HA_NOSTORE|HA_NOINC)) {

  1070 	zfree(chline, hlinesz);

  1071 	zfree(chwords, chwordlen*sizeof(short));

  1072 	chline = NULL;

  1073 	histactive = 0;

  1074 	unqueue_signals();

  1075 	return 1;

  1076     }

  1077     if (hist_ignore_all_dups != isset(HISTIGNOREALLDUPS)

  1078      && (hist_ignore_all_dups = isset(HISTIGNOREALLDUPS)) != 0)

  1079 	histremovedups();

  1080     /* For history sharing, lock history file once for both read and write */

  1081     hf = getsparam("HISTFILE");

  1082     if (isset(SHAREHISTORY) && lockhistfile(hf, 0)) {

  1083 	readhistfile(hf, 0, HFILE_USE_OPTIONS | HFILE_FAST);

  1084 	curline.histnum = curhist+1;

  1085     }

  1086     flag = histdone;

  1087     histdone = 0;

  1088     if (hptr < chline + 1)

  1089 	save = 0;

  1090     else {

  1091 	*hptr = '\0';

  1092 	if (hptr[-1] == '\n') {

  1093 	    if (chline[1]) {

  1094 		*--hptr = '\0';

  1095 	    } else

  1096 		save = 0;

  1097 	}

  1098 	if (chwordpos <= 2)

  1099 	    save = 0;

  1100 	else if (should_ignore_line(prog))

  1101 	    save = -1;

  1102     }

  1103     if (flag & (HISTFLAG_DONE | HISTFLAG_RECALL)) {

  1104 	char *ptr;

  1105 

  1106 	ptr = ztrdup(chline);

  1107 	if ((flag & (HISTFLAG_DONE | HISTFLAG_RECALL)) == HISTFLAG_DONE) {

  1108 	    zputs(ptr, shout);

  1109 	    fputc('\n', shout);

  1110 	    fflush(shout);

  1111 	}

  1112 	if (flag & HISTFLAG_RECALL) {

  1113 	    zpushnode(bufstack, ptr);

  1114 	    save = 0;

  1115 	} else

  1116 	    zsfree(ptr);

  1117     }

  1118     if (save || *chline == ' ') {

  1119 	Histent he;

  1120 	for (he = hist_ring; he && he->flags & HIST_FOREIGN;

  1121 	     he = up_histent(he)) ;

  1122 	if (he && he->flags & HIST_TMPSTORE) {

  1123 	    if (he == hist_ring)

  1124 		curline.histnum = curhist--;

  1125 	    freehistnode((HashNode)he);

  1126 	}

  1127     }

  1128     if (save) {

  1129 	Histent he;

  1130 	int newflags;

  1131 

  1132 #ifdef DEBUG

  1133 	/* debugging only */

  1134 	if (chwordpos%2) {