// params.c - parameters

//

// © 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 "params.pro"

#include "version.h"

#ifdef __SYMBIAN32__

#ifdef __WINSCW__

#pragma warn_unusedarg off

#pragma warn_possunwant off

#endif//__WINSCW__

#endif//__SYMBIAN32__

/* what level of localness we are at */

/**/

mod_export int locallevel;

/* Variables holding values of special parameters */

/**/

mod_export

char **pparams,		/* $argv        */

     **cdpath,		/* $cdpath      */

     **fpath,		/* $fpath       */

     **mailpath,	/* $mailpath    */

     **manpath,		/* $manpath     */

     **psvar,		/* $psvar       */

     **watch;		/* $watch       */

/**/

mod_export

char **path,		/* $path        */

     **fignore;		/* $fignore     */

/**/

char *argzero,		/* $0           */

     *home,		/* $HOME        */

     *nullcmd,		/* $NULLCMD     */

     *oldpwd,		/* $OLDPWD      */

     *zoptarg,		/* $OPTARG      */

     *prompt,		/* $PROMPT      */

     *prompt2,		/* $PROMPT2     */

     *prompt3,		/* $PROMPT3     */

     *prompt4,		/* $PROMPT4     */

     *readnullcmd,	/* $READNULLCMD */

     *rprompt,		/* $RPROMPT     */

     *rprompt2,		/* $RPROMPT2    */

     *sprompt,		/* $SPROMPT     */

     *wordchars,	/* $WORDCHARS   */

     *zsh_name;		/* $ZSH_NAME    */

/**/

mod_export

char *ifs,		/* $IFS         */

     *postedit,		/* $POSTEDIT    */

     *term,		/* $TERM        */

     *ttystrname,	/* $TTY         */

     *pwd;		/* $PWD         */

/**/

mod_export

zlong lastval,		/* $?           */

     mypid,		/* $$           */

     lastpid,		/* $!           */

     columns,		/* $COLUMNS     */

     lines,		/* $LINES       */

     ppid;		/* $PPID        */

/**/

zlong lineno,		/* $LINENO      */

     zoptind,		/* $OPTIND      */

     shlvl;		/* $SHLVL       */

/* $histchars */

/**/

mod_export unsigned char bangchar;

/**/

unsigned char hatchar, hashchar;

/* $SECONDS = now.tv_sec - shtimer.tv_sec

 *          + (now.tv_usec - shtimer.tv_usec) / 1000000.0

 * (rounded to an integer if the parameter is not set to float) */

/**/

struct timeval shtimer;

/* 0 if this $TERM setup is usable, otherwise it contains TERM_* flags */

/**/

mod_export int termflags;

/* Standard methods for get/set/unset pointers in parameters */

/**/

mod_export const struct gsu_scalar stdscalar_gsu =

{ strgetfn, strsetfn, stdunsetfn };

/**/

mod_export const struct gsu_scalar varscalar_gsu =

{ strvargetfn, strvarsetfn, stdunsetfn };

/**/

mod_export const struct gsu_scalar nullsetscalar_gsu =

{ strgetfn, nullstrsetfn, NULL };

/**/

mod_export const struct gsu_integer stdinteger_gsu =

{ intgetfn, intsetfn, stdunsetfn };

/**/

mod_export const struct gsu_integer varinteger_gsu =

{ intvargetfn, intvarsetfn, stdunsetfn };

/**/

mod_export const struct gsu_integer nullsetinteger_gsu =

{ intgetfn, NULL, NULL };

/**/

mod_export const struct gsu_float stdfloat_gsu =

{ floatgetfn, floatsetfn, stdunsetfn };

/**/

mod_export const struct gsu_array stdarray_gsu =

{ arrgetfn, arrsetfn, stdunsetfn };

/**/

mod_export const struct gsu_array vararray_gsu =

{ arrvargetfn, arrvarsetfn, stdunsetfn };

/**/

mod_export const struct gsu_hash stdhash_gsu =

{ hashgetfn, hashsetfn, stdunsetfn };

/**/

mod_export const struct gsu_hash nullsethash_gsu =

{ hashgetfn, nullsethashfn, nullunsetfn };

