/*

 * 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 "zshpaths.h"

#include "zshxmods.h"

#include "init.pro"

#include "version.h"

#ifdef __SYMBIAN32__

#ifdef __WINSCW__

#pragma warn_unusedarg off

#pragma warn_possunwant off

#endif//__WINSCW__

#endif//__SYMBIAN32__

#ifdef __SYMBIAN32__

#include "dummy.h"

char getSystemDriveChar(void);

#endif //__SYMBIAN32__

/**/

int noexitct = 0;

int pipeUsed;

/* buffer for $_ and its length */

/**/

char *underscore;

/**/

int underscorelen, underscoreused;

/* what level of sourcing we are at */

/**/

int sourcelevel;

/* the shell tty fd */

/**/

mod_export int SHTTY;

/* the FILE attached to the shell tty */

/**/

mod_export FILE *shout;

/* termcap strings */

/**/

mod_export char *tcstr[TC_COUNT];

/* lengths of each termcap string */

/**/

mod_export int tclen[TC_COUNT];

/* Values of the li, co and am entries */

/**/

int tclines, tccolumns;

/**/

mod_export int hasam;

/* Pointer to read-key function from zle */

/**/

mod_export int (*getkeyptr) _((int));

/* SIGCHLD mask */

/**/

mod_export sigset_t sigchld_mask;

/**/

mod_export struct hookdef zshhooks[] = {

    HOOKDEF("exit", NULL, HOOKF_ALL),

    HOOKDEF("before_trap", NULL, HOOKF_ALL),

    HOOKDEF("after_trap", NULL, HOOKF_ALL),

};

/* keep executing lists until EOF found */

/**/

void

loop(int toplevel, int justonce)

{

    Eprog prog;

    pushheap();

    for (;;) {

	freeheap();

	if (stophist == 3)	/* re-entry via preprompt() */

	    hend(NULL);

	hbegin(1);		/* init history mech        */

	if (isset(SHINSTDIN)) {

	    setblock_stdin();

	    if (interact) {

	        int hstop = stophist;

		stophist = 3;

		preprompt();

		if (stophist != 3)

		    hbegin(1);

		else

		    stophist = hstop;

		errflag = 0;

	    }

	}

	intr();			/* interrupts on            */

	lexinit();              /* initialize lexical state */

	if (!(prog = parse_event())) {	/* if we couldn't parse a list */

	    hend(NULL);

	    if ((tok == ENDINPUT && !errflag) ||

		(tok == LEXERR && (!isset(SHINSTDIN) || !toplevel)) ||

		justonce)

		break;

	    if (tok == LEXERR && !lastval)

		lastval = 1;

	    continue;

	}

	if (hend(prog)) {

	    int toksav = tok;

	    Eprog preprog;

	    if (toplevel && (preprog = getshfunc("preexec")) != &dummy_eprog) {

		LinkList args;

		int osc = sfcontext;

		char *cmdstr;

		args = znewlinklist();

		zaddlinknode(args, "preexec");

		/* If curline got dumped from the history, we don't know

		 * what the user typed. */

		if (hist_ring && curline.histnum == curhist)

		    zaddlinknode(args, hist_ring->text);

		else

		    zaddlinknode(args, "");

		zaddlinknode(args, getjobtext(prog, NULL));

		zaddlinknode(args, cmdstr = getpermtext(prog, NULL));

		sfcontext = SFC_HOOK;

		doshfunc("preexec", preprog, args, 0, 1);

		sfcontext = osc;

		zsfree(cmdstr);

		freelinklist(args, (FreeFunc) NULL);

		errflag = 0;

	    }

	    if (stopmsg)	/* unset 'you have stopped jobs' flag */

		stopmsg--;

	    execode(prog, 0, 0);

	    tok = toksav;

	    if (toplevel)

		noexitct = 0;

	}

	if (ferror(stderr)) {

	    zerr("write error", NULL, 0);

	    clearerr(stderr);

	}

	if (subsh)		/* how'd we get this far in a subshell? */

	    exit(lastval);

	if (((!interact || sourcelevel) && errflag) || retflag)

	    break;

	if (trapreturn) {

	    lastval = trapreturn;

	    trapreturn = 0;

	}

	if (isset(SINGLECOMMAND) && toplevel) {

	    if (sigtrapped[SIGEXIT])

		dotrap(SIGEXIT);

	    exit(lastval);

	}

	if (justonce)

	    break;

    }

    popheap();

}

static char *cmd;

static int restricted;

/**/

void

parseargs(char **argv)

