path: root/Src/Modules/parameter.c

/*
 * parameter.c - parameter interface to zsh internals
 *
 * 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"

/* 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_REMOVABLE|PM_HASHED)))
	return NULL;

    pm->level = pm->old ? locallevel : 0;
    pm->gets.hfn = hashgetfn;
    pm->sets.hfn = hashsetfn;
    pm->unsetfn = stdunsetfn;
    pm->u.hash = ht = newhashtable(7, 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");
    } else
	val = dupstring("");

    return val;
}

/**/
static HashNode
getpmparameter(HashTable ht, char *name)
{
    Param rpm, pm = NULL;

    HEAPALLOC {
	pm = (Param) zhalloc(sizeof(struct param));
	pm->nam = dupstring(name);
	pm->flags = PM_SCALAR | PM_READONLY;
	pm->sets.cfn = NULL;
	pm->gets.cfn = strgetfn;
	pm->unsetfn = NULL;
	pm->ct = 0;
	pm->env = NULL;
	pm->ename = NULL;
	pm->old = NULL;
	pm->level = 0;
	if ((rpm = (Param) realparamtab->getnode(realparamtab, name)) &&
	    !(rpm->flags & PM_UNSET))
	    pm->u.str = paramtypestr(rpm);
	else {
	    pm->u.str = "";
	    pm->flags |= PM_UNSET;
	}
    } LASTALLOC;

    return (HashNode) pm;
}

/**/
static void
scanpmparameters(HashTable ht, ScanFunc func, int flags)
{
    struct param pm;
    int i;
    HashNode hn;

    pm.flags = PM_SCALAR | PM_READONLY;
    pm.sets.cfn = NULL;
    pm.gets.cfn = strgetfn;
    pm.unsetfn = NULL;
    pm.ct = 0;
    pm.env = NULL;
    pm.ename = NULL;
    pm.old = NULL;
    pm.level = 0;

    for (i = 0; i < realparamtab->hsize; i++)
	for (hn = realparamtab->nodes[i]; hn; hn = hn->next) {
	    pm.nam = hn->nam;
	    if (func != scancountparams)
		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))
	zwarnnam(NULL, "restricted: %s", value, 0);
    else {
	Cmdnam cn = zcalloc(sizeof(*cn));

	cn->flags = HASHED;
	cn->u.cmd = value;

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

/**/
static void
unsetpmcommand(Param pm, int exp)
{
    HashNode hn = cmdnamtab->removenode(cmdnamtab, pm->nam);

    if (hn)
	cmdnamtab->freenode(hn);
}

/**/
static void
setpmcommands(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 = zcalloc(sizeof(*cn));
	    struct value v;

	    v.isarr = v.inv = v.a = 0;
	    v.b = -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 HashNode
getpmcommand(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);
    }
    HEAPALLOC {
	pm = (Param) zhalloc(sizeof(struct param));
	pm->nam = dupstring(name);
	pm->flags = PM_SCALAR;
	pm->sets.cfn = setpmcommand;
	pm->gets.cfn = strgetfn;
	pm->unsetfn = unsetpmcommand;
	pm->ct = 0;
	pm->env = NULL;
	pm->ename = NULL;
	pm->old = NULL;
	pm->level = 0;
	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 = "";
	    pm->flags |= PM_UNSET;
	}
    } LASTALLOC;

    return (HashNode) pm;
}

