#pragma prototyped

#include <shell.h>

static const char enum_usage[] =

"type \atypename\a that can only store any one of the values in the indexed "

"array variable \atypename\a.]"

"indexed array variable with at least two elements.]"

"{"

"[+0?Successful completion.]"

"[+>0?An error occurred.]"

"}"

;

static const char enum_type[] =

"enumeration type \b\f?\f\b where \b\f?\f\b is a type that has been "

"created with the \benum\b(1) command.]"

"The the values are \fcase\fcase sensitive.]"

"variables of this type are written to standard output.]"

"field splitting and pathname expansion are not performed on "

"the arguments. Tilde expansion occurs on \avalue\a.]"

"array of type \b\f?\f\b. If a variable already exists, the current "

"value will become index \b0\b.]"

"array of type \b\f?\f\b. If a variable already exists, the current "

"value will become subscript \b0\b.]"

"for variable \aname\a. Otherwise, it is ignored.]"

"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.]"

#if 0

"used as input to the shell to recreate the current type of "

"these variables.]"

#endif

"[+0?Successful completion.]"

"[+>0?An error occurred.]"

;

struct Enum

{

Namfun_t hdr;

short nelem;

short iflag;

const char *values[1];

};

static int enuminfo(Opt_t* op, Sfio_t *out, const char *str, Optdisc_t *fp)

{

Namval_t *np;

struct Enum *ep;

int n=0;

const char *v;

np = *(Namval_t**)(fp+1);

ep = (struct Enum*)np->nvfun;

if(strcmp(str,"default")==0)

#if 0

sfprintf(out,"\b%s\b%c",ep->values[0],0);

#else

sfprintf(out,"\b%s\b",ep->values[0]);

#endif

else if(strcmp(str,"case")==0)

{

if(ep->iflag)

sfprintf(out,"not ");

}

else while(v=ep->values[n++])

{

sfprintf(out,", \b%s\b",v);

}

return(0);

}

static Namfun_t *clone_enum(Namval_t* np, Namval_t *mp, int flags, Namfun_t *fp)

{

struct Enum *ep, *pp=(struct Enum*)fp;

ep = newof(0,struct Enum,1,pp->nelem*sizeof(char*));

memcpy((void*)ep,(void*)pp,sizeof(struct Enum)+pp->nelem*sizeof(char*));

return(&ep->hdr);

}

static void put_enum(Namval_t* np,const char *val,int flags,Namfun_t *fp)

{

struct Enum *ep = (struct Enum*)fp;

register const char *v;

unsigned short i=0, n;

if(!val)

{

nv_disc(np,&ep->hdr,NV_POP);

if(!ep->hdr.nofree)

free((void*)ep);

nv_putv(np, val, flags,fp);

return;

}

if(flags&NV_INTEGER)

{

nv_putv(np,val,flags,fp);

return;

}

while(v=ep->values[i])

{

if(ep->iflag)

n = strcasecmp(v,val);

else

n = strcmp(v,val);

if(n==0)

{

nv_putv(np, (char*)&i, NV_UINT16, fp);

return;

}

i++;

}

error(ERROR_exit(1), "%s: invalid value %s",nv_name(np),val);

}

static char* get_enum(register Namval_t* np, Namfun_t *fp)

{

static char buff[6];

struct Enum *ep = (struct Enum*)fp;

long n = nv_getn(np,fp);

if(n < ep->nelem)

return((char*)ep->values[n]);

sfsprintf(buff,sizeof(buff),"%u%c",n,0);

return(buff);

}

static Sfdouble_t get_nenum(register Namval_t* np, Namfun_t *fp)

{

return(nv_getn(np,fp));

}

const Namdisc_t ENUM_disc = { 0, put_enum, get_enum, get_nenum, 0,0,clone_enum };

#ifdef STANDALONE

static int enum_create(int argc, char** argv, void* context)

#else

int b_enum(int argc, char** argv, void* context)

#endif

{

int sz,i,n,iflag = 0;

Namval_t *np, *tp;

Namarr_t *ap;

char *cp,*sp;

struct Enum *ep;

Shell_t *shp = ((Shbltin_t*)context)->shp;

struct {

Optdisc_t opt;

Namval_t *np;

} optdisc;

cmdinit(argc, argv, context, ERROR_CATALOG, ERROR_NOTIFY);

for (;;)

{

switch (optget(argv, enum_usage))

{

case 'i':

iflag = 'i';

continue;

case '?':

error(ERROR_USAGE|4, "%s", opt_info.arg);

break;

case ':':

error(2, "%s", opt_info.arg);

break;

}

break;

}

argv += opt_info.index;

if (error_info.errors || !*argv || *(argv + 1))

{

error(ERROR_USAGE|2, "%s", optusage(NiL));

return 1;

}

while(cp = *argv++)

{

if(!(np = nv_open(cp, (void*)0, NV_VARNAME|NV_NOADD)) || !(ap=nv_arrayptr(np)) || ap->fun || (sz=ap->nelem&(((1L<<ARRAY_BITS)-1))) < 2)

error(ERROR_exit(1), "%s must name an array containing at least two elements",cp);

n = staktell();

sfprintf(stkstd,"%s.%s%c",NV_CLASS,np->nvname,0);

tp = nv_open(stakptr(n), shp->var_tree, NV_VARNAME);

stakseek(n);

n = sz;

i = 0;

nv_onattr(tp, NV_UINT16);

nv_putval(tp, (char*)&i, NV_INTEGER);

nv_putsub(np, (char*)0, ARRAY_SCAN);

do

{

sz += strlen(nv_getval(np));

}

while(nv_nextsub(np));

sz += n*sizeof(char*);

if(!(ep = newof(0,struct Enum,1,sz)))

error(ERROR_system(1), "out of space");

ep->iflag = iflag;

ep->nelem = n;

cp = (char*)&ep->values[n+1];

nv_putsub(np, (char*)0, ARRAY_SCAN);

ep->values[n] = 0;

i = 0;

do

{

ep->values[i++] = cp;

sp = nv_getval(np);

n = strlen(sp);

memcpy(cp,sp,n+1);

cp += n+1;

}

while(nv_nextsub(np));

ep->hdr.dsize = sizeof(struct Enum)+sz;

ep->hdr.disc = &ENUM_disc;

ep->hdr.type = tp;

nv_onattr(tp, NV_RDONLY);

nv_disc(tp, &ep->hdr,NV_FIRST);

memset(&optdisc,0,sizeof(optdisc));

optdisc.opt.infof = enuminfo;

optdisc.np = tp;

nv_addtype(tp, enum_type, &optdisc.opt, sizeof(optdisc));

}

return error_info.errors != 0;

}

#ifdef STANDALONE

void lib_init(int flag, void* context)

{

Shell_t *shp = ((Shbltin_t*)context)->shp;

Namval_t *mp,*bp;

if(flag)

return;

bp = sh_addbuiltin("Enum", enum_create, (void*)0);

mp = nv_search("typeset",shp->bltin_tree,0);

nv_onattr(bp,nv_isattr(mp,NV_PUBLIC));

}

#endif