hist.c

/*
 * hist.c - history expansion
 *
 * This file is part of zsh, the Z shell.
 *
 * Copyright (c) 1992-1997 Paul Falstad
 * All rights reserved.
 *
 * Permission is hereby granted, without written agreement and without
 * license or royalty fees, to use, copy, modify, and distribute this
 * software and to distribute modified versions of this software for any
 * purpose, provided that the above copyright notice and the following
 * two paragraphs appear in all copies of this software.
 *
 * In no event shall Paul Falstad or the Zsh Development Group be liable
 * to any party for direct, indirect, special, incidental, or consequential
 * damages arising out of the use of this software and its documentation,
 * even if Paul Falstad and the Zsh Development Group have been advised of
 * the possibility of such damage.
 *
 * Paul Falstad and the Zsh Development Group specifically disclaim any
 * warranties, including, but not limited to, the implied warranties of
 * merchantability and fitness for a particular purpose.  The software
 * provided hereunder is on an "as is" basis, and Paul Falstad and the
 * Zsh Development Group have no obligation to provide maintenance,
 * support, updates, enhancements, or modifications.
 *
 */

#include "zsh.mdh"
#include "hist.pro"

/* Functions to call for getting/ungetting a character and for history
 * word control. */

/**/
mod_export int (*hgetc) (void);

/**/
void (*hungetc) (int);

/**/
void (*hwaddc) (int);

/**/
void (*hwbegin) (int);

/**/
void (*hwabort) (void);

/**/
void (*hwend) (void);

/**/
void (*addtoline) (int);

/* != 0 means history substitution is turned off */
 
/**/
mod_export int stophist;

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

/**/
mod_export int expanding;

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

/**/
mod_export int excs, exlast;

/*
 * Current history event number
 *
 * Note on curhist: with history inactive, this points to the
 * last line actually added to the history list.  With history active,
 * the line does not get added to the list until hend(), if at all.
 * However, curhist is incremented to reflect the current line anyway
 * and a temporary history entry is inserted while the user is editing.
 * If the resulting line was not added to the list, a flag is set so
 * that curhist will be decremented in hbegin().
 *
 * Note curhist is passed to zle on variable length argument list:
 * type must match that retrieved in zle_main_entry.
 */
 
/**/
mod_export zlong curhist;

/**/
struct histent curline;

/* current line count of allocated history entries */

/**/
zlong histlinect;

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

/**/
HashTable histtab;
/**/
mod_export Histent hist_ring;
 
/* capacity of history lists */
 
/**/
zlong histsiz;
 
/* desired history-file size (in lines) */
 
/**/
zlong savehistsiz;
 
/* if = 1, we have performed history substitution on the current line *
 * if = 2, we have used the 'p' modifier                              */
 
/**/
int histdone;
 
/* state of the history mechanism */
 
/**/
int histactive;

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

/**/
int hist_ignore_all_dups;

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

/**/
mod_export int hist_skip_flags;

/* Bits of histactive variable */
#define HA_ACTIVE	(1<<0)	/* History mechanism is active */
#define HA_NOINC	(1<<1)	/* Don't store, curhist not incremented */
#define HA_INWORD       (1<<2)  /* We're inside a word, don't add
				   start and end markers */
#define HA_UNGET        (1<<3)  /* Recursively ungetting */

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

/**/
short *chwords;

/* Max, actual position in chwords.
 * nwords = chwordpos/2 because we record beginning and end of words.
 */

/**/
int chwordlen, chwordpos;

/* the last l for s/l/r/ history substitution */
 
/**/
char *hsubl;

/* the last r for s/l/r/ history substitution */
 
/**/
char *hsubr;
 
/* state of histsubstpattern at last substitution */

/**/
int hsubpatopt;

/* pointer into the history line */
 
/**/
mod_export char *hptr;
 
/* the current history line */
 
/**/
mod_export char *chline;

/*
 * The current history line as seen by ZLE.
 * We modify chline for use in other contexts while ZLE may
 * still be running; ZLE should see only the top-level value.
 *
 * To avoid having to modify this every time we modify chline,
 * we set it when we push the stack, and unset it when we pop
 * the appropriate value off the stack.  As it's never modified
 * on the stack this is the only maintenance we ever do on it.
 * In return, ZLE has to check both zle_chline and (if that's
 * NULL) chline to get the current value.
 */

/**/
mod_export char *zle_chline;

/* true if the last character returned by hgetc was an escaped bangchar *
 * if it is set and NOBANGHIST is unset hwaddc escapes bangchars        */

/**/
int qbang;
 
/* max size of histline */
 
/**/
int hlinesz;
 
/* default event (usually curhist-1, that is, "!!") */
 
static zlong defev;

/*
 * Flag that we stopped reading line when we got to a comment,
 * but we want to keep it in the histofy even if there were no words
 * (i.e. the comment was the entire line).
 */
static int hist_keep_comment;

/* Remember the last line in the history file so we can find it again. */
static struct histfile_stats {
    char *text;
    time_t stim, mtim;
    off_t fpos, fsiz;
    int interrupted;
    zlong next_write_ev;
} lasthist;

static struct histsave {
    struct histfile_stats lasthist;
    char *histfile;
    HashTable histtab;
    Histent hist_ring;
    zlong curhist;
    zlong histlinect;
    zlong histsiz;
    zlong savehistsiz;
    int locallevel;
} *histsave_stack;
static int histsave_stack_size = 0;
static int histsave_stack_pos = 0;

static zlong histfile_linect;

/* save history context */

/**/
void
hist_context_save(struct hist_stack *hs, int toplevel)
{
    if (toplevel) {
	/* top level, make this version visible to ZLE */
	zle_chline = chline;
	/* ensure line stored is NULL-terminated */
	if (hptr)
	    *hptr = '\0';
    }
    hs->histactive = histactive;
    hs->histdone = histdone;
    hs->stophist = stophist;
    hs->hline = chline;
    hs->hptr = hptr;
    hs->chwords = chwords;
    hs->chwordlen = chwordlen;
    hs->chwordpos = chwordpos;
    hs->hgetc = hgetc;
    hs->hungetc = hungetc;
    hs->hwaddc = hwaddc;
    hs->hwbegin = hwbegin;
    hs->hwabort = hwabort;
    hs->hwend = hwend;
    hs->addtoline = addtoline;
    hs->hlinesz = hlinesz;
    hs->defev = defev;
    hs->hist_keep_comment = hist_keep_comment;
    /*
     * We save and restore the command stack with history
     * as it's visible to the user interactively, so if
     * we're preserving history state we'll continue to
     * show the current set of commands from input.
     */
    hs->cstack = cmdstack;
    hs->csp = cmdsp;

    stophist = 0;
    chline = NULL;
    hptr = NULL;
    histactive = 0;
    cmdstack = (unsigned char *)zalloc(CMDSTACKSZ);
    cmdsp = 0;
}

/* restore history context */

/**/
void
hist_context_restore(const struct hist_stack *hs, int toplevel)
{
    if (toplevel) {
	/* Back to top level: don't need special ZLE value */
	DPUTS(hs->hline != zle_chline, "BUG: Ouch, wrong chline for ZLE");
	zle_chline = NULL;
    }
    histactive = hs->histactive;
    histdone = hs->histdone;
    stophist = hs->stophist;
    chline = hs->hline;
    hptr = hs->hptr;
    chwords = hs->chwords;
    chwordlen = hs->chwordlen;
    chwordpos = hs->chwordpos;
    hgetc = hs->hgetc;
    hungetc = hs->hungetc;
    hwaddc = hs->hwaddc;
    hwbegin = hs->hwbegin;
    hwabort = hs->hwabort;
    hwend = hs->hwend;
    addtoline = hs->addtoline;
    hlinesz = hs->hlinesz;
    defev = hs->defev;
    hist_keep_comment = hs->hist_keep_comment;
    if (cmdstack)
	zfree(cmdstack, CMDSTACKSZ);
    cmdstack = hs->cstack;
    cmdsp = hs->csp;
}

/*
 * Mark that the current level of history is within a word whatever
 * characters turn up, or turn that mode off.  This is used for nested
 * parsing of substitutions.
 *
 * The caller takes care only to turn this on or off at the start
 * or end of recursive use of the same mode, so a single flag is
 * good enough here.
 */

/**/
void
hist_in_word(int yesno)
{
    if (yesno)
	histactive |= HA_INWORD;
    else
	histactive &= ~HA_INWORD;
}

/**/
int
hist_is_in_word(void)
{
    return (histactive & HA_INWORD) ? 1 : 0;
}

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

static void
ihwaddc(int c)
{
    /* Only if history line exists and lexing has not finished. */
    if (chline && !(errflag || lexstop) &&
	/*
	 * If we're reading inside a word for command substitution
	 * we allow the lexer to expand aliases but don't deal
	 * with them here.  Note matching code in ihungetc().
	 * TBD: it might be neater to deal with all aliases in this
	 * fashion as we never need the expansion in the history
	 * line, only in the lexer and above.
	 */
	(inbufflags & (INP_ALIAS|INP_HIST)) != INP_ALIAS) {
	/* Quote un-expanded bangs in the history line. */
	if (c == bangchar && stophist < 2 && qbang)
	    /* If qbang is not set, we do not escape this bangchar as it's *
	     * not necessary (e.g. it's a bang in !=, or it is followed    *
	     * by a space). Roughly speaking, qbang is zero only if the    *
	     * history interpreter has already digested this bang and      *
	     * found that it is not necessary to escape it.                */
	    hwaddc('\\');
	*hptr++ = c;

	/* Resize history line if necessary */
	if (hptr - chline >= hlinesz) {
	    int oldsiz = hlinesz;

	    chline = realloc(chline, hlinesz = oldsiz + 64);
	    hptr = chline + oldsiz;
	}
    }
}

/* This function adds a character to the zle input line. It is used when *
 * zsh expands history (see doexpandhist() in zle_tricky.c). It also     *
 * calculates the new cursor position after the expansion. It is called  *
 * from hgetc() and from gettok() in lex.c for characters in comments.   */

/**/
void
iaddtoline(int c)
{
    if (!expanding || lexstop)
	return;
    if (qbang && c == bangchar && stophist < 2) {
	exlast--;
	zleentry(ZLE_CMD_ADD_TO_LINE, '\\');
    }
    if (excs > zlemetacs) {
	excs += 1 + inbufct - exlast;
	if (excs < zlemetacs)
	    /* this case could be handled better but it is    *
	     * so rare that it does not worth it              */
	    excs = zlemetacs;
    }
    exlast = inbufct;
    zleentry(ZLE_CMD_ADD_TO_LINE, itok(c) ? ztokens[c - Pound] : c);
}


static int
ihgetc(void)
{
    int c = ingetc();

    if (exit_pending)
    {
	lexstop = 1;
	errflag |= ERRFLAG_ERROR;
	return ' ';
    }
    qbang = 0;
    if (!stophist && !(inbufflags & INP_ALIAS)) {
	/* If necessary, expand history characters. */
	c = histsubchar(c);
	if (c < 0) {
	    /* bad expansion */
	    lexstop = 1;
	    errflag |= ERRFLAG_ERROR;
	    return ' ';
	}
    }
    if ((inbufflags & INP_HIST) && !stophist) {
	/* the current character c came from a history expansion          *
	 * (inbufflags & INP_HIST) and history is not disabled            *
	 * (e.g. we are not inside single quotes). In that case, \!       *
	 * should be treated as ! (since this \! came from a previous     *
	 * history line where \ was used to escape the bang). So if       *
	 * c == '\\' we fetch one more character to see if it's a bang,   *
	 * and if it is not, we unget it and reset c back to '\\'         */
	qbang = 0;
	if (c == '\\' && !(qbang = (c = ingetc()) == bangchar))
	    safeinungetc(c), c = '\\';
    } else if (stophist || (inbufflags & INP_ALIAS))
	/* If the result is a bangchar which came from history or alias  *
	 * expansion, we treat it as an escaped bangchar, unless history *
	 * is disabled. If stophist == 1 it only means that history is   *
	 * temporarily disabled by a !" which won't appear in the        *
	 * history, so we still have an escaped bang. stophist > 1 if    *
	 * history is disabled with NOBANGHIST or by someone else (e.g.  *
	 * when the lexer scans single quoted text).                     */
	qbang = c == bangchar && (stophist < 2);
    hwaddc(c);
    addtoline(c);

    return c;
}

/**/
static void
safeinungetc(int c)
{
    if (lexstop)
	lexstop = 0;
    else
	inungetc(c);
}

/**/
void
herrflush(void)
{
    inpopalias();

    if (lexstop)
	return;
    /*
     * The lex_add_raw test is needed if we are parsing a command
     * substitution when expanding history for ZLE: strin is set but we
     * need to finish off the input because the string we are reading is
     * going to be used directly in the line that goes to ZLE.
     *
     * Note that this is a side effect --- this is not the usual reason
     * for testing lex_add_raw which is to add the text to a different
     * buffer used when we are actually parsing the command substitution
     * (nothing to do with ZLE).  Sorry.
     */
    while (inbufct && (!strin || lex_add_raw)) {
	int c = ingetc();
	if (!lexstop) {
	    hwaddc(c);
	    addtoline(c);
	}
    }
}

/*
 * Extract :s/foo/bar/ delimiters and arguments
 *
 * The first character expected is the first delimiter.
 * The arguments are stored in the hsubl and hsubr variables.
 *
 * subline is the part of the command line to be matched.
 *
 * If a ':' was found but was not followed by a 'G',
 * *cflagp is set to 1 and the input is backed up to the
 * character following the colon.
 */

