// lex.c - lexical analysis

//

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

//

/*

 * 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 "lex.pro"

#ifdef __SYMBIAN32__

#ifdef __WINSCW__

#pragma warn_unusedarg off

#pragma warn_possunwant off

#endif//__WINSCW__

#endif//__SYMBIAN32__

/* tokens */

/**/

mod_export char ztokens[] = "#$^*()$=|{}[]`<>?~`,'\"\\";

/* parts of the current token */

/**/

char *yytext;

/**/

mod_export char *tokstr;

/**/

mod_export int tok;

/**/

mod_export int tokfd;

/* lexical analyzer error flag */

/**/

mod_export int lexstop;

/* if != 0, this is the first line of the command */

/**/

mod_export int isfirstln;

/* if != 0, this is the first char of the command (not including white space) */

/**/

int isfirstch;

/* flag that an alias should be expanded after expansion ending in space */

/**/

int inalmore;

/* don't do spelling correction */

/**/

int nocorrect;

/* the line buffer */

/**/

mod_export unsigned char *line;

/* cursor position and line length */

/* N.B.: must use the real names here, for the .export file */

/**/

mod_export int zshcs, zshll;

/* inwhat says what exactly we are in     *

 * (its value is one of the IN_* things). */

/**/

mod_export int inwhat;

/* 1 if x added to complete in a blank between words */

/**/

mod_export int addedx;

/* wb and we hold the beginning/end position of the word we are completing. */

/**/

mod_export int wb, we;

/* 1 if aliases should not be expanded */

/**/

mod_export int noaliases;

/* we are parsing a line sent to use by the editor */

/**/

mod_export int zleparse;

/**/

mod_export int wordbeg;

/**/

mod_export int parbegin;

/**/

mod_export int parend;

/* don't recognize comments */

/**/

mod_export int nocomments;

/* text of punctuation tokens */

/**/

mod_export char *tokstrings[WHILE + 1] = {

    NULL,	/* NULLTOK	  0  */

    ";",	/* SEPER	     */

    "\\n",	/* NEWLIN	     */

    ";",	/* SEMI		     */

    ";;",	/* DSEMI	     */

    "&",	/* AMPER	  5  */

    "(",	/* INPAR	     */

    ")",	/* OUTPAR	     */

    "||",	/* DBAR		     */

    "&&",	/* DAMPER	     */

    ">",	/* OUTANG	  10 */

    ">|",	/* OUTANGBANG	     */

    ">>",	/* DOUTANG	     */

    ">>|",	/* DOUTANGBANG	     */

    "<",	/* INANG	     */

    "<>",	/* INOUTANG	  15 */

    "<<",	/* DINANG	     */

    "<<-",	/* DINANGDASH	     */

    "<&",	/* INANGAMP	     */

    ">&",	/* OUTANGAMP	     */

    "&>",	/* AMPOUTANG	  20 */

    "&>|",	/* OUTANGAMPBANG     */

    ">>&",	/* DOUTANGAMP	     */

    ">>&|",	/* DOUTANGAMPBANG    */

    "<<<",	/* TRINANG	     */

    "|",	/* BAR		  25 */

    "|&",	/* BARAMP	     */

    "()",	/* INOUTPAR	     */

    "((",	/* DINPAR	     */

    "))",	/* DOUTPAR	     */

    "&|",	/* AMPERBANG	  30 */

    ";&",	/* SEMIAMP	     */

};

/* lexical state */

static int dbparens;

static int len = 0, bsiz = 256;

static char *bptr;

struct lexstack {

    struct lexstack *next;

    int incmdpos;

    int incond;

    int incasepat;

    int dbparens;

    int isfirstln;

    int isfirstch;

    int histactive;

    int histdone;

    int stophist;

    int hlinesz;

    char *hline;

    char *hptr;

    int tok;

    int isnewlin;

    char *tokstr;

    char *yytext;

    char *bptr;

    int bsiz;

    int len;

    short *chwords;

    int chwordlen;

    int chwordpos;

    int hwgetword;

    int lexstop;

    struct heredocs *hdocs;

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

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

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

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

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

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

    int eclen, ecused, ecnpats;

    Wordcode ecbuf;

    Eccstr ecstrs;

    int ecsoffs, ecssub, ecnfunc;

    unsigned char *cstack;

    int csp;

};

static struct lexstack *lstack = NULL;

/* save the lexical state */

/* is this a hack or what? */

/**/

mod_export void

lexsave(void)

