// parameter.c - parameter interface to zsh internals

//

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

//

/*

 * This file is part of zsh, the Z shell.

 *

 * Copyright (c) 1999 Sven Wischnowsky

 * 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 Sven Wischnowsky 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 Sven Wischnowsky and the Zsh Development Group have been advised of

 * the possibility of such damage.

 *

 * Sven Wischnowsky 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 Sven Wischnowsky and the

 * Zsh Development Group have no obligation to provide maintenance,

 * support, updates, enhancements, or modifications.

 *

 */

#include "parameter.mdh"

#include "parameter.pro"

#ifdef __SYMBIAN32__

#ifdef __WINSCW__

#pragma warn_unusedarg off

#pragma warn_possunwant off

#endif//__WINSCW__

#endif//__SYMBIAN32__

/* This says if we are cleaning up when the module is unloaded. */

static int incleanup;

/* Empty dummy function for special hash parameters. */

/**/

static void

shempty(void)

{

}

/* Create a simple special hash parameter. */

/**/

static Param

createspecialhash(char *name, GetNodeFunc get, ScanTabFunc scan)

{

    Param pm;

    HashTable ht;

    if (!(pm = createparam(name, PM_SPECIAL|PM_HIDE|PM_HIDEVAL|

			   PM_REMOVABLE|PM_HASHED)))

	return NULL;

    pm->level = pm->old ? locallevel : 0;

    pm->gsu.h = &stdhash_gsu;

    pm->u.hash = ht = newhashtable(0, name, NULL);

    ht->hash        = hasher;

    ht->emptytable  = (TableFunc) shempty;

    ht->filltable   = NULL;

    ht->addnode     = (AddNodeFunc) shempty;

    ht->getnode     = ht->getnode2 = get;

    ht->removenode  = (RemoveNodeFunc) shempty;

    ht->disablenode = NULL;

    ht->enablenode  = NULL;

    ht->freenode    = (FreeNodeFunc) shempty;

    ht->printnode   = printparamnode;

    ht->scantab     = scan;

    return pm;

}

/* Functions for the parameters special parameter. */

/* Return a string describing the type of a parameter. */

/**/

static char *

paramtypestr(Param pm)

{

    char *val = NULL;

    int f = pm->flags;

    if (!(f & PM_UNSET)) {

	if (pm->flags & PM_AUTOLOAD)

	    return dupstring("undefined");

	switch (PM_TYPE(f)) {

	case PM_SCALAR:  val = "scalar"; break;

	case PM_ARRAY:   val = "array"; break;

	case PM_INTEGER: val = "integer"; break;

	case PM_EFLOAT:

	case PM_FFLOAT:  val = "float"; break;

	case PM_HASHED:  val = "association"; break;

	}

	DPUTS(!val, "BUG: type not handled in parameter");

	val = dupstring(val);

	if (pm->level)

	    val = dyncat(val, "-local");

	if (f & PM_LEFT)

	    val = dyncat(val, "-left");

	if (f & PM_RIGHT_B)

	    val = dyncat(val, "-right_blanks");

	if (f & PM_RIGHT_Z)

	    val = dyncat(val, "-right_zeros");

	if (f & PM_LOWER)

	    val = dyncat(val, "-lower");

	if (f & PM_UPPER)

	    val = dyncat(val, "-upper");

	if (f & PM_READONLY)

	    val = dyncat(val, "-readonly");

	if (f & PM_TAGGED)

	    val = dyncat(val, "-tag");

	if (f & PM_EXPORTED)

	    val = dyncat(val, "-export");

	if (f & PM_UNIQUE)

	    val = dyncat(val, "-unique");

	if (f & PM_HIDE)

	    val = dyncat(val, "-hide");

	if (f & PM_HIDEVAL)

	    val = dyncat(val, "-hideval");

	if (f & PM_SPECIAL)

	    val = dyncat(val, "-special");

    } else

	val = dupstring("");

    return val;

}

/**/

static HashNode

getpmparameter(UNUSED(HashTable ht), char *name)