/* Non standard methods (not exported) */

static const struct gsu_integer pound_gsu =

{ poundgetfn, nullintsetfn, stdunsetfn };

static const struct gsu_integer errno_gsu =

{ errnogetfn, errnosetfn, stdunsetfn };

static const struct gsu_integer gid_gsu =

{ gidgetfn, gidsetfn, stdunsetfn };

static const struct gsu_integer egid_gsu =

{ egidgetfn, egidsetfn, stdunsetfn };

static const struct gsu_integer histsize_gsu =

{ histsizegetfn, histsizesetfn, stdunsetfn };

static const struct gsu_integer random_gsu =

{ randomgetfn, randomsetfn, stdunsetfn };

static const struct gsu_integer savehist_gsu =

{ savehistsizegetfn, savehistsizesetfn, stdunsetfn };

static const struct gsu_integer intseconds_gsu =

{ intsecondsgetfn, intsecondssetfn, stdunsetfn };

static const struct gsu_float floatseconds_gsu =

{ floatsecondsgetfn, floatsecondssetfn, stdunsetfn };

static const struct gsu_integer uid_gsu =

{ uidgetfn, uidsetfn, stdunsetfn };

static const struct gsu_integer euid_gsu =

{ euidgetfn, euidsetfn, stdunsetfn };

static const struct gsu_integer ttyidle_gsu =

{ ttyidlegetfn, nullintsetfn, stdunsetfn };

static const struct gsu_scalar username_gsu =

{ usernamegetfn, usernamesetfn, stdunsetfn };

static const struct gsu_scalar dash_gsu =

{ dashgetfn, nullstrsetfn, stdunsetfn };

static const struct gsu_scalar histchars_gsu =

{ histcharsgetfn, histcharssetfn, stdunsetfn };

static const struct gsu_scalar home_gsu =

{ homegetfn, homesetfn, stdunsetfn };

static const struct gsu_scalar term_gsu =

{ termgetfn, termsetfn, stdunsetfn };

static const struct gsu_scalar wordchars_gsu =

{ wordcharsgetfn, wordcharssetfn, stdunsetfn };

static const struct gsu_scalar ifs_gsu =

{ ifsgetfn, ifssetfn, stdunsetfn };

static const struct gsu_scalar underscore_gsu =

{ underscoregetfn, nullstrsetfn, stdunsetfn };

#ifdef USE_LOCALE

static const struct gsu_scalar lc_blah_gsu =

{ strgetfn, lcsetfn, stdunsetfn };

static const struct gsu_scalar lang_gsu =

{ strgetfn, langsetfn, stdunsetfn };

static const struct gsu_scalar lc_all_gsu =

{ strgetfn, lc_allsetfn, stdunsetfn };

#endif

static const struct gsu_integer varint_readonly_gsu =

{ intvargetfn, nullintsetfn, stdunsetfn };

static const struct gsu_integer zlevar_gsu =

{ intvargetfn, zlevarsetfn, stdunsetfn };

static const struct gsu_scalar colonarr_gsu =

{ colonarrgetfn, colonarrsetfn, stdunsetfn };

static const struct gsu_integer argc_gsu =

{ poundgetfn, nullintsetfn, stdunsetfn };

static const struct gsu_array pipestatus_gsu =

{ pipestatgetfn, pipestatsetfn, stdunsetfn };

/* Nodes for special parameters for parameter hash table */

#ifdef HAVE_UNION_INIT

# define BR(X) {X}

typedef struct param initparam;

#else

# define BR(X) X

typedef struct iparam {

    struct hashnode *next;

    char *nam;			/* hash data                             */

    int flags;			/* PM_* flags (defined in zsh.h)         */

    void *value;

    void *gsu;			/* get/set/unset methods */

    int base;			/* output base                           */

    int width;			/* output field width                    */

    char *env;			/* location in environment, if exported  */

    char *ename;		/* name of corresponding environment var */

    Param old;			/* old struct for use with local         */

    int level;			/* if (old != NULL), level of localness  */

} initparam;

#endif

