NetBSD/usr.sbin/sup/source/ci.c

849 lines
25 KiB
C
Raw Normal View History

1997-10-18 11:05:31 +04:00
/* $NetBSD: ci.c,v 1.3 1997/10/18 07:15:16 lukem Exp $ */
1993-05-21 18:52:16 +04:00
/*
* Copyright (c) 1991 Carnegie Mellon University
* All Rights Reserved.
*
* Permission to use, copy, modify and distribute this software and its
* documentation is hereby granted, provided that both the copyright
* notice and this permission notice appear in all copies of the
* software, derivative works or modified versions, and any portions
* thereof, and that both notices appear in supporting documentation.
*
* CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
* CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
* ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
*
* Carnegie Mellon requests users of this software to return to
*
* Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
* School of Computer Science
* Carnegie Mellon University
* Pittsburgh PA 15213-3890
*
* any improvements or extensions that they make and grant Carnegie the rights
* to redistribute these changes.
*/
/* ci -- command interpreter
*
* Usage (etc.)
*
* HISTORY
* 22-Nov-85 Glenn Marcy (gm0w) at Carnegie-Mellon University
* Removed checks for VIRTUE window manager. If they don't like
* it then they can fix the more program.
*
* 08-May-85 Steven Shafer (sas) at Carnegie-Mellon University
* Increased MAXENTRIES and MAXHELPS from 200 to 400.
*
* 30-Apr-85 Steven Shafer (sas) at Carnegie-Mellon University
* Adapted for 4.2 UNIX. Added calls to check for
* using window manager of VIRTUE.
*
* 29-Apr-85 Steven Shafer (sas) at Carnegie-Mellon University
* Added two small bug fixes (courtesy of Richard Cohn).
*
* 14-Aug-84 Steven Shafer (sas) at Carnegie-Mellon University
* Added fflush(stdout) after printing prompt, before asking for input line.
*
* 01-Jul-83 Steven Shafer (sas) at Carnegie-Mellon University
* Bug fix: whitespace now required before ">filename" and not permitted
* within or after filename.
*
* 06-Jun-83 Steven Shafer (sas) at Carnegie-Mellon University
* Bug fix: added line to initialize "redirected" to 0.
*
* 20-May-83 Steven Shafer (sas) at Carnegie-Mellon University
* Added quiet bits CINOSEM, CINOFILE, CIFIRSTEQUAL to allow user to
* have special characters ; > = treated as normal data (except =
* after first argument, which still means "variable assignment").
* Also added output redirection via >filename on input line.
*
* 07-Mar-83 Dave McKeown (dmm) at Carnegie-Mellon University
* (Slight alterations by Steve Shafer.)
* Made cidepth a global, used for recursive and nested calls to
* ci(), and accessable to the user. Added '@x' command, similar
* to '^x' except that the previous command interpreter name is
* remembered and after 'x' is executed, the previous command
* interpreter is reinvoked. Users who plan to use this feature
* must save the name of the previous ci in global variable
* 'ciprev' after exit from the ci(). ie.
* ci(.........);
* strcpy(ciprev,"ci-name");
* Added ci state CICMDNOINDENT to allow for no indentation of the
* command line prompt based on cidepth.
* Reduced amount of indentation on source code.
* Bug: the "depth" argument is now a no-op, retained for backward
* compatibility. Cidepth is initialized to zero, and incremented
* upon invocation of a ci(). If cidepth is <1 then you are not
* in a ci() instantiation.
*
* 21-Feb-83 Steven Shafer (sas) at Carnegie-Mellon University
* Added up-arrow (^) command (and variable cinext). ^x is used when
* you have a ci program in which one command invokes ci with a
* new set of commands (i.e. a subsystem of the program). Inside the
* subsystem, ^x will exit the subsystem, and cause the main level
* to execute the command line "x" before reading more input lines.
* The cinext variable is used to implement this. Cinext can also be
* used by any user code which desires to force ci to execute a
* specific command before reading more input from the current file.
*
* 16-Jul-82 Steven Shafer (sas) at Carnegie-Mellon University
* Added extra code in _ci_help to eliminate duplicate help file
* names. This way, if several directories are specified and there
* is are files with the same name in more than one directory, only
* the first of each file will be included in the help list.
*
* It would have been nice to do this after the qsort instead of
* before (in ci_help). However, qsort does not ensure that
* "equivalent" entries are kept in the same relative
* order; thus there would be no way to ensure that the
* file being used was the first such file found.
*
* 07-Jul-82 William Chiles (wpc) at Carnegie-Mellon University
* Modified so that "!" invokes shell commands from the type of
* shell specified by the environment variable SHELL. If SHELL
* is not defined the standard shell is used.
*
* 21-Sep-81 Steven Shafer (sas) at Carnegie-Mellon University
* Increased LINELENGTH (input buffer length) to 1100 to satisfy
* voracious requirements of a certain user whose name I won't mention
* but whose initials are "faa".
*
* 08-Oct-80 Steven Shafer (sas) at Carnegie-Mellon University
* Added class variables: ci_tclass cases in ci_show and ci_set.
* Also added CICMDFPEEK in addition to existing CISETPEEK.
*
* 22-May-80 Steven Shafer (sas) at Carnegie-Mellon University
* Ci now sorts help topics into alphabetical order. Some interrupt
* handling has been added, but there are bugs, for example, when
* you interrupt "*" (the listing of command names). The right thing
* happens, but bogus messages are printed.
*
* 16-Apr-80 Steven Shafer (sas) at Carnegie-Mellon University
* Ci now prints lists of names with prstab(). This uses multiple
* columns when appropriate.
*
* 12-Mar-80 Steven Shafer (sas) at Carnegie-Mellon University
* Added code to skip over leading blanks and tabs in the argument list
* when executing commands, and setting and displaying variables.
* Also fixed meta-help, which mysteriously disappeared.
*
* 19-Feb-80 Steven Shafer (sas) at Carnegie-Mellon University
* Added "if (0) del();" to force del() routine to be loaded. This is
* the safest way I know of to define the external int "_del_". If you
* don't believe it, think again about separately compiled files.
*
* 28-Jan-80 Steven Shafer (sas) at Carnegie-Mellon University
* Created. Patterned (somewhat) after ci() on PDP-11.
*
*/
1997-10-18 11:05:31 +04:00
#include <string.h>
1993-05-21 18:52:16 +04:00
#include <libc.h>
#include <ci.h>
#include <del.h>
char *index(),*getenv(),*rindex();
extern char _argbreak;
long atol();
double atof();
static int ci_help(), ci_show();
static int _ci_sho(), _ci_set(), ci_set();
/*************************
*** M A C R O S ***
*************************/
#define LINELENGTH 1100 /* max length of input line */
#define MAXENTRIES 400 /* max entries in entry list */
#define MAXHELPS 400 /* max help files available */
#define METAHELP "/usr/lib/ci.help" /* standard help file */
/*********************************************
*** G L O B A L V A R I A B L E S ***
*********************************************/
int ciquiet = 0; /* init globals */
int ciexit = 0;
int cidepth = 0;
int ciback = 0; /* for use in '@' command */
FILE *ciinput;
char cinext[LINELENGTH] = "";
char ciprev[LINELENGTH] = "";
static char *delchoice[] = { /* breakpoint choices */
"abort abort command file",
"breakpoint break to tty, then resume command file",
0};
/*************************************
*** M A I N R O U T I N E ***
*************************************/
ci (prompt,fil,depth,list,helppath,cmdfpath)
char *prompt; /* prompt message */
FILE *fil; /* input file */
int depth; /* recursion depth */
CIENTRY *list; /* entry list */
char *helppath; /* search list for help files */
char *cmdfpath; /* search list for command files */
{
FILE *savfile; /* input file for calling instance of ci */
int savquiet, savexit; /* globals for calling instance of ci */
char *p,*q,*cmd,*arg; /* temps for parsing input */
int i; /* temp */
char line[LINELENGTH]; /* input line buffer */
int firststmt; /* temp */
char *equals,*star; /* index of = and * in input line */
char cfnam[200]; /* name of command file */
char *name[MAXENTRIES]; /* name list for entries */
char *vname[MAXENTRIES]; /* name list for just variables */
int vnum[MAXENTRIES]; /* correspondence list for variables */
int nv; /* number of variables */
int helpcmd; /* "help" command index */
FILE *newfile; /* command file just opened */
char bprompt[100]; /* breakpoint prompt */
char *tname[MAXENTRIES]; /* temp name list */
int tnum; /* # entries in tname */
char *Shell; /* holds SHELL value from .login */
int redirected; /* 1 iff currently redirected output */
FILE savestdout; /* place to save normal std. output */
FILE *outfile; /* current output file */
char *outname; /* output file name */
/* force del() routine to be declared */
if (0) del();
/* save globals on stack */
cidepth++; /* bump the global depth, first CI() is 1 */
savquiet = ciquiet;
savexit = ciexit;
savfile = ciinput;
ciexit = 0; /* don't exit until this is set */
ciinput = (fil ? fil : stdin); /* new input file */
/* construct name lists for stablk */
nv = 0;
for (i=0; list[i].ci_etyp != ci_tend; i++) {
name[i] = list[i].ci_enam;
if (list[i].ci_etyp != ci_tcmd) { /* is variable */
vname[nv] = name[i];
vnum[nv] = i;
nv++;
}
}
helpcmd = i++; /* force-feed "help" onto list */
name[helpcmd] = "help";
name[i] = 0;
vname[nv] = 0;
/* loop for input lines */
redirected = 0;
while (!ciexit) {
if (*cinext) { /* get line from ^ command */
if (ciback) {
sprintf(line,"%s;%s",cinext,ciprev);
ciback = 0;
}
else {
strcpy (line,cinext);
}
strcpy (cinext,"");
p = line;
}
else { /* else read file */
if ((ciinput == stderr) || (ciinput == stdin) || (!(ciquiet&CICMDFPROMPT))) {
if (!(ciquiet &CICMDNOINDENT)) {
for (i=1; i<cidepth; i++) {
printf (" ");
}
}
printf ("%s ",prompt);
if ((ciinput == stderr) || (ciinput == stdin)) fflush (stdout);
}
p = fgets (line,LINELENGTH,ciinput); /* read input line */
if (p == 0) { /* EOF */
if (_del_) {
DELCLEAR;
strcpy (line,"");
p = line;
}
else {
ciexit = 1;
if ((ciinput==stdin) || (ciinput==stderr) ||
(!(ciquiet&CICMDFECHO))) printf ("\n");
}
}
else {
if ((ciinput != stderr) && (ciinput != stdin) &&
(!(ciquiet&CICMDFECHO))) printf ("%s",line);
for (p=line; (*p) && (*p != '\n'); p++) ;
*p = 0; /* kill trailing newline */
p = line; /* points to start of line */
}
}
/* check for redirection of output */
if (!ciexit) {
outname = rindex (p,'>');
if (outname) {
if (outname == p || *(outname+1) == 0
|| ((*(outname-1) != ' ') && (*(outname-1) != '\t'))) {
outname = 0;
}
else {
for (q=outname+1; *q && (*q != ' ') && (*q != '\t'); q++) ;
if (*q) outname = 0;
}
}
if (outname && !(ciquiet&CINOFILE)) {
*outname++ = 0;
outfile = fopen (outname,"w");
if (outfile == 0) {
printf ("ci: Can't create output file %s\n",outname);
p = "";
}
else {
fflush (stdout);
savestdout = *stdout;
*stdout = *outfile;
redirected = 1;
}
}
}
/* loop for each command */
firststmt = 1; /* first time through loop */
while ((!ciexit) && (((ciquiet&CINOSEM) && firststmt) || *(cmd=nxtarg(&p,";")) || _argbreak)) {
if (ciquiet & CINOSEM) {
cmd = p;
firststmt = 0;
}
switch (*cmd) { /* what kind of line? */
case ':': /* : comment */
case 0: /* null line */
break;
case '!': /* ! shell command */
cmd = skipover (cmd+1," ");
if ((Shell = getenv("SHELL")) == 0) Shell = "sh";
if (*cmd) runp (Shell, Shell, "-c", cmd, 0);
else runp (Shell, Shell, 0);
if (!(ciquiet&CISHEXIT)) printf ("Back to %s\n",prompt);
break;
case '?': /* ? help */
cmd = skipover (cmd+1," ");
ci_help (cmd,helppath);
break;
case '<': /* < command file */
arg = cmd + 1;
cmd = nxtarg (&arg,0); /* parse name */
if (*cmd == 0) printf ("ci: missing filename\n");
else {
if (cmdfpath) newfile = fopenp (cmdfpath,cmd,cfnam,"r");
else newfile = fopen (cmd,"r");
if (newfile == 0)
printf ("ci: can't open command file %s\n",cmd);
else {
if (!(ciquiet&CICMDFECHO)) printf ("\n");
ci (prompt,newfile,cidepth,list,helppath,cmdfpath);
fclose (newfile);
if (!(ciquiet&CICMDFEXIT)) printf ("End of file\n\n");
}
}
break;
case '^': /* exit and do command */
case '@':
if (cidepth > 1) {
if (*cmd == '@') ciback = 1;
if (_argbreak == ';') *(cmd+strlen(cmd)) = ';';
ciexit = 1;
cmd = skipover(cmd+1," ");
strcpy (cinext,cmd);
}
else printf ("ci: ^ not allowed at top level of ci\n");
break;
default: /* list cmds, etc. */
equals = index (cmd,'=');
if (equals == cmd) cmd++;
if (equals) {
if (*(equals+1) == 0) *equals = 0;
else *equals = ' ';
}
arg = cmd; /* parse first word */
cmd = nxtarg (&arg,0);
if ((ciquiet&CIFIRSTEQUAL) && equals && equals>arg) {
*equals = '='; /* if user doesn't want extra =, kill */
equals = 0;
}
star = index (cmd,'*');
if (star) *star = 0;
if (star && equals) { /* list vars */
printf ("\n");
for (i=0; vname[i]; i++) {
if (stlmatch (vname[i],cmd)) {
ci_show (list[vnum[i]],arg,CIPEEK);
}
DELBREAK;
}
printf ("\n");
}
else if (star) { /* list cmds */
printf ("\n");
tnum = 0;
for (i=0;name[i]; i++) {
if ((i==helpcmd || list[i].ci_etyp == ci_tcmd) &&
stlmatch (name[i],cmd)) {
tname[tnum++] = name[i];
}
}
tname[tnum] = 0;
prstab (tname);
if (_del_) {_DELNOTE_}
printf ("\n");
}
else if (equals) { /* set var */
i = stablk (cmd,vname,0);
if (i >= 0) ci_set (list[vnum[i]],skipover(arg," \t"));
}
else {
i = stablk (cmd,name,0);
if (i == helpcmd) ci_help (arg,helppath);
else if (i >= 0) {
if (list[i].ci_etyp == ci_tcmd) {
(* (int(*)()) (list[i].ci_eptr)) (skipover(arg," \t"));
}
else ci_show (list[i],skipover(arg," \t"),CISHOW);
}
}
}
/* end of command */
/* DEL trapping */
if (_del_) {
if (ciinput == stdin) {
DELCLEAR; /* already at tty level */
}
else {
_del_ = 0;
i = getstab ("INTERRUPT: abort or breakpoint?",delchoice,"abort");
if (i == 0) ciexit = 1; /* abort */
else { /* breakpoint */
sprintf (bprompt,"Breakpoint for %s",prompt);
ci (bprompt,0,cidepth,list,helppath,cmdfpath);
}
}
}
/* end of loop for commands */
}
/* end of loop for lines of input file */
if (redirected) {
fflush (stdout);
fclose (stdout);
*stdout = savestdout;
redirected = 0;
}
}
/* restore globals */
cidepth --; /* update current depth */
ciinput = savfile;
ciquiet = savquiet;
ciexit = savexit;
}
/********************************************
*** P R I N T H E L P F I L E ***
********************************************/
static int _h_found; /* how many matching names? */
static char **_h_list; /* list of matching names */
static char (*_h_nlist)[20]; /* list of filename part of names */
static int _ci_help (filspec)
/* called by searchp to expand filspec, adding names to _h_list */
char *filspec;
{
register int i,j,result;
char dir[200];
result = expand (filspec, _h_list + _h_found, MAXHELPS - _h_found);
if (result > 0) {
for (i=0; i<result; ) { /* elim duplicates */
path (_h_list[i+_h_found],dir,_h_nlist[i+_h_found]);
for (j=0;
j<_h_found && strcmp(_h_nlist[j],_h_nlist[i+_h_found]) != 0;
j++) ;
if (j < _h_found) { /* is duplicate */
--result;
strcpy (_h_list[i+_h_found],_h_list[result+_h_found]);
}
else i++; /* isn't duplicate */
}
_h_found += result;
}
return (1); /* keep searching */
}
/* for use in sorting help file names */
static ci_hcomp (p,q)
char **p,**q;
{
char dir[200],file1[20],file2[20];
path ((*p),dir,file1);
path ((*q),dir,file2);
return (strcmp(file1,file2));
}
static ci_help (topic,helppath)
char *topic,*helppath;
{
char *fnames[MAXHELPS]; /* names of matching files */
char names[MAXHELPS][20]; /* stripped filenames */
char *nptr[MAXHELPS+1]; /* list of ptrs for stablk */
char dir[200]; /* temp */
char shstr[300]; /* shell string for system */
int i;
char *star;
FILE *f;
if (*topic == 0) { /* wants meta-help */
f = fopen (METAHELP,"r");
if (f == 0) {
printf ("Yikes!! Can't open standard help file!\n");
}
else {
printf ("\n");
runp("more","more",METAHELP,0);
if (_del_) {_DELNOTE_}
printf ("\n");
fclose (f);
}
if (helppath && (*helppath) && (!getbool("Do you want a list of help topics?",1))) {
return;
}
}
else { /* chop at * */
star = index (topic,'*');
if (star) *star = 0;
}
if (helppath == 0) { /* no help at all */
printf ("Sorry, no specific help is available for this program.\n");
}
else {
_h_found = 0;
_h_list = fnames;
_h_nlist = names;
searchp (helppath,"*",dir,_ci_help); /* find file names */
qsort (fnames,_h_found,sizeof(char *),ci_hcomp);
for (i=0; i<_h_found; i++) { /* strip pathnames */
path (fnames[i],dir,names[i]);
nptr[i] = names[i];
}
nptr[i] = 0;
if (*topic) { /* request some topic */
if (_h_found == 0) {
printf ("No help for %s. Type '?*' for list of help messages.\n",topic);
}
else {
i = stablk (topic,nptr,1);
if (i < 0) i = stabsearch (topic,nptr,0);
if (i >= 0) {
f = fopen (fnames[i],"r");
if (f == 0)
printf ("Yikes! Can't open help file %s\n",fnames[i]);
else {
printf ("\n");
runp("more","more",fnames[i],0);
if (_del_) {_DELNOTE_}
printf ("\n");
fclose (f);
}
}
}
}
else { /* request topic list */
printf ("\nHelp is available for these topics:\n");
prstab (nptr);
if (_del_) {_DELNOTE_}
printf ("\n");
}
for (i=0; i<_h_found; i++) free (fnames[i]);
}
}
/*********************************************************
*** S H O W V A L U E O F V A R I A B L E ***
*********************************************************/
static ci_show (entry,arg,mode)
CIENTRY entry; /* entry to display */
char *arg; /* arg for variable procedures */
CIMODE mode; /* mode (CIPEEK or CISHOW) */
{
if (entry.ci_etyp == ci_tproc) { /* procedure */
(* (int(*)()) (entry.ci_eptr)) (mode,arg);
}
else if (entry.ci_etyp == ci_tclass) { /* class variable */
(* (int(*)()) (entry.ci_eptr)) (mode,arg,entry.ci_evar,entry.ci_enam);
}
else {
printf ("%-14s \t",entry.ci_enam);
_ci_sho (entry.ci_etyp, entry.ci_eptr);
printf ("\n");
}
}
static _ci_sho (etype,eptr)
ci_type etype;
ci_union *eptr;
{
int i;
unsigned int u;
switch (etype) {
case ci_tint:
printf ("%d",eptr->ci_uint);
break;
case ci_tshort:
printf ("%d",eptr->ci_ushort);
break;
case ci_tlong:
printf ("%D",eptr->ci_ulong);
break;
case ci_toct:
if (eptr->ci_uoct) printf ("0");
printf ("%o",eptr->ci_uoct);
break;
case ci_thex:
if (eptr->ci_uhex) printf ("0x");
printf ("%x",eptr->ci_uhex);
break;
case ci_tdouble:
printf ("%g",eptr->ci_udouble);
break;
case ci_tfloat:
printf ("%g",eptr->ci_ufloat);
break;
case ci_tbool:
if (eptr->ci_ubool) printf ("yes");
else printf ("no");
break;
case ci_tstring:
printf ("%s",(char *)eptr);
break;
case ci_tcint:
printf ("%d",*(eptr->ci_ucint.ci_ival));
break;
case ci_tcshort:
printf ("%d",*(eptr->ci_ucshort.ci_sval));
break;
case ci_tclong:
printf ("%D",*(eptr->ci_uclong.ci_lval));
break;
case ci_tcoct:
u = *(eptr->ci_ucoct.ci_uval);
if (u) printf ("0");
printf ("%o",u);
break;
case ci_tchex:
u = *(eptr->ci_uchex.ci_uval);
if (u) printf ("0x");
printf ("%x",u);
break;
case ci_tcdouble:
printf ("%g",*(eptr->ci_ucdouble.ci_dval));
break;
case ci_tcfloat:
printf ("%g",*(eptr->ci_ucfloat.ci_fval));
break;
case ci_tcbool:
i = *(eptr->ci_ucbool.ci_bval);
if (i) printf ("yes");
else printf ("no");
break;
case ci_tcchr:
i = *(eptr->ci_ucchr.ci_cval);
printf ("%c",eptr->ci_ucchr.ci_cleg[i]);
break;
case ci_tcstring:
printf ("%s",eptr->ci_ucstring.ci_pval);
break;
case ci_tctab:
i = *(eptr->ci_ucstab.ci_tval);
printf ("%s",eptr->ci_ucstab.ci_ttab[i]);
break;
case ci_tcsearch:
i = *(eptr->ci_ucsearch.ci_tval);
printf ("%s",eptr->ci_ucsearch.ci_ttab[i]);
break;
default:
printf ("Yeek! Illegal cientry type %d!\n",(int) etype);
}
}
/*************************************************************
*** A S S I G N V A L U E T O V A R I A B L E ***
*************************************************************/
static ci_set (entry,arg)
CIENTRY entry;
char *arg;
{
if (entry.ci_etyp == ci_tproc) { /* variable procedure */
(* (int(*)()) (entry.ci_eptr)) (CISET,arg);
}
else if (entry.ci_etyp == ci_tclass) { /* class variable */
(* (int(*)()) (entry.ci_eptr)) (CISET,arg,entry.ci_evar,entry.ci_enam);
}
else {
_ci_set (entry.ci_etyp, entry.ci_eptr, arg);
if (!(ciquiet & (((ciinput==stdin)||(ciinput==stderr)) ? CISETPEEK : CICMDFPEEK)))
ci_show (entry,arg,CIPEEK);
}
}
static _ci_set (etype,eptr,arg)
ci_type etype;
ci_union *eptr;
char *arg;
{
int i;
unsigned int u;
char *p;
if (etype == ci_tstring) {
strcpy ((char *)eptr,arg);
return;
}
if (etype == ci_tcstring) {
strarg (&arg, ";", eptr->ci_ucstring.ci_pmsg,
eptr->ci_ucstring.ci_pval,eptr->ci_ucstring.ci_pval);
return;
}
p = arg; /* parse first word */
arg = nxtarg (&p,0);
switch (etype) {
case ci_tint:
eptr->ci_uint = atoi (arg);
break;
case ci_tshort:
eptr->ci_ushort = atoi (arg);
break;
case ci_tlong:
eptr->ci_ulong = atol (arg);
break;
case ci_toct:
eptr->ci_uoct = atoo (arg);
break;
case ci_thex:
if (stlmatch(arg,"0x") || stlmatch(arg,"0X")) arg += 2;
eptr->ci_uhex = atoh (arg);
break;
case ci_tdouble:
eptr->ci_udouble = atof (arg);
break;
case ci_tfloat:
eptr->ci_ufloat = atof (arg);
break;
case ci_tbool:
eptr->ci_ubool = (index("yYtT",*arg) != 0);
break;
case ci_tcint:
*(eptr->ci_ucint.ci_ival) =
intarg (&arg,0,eptr->ci_ucint.ci_imsg,eptr->ci_ucint.ci_imin,
eptr->ci_ucint.ci_imax,*(eptr->ci_ucint.ci_ival));
break;
case ci_tcshort:
*(eptr->ci_ucshort.ci_sval) =
shortarg (&arg,0,eptr->ci_ucshort.ci_smsg,eptr->ci_ucshort.ci_smin,
eptr->ci_ucshort.ci_smax,*(eptr->ci_ucshort.ci_sval));
break;
case ci_tclong:
*(eptr->ci_uclong.ci_lval) =
longarg (&arg,0,eptr->ci_uclong.ci_lmsg,eptr->ci_uclong.ci_lmin,
eptr->ci_uclong.ci_lmax,*(eptr->ci_uclong.ci_lval));
break;
case ci_tcoct:
*(eptr->ci_ucoct.ci_uval) =
octarg (&arg,0,eptr->ci_ucoct.ci_umsg,eptr->ci_ucoct.ci_umin,
eptr->ci_ucoct.ci_umax,*(eptr->ci_ucoct.ci_uval));
break;
case ci_tchex:
*(eptr->ci_uchex.ci_uval) =
hexarg (&arg,0,eptr->ci_uchex.ci_umsg,eptr->ci_uchex.ci_umin,
eptr->ci_uchex.ci_umax,*(eptr->ci_uchex.ci_uval));
break;
case ci_tcdouble:
*(eptr->ci_ucdouble.ci_dval) =
doublearg (&arg,0,eptr->ci_ucdouble.ci_dmsg,eptr->ci_ucdouble.ci_dmin,
eptr->ci_ucdouble.ci_dmax,*(eptr->ci_ucdouble.ci_dval));
break;
case ci_tcfloat:
*(eptr->ci_ucfloat.ci_fval) =
floatarg (&arg,0,eptr->ci_ucfloat.ci_fmsg,eptr->ci_ucfloat.ci_fmin,
eptr->ci_ucfloat.ci_fmax,*(eptr->ci_ucfloat.ci_fval));
break;
case ci_tcbool:
*(eptr->ci_ucbool.ci_bval) =
boolarg (&arg,0,eptr->ci_ucbool.ci_bmsg,*(eptr->ci_ucbool.ci_bval));
break;
case ci_tcchr:
*(eptr->ci_ucchr.ci_cval) =
chrarg (&arg,0,eptr->ci_ucchr.ci_cmsg,eptr->ci_ucchr.ci_cleg,
eptr->ci_ucchr.ci_cleg[*(eptr->ci_ucchr.ci_cval)]);
break;
case ci_tctab:
*(eptr->ci_ucstab.ci_tval) =
stabarg (&arg,0,eptr->ci_ucstab.ci_tmsg,eptr->ci_ucstab.ci_ttab,
eptr->ci_ucstab.ci_ttab[*(eptr->ci_ucstab.ci_tval)]);
break;
case ci_tcsearch:
*(eptr->ci_ucsearch.ci_tval) =
searcharg (&arg,0,eptr->ci_ucsearch.ci_tmsg,
eptr->ci_ucsearch.ci_ttab,
eptr->ci_ucsearch.ci_ttab[*(eptr->ci_ucsearch.ci_tval)]);
break;
default:;
}
}