/**/
static int
getsubsargs(UNUSED(char *subline), int *gbalp, int *cflagp)
{
    int del, follow;
    char *ptr1, *ptr2;

    del = ingetc();
    ptr1 = hdynread2(del);
    if (!ptr1)
	return 1;
    ptr2 = hdynread2(del);
    if (strlen(ptr1)) {
	zsfree(hsubl);
	hsubl = ptr1;
    } else if (!hsubl) {		/* fail silently on this */
	zsfree(ptr1);
	zsfree(ptr2);
	return 0;
    }
    zsfree(hsubr);
    hsubr = ptr2;
    follow = ingetc();
    if (follow == ':') {
	follow = ingetc();
	if (follow == 'G')
	    *gbalp = 1;
	else {
	    inungetc(follow);
	    *cflagp = 1;
	}
    } else
	inungetc(follow);
    return 0;
}

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

/**/
static int
getargc(Histent ehist)
{
    return ehist->nwords ? ehist->nwords-1 : 0;
}

/**/
static int
substfailed(void)
{
    herrflush();
    zerr("substitution failed");
    return -1;
}

/*
 * Return a count given by decimal digits after a modifier.
 */
static int
digitcount(void)
{
    int c = ingetc(), count;

    if (idigit(c)) {
	count = 0;
	do {
	    count = 10 * count + (c - '0');
	    c = ingetc();
	} while (idigit(c));
    }
    else
	count = 0;
    inungetc(c);
    return count;
}

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

/**/
static int
histsubchar(int c)
{
    int farg, evset = -1, larg, argc, cflag = 0, bflag = 0;
    zlong ev;
    static int marg = -1;
    static zlong mev = -1;
    char *buf, *ptr;
    char *sline;
    int lexraw_mark;
    Histent ehist;
    size_t buflen;

    /*
     * If accumulating raw input for use in command substitution,
     * we don't want the history text, so mark it for later removal.
     * It would be better to do this at a level above the history
     * and below the lexer --- but there isn't one.
     *
     * Include the character we are attempting to substitute.
     */
    lexraw_mark = zshlex_raw_mark(-1); 

    /* look, no goto's */
    if (isfirstch && c == hatchar) {
	int gbal = 0;

	/* Line begins ^foo^bar */
	isfirstch = 0;
	inungetc(hatchar);
	if (!(ehist = gethist(defev))
	    || !(sline = getargs(ehist, 0, getargc(ehist))))
	    return -1;

	if (getsubsargs(sline, &gbal, &cflag))
	    return substfailed();
	if (!hsubl)
	    return -1;
	if (subst(&sline, hsubl, hsubr, gbal, 0))
	    return substfailed();
    } else {
	/* Line doesn't begin ^foo^bar */
	if (c != ' ')
	    isfirstch = 0;
	if (c == '\\') {
	    int g = ingetc();

	    if (g != bangchar)
		safeinungetc(g);
	    else {
		qbang = 1;
		return bangchar;
	    }
	}
	if (c != bangchar)
	    return c;
	*hptr = '\0';
	if ((c = ingetc()) == '{') {
	    bflag = cflag = 1;
	    c = ingetc();
	}
	if (c == '\"') {
	    stophist = 1;
	    return ingetc();
	}
	if ((!cflag && inblank(c)) || c == '=' || c == '(' || lexstop) {
	    safeinungetc(c);
	    return bangchar;
	}
	cflag = 0;
	ptr = buf = zhalloc(buflen = 265);

	/* get event number */

	queue_signals();
	if (c == '?') {
	    for (;;) {
		c = ingetc();
		if (c == '?' || c == '\n' || lexstop)
		    break;
		else {
		    *ptr++ = c;
		    if (ptr == buf + buflen) {
			buf = hrealloc(buf, buflen, 2 * buflen);
			ptr = buf + buflen;
			buflen *= 2;
		    }
		}
	    }
	    if (c != '\n' && !lexstop)
		c = ingetc();
	    *ptr = '\0';
	    mev = ev = hconsearch(hsubl = ztrdup(buf), &marg);
	    evset = 0;
	    if (ev == -1) {
		herrflush();
		unqueue_signals();
		zerr("no such event: %s", buf);
		return -1;
	    }
	} else {
	    zlong t0;

	    for (;;) {
		if (inblank(c) || c == ';' || c == ':' || c == '^' ||
		    c == '$' || c == '*' || c == '%' || c == '}' ||
		    c == '\'' || c == '"' || c == '`' || lexstop)
		    break;
		if (ptr != buf) {
		    if (c == '-')
			break;
		    if ((idigit(buf[0]) || buf[0] == '-') && !idigit(c))
			break;
		}
		*ptr++ = c;
		if (ptr == buf + buflen) {
		    buf = hrealloc(buf, buflen, 2 * buflen);
		    ptr = buf + buflen;
		    buflen *= 2;
		}
		if (c == '#' || c == bangchar) {
		    c = ingetc();
		    break;
		}
		c = ingetc();
	    }
	    if (ptr == buf &&
		(c == '}' ||  c == ';' || c == '\'' || c == '"' || c == '`')) {
	      /* Neither event nor word designator, no expansion */
	      safeinungetc(c);
	      unqueue_signals();
	      return bangchar;
	    }
	    *ptr = 0;
	    if (!*buf) {
		if (c != '%') {
		    if (isset(CSHJUNKIEHISTORY))
			ev = addhistnum(curhist,-1,HIST_FOREIGN);
		    else
			ev = defev;
		    if (c == ':' && evset == -1)
			evset = 0;
		    else
			evset = 1;
		} else {
		    if (marg != -1)
			ev = mev;
		    else
			ev = defev;
		    evset = 0;
		}
	    } else if ((t0 = zstrtol(buf, NULL, 10))) {
		ev = (t0 < 0) ? addhistnum(curhist,t0,HIST_FOREIGN) : t0;
		evset = 1;
	    } else if ((unsigned)*buf == bangchar) {
		ev = addhistnum(curhist,-1,HIST_FOREIGN);
		evset = 1;
	    } else if (*buf == '#') {
		ev = curhist;
		evset = 1;
	    } else if ((ev = hcomsearch(buf)) == -1) {
		herrflush();
		unqueue_signals();
		zerr("event not found: %s", buf);
		return -1;
	    } else
		evset = 1;
	}

	/* get the event */

	if (!(ehist = gethist(defev = ev))) {
	    unqueue_signals();
	    return -1;
	}
	/* extract the relevant arguments */

	argc = getargc(ehist);
	if (c == ':') {
	    cflag = 1;
	    c = ingetc();
	    if (c == '%' && marg != -1) {
		if (!evset) {
		    ehist = gethist(defev = mev);
		    argc = getargc(ehist);
		} else {
		    herrflush();
		    unqueue_signals();
		    zerr("ambiguous history reference");
		    return -1;
		}

	    }
	}
	if (c == '*') {
	    farg = 1;
	    larg = argc;
	    cflag = 0;
	} else {
	    inungetc(c);
	    larg = farg = getargspec(argc, marg, evset);
	    if (larg == -2) {
		unqueue_signals();
		return -1;
	    }
	    if (farg != -1)
		cflag = 0;
	    c = ingetc();
	    if (c == '*') {
		cflag = 0;
		larg = argc;
	    } else if (c == '-') {
		cflag = 0;
		larg = getargspec(argc, marg, evset);
		if (larg == -2) {
		    unqueue_signals();
		    return -1;
		}
		if (larg == -1)
		    larg = argc - 1;
	    } else
		inungetc(c);
	}
	if (farg == -1)
	    farg = 0;
	if (larg == -1)
	    larg = argc;
	if (!(sline = getargs(ehist, farg, larg))) {
	    unqueue_signals();
	    return -1;
	}
	unqueue_signals();
    }

    /* do the modifiers */

    for (;;) {
	c = (cflag) ? ':' : ingetc();
	cflag = 0;
	if (c == ':') {
	    int gbal = 0;

	    if ((c = ingetc()) == 'g') {
		gbal = 1;
		c = ingetc();
		if (c != 's' && c != 'S' && c != '&') {
		    zerr("'s' or '&' modifier expected after 'g'");
		    return -1;
		}
	    }
	    switch (c) {
	    case 'p':
		histdone = HISTFLAG_DONE | HISTFLAG_NOEXEC;
		break;
	    case 'a':
		if (!chabspath(&sline)) {
		    herrflush();
		    zerr("modifier failed: a");
		    return -1;
		}
		break;

	    case 'A':
		if (!chrealpath(&sline, 'A', 1)) {
		    herrflush();
		    zerr("modifier failed: A");
		    return -1;
		}
		break;
	    case 'c':
		if (!(sline = equalsubstr(sline, 0, 0))) {
		    herrflush();
		    zerr("modifier failed: c");
		    return -1;
		}
		break;
	    case 'h':
		if (!remtpath(&sline, digitcount())) {
		    herrflush();
		    zerr("modifier failed: h");
		    return -1;
		}
		break;
	    case 'e':
		if (!rembutext(&sline)) {
		    herrflush();
		    zerr("modifier failed: e");
		    return -1;
		}
		break;
	    case 'r':
		if (!remtext(&sline)) {
		    herrflush();
		    zerr("modifier failed: r");
		    return -1;
		}
		break;
	    case 't':
		if (!remlpaths(&sline, digitcount())) {
		    herrflush();
		    zerr("modifier failed: t");
		    return -1;
		}
		break;
	    case 's':
	    case 'S':
		hsubpatopt = (c == 'S');
		if (getsubsargs(sline, &gbal, &cflag))
		    return -1; /* fall through */
	    case '&':
		if (hsubl && hsubr) {
		    if (subst(&sline, hsubl, hsubr, gbal, hsubpatopt))
			return substfailed();
		} else {
		    herrflush();
		    zerr("no previous substitution");
		    return -1;
		}
		break;
	    case 'q':
		quote(&sline);
		break;
	    case 'Q':
		{
		    int one = noerrs, oef = errflag;

		    noerrs = 1;
		    parse_subst_string(sline);
		    noerrs = one;
		    errflag = oef | (errflag & ERRFLAG_INT);
		    remnulargs(sline);
		    untokenize(sline);
		}
		break;
	    case 'x':
		quotebreak(&sline);
		break;
	    case 'l':
		sline = casemodify(sline, CASMOD_LOWER);
		break;
	    case 'u':
		sline = casemodify(sline, CASMOD_UPPER);
		break;
	    case 'P':
		if (*sline != '/') {
		    char *here = zgetcwd();
		    if (here[strlen(here)-1] != '/')
			sline = zhtricat(metafy(here, -1, META_HEAPDUP), "/", sline);
		    else
			sline = dyncat(here, sline);
		}
		sline = xsymlink(sline, 1);
		break;
	    default:
		herrflush();
		zerr("illegal modifier: %c", c);
		return -1;
	    }
	} else {
	    if (c != '}' || !bflag)
		inungetc(c);
	    if (c != '}' && bflag) {
		zerr("'}' expected");
		return -1;
	    }
	    break;
	}
    }

    zshlex_raw_back_to_mark(lexraw_mark);

    /*
     * Push the expanded value onto the input stack,
     * marking this as a history word for purposes of the alias stack.
     */

    lexstop = 0;
    /* this function is called only called from hgetc and only if      *
     * !(inbufflags & INP_ALIAS). History expansion should never be    *
     * done with INP_ALIAS (to prevent recursive history expansion and *
     * histoty expansion of aliases). Escapes are not removed here.    *
     * This is now handled in hgetc.                                   */
    inpush(sline, INP_HIST, NULL); /* sline from heap, don't free */
    histdone |= HISTFLAG_DONE;
    if (isset(HISTVERIFY))
	histdone |= HISTFLAG_NOEXEC | HISTFLAG_RECALL;

    /* Don't try and re-expand line. */
    return ingetc();
}

/* unget a char and remove it from chline. It can only be used *
 * to unget a character returned by hgetc.                     */

static void
ihungetc(int c)
{
    int doit = 1;

    while (!lexstop && !errflag) {
	if (hptr[-1] != (char) c && stophist < 4 &&
	    hptr > chline + 1 && hptr[-1] == '\n' && hptr[-2] == '\\' &&
	    !(histactive & HA_UNGET) &&
	    (inbufflags & (INP_ALIAS|INP_HIST)) != INP_ALIAS) {
	    histactive |= HA_UNGET;
	    hungetc('\n');
	    hungetc('\\');
	    histactive &= ~HA_UNGET;
	}

	if (expanding) {
	    zlemetacs--;
	    zlemetall--;
	    exlast++;
	}
	if ((inbufflags & (INP_ALIAS|INP_HIST)) != INP_ALIAS) {
	    DPUTS(hptr <= chline, "BUG: hungetc attempted at buffer start");
	    hptr--;
	    DPUTS(*hptr != (char) c, "BUG: wrong character in hungetc() ");
	    qbang = (c == bangchar && stophist < 2 &&
		     hptr > chline && hptr[-1] == '\\');
	} else {
	    /* No active bangs in aliases */
	    qbang = 0;
	}
	if (doit)
	    inungetc(c);
	if (!qbang)
	    return;
	doit = !stophist && ((inbufflags & INP_HIST) ||
				 !(inbufflags & INP_ALIAS));
	c = '\\';
    }
}

/* begin reading a string */

/**/
mod_export void
strinbeg(int dohist)
{
    strin++;
    hbegin(dohist);
    lexinit();
    /*
     * Also initialise some variables owned by the parser but
     * used for communication between the parser and lexer.
     */
    init_parse_status();
}

/* done reading a string */

/**/
mod_export void
strinend(void)
{
    hend(NULL);
    DPUTS(!strin, "BUG: strinend() called without strinbeg()");
    strin--;
    isfirstch = 1;
    histdone = 0;
}