{

    Param rpm, pm = NULL;

    pm = (Param) hcalloc(sizeof(struct param));

    pm->nam = dupstring(name);

    pm->flags = PM_SCALAR | PM_READONLY;

    pm->gsu.s = &nullsetscalar_gsu;

    if ((rpm = (Param) realparamtab->getnode(realparamtab, name)) &&

	!(rpm->flags & PM_UNSET))

	pm->u.str = paramtypestr(rpm);

    else {

	pm->u.str = dupstring("");

	pm->flags |= PM_UNSET;

    }

    return (HashNode) pm;

}

/**/

static void

scanpmparameters(UNUSED(HashTable ht), ScanFunc func, int flags)

{

    struct param pm;

    int i;

    HashNode hn;

    memset((void *)&pm, 0, sizeof(struct param));

    pm.flags = PM_SCALAR | PM_READONLY;

    pm.gsu.s = &nullsetscalar_gsu;

    for (i = 0; i < realparamtab->hsize; i++)

	for (hn = realparamtab->nodes[i]; hn; hn = hn->next) {

	    if (((Param)hn)->flags & PM_UNSET)

		continue;

	    pm.nam = hn->nam;

	    if (func != scancountparams &&

		((flags & (SCANPM_WANTVALS|SCANPM_MATCHVAL)) ||

		 !(flags & SCANPM_WANTKEYS)))

		pm.u.str = paramtypestr((Param) hn);

	    func((HashNode) &pm, flags);

	}

}

/* Functions for the commands special parameter. */

/**/

static void

setpmcommand(Param pm, char *value)

{

    if (isset(RESTRICTED)) {

	zwarn("restricted: %s", value, 0);

	zsfree(value);

    } else {

	Cmdnam cn = zshcalloc(sizeof(*cn));

	cn->flags = HASHED;

	cn->u.cmd = value;

	cmdnamtab->addnode(cmdnamtab, ztrdup(pm->nam), (HashNode) cn);

    }

}

/**/

static void

unsetpmcommand(Param pm, UNUSED(int exp))

{

    HashNode hn = cmdnamtab->removenode(cmdnamtab, pm->nam);

    if (hn)

	cmdnamtab->freenode(hn);

}

/**/

static void

setpmcommands(UNUSED(Param pm), HashTable ht)

{

    int i;

    HashNode hn;

    if (!ht)

	return;

    for (i = 0; i < ht->hsize; i++)

	for (hn = ht->nodes[i]; hn; hn = hn->next) {

	    Cmdnam cn = zshcalloc(sizeof(*cn));

	    struct value v;

	    v.isarr = v.inv = v.start = 0;

	    v.end = -1;

	    v.arr = NULL;

	    v.pm = (Param) hn;

	    cn->flags = HASHED;

	    cn->u.cmd = ztrdup(getstrvalue(&v));

	    cmdnamtab->addnode(cmdnamtab, ztrdup(hn->nam), (HashNode) cn);

	}

    deleteparamtable(ht);

}

static const struct gsu_scalar pmcommand_gsu =

{ strgetfn, setpmcommand, unsetpmcommand };

/**/

static HashNode

getpmcommand(UNUSED(HashTable ht), char *name)

{

    Cmdnam cmd;

    Param pm = NULL;

    if (!(cmd = (Cmdnam) cmdnamtab->getnode(cmdnamtab, name)) &&

	isset(HASHLISTALL)) {

	cmdnamtab->filltable(cmdnamtab);

	cmd = (Cmdnam) cmdnamtab->getnode(cmdnamtab, name);

    }

    pm = (Param) hcalloc(sizeof(struct param));

    pm->nam = dupstring(name);

    pm->flags = PM_SCALAR;

    pm->gsu.s = &pmcommand_gsu;

    if (cmd) {

	if (cmd->flags & HASHED)

	    pm->u.str = cmd->u.cmd;

	else {

	    pm->u.str = zhalloc(strlen(*(cmd->u.name)) + strlen(name) + 2);

	    strcpy(pm->u.str, *(cmd->u.name));

	    strcat(pm->u.str, "/");

	    strcat(pm->u.str, name);

	}

    } else {

	pm->u.str = dupstring("");

	pm->flags |= PM_UNSET;

    }

    return (HashNode) pm;

}