static initparam special_params[] ={

#define GSU(X) BR((GsuScalar)(void *)(&(X)))

#define NULL_GSU BR((GsuScalar)(void *)NULL)

#define IPDEF1(A,B,C) {NULL,A,PM_INTEGER|PM_SPECIAL|C,BR(NULL),GSU(B),10,0,NULL,NULL,NULL,0}

IPDEF1("#", pound_gsu, PM_READONLY),

IPDEF1("ERRNO", errno_gsu, 0),

IPDEF1("GID", gid_gsu, PM_DONTIMPORT | PM_RESTRICTED),

IPDEF1("EGID", egid_gsu, PM_DONTIMPORT | PM_RESTRICTED),

IPDEF1("HISTSIZE", histsize_gsu, PM_RESTRICTED),

IPDEF1("RANDOM", random_gsu, 0),

IPDEF1("SAVEHIST", savehist_gsu, PM_RESTRICTED),

IPDEF1("SECONDS", intseconds_gsu, 0),

IPDEF1("UID", uid_gsu, PM_DONTIMPORT | PM_RESTRICTED),

IPDEF1("EUID", euid_gsu, PM_DONTIMPORT | PM_RESTRICTED),

IPDEF1("TTYIDLE", ttyidle_gsu, PM_READONLY),

#define IPDEF2(A,B,C) {NULL,A,PM_SCALAR|PM_SPECIAL|C,BR(NULL),GSU(B),0,0,NULL,NULL,NULL,0}

IPDEF2("USERNAME", username_gsu, PM_DONTIMPORT|PM_RESTRICTED),

IPDEF2("-", dash_gsu, PM_READONLY),

IPDEF2("histchars", histchars_gsu, PM_DONTIMPORT),

IPDEF2("HOME", home_gsu, 0),

IPDEF2("TERM", term_gsu, 0),

IPDEF2("WORDCHARS", wordchars_gsu, 0),

IPDEF2("IFS", ifs_gsu, PM_DONTIMPORT),

IPDEF2("_", underscore_gsu, PM_READONLY),

#ifdef USE_LOCALE

# define LCIPDEF(name) IPDEF2(name, lc_blah_gsu, PM_UNSET)

IPDEF2("LANG", lang_gsu, PM_UNSET),

IPDEF2("LC_ALL", lc_all_gsu, PM_UNSET),

# ifdef LC_COLLATE

LCIPDEF("LC_COLLATE"),

# endif

# ifdef LC_CTYPE

LCIPDEF("LC_CTYPE"),

# endif

# ifdef LC_MESSAGES

LCIPDEF("LC_MESSAGES"),

# endif

# ifdef LC_NUMERIC

LCIPDEF("LC_NUMERIC"),

# endif

# ifdef LC_TIME

LCIPDEF("LC_TIME"),

# endif

#endif /* USE_LOCALE */

#define IPDEF4(A,B) {NULL,A,PM_INTEGER|PM_READONLY|PM_SPECIAL,BR((void *)B),GSU(varint_readonly_gsu),10,0,NULL,NULL,NULL,0}

IPDEF4("!", &lastpid),

IPDEF4("$", &mypid),

IPDEF4("?", &lastval),

IPDEF4("HISTCMD", &curhist),

IPDEF4("LINENO", &lineno),

IPDEF4("PPID", &ppid),

#define IPDEF5(A,B,F) {NULL,A,PM_INTEGER|PM_SPECIAL,BR((void *)B),GSU(varinteger_gsu),10,0,NULL,NULL,NULL,0}

IPDEF5("COLUMNS", &columns, zlevar_gsu),

IPDEF5("LINES", &lines, zlevar_gsu),

IPDEF5("OPTIND", &zoptind, varinteger_gsu),

IPDEF5("SHLVL", &shlvl, varinteger_gsu),

IPDEF5("TRY_BLOCK_ERROR", &try_errflag, varinteger_gsu),

#define IPDEF7(A,B) {NULL,A,PM_SCALAR|PM_SPECIAL,BR((void *)B),GSU(varscalar_gsu),0,0,NULL,NULL,NULL,0}

IPDEF7("OPTARG", &zoptarg),

IPDEF7("NULLCMD", &nullcmd),

IPDEF7("POSTEDIT", &postedit),

IPDEF7("READNULLCMD", &readnullcmd),

IPDEF7("PS1", &prompt),

IPDEF7("RPS1", &rprompt),

IPDEF7("RPROMPT", &rprompt),

IPDEF7("PS2", &prompt2),

IPDEF7("RPS2", &rprompt2),

IPDEF7("RPROMPT2", &rprompt2),

IPDEF7("PS3", &prompt3),

IPDEF7("PS4", &prompt4),

IPDEF7("SPROMPT", &sprompt),

IPDEF7("0", &argzero),

#define IPDEF8(A,B,C,D) {NULL,A,D|PM_SCALAR|PM_SPECIAL,BR((void *)B),GSU(colonarr_gsu),0,0,NULL,C,NULL,0}

IPDEF8("CDPATH", &cdpath, "cdpath", 0),

IPDEF8("FIGNORE", &fignore, "fignore", 0),

IPDEF8("FPATH", &fpath, "fpath", 0),

IPDEF8("MAILPATH", &mailpath, "mailpath", 0),

IPDEF8("WATCH", &watch, "watch", 0),

IPDEF8("PATH", &path, "path", PM_RESTRICTED),

IPDEF8("PSVAR", &psvar, "psvar", 0),

/* MODULE_PATH is not imported for security reasons */

IPDEF8("MODULE_PATH", &module_path, "module_path", PM_DONTIMPORT|PM_RESTRICTED),

#define IPDEF9F(A,B,C,D) {NULL,A,D|PM_ARRAY|PM_SPECIAL|PM_DONTIMPORT,BR((void *)B),GSU(vararray_gsu),0,0,NULL,C,NULL,0}

#define IPDEF9(A,B,C) IPDEF9F(A,B,C,0)

IPDEF9F("*", &pparams, NULL, PM_ARRAY|PM_SPECIAL|PM_DONTIMPORT|PM_READONLY),

IPDEF9F("@", &pparams, NULL, PM_ARRAY|PM_SPECIAL|PM_DONTIMPORT|PM_READONLY),

{NULL,NULL,0,BR(NULL),NULL_GSU,0,0,NULL,NULL,NULL,0},

#define IPDEF10(A,B) {NULL,A,PM_ARRAY|PM_SPECIAL,BR(NULL),GSU(B),10,0,NULL,NULL,NULL,0}

/* The following parameters are not available in sh/ksh compatibility *

 * mode. All of these have sh compatible equivalents.                */

IPDEF1("ARGC", argc_gsu, PM_READONLY),

IPDEF2("HISTCHARS", histchars_gsu, PM_DONTIMPORT),

IPDEF4("status", &lastval),

IPDEF7("prompt", &prompt),

IPDEF7("PROMPT", &prompt),

IPDEF7("PROMPT2", &prompt2),

IPDEF7("PROMPT3", &prompt3),

IPDEF7("PROMPT4", &prompt4),

IPDEF8("MANPATH", &manpath, "manpath", 0),

IPDEF9("argv", &pparams, NULL),

IPDEF9("fignore", &fignore, "FIGNORE"),

IPDEF9("cdpath", &cdpath, "CDPATH"),

IPDEF9("fpath", &fpath, "FPATH"),

IPDEF9("mailpath", &mailpath, "MAILPATH"),

IPDEF9("manpath", &manpath, "MANPATH"),

IPDEF9("psvar", &psvar, "PSVAR"),

IPDEF9("watch", &watch, "WATCH"),

IPDEF9F("module_path", &module_path, "MODULE_PATH", PM_RESTRICTED),

IPDEF9F("path", &path, "PATH", PM_RESTRICTED),

IPDEF10("pipestatus", pipestatus_gsu),

{NULL,NULL,0,BR(NULL),NULL_GSU,0,0,NULL,NULL,NULL,0},

};