/* dummy functions to use instead of hwaddc(), hwbegin(), and hwend() when
 * they aren't needed */

static void
nohw(UNUSED(int c))
{
}

static void
nohwabort(void)
{
}

static void
nohwe(void)
{
}

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

static void
linkcurline(void)
{
    if (!hist_ring)
	hist_ring = curline.up = curline.down = &curline;
    else {
	curline.up = hist_ring;
	curline.down = hist_ring->down;
	hist_ring->down = hist_ring->down->up = &curline;
	hist_ring = &curline;
    }
    curline.histnum = ++curhist;
}

static void
unlinkcurline(void)
{
    curline.up->down = curline.down;
    curline.down->up = curline.up;
    if (hist_ring == &curline) {
	if (!histlinect)
	    hist_ring = NULL;
	else
	    hist_ring = curline.up;
    }
    curhist--;
}

/* initialize the history mechanism */

/**/
mod_export void
hbegin(int dohist)
{
    char *hf;

    isfirstln = isfirstch = 1;
    errflag &= ~ERRFLAG_ERROR;
    histdone = 0;
    if (!dohist)
	stophist = 2;
    else if (dohist != 2)
	stophist = (!interact || unset(SHINSTDIN)) ? 2 : 0;
    else
	stophist = 0;
    /*
     * pws: We used to test for "|| (inbufflags & INP_ALIAS)"
     * in this test, but at this point we don't have input
     * set up so this can trigger unnecessarily.
     * I don't see how the test at this point could ever be
     * useful, since we only get here when we're initialising
     * the history mechanism, before we've done any input.
     *
     * (I also don't see any point where this function is called with
     * dohist=0.)
     */
    if (stophist == 2) {
	chline = hptr = NULL;
	hlinesz = 0;
	chwords = NULL;
	chwordlen = 0;
	hgetc = ingetc;
	hungetc = inungetc;
	hwaddc = nohw;
	hwbegin = nohw;
	hwabort = nohwabort;
	hwend = nohwe;
	addtoline = nohw;
    } else {
	chline = hptr = zshcalloc(hlinesz = 64);
	chwords = zalloc((chwordlen = 64) * sizeof(short));
	hgetc = ihgetc;
	hungetc = ihungetc;
	hwaddc = ihwaddc;
	hwbegin = ihwbegin;
	hwabort = ihwabort;
	hwend = ihwend;
	addtoline = iaddtoline;
	if (!isset(BANGHIST))
	    stophist = 4;
    }
    chwordpos = 0;

    if (hist_ring && !hist_ring->ftim && !strin)
	hist_ring->ftim = time(NULL);
    if ((dohist == 2 || (interact && isset(SHINSTDIN))) && !strin) {
	histactive = HA_ACTIVE;
	attachtty(mypgrp);
	linkcurline();
	defev = addhistnum(curhist, -1, HIST_FOREIGN);
    } else
	histactive = HA_ACTIVE | HA_NOINC;

    /*
     * For INCAPPENDHISTORYTIME, when interactive, save the history here
     * as it gives a better estimate of the times of commands.
     *
     * If INCAPPENDHISTORY is also set we've already done it.
     *
     * If SHAREHISTORY is also set continue to do so in the
     * standard place, because that's safer about reading and
     * rewriting history atomically.
     *
     * The histsave_stack_pos test won't usually fail here.
     * We need to test the opposite for the hend() case because we
     * need to save in the history file we've switched to, but then
     * we pop immediately after that so the variable becomes zero.
     * We will already have saved the line and restored the history
     * so that (correctly) nothing happens here.  But it shows
     * I thought about it.
     */
    if (isset(INCAPPENDHISTORYTIME) && !isset(SHAREHISTORY) &&
	!isset(INCAPPENDHISTORY) &&
	!(histactive & HA_NOINC) && !strin && histsave_stack_pos == 0) {
	hf = getsparam("HISTFILE");
	savehistfile(hf, 0, HFILE_USE_OPTIONS | HFILE_FAST);
    }
}

/**/
void
histreduceblanks(void)
{
    int i, len, pos, needblank, spacecount = 0, trunc_ok;
    char *lastptr, *ptr;

    if (isset(HISTIGNORESPACE))
	while (chline[spacecount] == ' ') spacecount++;

    for (i = 0, len = spacecount; i < chwordpos; i += 2) {
	len += chwords[i+1] - chwords[i]
	     + (i > 0 && chwords[i] > chwords[i-1]);
    }
    if (chline[len] == '\0')
	return;

    /* Remember where the delimited words end */
    if (chwordpos)
	lastptr = chline + chwords[chwordpos-1];
    else
	lastptr = chline;

    for (i = 0, pos = spacecount; i < chwordpos; i += 2) {
	len = chwords[i+1] - chwords[i];
	needblank = (i < chwordpos-2 && chwords[i+2] > chwords[i+1]);
	if (pos != chwords[i]) {
	    memmove(chline + pos, chline + chwords[i], len + needblank);
	    chwords[i] = pos;
	    chwords[i+1] = chwords[i] + len;
	}
	pos += len + needblank;
    }

    /*
     * A terminating comment isn't recorded as a word.
     * Only truncate the line if just whitespace remains.
     */
    trunc_ok = 1;
    for (ptr = lastptr; *ptr; ptr++) {
	if (!inblank(*ptr)) {
	    trunc_ok = 0;
	    break;
	}
    }
    if (trunc_ok) {
	chline[pos] = '\0';
    } else {
	ptr = chline + pos;
	if (ptr < lastptr)
	    while ((*ptr++ = *lastptr++))
		;
    }
}

/**/
void
histremovedups(void)
{
    Histent he, next;
    for (he = hist_ring; he; he = next) {
	next = up_histent(he);
	if (he->node.flags & HIST_DUP)
	    freehistnode(&he->node);
    }
}

/**/
mod_export zlong
addhistnum(zlong hl, int n, int xflags)
{
    int dir = n < 0? -1 : n > 0? 1 : 0;
    Histent he = gethistent(hl, dir);
			     
    if (!he)
	return 0;
    if (he->histnum != hl)
	n -= dir;
    if (n)
	he = movehistent(he, n, xflags);
    if (!he)
	return dir < 0? firsthist() - 1 : curhist + 1;
    return he->histnum;
}

/**/
mod_export Histent
movehistent(Histent he, int n, int xflags)
{
    while (n < 0) {
	if (!(he = up_histent(he)))
	    return NULL;
	if (!(he->node.flags & xflags))
	    n++;
    }
    while (n > 0) {
	if (!(he = down_histent(he)))
	    return NULL;
	if (!(he->node.flags & xflags))
	    n--;
    }
    checkcurline(he);
    return he;
}

/**/
mod_export Histent
up_histent(Histent he)
{
    return !he || he->up == hist_ring? NULL : he->up;
}

/**/
mod_export Histent
down_histent(Histent he)
{
    return he == hist_ring? NULL : he->down;
}

/**/
mod_export Histent
gethistent(zlong ev, int nearmatch)
{
    Histent he;

    if (!hist_ring)
	return NULL;

    if (ev - hist_ring->down->histnum < hist_ring->histnum - ev) {
	for (he = hist_ring->down; he->histnum < ev; he = he->down) ;
	if (he->histnum != ev) {
	    if (nearmatch == 0
	     || (nearmatch < 0 && (he = up_histent(he)) == NULL))
		return NULL;
	}
    }
    else {
	for (he = hist_ring; he->histnum > ev; he = he->up) ;
	if (he->histnum != ev) {
	    if (nearmatch == 0
	     || (nearmatch > 0 && (he = down_histent(he)) == NULL))
		return NULL;
	}
    }

    checkcurline(he);
    return he;
}

static void
putoldhistentryontop(short keep_going)
{
    static Histent next = NULL;
    Histent he = (keep_going || !hist_ring) ? next : hist_ring->down;
    if (he)
	next = he->down;
    else
	return;
    if (isset(HISTEXPIREDUPSFIRST) && !(he->node.flags & HIST_DUP)) {
	static zlong max_unique_ct = 0;
	if (!keep_going)
	    max_unique_ct = savehistsiz;
	do {
	    if (max_unique_ct-- <= 0 || he == hist_ring) {
		max_unique_ct = 0;
		if (hist_ring)
		    he = hist_ring->down;
		next = hist_ring;
		break;
	    }
	    he = next;
	    next = he->down;
	} while (!(he->node.flags & HIST_DUP));
    }
    /* Is it really possible for hist_ring to be NULL here? */
    if (he && (!hist_ring || he != hist_ring->down)) {
	he->up->down = he->down;
	he->down->up = he->up;
	he->up = hist_ring;
	if (hist_ring) {
	    he->down = hist_ring->down;
	    hist_ring->down = he;
	}
	he->down->up = he;
    }
    hist_ring = he;
}

/**/
Histent
prepnexthistent(void)
{
    Histent he; 
    int curline_in_ring = hist_ring == &curline;

    if (curline_in_ring)
	unlinkcurline();
    if (hist_ring && hist_ring->node.flags & HIST_TMPSTORE) {
	curhist--;
	freehistnode(&hist_ring->node);
    }

    if (histlinect < histsiz || !hist_ring) {
	he = (Histent)zshcalloc(sizeof *he);
	if (!hist_ring)
	    hist_ring = he->up = he->down = he;
	else {
	    he->up = hist_ring;
	    he->down = hist_ring->down;
	    hist_ring->down = he->down->up = he;
	    hist_ring = he;
	}
	histlinect++;
    }
    else {
	putoldhistentryontop(0);
	freehistdata(hist_ring, 0);
	he = hist_ring;
    }
    he->histnum = ++curhist;
    if (curline_in_ring)
	linkcurline();
    return he;
}

/* A helper function for hend() */

static int
should_ignore_line(Eprog prog)
{
    if (isset(HISTIGNORESPACE)) {
	if (*chline == ' ' || aliasspaceflag)
	    return 1;
    }

    if (!prog)
	return 0;

    if (isset(HISTNOFUNCTIONS)) {
	Wordcode pc = prog->prog;
	wordcode code = *pc;
	if (wc_code(code) == WC_LIST && WC_LIST_TYPE(code) & Z_SIMPLE
	 && wc_code(pc[2]) == WC_FUNCDEF)
	    return 1;
    }

    if (isset(HISTNOSTORE)) {
	char *b = getjobtext(prog, NULL);
	int saw_builtin;
	if (*b == 'b' && strncmp(b,"builtin ",8) == 0) {
	    b += 8;
	    saw_builtin = 1;
	} else
	    saw_builtin = 0;
	if (*b == 'h' && strncmp(b,"history",7) == 0 && (!b[7] || b[7] == ' ')
	 && (saw_builtin || !shfunctab->getnode(shfunctab,"history")))
	    return 1;
	if (*b == 'r' && (!b[1] || b[1] == ' ')
	 && (saw_builtin || !shfunctab->getnode(shfunctab,"r")))
	    return 1;
	if (*b == 'f' && b[1] == 'c' && b[2] == ' ' && b[3] == '-'
	 && (saw_builtin || !shfunctab->getnode(shfunctab,"fc"))) {
	    b += 3;
	    do {
		if (*++b == 'l')
		    return 1;
	    } while (ialpha(*b));
	}
    }

    return 0;
}

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