{

    int optionbreak = 0;

    char **x;

    int action, optno;

    LinkList paramlist;

    argzero = *argv++;

    SHIN = 0;

    /* There's a bit of trickery with opts[INTERACTIVE] here.  It starts *

     * at a value of 2 (instead of 1) or 0.  If it is explicitly set on  *

     * the command line, it goes to 1 or 0.  If input is coming from     *

     * somewhere that normally makes the shell non-interactive, we do    *

     * "opts[INTERACTIVE] &= 1", so that only a *default* on state will  *

     * be changed.  At the end of the function, a value of 2 gets        *     

     * changed to 1.                                                     */

#ifdef __SYMBIAN32__     

    opts[INTERACTIVE] = 2; /*consider pipe end also as interative*/

#else

    opts[INTERACTIVE] = isatty(0) ? 2 : 0;

#endif    

    opts[SHINSTDIN] = 0;

    opts[SINGLECOMMAND] = 0;

    /* loop through command line options (begins with "-" or "+") */

    while (!optionbreak && *argv && (**argv == '-' || **argv == '+')) {

	char *args = *argv;

	action = (**argv == '-');

	if (!argv[0][1])

	    *argv = "--";

	while (*++*argv) {

	    if (**argv == '-') {

		if(!argv[0][1]) {

		    /* The pseudo-option `--' signifies the end of options. */

		    argv++;

		    goto doneoptions;

		}

		if(*argv != args+1 || **argv != '-')

		    goto badoptionstring;

		/* GNU-style long options */

		++*argv;

		if (!strcmp(*argv, "version")) {

		    printf("zsh %s (%s-%s-%s)\n",

			    ZSH_VERSION, MACHTYPE, VENDOR, OSTYPE);

		    exit(0);

		}

		if (!strcmp(*argv, "help")) {

		    printhelp();

		    exit(0);

		}

		/* `-' characters are allowed in long options */

		for(args = *argv; *args; args++)

		    if(*args == '-')

			*args = '_';

		goto longoptions;

	    }

	    if (unset(SHOPTIONLETTERS) && **argv == 'b') {

		/* -b ends options at the end of this argument */

		optionbreak = 1;

	    } else if (**argv == 'c') {

		/* -c command */

		cmd = *argv;

		opts[INTERACTIVE] &= 1;

		opts[SHINSTDIN] = 0;

		scriptname = ztrdup("zsh");

	    } else if (**argv == 'o') {

		if (!*++*argv)

		    argv++;

		if (!*argv) {

		    zerr("string expected after -o", NULL, 0);

		    exit(1);

		}

	    longoptions:

		if (!(optno = optlookup(*argv))) {

		    zerr("no such option: %s", *argv, 0);

		    exit(1);

		} else if (optno == RESTRICTED)

		    restricted = action;

		else

		    dosetopt(optno, action, 1);

              break;

	    } else if (isspace(STOUC(**argv))) {

		/* zsh's typtab not yet set, have to use ctype */

		while (*++*argv)

		    if (!isspace(STOUC(**argv))) {

		    badoptionstring:

			zerr("bad option string: `%s'", args, 0);

			exit(1);

		    }

		break;

	    } else {

	    	if (!(optno = optlookupc(**argv))) {

		    zerr("bad option: -%c", NULL, **argv);

		    exit(1);

		} else if (optno == RESTRICTED)

		    restricted = action;

		else

		    dosetopt(optno, action, 1);

	    }

	}

	argv++;

    }

    doneoptions:

    paramlist = znewlinklist();

    if (cmd) {

	if (!*argv) {

	    zerr("string expected after -%s", cmd, 0);

	    exit(1);

	}

	cmd = *argv++;

    }

    if (*argv) {

	if (unset(SHINSTDIN)) {

	    argzero = *argv;

	    if (!cmd)

		SHIN = movefd(open(unmeta(argzero), O_RDONLY | O_NOCTTY));

	    if (SHIN == -1) {

		zerr("can't open input file: %s", argzero, 0);

		exit(1);

	    }

	    opts[INTERACTIVE] &= 1;

	    argv++;

	}

	while (*argv)

	    zaddlinknode(paramlist, ztrdup(*argv++));

    } else

	opts[SHINSTDIN] = 1;

    if(isset(SINGLECOMMAND))

	opts[INTERACTIVE] &= 1;

    opts[INTERACTIVE] = !!opts[INTERACTIVE];

    pparams = x = (char **) zshcalloc((countlinknodes(paramlist) + 1) * sizeof(char *));

    while ((*x++ = (char *)getlinknode(paramlist)));

    free(paramlist);

    argzero = ztrdup(argzero);

}

/**/

static void

printhelp(void)

{

    printf("Usage: %s [<options>] [<argument> ...]\n", argzero);

    printf("\nSpecial options:\n");

    printf("  --help     show this message, then exit\n");

    printf("  --version  show zsh version number, then exit\n");

    if(unset(SHOPTIONLETTERS))

	printf("  -b         end option processing, like --\n");

    printf("  -c         take first argument as a command to execute\n");

    printf("  -o OPTION  set an option by name (see below)\n");

    printf("\nNormal options are named.  An option may be turned on by\n");

    printf("`-o OPTION', `--OPTION', `+o no_OPTION' or `+-no-OPTION'.  An\n");

    printf("option may be turned off by `-o no_OPTION', `--no-OPTION',\n");

    printf("`+o OPTION' or `+-OPTION'.  Options are listed below only in\n");

    printf("`--OPTION' or `--no-OPTION' form.\n");

    printoptionlist();

}