{

    struct lexstack *ls;

    ls = (struct lexstack *)malloc(sizeof(struct lexstack));

    ls->incmdpos = incmdpos;

    ls->incond = incond;

    ls->incasepat = incasepat;

    ls->dbparens = dbparens;

    ls->isfirstln = isfirstln;

    ls->isfirstch = isfirstch;

    ls->histactive = histactive;

    ls->histdone = histdone;

    ls->stophist = stophist;

    ls->hline = chline;

    ls->hptr = hptr;

    ls->hlinesz = hlinesz;

    ls->cstack = cmdstack;

    ls->csp = cmdsp;

    cmdstack = (unsigned char *)zalloc(CMDSTACKSZ);

    ls->tok = tok;

    ls->isnewlin = isnewlin;

    ls->tokstr = tokstr;

    ls->yytext = yytext;

    ls->bptr = bptr;

    ls->bsiz = bsiz;

    ls->len = len;

    ls->chwords = chwords;

    ls->chwordlen = chwordlen;

    ls->chwordpos = chwordpos;

    ls->hwgetword = hwgetword;

    ls->lexstop = lexstop;

    ls->hdocs = hdocs;

    ls->hgetc = hgetc;

    ls->hungetc = hungetc;

    ls->hwaddc = hwaddc;

    ls->hwbegin = hwbegin;

    ls->hwend = hwend;

    ls->addtoline = addtoline;

    ls->eclen = eclen;

    ls->ecused = ecused;

    ls->ecnpats = ecnpats;

    ls->ecbuf = ecbuf;

    ls->ecstrs = ecstrs;

    ls->ecsoffs = ecsoffs;

    ls->ecssub = ecssub;

    ls->ecnfunc = ecnfunc;

    cmdsp = 0;

    inredir = 0;

    hdocs = NULL;

    histactive = 0;

    ecbuf = NULL;

    ls->next = lstack;

    lstack = ls;

}

/* restore lexical state */

/**/

mod_export void

lexrestore(void)

{

    struct lexstack *ln;

    DPUTS(!lstack, "BUG: lexrestore() without lexsave()");

    incmdpos = lstack->incmdpos;

    incond = lstack->incond;

    incasepat = lstack->incasepat;

    dbparens = lstack->dbparens;

    isfirstln = lstack->isfirstln;

    isfirstch = lstack->isfirstch;

    histactive = lstack->histactive;

    histdone = lstack->histdone;

    stophist = lstack->stophist;

    chline = lstack->hline;

    hptr = lstack->hptr;

    if (cmdstack)

	free(cmdstack);

    cmdstack = lstack->cstack;

    cmdsp = lstack->csp;

    tok = lstack->tok;

    isnewlin = lstack->isnewlin;

    tokstr = lstack->tokstr;

    yytext = lstack->yytext;

    bptr = lstack->bptr;

    bsiz = lstack->bsiz;

    len = lstack->len;

    chwords = lstack->chwords;

    chwordlen = lstack->chwordlen;

    chwordpos = lstack->chwordpos;

    hwgetword = lstack->hwgetword;

    lexstop = lstack->lexstop;

    hdocs = lstack->hdocs;

    hgetc = lstack->hgetc;

    hungetc = lstack->hungetc;

    hwaddc = lstack->hwaddc;

    hwbegin = lstack->hwbegin;

    hwend = lstack->hwend;

    addtoline = lstack->addtoline;

    if (ecbuf)

	zfree(ecbuf, eclen);

    eclen = lstack->eclen;

    ecused = lstack->ecused;

    ecnpats = lstack->ecnpats;

    ecbuf = lstack->ecbuf;

    ecstrs = lstack->ecstrs;

    ecsoffs = lstack->ecsoffs;

    ecssub = lstack->ecssub;

    ecnfunc = lstack->ecnfunc;

    hlinesz = lstack->hlinesz;

    errflag = 0;

    ln = lstack->next;

    free(lstack);

    lstack = ln;

}

/**/

void

yylex(void)

{

    if (tok == LEXERR)

	return;

    do

	tok = gettok();

    while (tok != ENDINPUT && exalias());

    if (tok == NEWLIN || tok == ENDINPUT) {

	while (hdocs) {

	    struct heredocs *next = hdocs->next;

	    char *name;

	    hwbegin(0);

	    cmdpush(hdocs->type == REDIR_HEREDOC ? CS_HEREDOC : CS_HEREDOCD);

	    STOPHIST

	    name = gethere(hdocs->str, hdocs->type);

	    ALLOWHIST

	    cmdpop();

	    hwend();

	    setheredoc(hdocs->pc, REDIR_HERESTR, name);

	    zfree(hdocs, sizeof(struct heredocs));

	    hdocs = next;

	}

    }

    if (tok != NEWLIN)

	isnewlin = 0;

    else

	isnewlin = (inbufct) ? -1 : 1;

    if (tok == SEMI || tok == NEWLIN)

	tok = SEPER;

}