/**/
mod_export int
hend(Eprog prog)
{
    int flag, hookret = 0, stack_pos = histsave_stack_pos;
    /*
     * save:
     * 0: don't save
     * 1: save normally
     * -1: save temporarily, delete after next line
     * -2: save internally but mark for not writing
     */
    int save = 1;
    char *hf;

    DPUTS(stophist != 2 && !(inbufflags & INP_ALIAS) && !chline,
	  "BUG: chline is NULL in hend()");
    queue_signals();
    if (histdone & HISTFLAG_SETTY)
	settyinfo(&shttyinfo);
    if (!(histactive & HA_NOINC))
	unlinkcurline();
    if (histactive & HA_NOINC) {
	zfree(chline, hlinesz);
	zfree(chwords, chwordlen*sizeof(short));
	chline = hptr = NULL;
	chwords = NULL;
	histactive = 0;
	unqueue_signals();
	return 1;
    }
    if (hist_ignore_all_dups != isset(HISTIGNOREALLDUPS)
     && (hist_ignore_all_dups = isset(HISTIGNOREALLDUPS)) != 0)
	histremovedups();

    if (hptr) {
	/*
	 * Added the following in case the test "hptr < chline + 1"
	 * is more than just paranoia.
	 */
	DPUTS(hptr < chline, "History end pointer off start of line");
	*hptr = '\0';
    }
    if (*chline) {
	LinkList hookargs = newlinklist();
	int save_errflag = errflag;
	errflag = 0;

	addlinknode(hookargs, "zshaddhistory");
	addlinknode(hookargs, chline);
	callhookfunc("zshaddhistory", hookargs, 1, &hookret);

	errflag &= ~ERRFLAG_ERROR;
	errflag |= save_errflag;
    }
    /* For history sharing, lock history file once for both read and write */
    hf = getsparam("HISTFILE");
    if (isset(SHAREHISTORY) && !lockhistfile(hf, 0)) {
	readhistfile(hf, 0, HFILE_USE_OPTIONS | HFILE_FAST);
	curline.histnum = curhist+1;
    }
    flag = histdone;
    histdone = 0;
    if (hptr < chline + 1)
	save = 0;
    else {
	if (hptr[-1] == '\n') {
	    if (chline[1]) {
		*--hptr = '\0';
	    } else
		save = 0;
	}
	if (chwordpos <= 2 && !hist_keep_comment)
	    save = 0;
	else if (should_ignore_line(prog))
	    save = -1;
	else if (hookret == 2)
	    save = -2;
	else if (hookret)
	    save = -1;
    }
    if (flag & (HISTFLAG_DONE | HISTFLAG_RECALL)) {
	char *ptr;

	ptr = ztrdup(chline);
	if ((flag & (HISTFLAG_DONE | HISTFLAG_RECALL)) == HISTFLAG_DONE) {
	    zputs(ptr, shout);
	    fputc('\n', shout);
	    fflush(shout);
	}
	if (flag & HISTFLAG_RECALL) {
	    zpushnode(bufstack, ptr);
	    save = 0;
	} else
	    zsfree(ptr);
    }
    if (save || *chline == ' ') {
	Histent he;
	for (he = hist_ring; he && he->node.flags & HIST_FOREIGN;
	     he = up_histent(he)) ;
	if (he && he->node.flags & HIST_TMPSTORE) {
	    if (he == hist_ring)
		curline.histnum = curhist--;
	    freehistnode(&he->node);
	}
    }
    if (save) {
	Histent he;
	int newflags;

#ifdef DEBUG
	/* debugging only */
	if (chwordpos%2) {
	    hwend();
	    DPUTS(1, "BUG: uncompleted line in history");
	}
#endif
	/* get rid of pesky \n which we've already nulled out */
	if (chwordpos > 1 && !chline[chwords[chwordpos-2]]) {
	    chwordpos -= 2;
	    /* strip superfluous blanks, if desired */
	    if (isset(HISTREDUCEBLANKS))
		histreduceblanks();
	}
	if (save == -1)
	    newflags = HIST_TMPSTORE;
	else if (save == -2)
	    newflags = HIST_NOWRITE;
	else
	    newflags = 0;
	if ((isset(HISTIGNOREDUPS) || isset(HISTIGNOREALLDUPS)) && save > 0
	 && hist_ring && histstrcmp(chline, hist_ring->node.nam) == 0) {
	    /* This history entry compares the same as the previous.
	     * In case minor changes were made, we overwrite the
	     * previous one with the current one.  This also gets the
	     * timestamp right.  Perhaps, preserve the HIST_OLD flag.
	     */
	    he = hist_ring;
	    newflags |= he->node.flags & HIST_OLD; /* Avoid re-saving */
	    freehistdata(he, 0);
	    curline.histnum = curhist;
	} else
	    he = prepnexthistent();

	he->node.nam = ztrdup(chline);
	he->stim = time(NULL);
	he->ftim = 0L;
	he->node.flags = newflags;

	if ((he->nwords = chwordpos/2)) {
	    he->words = (short *)zalloc(chwordpos * sizeof(short));
	    memcpy(he->words, chwords, chwordpos * sizeof(short));
	}
	if (!(newflags & HIST_TMPSTORE))
	    addhistnode(histtab, he->node.nam, he);
    }
    zfree(chline, hlinesz);
    zfree(chwords, chwordlen*sizeof(short));
    chline = hptr = NULL;
    chwords = NULL;
    histactive = 0;
    /*
     * For normal INCAPPENDHISTORY case and reasoning, see hbegin().
     */
    if (isset(SHAREHISTORY) ? histfileIsLocked() :
	(isset(INCAPPENDHISTORY) || (isset(INCAPPENDHISTORYTIME) &&
				     histsave_stack_pos != 0)))
	savehistfile(hf, 0, HFILE_USE_OPTIONS | HFILE_FAST);
    unlockhistfile(hf); /* It's OK to call this even if we aren't locked */
    /*
     * No good reason for the user to push the history more than once, but
     * it's easy to be tidy...
     */
    while (histsave_stack_pos > stack_pos)
	pophiststack();
    hist_keep_comment = 0;
    unqueue_signals();
    return !(flag & HISTFLAG_NOEXEC || errflag);
}

/* begin a word */

/**/
void
ihwbegin(int offset)
{
    int pos = hptr - chline + offset;
    if (stophist == 2 || (histactive & HA_INWORD) ||
	(inbufflags & (INP_ALIAS|INP_HIST)) == INP_ALIAS)
	return;
    if (chwordpos%2)
	chwordpos--;	/* make sure we're on a word start, not end */
    DPUTS1(pos < 0, "History word position < 0 in %s",
	   dupstrpfx(chline, hptr-chline));
    if (pos < 0)
	pos = 0;
    chwords[chwordpos++] = pos;
}

/* Abort current history word, not needed */

/**/
void
ihwabort(void)
{
    if (chwordpos%2)
	chwordpos--;
    hist_keep_comment = 1;
}

/* add a word to the history List */

/**/
void
ihwend(void)
{
    if (stophist == 2 || (histactive & HA_INWORD) ||
	(inbufflags & (INP_ALIAS|INP_HIST)) == INP_ALIAS)
	return;
    if (chwordpos%2 && chline) {
	/* end of word reached and we've already begun a word */
	if (hptr > chline + chwords[chwordpos-1]) {
	    chwords[chwordpos++] = hptr - chline;
	    if (chwordpos >= chwordlen) {
		chwords = (short *) realloc(chwords,
					    (chwordlen += 32) * 
					    sizeof(short));
	    }
	} else {
	    /* scrub that last word, it doesn't exist */
	    chwordpos--;
	}
    }
}

/* Go back to immediately after the last word, skipping space. */

/**/
void
histbackword(void)
{
    if (!(chwordpos%2) && chwordpos)
	hptr = chline + chwords[chwordpos-1];
}

/* Get the start and end point of the current history word */

/**/
static void
hwget(char **startptr)
{
    int pos = chwordpos - 2;

#ifdef DEBUG
    /* debugging only */
    if (!chwordpos) {
	/* no words available */
	DPUTS(1, "BUG: hwget() called with no words");
	*startptr = "";
	return;
    }
    else if (chwordpos%2) {
	DPUTS(1, "BUG: hwget() called in middle of word");
	*startptr = "";
	return;
    }
#endif

    *startptr = chline + chwords[pos];
    chline[chwords[++pos]] = '\0';
}

/* Replace the current history word with rep, if different */

/**/
void
hwrep(char *rep)
{
    char *start;
    hwget(&start);

    if (!strcmp(rep, start))
	return;

    hptr = start;
    chwordpos = chwordpos - 2;
    hwbegin(0);
    qbang = 1;
    while (*rep)
	hwaddc(*rep++);
    hwend();
}

/* Get the entire current line, deleting it in the history. */

/**/
mod_export char *
hgetline(void)
{
    /* Currently only used by pushlineoredit().
     * It's necessary to prevent that from getting too pally with
     * the history code.
     */
    char *ret;

    if (!chline || hptr == chline)
	return NULL;
    *hptr = '\0';
    ret = dupstring(chline);

    /* reset line */
    hptr = chline;
    chwordpos = 0;

    return ret;
}

/* get an argument specification */

/**/
static int
getargspec(int argc, int marg, int evset)
{
    int c, ret = -1;

    if ((c = ingetc()) == '0')
	return 0;
    if (idigit(c)) {
	ret = 0;
	while (idigit(c)) {
	    ret = ret * 10 + c - '0';
	    if (ret < 0) {
		herrflush();
		zerr("no such word in event");
		return -2;
	    }
	    c = ingetc();
	}
	inungetc(c);
    } else if (c == '^')
	ret = 1;
    else if (c == '$')
	ret = argc;
    else if (c == '%') {
	if (evset) {
	    herrflush();
	    zerr("Ambiguous history reference");
	    return -2;
	}
	if (marg == -1) {
	    herrflush();
	    zerr("%% with no previous word matched");
	    return -2;
	}
	ret = marg;
    } else
	inungetc(c);
    return ret;
}

/* do ?foo? search */

/**/
static zlong
hconsearch(char *str, int *marg)
{
    int t1 = 0;
    char *s;
    Histent he;

    for (he = up_histent(hist_ring); he; he = up_histent(he)) {
	if (he->node.flags & HIST_FOREIGN)
	    continue;
	if ((s = strstr(he->node.nam, str))) {
	    int pos = s - he->node.nam;
	    while (t1 < he->nwords && he->words[2*t1] <= pos)
		t1++;
	    *marg = t1 - 1;
	    return he->histnum;
	}
    }
    return -1;
}

/* do !foo search */

/**/
zlong
hcomsearch(char *str)
{
    Histent he;
    int len = strlen(str);

    for (he = up_histent(hist_ring); he; he = up_histent(he)) {
	if (he->node.flags & HIST_FOREIGN)
	    continue;
	if (strncmp(he->node.nam, str, len) == 0)
	    return he->histnum;
    }
    return -1;
}

/* various utilities for : modifiers */

/**/
int
chabspath(char **junkptr)
{
    char *current, *dest;

    if (!**junkptr)
	return 1;

    if (**junkptr != '/') {
	char *here = zgetcwd();
	if (here[strlen(here)-1] != '/')
	    *junkptr = zhtricat(metafy(here, -1, META_HEAPDUP), "/", *junkptr);
	else
	    *junkptr = dyncat(here, *junkptr);
    }

    current = *junkptr;
    dest = *junkptr;

#ifdef HAVE_SUPERROOT
    while (*current == '/' && current[1] == '.' && current[2] == '.' &&
	   (!current[3] || current[3] == '/')) {
	*dest++ = '/';
	*dest++ = '.';
	*dest++ = '.';
	current += 3;
    }
#endif

    for (;;) {
	if (*current == '/') {
#ifdef __CYGWIN__
	    if (current == *junkptr && current[1] == '/')
		*dest++ = *current++;
#endif
	    *dest++ = *current++;
	    while (*current == '/')
		current++;
	} else if (!*current) {
	    while (dest > *junkptr + 1 && dest[-1] == '/')
		dest--;
	    *dest = '\0';
	    break;
	} else if (current[0] == '.' && current[1] == '.' &&
		   (!current[2] || current[2] == '/')) {
		if (current == *junkptr || dest == *junkptr) {
		    *dest++ = '.';
		    *dest++ = '.';
		    current += 2;
		} else if (dest > *junkptr + 2 &&
			   !strncmp(dest - 3, "../", 3)) {
		    *dest++ = '.';
		    *dest++ = '.';
		    current += 2;
		} else if (dest > *junkptr + 1) {
		    *dest = '\0';
		    for (dest--;
			 dest > *junkptr + 1 && dest[-1] != '/';
			 dest--);
		    if (dest[-1] != '/')
			dest--;
		    current += 2;
		    if (*current == '/')
			current++;
		} else if (dest == *junkptr + 1) {
		    /* This might break with Cygwin's leading double slashes? */
		    current += 2;
		} else {
		    return 0;
		}
	} else if (current[0] == '.' && (current[1] == '/' || !current[1])) {
	     while (*++current == '/');
	} else {
	    while (*current != '/' && *current != '\0')
		if ((*dest++ = *current++) == Meta)
		    *dest++ = *current++;
	}
    }
    return 1;
}

/*
 * Resolve symlinks in junkptr.
 *
 * If mode is 'A', resolve dot-dot before symlinks.  Else, mode should be 'P'.
 * Refer to the documentation of the :A and :P modifiers for details.
 *
 * use_heap is 1 if the result is to be allocated on the heap, 0 otherwise.
 *
 * Return 0 for error, non-zero for success.
 */

/**/
int
chrealpath(char **junkptr, char mode, int use_heap)
{
    char *str;
#ifdef HAVE_REALPATH
# ifdef REALPATH_ACCEPTS_NULL
    char *lastpos, *nonreal, *real;
# else
    char *lastpos, *nonreal, pathbuf[PATH_MAX+1];
    char *real = pathbuf;
# endif
#endif

    DPUTS1(mode != 'A' && mode != 'P', "chrealpath: mode='%c' is invalid", mode);

    if (!**junkptr)
	return 1;

    if (mode == 'A')
	if (!chabspath(junkptr))
	    return 0;

#ifndef HAVE_REALPATH
    return 1;
#else
    /*
     * Notice that this means you cannot pass relative paths into this
     * function!
     */
    if (**junkptr != '/')
	return 0;

    untokenize(*junkptr);
    unmetafy(*junkptr, NULL);

    lastpos = strend(*junkptr);
    nonreal = lastpos + 1;

    while (!
#ifdef REALPATH_ACCEPTS_NULL
	   /* realpath() with a NULL second argument uses malloc() to get
	    * memory so we don't need to worry about overflowing PATH_MAX */
	   (real = realpath(*junkptr, NULL))
#else
	   realpath(*junkptr, real)
#endif
	) {
	if (errno == EINVAL || errno == ENOMEM)
	    return 0;

	if (nonreal == *junkptr) {
#ifndef REALPATH_ACCEPTS_NULL
	    real = NULL;
#endif
	    break;
	}

	while (*nonreal != '/' && nonreal >= *junkptr)
	    nonreal--;
	*nonreal = '\0';
    }

    str = nonreal;
    while (str <= lastpos) {
	if (*str == '\0')
	    *str = '/';
	str++;
    }

    use_heap = (use_heap ? META_HEAPDUP : META_DUP);
    if (real) {
	*junkptr = metafy(str = bicat(real, nonreal), -1, use_heap);
	zsfree(str);
#ifdef REALPATH_ACCEPTS_NULL
	free(real);
#endif
    } else {
	*junkptr = metafy(nonreal, lastpos - nonreal + 1, use_heap);
    }
#endif

    return 1;
}