/*

 * Special way of referring to the positional parameters.  Unlike $*

 * and $@, this is not readonly.  This parameter is not directly

 * visible in user space.

 */

initparam argvparam_pm = IPDEF9F("", &pparams, NULL, \

				 PM_ARRAY|PM_SPECIAL|PM_DONTIMPORT);

#undef BR

#define IS_UNSET_VALUE(V) \

	((V) && (!(V)->pm || ((V)->pm->flags & PM_UNSET) || \

		 !(V)->pm->nam || !*(V)->pm->nam))

static Param argvparam;

/* hash table containing the parameters */

/**/

mod_export HashTable paramtab, realparamtab;

/**/

mod_export HashTable

newparamtable(int size, char const *name)

{

    HashTable ht;

    if (!size)

	size = 17;

    ht = newhashtable(size, name, NULL);

    ht->hash        = hasher;

    ht->emptytable  = emptyhashtable;

    ht->filltable   = NULL;

    ht->cmpnodes    = strcmp;

    ht->addnode     = addhashnode;

    ht->getnode     = getparamnode;

    ht->getnode2    = getparamnode;

    ht->removenode  = removehashnode;

    ht->disablenode = NULL;

    ht->enablenode  = NULL;

    ht->freenode    = freeparamnode;

    ht->printnode   = printparamnode;

    return ht;

}

