/***********************************************************************
* *
* This software is part of the ast package *
* Copyright (c) 1982-2012 AT&T Intellectual Property *
* and is licensed under the *
* Eclipse Public License, Version 1.0 *
* by AT&T Intellectual Property *
* *
* A copy of the License is available at *
* (with md5 checksum b35adb5213ca9657e911e9befb180842) *
* *
* Information and Software Systems Research *
* AT&T Research *
* Florham Park NJ *
* *
* David Korn <dgk@research.att.com> *
* *
***********************************************************************/
#pragma prototyped
/*
* David Korn
* AT&T Labs
*
*/
#include "defs.h"
#include "io.h"
#include "variables.h"
static const char sh_opttype[] =
"[-1c?\n@(#)$Id: type (AT&T Labs Research) 2008-07-01 $\n]"
"[+NAME?\f?\f - set the type of variables to \b\f?\f\b]"
"[+DESCRIPTION?\b\f?\f\b sets the type on each of the variables specified "
"by \aname\a to \b\f?\f\b. If \b=\b\avalue\a is specified, "
"the variable \aname\a is set to \avalue\a before the variable "
"is converted to \b\f?\f\b.]"
"[+?If no \aname\as are specified then the names and values of all "
"variables of this type are written to standard output.]"
"[+?\b\f?\f\b is built-in to the shell as a declaration command so that "
"field splitting and pathname expansion are not performed on "
"the arguments. Tilde expansion occurs on \avalue\a.]"
"[r?Enables readonly. Once enabled, the value cannot be changed or unset.]"
"[a]:?[type?Indexed array. Each \aname\a will converted to an index "
"array of type \b\f?\f\b. If a variable already exists, the current "
"value will become index \b0\b. If \b[\b\atype\a\b]]\b is "
"specified, each subscript is interpreted as a value of enumeration "
"type \atype\a.]"
"[A?Associative array. Each \aname\a will converted to an associate "
"array of type \b\f?\f\b. If a variable already exists, the current "
"value will become subscript \b0\b.]"
"[h]:[string?Used within a type definition to provide a help string "
"for variable \aname\a. Otherwise, it is ignored.]"
"[S?Used with a type definition to indicate that the variable is shared by "
"each instance of the type. When used inside a function defined "
"with the \bfunction\b reserved word, the specified variables "
"will have function static scope. Otherwise, the variable is "
"unset prior to processing the assignment list.]"
"[+DETAILS]\ftypes\f"
"\n"
"\n[name[=value]...]\n"
"\n"
"[+EXIT STATUS?]{"
"[+0?Successful completion.]"
"[+>0?An error occurred.]"
"}"
"[+SEE ALSO?\fother\f \breadonly\b(1), \btypeset\b(1)]"
;
typedef struct Namchld
{
} Namchld_t;
struct Namtype
{
#if SHOPT_NAMESPACE
#endif /* SHOPT_NAMESPACE */
char *nodes;
char *data;
int numnodes;
char **names;
short strsize;
unsigned short ndisc;
unsigned short current;
unsigned short nref;
};
#if 0
struct type
{
unsigned short ndisc;
unsigned short current;
unsigned short nref;
};
#endif
typedef struct
{
char _cSfdouble_t;
char _cdouble;
double _ddouble;
char _cfloat;
float _dfloat;
char _cSflong_t;
char _clong;
long _dlong;
char _cshort;
short _dshort;
char _cpointer;
char *_dpointer;
} _Align_;
{
sizeof(Namtype_t),
0,
0,
0,
0,
0,
#if 0
#endif
};
{
size_t s=0, a=0;
{
{
{
a = alignof(Sfdouble_t);
s = sizeof(Sfdouble_t);
}
{
a = alignof(float);
s = sizeof(float);
}
else
{
a = alignof(double);
s = sizeof(double);
}
}
else
{
{
s = sizeof(Sflong_t);
}
{
a = alignof(short);
s = sizeof(short);
}
else
{
s = sizeof(int32_t);
}
}
}
else
{
}
if(a>1 && offset)
return(s);
}
{
sh.last_table = 0;
else
#if SHOPT_FIXEDARRAY
#endif /* SHOPT_FIXEDARRAY */
}
{
return;
if(!val)
{
{
}
{
}
}
}
{
return(0);
}
{
sizeof(Namchld_t),
0,
0,
0,
0,
};
{
while(--i>0)
{
{
}
}
return(0);
}
{
{
nv_setsize(nq,0);
else
return(1);
}
{
{
if(nv_isarray(nq))
else
if(fp)
}
#if 0
#else
#endif
{
{
{
}
else
}
}
}
if(fp)
return(0);
}
{
register int i;
char *cp;
{
return(fp);
}
{
}
#if 0
#else
#endif
#if 0
#endif
{
{
nrp++;
}
continue;
{
/* see if default value has been overwritten */
continue;
else
stakputc('.');
stakputc(0);
if(nr)
{
{
do
{
if(array_assoc(ap))
else
if(array_assoc(ap))
{
}
else
{
}
}
while(nv_nextsub(nr));
}
else
#if SHOPT_TYPEDEF
#endif /* SHOPT_TYPEDEF */
continue;
}
}
}
}
/*
* return Namval_t* corresponding to child <name> in <np>
*/
{
register int i=0,n;
if(!name)
{
{
goto found;
}
nq = 0;
}
{
{
goto found;
}
}
nq = 0;
if(nq)
{
}
else
{
{
return(nq);
}
}
return(nq);
}
{
{
{
return;
}
}
if(!val)
{
int i;
return;
{
}
}
}
{
if(!root)
{
}
return(0);
}
{
else
return(pp);
}
{
stakputc('.');
stakputc(0);
if(!np)
{
return(-1);
}
{
{
break;
}
if(!fp)
{
return(-1);
}
return(0);
return(0);
}
{
{
{
}
}
return(0);
}
{
{
i++;
}
else
{
cp = 0;
buffer[n] = 0;
if(cp)
else
}
if(help[i])
}
{
stakputc('.');
stakputc('.');
n = staktell();
{
stakputc(0);
cp = 0;
else
if(cp)
stakseek(n);
}
}
return(0);
}
{
register const char **argv;
register int i;
if(cp)
cp++;
else
{
if(pp)
return(0);
}
{
{
if(!pp)
return(1);
goto found;
}
}
return(0);
{
{
break;
}
}
if(np)
{
}
else
return(1);
}
{
char *name;
if(optstr)
else
name++;
else
#if SHOPT_NAMESPACE
{
if(tp)
}
#endif /* SHOPT_NAMESPACE */
}
{
struct {
} optdisc;
}
/*
* This function creates a type out of the <numnodes> nodes in the
* array <nodes>. The first node is the name for the type
*/
{
if(numnodes < 2)
{
}
{
if(is_afunction(np))
{
{
nd++;
}
continue;
}
iref++;
continue;
if(qp)
{ /* delete duplicates */
{
break;
}
continue;
}
nnodes++;
offset -= sizeof(char*);
{
n = -n;
{
offset = 0;
size += n;
}
else
i++;
}
nref++;
}
if(nd)
nd++;
pp = newof(NiL, Namtype_t, 1, nnodes*NV_MINSZ + offset + size + (nnodes+nd)*sizeof(char*) + iref*sizeof(struct Namref)+k);
if(qp)
nd = 0;
*cp++ = 0;
{
if(is_afunction(np))
{
{
/* see if discipline already defined */
for(j=0; j< nd; j++)
{
{
break;
}
}
if(j>=nd)
{
*cp++ = 0;
}
}
continue;
}
if(inherit)
{
for(j=0; j < k ; j++)
{
break;
}
if(j < k)
{
if(nv_isvtree(np))
else if(sp)
goto skip;
}
}
{
goto skip;
}
if(qp)
{
{
{
nrp++;
}
{
else
{
}
}
}
{
{
}
}
qp = 0;
inherit=1;
goto skip;
}
{
/* need to save the string pointer */
j = *help[k];
if(islower(j))
*cp++ = 0;
}
offset -= sizeof(char*);
*cp++ = 0;
{
int r,kfirst=k;
/*
* If field is a type, mark the type by setting
* strsize<0. This changes create_type()
*/
if(nv_isarray(np))
{
k++;
goto skip;
}
{
{
{
}
else
}
{
*cp++ = '.';
}
*cp++ = 0;
}
while((i+1) < numnodes && (cname=&nodes[i+1]->nvname[m]) && memcmp(cname,&np->nvname[m],n)==0 && cname[n]=='.')
{
int j=kfirst;
while(j < k)
{
{
break;
}
}
}
}
else
{
j = 1;
{
}
{
{
j = 1;
}
if(sp)
if(!j)
}
#if 0
#else
#endif
}
k++;
skip:
}
if(k>1)
{
}
if(nd>0)
{
}
nv_newtype(mp);
return(mp);
}
{
stakputc('.');
stakputc(0);
if(ep)
if(size==16)
else if(size==64)
if(!sign)
nv_newtype(mp);
return(mp);
}
{
char *v,*cp;
cp = v+1;
{
}
else
}
{
{
}
{
return(np);
}
return(0);
}
/*
* call any and all create functions
*/
{
int i;
if(!pp)
return;
{
}
}
/*
* This function turns variable <np> to the type <tp>
*/
{
char *val=0;
#if SHOPT_TYPEDEF
return(0);
{
return(0);
}
{
do
{
}
while(nv_nextsub(np));
}
{
if(!ap)
{
if(subshell)
{
}
nelem = 1;
}
}
else
#endif /*SHOPT_TYPEDEF */
{
if(isnull)
else if(!nv_isvtree(np))
{
}
return(0);
}
if(ap)
{
int nofree;
if(nelem)
{
}
}
if(!rdonly)
if(val)
{
}
return(0);
}
#define S(x) #x
typedef struct _field_
{
char *name;
char *type;
int offset;
} Fields_t;
{
#if 0
#endif
0
};
{
stakputc('.');
r = staktell();
stakputc(0);
stakseek(r);
{
size += m;
nnodes++;
{
stakputc(0);
stakseek(r);
if(!tp)
{
i = -i;
}
}
}
{
cp += m;
{
stakputc(0);
stakseek(r);
{
{
cp += m;
cp += n;
{
}
}
}
}
{
}
}
nv_newtype(mp);
return(mp);
}
{
if(val)
{
return;
}
}
{
0,
};
void nv_mkstat(void)
{
}
{
while(n-- && (c = *str++))
{
if(c=='\n')
{
if(!first)
first = 0;
}
}
{
}
}
{
int n=0,indent = 0;
{
indent=1;
while(*cp)
{
if(*cp++ =='.')
indent++;
}
}
return(0);
if(indent==0)
{
continue;
}
{
continue;
if(indent && (memcmp(tp->nvname,shp->prefix,n-1) || tp->nvname[n-1]!='.' || strchr(tp->nvname+n,'.')))
continue;
if(indent)
shp->last_table = 0;
if(indent)
else
{
continue;
cp++;
else
if(indent)
else
xp = 0;
{
else
if(xp)
{
if(indent)
}
iop = 0;
}
}
if(indent)
}
return(0);
}