/**/
int
remtpath(char **junkptr, int count)
{
    char *str = strend(*junkptr);

    /* ignore trailing slashes */
    while (str >= *junkptr && IS_DIRSEP(*str))
	--str;
    if (!count) {
	/* skip filename */
	while (str >= *junkptr && !IS_DIRSEP(*str))
	    --str;
    }
    if (str < *junkptr) {
	if (IS_DIRSEP(**junkptr))
	    *junkptr = dupstring ("/");
	else
	    *junkptr = dupstring (".");

	return 0;
    }

    if (count)
    {
	/*
	 * Return this many components, so start from the front.
	 * Leading slash counts as one component, consistent with
	 * behaviour of repeated applications of :h.
	 */
	char *strp = *junkptr;
	while (strp < str) {
	    if (IS_DIRSEP(*strp)) {
		if (--count <= 0) {
		    if (strp == *junkptr)
			++strp;
		    *strp = '\0';
		    return 1;
		}
		/* Count consecutive separators as one */
		while (IS_DIRSEP(strp[1]))
		    ++strp;
	    }
	    ++strp;
	}

	/* Full string needed */
	return 1;
    }

    /* repeated slashes are considered like a single slash */
    while (str > *junkptr && IS_DIRSEP(str[-1]))
	--str;
    /* never erase the root slash */
    if (str == *junkptr) {
	++str;
	/* Leading doubled slashes (`//') have a special meaning on cygwin
	   and some old flavor of UNIX, so we do not assimilate them to
	   a single slash.  However a greater number is ok to squeeze. */
	if (IS_DIRSEP(*str) && !IS_DIRSEP(str[1]))
	    ++str;
    }
    *str = '\0';
    return 1;
}

/**/
int
remtext(char **junkptr)
{
    char *str;

    for (str = strend(*junkptr); str >= *junkptr && !IS_DIRSEP(*str); --str)
	if (*str == '.') {
	    *str = '\0';
	    return 1;
	}
    return 0;
}

/**/
int
rembutext(char **junkptr)
{
    char *str;

    for (str = strend(*junkptr); str >= *junkptr && !IS_DIRSEP(*str); --str)
	if (*str == '.') {
	    *junkptr = dupstring(str + 1); /* .xx or xx? */
	    return 1;
	}
    /* no extension */
    *junkptr = dupstring ("");
    return 0;
}

/**/
mod_export int
remlpaths(char **junkptr, int count)
{
    char *str = strend(*junkptr);

    if (IS_DIRSEP(*str)) {
	/* remove trailing slashes */
	while (str >= *junkptr && IS_DIRSEP(*str))
	    --str;
	str[1] = '\0';
    }
    for (;;) {
	for (; str >= *junkptr; --str) {
	    if (IS_DIRSEP(*str)) {
		if (--count > 0) {
		    if (str > *junkptr) {
			--str;
			break;
		    } else {
			/* Whole string needed */
			return 1;
		    }
		}
		*str = '\0';
		*junkptr = dupstring(str + 1);
		return 1;
	    }
	}
	/* Count consecutive separators as 1 */
	while (str >= *junkptr && IS_DIRSEP(*str))
	    --str;
	if (str <= *junkptr)
	    break;
    }
    return 0;
}

/*
 * Return modified version of str from the heap with modification
 * according to one of the CASMOD_* types defined in zsh.h; CASMOD_NONE
 * is not handled, for obvious reasons.
 */

/**/
char *
casemodify(char *str, int how)
{
    char *str2 = zhalloc(2 * strlen(str) + 1);
    char *ptr2 = str2;
    int nextupper = 1;

#ifdef MULTIBYTE_SUPPORT
    if (isset(MULTIBYTE)) {
	VARARR(char, mbstr, MB_CUR_MAX);
	mbstate_t ps;

	mb_charinit();
	memset(&ps, 0, sizeof(ps));
	while (*str) {
	    wint_t wc;
	    int len = mb_metacharlenconv(str, &wc), mod = 0, len2;
	    /*
	     * wc is set to WEOF if the start of str couldn't be
	     * converted.  Presumably WEOF doesn't match iswlower(), but
	     * better be safe.
	     */
	    if (wc == WEOF) {
		while (len--)
		    *ptr2++ = *str++;
		/* not alphanumeric */
		nextupper = 1;
		continue;
	    }
	    switch (how) {
	    case CASMOD_LOWER:
		if (iswupper(wc)) {
		    wc = towlower(wc);
		    mod = 1;
		}
		break;

	    case CASMOD_UPPER:
		if (iswlower(wc)) {
		    wc = towupper(wc);
		    mod = 1;
		}
		break;

	    case CASMOD_CAPS:
	    default:		/* shuts up compiler */
		if (IS_COMBINING(wc))
			break;
		if (!iswalnum(wc))
		    nextupper = 1;
		else if (nextupper) {
		    if (iswlower(wc)) {
			wc = towupper(wc);
			mod = 1;
		    }
		    nextupper = 0;
		} else if (iswupper(wc)) {
		    wc = towlower(wc);
		    mod = 1;
		}
		break;
	    }
	    if (mod && (len2 = wcrtomb(mbstr, wc, &ps)) > 0) {
		char *mbptr;

		for (mbptr = mbstr; mbptr < mbstr + len2; mbptr++) {
		    if (imeta((unsigned char) *mbptr)) {
			*ptr2++ = Meta;
			*ptr2++ = *mbptr ^ 32;
		    } else
			*ptr2++ = *mbptr;
		}
		str += len;
	    } else {
		while (len--)
		    *ptr2++ = *str++;
	    }
	}
    }
    else
#endif
	while (*str) {
	    int c;
	    int mod = 0;
	    if (*str == Meta) {
		c = (unsigned char) (str[1] ^ 32);
		str += 2;
	    } else
		c = (unsigned char) *str++;
	    switch (how) {
	    case CASMOD_LOWER:
		if (isupper(c)) {
		    c = tolower(c);
		    mod = 1;
		}
		break;

	    case CASMOD_UPPER:
		if (islower(c)) {
		    c = toupper(c);
		    mod = 1;
		}
		break;

	    case CASMOD_CAPS:
	    default:		/* shuts up compiler */
		if (!ialnum(c))
		    nextupper = 1;
		else if (nextupper) {
		    if (islower(c)) {
			c = toupper(c);
			mod = 1;
		    }
		    nextupper = 0;
		} else if (isupper(c)) {
		    c = tolower(c);
		    mod = 1;
		}
		break;
	    }
	    if (mod && imeta(c)) {
		*ptr2++ = Meta;
		*ptr2++ = c ^ 32;
	    } else
		*ptr2++ = c;
	}
    *ptr2 = '\0';
    return str2;
}


/*
 * Substitute "in" for "out" in "*strptr" and update "*strptr".
 * If "gbal", do global substitution.
 *
 * This returns a result from the heap.  There seems to have
 * been some confusion on this point.
 */

/**/
int
subst(char **strptr, char *in, char *out, int gbal, int forcepat)
{
    char *str = *strptr, *substcut, *sptr;
    int off, inlen, outlen;

    if (!*in)
	in = str, gbal = 0;

    if (isset(HISTSUBSTPATTERN) || forcepat) {
	int fl = SUB_LONG|SUB_REST|SUB_RETFAIL;
	char *oldin = in;
	if (gbal)
	    fl |= SUB_GLOBAL;
	if (*in == '#' || *in == Pound) {
	    /* anchor at head, flag needed if SUB_END is also set */
	    fl |= SUB_START;
	    in++;
	}
	if (*in == '%') {
	    /* anchor at tail */
	    in++;
	    fl |= SUB_END;
	}
	if (in == oldin) {
	    /* no anchor, substring match */
	    fl |= SUB_SUBSTR;
	}
	if (in == str)
	    in = dupstring(in);
	if (parse_subst_string(in) || errflag)
	    return 1;
	if (parse_subst_string(out) || errflag)
	    return 1;
	singsub(&in);
	if (getmatch(strptr, in, fl, 1, out))
	    return 0;
    } else {
	if ((substcut = (char *)strstr(str, in))) {
	    inlen = strlen(in);
	    sptr = convamps(out, in, inlen);
	    outlen = strlen(sptr);

	    do {
		*substcut = '\0';
		off = substcut - *strptr + outlen;
		substcut += inlen;
		*strptr = zhtricat(*strptr, sptr, substcut);
		str = (char *)*strptr + off;
	    } while (gbal && (substcut = (char *)strstr(str, in)));

	    return 0;
	}
    }

    return 1;
}

/**/
static char *
convamps(char *out, char *in, int inlen)
{
    char *ptr, *ret, *pp;
    int slen, sdup = 0;

    for (ptr = out, slen = 0; *ptr; ptr++, slen++)
	if (*ptr == '\\')
	    ptr++, sdup = 1;
	else if (*ptr == '&')
	    slen += inlen - 1, sdup = 1;
    if (!sdup)
	return out;
    ret = pp = (char *) zhalloc(slen + 1);
    for (ptr = out; *ptr; ptr++)
	if (*ptr == '\\')
	    *pp++ = *++ptr;
	else if (*ptr == '&') {
	    strcpy(pp, in);
	    pp += inlen;
	} else
	    *pp++ = *ptr;
    *pp = '\0';
    return ret;
}

/**/
static void
checkcurline(Histent he)
{
    if (he->histnum == curhist && (histactive & HA_ACTIVE)) {
	curline.node.nam = chline;
	curline.nwords = chwordpos/2;
	curline.words = chwords;
    }
}

/**/
mod_export Histent
quietgethist(int ev)
{
    return gethistent(ev, GETHIST_EXACT);
}

/**/
static Histent
gethist(int ev)
{
    Histent ret;

    ret = quietgethist(ev);
    if (!ret) {
	herrflush();
	zerr("no such event: %d", ev);
    }
    return ret;
}

/**/
static char *
getargs(Histent elist, int arg1, int arg2)
{
    short *words = elist->words;
    int pos1, pos2, nwords = elist->nwords;

    if (arg1 < 0 || arg2 < 0 || arg2 < arg1 || arg1 >= nwords || arg2 >= nwords) {
	/* remember, argN is indexed from 0, nwords is total no. of words */
	herrflush();
	zerr("no such word in event");
	return NULL;
    }

    /* optimization for accessing entire history event */
    if (arg1 == 0 && arg2 == nwords - 1)
	return dupstring(elist->node.nam);

    pos1 = words[2*arg1];
    pos2 = words[2*arg2+1];

    /* a word has to be at least one character long, so if the position
     * of a word is less than its index, we've overflowed our signed
     * short integer word range and the recorded position is garbage. */
    if (pos1 < 0 || pos1 < arg1 || pos2 < 0 || pos2 < arg2) {
	herrflush();
	zerr("history event too long, can't index requested words");
	return NULL;
    }
    return dupstrpfx(elist->node.nam + pos1, pos2 - pos1);
}

/**/
static int
quote(char **tr)
{
    char *ptr, *rptr, **str = tr;
    int len = 3;
    int inquotes = 0;

    for (ptr = *str; *ptr; ptr++, len++)
	if (*ptr == '\'') {
	    len += 3;
	    if (!inquotes)
		inquotes = 1;
	    else
		inquotes = 0;
	} else if (inblank(*ptr) && !inquotes && ptr[-1] != '\\')
	    len += 2;
    ptr = *str;
    *str = rptr = (char *) zhalloc(len);
    *rptr++ = '\'';
    for (; *ptr; ptr++)
	if (*ptr == '\'') {
	    if (!inquotes)
		inquotes = 1;
	    else
		inquotes = 0;
	    *rptr++ = '\'';
	    *rptr++ = '\\';
	    *rptr++ = '\'';
	    *rptr++ = '\'';
	} else if (inblank(*ptr) && !inquotes && ptr[-1] != '\\') {
	    *rptr++ = '\'';
	    *rptr++ = *ptr;
	    *rptr++ = '\'';
	} else
	    *rptr++ = *ptr;
    *rptr++ = '\'';
    *rptr++ = 0;
    return 0;
}

/**/
static int
quotebreak(char **tr)
{
    char *ptr, *rptr, **str = tr;
    int len = 3;

    for (ptr = *str; *ptr; ptr++, len++)
	if (*ptr == '\'')
	    len += 3;
	else if (inblank(*ptr))
	    len += 2;
    ptr = *str;
    *str = rptr = (char *) zhalloc(len);
    *rptr++ = '\'';
    for (; *ptr;)
	if (*ptr == '\'') {
	    *rptr++ = '\'';
	    *rptr++ = '\\';
	    *rptr++ = '\'';
	    *rptr++ = '\'';
	    ptr++;
	} else if (inblank(*ptr)) {
	    *rptr++ = '\'';
	    *rptr++ = *ptr++;
	    *rptr++ = '\'';
	} else
	    *rptr++ = *ptr++;
    *rptr++ = '\'';
    *rptr++ = '\0';
    return 0;
}

/* read an arbitrary amount of data into a buffer until stop is found */

#if 0 /**/
char *
hdynread(int stop)
{
    int bsiz = 256, ct = 0, c;
    char *buf = (char *)zalloc(bsiz), *ptr;

    ptr = buf;
    while ((c = ingetc()) != stop && c != '\n' && !lexstop) {
	if (c == '\\')
	    c = ingetc();
	*ptr++ = c;
	if (++ct == bsiz) {
	    buf = realloc(buf, bsiz *= 2);
	    ptr = buf + ct;
	}
    }
    *ptr = 0;
    if (c == '\n') {
	inungetc('\n');
	zerr("delimiter expected");
	zfree(buf, bsiz);
	return NULL;
    }
    return buf;
}
#endif

/**/
static char *
hdynread2(int stop)
{
    int bsiz = 256, ct = 0, c;
    char *buf = (char *)zalloc(bsiz), *ptr;

    ptr = buf;
    while ((c = ingetc()) != stop && c != '\n' && !lexstop) {
	if (c == '\\')
	    c = ingetc();
	*ptr++ = c;
	if (++ct == bsiz) {
	    buf = realloc(buf, bsiz *= 2);
	    ptr = buf + ct;
	}
    }
    *ptr = 0;
    if (c == '\n')
	inungetc('\n');
    return buf;
}

