/*

 * 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"

#ifdef __SYMBIAN32__

#ifdef __WINSCW__

#pragma warn_unusedarg off

#pragma warn_possunwant off

#endif//__WINSCW__

#endif//__SYMBIAN32__

/* 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 (*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().

 */

/**/

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_NOSTORE	(1<<1)	/* Don't store the line when finished */

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

/* 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;

/* pointer into the history line */

/**/

mod_export char *hptr;

/* the current history line */

/**/

mod_export char *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;

/* 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)) {

	/* 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 mecessary (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--;

	spaceinline(1);

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

    }

    if (excs > cs) {

	excs += 1 + inbufct - exlast;

	if (excs < cs)

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

	     * so rare that it does not worth it              */

	    excs = cs;

    }

    exlast = inbufct;

    spaceinline(1);

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

}

static int

ihgetc(void)

{

    int c = ingetc();

    qbang = 0;

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

	/* If necessary, expand history characters. */

	c = histsubchar(c);

	if (c < 0) {

	    /* bad expansion */

	    errflag = lexstop = 1;

	    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 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();

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

	hwaddc(ingetc());

}

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

/**/

static int

getsubsargs(char *subline)

{

    int del;

    char *ptr1, *ptr2;

    del = ingetc();

    ptr1 = hdynread2(del);

    if (!ptr1)

	return 1;

    ptr2 = hdynread2(del);

    if (strlen(ptr1)) {

	zsfree(hsubl);

	hsubl = ptr1;

    }

    zsfree(hsubr);

    hsubr = ptr2;

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

	herrflush();

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

	return 1;

    }

    return 0;

}

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

/**/

static int

getargc(Histent ehist)

{

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

}

/* 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[256], *ptr;

    char *sline;

    Histent ehist;

    /* look, no goto's */

    if (isfirstch && c == hatchar) {

	/* Line begins ^foo^bar */

	isfirstch = 0;

	inungetc(hatchar);

	if (!(ehist = gethist(defev))

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

	    || getsubsargs(sline) || !hsubl)

	    return -1;

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

    } else {

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

	if (c != ' ')

	    isfirstch = 0;

#ifndef __SYMBIAN32__	

	if (c == '\\') {

	    int g = ingetc();

	    if (g != bangchar)

		safeinungetc(g);

	    else {

		qbang = 1;

		return bangchar;

	    }

	}

#endif //__SYMBIAN32__	

	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;

	/* get event number */

	queue_signals();

	if (c == '?') {

	    for (;;) {

		c = ingetc();

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

		    break;

		else

		    *ptr++ = c;

	    }

	    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, 0);

		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 (c == '#' || c == bangchar) {

		    c = ingetc();

		    break;

		}

		c = ingetc();

	    }

	    *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, 0);

		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", NULL, 0);

		    return -1;

		}

	    }

	}

	if (c == '*') {

	    farg = 1;

	    larg = argc;

	    cflag = 0;

	} else {

	    inungetc(c);