/**/

static void

scanpmcommands(UNUSED(HashTable ht), ScanFunc func, int flags)

{

    struct param pm;

    int i;

    HashNode hn;

    Cmdnam cmd;

    if (isset(HASHLISTALL))

	cmdnamtab->filltable(cmdnamtab);

    memset((void *)&pm, 0, sizeof(struct param));

    pm.flags = PM_SCALAR;

    pm.gsu.s = &pmcommand_gsu;

    for (i = 0; i < cmdnamtab->hsize; i++)

	for (hn = cmdnamtab->nodes[i]; hn; hn = hn->next) {

	    pm.nam = hn->nam;

	    cmd = (Cmdnam) hn;

	    if (func != scancountparams &&

		((flags & (SCANPM_WANTVALS|SCANPM_MATCHVAL)) ||

		 !(flags & SCANPM_WANTKEYS))) {

		if (cmd->flags & HASHED)

		    pm.u.str = cmd->u.cmd;

		else {

		    pm.u.str = zhalloc(strlen(*(cmd->u.name)) +

				       strlen(cmd->nam) + 2);

		    strcpy(pm.u.str, *(cmd->u.name));

		    strcat(pm.u.str, "/");

		    strcat(pm.u.str, cmd->nam);

		}

	    }

	    func((HashNode) &pm, flags);

	}

}

/* Functions for the functions special parameter. */

/**/

static void

setfunction(char *name, char *val, int dis)

{

    char *value = dupstring(val);

    Shfunc shf;

    Eprog prog;

    int sn;

    val = metafy(val, strlen(val), META_REALLOC);

    prog = parse_string(val);

    if (!prog || prog == &dummy_eprog) {

	zwarn("invalid function definition", value, 0);

	zsfree(val);

	return;

    }

    shf = (Shfunc) zalloc(sizeof(*shf));

    shf->funcdef = dupeprog(prog, 0);

    shf->flags = dis;

    if (!strncmp(name, "TRAP", 4) &&

	(sn = getsignum(name + 4)) != -1) {

	if (settrap(sn, shf->funcdef)) {

	    freeeprog(shf->funcdef);

	    zfree(shf, sizeof(*shf));

	    zsfree(val);

	    return;

	}

	sigtrapped[sn] |= ZSIG_FUNC;

    }

    shfunctab->addnode(shfunctab, ztrdup(name), shf);

    zsfree(val);

}

/**/

static void

setpmfunction(Param pm, char *value)

{

    setfunction(pm->nam, value, 0);

}

/**/

static void

setpmdisfunction(Param pm, char *value)

{

    setfunction(pm->nam, value, DISABLED);

}

/**/

static void

unsetpmfunction(Param pm, UNUSED(int exp))

{

    HashNode hn = shfunctab->removenode(shfunctab, pm->nam);

    if (hn)

	shfunctab->freenode(hn);

}

/**/

static void

setfunctions(UNUSED(Param pm), HashTable ht, int dis)

{

    int i;

    HashNode hn;

    if (!ht)

	return;

    for (i = 0; i < ht->hsize; i++)

	for (hn = ht->nodes[i]; hn; hn = hn->next) {

	    struct value v;

	    v.isarr = v.inv = v.start = 0;

	    v.end = -1;

	    v.arr = NULL;

	    v.pm = (Param) hn;

	    setfunction(hn->nam, ztrdup(getstrvalue(&v)), dis);

	}

    deleteparamtable(ht);

}

/**/

static void

setpmfunctions(Param pm, HashTable ht)

{

    setfunctions(pm, ht, 0);

}

/**/

static void

setpmdisfunctions(Param pm, HashTable ht)

{

    setfunctions(pm, ht, DISABLED);

}

static const struct gsu_scalar pmfunction_gsu =

{ strgetfn, setpmfunction, unsetpmfunction };