/**/
void
inithist(void)
{
    createhisttable();
}

/**/
void
resizehistents(void)
{
    if (histlinect > histsiz) {
	/* The reason we don't just call freehistnode(hist_ring->down) is
	 * so that we can honor the HISTEXPIREDUPSFIRST setting. */
	putoldhistentryontop(0);
	freehistnode(&hist_ring->node);
	while (histlinect > histsiz) {
	    putoldhistentryontop(1);
	    freehistnode(&hist_ring->node);
	}
    }
}

static int
readhistline(int start, char **bufp, int *bufsiz, FILE *in, int *readbytes)
{
    char *buf = *bufp;
    if (fgets(buf + start, *bufsiz - start, in)) {
	int len = strlen(buf + start);
	*readbytes += len;
	len += start;
	if (len == start)
	    return -1;
	if (buf[len - 1] != '\n') {
	    if (!feof(in)) {
		if (len < (*bufsiz) - 1)
		    return -1;
		*bufp = zrealloc(buf, 2 * (*bufsiz));
		*bufsiz = 2 * (*bufsiz);
		return readhistline(len, bufp, bufsiz, in, readbytes);
	    }
	}
	else {
	    int spc;
	    buf[len - 1] = '\0';
	    if (len > 1 && buf[len - 2] == '\\') {
		buf[--len - 1] = '\n';
		if (!feof(in))
		    return readhistline(len, bufp, bufsiz, in, readbytes);
	    }

	    spc = len - 2;
	    while (spc >= 0 && buf[spc] == ' ')
		spc--;
	    if (spc != len - 2 && buf[spc] == '\\')
		buf[--len - 1] = '\0';
	}
	return len;
    }
    return 0;
}

/**/
void
readhistfile(char *fn, int err, int readflags)
{
    char *buf, *start = NULL;
    FILE *in;
    Histent he;
    time_t stim, ftim, tim = time(NULL);
    off_t fpos;
    short *words;
    struct stat sb;
    int nwordpos, nwords, bufsiz;
    int searching, newflags, l, ret, uselex, readbytes;

    if (!fn && !(fn = getsparam("HISTFILE")))
	return;
    if (stat(unmeta(fn), &sb) < 0 ||
	sb.st_size == 0)
	return;
    if (readflags & HFILE_FAST) {
	if (!lasthist.interrupted &&
	    ((lasthist.fsiz == sb.st_size && lasthist.mtim == sb.st_mtime)
	     || lockhistfile(fn, 0)))
	    return;
	lasthist.fsiz = sb.st_size;
	lasthist.mtim = sb.st_mtime;
	lasthist.interrupted = 0;
    } else if ((ret = lockhistfile(fn, 1))) {
	if (ret == 2) {
	    zwarn("locking failed for %s: %e: reading anyway", fn, errno);
	} else {
	    zerr("locking failed for %s: %e", fn, errno);
	    return;
	}
    }
    if ((in = fopen(unmeta(fn), "r"))) {
	nwords = 64;
	words = (short *)zalloc(nwords*sizeof(short));
	bufsiz = 1024;
	buf = zalloc(bufsiz);

	pushheap();
	if (readflags & HFILE_FAST && lasthist.text) {
	    if (lasthist.fpos < lasthist.fsiz) {
		fseek(in, lasthist.fpos, SEEK_SET);
		searching = 1;
	    }
	    else {
		histfile_linect = 0;
		searching = -1;
	    }
	} else
	    searching = 0;

	fpos = ftell(in);
	readbytes = 0;
	newflags = HIST_OLD | HIST_READ;
	if (readflags & HFILE_FAST)
	    newflags |= HIST_FOREIGN;
	if (readflags & HFILE_SKIPOLD
	 || (hist_ignore_all_dups && newflags & hist_skip_flags))
	    newflags |= HIST_MAKEUNIQUE;
	while (fpos += readbytes, readbytes = 0, (l = readhistline(0, &buf, &bufsiz, in, &readbytes))) {
	    char *pt;
	    int remeta = 0;

	    if (l < 0) {
		zerr("corrupt history file %s", fn);
		break;
	    }

	    /*
	     * Handle the special case that we're reading from an
	     * old shell with fewer meta characters, so we need to
	     * metafy some more.  (It's not clear why the history
	     * file is metafied at all; some would say this is plain
	     * stupid.  But we're stuck with it now without some
	     * hairy workarounds for compatibility).
	     *
	     * This is rare so doesn't need to be that efficient; just
	     * allocate space off the heap.
	     */
	    for (pt = buf; *pt; pt++) {
		if (*pt == Meta && pt[1])
		    pt++;
		else if (imeta(*pt)) {
		    remeta = 1;
		    break;
		}
	    }
	    if (remeta) {
		unmetafy(buf, &remeta);
		pt = metafy(buf, remeta, META_USEHEAP);
	    } else {
		pt = buf;
	    }

	    if (*pt == ':') {
		pt++;
		stim = zstrtol(pt, NULL, 0);
		for (; *pt != ':' && *pt; pt++);
		if (*pt) {
		    pt++;
		    ftim = zstrtol(pt, NULL, 0);
		    for (; *pt != ';' && *pt; pt++);
		    if (*pt)
			pt++;
		} else
		    ftim = stim;
	    } else {
		if (*pt == '\\' && pt[1] == ':')
		    pt++;
		stim = ftim = 0;
	    }

	    if (searching) {
		if (searching > 0) {
		    if (stim == lasthist.stim
		     && histstrcmp(pt, lasthist.text) == 0)
			searching = 0;
		    else {
			fseek(in, 0, SEEK_SET);
			histfile_linect = 0;
			searching = -1;
		    }
		    continue;
		}
		else if (stim < lasthist.stim) {
		    histfile_linect++;
		    continue;
		}
		searching = 0;
	    }

	    if (readflags & HFILE_USE_OPTIONS) {
		histfile_linect++;
		lasthist.fpos = fpos;
		lasthist.stim = stim;
	    }

	    he = prepnexthistent();
	    he->node.nam = ztrdup(pt);
	    he->node.flags = newflags;
	    if ((he->stim = stim) == 0)
		he->stim = he->ftim = tim;
	    else if (ftim < stim)
		he->ftim = stim + ftim;
	    else
		he->ftim = ftim;

	    /*
	     * Divide up the words.
	     */
	    start = pt;
	    uselex = isset(HISTLEXWORDS) && !(readflags & HFILE_FAST);
	    histsplitwords(pt, &words, &nwords, &nwordpos, uselex);

	    he->nwords = nwordpos/2;
	    if (he->nwords) {
		he->words = (short *)zalloc(nwordpos*sizeof(short));
		memcpy(he->words, words, nwordpos*sizeof(short));
	    } else
		he->words = (short *)NULL;
	    addhistnode(histtab, he->node.nam, he);
	    if (he->node.flags & HIST_DUP) {
		freehistnode(&he->node);
		curhist--;
	    }
	    /*
	     * Do this last out of paranoia in case use of
	     * heap is disguised...
	     */
	    if (uselex || remeta)
		freeheap();
	    if (errflag & ERRFLAG_INT)
		break;
	}
	if (errflag & ERRFLAG_INT) {
	    /* Can't assume fast read next time if interrupted. */
	    lasthist.interrupted = 1;
	}
	if (start && readflags & HFILE_USE_OPTIONS) {
	    zsfree(lasthist.text);
	    lasthist.text = ztrdup(start);
	}
	zfree(words, nwords*sizeof(short));
	zfree(buf, bufsiz);

	popheap();
	fclose(in);
    } else if (err)
	zerr("can't read history file %s", fn);

    unlockhistfile(fn);

    if (zleactive)
	zleentry(ZLE_CMD_SET_HIST_LINE, curhist);
}

#ifdef HAVE_FCNTL_H
static int flock_fd = -1;

/*
 * Lock file using fcntl().  Return 0 on success, 1 on failure of
 * locking mechanism, 2 on permanent failure (e.g. permission).
 */

static int
flockhistfile(char *fn, int keep_trying)
{
    struct flock lck;
    long sleep_us = 0x10000; /* about 67 ms */
    time_t end_time;

    if (flock_fd >= 0)
	return 0; /* already locked */

    if ((flock_fd = open(unmeta(fn), O_RDWR | O_NOCTTY)) < 0)
	return errno == ENOENT ? 0 : 2; /* "successfully" locked missing file */

    lck.l_type = F_WRLCK;
    lck.l_whence = SEEK_SET;
    lck.l_start = 0;
    lck.l_len = 0;  /* lock the whole file */

    /*
     * Timeout is ten seconds.
     */
    end_time = zmonotime(NULL) + (time_t)10;
    while (fcntl(flock_fd, F_SETLKW, &lck) == -1) {
	if (!keep_trying || zmonotime(NULL) >= end_time ||
	    /*
	     * Randomise wait to minimise clashes with shells exiting at
	     * the same time.
	     */
	    !zsleep_random(sleep_us, end_time)) {
	    close(flock_fd);
	    flock_fd = -1;
	    return 1;
	}
	sleep_us <<= 1;
    }

    return 0;
}
#endif

/**/
void
savehistfile(char *fn, int err, int writeflags)
{
    char *t, *tmpfile, *start = NULL;
    FILE *out;
    Histent he;
    zlong xcurhist = curhist - !!(histactive & HA_ACTIVE);
    int extended_history = isset(EXTENDEDHISTORY);
    int ret;

    if (!interact || savehistsiz <= 0 || !hist_ring
     || (!fn && !(fn = getsparam("HISTFILE"))))
	return;
    if (writeflags & HFILE_FAST) {
	he = gethistent(lasthist.next_write_ev, GETHIST_DOWNWARD);
	while (he && he->node.flags & HIST_OLD) {
	    lasthist.next_write_ev = he->histnum + 1;
	    he = down_histent(he);
	}
	if (!he || lockhistfile(fn, 0))
	    return;
	if (histfile_linect > savehistsiz + savehistsiz / 5)
	    writeflags &= ~HFILE_FAST;
    }
    else {
	if (lockhistfile(fn, 1)) {
	    zerr("locking failed for %s: %e", fn, errno);
	    return;
	}
	he = hist_ring->down;
    }
    if (writeflags & HFILE_USE_OPTIONS) {
	if (isset(APPENDHISTORY) || isset(INCAPPENDHISTORY)
	 || isset(INCAPPENDHISTORYTIME) || isset(SHAREHISTORY))
	    writeflags |= HFILE_APPEND | HFILE_SKIPOLD;
	else
	    histfile_linect = 0;
	if (isset(HISTSAVENODUPS))
	    writeflags |= HFILE_SKIPDUPS;
	if (isset(SHAREHISTORY))
	    extended_history = 1;
    }
    errno = 0;
    if (writeflags & HFILE_APPEND) {
	int fd = open(unmeta(fn), O_CREAT | O_WRONLY | O_APPEND | O_NOCTTY, 0600);
	tmpfile = NULL;
	out = fd >= 0 ? fdopen(fd, "a") : NULL;
    } else if (!isset(HISTSAVEBYCOPY)) {
	int fd = open(unmeta(fn), O_CREAT | O_WRONLY | O_TRUNC | O_NOCTTY, 0600);
	tmpfile = NULL;
	out = fd >= 0 ? fdopen(fd, "w") : NULL;
    } else {
	tmpfile = bicat(unmeta(fn), ".new");
	if (unlink(tmpfile) < 0 && errno != ENOENT)
	    out = NULL;
	else {
	    struct stat sb;
	    int old_exists = stat(unmeta(fn), &sb) == 0;
	    uid_t euid = geteuid();

	    if (old_exists
#if defined HAVE_FCHMOD && defined HAVE_FCHOWN
	     && euid
#endif
	     && sb.st_uid != euid) {
		free(tmpfile);
		tmpfile = NULL;
		if (err) {
		    if (isset(APPENDHISTORY) || isset(INCAPPENDHISTORY)
		     || isset(INCAPPENDHISTORYTIME) || isset(SHAREHISTORY))
			zerr("rewriting %s would change its ownership -- skipped", fn);
		    else
			zerr("rewriting %s would change its ownership -- history not saved", fn);
		    err = 0; /* Don't report a generic error below. */
		}
		out = NULL;
	    } else {
		int fd = open(tmpfile, O_CREAT | O_WRONLY | O_EXCL, 0600);
		if (fd >=0) {
		    out = fdopen(fd, "w");
		    if (!out)
			close(fd);
		} else
		    out = NULL;
	    }

#ifdef HAVE_FCHMOD
	    if (old_exists && out) {
#ifdef HAVE_FCHOWN
		if (fchown(fileno(out), sb.st_uid, sb.st_gid) < 0) {} /* IGNORE FAILURE */
#endif
		if (fchmod(fileno(out), sb.st_mode) < 0) {} /* IGNORE FAILURE */
	    }
#endif
	}
    }
    if (out) {
	char *history_ignore;
	Patprog histpat = NULL;

	pushheap();

	if ((history_ignore = getsparam("HISTORY_IGNORE")) != NULL) {
	    tokenize(history_ignore = dupstring(history_ignore));
	    remnulargs(history_ignore);
	    histpat = patcompile(history_ignore, 0, NULL);
	}

	ret = 0;
	for (; he && he->histnum <= xcurhist; he = down_histent(he)) {
	    int end_backslashes = 0;

	    if ((writeflags & HFILE_SKIPDUPS && he->node.flags & HIST_DUP)
	     || (writeflags & HFILE_SKIPFOREIGN && he->node.flags & HIST_FOREIGN)
	     || he->node.flags & HIST_TMPSTORE)
		continue;
	    if (histpat &&
		pattry(histpat, metafy(he->node.nam, -1, META_HEAPDUP))) {
		continue;
	    }
	    if (writeflags & HFILE_SKIPOLD) {
		if (he->node.flags & (HIST_OLD|HIST_NOWRITE))
		    continue;
		he->node.flags |= HIST_OLD;
		if (writeflags & HFILE_USE_OPTIONS)
		    lasthist.next_write_ev = he->histnum + 1;
	    }
	    if (writeflags & HFILE_USE_OPTIONS) {
		lasthist.fpos = ftell(out);
		lasthist.stim = he->stim;
		histfile_linect++;
	    }
	    t = start = he->node.nam;
	    if (extended_history) {
		ret = fprintf(out, ": %ld:%ld;", (long)he->stim,
			      he->ftim? (long)(he->ftim - he->stim) : 0L);
	    } else if (*t == ':')
		ret = fputc('\\', out);

	    for (; ret >= 0 && *t; t++) {
		if (*t == '\n')
		    if ((ret = fputc('\\', out)) < 0)
			break;
		end_backslashes = (*t == '\\' || (end_backslashes && *t == ' '));
		if ((ret = fputc(*t, out)) < 0)
		    break;
	    }
	    if (ret < 0)
	    	break;
	    if (end_backslashes)
		ret = fputc(' ', out);
	    if (ret < 0 || (ret = fputc('\n', out)) < 0)
		break;
	}
	if (ret >= 0 && start && writeflags & HFILE_USE_OPTIONS) {
	    struct stat sb;
	    if ((ret = fflush(out)) >= 0) {
		if (fstat(fileno(out), &sb) == 0) {
		    lasthist.fsiz = sb.st_size;
		    lasthist.mtim = sb.st_mtime;
		}
		zsfree(lasthist.text);
		lasthist.text = ztrdup(start);
	    }
	}
	if (fclose(out) < 0 && ret >= 0)
	    ret = -1;
	if (ret >= 0) {
	    if (tmpfile) {
		if (rename(tmpfile, unmeta(fn)) < 0) {
		    zerr("can't rename %s.new to $HISTFILE", fn);
		    ret = -1;
		    err = 0;
#ifdef HAVE_FCNTL_H
		} else {
		    /* We renamed over the locked HISTFILE, so close fd.
		     * If we do more writing, we'll get a lock then. */
		    if (flock_fd >= 0) {
			close(flock_fd);
			flock_fd = -1;
		    }
#endif
		}
	    }

	    if (ret >= 0 && writeflags & HFILE_SKIPOLD
		&& !(writeflags & (HFILE_FAST | HFILE_NO_REWRITE))) {
		int remember_histactive = histactive;

		/* Zeroing histactive avoids unnecessary munging of curline. */
		histactive = 0;
		/* The NULL leaves HISTFILE alone, preserving fn's value. */
		pushhiststack(NULL, savehistsiz, savehistsiz, -1);

		hist_ignore_all_dups |= isset(HISTSAVENODUPS);
		readhistfile(fn, err, 0);
		hist_ignore_all_dups = isset(HISTIGNOREALLDUPS);
		if (errflag & ERRFLAG_INT)
		    ret = -1;
		else if (histlinect)
		    savehistfile(fn, err, 0);

		pophiststack();
		histactive = remember_histactive;
	    }
	}

	popheap();
    } else
	ret = -1;

    if (ret < 0 && err) {
	if (tmpfile)
	    zerr("failed to write history file %s.new: %e", fn, errno);
	else
	    zerr("failed to write history file %s: %e", fn, errno);
    }
    if (tmpfile)
	free(tmpfile);

    unlockhistfile(fn);
}

