1N/A/***********************************************************************
1N/A* *
1N/A* This software is part of the ast package *
1N/A* Copyright (c) 1982-2011 AT&T Intellectual Property *
1N/A* and is licensed under the *
1N/A* Common Public License, Version 1.0 *
1N/A* by AT&T Intellectual Property *
1N/A* *
1N/A* A copy of the License is available at *
1N/A* http://www.opensource.org/licenses/cpl1.0.txt *
1N/A* (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9) *
1N/A* *
1N/A* Information and Software Systems Research *
1N/A* AT&T Research *
1N/A* Florham Park NJ *
1N/A* *
1N/A* David Korn <dgk@research.att.com> *
1N/A* *
1N/A***********************************************************************/
1N/A#pragma prototyped
1N/A/*
1N/A * AT&T Labs
1N/A *
1N/A */
1N/A
1N/A#define putenv ___putenv
1N/A
1N/A#include "defs.h"
1N/A#include "variables.h"
1N/A#include "path.h"
1N/A#include "lexstates.h"
1N/A#include "timeout.h"
1N/A#include "FEATURE/externs"
1N/A#include "streval.h"
1N/A
1N/A#define NVCACHE 8 /* must be a power of 2 */
1N/A#define Empty ((char*)(e_sptbnl+3))
1N/Astatic char *savesub = 0;
1N/Astatic char Null[1];
1N/Astatic Namval_t NullNode;
1N/Astatic Dt_t *Refdict;
1N/Astatic Dtdisc_t _Refdisc =
1N/A{
1N/A offsetof(struct Namref,np),sizeof(struct Namval_t*),sizeof(struct Namref)
1N/A};
1N/A
1N/A#if !_lib_pathnative && _lib_uwin_path
1N/A
1N/A#define _lib_pathnative 1
1N/A
1N/Aextern int uwin_path(const char*, char*, int);
1N/A
1N/Asize_t
1N/Apathnative(const char* path, char* buf, size_t siz)
1N/A{
1N/A return uwin_path(path, buf, siz);
1N/A}
1N/A
1N/A#endif /* _lib_pathnative */
1N/A
1N/Astatic void attstore(Namval_t*,void*);
1N/A#ifndef _ENV_H
1N/A static void pushnam(Namval_t*,void*);
1N/A static char *staknam(Namval_t*, char*);
1N/A#endif
1N/Astatic void rightjust(char*, int, int);
1N/Astatic char *lastdot(char*, int);
1N/A
1N/Astruct adata
1N/A{
1N/A Shell_t *sh;
1N/A Namval_t *tp;
1N/A char *mapname;
1N/A char **argnam;
1N/A int attsize;
1N/A char *attval;
1N/A};
1N/A
1N/A#if SHOPT_TYPEDEF
1N/A struct sh_type
1N/A {
1N/A void *previous;
1N/A Namval_t **nodes;
1N/A Namval_t *rp;
1N/A short numnodes;
1N/A short maxnodes;
1N/A };
1N/A#endif /*SHOPT_TYPEDEF */
1N/A
1N/A#if NVCACHE
1N/A struct Namcache
1N/A {
1N/A struct Cache_entry
1N/A {
1N/A Dt_t *root;
1N/A Dt_t *last_root;
1N/A char *name;
1N/A Namval_t *np;
1N/A Namval_t *last_table;
1N/A int flags;
1N/A short size;
1N/A short len;
1N/A } entries[NVCACHE];
1N/A short index;
1N/A short ok;
1N/A };
1N/A static struct Namcache nvcache;
1N/A#endif
1N/A
1N/Achar nv_local = 0;
1N/A#ifndef _ENV_H
1N/Astatic void(*nullscan)(Namval_t*,void*);
1N/A#endif
1N/A
1N/A#if ( SFIO_VERSION <= 20010201L )
1N/A# define _data data
1N/A#endif
1N/A
1N/A#if !SHOPT_MULTIBYTE
1N/A# define mbchar(p) (*(unsigned char*)p++)
1N/A#endif /* SHOPT_MULTIBYTE */
1N/A
1N/A/* ======== name value pair routines ======== */
1N/A
1N/A#include "shnodes.h"
1N/A#include "builtins.h"
1N/A
1N/Astatic char *getbuf(size_t len)
1N/A{
1N/A static char *buf;
1N/A static size_t buflen;
1N/A if(buflen < len)
1N/A {
1N/A if(buflen==0)
1N/A buf = (char*)malloc(len);
1N/A else
1N/A buf = (char*)realloc(buf,len);
1N/A buflen = len;
1N/A }
1N/A return(buf);
1N/A}
1N/A
1N/A#ifdef _ENV_H
1N/Avoid sh_envput(Env_t* ep,Namval_t *np)
1N/A{
1N/A int offset = staktell();
1N/A Namarr_t *ap = nv_arrayptr(np);
1N/A char *val;
1N/A if(ap)
1N/A {
1N/A if(ap->nelem&ARRAY_UNDEF)
1N/A nv_putsub(np,"0",0L);
1N/A else if(!(val=nv_getsub(np)) || strcmp(val,"0"))
1N/A return;
1N/A }
1N/A if(!(val = nv_getval(np)))
1N/A return;
1N/A stakputs(nv_name(np));
1N/A stakputc('=');
1N/A stakputs(val);
1N/A stakseek(offset);
1N/A env_add(ep,stakptr(offset),ENV_STRDUP);
1N/A}
1N/A#endif
1N/A
1N/A/*
1N/A * output variable name in format for re-input
1N/A */
1N/Avoid nv_outname(Sfio_t *out, char *name, int len)
1N/A{
1N/A const char *cp=name, *sp;
1N/A int c, offset = staktell();
1N/A while(sp= strchr(cp,'['))
1N/A {
1N/A if(len>0 && cp+len <= sp)
1N/A break;
1N/A sfwrite(out,cp,++sp-cp);
1N/A stakseek(offset);
1N/A while(c= *sp++)
1N/A {
1N/A if(c==']')
1N/A break;
1N/A else if(c=='\\')
1N/A {
1N/A if(*sp=='[' || *sp==']' || *sp=='\\')
1N/A c = *sp++;
1N/A }
1N/A stakputc(c);
1N/A }
1N/A stakputc(0);
1N/A sfputr(out,sh_fmtq(stakptr(offset)),-1);
1N/A if(len>0)
1N/A {
1N/A sfputc(out,']');
1N/A return;
1N/A }
1N/A cp = sp-1;
1N/A }
1N/A if(*cp)
1N/A {
1N/A if(len>0)
1N/A sfwrite(out,cp,len);
1N/A else
1N/A sfputr(out,cp,-1);
1N/A }
1N/A stakseek(offset);
1N/A}
1N/A
1N/A#if SHOPT_TYPEDEF
1N/ANamval_t *nv_addnode(Namval_t* np, int remove)
1N/A{
1N/A Shell_t *shp = sh_getinterp();
1N/A register struct sh_type *sp = (struct sh_type*)shp->mktype;
1N/A register int i;
1N/A register char *name=0;
1N/A if(sp->numnodes==0 && !nv_isnull(np) && shp->last_table)
1N/A {
1N/A /* could be an redefine */
1N/A Dt_t *root = nv_dict(shp->last_table);
1N/A sp->rp = np;
1N/A nv_delete(np,root,NV_NOFREE);
1N/A np = nv_search(sp->rp->nvname,root,NV_ADD);
1N/A }
1N/A if(sp->numnodes && memcmp(np->nvname,NV_CLASS,sizeof(NV_CLASS)-1))
1N/A {
1N/A name = (sp->nodes[0])->nvname;
1N/A i = strlen(name);
1N/A if(memcmp(np->nvname,name,i))
1N/A return(np);
1N/A }
1N/A if(sp->rp && sp->numnodes)
1N/A {
1N/A /* check for a redefine */
1N/A if(name && np->nvname[i]=='.' && np->nvname[i+1]=='_' && np->nvname[i+2]==0)
1N/A sp->rp = 0;
1N/A else
1N/A {
1N/A Dt_t *root = nv_dict(shp->last_table);
1N/A nv_delete(sp->nodes[0],root,NV_NOFREE);
1N/A dtinsert(root,sp->rp);
1N/A errormsg(SH_DICT,ERROR_exit(1),e_redef,sp->nodes[0]->nvname);
1N/A }
1N/A }
1N/A for(i=0; i < sp->numnodes; i++)
1N/A {
1N/A if(np == sp->nodes[i])
1N/A {
1N/A if(remove)
1N/A {
1N/A while(++i < sp->numnodes)
1N/A sp->nodes[i-1] = sp->nodes[i];
1N/A sp->numnodes--;
1N/A }
1N/A return(np);
1N/A }
1N/A }
1N/A if(remove)
1N/A return(np);
1N/A if(sp->numnodes==sp->maxnodes)
1N/A {
1N/A sp->maxnodes += 20;
1N/A sp->nodes = (Namval_t**)realloc(sp->nodes,sizeof(Namval_t*)*sp->maxnodes);
1N/A }
1N/A sp->nodes[sp->numnodes++] = np;
1N/A return(np);
1N/A}
1N/A#endif /* SHOPT_TYPEDEF */
1N/A
1N/A/*
1N/A * given a list of assignments, determine <name> is on the list
1N/A returns a pointer to the argnod on the list or NULL
1N/A */
1N/Astruct argnod *nv_onlist(struct argnod *arg, const char *name)
1N/A{
1N/A char *cp;
1N/A int len = strlen(name);
1N/A for(;arg; arg=arg->argnxt.ap)
1N/A {
1N/A if(*arg->argval==0 && arg->argchn.ap && !(arg->argflag&~(ARG_APPEND|ARG_QUOTED|ARG_MESSAGE)))
1N/A cp = ((struct fornod*)arg->argchn.ap)->fornam;
1N/A else
1N/A cp = arg->argval;
1N/A if(memcmp(cp,name,len)==0 && (cp[len]==0 || cp[len]=='='))
1N/A return(arg);
1N/A }
1N/A return(0);
1N/A}
1N/A
1N/A/*
1N/A * Perform parameter assignment for a linked list of parameters
1N/A * <flags> contains attributes for the parameters
1N/A */
1N/Avoid nv_setlist(register struct argnod *arg,register int flags, Namval_t *typ)
1N/A{
1N/A Shell_t *shp = sh_getinterp();
1N/A register char *cp;
1N/A register Namval_t *np, *mp;
1N/A char *trap=shp->st.trap[SH_DEBUGTRAP];
1N/A char *prefix = shp->prefix;
1N/A int traceon = (sh_isoption(SH_XTRACE)!=0);
1N/A int array = (flags&(NV_ARRAY|NV_IARRAY));
1N/A Namarr_t *ap;
1N/A Namval_t node;
1N/A struct Namref nr;
1N/A#if SHOPT_TYPEDEF
1N/A int maketype = flags&NV_TYPE;
1N/A struct sh_type shtp;
1N/A if(maketype)
1N/A {
1N/A shtp.previous = shp->mktype;
1N/A shp->mktype=(void*)&shtp;
1N/A shtp.numnodes=0;
1N/A shtp.maxnodes = 20;
1N/A shtp.rp = 0;
1N/A shtp.nodes =(Namval_t**)malloc(shtp.maxnodes*sizeof(Namval_t*));
1N/A }
1N/A#endif /* SHOPT_TYPEDEF*/
1N/A#if SHOPT_NAMESPACE
1N/A if(shp->namespace && nv_dict(shp->namespace)==shp->var_tree)
1N/A flags |= NV_NOSCOPE;
1N/A#endif /* SHOPT_NAMESPACE */
1N/A flags &= ~(NV_TYPE|NV_ARRAY|NV_IARRAY);
1N/A if(sh_isoption(SH_ALLEXPORT))
1N/A flags |= NV_EXPORT;
1N/A if(shp->prefix)
1N/A {
1N/A flags &= ~(NV_IDENT|NV_EXPORT);
1N/A flags |= NV_VARNAME;
1N/A }
1N/A for(;arg; arg=arg->argnxt.ap)
1N/A {
1N/A shp->used_pos = 0;
1N/A if(arg->argflag&ARG_MAC)
1N/A {
1N/A shp->prefix = 0;
1N/A cp = sh_mactrim(shp,arg->argval,(flags&NV_NOREF)?-3:-1);
1N/A shp->prefix = prefix;
1N/A }
1N/A else
1N/A {
1N/A stakseek(0);
1N/A if(*arg->argval==0 && arg->argchn.ap && !(arg->argflag&~(ARG_APPEND|ARG_QUOTED|ARG_MESSAGE)))
1N/A {
1N/A int flag = (NV_VARNAME|NV_ARRAY|NV_ASSIGN);
1N/A int sub=0;
1N/A struct fornod *fp=(struct fornod*)arg->argchn.ap;
1N/A register Shnode_t *tp=fp->fortre;
1N/A flag |= (flags&(NV_NOSCOPE|NV_STATIC|NV_FARRAY));
1N/A if(arg->argflag&ARG_QUOTED)
1N/A cp = sh_mactrim(shp,fp->fornam,-1);
1N/A else
1N/A cp = fp->fornam;
1N/A error_info.line = fp->fortyp-shp->st.firstline;
1N/A if(!array && tp->tre.tretyp!=TLST && tp->com.comset && !tp->com.comarg && tp->com.comset->argval[0]==0 && tp->com.comset->argval[1]=='[')
1N/A array |= (tp->com.comset->argflag&ARG_MESSAGE)?NV_IARRAY:NV_ARRAY;
1N/A if(shp->fn_depth && (Namval_t*)tp->com.comnamp==SYSTYPESET)
1N/A flag |= NV_NOSCOPE;
1N/A if(prefix && tp->com.comset && *cp=='[')
1N/A {
1N/A shp->prefix = 0;
1N/A np = nv_open(prefix,shp->var_tree,flag);
1N/A shp->prefix = prefix;
1N/A if(np)
1N/A {
1N/A if(nv_isvtree(np) && !nv_isarray(np))
1N/A {
1N/A stakputc('.');
1N/A stakputs(cp);
1N/A cp = stakfreeze(1);
1N/A }
1N/A nv_close(np);
1N/A }
1N/A }
1N/A np = nv_open(cp,shp->var_tree,flag|NV_ASSIGN);
1N/A if(nv_isattr(np,NV_NOFREE) && nv_isnull(np))
1N/A nv_offattr(np,NV_NOFREE);
1N/A if(nv_istable(np))
1N/A _nv_unset(np,0);
1N/A if(typ && !array && (!shp->prefix || nv_isnull(np) || nv_isarray(np)))
1N/A {
1N/A if(!(nv_isnull(np)) && !nv_isarray(np))
1N/A _nv_unset(np,0);
1N/A nv_settype(np,typ,0);
1N/A }
1N/A if((flags&NV_STATIC) && !nv_isattr(np,NV_EXPORT) && !nv_isnull(np))
1N/A#if SHOPT_TYPEDEF
1N/A goto check_type;
1N/A#else
1N/A continue;
1N/A#endif /* SHOPT_TYPEDEF */
1N/A#if SHOPT_FIXEDARRAY
1N/A if((ap=nv_arrayptr(np)) && ap->fixed)
1N/A flags |= NV_FARRAY;
1N/A if(array && (!ap || !ap->hdr.type))
1N/A {
1N/A if(!(arg->argflag&ARG_APPEND) && (!ap || !ap->fixed))
1N/A#else
1N/A if(array && (!(ap=nv_arrayptr(np)) || !ap->hdr.type))
1N/A {
1N/A if(!(arg->argflag&ARG_APPEND))
1N/A#endif /* SHOPT_FIXEDARRAY */
1N/A _nv_unset(np,NV_EXPORT);
1N/A if(array&NV_ARRAY)
1N/A {
1N/A nv_setarray(np,nv_associative);
1N/A }
1N/A else
1N/A {
1N/A nv_onattr(np,NV_ARRAY);
1N/A }
1N/A }
1N/A if(array && tp->tre.tretyp!=TLST && !tp->com.comset && !tp->com.comarg)
1N/A {
1N/A#if SHOPT_TYPEDEF
1N/A goto check_type;
1N/A#else
1N/A continue;
1N/A#endif /* SHOPT_TYPEDEF */
1N/A }
1N/A /* check for array assignment */
1N/A if(tp->tre.tretyp!=TLST && tp->com.comarg && !tp->com.comset && ((array&NV_IARRAY) || !((mp=tp->com.comnamp) && nv_isattr(mp,BLT_DCL))))
1N/A {
1N/A int argc;
1N/A Dt_t *last_root = shp->last_root;
1N/A char **argv = sh_argbuild(shp,&argc,&tp->com,0);
1N/A shp->last_root = last_root;
1N/A#if SHOPT_TYPEDEF
1N/A if(shp->mktype && shp->dot_depth==0 && np==((struct sh_type*)shp->mktype)->nodes[0])
1N/A {
1N/A shp->mktype = 0;
1N/A errormsg(SH_DICT,ERROR_exit(1),"%s: not a known type name",argv[0]);
1N/A }
1N/A#endif /* SHOPT_TYPEDEF */
1N/A if(!(arg->argflag&ARG_APPEND))
1N/A {
1N/A#if SHOPT_FIXEDARRAY
1N/A if(!nv_isarray(np) || ((ap=nv_arrayptr(np)) && !ap->fixed && (ap->nelem&ARRAY_MASK)))
1N/A#else
1N/A if(!nv_isarray(np) || ((ap=nv_arrayptr(np)) && (ap->nelem&ARRAY_MASK)))
1N/A#endif /* SHOPT_FIXEDARRAY */
1N/A _nv_unset(np,0);
1N/A }
1N/A nv_setvec(np,(arg->argflag&ARG_APPEND),argc,argv);
1N/A if(traceon || trap)
1N/A {
1N/A int n = -1;
1N/A char *name = nv_name(np);
1N/A if(arg->argflag&ARG_APPEND)
1N/A n = '+';
1N/A if(trap)
1N/A sh_debug(shp,trap,name,(char*)0,argv,(arg->argflag&ARG_APPEND)|ARG_ASSIGN);
1N/A if(traceon)
1N/A {
1N/A sh_trace(shp,NIL(char**),0);
1N/A sfputr(sfstderr,name,n);
1N/A sfwrite(sfstderr,"=( ",3);
1N/A while(cp= *argv++)
1N/A sfputr(sfstderr,sh_fmtq(cp),' ');
1N/A sfwrite(sfstderr,")\n",2);
1N/A }
1N/A }
1N/A#if SHOPT_TYPEDEF
1N/A goto check_type;
1N/A#else
1N/A continue;
1N/A#endif /* SHOPT_TYPEDEF */
1N/A }
1N/A if((tp->tre.tretyp&COMMSK)==TFUN)
1N/A goto skip;
1N/A if(tp->tre.tretyp==TLST || !tp->com.comset || tp->com.comset->argval[0]!='[')
1N/A {
1N/A if(tp->tre.tretyp!=TLST && !tp->com.comnamp && tp->com.comset && tp->com.comset->argval[0]==0 && tp->com.comset->argchn.ap)
1N/A {
1N/A if(prefix)
1N/A cp = stakcopy(nv_name(np));
1N/A shp->prefix = cp;
1N/A if(tp->com.comset->argval[1]=='[')
1N/A {
1N/A if((arg->argflag&ARG_APPEND) && (!nv_isarray(np) || (nv_aindex(np)>=0)))
1N/A _nv_unset(np,0);
1N/A if(!(array&NV_IARRAY) && !(tp->com.comset->argflag&ARG_MESSAGE))
1N/A nv_setarray(np,nv_associative);
1N/A }
1N/A nv_setlist(tp->com.comset,flags&~NV_STATIC,0);
1N/A shp->prefix = prefix;
1N/A if(tp->com.comset->argval[1]!='[')
1N/A nv_setvtree(np);
1N/A nv_close(np);
1N/A#if SHOPT_TYPEDEF
1N/A goto check_type;
1N/A#else
1N/A continue;
1N/A#endif /* SHOPT_TYPEDEF */
1N/A }
1N/A if(*cp!='.' && *cp!='[' && strchr(cp,'['))
1N/A {
1N/A nv_close(np);
1N/A np = nv_open(cp,shp->var_tree,flag);
1N/A }
1N/A if(arg->argflag&ARG_APPEND)
1N/A {
1N/A if(nv_isarray(np))
1N/A {
1N/A if((sub=nv_aimax(np)) < 0 && nv_arrayptr(np))
1N/A errormsg(SH_DICT,ERROR_exit(1),e_badappend,nv_name(np));
1N/A if(sub>=0)
1N/A sub++;
1N/A }
1N/A if(!nv_isnull(np) && np->nvalue.cp!=Empty && !nv_isvtree(np))
1N/A sub=1;
1N/A }
1N/A else if(((np->nvalue.cp && np->nvalue.cp!=Empty)||nv_isvtree(np)) && !nv_type(np))
1N/A _nv_unset(np,NV_EXPORT);
1N/A }
1N/A else
1N/A {
1N/A if(!(arg->argflag&ARG_APPEND))
1N/A _nv_unset(np,NV_EXPORT);
1N/A if(!sh_isoption(SH_BASH) && !(array&NV_IARRAY) && !nv_isarray(np))
1N/A nv_setarray(np,nv_associative);
1N/A }
1N/A skip:
1N/A if(sub>0)
1N/A {
1N/A sfprintf(stkstd,"%s[%d]",prefix?nv_name(np):cp,sub);
1N/A shp->prefix = stakfreeze(1);
1N/A nv_putsub(np,(char*)0,ARRAY_ADD|ARRAY_FILL|sub);
1N/A }
1N/A else if(prefix)
1N/A shp->prefix = stakcopy(nv_name(np));
1N/A else
1N/A shp->prefix = cp;
1N/A shp->last_table = 0;
1N/A if(shp->prefix)
1N/A {
1N/A if(*shp->prefix=='_' && shp->prefix[1]=='.' && nv_isref(L_ARGNOD))
1N/A {
1N/A sfprintf(stkstd,"%s%s",nv_name(L_ARGNOD->nvalue.nrp->np),shp->prefix+1);
1N/A shp->prefix = stkfreeze(stkstd,1);
1N/A }
1N/A memset(&nr,0,sizeof(nr));
1N/A memcpy(&node,L_ARGNOD,sizeof(node));
1N/A L_ARGNOD->nvalue.nrp = &nr;
1N/A nr.np = np;
1N/A nr.root = shp->last_root;
1N/A nr.table = shp->last_table;
1N/A L_ARGNOD->nvflag = NV_REF|NV_NOFREE;
1N/A L_ARGNOD->nvfun = 0;
1N/A }
1N/A sh_exec(tp,sh_isstate(SH_ERREXIT));
1N/A#if SHOPT_TYPEDEF
1N/A if(shp->prefix)
1N/A#endif
1N/A {
1N/A L_ARGNOD->nvalue.nrp = node.nvalue.nrp;
1N/A L_ARGNOD->nvflag = node.nvflag;
1N/A L_ARGNOD->nvfun = node.nvfun;
1N/A }
1N/A shp->prefix = prefix;
1N/A if(nv_isarray(np) && (mp=nv_opensub(np)))
1N/A np = mp;
1N/A while(tp->tre.tretyp==TLST)
1N/A {
1N/A if(!tp->lst.lstlef || !tp->lst.lstlef->tre.tretyp==TCOM || tp->lst.lstlef->com.comarg || tp->lst.lstlef->com.comset && tp->lst.lstlef->com.comset->argval[0]!='[')
1N/A break;
1N/A tp = tp->lst.lstrit;
1N/A
1N/A }
1N/A if(!nv_isarray(np) && !typ && (tp->com.comarg || !tp->com.comset || tp->com.comset->argval[0]!='['))
1N/A {
1N/A nv_setvtree(np);
1N/A if(tp->com.comarg || tp->com.comset)
1N/A np->nvfun->dsize = 0;
1N/A }
1N/A#if SHOPT_TYPEDEF
1N/A goto check_type;
1N/A#else
1N/A continue;
1N/A#endif /* SHOPT_TYPEDEF */
1N/A }
1N/A cp = arg->argval;
1N/A mp = 0;
1N/A }
1N/A np = nv_open(cp,shp->var_tree,flags);
1N/A if(!np->nvfun && (flags&NV_NOREF))
1N/A {
1N/A if(shp->used_pos)
1N/A nv_onattr(np,NV_PARAM);
1N/A else
1N/A nv_offattr(np,NV_PARAM);
1N/A }
1N/A if(traceon || trap)
1N/A {
1N/A register char *sp=cp;
1N/A char *name=nv_name(np);
1N/A char *sub=0;
1N/A int append = 0;
1N/A if(nv_isarray(np))
1N/A sub = savesub;
1N/A if(cp=lastdot(sp,'='))
1N/A {
1N/A if(cp[-1]=='+')
1N/A append = ARG_APPEND;
1N/A cp++;
1N/A }
1N/A if(traceon)
1N/A {
1N/A sh_trace(shp,NIL(char**),0);
1N/A nv_outname(sfstderr,name,-1);
1N/A if(sub)
1N/A sfprintf(sfstderr,"[%s]",sh_fmtq(sub));
1N/A if(cp)
1N/A {
1N/A if(append)
1N/A sfputc(sfstderr,'+');
1N/A sfprintf(sfstderr,"=%s\n",sh_fmtq(cp));
1N/A }
1N/A }
1N/A if(trap)
1N/A {
1N/A char *av[2];
1N/A av[0] = cp;
1N/A av[1] = 0;
1N/A sh_debug(shp,trap,name,sub,av,append);
1N/A }
1N/A }
1N/A#if SHOPT_TYPEDEF
1N/A check_type:
1N/A if(maketype)
1N/A {
1N/A nv_open(shtp.nodes[0]->nvname,shp->var_tree,NV_ASSIGN|NV_VARNAME|NV_NOADD|NV_NOFAIL);
1N/A np = nv_mktype(shtp.nodes,shtp.numnodes);
1N/A free((void*)shtp.nodes);
1N/A shp->mktype = shtp.previous;
1N/A maketype = 0;
1N/A shp->prefix = 0;
1N/A if(nr.np == np)
1N/A {
1N/A L_ARGNOD->nvalue.nrp = node.nvalue.nrp;
1N/A L_ARGNOD->nvflag = node.nvflag;
1N/A L_ARGNOD->nvfun = node.nvfun;
1N/A }
1N/A }
1N/A#endif /* SHOPT_TYPEDEF */
1N/A }
1N/A}
1N/A
1N/A/*
1N/A * copy the subscript onto the stack
1N/A */
1N/Astatic void stak_subscript(const char *sub, int last)
1N/A{
1N/A register int c;
1N/A stakputc('[');
1N/A while(c= *sub++)
1N/A {
1N/A if(c=='[' || c==']' || c=='\\')
1N/A stakputc('\\');
1N/A stakputc(c);
1N/A }
1N/A stakputc(last);
1N/A}
1N/A
1N/A/*
1N/A * construct a new name from a prefix and base name on the stack
1N/A */
1N/Astatic char *copystack(const char *prefix, register const char *name, const char *sub)
1N/A{
1N/A register int last=0,offset = staktell();
1N/A if(prefix)
1N/A {
1N/A stakputs(prefix);
1N/A if(*stakptr(staktell()-1)=='.')
1N/A stakseek(staktell()-1);
1N/A if(*name=='.' && name[1]=='[')
1N/A last = staktell()+2;
1N/A if(*name!='[' && *name!='.' && *name!='=' && *name!='+')
1N/A stakputc('.');
1N/A if(*name=='.' && (name[1]=='=' || name[1]==0))
1N/A stakputc('.');
1N/A }
1N/A if(last)
1N/A {
1N/A stakputs(name);
1N/A if(sh_checkid(stakptr(last),(char*)0))
1N/A stakseek(staktell()-2);
1N/A }
1N/A if(sub)
1N/A stak_subscript(sub,']');
1N/A if(!last)
1N/A stakputs(name);
1N/A stakputc(0);
1N/A return(stakptr(offset));
1N/A}
1N/A
1N/A/*
1N/A * grow this stack string <name> by <n> bytes and move from cp-1 to end
1N/A * right by <n>. Returns beginning of string on the stack
1N/A */
1N/Astatic char *stack_extend(const char *cname, char *cp, int n)
1N/A{
1N/A register char *name = (char*)cname;
1N/A int offset = name - stakptr(0);
1N/A int m = cp-name;
1N/A stakseek(strlen(name)+n+1);
1N/A name = stakptr(offset);
1N/A cp = name + m;
1N/A m = strlen(cp)+1;
1N/A while(m-->0)
1N/A cp[n+m]=cp[m];
1N/A return((char*)name);
1N/A}
1N/A
1N/ANamval_t *nv_create(const char *name, Dt_t *root, int flags, Namfun_t *dp)
1N/A{
1N/A Shell_t *shp = sh_getinterp();
1N/A char *cp=(char*)name, *sp, *xp;
1N/A register int c;
1N/A register Namval_t *np=0, *nq=0;
1N/A Namfun_t *fp=0;
1N/A long mode, add=0;
1N/A int copy=0,isref,top=0,noscope=(flags&NV_NOSCOPE);
1N/A#if SHOPT_FIXEDARRAY
1N/A Namarr_t *ap;
1N/A#endif /* SHOPT_FIXEDARRAY */
1N/A if(root==shp->var_tree)
1N/A {
1N/A if(dtvnext(root))
1N/A top = 1;
1N/A else
1N/A flags &= ~NV_NOSCOPE;
1N/A }
1N/A if(!dp->disc)
1N/A copy = dp->nofree&1;
1N/A if(*cp=='.')
1N/A cp++;
1N/A while(1)
1N/A {
1N/A switch(c = *(unsigned char*)(sp = cp))
1N/A {
1N/A case '[':
1N/A if(flags&NV_NOARRAY)
1N/A {
1N/A dp->last = cp;
1N/A return(np);
1N/A }
1N/A cp = nv_endsubscript((Namval_t*)0,sp,0);
1N/A if(sp==name || sp[-1]=='.')
1N/A c = *(sp = cp);
1N/A goto skip;
1N/A case '.':
1N/A if(flags&NV_IDENT)
1N/A return(0);
1N/A if(root==shp->var_tree)
1N/A flags &= ~NV_EXPORT;
1N/A if(!copy && !(flags&NV_NOREF))
1N/A {
1N/A c = sp-name;
1N/A copy = cp-name;
1N/A dp->nofree |= 1;
1N/A name = copystack((const char*)0, name,(const char*)0);
1N/A cp = (char*)name+copy;
1N/A sp = (char*)name+c;
1N/A c = '.';
1N/A }
1N/A skip:
1N/A case '+':
1N/A case '=':
1N/A *sp = 0;
1N/A case 0:
1N/A isref = 0;
1N/A dp->last = cp;
1N/A mode = (c=='.' || (flags&NV_NOADD))?add:NV_ADD;
1N/A if((flags&NV_NOSCOPE) && c!='.')
1N/A mode |= HASH_NOSCOPE;
1N/A np=0;
1N/A if(top)
1N/A {
1N/A struct Ufunction *rp;
1N/A if((rp=shp->st.real_fun) && !rp->sdict && (flags&NV_STATIC))
1N/A {
1N/A Dt_t *dp = dtview(shp->var_tree,(Dt_t*)0);
1N/A rp->sdict = dtopen(&_Nvdisc,Dtoset);
1N/A dtview(rp->sdict,dp);
1N/A dtview(shp->var_tree,rp->sdict);
1N/A }
1N/A if(np = nv_search(name,shp->var_tree,0))
1N/A {
1N/A#if SHOPT_NAMESPACE
1N/A if(shp->var_tree->walk==shp->var_base || (shp->var_tree->walk!=shp->var_tree && shp->namespace && nv_dict(shp->namespace)==shp->var_tree->walk))
1N/A#else
1N/A if(shp->var_tree->walk==shp->var_base)
1N/A#endif /* SHOPT_NAMESPACE */
1N/A {
1N/A#if SHOPT_NAMESPACE
1N/A if(!(nq = nv_search((char*)np,shp->var_base,HASH_BUCKET)))
1N/A#endif /* SHOPT_NAMESPACE */
1N/A nq = np;
1N/A shp->last_root = shp->var_tree->walk;
1N/A if((flags&NV_NOSCOPE) && *cp!='.')
1N/A {
1N/A if(mode==0)
1N/A root = shp->var_tree->walk;
1N/A else
1N/A {
1N/A nv_delete(np,(Dt_t*)0,NV_NOFREE);
1N/A np = 0;
1N/A }
1N/A }
1N/A }
1N/A else
1N/A {
1N/A if(shp->var_tree->walk)
1N/A root = shp->var_tree->walk;
1N/A flags |= NV_NOSCOPE;
1N/A noscope = 1;
1N/A }
1N/A }
1N/A if(rp && rp->sdict && (flags&NV_STATIC))
1N/A {
1N/A root = rp->sdict;
1N/A if(np && shp->var_tree->walk==shp->var_tree)
1N/A {
1N/A _nv_unset(np,0);
1N/A nv_delete(np,shp->var_tree,0);
1N/A np = 0;
1N/A }
1N/A if(!np || shp->var_tree->walk!=root)
1N/A np = nv_search(name,root,HASH_NOSCOPE|NV_ADD);
1N/A }
1N/A }
1N/A#if SHOPT_NAMESPACE
1N/A if(!np && !noscope && *name!='.' && shp->namespace && root==shp->var_tree)
1N/A root = nv_dict(shp->namespace);
1N/A#endif /* SHOPT_NAMESPACE */
1N/A if(np || (np = nv_search(name,root,mode)))
1N/A {
1N/A isref = nv_isref(np);
1N/A if(top)
1N/A {
1N/A if(nq==np)
1N/A {
1N/A flags &= ~NV_NOSCOPE;
1N/A root = shp->last_root;
1N/A }
1N/A else if(nq)
1N/A {
1N/A if(nv_isnull(np) && c!='.' && (np->nvfun=nv_cover(nq)))
1N/A np->nvname = nq->nvname;
1N/A flags |= NV_NOSCOPE;
1N/A }
1N/A }
1N/A else if(add && nv_isnull(np) && c=='.' && cp[1]!='.')
1N/A nv_setvtree(np);
1N/A#if SHOPT_NAMESPACE
1N/A if(shp->namespace && root==nv_dict(shp->namespace))
1N/A {
1N/A flags |= NV_NOSCOPE;
1N/A shp->last_table = shp->namespace;
1N/A }
1N/A#endif /* SHOPT_NAMESPACE */
1N/A }
1N/A if(c)
1N/A *sp = c;
1N/A top = 0;
1N/A if(isref)
1N/A {
1N/A#if SHOPT_FIXEDARRAY
1N/A int n=0,dim;
1N/A#endif /* SHOPT_FIXEDARRAY */
1N/A char *sub=0;
1N/A#if NVCACHE
1N/A nvcache.ok = 0;
1N/A#endif
1N/A if(c=='.') /* don't optimize */
1N/A shp->argaddr = 0;
1N/A else if((flags&NV_NOREF) && (c!='[' && *cp!='.'))
1N/A {
1N/A if(c && !(flags&NV_NOADD))
1N/A nv_unref(np);
1N/A return(np);
1N/A }
1N/A while(nv_isref(np) && np->nvalue.cp)
1N/A {
1N/A root = nv_reftree(np);
1N/A shp->last_root = root;
1N/A shp->last_table = nv_reftable(np);
1N/A sub = nv_refsub(np);
1N/A#if SHOPT_FIXEDARRAY
1N/A n = nv_refindex(np);
1N/A dim = nv_refdimen(np);
1N/A#endif /* SHOPT_FIXEDARRAY */
1N/A np = nv_refnode(np);
1N/A#if SHOPT_FIXEDARRAY
1N/A if(n)
1N/A {
1N/A ap = nv_arrayptr(np);
1N/A ap->nelem = dim;
1N/A nv_putsub(np,(char*)0,n);
1N/A }
1N/A else
1N/A#endif /* SHOPT_FIXEDARRAY */
1N/A if(sub && c!='.')
1N/A nv_putsub(np,sub,0L);
1N/A flags |= NV_NOSCOPE;
1N/A noscope = 1;
1N/A }
1N/A if(nv_isref(np) && (c=='[' || c=='.' || !(flags&NV_ASSIGN)))
1N/A errormsg(SH_DICT,ERROR_exit(1),e_noref,nv_name(np));
1N/A
1N/A if(sub && c==0 && !(flags&NV_ARRAY))
1N/A return(np);
1N/A if(np==nq)
1N/A flags &= ~(noscope?0:NV_NOSCOPE);
1N/A#if SHOPT_FIXEDARRAY
1N/A else if(c || n)
1N/A {
1N/A static char null[1] = "";
1N/A#else
1N/A else if(c)
1N/A {
1N/A#endif /* SHOPT_FIXEDARRAY */
1N/A c = (cp-sp);
1N/A copy = strlen(cp=nv_name(np));
1N/A dp->nofree |= 1;
1N/A#if SHOPT_FIXEDARRAY
1N/A if(*sp==0)
1N/A name = cp;
1N/A else
1N/A#endif /* SHOPT_FIXEDARRAY */
1N/A name = copystack(cp,sp,sub);
1N/A sp = (char*)name + copy;
1N/A cp = sp+c;
1N/A c = *sp;
1N/A if(!noscope)
1N/A flags &= ~NV_NOSCOPE;
1N/A#if SHOPT_FIXEDARRAY
1N/A if(c==0)
1N/A nv_endsubscript(np,null,NV_ADD);
1N/A#endif /* SHOPT_FIXEDARRAY */
1N/A }
1N/A flags |= NV_NOREF;
1N/A if(nv_isnull(np) && !nv_isarray(np))
1N/A nv_onattr(np,NV_NOFREE);
1N/A }
1N/A shp->last_root = root;
1N/A if(*cp && cp[1]=='.')
1N/A cp++;
1N/A if(c=='.' && (cp[1]==0 || cp[1]=='=' || cp[1]=='+'))
1N/A {
1N/A nv_local = 1;
1N/A return(np);
1N/A }
1N/A if(cp[-1]=='.')
1N/A cp--;
1N/A do
1N/A {
1N/A#if SHOPT_FIXEDARRAY
1N/A int fixed;
1N/A#endif /* SHOPT_FIXEDARRAY */
1N/A if(!np)
1N/A {
1N/A if(!nq && *sp=='[' && *cp==0 && cp[-1]==']')
1N/A {
1N/A /*
1N/A * for backward compatibility
1N/A * evaluate subscript for
1N/A * possible side effects
1N/A */
1N/A cp[-1] = 0;
1N/A sh_arith(shp,sp+1);
1N/A cp[-1] = ']';
1N/A }
1N/A return(np);
1N/A }
1N/A#if SHOPT_FIXEDARRAY
1N/A fixed = 0;
1N/A if((ap=nv_arrayptr(np)) && ap->fixed)
1N/A fixed = 1;
1N/A#endif /* SHOPT_FIXEDARRAY */
1N/A if(c=='[' || (c=='.' && nv_isarray(np)))
1N/A {
1N/A char *sub=0;
1N/A int n = 0;
1N/A mode &= ~HASH_NOSCOPE;
1N/A if(c=='[')
1N/A {
1N/A#if SHOPT_FIXEDARRAY
1N/A Namarr_t *ap = nv_arrayptr(np);
1N/A#endif /* SHOPT_FIXEDARRAY */
1N/A#if 0
1N/A int scan = ap?(ap->nelem&ARRAY_SCAN):0;
1N/A#endif
1N/A n = mode|nv_isarray(np);
1N/A if(!mode && (flags&NV_ARRAY) && ((c=sp[1])=='*' || c=='@') && sp[2]==']')
1N/A {
1N/A /* not implemented yet */
1N/A dp->last = cp;
1N/A return(np);
1N/A }
1N/A#if SHOPT_FIXEDARRAY
1N/A if(fixed)
1N/A flags |= NV_FARRAY;
1N/A else
1N/A#endif /* SHOPT_FIXEDARRAY */
1N/A if((n&NV_ADD)&&(flags&NV_ARRAY))
1N/A n |= ARRAY_FILL;
1N/A if(flags&NV_ASSIGN)
1N/A n |= NV_ADD;
1N/A cp = nv_endsubscript(np,sp,n|(flags&(NV_ASSIGN|NV_FARRAY)));
1N/A#if SHOPT_FIXEDARRAY
1N/A flags &= ~NV_FARRAY;
1N/A if(fixed)
1N/A flags &= ~NV_ARRAY;
1N/A
1N/A#endif /* SHOPT_FIXEDARRAY */
1N/A#if 0
1N/A if(scan)
1N/A nv_putsub(np,NIL(char*),ARRAY_SCAN);
1N/A#endif
1N/A }
1N/A else
1N/A cp = sp;
1N/A if((c = *cp)=='.' || (c=='[' && nv_isarray(np)) || (n&ARRAY_FILL) || (flags&NV_ARRAY))
1N/A
1N/A {
1N/A int m = cp-sp;
1N/A sub = m?nv_getsub(np):0;
1N/A if(!sub)
1N/A {
1N/A if(m && !(n&NV_ADD))
1N/A return(0);
1N/A sub = "0";
1N/A }
1N/A n = strlen(sub)+2;
1N/A if(!copy)
1N/A {
1N/A copy = cp-name;
1N/A dp->nofree |= 1;
1N/A name = copystack((const char*)0, name,(const char*)0);
1N/A cp = (char*)name+copy;
1N/A sp = cp-m;
1N/A }
1N/A if(n <= m)
1N/A {
1N/A if(n)
1N/A {
1N/A memcpy(sp+1,sub,n-2);
1N/A sp[n-1] = ']';
1N/A }
1N/A if(n < m)
1N/A {
1N/A char *dp = sp+n;
1N/A while(*dp++=*cp++);
1N/A cp = sp+n;
1N/A }
1N/A }
1N/A else
1N/A {
1N/A int r = n-m;
1N/A m = sp-name;
1N/A name = stack_extend(name, cp-1, r);
1N/A sp = (char*)name + m;
1N/A *sp = '[';
1N/A memcpy(sp+1,sub,n-2);
1N/A sp[n-1] = ']';
1N/A cp = sp+n;
1N/A
1N/A }
1N/A }
1N/A else if(c==0 && mode && (n=nv_aindex(np))>0)
1N/A nv_putsub(np,(char*)0,n);
1N/A#if SHOPT_FIXEDARRAY
1N/A else if(n==0 && !fixed && (c==0 || (c=='[' && !nv_isarray(np))))
1N/A#else
1N/A else if(n==0 && (c==0 || (c=='[' && !nv_isarray(np))))
1N/A#endif /* SHOPT_FIXEDARRAY */
1N/A {
1N/A /* subscript must be 0*/
1N/A cp[-1] = 0;
1N/A n = sh_arith(shp,sp+1);
1N/A cp[-1] = ']';
1N/A if(n)
1N/A return(0);
1N/A if(c)
1N/A sp = cp;
1N/A }
1N/A dp->last = cp;
1N/A if(nv_isarray(np) && (c=='[' || c=='.' || (flags&NV_ARRAY)))
1N/A {
1N/A sp = cp;
1N/A if(!(nq = nv_opensub(np)))
1N/A {
1N/A Namarr_t *ap = nv_arrayptr(np);
1N/A if(!sub && (flags&NV_NOADD))
1N/A return(0);
1N/A n = mode|((flags&NV_NOADD)?0:NV_ADD);
1N/A if(!ap && (n&NV_ADD))
1N/A {
1N/A nv_putsub(np,sub,ARRAY_FILL);
1N/A ap = nv_arrayptr(np);
1N/A }
1N/A if(n && ap && !ap->table)
1N/A ap->table = dtopen(&_Nvdisc,Dtoset);
1N/A if(ap && ap->table && (nq=nv_search(sub,ap->table,n)))
1N/A nq->nvenv = (char*)np;
1N/A if(nq && nv_isnull(nq))
1N/A nq = nv_arraychild(np,nq,c);
1N/A }
1N/A if(nq)
1N/A {
1N/A if(c=='.' && !nv_isvtree(nq))
1N/A {
1N/A if(flags&NV_NOADD)
1N/A return(0);
1N/A nv_setvtree(nq);
1N/A }
1N/A np = nq;
1N/A }
1N/A else if(memcmp(cp,"[0]",3))
1N/A return(nq);
1N/A else
1N/A {
1N/A /* ignore [0] */
1N/A dp->last = cp += 3;
1N/A c = *cp;
1N/A }
1N/A }
1N/A }
1N/A#if SHOPT_FIXEDARRAY
1N/A else if(nv_isarray(np) && (!fixed || cp[-1]!=']'))
1N/A#else
1N/A else if(nv_isarray(np))
1N/A#endif /* SHOPT_FIXEDARRAY */
1N/A {
1N/A if(c==0 && (flags&NV_MOVE))
1N/A return(np);
1N/A nv_putsub(np,NIL(char*),ARRAY_UNDEF);
1N/A }
1N/A if(c=='.' && (fp=np->nvfun))
1N/A {
1N/A for(; fp; fp=fp->next)
1N/A {
1N/A if(fp->disc && fp->disc->createf)
1N/A break;
1N/A }
1N/A if(fp)
1N/A {
1N/A if((nq = (*fp->disc->createf)(np,cp+1,flags,fp)) == np)
1N/A {
1N/A add = NV_ADD;
1N/A shp->last_table = 0;
1N/A break;
1N/A }
1N/A else if(np=nq)
1N/A {
1N/A if((c = *(sp=cp=dp->last=fp->last))==0)
1N/A {
1N/A if(nv_isarray(np) && sp[-1]!=']')
1N/A nv_putsub(np,NIL(char*),ARRAY_UNDEF);
1N/A return(np);
1N/A }
1N/A }
1N/A }
1N/A }
1N/A }
1N/A while(c=='[');
1N/A if(c!='.' || cp[1]=='.')
1N/A return(np);
1N/A cp++;
1N/A break;
1N/A default:
1N/A dp->last = cp;
1N/A if((c = mbchar(cp)) && !isaletter(c))
1N/A return(np);
1N/A while(xp=cp, c=mbchar(cp), isaname(c));
1N/A cp = xp;
1N/A }
1N/A }
1N/A return(np);
1N/A}
1N/A
1N/A/*
1N/A * delete the node <np> from the dictionary <root> and clear from the cache
1N/A * if <root> is NULL, only the cache is cleared
1N/A * if flags does not contain NV_NOFREE, the node is freed
1N/A */
1N/Avoid nv_delete(Namval_t* np, Dt_t *root, int flags)
1N/A{
1N/A#if NVCACHE
1N/A register int c;
1N/A struct Cache_entry *xp;
1N/A for(c=0,xp=nvcache.entries ; c < NVCACHE; xp= &nvcache.entries[++c])
1N/A {
1N/A if(xp->np==np)
1N/A xp->root = 0;
1N/A }
1N/A#endif
1N/A if(root || !(flags&NV_NOFREE))
1N/A {
1N/A if(!(flags&NV_FUNCTION) && Refdict)
1N/A {
1N/A Namval_t **key = &np;
1N/A struct Namref *rp;
1N/A while(rp = (struct Namref*)dtmatch(Refdict,(void*)key))
1N/A {
1N/A rp->np = &NullNode;
1N/A if(rp->sub)
1N/A free(rp->sub);
1N/A rp->sub = 0;
1N/A dtdelete(Refdict,(void*)rp);
1N/A }
1N/A }
1N/A }
1N/A if(root)
1N/A {
1N/A if(dtdelete(root,np))
1N/A {
1N/A if(!(flags&NV_NOFREE) && ((flags&NV_FUNCTION) || !nv_subsaved(np)))
1N/A free((void*)np);
1N/A }
1N/A#if 0
1N/A else
1N/A {
1N/A sfprintf(sfstderr,"%s not deleted\n",nv_name(np));
1N/A sfsync(sfstderr);
1N/A }
1N/A#endif
1N/A }
1N/A}
1N/A
1N/A/*
1N/A * Put <arg> into associative memory.
1N/A * If <flags> & NV_ARRAY then follow array to next subscript
1N/A * If <flags> & NV_NOARRAY then subscript is not allowed
1N/A * If <flags> & NV_NOSCOPE then use the current scope only
1N/A * If <flags> & NV_ASSIGN then assignment is allowed
1N/A * If <flags> & NV_IDENT then name must be an identifier
1N/A * If <flags> & NV_VARNAME then name must be a valid variable name
1N/A * If <flags> & NV_NOADD then node will not be added if not found
1N/A * If <flags> & NV_NOREF then don't follow reference
1N/A * If <flags> & NV_NOFAIL then don't generate an error message on failure
1N/A * If <flags> & NV_STATIC then unset before an assignment
1N/A * If <flags> & NV_UNJUST then unset attributes before assignment
1N/A * SH_INIT is only set while initializing the environment
1N/A */
1N/ANamval_t *nv_open(const char *name, Dt_t *root, int flags)
1N/A{
1N/A Shell_t *shp = sh_getinterp();
1N/A register char *cp=(char*)name;
1N/A register int c;
1N/A register Namval_t *np=0;
1N/A Namfun_t fun;
1N/A int append=0;
1N/A const char *msg = e_varname;
1N/A char *fname = 0;
1N/A int offset = staktell();
1N/A Dt_t *funroot;
1N/A#if NVCACHE
1N/A struct Cache_entry *xp;
1N/A#endif
1N/A
1N/A sh_stats(STAT_NVOPEN);
1N/A memset(&fun,0,sizeof(fun));
1N/A shp->last_table = 0;
1N/A if(!root)
1N/A root = shp->var_tree;
1N/A shp->last_root = root;
1N/A if(root==shp->fun_tree)
1N/A {
1N/A flags |= NV_NOREF;
1N/A msg = e_badfun;
1N/A if(strchr(name,'.'))
1N/A {
1N/A name = cp = copystack(0,name,(const char*)0);
1N/A fname = strrchr(cp,'.');
1N/A *fname = 0;
1N/A fun.nofree |= 1;
1N/A flags &= ~NV_IDENT;
1N/A funroot = root;
1N/A root = shp->var_tree;
1N/A }
1N/A }
1N/A else if(!(flags&(NV_IDENT|NV_VARNAME|NV_ASSIGN)))
1N/A {
1N/A long mode = ((flags&NV_NOADD)?0:NV_ADD);
1N/A if(flags&NV_NOSCOPE)
1N/A mode |= HASH_SCOPE|HASH_NOSCOPE;
1N/A np = nv_search(name,root,mode);
1N/A if(np && !(flags&NV_REF))
1N/A {
1N/A while(nv_isref(np))
1N/A {
1N/A shp->last_table = nv_reftable(np);
1N/A np = nv_refnode(np);
1N/A }
1N/A }
1N/A return(np);
1N/A }
1N/A else if(shp->prefix && (flags&NV_ASSIGN))
1N/A {
1N/A name = cp = copystack(shp->prefix,name,(const char*)0);
1N/A fun.nofree |= 1;
1N/A }
1N/A c = *(unsigned char*)cp;
1N/A if(root==shp->alias_tree)
1N/A {
1N/A msg = e_aliname;
1N/A while((c= *(unsigned char*)cp++) && (c!='=') && (c!='/') &&
1N/A (c>=0x200 || !(c=sh_lexstates[ST_NORM][c]) || c==S_EPAT || c==S_COLON));
1N/A if(shp->subshell && c=='=')
1N/A root = sh_subaliastree(1);
1N/A if(c= *--cp)
1N/A *cp = 0;
1N/A np = nv_search(name, root, (flags&NV_NOADD)?0:NV_ADD);
1N/A if(c)
1N/A *cp = c;
1N/A goto skip;
1N/A }
1N/A else if(flags&NV_IDENT)
1N/A msg = e_ident;
1N/A else if(c=='.')
1N/A {
1N/A c = *++cp;
1N/A flags |= NV_NOREF;
1N/A if(root==shp->var_tree)
1N/A root = shp->var_base;
1N/A shp->last_table = 0;
1N/A }
1N/A if(c= !isaletter(c))
1N/A goto skip;
1N/A#if NVCACHE
1N/A for(c=0,xp=nvcache.entries ; c < NVCACHE; xp= &nvcache.entries[++c])
1N/A {
1N/A if(xp->root!=root)
1N/A continue;
1N/A if(*name==*xp->name && (flags&(NV_ARRAY|NV_NOSCOPE))==xp->flags && memcmp(xp->name,name,xp->len)==0 && (name[xp->len]==0 || name[xp->len]=='=' || name[xp->len]=='+'))
1N/A {
1N/A sh_stats(STAT_NVHITS);
1N/A np = xp->np;
1N/A cp = (char*)name+xp->len;
1N/A if(nv_isarray(np) && !(flags&NV_MOVE))
1N/A nv_putsub(np,NIL(char*),ARRAY_UNDEF);
1N/A shp->last_table = xp->last_table;
1N/A shp->last_root = xp->last_root;
1N/A goto nocache;
1N/A }
1N/A }
1N/A nvcache.ok = 1;
1N/A#endif
1N/A np = nv_create(name, root, flags, &fun);
1N/A cp = fun.last;
1N/A#if NVCACHE
1N/A if(np && nvcache.ok && cp[-1]!=']')
1N/A {
1N/A xp = &nvcache.entries[nvcache.index];
1N/A if(*cp)
1N/A {
1N/A char *sp = strchr(name,*cp);
1N/A if(!sp)
1N/A goto nocache;
1N/A xp->len = sp-name;
1N/A }
1N/A else
1N/A xp->len = strlen(name);
1N/A c = roundof(xp->len+1,32);
1N/A if(c > xp->size)
1N/A {
1N/A if(xp->size==0)
1N/A xp->name = malloc(c);
1N/A else
1N/A xp->name = realloc(xp->name,c);
1N/A xp->size = c;
1N/A }
1N/A memcpy(xp->name,name,xp->len);
1N/A xp->name[xp->len] = 0;
1N/A xp->root = root;
1N/A xp->np = np;
1N/A xp->last_table = shp->last_table;
1N/A xp->last_root = shp->last_root;
1N/A xp->flags = (flags&(NV_ARRAY|NV_NOSCOPE));
1N/A nvcache.index = (nvcache.index+1)&(NVCACHE-1);
1N/A }
1N/Anocache:
1N/A nvcache.ok = 0;
1N/A#endif
1N/A if(fname)
1N/A {
1N/A c = ((flags&NV_NOSCOPE)?HASH_NOSCOPE:0)|((flags&NV_NOADD)?0:NV_ADD);
1N/A *fname = '.';
1N/A np = nv_search(name, funroot, c);
1N/A *fname = 0;
1N/A }
1N/A else
1N/A {
1N/A if(*cp=='.' && cp[1]=='.')
1N/A {
1N/A append |= NV_NODISC;
1N/A cp+=2;
1N/A }
1N/A if(*cp=='+' && cp[1]=='=')
1N/A {
1N/A append |= NV_APPEND;
1N/A cp++;
1N/A }
1N/A }
1N/A c = *cp;
1N/Askip:
1N/A#if SHOPT_TYPEDEF
1N/A if(np && shp->mktype)
1N/A np = nv_addnode(np,0);
1N/A#endif /* SHOPT_TYPEDEF */
1N/A if(c=='=' && np && (flags&NV_ASSIGN))
1N/A {
1N/A cp++;
1N/A if(sh_isstate(SH_INIT))
1N/A {
1N/A nv_putval(np, cp, NV_RDONLY);
1N/A if(np==PWDNOD)
1N/A nv_onattr(np,NV_TAGGED);
1N/A }
1N/A else
1N/A {
1N/A char *sub=0, *prefix= shp->prefix;
1N/A Namval_t *mp;
1N/A Namarr_t *ap;
1N/A int isref;
1N/A shp->prefix = 0;
1N/A if((flags&NV_STATIC) && !shp->mktype)
1N/A {
1N/A if(!nv_isnull(np))
1N/A {
1N/A shp->prefix = prefix;
1N/A return(np);
1N/A }
1N/A }
1N/A isref = nv_isref(np);
1N/A#if SHOPT_FIXEDARRAY
1N/A if(sh_isoption(SH_XTRACE) && (ap=nv_arrayptr(np)) && !ap->fixed)
1N/A#else
1N/A if(sh_isoption(SH_XTRACE) && nv_isarray(np))
1N/A#endif /* SHOPT_FIXEDARRAY */
1N/A sub = nv_getsub(np);
1N/A c = msg==e_aliname? 0: (append | (flags&NV_EXPORT));
1N/A if(isref)
1N/A nv_offattr(np,NV_REF);
1N/A if(!append && (flags&NV_UNJUST))
1N/A {
1N/A nv_offattr(np,NV_LJUST|NV_RJUST|NV_ZFILL);
1N/A np->nvsize = 0;
1N/A }
1N/A if((flags&NV_MOVE) && (ap=nv_arrayptr(np)) && (mp=nv_opensub(np)))
1N/A {
1N/A _nv_unset(mp,NV_EXPORT);
1N/A np = mp;
1N/A }
1N/A nv_putval(np, cp, c);
1N/A if(isref)
1N/A {
1N/A if(nv_search((char*)np,shp->var_base,HASH_BUCKET))
1N/A shp->last_root = shp->var_base;
1N/A nv_setref(np,(Dt_t*)0,NV_VARNAME);
1N/A }
1N/A savesub = sub;
1N/A shp->prefix = prefix;
1N/A }
1N/A nv_onattr(np, flags&NV_ATTRIBUTES);
1N/A }
1N/A else if(c)
1N/A {
1N/A if(flags&NV_NOFAIL)
1N/A return(0);
1N/A if(c=='.')
1N/A msg = e_noparent;
1N/A else if(c=='[')
1N/A msg = e_noarray;
1N/A errormsg(SH_DICT,ERROR_exit(1),msg,name);
1N/A }
1N/A if(fun.nofree&1)
1N/A stakseek(offset);
1N/A return(np);
1N/A}
1N/A
1N/A#if SHOPT_MULTIBYTE
1N/A static int ja_size(char*, int, int);
1N/A static void ja_restore(void);
1N/A static char *savep;
1N/A static char savechars[8+1];
1N/A#endif /* SHOPT_MULTIBYTE */
1N/A
1N/A/*
1N/A * put value <string> into name-value node <np>.
1N/A * If <np> is an array, then the element given by the
1N/A * current index is assigned to.
1N/A * If <flags> contains NV_RDONLY, readonly attribute is ignored
1N/A * If <flags> contains NV_INTEGER, string is a pointer to a number
1N/A * If <flags> contains NV_NOFREE, previous value is freed, and <string>
1N/A * becomes value of node and <flags> becomes attributes
1N/A */
1N/Avoid nv_putval(register Namval_t *np, const char *string, int flags)
1N/A{
1N/A Shell_t *shp = sh_getinterp();
1N/A register const char *sp=string;
1N/A register union Value *up;
1N/A register char *cp;
1N/A register int size = 0;
1N/A register int dot;
1N/A int was_local = nv_local;
1N/A union Value u;
1N/A#if SHOPT_FIXEDARRAY
1N/A Namarr_t *ap;
1N/A#endif /* SHOPT_FIXEDARRAY */
1N/A if(!(flags&NV_RDONLY) && nv_isattr (np, NV_RDONLY))
1N/A errormsg(SH_DICT,ERROR_exit(1),e_readonly, nv_name(np));
1N/A /* The following could cause the shell to fork if assignment
1N/A * would cause a side effect
1N/A */
1N/A shp->argaddr = 0;
1N/A if(shp->subshell && !nv_local)
1N/A np = sh_assignok(np,1);
1N/A if(np->nvfun && np->nvfun->disc && !(flags&NV_NODISC) && !nv_isref(np))
1N/A {
1N/A /* This function contains disc */
1N/A if(!nv_local)
1N/A {
1N/A nv_local=1;
1N/A nv_putv(np,sp,flags,np->nvfun);
1N/A if(sp && ((flags&NV_EXPORT) || nv_isattr(np,NV_EXPORT)))
1N/A sh_envput(shp->env,np);
1N/A return;
1N/A }
1N/A /* called from disc, assign the actual value */
1N/A }
1N/A flags &= ~NV_NODISC;
1N/A nv_local=0;
1N/A if(flags&(NV_NOREF|NV_NOFREE))
1N/A {
1N/A if(np->nvalue.cp && np->nvalue.cp!=sp && !nv_isattr(np,NV_NOFREE))
1N/A free((void*)np->nvalue.cp);
1N/A np->nvalue.cp = (char*)sp;
1N/A nv_setattr(np,(flags&~NV_RDONLY)|NV_NOFREE);
1N/A return;
1N/A }
1N/A up= &np->nvalue;
1N/A if(nv_isattr(np,NV_INT16P) == NV_INT16)
1N/A {
1N/A if(!np->nvalue.up || !nv_isarray(np))
1N/A {
1N/A up = &u;
1N/A up->up = &np->nvalue;
1N/A }
1N/A }
1N/A#if SHOPT_FIXEDARRAY
1N/A else if(np->nvalue.up && nv_isarray(np) && (ap=nv_arrayptr(np)) && !ap->fixed)
1N/A#else
1N/A else if(np->nvalue.up && nv_isarray(np) && nv_arrayptr(np))
1N/A#endif /* SHOPT_FIXEDARRAY */
1N/A up = np->nvalue.up;
1N/A if(up && up->cp==Empty)
1N/A up->cp = 0;
1N/A if(nv_isattr(np,NV_EXPORT))
1N/A nv_offattr(np,NV_IMPORT);
1N/A if(nv_isattr (np, NV_INTEGER))
1N/A {
1N/A if(nv_isattr(np, NV_DOUBLE) == NV_DOUBLE)
1N/A {
1N/A if(nv_isattr(np, NV_LONG) && sizeof(double)<sizeof(Sfdouble_t))
1N/A {
1N/A Sfdouble_t ld, old=0;
1N/A if(flags&NV_INTEGER)
1N/A {
1N/A if(flags&NV_LONG)
1N/A ld = *((Sfdouble_t*)sp);
1N/A else if(flags&NV_SHORT)
1N/A ld = *((float*)sp);
1N/A else
1N/A ld = *((double*)sp);
1N/A }
1N/A else
1N/A ld = sh_arith(shp,sp);
1N/A if(!up->ldp)
1N/A up->ldp = new_of(Sfdouble_t,0);
1N/A else if(flags&NV_APPEND)
1N/A old = *(up->ldp);
1N/A *(up->ldp) = old?ld+old:ld;
1N/A }
1N/A else
1N/A {
1N/A double d,od=0;
1N/A if(flags&NV_INTEGER)
1N/A {
1N/A if(flags&NV_LONG)
1N/A d = (double)(*(Sfdouble_t*)sp);
1N/A else if(flags&NV_SHORT)
1N/A d = (double)(*(float*)sp);
1N/A else
1N/A d = *(double*)sp;
1N/A }
1N/A else
1N/A d = sh_arith(shp,sp);
1N/A if(!up->dp)
1N/A up->dp = new_of(double,0);
1N/A else if(flags&NV_APPEND)
1N/A od = *(up->dp);
1N/A *(up->dp) = od?d+od:d;
1N/A }
1N/A }
1N/A else
1N/A {
1N/A if(nv_isattr(np, NV_LONG) && sizeof(int32_t)<sizeof(Sflong_t))
1N/A {
1N/A Sflong_t ll=0,oll=0;
1N/A if(flags&NV_INTEGER)
1N/A {
1N/A if((flags&NV_DOUBLE) == NV_DOUBLE)
1N/A {
1N/A if(flags&NV_LONG)
1N/A ll = *((Sfdouble_t*)sp);
1N/A else if(flags&NV_SHORT)
1N/A ll = *((float*)sp);
1N/A else
1N/A ll = *((double*)sp);
1N/A }
1N/A else if(nv_isattr(np,NV_UNSIGN))
1N/A {
1N/A if(flags&NV_LONG)
1N/A ll = *((Sfulong_t*)sp);
1N/A else if(flags&NV_SHORT)
1N/A ll = *((uint16_t*)sp);
1N/A else
1N/A ll = *((uint32_t*)sp);
1N/A }
1N/A else
1N/A {
1N/A if(flags&NV_LONG)
1N/A ll = *((Sflong_t*)sp);
1N/A else if(flags&NV_SHORT)
1N/A ll = *((uint16_t*)sp);
1N/A else
1N/A ll = *((uint32_t*)sp);
1N/A }
1N/A }
1N/A else if(sp)
1N/A ll = (Sflong_t)sh_arith(shp,sp);
1N/A if(!up->llp)
1N/A up->llp = new_of(Sflong_t,0);
1N/A else if(flags&NV_APPEND)
1N/A oll = *(up->llp);
1N/A *(up->llp) = ll+oll;
1N/A }
1N/A else
1N/A {
1N/A int32_t l=0,ol=0;
1N/A if(flags&NV_INTEGER)
1N/A {
1N/A if((flags&NV_DOUBLE) == NV_DOUBLE)
1N/A {
1N/A Sflong_t ll;
1N/A if(flags&NV_LONG)
1N/A ll = *((Sfdouble_t*)sp);
1N/A else if(flags&NV_SHORT)
1N/A ll = *((float*)sp);
1N/A else
1N/A ll = *((double*)sp);
1N/A l = (int32_t)ll;
1N/A }
1N/A else if(nv_isattr(np,NV_UNSIGN))
1N/A {
1N/A if(flags&NV_LONG)
1N/A l = *((Sfulong_t*)sp);
1N/A else if(flags&NV_SHORT)
1N/A l = *((uint16_t*)sp);
1N/A else
1N/A l = *(uint32_t*)sp;
1N/A }
1N/A else
1N/A {
1N/A if(flags&NV_LONG)
1N/A l = *((Sflong_t*)sp);
1N/A else if(flags&NV_SHORT)
1N/A l = *((int16_t*)sp);
1N/A else
1N/A l = *(int32_t*)sp;
1N/A }
1N/A }
1N/A else if(sp)
1N/A {
1N/A Sfdouble_t ld = sh_arith(shp,sp);
1N/A if(ld<0)
1N/A l = (int32_t)ld;
1N/A else
1N/A l = (uint32_t)ld;
1N/A }
1N/A if(nv_size(np) <= 1)
1N/A nv_setsize(np,10);
1N/A if(nv_isattr (np, NV_SHORT))
1N/A {
1N/A int16_t s=0;
1N/A if(flags&NV_APPEND)
1N/A s = *up->sp;
1N/A *(up->sp) = s+(int16_t)l;
1N/A nv_onattr(np,NV_NOFREE);
1N/A }
1N/A else
1N/A {
1N/A if(!up->lp)
1N/A up->lp = new_of(int32_t,0);
1N/A else if(flags&NV_APPEND)
1N/A ol = *(up->lp);
1N/A *(up->lp) = l+ol;
1N/A }
1N/A }
1N/A }
1N/A }
1N/A else
1N/A {
1N/A const char *tofree=0;
1N/A int offset;
1N/A#if _lib_pathnative
1N/A char buff[PATH_MAX];
1N/A#endif /* _lib_pathnative */
1N/A if(flags&NV_INTEGER)
1N/A {
1N/A if((flags&NV_DOUBLE)==NV_DOUBLE)
1N/A {
1N/A if(flags&NV_LONG)
1N/A sfprintf(shp->strbuf,"%.*Lg",LDBL_DIG,*((Sfdouble_t*)sp));
1N/A else
1N/A sfprintf(shp->strbuf,"%.*g",DBL_DIG,*((double*)sp));
1N/A }
1N/A else if(flags&NV_UNSIGN)
1N/A {
1N/A if(flags&NV_LONG)
1N/A sfprintf(shp->strbuf,"%I*lu",sizeof(Sfulong_t),*((Sfulong_t*)sp));
1N/A else
1N/A sfprintf(shp->strbuf,"%lu",(unsigned long)((flags&NV_SHORT)?*((uint16_t*)sp):*((uint32_t*)sp)));
1N/A }
1N/A else
1N/A {
1N/A if(flags&NV_LONG)
1N/A sfprintf(shp->strbuf,"%I*ld",sizeof(Sflong_t),*((Sflong_t*)sp));
1N/A else
1N/A sfprintf(shp->strbuf,"%ld",(long)((flags&NV_SHORT)?*((int16_t*)sp):*((int32_t*)sp)));
1N/A }
1N/A sp = sfstruse(shp->strbuf);
1N/A }
1N/A if(nv_isattr(np, NV_HOST|NV_INTEGER)==NV_HOST && sp)
1N/A {
1N/A#ifdef _lib_pathnative
1N/A /*
1N/A * return the host file name given the UNIX name
1N/A */
1N/A pathnative(sp,buff,sizeof(buff));
1N/A if(buff[1]==':' && buff[2]=='/')
1N/A {
1N/A buff[2] = '\\';
1N/A if(*buff>='A' && *buff<='Z')
1N/A *buff += 'a'-'A';
1N/A }
1N/A sp = buff;
1N/A#else
1N/A ;
1N/A#endif /* _lib_pathnative */
1N/A }
1N/A else if((nv_isattr(np, NV_RJUST|NV_ZFILL|NV_LJUST)) && sp)
1N/A {
1N/A for(;*sp == ' '|| *sp=='\t';sp++);
1N/A if((nv_isattr(np,NV_ZFILL)) && (nv_isattr(np,NV_LJUST)))
1N/A for(;*sp=='0';sp++);
1N/A size = nv_size(np);
1N/A#if SHOPT_MULTIBYTE
1N/A if(size)
1N/A size = ja_size((char*)sp,size,nv_isattr(np,NV_RJUST|NV_ZFILL));
1N/A#endif /* SHOPT_MULTIBYTE */
1N/A }
1N/A if(!up->cp)
1N/A flags &= ~NV_APPEND;
1N/A if((flags&NV_APPEND) && !nv_isattr(np,NV_BINARY))
1N/A {
1N/A offset = staktell();
1N/A stakputs(up->cp);
1N/A stakputs(sp);
1N/A stakputc(0);
1N/A sp = stakptr(offset);
1N/A }
1N/A if(!nv_isattr(np, NV_NOFREE))
1N/A {
1N/A /* delay free in case <sp> points into free region */
1N/A tofree = up->cp;
1N/A }
1N/A if(nv_isattr(np,NV_BINARY) && !(flags&NV_RAW))
1N/A tofree = 0;
1N/A if(nv_isattr(np,NV_LJUST|NV_RJUST) && nv_isattr(np,NV_LJUST|NV_RJUST)!=(NV_LJUST|NV_RJUST))
1N/A tofree = 0;
1N/A if (sp)
1N/A {
1N/A dot = strlen(sp);
1N/A#if (_AST_VERSION>=20030127L)
1N/A if(nv_isattr(np,NV_BINARY))
1N/A {
1N/A int oldsize = (flags&NV_APPEND)?nv_size(np):0;
1N/A if(flags&NV_RAW)
1N/A {
1N/A if(tofree)
1N/A {
1N/A free((void*)tofree);
1N/A nv_offattr(np,NV_NOFREE);
1N/A }
1N/A up->cp = sp;
1N/A return;
1N/A }
1N/A size = 0;
1N/A if(nv_isattr(np,NV_ZFILL))
1N/A size = nv_size(np);
1N/A if(size==0)
1N/A size = oldsize + (3*dot/4);
1N/A cp = (char*)malloc(size+1);
1N/A nv_offattr(np,NV_NOFREE);
1N/A if(oldsize)
1N/A memcpy((void*)cp,(void*)up->cp,oldsize);
1N/A up->cp = cp;
1N/A if(size <= oldsize)
1N/A return;
1N/A dot = base64decode(sp,dot, (void**)0, cp+oldsize, size-oldsize,(void**)0);
1N/A dot += oldsize;
1N/A if(!nv_isattr(np,NV_ZFILL) || nv_size(np)==0)
1N/A nv_setsize(np,dot);
1N/A else if(nv_isattr(np,NV_ZFILL) && (size>dot))
1N/A memset((void*)&cp[dot],0,size-dot);
1N/A return;
1N/A }
1N/A else
1N/A#endif
1N/A if(size==0 && nv_isattr(np,NV_HOST)!=NV_HOST &&nv_isattr(np,NV_LJUST|NV_RJUST|NV_ZFILL))
1N/A nv_setsize(np,size=dot);
1N/A else if(size > dot)
1N/A dot = size;
1N/A else if(nv_isattr(np,NV_LJUST|NV_RJUST)==NV_LJUST && dot>size)
1N/A dot = size;
1N/A if(size==0 || tofree || !(cp=(char*)up->cp))
1N/A {
1N/A if(dot==0 && !nv_isattr(np,NV_LJUST|NV_RJUST))
1N/A {
1N/A cp = Null;
1N/A nv_onattr(np,NV_NOFREE);
1N/A }
1N/A else
1N/A {
1N/A cp = (char*)malloc(((unsigned)dot+1));
1N/A cp[dot] = 0;
1N/A nv_offattr(np,NV_NOFREE);
1N/A }
1N/A }
1N/A
1N/A }
1N/A else
1N/A cp = 0;
1N/A up->cp = cp;
1N/A if(sp)
1N/A {
1N/A int c = cp[dot];
1N/A memmove(cp,sp,dot);
1N/A cp[dot] = c;
1N/A if(nv_isattr(np, NV_RJUST) && nv_isattr(np, NV_ZFILL))
1N/A rightjust(cp,size,'0');
1N/A else if(nv_isattr(np, NV_LJUST|NV_RJUST)==NV_RJUST)
1N/A rightjust(cp,size,' ');
1N/A else if(nv_isattr(np, NV_LJUST|NV_RJUST)==NV_LJUST)
1N/A {
1N/A register char *dp;
1N/A dp = strlen (cp) + cp;
1N/A cp = cp+size;
1N/A for (; dp < cp; *dp++ = ' ');
1N/A }
1N/A#if SHOPT_MULTIBYTE
1N/A /* restore original string */
1N/A if(savep)
1N/A ja_restore();
1N/A#endif /* SHOPT_MULTIBYTE */
1N/A }
1N/A if(flags&NV_APPEND)
1N/A stakseek(offset);
1N/A if(tofree && tofree!=Empty && tofree!=Null)
1N/A free((void*)tofree);
1N/A }
1N/A if(!was_local && ((flags&NV_EXPORT) || nv_isattr(np,NV_EXPORT)))
1N/A sh_envput(shp->env,np);
1N/A return;
1N/A}
1N/A
1N/A/*
1N/A *
1N/A * Right-justify <str> so that it contains no more than
1N/A * <size> characters. If <str> contains fewer than <size>
1N/A * characters, left-pad with <fill>. Trailing blanks
1N/A * in <str> will be ignored.
1N/A *
1N/A * If the leftmost digit in <str> is not a digit, <fill>
1N/A * will default to a blank.
1N/A */
1N/Astatic void rightjust(char *str, int size, int fill)
1N/A{
1N/A register int n;
1N/A register char *cp,*sp;
1N/A n = strlen(str);
1N/A
1N/A /* ignore trailing blanks */
1N/A for(cp=str+n;n && *--cp == ' ';n--);
1N/A if (n == size)
1N/A return;
1N/A if(n > size)
1N/A {
1N/A *(str+n) = 0;
1N/A for (sp = str, cp = str+n-size; sp <= str+size; *sp++ = *cp++);
1N/A return;
1N/A }
1N/A else *(sp = str+size) = 0;
1N/A if (n == 0)
1N/A {
1N/A while (sp > str)
1N/A *--sp = ' ';
1N/A return;
1N/A }
1N/A while(n--)
1N/A {
1N/A sp--;
1N/A *sp = *cp--;
1N/A }
1N/A if(!isdigit(*str))
1N/A fill = ' ';
1N/A while(sp>str)
1N/A *--sp = fill;
1N/A return;
1N/A}
1N/A
1N/A#if SHOPT_MULTIBYTE
1N/A /*
1N/A * handle left and right justified fields for multi-byte chars
1N/A * given physical size, return a logical size which reflects the
1N/A * screen width of multi-byte characters
1N/A * Multi-width characters replaced by spaces if they cross the boundary
1N/A * <type> is non-zero for right justified fields
1N/A */
1N/A
1N/A static int ja_size(char *str,int size,int type)
1N/A {
1N/A register char *cp = str;
1N/A register int c, n=size;
1N/A register int outsize;
1N/A register char *oldcp=cp;
1N/A int oldn;
1N/A wchar_t w;
1N/A while(*cp)
1N/A {
1N/A oldn = n;
1N/A w = mbchar(cp);
1N/A outsize = mbwidth(w);
1N/A size -= outsize;
1N/A c = cp-oldcp;
1N/A n += (c-outsize);
1N/A oldcp = cp;
1N/A if(size<=0 && type==0)
1N/A break;
1N/A }
1N/A /* check for right justified fields that need truncating */
1N/A if(size <0)
1N/A {
1N/A if(type==0)
1N/A {
1N/A /* left justified and character crosses field boundary */
1N/A n = oldn;
1N/A /* save boundary char and replace with spaces */
1N/A size = c;
1N/A savechars[size] = 0;
1N/A while(size--)
1N/A {
1N/A savechars[size] = cp[size];
1N/A cp[size] = ' ';
1N/A }
1N/A savep = cp;
1N/A }
1N/A size = -size;
1N/A if(type)
1N/A n -= (ja_size(str,size,0)-size);
1N/A }
1N/A return(n);
1N/A }
1N/A
1N/A static void ja_restore(void)
1N/A {
1N/A register char *cp = savechars;
1N/A while(*cp)
1N/A *savep++ = *cp++;
1N/A savep = 0;
1N/A }
1N/A#endif /* SHOPT_MULTIBYTE */
1N/A
1N/A#ifndef _ENV_H
1N/Astatic char *staknam(register Namval_t *np, char *value)
1N/A{
1N/A register char *p,*q;
1N/A q = stakalloc(strlen(nv_name(np))+(value?strlen(value):0)+2);
1N/A p=strcopy(q,nv_name(np));
1N/A if(value)
1N/A {
1N/A *p++ = '=';
1N/A strcpy(p,value);
1N/A }
1N/A return(q);
1N/A}
1N/A#endif
1N/A
1N/A/*
1N/A * put the name and attribute into value of attributes variable
1N/A */
1N/A#ifdef _ENV_H
1N/Astatic void attstore(register Namval_t *np, void *data)
1N/A{
1N/A register int flag, c = ' ';
1N/A NOT_USED(data);
1N/A if(!(nv_isattr(np,NV_EXPORT)))
1N/A return;
1N/A flag = nv_isattr(np,NV_RDONLY|NV_UTOL|NV_LTOU|NV_RJUST|NV_LJUST|NV_ZFILL|NV_INTEGER);
1N/A stakputc('=');
1N/A if((flag&NV_DOUBLE) == NV_DOUBLE)
1N/A {
1N/A /* export doubles as integers for ksh88 compatibility */
1N/A stakputc(c+NV_INTEGER|(flag&~(NV_DOUBLE|NV_EXPNOTE)));
1N/A }
1N/A else
1N/A {
1N/A stakputc(c+flag);
1N/A if(flag&NV_INTEGER)
1N/A c += nv_size(np);
1N/A }
1N/A stakputc(c);
1N/A stakputs(nv_name(np));
1N/A}
1N/A#else
1N/Astatic void attstore(register Namval_t *np, void *data)
1N/A{
1N/A register int flag = np->nvflag;
1N/A register struct adata *ap = (struct adata*)data;
1N/A ap->sh = sh_getinterp();
1N/A ap->tp = 0;
1N/A if(!(flag&NV_EXPORT) || (flag&NV_FUNCT))
1N/A return;
1N/A if((flag&(NV_UTOL|NV_LTOU|NV_INTEGER)) == (NV_UTOL|NV_LTOU))
1N/A {
1N/A data = (void*)nv_mapchar(np,0);
1N/A if(strcmp(data,e_tolower) && strcmp(data,e_toupper))
1N/A return;
1N/A }
1N/A flag &= (NV_RDONLY|NV_UTOL|NV_LTOU|NV_RJUST|NV_LJUST|NV_ZFILL|NV_INTEGER);
1N/A *ap->attval++ = '=';
1N/A if((flag&NV_DOUBLE) == NV_DOUBLE)
1N/A {
1N/A /* export doubles as integers for ksh88 compatibility */
1N/A *ap->attval++ = ' '+ NV_INTEGER|(flag&~(NV_DOUBLE|NV_EXPNOTE));
1N/A *ap->attval = ' ';
1N/A }
1N/A else
1N/A {
1N/A *ap->attval++ = ' '+flag;
1N/A if(flag&NV_INTEGER)
1N/A *ap->attval = ' ' + nv_size(np);
1N/A else
1N/A *ap->attval = ' ';
1N/A }
1N/A ap->attval = strcopy(++ap->attval,nv_name(np));
1N/A}
1N/A#endif
1N/A
1N/A#ifndef _ENV_H
1N/Astatic void pushnam(Namval_t *np, void *data)
1N/A{
1N/A register char *value;
1N/A register struct adata *ap = (struct adata*)data;
1N/A ap->sh = sh_getinterp();
1N/A ap->tp = 0;
1N/A if(nv_isattr(np,NV_IMPORT) && np->nvenv)
1N/A *ap->argnam++ = np->nvenv;
1N/A else if(value=nv_getval(np))
1N/A *ap->argnam++ = staknam(np,value);
1N/A if(nv_isattr(np,NV_RDONLY|NV_UTOL|NV_LTOU|NV_RJUST|NV_LJUST|NV_ZFILL|NV_INTEGER))
1N/A ap->attsize += (strlen(nv_name(np))+4);
1N/A}
1N/A#endif
1N/A
1N/A/*
1N/A * Generate the environment list for the child.
1N/A */
1N/A
1N/A#ifdef _ENV_H
1N/Achar **sh_envgen(void)
1N/A{
1N/A Shell_t *shp = sh_getinterp();
1N/A int offset,tell;
1N/A register char **er;
1N/A env_delete(shp->env,"_");
1N/A er = env_get(shp->env);
1N/A offset = staktell();
1N/A stakputs(e_envmarker);
1N/A tell = staktell();
1N/A nv_scan(shp->var_tree, attstore,(void*)0,0,(NV_RDONLY|NV_UTOL|NV_LTOU|NV_RJUST|NV_LJUST|NV_ZFILL|NV_INTEGER));
1N/A if(tell ==staktell())
1N/A stakseek(offset);
1N/A else
1N/A *--er = stakfreeze(1)+offset;
1N/A return(er);
1N/A}
1N/A#else
1N/Achar **sh_envgen(void)
1N/A{
1N/A register char **er;
1N/A register int namec;
1N/A register char *cp;
1N/A struct adata data;
1N/A Shell_t *shp = sh_getinterp();
1N/A data.sh = shp;
1N/A data.tp = 0;
1N/A data.mapname = 0;
1N/A /* L_ARGNOD gets generated automatically as full path name of command */
1N/A nv_offattr(L_ARGNOD,NV_EXPORT);
1N/A data.attsize = 6;
1N/A namec = nv_scan(shp->var_tree,nullscan,(void*)0,NV_EXPORT,NV_EXPORT);
1N/A namec += shp->nenv;
1N/A er = (char**)stakalloc((namec+4)*sizeof(char*));
1N/A data.argnam = (er+=2) + shp->nenv;
1N/A if(shp->nenv)
1N/A memcpy((void*)er,environ,shp->nenv*sizeof(char*));
1N/A nv_scan(shp->var_tree, pushnam,&data,NV_EXPORT, NV_EXPORT);
1N/A *data.argnam = (char*)stakalloc(data.attsize);
1N/A cp = data.attval = strcopy(*data.argnam,e_envmarker);
1N/A nv_scan(shp->var_tree, attstore,&data,0,(NV_RDONLY|NV_UTOL|NV_LTOU|NV_RJUST|NV_LJUST|NV_ZFILL|NV_INTEGER));
1N/A *data.attval = 0;
1N/A if(cp!=data.attval)
1N/A data.argnam++;
1N/A *data.argnam = 0;
1N/A return(er);
1N/A}
1N/A#endif
1N/A
1N/Astruct scan
1N/A{
1N/A void (*scanfn)(Namval_t*, void*);
1N/A int scanmask;
1N/A int scanflags;
1N/A int scancount;
1N/A void *scandata;
1N/A};
1N/A
1N/Astatic int scanfilter(Dt_t *dict, void *arg, void *data)
1N/A{
1N/A register Namval_t *np = (Namval_t*)arg;
1N/A register int k=np->nvflag;
1N/A register struct scan *sp = (struct scan*)data;
1N/A register struct adata *tp = (struct adata*)sp->scandata;
1N/A char *cp;
1N/A NOT_USED(dict);
1N/A#if SHOPT_TYPEDEF
1N/A if(!is_abuiltin(np) && tp && tp->tp && nv_type(np)!=tp->tp)
1N/A return(0);
1N/A#endif /*SHOPT_TYPEDEF */
1N/A if(sp->scanmask?(k&sp->scanmask)==sp->scanflags:(!sp->scanflags || (k&sp->scanflags)))
1N/A {
1N/A if(tp && tp->mapname && (sp->scanflags==NV_UTOL||sp->scanflags==NV_LTOU) && (cp=(char*)nv_mapchar(np,0)) && strcmp(cp,tp->mapname))
1N/A return(0);
1N/A if(!np->nvalue.cp && !np->nvfun && !nv_isattr(np,~NV_DEFAULT))
1N/A return(0);
1N/A if(sp->scanfn)
1N/A {
1N/A if(nv_isarray(np))
1N/A nv_putsub(np,NIL(char*),0L);
1N/A (*sp->scanfn)(np,sp->scandata);
1N/A }
1N/A sp->scancount++;
1N/A }
1N/A return(0);
1N/A}
1N/A
1N/A/*
1N/A * Walk through the name-value pairs
1N/A * if <mask> is non-zero, then only nodes with (nvflags&mask)==flags
1N/A * are visited
1N/A * If <mask> is zero, and <flags> non-zero, then nodes with one or
1N/A * more of <flags> is visited
1N/A * If <mask> and <flags> are zero, then all nodes are visted
1N/A */
1N/Aint nv_scan(Dt_t *root, void (*fn)(Namval_t*,void*), void *data,int mask, int flags)
1N/A{
1N/A Dt_t *base=0;
1N/A struct scan sdata;
1N/A int (*hashfn)(Dt_t*, void*, void*);
1N/A sdata.scanmask = mask;
1N/A sdata.scanflags = flags&~NV_NOSCOPE;
1N/A sdata.scanfn = fn;
1N/A sdata.scancount = 0;
1N/A sdata.scandata = data;
1N/A hashfn = scanfilter;
1N/A if(flags&NV_NOSCOPE)
1N/A base = dtview((Dt_t*)root,0);
1N/A dtwalk(root, hashfn,&sdata);
1N/A if(base)
1N/A dtview((Dt_t*)root,base);
1N/A return(sdata.scancount);
1N/A}
1N/A
1N/A/*
1N/A * create a new environment scope
1N/A */
1N/Avoid sh_scope(Shell_t *shp, struct argnod *envlist, int fun)
1N/A{
1N/A register Dt_t *newscope, *newroot=shp->var_base;
1N/A struct Ufunction *rp;
1N/A#if SHOPT_NAMESPACE
1N/A if(shp->namespace)
1N/A {
1N/A newroot = nv_dict(shp->namespace);
1N/A dtview(newroot,(Dt_t*)shp->var_base);
1N/A }
1N/A#endif /* SHOPT_NAMESPACE */
1N/A newscope = dtopen(&_Nvdisc,Dtoset);
1N/A if(envlist)
1N/A {
1N/A dtview(newscope,(Dt_t*)shp->var_tree);
1N/A shp->var_tree = newscope;
1N/A nv_setlist(envlist,NV_EXPORT|NV_NOSCOPE|NV_IDENT|NV_ASSIGN,0);
1N/A if(!fun)
1N/A return;
1N/A shp->var_tree = dtview(newscope,0);
1N/A }
1N/A if((rp=shp->st.real_fun) && rp->sdict)
1N/A {
1N/A dtview(rp->sdict,newroot);
1N/A newroot = rp->sdict;
1N/A
1N/A }
1N/A dtview(newscope,(Dt_t*)newroot);
1N/A shp->var_tree = newscope;
1N/A}
1N/A
1N/A/*
1N/A * Remove freeable local space associated with the nvalue field
1N/A * of nnod. This includes any strings representing the value(s) of the
1N/A * node, as well as its dope vector, if it is an array.
1N/A */
1N/A
1N/Avoid sh_envnolocal (register Namval_t *np, void *data)
1N/A{
1N/A struct adata *tp = (struct adata*)data;
1N/A char *cp=0;
1N/A if(np==VERSIONNOD && nv_isref(np))
1N/A return;
1N/A if(np==L_ARGNOD)
1N/A return;
1N/A if(np == tp->sh->namespace)
1N/A return;
1N/A if(nv_isattr(np,NV_EXPORT) && nv_isarray(np))
1N/A {
1N/A nv_putsub(np,NIL(char*),0);
1N/A if(cp = nv_getval(np))
1N/A cp = strdup(cp);
1N/A }
1N/A if(nv_isattr(np,NV_EXPORT|NV_NOFREE))
1N/A {
1N/A if(nv_isref(np) && np!=VERSIONNOD)
1N/A {
1N/A nv_offattr(np,NV_NOFREE|NV_REF);
1N/A free((void*)np->nvalue.nrp);
1N/A np->nvalue.cp = 0;
1N/A }
1N/A if(!cp)
1N/A return;
1N/A }
1N/A if(nv_isarray(np))
1N/A nv_putsub(np,NIL(char*),ARRAY_UNDEF);
1N/A _nv_unset(np,NV_RDONLY);
1N/A nv_setattr(np,0);
1N/A if(cp)
1N/A {
1N/A nv_putval(np,cp,0);
1N/A free((void*)cp);
1N/A }
1N/A}
1N/A
1N/A/*
1N/A * Currently this is a dummy, but someday will be needed
1N/A * for reference counting
1N/A */
1N/Avoid nv_close(Namval_t *np)
1N/A{
1N/A NOT_USED(np);
1N/A}
1N/A
1N/Astatic void table_unset(Shell_t *shp, register Dt_t *root, int flags, Dt_t *oroot)
1N/A{
1N/A register Namval_t *np,*nq, *npnext;
1N/A for(np=(Namval_t*)dtfirst(root);np;np=npnext)
1N/A {
1N/A if(nq=dtsearch(oroot,np))
1N/A {
1N/A if(nv_cover(nq))
1N/A {
1N/A int subshell = shp->subshell;
1N/A shp->subshell = 0;
1N/A if(nv_isattr(nq, NV_INTEGER))
1N/A {
1N/A Sfdouble_t d = nv_getnum(nq);
1N/A nv_putval(nq,(char*)&d,NV_LDOUBLE);
1N/A }
1N/A else if(shp->test&4)
1N/A nv_putval(nq, strdup(nv_getval(nq)), NV_RDONLY);
1N/A else
1N/A nv_putval(nq, nv_getval(nq), NV_RDONLY);
1N/A shp->subshell = subshell;
1N/A np->nvfun = 0;
1N/A }
1N/A if(nv_isattr(nq,NV_EXPORT))
1N/A sh_envput(shp->env,nq);
1N/A }
1N/A npnext = (Namval_t*)dtnext(root,np);
1N/A shp->last_root = root;
1N/A shp->last_table = 0;
1N/A if(nv_isvtree(np))
1N/A {
1N/A int len = strlen(np->nvname);
1N/A while((nq=npnext) && memcmp(np->nvname,nq->nvname,len)==0 && nq->nvname[len]=='.')
1N/A
1N/A {
1N/A npnext = (Namval_t*)dtnext(root,nq);
1N/A _nv_unset(nq,flags);
1N/A nv_delete(nq,root,0);
1N/A }
1N/A }
1N/A _nv_unset(np,flags);
1N/A nv_delete(np,root,0);
1N/A }
1N/A}
1N/A
1N/A/*
1N/A *
1N/A * Set the value of <np> to 0, and nullify any attributes
1N/A * that <np> may have had. Free any freeable space occupied
1N/A * by the value of <np>. If <np> denotes an array member, it
1N/A * will retain its attributes.
1N/A * <flags> can contain NV_RDONLY to override the readonly attribute
1N/A * being cleared.
1N/A * <flags> can contain NV_EXPORT to override preserve nvenv
1N/A */
1N/Avoid _nv_unset(register Namval_t *np,int flags)
1N/A{
1N/A Shell_t *shp = sh_getinterp();
1N/A register union Value *up;
1N/A if(!(flags&NV_RDONLY) && nv_isattr (np,NV_RDONLY))
1N/A errormsg(SH_DICT,ERROR_exit(1),e_readonly, nv_name(np));
1N/A if(is_afunction(np) && np->nvalue.ip)
1N/A {
1N/A register struct slnod *slp = (struct slnod*)(np->nvenv);
1N/A if(slp && !nv_isattr(np,NV_NOFREE))
1N/A {
1N/A struct Ufunction *rq,*rp = np->nvalue.rp;
1N/A /* free function definition */
1N/A register char *name=nv_name(np),*cp= strrchr(name,'.');
1N/A if(cp)
1N/A {
1N/A Namval_t *npv;
1N/A *cp = 0;
1N/A npv = nv_open(name,shp->var_tree,NV_NOARRAY|NV_VARNAME|NV_NOADD);
1N/A *cp++ = '.';
1N/A if(npv && npv!=shp->namespace)
1N/A nv_setdisc(npv,cp,NIL(Namval_t*),(Namfun_t*)npv);
1N/A }
1N/A if(rp->fname && shp->fpathdict && (rq = (struct Ufunction*)nv_search(rp->fname,shp->fpathdict,0)))
1N/A {
1N/A do
1N/A {
1N/A if(rq->np != np)
1N/A continue;
1N/A dtdelete(shp->fpathdict,rq);
1N/A break;
1N/A }
1N/A while(rq = (struct Ufunction*)dtnext(shp->fpathdict,rq));
1N/A }
1N/A if(rp->sdict)
1N/A {
1N/A Namval_t *mp, *nq;
1N/A for(mp=(Namval_t*)dtfirst(rp->sdict);mp;mp=nq)
1N/A {
1N/A nq = dtnext(rp->sdict,mp);
1N/A _nv_unset(mp,NV_RDONLY);
1N/A nv_delete(mp,rp->sdict,0);
1N/A }
1N/A dtclose(rp->sdict);
1N/A }
1N/A stakdelete(slp->slptr);
1N/A free((void*)np->nvalue.ip);
1N/A np->nvalue.ip = 0;
1N/A }
1N/A goto done;
1N/A }
1N/A if(shp->subshell)
1N/A np = sh_assignok(np,0);
1N/A nv_offattr(np,NV_NODISC);
1N/A if(np->nvfun && !nv_isref(np))
1N/A {
1N/A /* This function contains disc */
1N/A if(!nv_local)
1N/A {
1N/A nv_local=1;
1N/A nv_putv(np,NIL(char*),flags,np->nvfun);
1N/A nv_local=0;
1N/A return;
1N/A }
1N/A /* called from disc, assign the actual value */
1N/A nv_local=0;
1N/A }
1N/A if(nv_isattr(np,NV_INT16P) == NV_INT16)
1N/A {
1N/A np->nvalue.cp = nv_isarray(np)?Empty:0;
1N/A goto done;
1N/A }
1N/A if(nv_isarray(np) && np->nvalue.cp!=Empty && np->nvfun)
1N/A up = np->nvalue.up;
1N/A else if(nv_isref(np) && !nv_isattr(np,NV_EXPORT|NV_MINIMAL) && np->nvalue.nrp)
1N/A {
1N/A
1N/A if(np->nvalue.nrp->root)
1N/A dtdelete(Refdict,(void*)np->nvalue.nrp);
1N/A if(np->nvalue.nrp->sub)
1N/A free(np->nvalue.nrp->sub);
1N/A free((void*)np->nvalue.nrp);
1N/A np->nvalue.cp = 0;
1N/A up = 0;
1N/A }
1N/A else
1N/A up = &np->nvalue;
1N/A if(up && up->cp)
1N/A {
1N/A if(up->cp!=Empty && up->cp!=Null && !nv_isattr(np, NV_NOFREE))
1N/A free((void*)up->cp);
1N/A up->cp = 0;
1N/A }
1N/Adone:
1N/A if(!nv_isarray(np) || !nv_arrayptr(np))
1N/A {
1N/A nv_setsize(np,0);
1N/A if(!nv_isattr(np,NV_MINIMAL) || nv_isattr(np,NV_EXPORT))
1N/A {
1N/A if(nv_isattr(np,NV_EXPORT) && !strchr(np->nvname,'['))
1N/A env_delete(shp->env,nv_name(np));
1N/A if(!(flags&NV_EXPORT) || nv_isattr(np,NV_IMPORT|NV_EXPORT)==(NV_IMPORT|NV_EXPORT))
1N/A np->nvenv = 0;
1N/A nv_setattr(np,0);
1N/A }
1N/A else
1N/A {
1N/A nv_setattr(np,NV_MINIMAL);
1N/A nv_delete(np,(Dt_t*)0,0);
1N/A }
1N/A }
1N/A}
1N/A
1N/A/*
1N/A * return the node pointer in the highest level scope
1N/A */
1N/ANamval_t *sh_scoped(Shell_t *shp, register Namval_t *np)
1N/A{
1N/A if(!dtvnext(shp->var_tree))
1N/A return(np);
1N/A return(dtsearch(shp->var_tree,np));
1N/A}
1N/A
1N/A#if 1
1N/A/*
1N/A * return space separated list of names of variables in given tree
1N/A */
1N/Astatic char *tableval(Dt_t *root)
1N/A{
1N/A static Sfio_t *out;
1N/A register Namval_t *np;
1N/A register int first=1;
1N/A register Dt_t *base = dtview(root,0);
1N/A if(out)
1N/A sfseek(out,(Sfoff_t)0,SEEK_SET);
1N/A else
1N/A out = sfnew((Sfio_t*)0,(char*)0,-1,-1,SF_WRITE|SF_STRING);
1N/A for(np=(Namval_t*)dtfirst(root);np;np=(Namval_t*)dtnext(root,np))
1N/A {
1N/A if(!nv_isnull(np) || np->nvfun || nv_isattr(np,~NV_NOFREE))
1N/A {
1N/A if(!first)
1N/A sfputc(out,' ');
1N/A else
1N/A first = 0;
1N/A sfputr(out,np->nvname,-1);
1N/A }
1N/A }
1N/A sfputc(out,0);
1N/A if(base)
1N/A dtview(root,base);
1N/A return((char*)out->_data);
1N/A}
1N/A#endif
1N/A
1N/A#if SHOPT_OPTIMIZE
1N/Astruct optimize
1N/A{
1N/A Namfun_t hdr;
1N/A Shell_t *sh;
1N/A char **ptr;
1N/A struct optimize *next;
1N/A Namval_t *np;
1N/A};
1N/A
1N/Astatic struct optimize *opt_free;
1N/A
1N/Astatic void optimize_clear(Namval_t* np, Namfun_t *fp)
1N/A{
1N/A struct optimize *op = (struct optimize*)fp;
1N/A nv_stack(np,fp);
1N/A nv_stack(np,(Namfun_t*)0);
1N/A for(;op && op->np==np; op=op->next)
1N/A {
1N/A if(op->ptr)
1N/A {
1N/A *op->ptr = 0;
1N/A op->ptr = 0;
1N/A }
1N/A }
1N/A}
1N/A
1N/Astatic void put_optimize(Namval_t* np,const char *val,int flags,Namfun_t *fp)
1N/A{
1N/A nv_putv(np,val,flags,fp);
1N/A optimize_clear(np,fp);
1N/A}
1N/A
1N/Astatic Namfun_t *clone_optimize(Namval_t* np, Namval_t *mp, int flags, Namfun_t *fp)
1N/A{
1N/A return((Namfun_t*)0);
1N/A}
1N/A
1N/Astatic const Namdisc_t optimize_disc = {sizeof(struct optimize),put_optimize,0,0,0,0,clone_optimize};
1N/A
1N/Avoid nv_optimize(Namval_t *np)
1N/A{
1N/A Shell_t *shp = sh_getinterp();
1N/A register Namfun_t *fp;
1N/A register struct optimize *op, *xp;
1N/A if(shp->argaddr)
1N/A {
1N/A if(np==SH_LINENO)
1N/A {
1N/A shp->argaddr = 0;
1N/A return;
1N/A }
1N/A for(fp=np->nvfun; fp; fp = fp->next)
1N/A {
1N/A if(fp->disc && (fp->disc->getnum || fp->disc->getval))
1N/A {
1N/A shp->argaddr = 0;
1N/A return;
1N/A }
1N/A if(fp->disc== &optimize_disc)
1N/A break;
1N/A }
1N/A if((xp= (struct optimize*)fp) && xp->ptr==shp->argaddr)
1N/A return;
1N/A if(op = opt_free)
1N/A opt_free = op->next;
1N/A else
1N/A op=(struct optimize*)calloc(1,sizeof(struct optimize));
1N/A op->ptr = shp->argaddr;
1N/A op->np = np;
1N/A if(xp)
1N/A {
1N/A op->hdr.disc = 0;
1N/A op->next = xp->next;
1N/A xp->next = op;
1N/A }
1N/A else
1N/A {
1N/A op->hdr.disc = &optimize_disc;
1N/A op->next = (struct optimize*)shp->optlist;
1N/A shp->optlist = (void*)op;
1N/A nv_stack(np,&op->hdr);
1N/A }
1N/A }
1N/A}
1N/A
1N/Avoid sh_optclear(Shell_t *shp, void *old)
1N/A{
1N/A register struct optimize *op,*opnext;
1N/A for(op=(struct optimize*)shp->optlist; op; op = opnext)
1N/A {
1N/A opnext = op->next;
1N/A if(op->ptr && op->hdr.disc)
1N/A {
1N/A nv_stack(op->np,&op->hdr);
1N/A nv_stack(op->np,(Namfun_t*)0);
1N/A }
1N/A op->next = opt_free;
1N/A opt_free = op;
1N/A }
1N/A shp->optlist = old;
1N/A}
1N/A
1N/A#else
1N/A# define optimize_clear(np,fp)
1N/A#endif /* SHOPT_OPTIMIZE */
1N/A
1N/A/*
1N/A * Return a pointer to a character string that denotes the value
1N/A * of <np>. If <np> refers to an array, return a pointer to
1N/A * the value associated with the current index.
1N/A *
1N/A * If the value of <np> is an integer, the string returned will
1N/A * be overwritten by the next call to nv_getval.
1N/A *
1N/A * If <np> has no value, 0 is returned.
1N/A */
1N/A
1N/Achar *nv_getval(register Namval_t *np)
1N/A{
1N/A Shell_t *shp = sh_getinterp();
1N/A register union Value *up= &np->nvalue;
1N/A register int numeric;
1N/A#if SHOPT_OPTIMIZE
1N/A if(!nv_local && shp->argaddr)
1N/A nv_optimize(np);
1N/A#endif /* SHOPT_OPTIMIZE */
1N/A if((!np->nvfun || !np->nvfun->disc) && !nv_isattr(np,NV_ARRAY|NV_INTEGER|NV_FUNCT|NV_REF))
1N/A goto done;
1N/A if(nv_isref(np))
1N/A {
1N/A if(!np->nvalue.cp)
1N/A return(0);
1N/A shp->last_table = nv_reftable(np);
1N/A return(nv_name(nv_refnode(np)));
1N/A }
1N/A if(np->nvfun && np->nvfun->disc)
1N/A {
1N/A if(!nv_local)
1N/A {
1N/A nv_local=1;
1N/A return(nv_getv(np, np->nvfun));
1N/A }
1N/A nv_local=0;
1N/A }
1N/A numeric = ((nv_isattr (np, NV_INTEGER)) != 0);
1N/A if(numeric)
1N/A {
1N/A Sflong_t ll;
1N/A if(!up->cp)
1N/A return("0");
1N/A if(nv_isattr (np,NV_DOUBLE)==NV_DOUBLE)
1N/A {
1N/A Sfdouble_t ld;
1N/A double d;
1N/A char *format;
1N/A if(nv_isattr(np,NV_LONG))
1N/A {
1N/A ld = *up->ldp;
1N/A if(nv_isattr (np,NV_EXPNOTE))
1N/A format = "%.*Lg";
1N/A else if(nv_isattr (np,NV_HEXFLOAT))
1N/A format = "%.*La";
1N/A else
1N/A format = "%.*Lf";
1N/A sfprintf(shp->strbuf,format,nv_size(np),ld);
1N/A }
1N/A else
1N/A {
1N/A d = *up->dp;
1N/A if(nv_isattr (np,NV_EXPNOTE))
1N/A format = "%.*g";
1N/A else if(nv_isattr (np,NV_HEXFLOAT))
1N/A format = "%.*a";
1N/A else
1N/A format = "%.*f";
1N/A sfprintf(shp->strbuf,format,nv_size(np),d);
1N/A }
1N/A return(sfstruse(shp->strbuf));
1N/A }
1N/A else if(nv_isattr(np,NV_UNSIGN))
1N/A {
1N/A if(nv_isattr (np,NV_LONG))
1N/A ll = *(Sfulong_t*)up->llp;
1N/A else if(nv_isattr (np,NV_SHORT))
1N/A {
1N/A if(nv_isattr(np,NV_INT16P)==NV_INT16P)
1N/A ll = *(uint16_t*)(up->sp);
1N/A else
1N/A ll = (uint16_t)up->s;
1N/A }
1N/A else
1N/A ll = *(uint32_t*)(up->lp);
1N/A }
1N/A else if(nv_isattr (np,NV_LONG))
1N/A ll = *up->llp;
1N/A else if(nv_isattr (np,NV_SHORT))
1N/A {
1N/A if(nv_isattr(np,NV_INT16P)==NV_INT16P)
1N/A ll = *up->sp;
1N/A else
1N/A ll = up->s;
1N/A }
1N/A else
1N/A ll = *(up->lp);
1N/A if((numeric=nv_size(np))==10)
1N/A {
1N/A if(nv_isattr(np,NV_UNSIGN))
1N/A {
1N/A sfprintf(shp->strbuf,"%I*u",sizeof(ll),ll);
1N/A return(sfstruse(shp->strbuf));
1N/A }
1N/A numeric = 0;
1N/A }
1N/A return(fmtbase(ll,numeric, numeric&&numeric!=10));
1N/A }
1N/Adone:
1N/A#if (_AST_VERSION>=20030127L)
1N/A /*
1N/A * if NV_RAW flag is on, return pointer to binary data
1N/A * otherwise, base64 encode the data and return this string
1N/A */
1N/A if(up->cp && nv_isattr(np,NV_BINARY) && !nv_isattr(np,NV_RAW))
1N/A {
1N/A char *cp;
1N/A char *ep;
1N/A int size= nv_size(np), insize=(4*size)/3+size/45+8;
1N/A base64encode(up->cp, size, (void**)0, cp=getbuf(insize), insize, (void**)&ep);
1N/A *ep = 0;
1N/A return(cp);
1N/A }
1N/A#endif
1N/A if((numeric=nv_size(np)) && up->cp && up->cp[numeric])
1N/A {
1N/A char *cp = getbuf(numeric+1);
1N/A memcpy(cp,up->cp,numeric);
1N/A cp[numeric]=0;
1N/A return(cp);
1N/A }
1N/A return ((char*)up->cp);
1N/A}
1N/A
1N/ASfdouble_t nv_getnum(register Namval_t *np)
1N/A{
1N/A Shell_t *shp = sh_getinterp();
1N/A register union Value *up;
1N/A register Sfdouble_t r=0;
1N/A register char *str;
1N/A#if SHOPT_OPTIMIZE
1N/A if(!nv_local && shp->argaddr)
1N/A nv_optimize(np);
1N/A#endif /* SHOPT_OPTIMIZE */
1N/A if(nv_istable(np))
1N/A errormsg(SH_DICT,ERROR_exit(1),e_number,nv_name(np));
1N/A if(np->nvfun && np->nvfun->disc)
1N/A {
1N/A if(!nv_local)
1N/A {
1N/A nv_local=1;
1N/A return(nv_getn(np, np->nvfun));
1N/A }
1N/A nv_local=0;
1N/A }
1N/A if(nv_isref(np))
1N/A {
1N/A str = nv_refsub(np);
1N/A np = nv_refnode(np);
1N/A if(str)
1N/A nv_putsub(np,str,0L);
1N/A }
1N/A if(nv_isattr (np, NV_INTEGER))
1N/A {
1N/A up= &np->nvalue;
1N/A if(!up->lp || up->cp==Empty)
1N/A r = 0;
1N/A else if(nv_isattr(np, NV_DOUBLE)==NV_DOUBLE)
1N/A {
1N/A if(nv_isattr(np, NV_LONG))
1N/A r = *up->ldp;
1N/A else
1N/A r = *up->dp;
1N/A }
1N/A else if(nv_isattr(np, NV_UNSIGN))
1N/A {
1N/A if(nv_isattr(np, NV_LONG))
1N/A r = (Sflong_t)*((Sfulong_t*)up->llp);
1N/A else if(nv_isattr(np, NV_SHORT))
1N/A {
1N/A if(nv_isattr(np,NV_INT16P)==NV_INT16P)
1N/A r = (Sflong_t)(*(uint16_t*)up->sp);
1N/A else
1N/A r = (Sflong_t)((uint16_t)up->s);
1N/A }
1N/A else
1N/A r = *((uint32_t*)up->lp);
1N/A }
1N/A else
1N/A {
1N/A if(nv_isattr(np, NV_LONG))
1N/A r = *up->llp;
1N/A else if(nv_isattr(np, NV_SHORT))
1N/A {
1N/A if(nv_isattr(np,NV_INT16P)==NV_INT16P)
1N/A r = *up->sp;
1N/A else
1N/A r = up->s;
1N/A }
1N/A else
1N/A r = *up->lp;
1N/A }
1N/A }
1N/A else if((str=nv_getval(np)) && *str!=0)
1N/A {
1N/A if(nv_isattr(np,NV_LJUST|NV_RJUST) || (*str=='0' && !(str[1]=='x'||str[1]=='X')))
1N/A {
1N/A while(*str=='0')
1N/A str++;
1N/A }
1N/A r = sh_arith(shp,str);
1N/A }
1N/A return(r);
1N/A}
1N/A
1N/A/*
1N/A * Give <np> the attributes <newatts,> and change its current
1N/A * value to conform to <newatts>. The <size> of left and right
1N/A * justified fields may be given.
1N/A */
1N/Avoid nv_newattr (register Namval_t *np, unsigned newatts, int size)
1N/A{
1N/A Shell_t *shp = sh_getinterp();
1N/A register char *sp;
1N/A register char *cp = 0;
1N/A register unsigned int n;
1N/A Namval_t *mp = 0;
1N/A Namarr_t *ap = 0;
1N/A int oldsize,oldatts,trans;
1N/A Namfun_t *fp= (newatts&NV_NODISC)?np->nvfun:0;
1N/A char *prefix = shp->prefix,*sub;
1N/A newatts &= ~NV_NODISC;
1N/A
1N/A /* check for restrictions */
1N/A if(sh_isoption(SH_RESTRICTED) && ((sp=nv_name(np))==nv_name(PATHNOD) || sp==nv_name(SHELLNOD) || sp==nv_name(ENVNOD) || sp==nv_name(FPATHNOD)))
1N/A errormsg(SH_DICT,ERROR_exit(1),e_restricted,nv_name(np));
1N/A /* handle attributes that do not change data separately */
1N/A n = np->nvflag;
1N/A trans = !(n&NV_INTEGER) && (n&(NV_LTOU|NV_UTOL));
1N/A if(newatts&NV_EXPORT)
1N/A nv_offattr(np,NV_IMPORT);
1N/A if(((n^newatts)&NV_EXPORT))
1N/A {
1N/A /* record changes to the environment */
1N/A if(n&NV_EXPORT)
1N/A env_delete(shp->env,nv_name(np));
1N/A else
1N/A sh_envput(shp->env,np);
1N/A }
1N/A oldsize = nv_size(np);
1N/A if((size==oldsize|| (n&NV_INTEGER)) && !trans && ((n^newatts)&~NV_NOCHANGE)==0)
1N/A {
1N/A if(size)
1N/A nv_setsize(np,size);
1N/A nv_offattr(np, ~NV_NOFREE);
1N/A nv_onattr(np, newatts);
1N/A return;
1N/A }
1N/A /* for an array, change all the elements */
1N/A if((ap=nv_arrayptr(np)) && ap->nelem>0)
1N/A nv_putsub(np,NIL(char*),ARRAY_SCAN);
1N/A oldsize = nv_size(np);
1N/A oldatts = np->nvflag;
1N/A if(fp)
1N/A np->nvfun = 0;
1N/A if(ap) /* add element to prevent array deletion */
1N/A {
1N/A ap->nelem++;
1N/A#if SHOPT_FIXEDARRAY
1N/A if(ap->fixed)
1N/A {
1N/A nv_setsize(np,size);
1N/A np->nvflag &= NV_ARRAY;
1N/A np->nvflag |= newatts;
1N/A goto skip;
1N/A }
1N/A#endif /* SHOPT_TYPEDEF */
1N/A }
1N/A do
1N/A {
1N/A nv_setsize(np,oldsize);
1N/A np->nvflag = oldatts;
1N/A if (sp = nv_getval(np))
1N/A {
1N/A if(nv_isattr(np,NV_ZFILL))
1N/A while(*sp=='0') sp++;
1N/A cp = (char*)malloc((n=strlen (sp)) + 1);
1N/A strcpy(cp, sp);
1N/A if(sp && (mp=nv_opensub(np)))
1N/A {
1N/A sub = nv_getsub(mp);
1N/A if(trans)
1N/A {
1N/A nv_disc(np, &ap->hdr,NV_POP);
1N/A nv_clone(np,mp,0);
1N/A nv_disc(np, &ap->hdr,NV_FIRST);
1N/A nv_offattr(mp,NV_ARRAY);
1N/A }
1N/A nv_newattr(mp,newatts&~NV_ARRAY,size);
1N/A }
1N/A if(!mp)
1N/A {
1N/A if(ap)
1N/A ap->nelem &= ~ARRAY_SCAN;
1N/A if(!trans)
1N/A _nv_unset(np,NV_RDONLY|NV_EXPORT);
1N/A if(ap)
1N/A ap->nelem |= ARRAY_SCAN;
1N/A }
1N/A if(size==0 && (newatts&NV_HOST)!=NV_HOST && (newatts&(NV_LJUST|NV_RJUST|NV_ZFILL)))
1N/A size = n;
1N/A }
1N/A else if(!trans)
1N/A _nv_unset(np,NV_EXPORT);
1N/A nv_setsize(np,size);
1N/A np->nvflag &= NV_ARRAY;
1N/A np->nvflag |= newatts;
1N/A if (cp)
1N/A {
1N/A if(!mp)
1N/A nv_putval (np, cp, NV_RDONLY);
1N/A free(cp);
1N/A }
1N/A }
1N/A while(ap && nv_nextsub(np));
1N/A#if SHOPT_FIXEDARRAY
1N/Askip:
1N/A#endif /* SHOPT_TYPEDEF */
1N/A if(fp)
1N/A np->nvfun = fp;
1N/A if(ap)
1N/A ap->nelem--;
1N/A shp->prefix = prefix;
1N/A return;
1N/A}
1N/A
1N/Astatic char *oldgetenv(const char *string)
1N/A{
1N/A register char c0,c1;
1N/A register const char *cp, *sp;
1N/A register char **av = environ;
1N/A if(!string || (c0= *string)==0)
1N/A return(0);
1N/A if((c1=*++string)==0)
1N/A c1= '=';
1N/A while(cp = *av++)
1N/A {
1N/A if(cp[0]!=c0 || cp[1]!=c1)
1N/A continue;
1N/A sp = string;
1N/A while(*sp && *sp++ == *++cp);
1N/A if(*sp==0 && *++cp=='=')
1N/A return((char*)(cp+1));
1N/A }
1N/A return(0);
1N/A}
1N/A
1N/A/*
1N/A * This version of getenv uses the hash storage to access environment values
1N/A */
1N/Achar *sh_getenv(const char *name)
1N/A{
1N/A Shell_t *shp = sh_getinterp();
1N/A register Namval_t *np;
1N/A if(!shp->var_tree)
1N/A {
1N/A#if 0
1N/A if(name[0] == 'P' && name[1] == 'A' && name[2] == 'T' && name[3] == 'H' && name[4] == 0 || name[0] == 'L' && ((name[1] == 'C' || name[1] == 'D') && name[2] == '_' || name[1] == 'A' && name[1] == 'N') || name[0] == 'V' && name[1] == 'P' && name[2] == 'A' && name[3] == 'T' && name[4] == 'H' && name[5] == 0 || name[0] == '_' && name[1] == 'R' && name[2] == 'L' && name[3] == 'D' || name[0] == '_' && name[1] == 'A' && name[2] == 'S' && name[3] == 'T' && name[4] == '_')
1N/A#endif
1N/A return(oldgetenv(name));
1N/A }
1N/A else if((np = nv_search(name,shp->var_tree,0)) && nv_isattr(np,NV_EXPORT))
1N/A return(nv_getval(np));
1N/A return(0);
1N/A}
1N/A
1N/A#ifndef _NEXT_SOURCE
1N/A/*
1N/A * Some dynamic linkers will make this file see the libc getenv(),
1N/A * so sh_getenv() is used for the astintercept() callback. Plain
1N/A * getenv() is provided for static links.
1N/A */
1N/Achar *getenv(const char *name)
1N/A{
1N/A return sh_getenv(name);
1N/A}
1N/A#endif /* _NEXT_SOURCE */
1N/A
1N/A#undef putenv
1N/A/*
1N/A * This version of putenv uses the hash storage to assign environment values
1N/A */
1N/Aint putenv(const char *name)
1N/A{
1N/A Shell_t *shp = sh_getinterp();
1N/A register Namval_t *np;
1N/A if(name)
1N/A {
1N/A np = nv_open(name,shp->var_tree,NV_EXPORT|NV_IDENT|NV_NOARRAY|NV_ASSIGN);
1N/A if(!strchr(name,'='))
1N/A _nv_unset(np,0);
1N/A }
1N/A return(0);
1N/A}
1N/A
1N/A/*
1N/A * Override libast setenviron().
1N/A */
1N/Achar* sh_setenviron(const char *name)
1N/A{
1N/A Shell_t *shp = sh_getinterp();
1N/A register Namval_t *np;
1N/A if(name)
1N/A {
1N/A np = nv_open(name,shp->var_tree,NV_EXPORT|NV_IDENT|NV_NOARRAY|NV_ASSIGN);
1N/A if(strchr(name,'='))
1N/A return(nv_getval(np));
1N/A _nv_unset(np,0);
1N/A }
1N/A return("");
1N/A}
1N/A
1N/A/*
1N/A * Same linker dance as with getenv() above.
1N/A */
1N/Achar* setenviron(const char *name)
1N/A{
1N/A return sh_setenviron(name);
1N/A}
1N/A
1N/A/*
1N/A * normalize <cp> and return pointer to subscript if any
1N/A * if <eq> is specified, return pointer to first = not in a subscript
1N/A */
1N/Astatic char *lastdot(char *cp, int eq)
1N/A{
1N/A register char *ep=0;
1N/A register int c;
1N/A if(eq)
1N/A cp++;
1N/A while(c= mbchar(cp))
1N/A {
1N/A if(c=='[')
1N/A {
1N/A if(*cp==']')
1N/A cp++;
1N/A else
1N/A cp = nv_endsubscript((Namval_t*)0,ep=cp,0);
1N/A }
1N/A else if(c=='.')
1N/A {
1N/A if(*cp=='[')
1N/A {
1N/A cp = nv_endsubscript((Namval_t*)0,ep=cp,0);
1N/A if((ep=sh_checkid(ep+1,cp)) < cp)
1N/A cp=strcpy(ep,cp);
1N/A }
1N/A ep = 0;
1N/A }
1N/A else if(eq && c == '=')
1N/A return(cp-1);
1N/A }
1N/A return(eq?0:ep);
1N/A}
1N/A
1N/Aint nv_rename(register Namval_t *np, int flags)
1N/A{
1N/A Shell_t *shp = sh_getinterp();
1N/A register Namval_t *mp=0,*nr=0;
1N/A register char *cp;
1N/A int r=0,arraynp,arraynr,index= -1;
1N/A Namval_t *last_table = shp->last_table;
1N/A Dt_t *last_root = shp->last_root;
1N/A Dt_t *hp = 0;
1N/A char *nvenv=0,*prefix=shp->prefix;
1N/A Namarr_t *ap,*aq=0;
1N/A if(nv_isattr(np,NV_PARAM) && shp->st.prevst)
1N/A {
1N/A if(!(hp=(Dt_t*)shp->st.prevst->save_tree))
1N/A hp = dtvnext(shp->var_tree);
1N/A }
1N/A if(cp = nv_name(np))
1N/A arraynp = cp[strlen(cp)-1] == ']';
1N/A if(!(cp=nv_getval(np)))
1N/A {
1N/A if(flags&NV_MOVE)
1N/A errormsg(SH_DICT,ERROR_exit(1),e_varname,"");
1N/A return(0);
1N/A }
1N/A if(lastdot(cp,0) && nv_isattr(np,NV_MINIMAL))
1N/A errormsg(SH_DICT,ERROR_exit(1),e_varname,nv_name(np));
1N/A arraynr = cp[strlen(cp)-1] == ']';
1N/A if(nv_isarray(np) && !(mp=nv_opensub(np)))
1N/A index=nv_aindex(np);
1N/A shp->prefix = 0;
1N/A if(!hp)
1N/A hp = shp->var_tree;
1N/A if(!(nr = nv_open(cp, hp, flags|NV_ARRAY|NV_NOREF|NV_NOSCOPE|NV_NOADD|NV_NOFAIL)))
1N/A {
1N/A#if SHOPT_NAMESPACE
1N/A if(shp->namespace)
1N/A hp = nv_dict(shp->namespace);
1N/A else
1N/A#endif /* SHOPT_NAMESPACE */
1N/A hp = shp->var_base;
1N/A }
1N/A else if(shp->last_root)
1N/A hp = shp->last_root;
1N/A if(!nr)
1N/A nr= nv_open(cp, hp, flags|NV_NOREF|((flags&NV_MOVE)?0:NV_NOFAIL));
1N/A shp->prefix = prefix;
1N/A if(!nr)
1N/A {
1N/A if(!nv_isvtree(np))
1N/A _nv_unset(np,0);
1N/A return(0);
1N/A }
1N/A if(!mp && index>=0 && nv_isvtree(nr))
1N/A {
1N/A sfprintf(shp->strbuf,"%s[%d]%c",nv_name(np),index,0);
1N/A /* create a virtual node */
1N/A if(mp = nv_open(sfstruse(shp->strbuf),shp->var_tree,NV_VARNAME|NV_ADD|NV_ARRAY))
1N/A {
1N/A if(ap = nv_arrayptr(np))
1N/A ap->nelem++;
1N/A mp->nvenv = nvenv = (void*)np;
1N/A }
1N/A }
1N/A if(mp)
1N/A np = mp;
1N/A if(nr==np)
1N/A {
1N/A if(index<0)
1N/A return(0);
1N/A if(cp = nv_getval(np))
1N/A cp = strdup(cp);
1N/A }
1N/A _nv_unset(np,NV_EXPORT);
1N/A if(nr==np)
1N/A {
1N/A nv_putsub(np,(char*)0, index);
1N/A nv_putval(np,cp,0);
1N/A free((void*)cp);
1N/A return(1);
1N/A }
1N/A shp->prev_table = shp->last_table;
1N/A shp->prev_root = shp->last_root;
1N/A shp->last_table = last_table;
1N/A shp->last_root = last_root;
1N/A if(flags&NV_MOVE)
1N/A {
1N/A if(arraynr && !nv_isattr(nr,NV_MINIMAL) && (mp=(Namval_t*)nr->nvenv) && (ap=nv_arrayptr(mp)))
1N/A ap->nelem--;
1N/A if(arraynp && !nv_isattr(np,NV_MINIMAL) && (mp=(Namval_t*)np->nvenv) && (ap=nv_arrayptr(mp)))
1N/A ap->nelem++;
1N/A }
1N/A if(((aq=nv_arrayptr(nr)) && !arraynr) || nv_isvtree(nr))
1N/A {
1N/A if(ap=nv_arrayptr(np))
1N/A {
1N/A if(!ap->table)
1N/A ap->table = dtopen(&_Nvdisc,Dtoset);
1N/A if(ap->table)
1N/A mp = nv_search(nv_getsub(np),ap->table,NV_ADD);
1N/A nv_arraychild(np,mp,0);
1N/A nvenv = (void*)np;
1N/A }
1N/A else
1N/A mp = np;
1N/A nv_clone(nr,mp,(flags&NV_MOVE)|NV_COMVAR);
1N/A mp->nvenv = nvenv;
1N/A if(flags&NV_MOVE)
1N/A nv_delete(nr,(Dt_t*)0,NV_NOFREE);
1N/A }
1N/A else
1N/A {
1N/A nv_putval(np,nv_getval(nr),0);
1N/A if(flags&NV_MOVE)
1N/A _nv_unset(nr,0);
1N/A }
1N/A return(1);
1N/A}
1N/A
1N/A/*
1N/A * Create a reference node from <np> to $np in dictionary <hp>
1N/A */
1N/Avoid nv_setref(register Namval_t *np, Dt_t *hp, int flags)
1N/A{
1N/A Shell_t *shp = sh_getinterp();
1N/A register Namval_t *nq=0, *nr=0;
1N/A register char *ep,*cp;
1N/A Dt_t *root = shp->last_root, *hpnext=0;
1N/A Namarr_t *ap=0;
1N/A if(nv_isref(np))
1N/A return;
1N/A if(nv_isarray(np))
1N/A errormsg(SH_DICT,ERROR_exit(1),e_badref,nv_name(np));
1N/A if(!(cp=nv_getval(np)))
1N/A {
1N/A _nv_unset(np,0);
1N/A nv_onattr(np,NV_REF);
1N/A return;
1N/A }
1N/A if((ep = lastdot(cp,0)) && nv_isattr(np,NV_MINIMAL))
1N/A errormsg(SH_DICT,ERROR_exit(1),e_badref,nv_name(np));
1N/A if(hp)
1N/A hpnext = dtvnext(hp);
1N/A if((nr=nv_open(cp, hp?hp:shp->var_tree, flags|NV_NOSCOPE|NV_NOADD|NV_NOFAIL)) ||
1N/A (hpnext && dtvnext(hpnext)==shp->var_base && (nr=nv_open(cp,hpnext,flags|NV_NOSCOPE|NV_NOADD|NV_NOFAIL))))
1N/A {
1N/A nq = nr;
1N/A hp = shp->last_root;
1N/A }
1N/A else
1N/A hp = hp?shp->var_base:shp->var_tree;
1N/A if(nr==np)
1N/A {
1N/A if(shp->namespace && nv_dict(shp->namespace)==hp)
1N/A errormsg(SH_DICT,ERROR_exit(1),e_selfref,nv_name(np));
1N/A /* bind to earlier scope, or add to global scope */
1N/A if(!(hp=dtvnext(hp)) || (nq=nv_search((char*)np,hp,NV_ADD|HASH_BUCKET))==np)
1N/A errormsg(SH_DICT,ERROR_exit(1),e_selfref,nv_name(np));
1N/A if(nv_isarray(nq))
1N/A nv_putsub(nq,(char*)0,ARRAY_UNDEF);
1N/A }
1N/A#if SHOPT_FIXEDARRAY
1N/A if(nq && ep && nv_isarray(nq) && !((ap=nv_arrayptr(nq)) && ap->fixed) && !nv_getsub(nq))
1N/A#else
1N/A if(nq && ep && nv_isarray(nq) && !nv_getsub(nq))
1N/A#endif /* SHOPT_FIXEDARRAY */
1N/A {
1N/A if(!nv_arrayptr(nq))
1N/A {
1N/A nv_putsub(nq,"1",ARRAY_FILL);
1N/A _nv_unset(nq,NV_RDONLY);
1N/A }
1N/A nv_endsubscript(nq,ep-1,NV_ARRAY);
1N/A }
1N/A if(!nr)
1N/A {
1N/A shp->last_root = 0;
1N/A nr= nq = nv_open(cp, hp, flags);
1N/A if(shp->last_root)
1N/A hp = shp->last_root;
1N/A }
1N/A if(shp->last_root == shp->var_tree && root!=shp->var_tree)
1N/A {
1N/A _nv_unset(np,NV_RDONLY);
1N/A nv_onattr(np,NV_REF);
1N/A errormsg(SH_DICT,ERROR_exit(1),e_globalref,nv_name(np));
1N/A }
1N/A shp->instance = 1;
1N/A if(nq && !ep && (ap=nv_arrayptr(nq)) && !(ap->nelem&(ARRAY_UNDEF|ARRAY_SCAN)))
1N/A ep = nv_getsub(nq);
1N/A#if SHOPT_FIXEDARRAY
1N/A if(ep && !(ap && ap->fixed))
1N/A#else
1N/A if(ep)
1N/A#endif /* SHOPT_FIXEDARRAY */
1N/A {
1N/A /* cause subscript evaluation and return result */
1N/A if(nv_isarray(nq))
1N/A ep = nv_getsub(nq);
1N/A else
1N/A {
1N/A int n;
1N/A ep[n=strlen(ep)-1] = 0;
1N/A nv_putsub(nr, ep, ARRAY_FILL);
1N/A ep[n] = ']';
1N/A if(nq = nv_opensub(nr))
1N/A ep = 0;
1N/A else
1N/A ep = nv_getsub(nq=nr);
1N/A }
1N/A }
1N/A shp->instance = 0;
1N/A shp->last_root = root;
1N/A _nv_unset(np,0);
1N/A nv_delete(np,(Dt_t*)0,0);
1N/A np->nvalue.nrp = newof(0,struct Namref,1,sizeof(Dtlink_t));
1N/A np->nvalue.nrp->np = nq;
1N/A np->nvalue.nrp->root = hp;
1N/A if(ep)
1N/A {
1N/A#if SHOPT_FIXEDARRAY
1N/A if(ap && ap->fixed)
1N/A np->nvalue.nrp->curi = ARRAY_FIXED|nv_arrfixed(nq,(Sfio_t*)0,1,&np->nvalue.nrp->dim);
1N/A else
1N/A#endif /* SHOPT_FIXEDARRAY */
1N/A np->nvalue.nrp->sub = strdup(ep);
1N/A }
1N/A np->nvalue.nrp->table = shp->last_table;
1N/A nv_onattr(np,NV_REF|NV_NOFREE);
1N/A if(!Refdict)
1N/A {
1N/A NullNode.nvname = ".deleted";
1N/A NullNode.nvflag = NV_RDONLY;
1N/A Refdict = dtopen(&_Refdisc,Dtobag);
1N/A }
1N/A dtinsert(Refdict,np->nvalue.nrp);
1N/A}
1N/A
1N/A/*
1N/A * get the scope corresponding to <index>
1N/A * whence uses the same values as lseeek()
1N/A */
1N/AShscope_t *sh_getscope(int index, int whence)
1N/A{
1N/A Shell_t *shp = sh_getinterp();
1N/A register struct sh_scoped *sp, *topmost;
1N/A if(whence==SEEK_CUR)
1N/A sp = &shp->st;
1N/A else
1N/A {
1N/A if ((struct sh_scoped*)shp->topscope != shp->st.self)
1N/A topmost = (struct sh_scoped*)shp->topscope;
1N/A else
1N/A topmost = &(shp->st);
1N/A sp = topmost;
1N/A if(whence==SEEK_SET)
1N/A {
1N/A int n =0;
1N/A while(sp = sp->prevst)
1N/A n++;
1N/A index = n - index;
1N/A sp = topmost;
1N/A }
1N/A }
1N/A if(index < 0)
1N/A return((Shscope_t*)0);
1N/A while(index-- && (sp = sp->prevst));
1N/A return((Shscope_t*)sp);
1N/A}
1N/A
1N/A/*
1N/A * make <scoped> the top scope and return previous scope
1N/A */
1N/AShscope_t *sh_setscope(Shscope_t *scope)
1N/A{
1N/A Shell_t *shp = sh_getinterp();
1N/A Shscope_t *old = (Shscope_t*)shp->st.self;
1N/A *shp->st.self = shp->st;
1N/A shp->st = *((struct sh_scoped*)scope);
1N/A shp->var_tree = scope->var_tree;
1N/A SH_PATHNAMENOD->nvalue.cp = shp->st.filename;
1N/A SH_FUNNAMENOD->nvalue.cp = shp->st.funname;
1N/A return(old);
1N/A}
1N/A
1N/Avoid sh_unscope(Shell_t *shp)
1N/A{
1N/A register Dt_t *root = shp->var_tree;
1N/A register Dt_t *dp = dtview(root,(Dt_t*)0);
1N/A table_unset(shp,root,NV_RDONLY|NV_NOSCOPE,dp);
1N/A if(shp->st.real_fun && dp==shp->st.real_fun->sdict)
1N/A {
1N/A dp = dtview(dp,(Dt_t*)0);
1N/A shp->st.real_fun->sdict->view = dp;
1N/A }
1N/A shp->var_tree=dp;
1N/A dtclose(root);
1N/A}
1N/A
1N/A/*
1N/A * The inverse of creating a reference node
1N/A */
1N/Avoid nv_unref(register Namval_t *np)
1N/A{
1N/A Namval_t *nq;
1N/A if(!nv_isref(np))
1N/A return;
1N/A nv_offattr(np,NV_NOFREE|NV_REF);
1N/A if(!np->nvalue.nrp)
1N/A return;
1N/A nq = nv_refnode(np);
1N/A if(Refdict)
1N/A {
1N/A if(np->nvalue.nrp->sub)
1N/A free(np->nvalue.nrp->sub);
1N/A dtdelete(Refdict,(void*)np->nvalue.nrp);
1N/A }
1N/A free((void*)np->nvalue.nrp);
1N/A np->nvalue.cp = strdup(nv_name(nq));
1N/A#if SHOPT_OPTIMIZE
1N/A {
1N/A Namfun_t *fp;
1N/A for(fp=nq->nvfun; fp; fp = fp->next)
1N/A {
1N/A if(fp->disc== &optimize_disc)
1N/A {
1N/A optimize_clear(nq,fp);
1N/A return;
1N/A }
1N/A }
1N/A }
1N/A#endif
1N/A}
1N/A
1N/A/*
1N/A * These following are for binary compatibility with the old hash library
1N/A * They will be removed someday
1N/A */
1N/A
1N/A#if defined(__IMPORT__) && defined(__EXPORT__)
1N/A# define extern __EXPORT__
1N/A#endif
1N/A
1N/A#undef hashscope
1N/A
1N/Aextern Dt_t *hashscope(Dt_t *root)
1N/A{
1N/A return(dtvnext(root));
1N/A}
1N/A
1N/A#undef hashfree
1N/A
1N/Aextern Dt_t *hashfree(Dt_t *root)
1N/A{
1N/A Dt_t *dp = dtvnext(root);
1N/A dtclose(root);
1N/A return(dp);
1N/A}
1N/A
1N/A#undef hashname
1N/A
1N/Aextern char *hashname(void *obj)
1N/A{
1N/A Namval_t *np = (Namval_t*)obj;
1N/A return(np->nvname);
1N/A}
1N/A
1N/A#undef hashlook
1N/A
1N/Aextern void *hashlook(Dt_t *root, const char *name, int mode,int size)
1N/A{
1N/A NOT_USED(size);
1N/A return((void*)nv_search(name,root,mode));
1N/A}
1N/A
1N/Achar *nv_name(register Namval_t *np)
1N/A{
1N/A Shell_t *shp = sh_getinterp();
1N/A register Namval_t *table;
1N/A register Namfun_t *fp;
1N/A#if SHOPT_FIXEDARRAY
1N/A Namarr_t *ap;
1N/A#endif /* SHOPT_FIXEDARRAY */
1N/A char *cp;
1N/A if(is_abuiltin(np) || is_afunction(np))
1N/A {
1N/A#if SHOPT_NAMESPACE
1N/A if(shp->namespace && is_afunction(np))
1N/A {
1N/A char *name = nv_name(shp->namespace);
1N/A int n = strlen(name);
1N/A if(memcmp(np->nvname,name,n)==0 && np->nvname[n]=='.')
1N/A return(np->nvname+n+1);
1N/A }
1N/A#endif /* SHOPT_NAMESPACE */
1N/A return(np->nvname);
1N/A }
1N/A#if SHOPT_FIXEDARRAY
1N/A ap = nv_arrayptr(np);
1N/A#endif /* SHOPT_FIXEDARRAY */
1N/A if(!nv_isattr(np,NV_MINIMAL|NV_EXPORT) && np->nvenv)
1N/A {
1N/A Namval_t *nq= shp->last_table, *mp= (Namval_t*)np->nvenv;
1N/A if(np==shp->last_table)
1N/A shp->last_table = 0;
1N/A if(nv_isarray(mp))
1N/A sfprintf(shp->strbuf,"%s[%s]",nv_name(mp),np->nvname);
1N/A else
1N/A sfprintf(shp->strbuf,"%s.%s",nv_name(mp),np->nvname);
1N/A shp->last_table = nq;
1N/A return(sfstruse(shp->strbuf));
1N/A }
1N/A if(nv_istable(np))
1N/A#if 1
1N/A shp->last_table = nv_parent(np);
1N/A#else
1N/A shp->last_table = nv_create(np,0, NV_LAST,(Namfun_t*)0);
1N/A#endif
1N/A else if(!nv_isref(np))
1N/A {
1N/A for(fp= np->nvfun ; fp; fp=fp->next)
1N/A if(fp->disc && fp->disc->namef)
1N/A {
1N/A if(np==shp->last_table)
1N/A shp->last_table = 0;
1N/A return((*fp->disc->namef)(np,fp));
1N/A }
1N/A }
1N/A if(!(table=shp->last_table) || *np->nvname=='.' || table==shp->namespace || np==table)
1N/A {
1N/A#if SHOPT_FIXEDARRAY
1N/A if(!ap || !ap->fixed || (ap->nelem&ARRAY_UNDEF))
1N/A return(np->nvname);
1N/A table = 0;
1N/A#else
1N/A return(np->nvname);
1N/A#endif /* SHOPT_FIXEDARRAY */
1N/A }
1N/A if(table)
1N/A {
1N/A cp = nv_name(table);
1N/A sfprintf(shp->strbuf,"%s.%s",cp,np->nvname);
1N/A }
1N/A else
1N/A sfprintf(shp->strbuf,"%s",np->nvname);
1N/A#if SHOPT_FIXEDARRAY
1N/A if(ap && ap->fixed)
1N/A nv_arrfixed(np,shp->strbuf,1,(char*)0);
1N/A#endif /* SHOPT_FIXEDARRAY */
1N/A return(sfstruse(shp->strbuf));
1N/A}
1N/A
1N/ANamval_t *nv_lastdict(void)
1N/A{
1N/A Shell_t *shp = sh_getinterp();
1N/A return(shp->last_table);
1N/A}
1N/A
1N/A#undef nv_context
1N/A/*
1N/A * returns the data context for a builtin
1N/A */
1N/Avoid *nv_context(Namval_t *np)
1N/A{
1N/A return((void*)np->nvfun);
1N/A}
1N/A
1N/A#define DISABLE /* proto workaround */
1N/A
1N/Aint nv_isnull DISABLE (register Namval_t *np)
1N/A{
1N/A return(nv_isnull(np));
1N/A}
1N/A
1N/A#undef nv_setsize
1N/Aint nv_setsize(register Namval_t *np, int size)
1N/A{
1N/A int oldsize = nv_size(np);
1N/A if(size>=0)
1N/A np->nvsize = size;
1N/A return(oldsize);
1N/A}
1N/A
1N/AShell_t *nv_shell(Namval_t *np)
1N/A{
1N/A Namfun_t *fp;
1N/A for(fp=np->nvfun;fp;fp=fp->next)
1N/A {
1N/A if(!fp->disc)
1N/A return((Shell_t*)fp->last);
1N/A }
1N/A return(0);
1N/A}
1N/A
1N/A#undef nv_unset
1N/A
1N/Avoid nv_unset(register Namval_t *np)
1N/A{
1N/A _nv_unset(np,0);
1N/A return;
1N/A}