/**/
static void
scanpmcommands(HashTable ht, ScanFunc func, int flags)
{
    struct param pm;
    int i;
    HashNode hn;
    Cmdnam cmd;

    if (isset(HASHLISTALL))
	cmdnamtab->filltable(cmdnamtab);

    pm.flags = PM_SCALAR;
    pm.sets.cfn = setpmcommand;
    pm.gets.cfn = strgetfn;
    pm.unsetfn = unsetpmcommand;
    pm.ct = 0;
    pm.env = NULL;
    pm.ename = NULL;
    pm.old = NULL;
    pm.level = 0;

    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) {
		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)
{
    char *value = dupstring(val);
    Shfunc shf;
    List list;
    int sn;

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

    HEAPALLOC {
	list = parse_string(val, 1);
    } LASTALLOC;

    if (!list || list == &dummy_list) {
	zwarnnam(NULL, "invalid function definition", value, 0);
	zsfree(val);
	return;
    }
    PERMALLOC {
	shf = (Shfunc) zalloc(sizeof(*shf));
	shf->funcdef = (List) dupstruct(list);
	shf->flags = 0;

	if (!strncmp(name, "TRAP", 4) &&
	    (sn = getsignum(name + 4)) != -1) {
	    if (settrap(sn, shf->funcdef)) {
		freestruct(shf->funcdef);
		zfree(shf, sizeof(*shf));
		zsfree(val);
		LASTALLOC_RETURN;
	    }
	    sigtrapped[sn] |= ZSIG_FUNC;
	}
	shfunctab->addnode(shfunctab, ztrdup(name), shf);
    } LASTALLOC;
    zsfree(val);
}

/**/
static void
setpmfunction(Param pm, char *value)
{
    setfunction(pm->nam, value);
}

/**/
static void
unsetpmfunction(Param pm, int exp)
{
    HashNode hn = shfunctab->removenode(shfunctab, pm->nam);

    if (hn)
	shfunctab->freenode(hn);
}

/**/
static void
setpmfunctions(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) {
	    struct value v;

	    v.isarr = v.inv = v.a = 0;
	    v.b = -1;
	    v.arr = NULL;
	    v.pm = (Param) hn;

	    setfunction(hn->nam, ztrdup(getstrvalue(&v)));
	}
    deleteparamtable(ht);
}

/**/
static HashNode
getpmfunction(HashTable ht, char *name)
{
    Shfunc shf;
    Param pm = NULL;

    HEAPALLOC {
	pm = (Param) zhalloc(sizeof(struct param));
	pm->nam = dupstring(name);
	pm->flags = PM_SCALAR;
	pm->sets.cfn = setpmfunction;
	pm->gets.cfn = strgetfn;
	pm->unsetfn = unsetpmfunction;
	pm->ct = 0;
	pm->env = NULL;
	pm->ename = NULL;
	pm->old = NULL;
	pm->level = 0;

	if ((shf = (Shfunc) shfunctab->getnode(shfunctab, name))) {
	    if (shf->flags & PM_UNDEFINED)
		pm->u.str = tricat("builtin autoload -X",
				   ((shf->flags & PM_UNALIASED)? "U" : ""),
				   ((shf->flags & PM_TAGGED)? "t" : ""));
	    else {
		char *t = getpermtext((void *) dupstruct((void *)
							 shf->funcdef)), *h;

		h = dupstring(t);
		zsfree(t);
		unmetafy(h, NULL);

		pm->u.str = h;
	    }
	} else {
	    pm->u.str = "";
	    pm->flags |= PM_UNSET;
	}
    } LASTALLOC;

    return (HashNode) pm;
}

/**/
static void
scanpmfunctions(HashTable ht, ScanFunc func, int flags)
{
    struct param pm;
    int i;
    HashNode hn;

    pm.flags = PM_SCALAR;
    pm.sets.cfn = setpmcommand;
    pm.gets.cfn = strgetfn;
    pm.unsetfn = unsetpmcommand;
    pm.ct = 0;
    pm.env = NULL;
    pm.ename = NULL;
    pm.old = NULL;
    pm.level = 0;

    for (i = 0; i < shfunctab->hsize; i++)
	for (hn = shfunctab->nodes[i]; hn; hn = hn->next) {
	    if (!(hn->flags & DISABLED)) {
		pm.nam = hn->nam;
		if (func != scancountparams) {
		    if (((Shfunc) hn)->flags & PM_UNDEFINED) {
			Shfunc shf = (Shfunc) hn;
			pm.u.str = tricat("builtin autoload -X",
					  ((shf->flags & PM_UNALIASED)? "U" : ""),
					  ((shf->flags & PM_TAGGED)? "t" : ""));
		    } else {
			char *t = getpermtext((void *)
					      dupstruct((void *) ((Shfunc) hn)->funcdef));

			unmetafy((pm.u.str = dupstring(t)), NULL);
			zsfree(t);
		    }
		}
		func((HashNode) &pm, flags);
	    }
	}
}