static int lockhistct;

static int
checklocktime(char *lockfile, long *sleep_usp, time_t then)
{
    time_t now = zmonotime(NULL);

    if (now + 10 < then) {
	/* File is more than 10 seconds in the future? */
	errno = EEXIST;
	return -1;
    }

    if (now - then < 10) {
	/*
	 * To give the effect of a gradually increasing backoff,
	 * we'll sleep a period based on the time we've spent so far.
	 */
	DPUTS(now < then, "time flowing backwards through history");
	/*
	 * Randomise to minimise clashes with shells exiting at the same
	 * time.
	 */
	(void)zsleep_random(*sleep_usp, then + 10);
	*sleep_usp <<= 1;
    } else
	unlink(lockfile);

    return 0;
}

/*
 * Lock history file.  Return 0 on success, 1 on failure to lock this
 * time, 2 on permanent failure (e.g. permission).
 */

/**/
int
lockhistfile(char *fn, int keep_trying)
{
    int ct = lockhistct;
    int ret = 0;
    long sleep_us = 0x10000; /* about 67 ms */

    if (!fn && !(fn = getsparam("HISTFILE")))
	return 1;

    if (!lockhistct++) {
	struct stat sb;
	int fd;
	char *lockfile;
#ifdef HAVE_LINK
# ifdef HAVE_SYMLINK
	char pidbuf[32], *lnk;
# else
	char *tmpfile;
# endif
#endif

#ifdef HAVE_FCNTL_H
	if (isset(HISTFCNTLLOCK))
	    return flockhistfile(fn, keep_trying);
#endif

	lockfile = bicat(unmeta(fn), ".LOCK");
	/* NOTE: only use symlink locking on a link()-having host in order to
	 * avoid a change from open()-based locking to symlink()-based. */
#ifdef HAVE_LINK
# ifdef HAVE_SYMLINK
	sprintf(pidbuf, "/pid-%ld/host-", (long)mypid);
	lnk = getsparam("HOST");
	lnk = bicat(pidbuf, lnk ? lnk : "");
	/* We'll abuse fd as our success flag. */
	while ((fd = symlink(lnk, lockfile)) < 0) {
	    if (errno != EEXIST) {
		ret = 2;
		break;
	    } else if (!keep_trying) {
		ret = 1;
		break;
	    }
	    if (lstat(lockfile, &sb) < 0) {
		if (errno == ENOENT)
		    continue;
		break;
	    }
	    if (checklocktime(lockfile, &sleep_us, sb.st_mtime) < 0) {
		ret = 1;
		break;
	    }
	}
	if (fd < 0)
	    lockhistct--;
	free(lnk);
# else /* not HAVE_SYMLINK */
	if ((fd = gettempfile(fn, 0, &tmpfile)) >= 0) {
	    FILE *out = fdopen(fd, "w");
	    if (out) {
		fprintf(out, "%ld %s\n", (long)getpid(), getsparam("HOST"));
		fclose(out);
	    } else
		close(fd);
	    while (link(tmpfile, lockfile) < 0) {
		if (errno != EEXIST) {
		    ret = 2;
		    break;
		} else if (!keep_trying) {
		    ret = 1;
		    break;
		} else if (lstat(lockfile, &sb) < 0) {
		    if (errno == ENOENT)
			continue;
		    ret = 2;
		} else {
		    if (checklocktime(lockfile, &sleep_us, sb.st_mtime) < 0) {
			ret = 1;
			break;
		    }
		    continue;
		}
		lockhistct--;
		break;
	    }
	    unlink(tmpfile);
	    free(tmpfile);
	}
# endif /* not HAVE_SYMLINK */
#else /* not HAVE_LINK */
	while ((fd = open(lockfile, O_WRONLY|O_CREAT|O_EXCL, 0644)) < 0) {
	    if (errno != EEXIST) {
		ret = 2;
		break;
	    } else if (!keep_trying) {
		ret = 1;
		break;
	    }
	    if (lstat(lockfile, &sb) < 0) {
		if (errno == ENOENT)
		    continue;
		ret = 2;
		break;
	    }
	    if (checklocktime(lockfile, &sleep_us, sb.st_mtime) < 0) {
		ret = 1;
		break;
	    }
	}
	if (fd < 0)
	    lockhistct--;
	else {
	    FILE *out = fdopen(fd, "w");
	    if (out) {
		fprintf(out, "%ld %s\n", (long)mypid, getsparam("HOST"));
		fclose(out);
	    } else
		close(fd);
	}
#endif /* not HAVE_LINK */
	free(lockfile);
    }

    if (ct == lockhistct) {
#ifdef HAVE_FCNTL_H
	if (flock_fd >= 0) {
	    close(flock_fd);
	    flock_fd = -1;
	}
#endif
	DPUTS(ret == 0, "BUG: return value non-zero on locking error");
	return ret;
    }
    return 0;
}

/* Unlock the history file if this corresponds to the last nested lock
 * request.  If we don't have the file locked, just return.
 */

/**/
void
unlockhistfile(char *fn)
{
    if (!fn && !(fn = getsparam("HISTFILE")))
	return;
    if (--lockhistct) {
	if (lockhistct < 0)
	    lockhistct = 0;
    }
    else {
	char *lockfile;
	fn = unmeta(fn);
	lockfile = zalloc(strlen(fn) + 5 + 1);
	sprintf(lockfile, "%s.LOCK", fn);
	unlink(lockfile);
	free(lockfile);
#ifdef HAVE_FCNTL_H
	if (flock_fd >= 0) {
	    close(flock_fd);
	    flock_fd = -1;
	}
#endif
    }
}

/**/
int
histfileIsLocked(void)
{
    return lockhistct > 0;
}

/*
 * Get the words in the current buffer. Using the lexer. 
 *
 * As far as I can make out, this is a gross hack based on a gross hack.
 * When analysing lines from within zle, we tweak the metafied line
 * positions (zlemetall and zlemetacs) directly in the lexer.  That's
 * bad enough, but this function appears to be designed to be called
 * from outside zle, pretending to be in zle and calling out, so
 * we set zlemetall and zlemetacs locally and copy the current zle line,
 * which may not even be valid at this point.
 *
 * However, I'm so confused it could simply be baking Bakewell tarts.
 *
 * list may be an existing linked list (off the heap), in which case
 * it will be appended to; otherwise it will be created.
 *
 * If buf is set we will take input from that string, else we will
 * attempt to use ZLE directly in a way they tell you not to do on all
 * programming courses.
 *
 * If index is non-NULL, and input is from a string in ZLE, *index
 * is set to the position of the end of the current editor word.
 *
 * flags is passed directly to lexflags, see lex.c, except that
 * we 'or' in the bit LEXFLAGS_ACTIVE to make sure the variable
 * is set.
 */