/**/

mod_export void

init_io(void)

{

    static char outbuf[BUFSIZ], errbuf[BUFSIZ];

#ifdef RSH_BUG_WORKAROUND

    int i;

#endif

/* stdout, stderr fully buffered */

#ifdef _IOFBF

    setvbuf(stdout, outbuf, _IOFBF, BUFSIZ);

    setvbuf(stderr, errbuf, _IOFBF, BUFSIZ);

#else

    setbuffer(stdout, outbuf, BUFSIZ);

    setbuffer(stderr, errbuf, BUFSIZ);

#endif

/* This works around a bug in some versions of in.rshd. *

 * Currently this is not defined by default.            */

#ifdef RSH_BUG_WORKAROUND

    if (cmd) {

	for (i = 3; i < 10; i++)

	    close(i);

    }

#endif

    if (shout) {

	/*

	 * Check if shout was set to stderr, if so don't close it.

	 * We do this if we are interactive but don't have a

	 * terminal.

	 */

	if (shout != stderr)

	    fclose(shout);

	shout = 0;

    }

    if (SHTTY != -1) {

	zclose(SHTTY);

	SHTTY = -1;

    }

    /* Send xtrace output to stderr -- see execcmd() */

    xtrerr = stderr;

    /* Make sure the tty is opened read/write. */

    if (isatty(0)) {

	zsfree(ttystrname);

	if ((ttystrname = ztrdup((char*)ttyname(0)))) {

	    SHTTY = movefd(open(ttystrname, O_RDWR | O_NOCTTY));

#ifdef TIOCNXCL

	    /*

	     * See if the terminal claims to be busy.  If so, and fd 0

	     * is a terminal, try and set non-exclusive use for that.

	     * This is something to do with Solaris over-cleverness.

	     */

	    if (SHTTY == -1 && errno == EBUSY)

		ioctl(0, TIOCNXCL, 0);

#endif

	}

	/*

	 * xterm, rxvt and probably all terminal emulators except

	 * dtterm on Solaris 2.6 & 7 have a bug. Applications are

	 * unable to open /dev/tty or /dev/pts/<terminal number here>

	 * because something in Sun's STREAMS modules doesn't like

	 * it. The open() call fails with EBUSY which is not even

	 * listed as a possibility in the open(2) man page.  So we'll

	 * try to outsmart The Company.  -- <dave@srce.hr>

	 *

	 * Presumably there's no harm trying this on any OS, given that

	 * isatty(0) worked but opening the tty didn't.  Possibly we won't

	 * get the tty read/write, but it's the best we can do -- pws

	 *

	 * Try both stdin and stdout before trying /dev/tty. -- Bart

	 */

#if defined(HAVE_FCNTL_H) && defined(F_GETFL)

#define rdwrtty(fd)	((fcntl(fd, F_GETFL, 0) & O_RDWR) == O_RDWR)

#else

#define rdwrtty(fd)	1

#endif

	if (SHTTY == -1 && rdwrtty(0)) {

	    SHTTY = movefd(dup(0));

	}

    }

    if (SHTTY == -1 && isatty(1) && rdwrtty(1) &&

	(SHTTY = movefd(dup(1))) != -1) {

	zsfree(ttystrname);

	ttystrname = ztrdup((char*)ttyname((1)));

    }

    if (SHTTY == -1 &&

	(SHTTY = movefd(open("/dev/tty", O_RDWR | O_NOCTTY))) != -1) {

	zsfree(ttystrname);

	ttystrname = ztrdup((char*)ttyname(SHTTY));

    }

    if (SHTTY == -1) {

	zsfree(ttystrname);

	ttystrname = ztrdup("");

    } else if (!ttystrname) {

	ttystrname = ztrdup("/dev/tty");

    }

    /* We will only use zle if shell is interactive, *

     * SHTTY != -1, and shout != 0                   */

    if (interact) {

	init_shout();

	if(!SHTTY || !shout)

	    opts[USEZLE] = 0;

    } else

	opts[USEZLE] = 0;

#ifdef JOB_CONTROL

    /* If interactive, make sure the shell is in the foreground and is the

     * process group leader.

     */

    mypid = (zlong)getpid();

    if (opts[MONITOR] && interact && (SHTTY != -1)) {

	origpgrp = GETPGRP();

        acquire_pgrp(); /* might also clear opts[MONITOR] */

    } else

	opts[MONITOR] = 0;

#else

    opts[MONITOR] = 0;

#endif

}

/**/

mod_export void

init_shout(void)

{

    static char shoutbuf[BUFSIZ];

#if defined(JOB_CONTROL) && defined(TIOCSETD) && defined(NTTYDISC)

    int ldisc;

#endif

    if (SHTTY == -1)

    {

	/* Since we're interative, it's nice to have somewhere to write. */

	shout = stderr;