/* Functions for the options special parameter. */

/**/
static void
setpmoption(Param pm, char *value)
{
    int n;

    if (!value || (strcmp(value, "on") && strcmp(value, "off")))
	zwarnnam(NULL, "invalid value: %s", value, 0);
    else if (!(n = optlookup(pm->nam)))
	zwarnnam(NULL, "no such option: %s", pm->nam, 0);
    else if (dosetopt(n, (value && strcmp(value, "off")), 0))
	zwarnnam(NULL, "can't change option: %s", pm->nam, 0);
    zsfree(value);
}

/**/
static void
unsetpmoption(Param pm, int exp)
{
    int n;

    if (!(n = optlookup(pm->nam)))
	zwarnnam(NULL, "no such option: %s", pm->nam, 0);
    else if (dosetopt(n, 0, 0))
	zwarnnam(NULL, "can't change option: %s", pm->nam, 0);
}

/**/
static void
setpmoptions(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) {
	    struct value v;
	    char *val;

	    v.isarr = v.inv = v.a = 0;
	    v.b = -1;
	    v.arr = NULL;
	    v.pm = (Param) hn;

	    val = getstrvalue(&v);
	    if (!val || (strcmp(val, "on") && strcmp(val, "off")))
		zwarnnam(NULL, "invalid value: %s", val, 0);
	    else if (dosetopt(optlookup(hn->nam),
			      (val && strcmp(val, "off")), 0))
		zwarnnam(NULL, "can't change option: %s", hn->nam, 0);
	}
    deleteparamtable(ht);
}

/**/
static HashNode
getpmoption(HashTable ht, char *name)
{
    Param pm = NULL;
    int n;

    HEAPALLOC {
	pm = (Param) zhalloc(sizeof(struct param));
	pm->nam = dupstring(name);
	pm->flags = PM_SCALAR;
	pm->sets.cfn = setpmoption;
	pm->gets.cfn = strgetfn;
	pm->unsetfn = unsetpmoption;
	pm->ct = 0;
	pm->env = NULL;
	pm->ename = NULL;
	pm->old = NULL;
	pm->level = 0;

	if ((n = optlookup(name)))
	    pm->u.str = dupstring(opts[n] ? "on" : "off");
	else {
	    pm->u.str = "";
	    pm->flags |= PM_UNSET;
	}
    } LASTALLOC;

    return (HashNode) pm;
}

/**/
static void
scanpmoptions(HashTable ht, ScanFunc func, int flags)
{
    struct param pm;
    int i;
    HashNode hn;

    pm.flags = PM_SCALAR;
    pm.sets.cfn = setpmoption;
    pm.gets.cfn = strgetfn;
    pm.unsetfn = unsetpmoption;
    pm.ct = 0;
    pm.env = NULL;
    pm.ename = NULL;
    pm.old = NULL;
    pm.level = 0;

    for (i = 0; i < optiontab->hsize; i++)
	for (hn = optiontab->nodes[i]; hn; hn = hn->next) {
	    pm.nam = hn->nam;
	    pm.u.str = opts[((Optname) hn)->optno] ? "on" : "off";
	    func((HashNode) &pm, flags);
	}
}

/* Functions for the modules special parameter. */

static char *modpmname;
static int modpmfound;

/**/
static void
modpmbuiltinscan(HashNode hn, int dummy)
{
    if (!(((Builtin) hn)->flags & BINF_ADDED) &&
	!strcmp(((Builtin) hn)->optstr, modpmname))
	modpmfound = 1;
}

/**/
static void
modpmparamscan(HashNode hn, int dummy)
{
    if ((((Param) hn)->flags & PM_AUTOLOAD) &&
	!strcmp(((Param) hn)->u.str, modpmname))
	modpmfound = 1;
}

/**/
static int
findmodnode(LinkList l, char *nam)
{
    LinkNode node;

    for (node = firstnode(l); node; incnode(node))
	if (!strcmp(nam, (char *) getdata(node)))
	    return 1;

    return 0;
}

