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

/*	$NetBSD: ci.c,v 1.3 1997/10/18 07:15:16 lukem Exp $	*/
/*
 * 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.
 *
 */


#include <string.h>
#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:;
  }
}