/**/

static HashNode

getparamnode(HashTable ht, char *nam)

{

    HashNode hn = gethashnode2(ht, nam);

    Param pm = (Param) hn;

    if (pm && pm->u.str && (pm->flags & PM_AUTOLOAD)) {

	char *mn = dupstring(pm->u.str);

	if (!load_module(mn))

	    return NULL;

	hn = gethashnode2(ht, nam);

	if (((Param) hn) == pm && (pm->flags & PM_AUTOLOAD)) {

	    pm->flags &= ~PM_AUTOLOAD;

	    zwarnnam(nam, "autoload failed", NULL, 0);

	}

    }

    return hn;

}

/* Copy a parameter hash table */

static HashTable outtable;

/**/

static void

scancopyparams(HashNode hn, UNUSED(int flags))

{

    /* Going into a real parameter, so always use permanent storage */

    Param pm = (Param)hn;

    Param tpm = (Param) zshcalloc(sizeof *tpm);

    tpm->nam = ztrdup(pm->nam);

    copyparam(tpm, pm, 0);

    addhashnode(outtable, tpm->nam, tpm);

}

/**/

HashTable

copyparamtable(HashTable ht, char *name)

{

    HashTable nht = newparamtable(ht->hsize, name);

    outtable = nht;

    scanhashtable(ht, 0, 0, 0, scancopyparams, 0);

    outtable = NULL;

    return nht;

}

/* Flag to freeparamnode to unset the struct */

static int delunset;

/* Function to delete a parameter table. */

/**/

mod_export void

deleteparamtable(HashTable t)

{

    /* The parameters in the hash table need to be unset *

     * before being deleted.                             */

    int odelunset = delunset;

    delunset = 1;

    deletehashtable(t);

    delunset = odelunset;

}

static unsigned numparamvals;

/**/

mod_export void

scancountparams(UNUSED(HashNode hn), int flags)

{

    ++numparamvals;

    if ((flags & SCANPM_WANTKEYS) && (flags & SCANPM_WANTVALS))

	++numparamvals;

}

static Patprog scanprog;

static char *scanstr;

static char **paramvals;

static Param foundparam;     

/**/

void

scanparamvals(HashNode hn, int flags)

{

    struct value v;

    Patprog prog;

    if (numparamvals && !(flags & SCANPM_MATCHMANY) &&

	(flags & (SCANPM_MATCHVAL|SCANPM_MATCHKEY|SCANPM_KEYMATCH)))

	return;

    v.pm = (Param)hn;

    if ((flags & SCANPM_KEYMATCH)) {

	char *tmp = dupstring(v.pm->nam);

	tokenize(tmp);

	remnulargs(tmp);

	if (!(prog = patcompile(tmp, 0, NULL)) || !pattry(prog, scanstr))

	    return;

    } else if ((flags & SCANPM_MATCHKEY) && !pattry(scanprog, v.pm->nam)) {

	return;

    }

    foundparam = v.pm;

    if (flags & SCANPM_WANTKEYS) {

	paramvals[numparamvals++] = v.pm->nam;

	if (!(flags & (SCANPM_WANTVALS|SCANPM_MATCHVAL)))

	    return;

    }