/**/
static HashNode
getpmmodule(HashTable ht, char *name)
{
    Param pm = NULL;
    char *type = NULL;
    LinkNode node;

    HEAPALLOC {
	pm = (Param) zhalloc(sizeof(struct param));
	pm->nam = dupstring(name);
	pm->flags = PM_SCALAR | PM_READONLY;
	pm->sets.cfn = NULL;
	pm->gets.cfn = strgetfn;
	pm->unsetfn = NULL;
	pm->ct = 0;
	pm->env = NULL;
	pm->ename = NULL;
	pm->old = NULL;
	pm->level = 0;

	for (node = firstnode(bltinmodules); node; incnode(node))
	    if (!strcmp(name, (char *) getdata(node))) {
		type = "builtin";
		break;
	    }
#ifdef DYNAMIC
	if (!type) {
	    Module m;

	    for (node = firstnode(modules); node; incnode(node)) {
		m = (Module) getdata(node);
		if (m->handle && !(m->flags & MOD_UNLOAD) &&
		    !strcmp(name, m->nam)) {
		    type = "loaded";
		    break;
		}
	    }
	}
	modpmname = name;
	modpmfound = 0;
	if (!type) {
	    scanhashtable(builtintab, 0, 0, 0, modpmbuiltinscan, 0);
	    if (!modpmfound) {
		Conddef p;

		for (p = condtab; p; p = p->next)
		    if (p->module && !strcmp(name, p->module)) {
			modpmfound = 1;
			break;
		    }
		if (!modpmfound)
		    scanhashtable(realparamtab, 0, 0, 0, modpmparamscan, 0);
	    }
	    if (modpmfound)
		type = "autoloaded";
	}
#endif
	if (type)
	    pm->u.str = type;
	else {
	    pm->u.str = "";
	    pm->flags |= PM_UNSET;
	}
    } LASTALLOC;

    return (HashNode) pm;
}

/**/
static void
scanpmmodules(HashTable ht, ScanFunc func, int flags)
{
    struct param pm;
    int i;
    HashNode hn;
    LinkList done = newlinklist();
    LinkNode node;
    Module m;
    Conddef p;

    pm.flags = PM_SCALAR | PM_READONLY;
    pm.sets.cfn = NULL;
    pm.gets.cfn = strgetfn;
    pm.unsetfn = NULL;
    pm.ct = 0;
    pm.env = NULL;
    pm.ename = NULL;
    pm.old = NULL;
    pm.level = 0;

    for (node = firstnode(bltinmodules); node; incnode(node)) {
	pm.nam = (char *) getdata(node);
	addlinknode(done, pm.nam);
	pm.u.str = "builtin";
	func((HashNode) &pm, flags);
    }
#ifdef DYNAMIC
    for (node = firstnode(modules); node; incnode(node)) {
	m = (Module) getdata(node);
	if (m->handle && !(m->flags & MOD_UNLOAD)) {
	    pm.nam = m->nam;
	    addlinknode(done, pm.nam);
	    pm.u.str = "loaded";
	    func((HashNode) &pm, flags);
	}
    }
    for (i = 0; i < builtintab->hsize; i++)
	for (hn = builtintab->nodes[i]; hn; hn = hn->next) {
	    if (!(((Builtin) hn)->flags & BINF_ADDED) &&
		!findmodnode(done, ((Builtin) hn)->optstr)) {
		pm.nam = ((Builtin) hn)->optstr;
		addlinknode(done, pm.nam);
		pm.u.str = "autoloaded";
		func((HashNode) &pm, flags);
	    }
	}
    for (p = condtab; p; p = p->next)
	if (p->module && !findmodnode(done, p->module)) {
	    pm.nam = p->module;
	    addlinknode(done, pm.nam);
	    pm.u.str = "autoloaded";
	    func((HashNode) &pm, flags);
	}
    for (i = 0; i < realparamtab->hsize; i++)
	for (hn = realparamtab->nodes[i]; hn; hn = hn->next) {
	    if ((((Param) hn)->flags & PM_AUTOLOAD) &&
		!findmodnode(done, ((Param) hn)->u.str)) {
		pm.nam = ((Param) hn)->u.str;
		addlinknode(done, pm.nam);
		pm.u.str = "autoloaded";
		func((HashNode) &pm, flags);
	    }
	}
#endif
}