static const struct gsu_scalar pmdisfunction_gsu =

{ strgetfn, setpmdisfunction, unsetpmfunction };

/**/

static HashNode

getfunction(UNUSED(HashTable ht), char *name, int dis)

{

    Shfunc shf;

    Param pm = NULL;

    pm = (Param) hcalloc(sizeof(struct param));

    pm->nam = dupstring(name);

    pm->flags = PM_SCALAR;

    pm->gsu.s = dis ? &pmdisfunction_gsu :  &pmfunction_gsu;

    if ((shf = (Shfunc) shfunctab->getnode2(shfunctab, name)) &&

	(dis ? (shf->flags & DISABLED) : !(shf->flags & DISABLED))) {

	if (shf->flags & PM_UNDEFINED) {

	    pm->u.str = dyncat("builtin autoload -X",

			       ((shf->flags & PM_UNALIASED) ?

				((shf->flags & PM_TAGGED) ? "Ut" : "U") :

				((shf->flags & PM_TAGGED) ? "t" : "")));

	} else {

	    char *t = getpermtext(shf->funcdef, NULL), *n, *h;

	    if (shf->funcdef->flags & EF_RUN) {

		n = nicedupstring(name);

		h = (char *) zhalloc(strlen(t) + strlen(n) + 9);

		h[0] = '\t';

		strcpy(h + 1, t);

		strcat(h, "\n\t");

		strcat(h, n);

		strcat(h, " \"$@\"");

	    } else

		h = dyncat("\t", t);

	    zsfree(t);

	    unmetafy(h, NULL);

	    pm->u.str = h;

	}

    } else {

	pm->u.str = dupstring("");

	pm->flags |= PM_UNSET;

    }

    return (HashNode) pm;

}

/**/

static HashNode

getpmfunction(HashTable ht, char *name)

{

    return getfunction(ht, name, 0);

}

/**/

static HashNode

getpmdisfunction(HashTable ht, char *name)

{

    return getfunction(ht, name, DISABLED);

}

/**/

static void

scanfunctions(UNUSED(HashTable ht), ScanFunc func, int flags, int dis)

{

    struct param pm;

    int i;

    HashNode hn;

    memset((void *)&pm, 0, sizeof(struct param));

    pm.flags = PM_SCALAR;

    pm.gsu.s = dis ? &pmdisfunction_gsu : &pmfunction_gsu;

    for (i = 0; i < shfunctab->hsize; i++)

	for (hn = shfunctab->nodes[i]; hn; hn = hn->next) {

	    if (dis ? (hn->flags & DISABLED) : !(hn->flags & DISABLED)) {

		pm.nam = hn->nam;

		if (func != scancountparams &&

		    ((flags & (SCANPM_WANTVALS|SCANPM_MATCHVAL)) ||

		     !(flags & SCANPM_WANTKEYS))) {

		    if (((Shfunc) hn)->flags & PM_UNDEFINED) {

			Shfunc shf = (Shfunc) hn;

			pm.u.str =

			    dyncat("builtin autoload -X",

				   ((shf->flags & PM_UNALIASED) ?

				    ((shf->flags & PM_TAGGED) ? "Ut" : "U") :

				    ((shf->flags & PM_TAGGED) ? "t" : "")));

		    } else {

			char *t = getpermtext(((Shfunc) hn)->funcdef, NULL), *n;

			if (((Shfunc) hn)->funcdef->flags & EF_RUN) {

			    n = nicedupstring(hn->nam);

			    pm.u.str = (char *) zhalloc(strlen(t) + strlen(n) + 9);

			    pm.u.str[0] = '\t';

			    strcpy(pm.u.str + 1, t);

			    strcat(pm.u.str, "\n\t");

			    strcat(pm.u.str, n);

			    strcat(pm.u.str, " \"$@\"");

			} else

			    pm.u.str = dyncat("\t", t);

			unmetafy(pm.u.str, NULL);

			zsfree(t);

		    }

		}

		func((HashNode) &pm, flags);

	    }

	}

}