/**/
mod_export LinkList
bufferwords(LinkList list, char *buf, int *index, int flags)
{
    int num = 0, cur = -1, got = 0, ne = noerrs;
    int owb = wb, owe = we, oadx = addedx, onc = nocomments;
    int ona = noaliases, ocs = zlemetacs, oll = zlemetall;
    int forloop = 0, rcquotes = opts[RCQUOTES];
    int envarray = 0;
    char *p, *addedspaceptr;

    if (!list)
	list = newlinklist();

    /*
     * With RC_QUOTES, 'foo '' bar' comes back as 'foo ' bar'.  That's
     * not very useful.  As nothing in here requires the fully processed
     * string expression, we just turn the option off for this function.
     */
    opts[RCQUOTES] = 0;
    addedx = 0;
    noerrs = 1;
    zcontext_save();
    lexflags = flags | LEXFLAGS_ACTIVE;
    /*
     * Are we handling comments?
     */
    nocomments = !(flags & (LEXFLAGS_COMMENTS_KEEP|
			    LEXFLAGS_COMMENTS_STRIP));
    if (buf) {
	int l = strlen(buf);

	p = (char *) zhalloc(l + 2);
	memcpy(p, buf, l);
	/*
	 * I'm sure this space is here for a reason, but it's
	 * a pain in the neck:  when we get back a string that's
	 * not finished it's very hard to tell if a space at the
	 * end is this one or not.  We use two tricks below to
	 * work around this.
	 */
	addedspaceptr = p + l;
	*addedspaceptr = ' ';
	addedspaceptr[1] = '\0';
	inpush(p, 0, NULL);
	zlemetall = strlen(p) ;
	zlemetacs = zlemetall + 1;
    } else {
	int ll, cs;
	char *linein;

	linein = zleentry(ZLE_CMD_GET_LINE, &ll, &cs);
	zlemetall = ll + 1; /* length of line plus space added below */
	zlemetacs = cs;

	if (!isfirstln && chline) {
	    p = (char *) zhalloc(hptr - chline + ll + 2);
	    memcpy(p, chline, hptr - chline);
	    memcpy(p + (hptr - chline), linein, ll);
	    addedspaceptr = p + (hptr - chline) + ll;
	    *addedspaceptr = ' ';
	    addedspaceptr[1] = '\0';
	    inpush(p, 0, NULL);

	    /*
	     * advance line length and character position over
	     * prepended string.
	     */
	    zlemetall += hptr - chline;
	    zlemetacs += hptr - chline;
	} else {
	    p = (char *) zhalloc(ll + 2);
	    memcpy(p, linein, ll);
	    addedspaceptr = p + ll;
	    *addedspaceptr = ' ';
	    p[zlemetall] = '\0';
	    inpush(p, 0, NULL);
	}
	zsfree(linein);
    }
    if (zlemetacs)
	zlemetacs--;
    strinbeg(0);
    noaliases = 1;
    do {
	if (incond)
	    incond = 1 + (tok != DINBRACK && tok != INPAR &&
			  tok != DBAR && tok != DAMPER &&
			  tok != BANG);
	ctxtlex();
	if (tok == ENDINPUT || tok == LEXERR)
	    break;
	/*
	 * After an array assignment, return to the initial
	 * start-of-command state.  There could be a second ENVARRAY.
	 */
	if (tok == OUTPAR && envarray) {
	    incmdpos = 1;
	    envarray = 0;
	}
	if (tok == FOR) {
	    /*
	     * The way for (( expr1 ; expr2; expr3 )) is parsed is:
	     * - a FOR tok
	     * - a DINPAR with no tokstr
	     * - two DINPARS with tokstr's expr1, expr2.
	     * - a DOUTPAR with tokstr expr3.
	     *
	     * We'll decrement the variable forloop as we verify
	     * the various stages.
	     *
	     * Don't ask me, ma'am, I'm just the programmer.
	     */
	    forloop = 5;
	} else {
	    switch (forloop) {
	    case 1:
		if (tok != DOUTPAR)
		    forloop = 0;
		break;

	    case 2:
	    case 3:
	    case 4:
		if (tok != DINPAR)
		    forloop = 0;
		break;

	    default:
		/* nothing to do */
		break;
	    }
	}
	if (tokstr) {
	    switch (tok) {
	    case ENVARRAY:
		p = dyncat(tokstr, "=(");
		envarray = 1;
		break;

	    case DINPAR:
		if (forloop) {
		    /* See above. */
		    p = dyncat(tokstr, ";");
		} else {
		    /*
		     * Mathematical expressions analysed as a single
		     * word.  That's correct because it behaves like
		     * double quotes.  Whitespace in the middle is
		     * similarly retained, so just add the parentheses back.
		     */
		    p = zhtricat("((", tokstr, "))");
		}
		break;

	    default:
		p = dupstring(tokstr);
		break;
	    }
	    if (*p) {
		untokenize(p);
		if (ingetptr() == addedspaceptr + 1) {
		    /*
		     * Whoops, we've read past the space we added, probably
		     * because we were expecting a terminator but when
		     * it didn't turn up we shrugged our shoulders thinking
		     * it might as well be a complete string anyway.
		     * So remove the space.  C.f. below for the case
		     * where the missing terminator caused a lex error.
		     * We use the same paranoid test.
		     */
		    int plen = strlen(p);
		    if (plen && p[plen-1] == ' ' &&
			(plen == 1 || p[plen-2] != Meta))
			p[plen-1] = '\0';
		}
		addlinknode(list, p);
		num++;
	    }
	} else if (buf) {
	    if (IS_REDIROP(tok) && tokfd >= 0) {
		char b[20];
		int l = sprintf(b, "%d%s", tokfd, tokstrings[tok]);
		addlinknode(list, dupstring_wlen(b, l));
		num++;
	    } else if (tok != NEWLIN) {
		addlinknode(list, dupstring(tokstrings[tok]));
		num++;
	    }
	}
	if (forloop) {
	    if (forloop == 1) {
		/*
		 * Final "))" of for loop to match opening,
		 * since we've just added the preceding element.
 		 */
		addlinknode(list, dupstring("))"));
	    }
	    forloop--;
	}
	if (!got && !lexflags) {
	    got = 1;
	    cur = num - 1;
	}
    } while (tok != ENDINPUT && tok != LEXERR && !(errflag & ERRFLAG_INT));
    if (buf && tok == LEXERR && tokstr && *tokstr) {
	int plen;
	untokenize((p = dupstring(tokstr)));
	plen = strlen(p);
	/*
	 * Strip the space we added for lexing but which won't have
	 * been swallowed by the lexer because we aborted early.
	 * The test is paranoia.
	 */
	if (plen && p[plen-1] == ' ' && (plen == 1 || p[plen-2] != Meta))
	    p[plen - 1] = '\0';
	addlinknode(list, p);
	num++;
    }
    if (cur < 0 && num)
	cur = num - 1;
    noaliases = ona;
    strinend();
    inpop();
    errflag &= ~ERRFLAG_ERROR;
    nocomments = onc;
    noerrs = ne;
    zcontext_restore();
    zlemetacs = ocs;
    zlemetall = oll;
    wb = owb;
    we = owe;
    addedx = oadx;
    opts[RCQUOTES] = rcquotes;

    if (index)
	*index = cur;

    return list;
}

/*
 * Split up a line into words for use in a history file.
 *
 * lineptr is the line to be split.
 *
 * *wordsp and *nwordsp are an array already allocated to hold words
 * and its length.  The array holds both start and end positions,
 * so *nwordsp actually counts twice the number of words in the
 * original string.  *nwordsp may be zero in which case the array
 * will be allocated.
 *
 * *nwordposp returns the used length of *wordsp in the same units as
 * *nwordsp, i.e. twice the number of words in the input line.
 *
 * If uselex is 1, attempt to do this using the lexical analyser.
 * This is more accurate, but slower; for reading history files it's
 * controlled by the option HISTLEXWORDS.  If this failed (which
 * indicates a bug in the shell) it falls back to whitespace-separated
 * strings, printing a message if in debug mode.
 *
 * If uselex is 0, just look for whitespace-separated words; the only
 * special handling is for a backslash-newline combination as used
 * by the history file format to save multiline buffers.
 */
/**/
mod_export void
histsplitwords(char *lineptr, short **wordsp, int *nwordsp, int *nwordposp,
	       int uselex)
{
    int nwords = *nwordsp, nwordpos = 0;
    short *words = *wordsp;
    char *start = lineptr;

    if (uselex) {
	LinkList wordlist;
	LinkNode wordnode;
	int nwords_max;

	wordlist = bufferwords(NULL, lineptr, NULL,
			       LEXFLAGS_COMMENTS_KEEP);
	if (errflag)
	    return;
	nwords_max = 2 * countlinknodes(wordlist);
	if (nwords_max > nwords) {
	    *nwordsp = nwords = nwords_max;
	    *wordsp = words = (short *)zrealloc(words, nwords*sizeof(short));
	}
	for (wordnode = firstnode(wordlist);
	     wordnode;
	     incnode(wordnode)) {
	    char *word = getdata(wordnode);
	    char *lptr, *wptr = word;
	    int loop_next = 0, skipping;

	    /* Skip stuff at the start of the word */
	    for (;;) {
		/*
		 * Not really an oddity: "\\\n" is
		 * removed from input as if whitespace.
		 */
		if (inblank(*lineptr))
		    lineptr++;
		else if (lineptr[0] == '\\' && lineptr[1] == '\n') {
		    /*
		     * Optimisation: we handle this in the loop below,
		     * too.
		     */
		    lineptr += 2;
		} else
		    break;
	    }
	    lptr = lineptr;
	    /*
	     * Skip chunks of word with possible intervening
	     * backslash-newline.
	     *
	     * To get round C's annoying lack of ability to
	     * reference the outer loop, we'll break from this
	     * one with
	     * loop_next = 0: carry on as normal
	     * loop_next = 1: break from outer loop
	     * loop_next = 2: continue round outer loop.
	     */
	    do {
		skipping = 0;
		if (strpfx(wptr, lptr)) {
		    /*
		     * Normal case: word from lexer matches start of
		     * string from line.  Just advance over it.
		     */
		    int len;
		    if (!strcmp(wptr, ";") && strpfx(";;", lptr)) {
			/*
			 * Don't get confused between a semicolon that's
			 * probably really a newline and a double
			 * semicolon that's terminating a case.
			 */
			loop_next = 2;
			break;
		    }
		    len = strlen(wptr);
		    lptr += len;
		    wptr += len;
		} else {
		    /*
		     * Didn't get to the end of the word.
		     * See what's amiss.
		     */
		    int bad = 0;
		    /*
		     * Oddity 1: newlines turn into semicolons.
		     */
		    if (!strcmp(wptr, ";"))
		    {
			loop_next = 2;
			break;
		    }
		    while (*lptr) {
			if (!*wptr) {
			    /*
			     * End of the word before the end of the
			     * line: not good.
			     */
			    bad = 1;
			    loop_next = 1;
			    break;
			}
			/*
			 * Oddity 2: !'s turn into |'s.
			 */
			if (*lptr == *wptr ||
			    (*lptr == '!' && *wptr == '|')) {
			    lptr++;
			    if (!*++wptr)
				break;
			} else if (lptr[0] == '\\' &&
				   lptr[1] == '\n') {
			    /*
			     * \\\n can occur in the middle of a word;
			     * wptr is already pointing at this, we
			     * just need to skip over the break
			     * in lptr and look at the next chunk.
			     */
			    lptr += 2;
			    skipping = 1;
			    break;
			} else {
			    bad = 1;
			    loop_next = 1;
			    break;
			}
		    }
		    if (bad) {
#ifdef DEBUG
			dputs(ERRMSG("bad wordsplit reading history: "
				     "%s\nat: %s\nword: %s"),
			      start, lineptr, word);
#endif
			lineptr = start;
			nwordpos = 0;
			uselex = 0;
			loop_next = 1;
		    }
		}
	    } while (skipping);
	    if (loop_next) {
		if (loop_next == 1)
		    break;
		continue;
	    }
	    /* Record position of current word... */
	    words[nwordpos++] = lineptr - start;
	    words[nwordpos++] = lptr - start;

	    /* ready for start of next word. */
	    lineptr = lptr;
	}
    }
    if (!uselex) {
	do {
	    for (;;) {
		if (inblank(*lineptr))
		    lineptr++;
		else if (lineptr[0] == '\\' && lineptr[1] == '\n')
		    lineptr += 2;
		else
		    break;
	    }
	    if (*lineptr) {
		if (nwordpos >= nwords) {
		    *nwordsp = nwords = nwords + 64;
		    *wordsp = words = (short *)
			zrealloc(words, nwords*sizeof(*words));
		}
		words[nwordpos++] = lineptr - start;
		while (*lineptr) {
		    if (*lineptr == Meta && lineptr[1])
			lineptr += 2;
		    else if (!inblank(*lineptr))
			lineptr++;
		    else
			break;
		}
		words[nwordpos++] = lineptr - start;
	    }
	} while (*lineptr);
    }

    *nwordposp = nwordpos;
}

/* Move the current history list out of the way and prepare a fresh history
 * list using hf for HISTFILE, hs for HISTSIZE, and shs for SAVEHIST.  If
 * the hf value is an empty string, HISTFILE will be unset from the new
 * environment; if it is NULL, HISTFILE will not be changed, not even by the
 * pop function (this functionality is used internally to rewrite the current
 * history file without affecting pointers into the environment).
 */

/**/
int
pushhiststack(char *hf, zlong hs, zlong shs, int level)
{
    struct histsave *h;
    int curline_in_ring = (histactive & HA_ACTIVE) && hist_ring == &curline;

    if (histsave_stack_pos == histsave_stack_size) {
	histsave_stack_size += 5;
	histsave_stack = zrealloc(histsave_stack,
			    histsave_stack_size * sizeof (struct histsave));
    }

    if (curline_in_ring)
	unlinkcurline();

    h = &histsave_stack[histsave_stack_pos++];

    h->lasthist = lasthist;
    if (hf) {
	if ((h->histfile = getsparam("HISTFILE")) != NULL && *h->histfile)
	    h->histfile = ztrdup(h->histfile);
	else
	    h->histfile = "";
    } else
	h->histfile = NULL;
    h->histtab = histtab;
    h->hist_ring = hist_ring;
    h->curhist = curhist;
    h->histlinect = histlinect;
    h->histsiz = histsiz;
    h->savehistsiz = savehistsiz;
    h->locallevel = level;

    memset(&lasthist, 0, sizeof lasthist);
    if (hf) {
	if (*hf)
	    setsparam("HISTFILE", ztrdup(hf));
	else
	    unsetparam("HISTFILE");
    }
    hist_ring = NULL;
    curhist = histlinect = 0;
    if (zleactive)
	zleentry(ZLE_CMD_SET_HIST_LINE, curhist);
    histsiz = hs;
    savehistsiz = shs;
    inithist(); /* sets histtab */

    if (curline_in_ring)
	linkcurline();

    return histsave_stack_pos;
}


/**/
int
pophiststack(void)
{
    struct histsave *h;
    int curline_in_ring = (histactive & HA_ACTIVE) && hist_ring == &curline;

    if (histsave_stack_pos == 0)
	return 0;

    if (curline_in_ring)
	unlinkcurline();

    deletehashtable(histtab);
    zsfree(lasthist.text);

    h = &histsave_stack[--histsave_stack_pos];

    lasthist = h->lasthist;
    if (h->histfile) {
	if (*h->histfile)
	    setsparam("HISTFILE", h->histfile);
	else
	    unsetparam("HISTFILE");
    }
    histtab = h->histtab;
    hist_ring = h->hist_ring;
    curhist = h->curhist;
    if (zleactive)
	zleentry(ZLE_CMD_SET_HIST_LINE, curhist);
    histlinect = h->histlinect;
    histsiz = h->histsiz;
    savehistsiz = h->savehistsiz;

    if (curline_in_ring)
	linkcurline();

    return histsave_stack_pos + 1;
}

/* If pop_through > 0, pop all array items >= the 1-relative index value.
 * If pop_through <= 0, pop (-1)*pop_through levels off the stack.
 * If the (new) top of stack is from a higher locallevel, auto-pop until
 * it is not.
 */

/**/
int
saveandpophiststack(int pop_through, int writeflags)
{
    if (pop_through <= 0) {
	pop_through += histsave_stack_pos + 1;
	if (pop_through <= 0)
	    pop_through = 1;
    }
    while (pop_through > 1
     && histsave_stack[pop_through-2].locallevel > locallevel)
	pop_through--;
    if (histsave_stack_pos < pop_through)
	return 0;
    do {
	if (!nohistsave)
	    savehistfile(NULL, 1, writeflags);
	pophiststack();
    } while (histsave_stack_pos >= pop_through);
    return 1;
}