/* Functions for the dirstack special parameter. */

static void
dirssetfn(Param pm, char **x)
{
    PERMALLOC {
	freelinklist(dirstack, freestr);
	dirstack = newlinklist();
	while (x && *x)
	    addlinknode(dirstack, ztrdup(*x++));
    } LASTALLOC;
}

static char **
dirsgetfn(Param pm)
{
    int l = countlinknodes(dirstack);
    char **ret = (char **) zhalloc((l + 1) * sizeof(char *)), **p;
    LinkNode n;

    for (n = firstnode(dirstack), p = ret; n; incnode(n), p++)
	*p = dupstring((char *) getdata(n));
    *p = NULL;

    return ret;
}

/* Names and Params for the special parameters. */

#define PAR_NAM "parameters"
#define CMD_NAM "commands"
#define FUN_NAM "functions"
#define OPT_NAM "options"
#define MOD_NAM "modules"
#define DIR_NAM "dirstack"

static Param parpm, cmdpm, funpm, optpm, modpm, dirpm;

/**/
int
setup_parameter(Module m)
{
    return 0;
}

/**/
int
boot_parameter(Module m)
{
    /* Create the special associative arrays.
     * As an example for autoloaded parameters, this is probably a bad
     * example, because the zsh core doesn't support creation of
     * special hashes, yet. */

    unsetparam(PAR_NAM);
    if (!(parpm = createspecialhash(PAR_NAM, getpmparameter,
				    scanpmparameters)))
	return 1;
    parpm->flags |= PM_READONLY;
    unsetparam(CMD_NAM);
    if (!(cmdpm = createspecialhash(CMD_NAM, getpmcommand,
				    scanpmcommands)))
	return 1;
    cmdpm->sets.hfn = setpmcommands;
    unsetparam(FUN_NAM);
    if (!(funpm = createspecialhash(FUN_NAM, getpmfunction,
				    scanpmfunctions)))
	return 1;
    funpm->sets.hfn = setpmfunctions;
    unsetparam(OPT_NAM);
    if (!(optpm = createspecialhash(OPT_NAM, getpmoption,
				    scanpmoptions)))
	return 1;
    optpm->sets.hfn = setpmoptions;
    unsetparam(MOD_NAM);
    if (!(modpm = createspecialhash(MOD_NAM, getpmmodule,
				    scanpmmodules)))
	return 1;
    modpm->flags |= PM_READONLY;
    unsetparam(DIR_NAM);
    if (!(dirpm = createparam(DIR_NAM,
			      PM_ARRAY|PM_HIDE|PM_SPECIAL|PM_REMOVABLE)))
	return 1;
    dirpm->sets.afn = dirssetfn;
    dirpm->gets.afn = dirsgetfn;
    dirpm->unsetfn = stdunsetfn;

    return 0;
}

#ifdef MODULE

/**/
int
cleanup_parameter(Module m)
{
    Param pm;

    /* Remove the special parameters if they are still the same. */

    if ((pm = (Param) paramtab->getnode(paramtab, PAR_NAM)) && pm == parpm) {
	pm->flags &= ~PM_READONLY;
	unsetparam_pm(pm, 0, 1);
    }
    if ((pm = (Param) paramtab->getnode(paramtab, CMD_NAM)) && pm == cmdpm)
	unsetparam_pm(pm, 0, 1);
    if ((pm = (Param) paramtab->getnode(paramtab, FUN_NAM)) && pm == funpm)
	unsetparam_pm(pm, 0, 1);
    if ((pm = (Param) paramtab->getnode(paramtab, OPT_NAM)) && pm == optpm)
	unsetparam_pm(pm, 0, 1);
    if ((pm = (Param) paramtab->getnode(paramtab, MOD_NAM)) && pm == modpm) {
	pm->flags &= ~PM_READONLY;
	unsetparam_pm(pm, 0, 1);
    }
    if ((pm = (Param) paramtab->getnode(paramtab, DIR_NAM)) && pm == dirpm)
	unsetparam_pm(pm, 0, 1);
    return 0;
}

/**/
int
finish_parameter(Module m)
{
    return 0;
}

#endif