/**/

mod_export void

ctxtlex(void)

{

    static int oldpos;

    yylex();

    switch (tok) {

    case SEPER:

    case NEWLIN:

    case SEMI:

    case DSEMI:

    case SEMIAMP:

    case AMPER:

    case AMPERBANG:

    case INPAR:

    case INBRACE:

    case DBAR:

    case DAMPER:

    case BAR:

    case BARAMP:

    case INOUTPAR:

    case DOLOOP:

    case THEN:

    case ELIF:

    case ELSE:

    case DOUTBRACK:

	incmdpos = 1;

	break;

    case STRING:

 /* case ENVSTRING: */

    case ENVARRAY:

    case OUTPAR:

    case CASE:

    case DINBRACK:

	incmdpos = 0;

	break;

    }

    if (tok != DINPAR)

	infor = tok == FOR ? 2 : 0;

    if (IS_REDIROP(tok) || tok == FOR || tok == FOREACH || tok == SELECT) {

	inredir = 1;

	oldpos = incmdpos;

	incmdpos = 0;

    } else if (inredir) {

	incmdpos = oldpos;

	inredir = 0;

    }

}

#define LX1_BKSLASH 0

#define LX1_COMMENT 1

#define LX1_NEWLIN 2

#define LX1_SEMI 3

#define LX1_AMPER 5

#define LX1_BAR 6

#define LX1_INPAR 7

#define LX1_OUTPAR 8

#define LX1_INANG 13

#define LX1_OUTANG 14

#define LX1_OTHER 15

#define LX2_BREAK 0

#define LX2_OUTPAR 1

#define LX2_BAR 2

#define LX2_STRING 3

#define LX2_INBRACK 4

#define LX2_OUTBRACK 5

#define LX2_TILDE 6

#define LX2_INPAR 7

#define LX2_INBRACE 8

#define LX2_OUTBRACE 9

#define LX2_OUTANG 10

#define LX2_INANG 11

#define LX2_EQUALS 12

#define LX2_BKSLASH 13

#define LX2_QUOTE 14

#define LX2_DQUOTE 15

#define LX2_BQUOTE 16

#define LX2_COMMA 17

#define LX2_OTHER 18

#define LX2_META 19

static unsigned char lexact1[256], lexact2[256], lextok2[256];

/**/

void

initlextabs(void)

{

    int t0;

    static char *lx1 = "\\q\n;!&|(){}[]<>";

    static char *lx2 = ";)|$[]~({}><=\\\'\"`,";

    for (t0 = 0; t0 != 256; t0++) {

	lexact1[t0] = LX1_OTHER;

	lexact2[t0] = LX2_OTHER;

	lextok2[t0] = t0;

    }

    for (t0 = 0; lx1[t0]; t0++)

	lexact1[(int)lx1[t0]] = t0;

    for (t0 = 0; lx2[t0]; t0++)

	lexact2[(int)lx2[t0]] = t0;

    lexact2['&'] = LX2_BREAK;

    lexact2[STOUC(Meta)] = LX2_META;

    lextok2['*'] = Star;

    lextok2['?'] = Quest;

    lextok2['{'] = Inbrace;

    lextok2['['] = Inbrack;

    lextok2['$'] = String;

    lextok2['~'] = Tilde;

    lextok2['#'] = Pound;

    lextok2['^'] = Hat;

}

/* initialize lexical state */

/**/

void

lexinit(void)

{

    incond = incasepat = nocorrect =

    infor = dbparens = lexstop = 0;

    incmdpos = 1;

    tok = ENDINPUT;

}

/* add a char to the string buffer */

/**/

void

add(int c)

{

    *bptr++ = c;

    if (bsiz == ++len) {

#if 0

	int newbsiz;

	newbsiz = bsiz * 8;

	while (newbsiz < inbufct)

	    newbsiz *= 2;

	bptr = len + (tokstr = (char *)hrealloc(tokstr, bsiz, newbsiz));

	bsiz = newbsiz;

#endif

	int newbsiz = bsiz * 2;