//+++2004-09-11
//    Copyright (C) 2004  Mike Rieker, Beverly, MA USA
//
//    This program is free software; you can redistribute it and/or modify
//    it under the terms of the GNU General Public License as published by
//    the Free Software Foundation; version 2 of the License.
//
//    This program is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//    GNU General Public License for more details.
//
//    You should have received a copy of the GNU General Public License
//    along with this program; if not, write to the Free Software
//    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//---2004-09-11

/************************************************************************/
/*									*/
/*  Command-line interpreter						*/
/*									*/
/************************************************************************/

#include "ozone.h"

#include "oz_crtl_malloc.h"
#include "oz_io_console.h"
#include "oz_io_fs.h"
#include "oz_io_mutex.h"
#include "oz_io_pipe.h"
#include "oz_io_timer.h"
#include "oz_knl_ast.h"
#include "oz_knl_devio.h"
#include "oz_knl_hw.h"
#include "oz_knl_lock.h"
#include "oz_knl_logname.h"
#include "oz_knl_sdata.h"
#include "oz_knl_status.h"
#include "oz_knl_thread.h"
#include "oz_knl_userjob.h"
#include "oz_sys_callknl.h"
#include "oz_sys_dateconv.h"
#include "oz_sys_event.h"
#include "oz_sys_exhand.h"
#include "oz_sys_handle.h"
#include "oz_sys_io.h"
#include "oz_sys_io_fs.h"
#include "oz_sys_io_fs_printf.h"
#include "oz_sys_logname.h"
#include "oz_sys_password.h"
#include "oz_sys_process.h"
#include "oz_sys_spawn.h"
#include "oz_sys_thread.h"
#include "oz_sys_tzconv.h"
#include "oz_sys_userjob.h"
#include "oz_sys_xprintf.h"
#include "oz_util_start.h"

#include <string.h>

#define CMDSIZ 4096
#define MAXLBLNAM 64
#define MAXSYMNAM 64
#define CMDLNMTBL "OZ_CLI_TABLES"
#define LASTPROCLNM "OZ_LAST_PROCESS"
#define LASTHREADLNM "OZ_LAST_THREAD"
#define SECATTRSIZE 4096

#define SYMBOLSTARTCHAR(c) ((c == '_') || ((c >= 'a') && (c <= 'z')) || ((c >= 'A') && (c <= 'Z')))
#define SYMBOLCHAR(c) (SYMBOLSTARTCHAR(c) || ((c >= '0') && (c <= '9')))

#define SHOWOPT_PROC_THREADS 0x1
#define SHOWOPT_JOB_PROCS 0x2
#define SHOWOPT_JOB_THREADS (SHOWOPT_PROC_THREADS | SHOWOPT_JOB_PROCS)
#define SHOWOPT_USER_JOBS 0x4
#define SHOWOPT_USER_PROCS (SHOWOPT_JOB_PROCS | SHOWOPT_USER_JOBS)
#define SHOWOPT_USER_THREADS (SHOWOPT_PROC_THREADS | SHOWOPT_USER_PROCS)
#define SHOWOPT_DEVICE_IOCHANS 0x8
#define SHOWOPT_SYSTEM_USERS 0x10
#define SHOWOPT_SYSTEM_JOBS (SHOWOPT_USER_JOBS | SHOWOPT_SYSTEM_USERS)
#define SHOWOPT_SYSTEM_PROCS (SHOWOPT_JOB_PROCS | SHOWOPT_SYSTEM_JOBS)
#define SHOWOPT_SYSTEM_THREADS (SHOWOPT_PROC_THREADS | SHOWOPT_SYSTEM_PROCS)
#define SHOWOPT_SYSTEM_DEVICES 0x20
#define SHOWOPT_SYSTEM_IOCHANS (SHOWOPT_DEVICE_IOCHANS | SHOWOPT_SYSTEM_DEVICES)

#define SHOWOPT_SECURITY 0x00010000
#define SHOWOPT_OBJADDR  0x00020000

#define SHOWNHDR_THREAD 0x80000000
#define SHOWNHDR_PROCESS 0x40000000
#define SHOWNHDR_JOB 0x20000000
#define SHOWNHDR_USER 0x10000000
#define SHOWNHDR_IOCHAN 0x8000000
#define SHOWNHDR_DEVICE 0x4000000
#define SHOWNHDR_SYSTEM 0x2000000

#define SHOLNMFLG_SECURITY 0x00000001

typedef struct Attachedthread Attachedthread;
typedef struct Command Command;
typedef struct Label Label;
typedef struct Pipebuf Pipebuf;
typedef struct Runopts Runopts;
typedef struct Script Script;
typedef struct Symbol Symbol;

typedef uLong (*Entry) (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *param, int argc, const char *argv[]);

struct Attachedthread { Attachedthread *next;
                        OZ_Threadid thread_id;
                        OZ_Handle h_thread;
                        OZ_Handle h_waitevent;
                        OZ_Handle h_haltevent;
                        OZ_Procmode procmode;
                        OZ_Sigargs const *volatile sigargs_p;
                        OZ_Mchargs *volatile mchargs_p;
                        OZ_Mchargx *volatile mchargx_p;
                        OZ_Processid volatile processid;
                      };

struct Command { int async;	/* 0: cannot run as a thread; 1: ok to run as a thread */
				/* - Basically anything that accesses cli internal static data (like symbol tables and script stacks) cannot be run as a thread. */
				/*   Also, things like 'abort/wait/suspend/resume thread' and 'run' do their own ctrl-Y processing so do not need to be async.   */
                 char *name;	/* command name string; multiple words separated by a single space */
                 Entry entry;	/* entrypoint to the routine */
                 void *param;	/* param to pass to the routine */
                 char *help;	/* corresponding help string */
               };

struct Label { Label *next;
               char name[MAXLBLNAM];
               OZ_Dbn blkoffs;
               uLong bytoffs;
             };

typedef enum { SYMTYPE_STRING, 
               SYMTYPE_INTEGER
             } Symtype;

struct Symbol { Symbol *next;
                char name[MAXSYMNAM];
                Symtype symtype;
                uLong (*func) (Symbol *symbol, char *strp, char **rtnp, void *valuep);
                uLong ivalue;
                char svalue[1];
              };

struct Script { Script *next;		/* next outermost script */
                OZ_Handle h_input;	/* input of next outermost script */
                OZ_Handle h_output;	/* output of next outermost script */
                OZ_Handle h_error;	/* error of next outermost script */
                Symbol *symbols;	/* symbols of next outermost script */
                Label *labels;		/* labels of next outermost script */
              };

typedef enum {
	OPTYPE_UNKNOWN, 
	OPTYPE_ADD, 
	OPTYPE_BITAND, 
	OPTYPE_BITOR, 
	OPTYPE_BITXOR, 
	OPTYPE_BOOLAND, 
	OPTYPE_BOOLOR, 
	OPTYPE_BOOLXOR, 
	OPTYPE_DIVIDE, 
	OPTYPE_EQ, 
	OPTYPE_GT, 
	OPTYPE_GE, 
	OPTYPE_LT, 
	OPTYPE_LE, 
	OPTYPE_NE, 
	OPTYPE_MODULUS, 
	OPTYPE_MULTIPLY, 
	OPTYPE_SHLEFT, 
	OPTYPE_SHRIGHT, 
	OPTYPE_SUBTRACT } Optype;

typedef struct { char *opname;
                 Optype optype;
               } Operator;

static const Operator operators[] = {
	"||", OPTYPE_BOOLOR, 
	"^^", OPTYPE_BOOLXOR, 
	">>", OPTYPE_SHRIGHT, 
	">=", OPTYPE_GE, 
	"==", OPTYPE_EQ, 
	"<>", OPTYPE_NE, 
	"<=", OPTYPE_LE, 
	"<<", OPTYPE_SHLEFT, 
	"&&", OPTYPE_BOOLAND, 
	"!=", OPTYPE_NE, 
	"|",  OPTYPE_BITOR, 
	"^",  OPTYPE_BITXOR, 
	">",  OPTYPE_GT, 
	"<",  OPTYPE_LT, 
	"/",  OPTYPE_DIVIDE, 
	"-",  OPTYPE_SUBTRACT, 
	"+",  OPTYPE_ADD, 
	"*",  OPTYPE_MULTIPLY, 
	"&",  OPTYPE_BITAND, 
	"%",  OPTYPE_MODULUS, 
	NULL, OPTYPE_UNKNOWN };

struct Pipebuf { Pipebuf *next;
                 Runopts *runopts;
                 uLong rlen;
                 char data[256];
               };

struct Runopts { const char *defdir;		/* -directory name */
                 const char *error_name;	/* -error file name */
                 const char *ersym_name;	/* -ersym symbol name */
                 const char *exit_name;		/* -exit event flag logical name */
                 const char *init_name;		/* -init event flag logical name */
                 const char *input_name;	/* -input file name */
                 const char *insym_name;	/* -insym symbol name */
                 const char *job_name;		/* -job name */
                 const char *output_name;	/* -output file name */
                 const char *outsym_name;	/* -outsym symbol name */
                 const char *process_name;	/* -process logical name */
                 const char *thread_name;	/* -thread logical name */
                 int debug;			/* -debug flag */
                 int timeit;			/* -timeit flag */
                 int wait;			/* opposite of -nowait setting */
                 int orphan;			/* -orphan flag */
                 OZ_Handle h_err;		/* -error io channel handle */
                 OZ_Handle h_exit;		/* -exit event flag handle */
                 OZ_Handle h_init;		/* -init event flag handle */
                 OZ_Handle h_in;		/* -input io channel handle */
                 OZ_Handle h_job;		/* -job handle */
                 OZ_Handle h_out;		/* -output io channel handle */
                 OZ_Handle h_process;		/* created process handle (0 for internal commands) */
                 OZ_Handle h_thread;		/* created thread handle */

                 OZ_Handle h_ersym;		/* read ersym data from this pipe handle */
                 OZ_Handle h_insym;		/* write insym data to this pipe handle */
                 OZ_Handle h_outsym;		/* read outsym data from this pipe handle */
                 OZ_Handle h_evsym;		/* this event sets when symbol stream completes */
                 Pipebuf *ersym_pipebuf_qh;	/* list of buffers for -ersym */
                 Pipebuf **ersym_pipebuf_qt;
                 char *insym_data;		/* pointer to buffer for -insym */
                 Pipebuf *outsym_pipebuf_qh;	/* list of buffers for -outsym */
                 Pipebuf **outsym_pipebuf_qt;
               };

static const struct { char *name; OZ_Lockmode valu; } lockmodes[OZ_LOCKMODE_XX] = 
                    { "NL", OZ_LOCKMODE_NL, "CR", OZ_LOCKMODE_CR, "CW", OZ_LOCKMODE_CW, "PR", OZ_LOCKMODE_PR, "PW", OZ_LOCKMODE_PW, "EX", OZ_LOCKMODE_EX };

static Attachedthread *attachedthreads;
static char *pn, skiplabel[MAXLBLNAM];
static char *defaulttables;
static int ctrly_hit, exited, verify;
static Label *labels;
static OZ_Handle h_s_console;
static OZ_Handle h_event_ctrly;
static OZ_Handle h_s_error;
static OZ_Handle h_s_input;
static OZ_Handle h_s_output;
static OZ_Handle h_timer;
static OZ_IO_fs_getinfo1 scriptinfo;
static OZ_IO_fs_readrec scriptread;
static Script *scripts;
static Symbol *symbols;

static void startendmsg (const char *name);
static void ctrly_enable (void);
static void ctrly_ast (void *dummy, uLong status, OZ_Mchargs *mchargs);
static void ctrlt_enable (void);
static void ctrlt_ast (void *dummy, uLong status, OZ_Mchargs *mchargs);
static void exit_script (void);
static char *proclabels (char *cmdbuf);
static uLong execute (char *cmdbuf);
static uLong exechopped (int argc, const char *argv[], const char *input, const char *output, int nowait);
static uLong substitute (char *inbuf, char **outbuf_r);
static uLong eval_handle (char *inbuf, char **inbuf_r, OZ_Handle *outval_r, char *objtype, char termch);
static uLong eval_integer (char *inbuf, char **inbuf_r, uLong *outval_r, char termch);
static uLong eval_string (char *inbuf, char **inbuf_r, char **outbuf_r, char termch);
static uLong evaluate (char *inbuf, char **inbuf_r, Symbol **symbol_r, char termch);
static uLong get_operand (char *inbuf, char **inbuf_r, Symbol **symbol_r);
static Optype get_operator (char *inbuf, char **inbuf_r);
static char *cvt_sym_to_str (Symbol *symbol);
static uLong func_collapse    (Symbol *symbol, char *strp, char **rtnp, void *valuep);
static uLong func_compress    (Symbol *symbol, char *strp, char **rtnp, void *valuep);
static uLong func_date_add    (Symbol *symbol, char *strp, char **rtnp, void *valuep);
static uLong func_date_dow    (Symbol *symbol, char *strp, char **rtnp, void *valuep);
static uLong func_date_now    (Symbol *symbol, char *strp, char **rtnp, void *valuep);
static uLong func_date_sub    (Symbol *symbol, char *strp, char **rtnp, void *valuep);
static uLong func_date_tzconv (Symbol *symbol, char *strp, char **rtnp, void *valuep);
static uLong func_event_inc   (Symbol *symbol, char *strp, char **rtnp, void *valuep);
static uLong func_event_set   (Symbol *symbol, char *strp, char **rtnp, void *valuep);
static uLong func_field       (Symbol *symbol, char *strp, char **rtnp, void *valuep);
static uLong func_h_info      (Symbol *symbol, char *strp, char **rtnp, void *valuep);
static uLong func_len         (Symbol *symbol, char *strp, char **rtnp, void *valuep);
static uLong func_lnm_attrs   (Symbol *symbol, char *strp, char **rtnp, void *valuep);
static uLong func_lnm_lookup  (Symbol *symbol, char *strp, char **rtnp, void *valuep);
static uLong func_lnm_nvalues (Symbol *symbol, char *strp, char **rtnp, void *valuep);
static uLong func_lnm_object  (Symbol *symbol, char *strp, char **rtnp, void *valuep);
static uLong func_lnm_string  (Symbol *symbol, char *strp, char **rtnp, void *valuep);
static uLong func_loc         (Symbol *symbol, char *strp, char **rtnp, void *valuep);
static uLong func_lowercase   (Symbol *symbol, char *strp, char **rtnp, void *valuep);
static uLong func_process     (Symbol *symbol, char *strp, char **rtnp, void *valuep);
static uLong func_sub         (Symbol *symbol, char *strp, char **rtnp, void *valuep);
static uLong func_thread      (Symbol *symbol, char *strp, char **rtnp, void *valuep);
static uLong func_trim        (Symbol *symbol, char *strp, char **rtnp, void *valuep);
static uLong func_uppercase   (Symbol *symbol, char *strp, char **rtnp, void *valuep);
static uLong func_verify      (Symbol *symbol, char *strp, char **rtnp, void *valuep);
static uLong decode_objtype_string (const char *s_objtype, OZ_Objtype *b_objtype_r);
static const char *encode_objtype_string (OZ_Objtype b_objtype);
static void def_func (char *name, uLong (*func) (Symbol *symbol, char *strp, char **rtnp, void *valuep), Symtype symtype, char *help);
static void setscriptsyms (int argc, const char *argv[]);
static void insert_symbol (Symbol *symbol, uLong (*func) (Symbol *symbol, char *strp, char **rtnp, void *valuep), uLong level);
static Symbol *lookup_symbol (const char *name, uLong level, uLong *level_r);
static Command *decode_command (int argc, const char **argv, Command *cmdtbl, int *argc_r);
static int cmpcmdname (int argc, const char **argv, char *name);
static uLong logname_getobj (const char *name, OZ_Objtype objtype, OZ_Handle *h_object_r);
static uLong logname_creobj (const char *name, OZ_Objtype objtype, OZ_Handle h_object);
static uLong delete_logical (OZ_Handle h_error, const char *default_table_name, int argc, const char *argv[]);
static uLong extcommand (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong runimage (OZ_Handle h_error, Runopts *runopts, const char *image, int argc, const char *argv[]);
static uLong decode_runopts (const char *input, const char *output, int nowait, OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, int *argc_r, const char ***argv_r, Runopts *runopts);
static uLong setup_runopts (OZ_Handle h_error, Runopts *runopts);
static uLong finish_runopts (OZ_Handle h_error, Runopts *runopts);
static uLong crepipepair (OZ_Handle *h_read_r, OZ_Handle *h_write_r);
static void cleanup_runopts (Runopts *runopts);
static void start_ersym_read (Runopts *runopts);
static void ersym_read_ast (void *pipebufv, uLong status, OZ_Mchargs *mchargs);
static void start_insym_write (Runopts *runopts);
static void insym_write_ast (void *runoptsv, uLong status, OZ_Mchargs *mchargs);
static void start_outsym_read (Runopts *runopts);
static void outsym_read_ast (void *pipebufv, uLong status, OZ_Mchargs *mchargs);
static void deferoutsym (const char *sym_name, Pipebuf *pipebuf_qh);
static uLong show_device_bylogical (OZ_Handle h_output, OZ_Handle h_error, const char *logical, uLong *showopts);
static uLong show_device_byhandle (OZ_Handle h_output, OZ_Handle h_error, OZ_Handle h_device, uLong *showopts);
static uLong show_iochan_bylogical (OZ_Handle h_output, OZ_Handle h_error, const char *logical, uLong *showopts);
static uLong show_iochan_byhandle (OZ_Handle h_output, OZ_Handle h_error, OZ_Handle h_iochan, uLong *showopts);
static uLong show_job_bylogical (OZ_Handle h_output, OZ_Handle h_error, const char *logical, uLong *showopts);
static uLong show_job_byhandle (OZ_Handle h_output, OZ_Handle h_error, OZ_Handle h_job, uLong *showopts);
static uLong show_logical_table (OZ_Handle h_output, OZ_Handle h_error, int level, uLong sholnmflg, uLong logtblatr, const char *table_name, OZ_Handle h_table);
static uLong show_logical_name (OZ_Handle h_output, OZ_Handle h_error, int level, uLong sholnmflg, int table, OZ_Handle h_logname);
static uLong show_process_bylogical (OZ_Handle h_output, OZ_Handle h_error, const char *logical, uLong *showopts);
static uLong show_process_byhandle (OZ_Handle h_output, OZ_Handle h_error, OZ_Handle h_process, uLong *showopts);
static void show_symbol (OZ_Handle h_output, OZ_Handle h_error, Symbol *symbol);
static uLong show_system (OZ_Handle h_output, OZ_Handle h_error, uLong *showopts);
static uLong show_thread_bylogical (OZ_Handle h_output, OZ_Handle h_error, const char *logical, uLong *showopts);
static uLong show_thread_byhandle (OZ_Handle h_output, OZ_Handle h_error, OZ_Handle h_thread, uLong *showopts);
static void show_thread_seckeys (OZ_Handle h_output, OZ_Handle h_thread);
static void show_secattr (OZ_Handle h_output, OZ_Handle h_object, OZ_Handle_code secattrcode, int prefix_w, const char *prefix);
static void *secmalloc (void *dummy, uLong osize, void *obuff, uLong nsize);
static uLong show_user_bylogical (OZ_Handle h_output, OZ_Handle h_error, const char *logical, uLong *showopts);
static uLong show_user_byhandle (OZ_Handle h_output, OZ_Handle h_error, OZ_Handle h_user, uLong *showopts);
static uLong wait_thread (OZ_Handle h_error, OZ_Handle h_thread);
static uLong wait_events (uLong nevents, OZ_Handle *h_events);

/* Internal command declarations */

static uLong int_abort_thread         (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_allocate_device      (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_change_password      (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_close_handle         (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_create_event         (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_create_file          (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_create_job           (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_create_logical_name  (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_create_logical_table (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_create_mutex         (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_create_symbol        (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_deallocate_device    (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_delete_logical_name  (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_delete_logical_table (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_echo                 (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_exit                 (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_goto                 (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_halt_thread          (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_help                 (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_if                   (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_more                 (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_open_file            (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_open_mutex           (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_read_file            (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_resume_thread        (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_script               (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_set_console          (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_set_datetime         (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_set_default          (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_set_event_interval   (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_set_mutex            (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_set_thread           (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_set_timezone         (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_show_datetime        (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_show_device          (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_show_default         (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_show_event           (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_show_iochan          (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_show_job             (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_show_logical_name    (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_show_logical_table   (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_show_job             (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_show_mutex           (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_show_process         (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_show_symbol          (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_show_system          (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_show_thread          (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_show_user            (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_show_volume          (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_step_thread          (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_suspend_thread       (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_wait_event           (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_wait_mutex           (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_wait_thread          (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);
static uLong int_wait_until           (OZ_Handle h_input, OZ_Handle h_output, OZ_Handle h_error, char *name, void *dummy, int argc, const char *argv[]);

static Command intcmd[] = {
	0, "abort thread",         int_abort_thread,         NULL, "[-id <thread_id>] [-nowait] [-status <status>] [<thread_logical_name>]", 
	0, "allocate device",      int_allocate_device,      NULL, "[-user] [-job] [-process] [-thread] <device_name>", 
	0, "change password",      int_change_password,      NULL, "[<old_password> [<new_password>]]", 
	1, "close handle",         int_close_handle,         NULL, "<handle> ...", 
	0, "create event",         int_create_event,         NULL, "<logical_name> <event_name>", 
	1, "create file",          int_create_file,          NULL, "[-lockmode <lockmode>] [-logical <logical_name>] <file_name>", 
	0, "create job",           int_create_job,           NULL, "<logical_name> <job_name>", 
	0, "create logical name",  int_create_logical_name,  NULL, "[-kernel] [-nooutermode] [-nosupersede] <logical_name> [-copy <logical_name>] [-link <logical_name>] [-object <handle>] [-terminal] [-value <value>] <value> ...", 
	0, "create logical table", int_create_logical_table, NULL, "[-kernel] [-nooutermode] [-nosupersede] <table_name>", 
	1, "create mutex",         int_create_mutex,         NULL, "<iochan_logical_name> <mutex_device_name> <mutex_name>", 
	0, "create symbol",        int_create_symbol,        NULL, "[-global] [-integer] [-level <n>] [-string] <name> <value> ...",
	0, "deallocate device",    int_deallocate_device,    NULL, "<device_name>", 
	0, "delete logical name",  int_delete_logical_name,  NULL, "<logical_name>", 
	0, "delete logical table", int_delete_logical_table, NULL, "<table_name>", 
	1, "echo",                 int_echo,                 NULL, "<string> ...", 
	0, "exit",                 int_exit,                 NULL, "[<status>]", 
	0, "goto",                 int_goto,                 NULL, "<label>",
	1, "halt thread",          int_halt_thread,          NULL, "[-id <thread_id>] [<thread_logical_name>]", 
	1, "help",                 int_help,                 NULL, "", 
	0, "if",                   int_if,                   NULL, "<integervalue> <statement ...>", 
	1, "more",                 int_more,                 NULL, "[-columns <number>] [-number] [-rows <number>] [<file>]", 
	1, "open file",            int_open_file,            NULL, "[-lockmode <lockmode>] [-logical <logical_name>] <file_name>", 
	1, "open mutex",           int_open_mutex,           NULL, "<iochan_logical_name> <mutex_device_name> <mutex_name>", 
	1, "read file",            int_read_file,            NULL, "[-logical <logical_name>] [-prompt <prompt>] [-size <size>] [-terminator <terminator>] <symbol_name>", 
	0, "resume thread",        int_resume_thread,        NULL, "[-id <thread_id>] [<thread_logical_name>]", 
	0, "script",               int_script,               NULL, "<script_name> [<args> ...]", 
	1, "set console",          int_set_console,          NULL, "[-columns <columns>] [-[no]linewrap] [-rows <rows>] [<logical_name>]", 
	0, "set datetime",         int_set_datetime,         NULL, "<newdatetime>", 
	0, "set default",          int_set_default,          NULL, "<directory>", 
	0, "set event interval",   int_set_event_interval,   NULL, "<event_logname> <interval> [<basetime>]", 
	1, "set mutex",            int_set_mutex,            NULL, "[-express] [-noqueue] <iochan_logical_name> <new_mode>", 
	0, "set thread",           int_set_thread,           NULL, "[-id <thread_id>] [<thread_logical_name>] [-creates <secattr>] [-priority <basepri>] [-secattr <secattr>] [-seckeys <seckeys>]", 
	0, "set timezone",         int_set_timezone,         NULL, "<timezonename>", 
	1, "show datetime",        int_show_datetime,        NULL, "[-GMT] [-UTC] [-local] [-timezone <timezone>] [-zulu]", 
	1, "show device",          int_show_device,          NULL, "[<device_logical_name> ...] [-iochans] [-objaddr] [-security]", 
	0, "show default",         int_show_default,         NULL, "", 
	1, "show event",           int_show_event,           NULL, "<event_logical_name> ...", 
	1, "show iochan",          int_show_iochan,          NULL, "[<iochan_logical_name> ...] [-objaddr] [-security]", 
	1, "show job",             int_show_job,             NULL, "[<job_logical_name> ...] [-objaddr] [-processes] [-security] [-threads]", 
	1, "show logical name",    int_show_logical_name,    NULL, "<logical_name> [-security]", 
	1, "show logical table",   int_show_logical_table,   NULL, "[<table_name>] [-security]", 
	1, "show mutex",           int_show_mutex,           NULL, "<iochan_logical_name>", 
	1, "show process",         int_show_process,         NULL, "[<process_logical_name> ...] [-objaddr] [-security] [-threads]", 
	1, "show symbol",          int_show_symbol,          NULL, "[<symbol_name> ...]", 
	1, "show system",          int_show_system,          NULL, "[-devices] [-iochans] [-job] [-processes] [-security] [-threads]", 
	1, "show thread",          int_show_thread,          NULL, "[-id <thread_id>] [-objaddr] [-security] [<thread_logical_name> ...]", 
	1, "show user",            int_show_user,            NULL, "[<user_logical_name> ...] [-jobs] [-objaddr] [-processes] [-security] [-threads]", 
	1, "show volume",          int_show_volume,          NULL, "[<device_name> ...]", 
        1, "step thread",          int_step_thread,          NULL, "[-id <thread_id>] [<thread_logical_name>]", 
	0, "suspend thread",       int_suspend_thread,       NULL, "[-id <thread_id>] [<thread_logical_name>]", 
	0, "wait event",           int_wait_event,           NULL, "<logical_name> ...", 
	1, "wait mutex",           int_wait_mutex,           NULL, "<iochan_logical_name>", 
	0, "wait thread",          int_wait_thread,          NULL, "[-id <thread_id>] [<thread_logical_name>]", 
	1, "wait until",           int_wait_until,           NULL, "<datetime>", 
	0, NULL, NULL, NULL, NULL };

uLong oz_util_main (int argc, char *argv[])

{
  char cmdbuf[CMDSIZ], *p;
  int i;
  uLong cmdlen, sts;
  OZ_Handle h_event, h_logname, h_logtable;
  Symbol *symbol;

  defaulttables   = oz_s_logname_defaulttables;

  attachedthreads = NULL;
  exited          = 0;
  scripts         = NULL;
  skiplabel[0]    = 0;
  symbols         = NULL;
  verify          = 0;

  h_s_console = 0;
  h_s_error   = oz_util_h_error;
  h_s_input   = oz_util_h_input;
  h_s_output  = oz_util_h_output;

  /* Put argc/argv's in symbols oz_arg0... Set symbol oz_nargs to the number of values. */

  setscriptsyms (argc, (const char **)argv);

  /* Process command line arguments */

  pn = "oz_cli";
  if (argc > 0) pn = argv[0];

  for (i = 1; i < argc; i ++) {

    /* -console <device> : use the alternate device as the console (for control-Y, -T, etc) */

    if (strcmp (argv[i], "-console") == 0) {
      if (++ i >= argc) goto usage;
      if ((h_s_console != 0) && (h_s_console != oz_util_h_console)) oz_sys_handle_release (OZ_PROCMODE_KNL, h_s_console);
      sts = oz_sys_logname_lookup (0, OZ_PROCMODE_USR, defaulttables, NULL, NULL, NULL, &h_logtable);
      if (sts == OZ_SUCCESS) {
        sts = oz_sys_logname_lookup (h_logtable, OZ_PROCMODE_USR, argv[i], NULL, NULL, NULL, &h_logname);
        oz_sys_handle_release (OZ_PROCMODE_KNL, h_logtable);
        if (sts == OZ_SUCCESS) {
          sts = oz_sys_logname_getval (h_logname, 0, NULL, 0, NULL, NULL, &h_s_console, OZ_OBJTYPE_IOCHAN, NULL);
          oz_sys_handle_release (OZ_PROCMODE_KNL, h_logname);
        }
      }
      if (sts != OZ_SUCCESS) {
        sts = oz_sys_io_assign (OZ_PROCMODE_KNL, &h_s_console, argv[i], OZ_LOCKMODE_EX);
        if (sts != OZ_SUCCESS) {
          oz_sys_io_fs_printf (h_s_error, "%s: error %u assigning channel to console %s\n", pn, sts, argv[i]);
          return (sts);
        }
      }
      continue;
    }

    /* -exec <rest_of_line> : execute the single rest_of_line command */

    if (strcmp (argv[i], "-exec") == 0) {
      argc -= i;
      argv += i;
      break;
    }

    /* -interactive : set up default console device */

    if (strcmp (argv[i], "-interactive") == 0) {
      if ((h_s_console != 0) && (h_s_console != oz_util_h_console)) oz_sys_handle_release (OZ_PROCMODE_KNL, h_s_console);
      h_s_console = oz_util_h_console;
      continue;
    }

    /* -nointeractive : no console device */

    if (strcmp (argv[i], "-nointeractive") == 0) {
      if ((h_s_console != 0) && (h_s_console != oz_util_h_console)) oz_sys_handle_release (OZ_PROCMODE_KNL, h_s_console);
      h_s_console = 0;
      continue;
    }

    /* -noverify : turn off verify */

    if (strcmp (argv[i], "-noverify") == 0) {
      verify = 0;
      continue;
    }

    /* -verify : turn on verify */

    if (strcmp (argv[i], "-verify") == 0) {
      verify = 1;
      continue;
    }

    goto usage;
  }
  if (i == argc) argc = 0;

  if (h_s_console != 0) {
    oz_sys_io_fs_printf (h_s_console, "%s\n", oz_sys_copyright);
    startendmsg ("start");
  }

  /* Set up handle to timer */

  sts = oz_sys_io_assign (OZ_PROCMODE_KNL, &h_timer, "timer", OZ_LOCKMODE_NL);
  if (sts != OZ_SUCCESS) {
    oz_sys_io_fs_printf (h_s_error, "oz_cli: error %u assigning channel to timer\n", sts);
    h_timer = 0;
  }

  /* Set up expression function declarations in symbol table */

  def_func ("oz_collapse",    func_collapse,    SYMTYPE_STRING,  "collapsed = oz_collapse (string)");
  def_func ("oz_compress",    func_compress,    SYMTYPE_STRING, "compressed = oz_compress (string)");
  def_func ("oz_date_add",    func_date_add,    SYMTYPE_STRING,        "sum = oz_date_add (date1, date2)");
  def_func ("oz_date_dow",    func_date_dow,    SYMTYPE_STRING,  "dayofweek = oz_date_dow (date)");
  def_func ("oz_date_now",    func_date_now,    SYMTYPE_STRING,        "now = oz_date_now");
  def_func ("oz_date_sub",    func_date_sub,    SYMTYPE_STRING,       "diff = oz_date_sub (date1, date2)");
  def_func ("oz_date_tzconv", func_date_tzconv, SYMTYPE_STRING,       "date = oz_date_tzconv (date, conv)");
  def_func ("oz_field",       func_field,       SYMTYPE_STRING,      "field = oz_field (index, separator, string)");
  def_func ("oz_event_inc",   func_event_inc,   SYMTYPE_INTEGER,       "old = oz_event_inc (handle, inc)");
  def_func ("oz_event_set",   func_event_set,   SYMTYPE_INTEGER,       "old = oz_event_set (handle, new)");
  def_func ("oz_h_info",      func_h_info,      SYMTYPE_STRING,     "string = oz_h_info (handle, item)");
  def_func ("oz_len",         func_len,         SYMTYPE_INTEGER,    "length = oz_len (string)");
  def_func ("oz_lnm_attrs",   func_lnm_attrs,   SYMTYPE_STRING,      "attrs = oz_lnm_attrs (h_logname, index)");
  def_func ("oz_lnm_lookup",  func_lnm_lookup,  SYMTYPE_STRING,  "h_logname = oz_lnm_lookup (logname, procmode)");
  def_func ("oz_lnm_nvalues", func_lnm_nvalues, SYMTYPE_INTEGER,   "nvalues = oz_lnm_nvalues (h_logname)");
  def_func ("oz_lnm_object",  func_lnm_object,  SYMTYPE_STRING,   "h_object = oz_lnm_object (h_logname, index, objtype)");
  def_func ("oz_lnm_string",  func_lnm_string,  SYMTYPE_STRING,     "string = oz_lnm_string (h_logname, index)");
  def_func ("oz_loc",         func_loc,         SYMTYPE_INTEGER,    "offset = oz_loc (haystack, needle) (length if not found)");
  def_func ("oz_lowercase",   func_lowercase,   SYMTYPE_STRING,  "lowercase = oz_lowercase (string)");
  def_func ("oz_process",     func_process,     SYMTYPE_STRING,  "h_process = oz_process (process_id)");
  def_func ("oz_sub",         func_sub,         SYMTYPE_STRING,  "substring = oz_sub (size, offset, string)");
  def_func ("oz_thread",      func_thread,      SYMTYPE_STRING,   "h_thread = oz_thread (thread_id)");
  def_func ("oz_trim",        func_trim,        SYMTYPE_STRING,    "trimmed = oz_trim (string)");
  def_func ("oz_uppercase",   func_uppercase,   SYMTYPE_STRING,  "uppercase = oz_uppercase (string)");
  def_func ("oz_verify",      func_verify,      SYMTYPE_INTEGER, "oldverify = oz_verify (-1:nc 0:off 1:on)");

  /* Create an event flag to use for I/O, and one for control-Y */

  sts = oz_sys_event_create (OZ_PROCMODE_KNL, "oz_cli i/o", &h_event);
  if (sts != OZ_SUCCESS) {
    oz_sys_io_fs_printf (h_s_error, "oz_cli: error %u creating event flag\n", sts);
    return (sts);
  }

  sts = oz_sys_event_create (OZ_PROCMODE_KNL, "oz_cli ctrl-Y", &h_event_ctrly);
  if (sts != OZ_SUCCESS) {
    oz_sys_io_fs_printf (h_s_error, "oz_cli: error %u creating event flag\n", sts);
    return (sts);
  }

  /* Set up and enable ctrl-Y and ctrl-T */

  ctrly_hit = 0;
  ctrly_enable ();
  ctrlt_enable ();

  /* Set up a status symbol (oz_status) */

  symbol = malloc (sizeof *symbol);
  strcpy (symbol -> name, "oz_status");
  symbol -> symtype = SYMTYPE_INTEGER;
  symbol -> ivalue = OZ_SUCCESS;
  insert_symbol (symbol, NULL, 0);

  /* Set up command read prompt */

  memset (&scriptread, 0, sizeof scriptread);
  scriptread.size = sizeof cmdbuf - 1;
  scriptread.buff = cmdbuf;
  scriptread.rlen = &cmdlen;
  scriptread.trmsize = 1;
  scriptread.trmbuff = "\n";
  scriptread.pmtsize = 7;
  scriptread.pmtbuff = "oz_cli>";

  memset (&scriptinfo, 0, sizeof scriptinfo);

  /* If -exec, execute the one command they supply                                     */
  /* But it might be a 'script' command, so check for that after executing the command */

  if (argc > 0) {
    h_s_input = 0;
    symbol -> ivalue = exechopped (argc - 1, (const char **)(argv + 1), NULL, NULL, 0);
  }

  /* Process commands from the input file */

  while (!exited && (h_s_input != 0)) {

    /* If control-Y was pressed, wipe out scripts and return to top level */

    if (ctrly_hit) {
      ctrly_hit = 0;
      skiplabel[0] = 0;
      while (scripts != NULL) {
        exit_script ();
      }
      scriptread.atblock = 0;
      scriptread.atbyte  = 0;
    }

    /* Read command line from input file (but first get current file position) */

    sts = oz_sys_io (OZ_PROCMODE_KNL, h_s_input, h_event, OZ_IO_FS_GETINFO1, sizeof scriptinfo, &scriptinfo);
    if (sts != OZ_SUCCESS) scriptinfo.curblock = 0;
    if ((sts == OZ_SUCCESS) || (sts == OZ_BADIOFUNC)) {
      if (scriptread.atblock != 0) {
        scriptinfo.curblock = scriptread.atblock;
        scriptinfo.curbyte  = scriptread.atbyte;
      }
      sts = oz_sys_io (OZ_PROCMODE_KNL, h_s_input, h_event, OZ_IO_FS_READREC, sizeof scriptread, &scriptread);
    }
    scriptread.atblock = 0;
    scriptread.atbyte  = 0;

    /* If read error, close this script and resume next outer level */

    if (sts != OZ_SUCCESS) {
      if (sts != OZ_ENDOFFILE) {					/* error message if not end-of-file */
        oz_sys_io_fs_printf (h_s_error, "oz_cli: error %u reading from input\n", sts);
        symbol -> ivalue = sts;						/* ... and set the error status */
      }
      exit_script ();							/* in any case, pop script level */
      if ((sts == OZ_ENDOFFILE) && exited && (oz_sys_io (OZ_PROCMODE_KNL, h_s_input, h_event, OZ_IO_CONSOLE_GETMODE, 0, NULL) == OZ_SUCCESS)) {
        oz_sys_io_fs_printf (h_s_error, "oz_cli: use 'exit' command to log out\n"); /* don't allow end-of-file to exit interactive session */
        exited = 0;
      }
    }

    /* Otherwise, process the command line */

    else {
      cmdbuf[cmdlen] = 0;						/* null terminate command line */
      p = proclabels (cmdbuf);						/* process any labels that are present */
      if (skiplabel[0] == 0) {						/* ignore line if skipping to a particular label */
        if (verify) oz_sys_io_fs_printf (h_s_output, "%s\n", cmdbuf);	/* ok, echo if verifying turned on */
        sts = execute (p);						/* execute the command line */
        if (sts != OZ_PENDING) symbol -> ivalue = sts;			/* save the new status */
      }
    }
  }

  /* End of outermost script, return last oz_status symbol value */

  if (h_s_console != 0) startendmsg ("end");
  return (symbol -> ivalue);

  /* Option error, print usage line and exit */

usage:
  oz_sys_io_fs_printf (oz_util_h_error, "%s: usage: %s [-console <device>] [-exec <rest_of_line>] [-interactive] [-noverify] [-verify]\n", pn, pn);
  return (OZ_BADPARAM);
}

/* Write session starting and ending message, but only if input is a console device */

static void startendmsg (const char *name)

{
  char buf[64];
  OZ_IO_console_write console_write;

  oz_sys_sprintf (sizeof buf, buf, "%s: session %sing at %19.19t\n", pn, name, oz_hw_tod_getnow ());
  memset (&console_write, 0, sizeof console_write);
  console_write.size = strlen (buf);
  console_write.buff = buf;
  oz_sys_io (OZ_PROCMODE_KNL, h_s_input, 0, OZ_IO_CONSOLE_WRITE, sizeof console_write, &console_write);
}

/************************************************************************/
/*									*/
/*  Enable and process control-Y detection on h_s_console device	*/
/*									*/
/************************************************************************/

static void ctrly_enable (void)

{
  uLong sts;
  OZ_IO_console_ctrlchar ctrly;

  if (h_s_console != 0) {
    memset (&ctrly, 0, sizeof ctrly);
    ctrly.mask[0] = 1 << ('Y' - '@');
    sts = oz_sys_io_start (OZ_PROCMODE_KNL, h_s_console, NULL, 0, ctrly_ast, NULL, OZ_IO_CONSOLE_CTRLCHAR, sizeof ctrly, &ctrly);
    if (sts != OZ_STARTED) oz_sys_io_fs_printf (h_s_console, "oz_cli ctrly_enable: error %u enabling ctrl-Y detection\n", sts);
  }
}

/* This routine gets called when ctrl-Y is pressed.                                                          */
/* It also gets called when the thread exits, because the main program calls oz_sys_io_abort on the channel. */

static void ctrly_ast (void *dummy, uLong status, OZ_Mchargs *mchargs)

{
  if (status == OZ_SUCCESS) {
    ctrly_hit = 1;
  } else if (status != OZ_ABORTED) {
    oz_sys_io_fs_printf (h_s_console, "oz_cli ctrly_ast: error %u ctrl-Y completion\n", status);
  }

  ctrly_enable ();
}

/************************************************************************/
/*									*/
/*  Enable and process control-T detection on h_s_console device	*/
/*									*/
/************************************************************************/

static void ctrlt_enable (void)

{
  uLong sts;
  OZ_IO_console_ctrlchar ctrlt;

  if (h_s_console != 0) {
    memset (&ctrlt, 0, sizeof ctrlt);
    ctrlt.mask[0] = 1 << ('T' - '@');
    sts = oz_sys_io_start (OZ_PROCMODE_KNL, h_s_console, NULL, 0, ctrlt_ast, NULL, OZ_IO_CONSOLE_CTRLCHAR, sizeof ctrlt, &ctrlt);
    if (sts != OZ_STARTED) oz_sys_io_fs_printf (h_s_console, "oz_cli ctrlt_enable: error %u enabling ctrl-T detection\n", sts);
  }
}

/* This routine gets called when ctrl-T is pressed.                                                          */
/* It also gets called when the thread exits, because the main program calls oz_sys_io_abort on the channel. */

static void ctrlt_ast (void *dummy, uLong status, OZ_Mchargs *mchargs)

{
  char t_name[OZ_THREAD_NAMESIZE], u_quota[256];
  char state[16];
  OZ_Datebin now, t_tis_com, t_tis_run, t_tis_wev;
  OZ_Handle h_lastproc, h_nextproc;
  OZ_Handle h_lastthread, h_nextthread;
  OZ_Thread_state t_state;
  OZ_Threadid t_id;
  uLong index, sts, t_numios, t_numpfs;

  OZ_Handle_item p_item = { 
	OZ_HANDLE_CODE_PROCESS_FIRST, sizeof h_nextproc, &h_nextproc, NULL };

  OZ_Handle_item p_items[] = {
	OZ_HANDLE_CODE_PROCESS_NEXT, sizeof h_nextproc,   &h_nextproc,   NULL, 
	OZ_HANDLE_CODE_THREAD_FIRST, sizeof h_nextthread, &h_nextthread, NULL };

  OZ_Handle_item t_items[] = { 
	OZ_HANDLE_CODE_THREAD_NEXT,    sizeof h_nextthread, &h_nextthread, NULL, 
        OZ_HANDLE_CODE_THREAD_STATE,   sizeof t_state,      &t_state,      NULL, 
        OZ_HANDLE_CODE_THREAD_TIS_RUN, sizeof t_tis_run,    &t_tis_run,    NULL, 
        OZ_HANDLE_CODE_THREAD_TIS_COM, sizeof t_tis_com,    &t_tis_com,    NULL, 
        OZ_HANDLE_CODE_THREAD_TIS_WEV, sizeof t_tis_wev,    &t_tis_wev,    NULL, 
        OZ_HANDLE_CODE_THREAD_ID,      sizeof t_id,         &t_id,         NULL, 
        OZ_HANDLE_CODE_THREAD_NUMIOS,  sizeof t_numios,     &t_numios,     NULL, 
        OZ_HANDLE_CODE_THREAD_NUMPFS,  sizeof t_numpfs,     &t_numpfs,     NULL, 
        OZ_HANDLE_CODE_THREAD_NAME,    sizeof t_name,        t_name,       NULL };

  OZ_Handle_item u_item = {
	OZ_HANDLE_CODE_USER_QUOTA_USE, sizeof u_quota, u_quota, NULL };

  h_lastproc   = 0;
  h_nextproc   = 0;
  h_lastthread = 0;
  h_nextthread = 0;

  /* Check the status */

  if (status != OZ_SUCCESS) {
    if (status == OZ_ABORTED) ctrlt_enable ();
    else oz_sys_io_fs_printf (h_s_console, "oz_cli ctrlt_ast: error %u ctrl-T completion\n", status);
    return;
  }

  /* First line is the current date/time and the quota */

  sts = oz_sys_handle_getinfo (0, 1, &u_item, &index);
  if (sts != OZ_SUCCESS) {
    oz_sys_io_fs_printf (h_s_console, "oz_cli: error %u getting user info\n", sts);
    goto cleanup;
  }
  now = oz_hw_tod_getnow ();
  oz_sys_io_fs_printf (h_s_console, "\noz_cli  %.22t  (%s)\n", now, u_quota);

  /* Get handle to the first process in this job */

  sts = oz_sys_handle_getinfo (0, 1, &p_item, &index);
  if (sts != OZ_SUCCESS) {
    oz_sys_io_fs_printf (h_s_console, "oz_cli: error %u getting first process handle\n", sts);
    goto cleanup;
  }

  /* Repeat as long as we find processes in this job */

  while (h_nextproc != 0) {
    h_lastproc = h_nextproc;
    h_nextproc = 0;

    /* Find out process */

    sts = oz_sys_handle_getinfo (h_lastproc, sizeof p_items / sizeof *p_items, p_items, &index);
    if (sts != OZ_SUCCESS) {
      oz_sys_io_fs_printf (h_s_console, "oz_cli: error %u getting process info\n", sts);
      goto cleanup;
    }

    /* Repeat as long as we find threads in the process */

    while (h_nextthread != 0) {
      h_lastthread = h_nextthread;
      h_nextthread = 0;

      /* Find out about thread */

      sts = oz_sys_handle_getinfo (h_lastthread, sizeof t_items / sizeof *t_items, t_items, &index);
      if (sts != OZ_SUCCESS) {
        oz_sys_io_fs_printf (h_s_console, "oz_cli: error %u getting next thread info\n", sts);
        goto cleanup;
      }

      /* Print out info about thread */

      switch (t_state) {
        case OZ_THREAD_STATE_RUN: { strcpy (state, "RUN"); break; }
        case OZ_THREAD_STATE_COM: { strcpy (state, "COM"); break; }
        case OZ_THREAD_STATE_WEV: { strcpy (state, "WEV"); break; }
        case OZ_THREAD_STATE_INI: { strcpy (state, "INI"); break; }
        case OZ_THREAD_STATE_ZOM: { strcpy (state, "ZOM"); break; }
        default: { oz_sys_sprintf (sizeof state, state, "%3d", t_state); };
      }
      oz_sys_io_fs_printf (h_s_console, "%u: %s  %#.3tr/%#.3tc/%#.3tw %ui/%up  %s\n", 
	t_id, state, t_tis_run, t_tis_com, t_tis_wev, t_numios, t_numpfs, t_name);

      oz_sys_handle_release (OZ_PROCMODE_KNL, h_lastthread);
      h_lastthread = 0;
    }
    oz_sys_handle_release (OZ_PROCMODE_KNL, h_lastproc);
    h_lastproc = 0;
  }

cleanup:
  if (h_nextproc   != 0) oz_sys_handle_release (OZ_PROCMODE_KNL, h_nextproc);
  if (h_lastproc   != 0) oz_sys_handle_release (OZ_PROCMODE_KNL, h_lastproc);
  if (h_nextthread != 0) oz_sys_handle_release (OZ_PROCMODE_KNL, h_nextthread);
  if (h_lastthread != 0) oz_sys_handle_release (OZ_PROCMODE_KNL, h_lastthread);
  ctrlt_enable ();
}

/************************************************************************/
/*									*/
/*  Close current script and re-activate next outer script		*/
/*  If we're already at outermost script, set the exited flag		*/
/*									*/
/************************************************************************/

static void exit_script (void)

{
  Label *label;
  Script *script;
  Symbol *symbol;

  script = scripts;					/* point to script block */
  if (script == NULL) exited = 1;			/* if this is outermost, say we have exited */
  else {
    if (skiplabel[0] != 0) {
      oz_sys_io_fs_printf (h_s_error, "oz_cli: undefined label %s in script\n", skiplabel);
      skiplabel[0] = 0;
    }
    oz_sys_handle_release (OZ_PROCMODE_KNL, h_s_input);	/* this is an inner script, close it */
    h_s_input = script -> h_input;			/* get next outer script handle */
    if (h_s_output != script -> h_output) {		/* restore its output file */
      oz_sys_handle_release (OZ_PROCMODE_KNL, h_s_output);
      h_s_output = script -> h_output;
    }
    if (h_s_error  != script -> h_error)  {		/* restore its error file */
      oz_sys_handle_release (OZ_PROCMODE_KNL, h_s_error);
      h_s_error  = script -> h_error;
    }
    while ((label = labels) != NULL) {			/* free off this ones labels */
      labels = label -> next;
      free (label);
    }
    while ((symbol = symbols) != NULL) {		/* free off this ones symbols */
      symbols = symbol -> next;
      free (symbol);
    }
    labels  = script -> labels;				/* restore outer script's labels */
    symbols = script -> symbols;			/* restore outer script's symbols */
    scripts = script -> next;				/* unlink and free script save block */
    free (script);
  }
}

/************************************************************************/
/*									*/
/*  Process the optional label at the beginning of a command line	*/
/*									*/
/************************************************************************/

static char *proclabels (char *cmdbuf)

{
  char c, labelname[MAXSYMNAM], *p, *q;
  Label *label;

  p = cmdbuf;

  /* Skip over leading spaces */

  while (((c = *p) != 0) && (c <= ' ')) p ++;

  /* Keep scanning from there for either a ': ' or just a space or end-of-line */
  /* If we get a ': ', then we have a label definition */

  for (q = p; (c = *q) > ' '; q ++) {
    if ((c == ':') && (q[1] <= ' ')) {

      /* Found a label, put name in 'labelname' */

      *q = 0;
      strncpyz (labelname, p, sizeof labelname);
      *(q ++) = ':';

      /* See if we already have such a label for this script */

      for (label = labels; label != NULL; label = label -> next) {
        if (strcmp (label -> name, labelname) == 0) break;
      }

      /* If not, create a new label definition */

      if (label == NULL) {
        label = malloc (sizeof *label);
        label -> next = labels;
        strncpyz (label -> name, labelname, sizeof label -> name);
        labels = label;
      }

      /* Either way, store the current record's address in the label definition */

      label -> blkoffs = scriptinfo.curblock;
      label -> bytoffs = scriptinfo.curbyte;

      /* If we are skipping to a particular label, see if we are there */

      if ((skiplabel[0] != 0) && (strcmp (skiplabel, label -> name) == 0)) skiplabel[0] = 0;

      /* There or not, return pointer in command line past the label */

      return (q);
    }
  }

  /* Got to a space before we found a colon, so there is no label */

  return (p);
}

/************************************************************************/
/*									*/
/*  This routine executes a command line				*/
/*									*/
/*    Input:								*/
/*									*/
/*	cmdbuf = null terminated command line string			*/
/*									*/
/*    Output:								*/
/*									*/
/*	execute = completion status					*/
/*									*/
/************************************************************************/

static uLong execute (char *cmdbuf)

{
  char c, *input, *newbuf, pipei[OZ_DEVUNIT_NAMESIZE], pipeo[OZ_DEVUNIT_NAMESIZE];
  const char **v;
  int dq, i, j, n, s, sq;
  uLong sts;
  OZ_Handle h_pipei, h_pipeo;

  /* Substitute in variables */

  sts = substitute (cmdbuf, &newbuf);
  if (sts != OZ_SUCCESS) return (sts);

  /* Chop command line up into parameter vector */

  v = malloc ((strlen (newbuf) / 2 + 2) * sizeof *v);

  input   = NULL;				/* no piping going on */
  h_pipei = 0;
  h_pipeo = 0;
  i = 0;					/* start at beg of command line */
restart:
  j = i;					/* no output chars yet */
  n = 0;					/* no output tokens yet */
  dq = 0;					/* not inside double quotes */
  sq = 0;					/* not inside single quotes */
  s = 1;					/* skip leading spaces */
  for (; (c = newbuf[i]) != 0; i ++) {		/* loop through all input chars */
    if (!dq && !sq && (c == '#')) break;	/* stop if unquoted comment character */
    if (!dq && !sq && (c == '|') && (newbuf[i+1] == '>')) goto piping;
    if (!sq && (c == '"')) dq = 1 - dq;		/* if double quote outside single quotes, flip double quote flag */
    else if (!dq && (c == '\'')) sq = 1 - sq;	/* if single quote outside double quotes, flip single quote flag */
    else if (dq || sq || (c > ' ')) {		/* otherwise, check for printables (or quoted non-printables) */
      if (c == '\\') {				/* ok, check for backslash (the escape char) */
        c = newbuf[++i];			/* if so, get the next char */
        if (c == 0) break;			/* (abort loop if eol) */
        if (c == 'b') c = '\b';
        if (c == 'n') c = '\n';
        if (c == 'r') c = '\r';
        if (c == 't') c = '\t';
      }
      if (s) {
        v[n++] = newbuf + j;			/* start new token if we were skipping spaces */
        s = 0;					/* no longer skipping spaces */
      }
      newbuf[j++] = c;				/* store printable or escaped char in output buffer */
    } else if (!s) {				/* non-printable, see if first non-printable */
      newbuf[j++] = 0;				/* first non-printable, null-terminate prior string */
      s = 1;					/* ... and remember we're skipping spaces */
    }
  }
  newbuf[j] = 0;				/* make sure last token is null terminated */
  v[n] = NULL;					/* put a null pointer on the end of vector */

  /* Execute the chopped up command - maybe input is a pipe, output is normal, don't force -nowait */

  sts = exechopped (n, v, input, NULL, 0);

  /* Free off temp buffers */

rtn:
  free (newbuf);
  free (v);

  /* Close any pipe handles */

  if (h_pipei != 0) oz_sys_handle_release (OZ_PROCMODE_KNL, h_pipei);
  if (h_pipeo != 0) oz_sys_handle_release (OZ_PROCMODE_KNL, h_pipeo);

  /* Return completion status */

  return (sts);

  /* Piping using |> */

piping:
  i += 2;								/* skip over the |> */
  newbuf[j] = 0;							/* make sure last arg string is terminated */
  v[n] = NULL;								/* terminate the arg list with a null */
  sts = oz_sys_io_assign (OZ_PROCMODE_KNL, &h_pipeo, OZ_IO_PIPES_TEMPLATE, OZ_LOCKMODE_NL); /* create a stream-style pipe */
  if (sts != OZ_SUCCESS) {
    oz_sys_io_fs_printf (h_s_error, "oz_cli: error %u creating pipe\n", sts);
    h_pipeo = 0;
    goto rtn;
  }
  sts = oz_sys_iochan_getunitname (h_pipeo, sizeof pipeo - 1, pipeo);	/* get the pipe's device name */
  if (sts != OZ_SUCCESS) oz_sys_condhand_signal (2, sts, 0);
  strcat (pipeo, ":");							/* put a colon on the end */
  sts = exechopped (n, v, input, pipeo, 1);				/* execute the command using that pipe as the -output */
									/* ... and forcing a -nowait option */
  if ((sts != OZ_SUCCESS) && (sts != OZ_PENDING)) goto rtn;		/* all done if some failure */
  if (h_pipei != 0) oz_sys_handle_release (OZ_PROCMODE_KNL, h_pipei);	/* if input was a pipe, it's safe to release handle because exechopped made its own */
  strcpy (pipei, pipeo);						/* set the new pipe as input to the next command on line */
  input   = pipei;
  h_pipei = h_pipeo;
  h_pipeo = 0;
  goto restart;								/* go process next command on line following |> */
}

/************************************************************************/
/*									*/
/*  Execute chopped-up command						*/
/*									*/
/*    Input:								*/
/*									*/
/*	argc = argument count						*/
/*	argv = argument vector						*/
/*									*/
/*    Output:								*/
/*									*/
/*	exechopped = OZ_PENDING : command just started			*/
/*	                   else : command's status			*/
/*									*/
/************************************************************************/

typedef struct { Runopts runopts;
                 Command *command;
                 int argc;
                 const char **argv;
                 Long refcount;
               } Tc;

static uLong threadcommand (void *tcv);
static void threadcommandexit (void *tcv, uLong status);

static uLong exechopped (int argc, const char *argv[], const char *input, const char *output, int nowait)

{
  const char **aargv;
  int aargc, i;
  uLong sts;
  Tc *tc;

  /* Ignore blank lines */

  if (argc == 0) return (OZ_PENDING);

  /* Decode the prefix options in case of internal async command */

  tc = malloc (sizeof *tc);			/* allocate threadcommand buffer */
  tc -> argc = argc;				/* fill it in with prefix options from command line args */
  tc -> argv = argv;
  sts = decode_runopts (input, output, nowait, h_s_input, h_s_output, h_s_error, &(tc -> argc), &(tc -> argv), &(tc -> runopts));
  if (sts != OZ_SUCCESS) {
    free (tc);					/* some error processing prefixes, release buffer */
    return (sts);				/* return error status */
  }
  if (nowait) tc -> runopts.wait = 0;		/* maybe force -nowait */

  /* Check for internal commands */

  tc -> command = decode_command (tc -> argc, tc -> argv, intcmd, &i);
  if (tc -> command != NULL) {
    tc -> argc -= i;
    tc -> argv += i;

    /* Internal commands flagged 'async' run as a thread */

    if (tc -> command -> async) {
      if ((tc -> runopts.debug) || (tc -> runopts.defdir != NULL) || (tc -> runopts.job_name != NULL) || (tc -> runopts.orphan) || (tc -> runopts.process_name != NULL)) {
        oz_sys_io_fs_printf (h_s_error, "oz_cli: -debug, -directory, -job, -orphan and -process options illegal on '%s' command\n", tc -> command -> name);
        cleanup_runopts (&(tc -> runopts));
        free (tc);
        return (OZ_BADPARAM);
      }
      sts = setup_runopts (h_s_error, &(tc -> runopts));		/* open corresponding handles */
      if (sts == OZ_SUCCESS) {
        tc -> refcount = 2;						/* don't free tc until both thread and I are done with it */
        sts = oz_sys_thread_create (OZ_PROCMODE_KNL, 0, 0, tc -> runopts.h_init, tc -> runopts.h_exit, 0, 
                                    threadcommand, tc, OZ_ASTMODE_ENABLE, tc -> command -> name, &(tc -> runopts.h_thread));
        if (sts != OZ_SUCCESS) {
          oz_sys_io_fs_printf (h_s_error, "oz_cli: error %u creating thread for %s\n", sts, tc -> command -> name);
          cleanup_runopts (&(tc -> runopts));				/* couldn't create thread, close off runopts */
          free (tc);							/* then free the tc */
        } else {
          sts = finish_runopts (h_s_error, &(tc -> runopts));		/* thread started, finish with runopts */
          if (oz_hw_atomic_inc_long (&(tc -> refcount), -1) == 0) {	/* dec ref count */
            cleanup_runopts (&(tc -> runopts));				/* I made them go zero, close runopts */
            free (tc);							/* ... and free the tc */
          }
        }
      }
    }

    /* Otherwise, they are simply called */

    else {
      if ((tc -> runopts.debug) || (tc -> runopts.defdir != NULL) || (tc -> runopts.job_name != NULL) || (tc -> runopts.process_name != NULL) || (tc -> runopts.timeit) || (tc -> runopts.orphan) 
       || (tc -> runopts.exit_name != NULL) || (tc -> runopts.init_name != NULL) || (tc -> runopts.thread_name != NULL) || !(tc -> runopts.wait)) {
        oz_sys_io_fs_printf (h_s_error, "oz_cli: -debug -directory, -exit, -init, -job, -nowait, -orphan, -process, -thread and -timeit options illegal on '%s' command\n", tc -> command -> name);
        cleanup_runopts (&(tc -> runopts));
        free (tc);
        return (OZ_BADPARAM);
      }
      sts = (*(tc -> command -> entry)) (tc -> runopts.h_in, 
                                         tc -> runopts.h_out, 
                                         tc -> runopts.h_err, 
                                         tc -> command -> name, 
                                         tc -> command -> param, 
                                         tc -> argc, 
                                         tc -> argv);
      cleanup_runopts (&(tc -> runopts));
      free (tc);
    }
  }

  /* If not, assume it is an external command - it reprocesses the options */

  else {
    free (tc);
    aargc = argc;
    aargv = argv;
    if ((input != NULL) || (output != NULL) || nowait) {
      aargv = malloc ((aargc + 5) * sizeof *argv);
      aargc = 0;
      if (input  != NULL) { aargv[aargc++] = "-input";  aargv[aargc++] = input;  }
      if (output != NULL) { aargv[aargc++] = "-output"; aargv[aargc++] = output; }
      if (nowait)         { aargv[aargc++] = "-nowait"; }
      memcpy (aargv + aargc, argv, argc * sizeof *argv);
      aargc += argc;
    }
    sts = extcommand (h_s_input, h_s_output, h_s_error, "", NULL, aargc, aargv);
    if (aargv != argv) free (aargv);
  }

  return (sts);
}

/* This executes an internal command as a thread */

static uLong threadcommand (void *tcv)

{
  uLong sts;
  Tc *tc;

  tc = tcv;
  sts = oz_sys_exhand_create (OZ_PROCMODE_KNL, threadcommandexit, tc);
  if (sts != OZ_SUCCESS) oz_sys_io_fs_printf (tc -> runopts.h_err, "oz_cli: error %u creating exit handler\n", sts);
  else sts = (*(tc -> command -> entry)) (tc -> runopts.h_in, 
                                          tc -> runopts.h_out, 
                                          tc -> runopts.h_err, 
                                          tc -> command -> name, 
                                          tc -> command -> param, 
                                          tc -> argc, 
                                          tc -> argv);
  return (sts);
}

static void threadcommandexit (void *tcv, uLong status)

{
  Tc *tc;

  tc = tcv;
  if (oz_hw_atomic_inc_long (&(tc -> refcount), -1) == 0) {	/* dec ref count */
    cleanup_runopts (&(tc -> runopts));				/* I made them go zero, close runopts */
    free (tc);							/* ... and free the tc */
  }
}

/************************************************************************/
/*									*/
/*  This routine takes a command line and makes all the variable 	*/
/*  substitutions for expressions enclosed by {...}.  Strings enclosed 	*/
/*  by '...' are excluded from substitution.				*/
/*									*/
/*    Input:								*/
/*									*/
/*	inbuf = input string buffer (null terminated)			*/
/*									*/
/*    Output:								*/
/*									*/
/*	substitute = OZ_SUCCESS : successful				*/
/*	                   else : error status				*/
/*	*outbuf_r = output string buffer pointer (malloc'd)		*/
/*									*/
/************************************************************************/

static uLong substitute (char *inbuf, char **outbuf_r)

{
  char c, *evalbuf, *outbuf, *p;
  int i, j, l, m, o, q;
  Symbol *symbol;
  uLong sts;

  *outbuf_r = NULL;

  m = strlen (inbuf) + 8;			/* allocate an output buffer */
  outbuf = malloc (m);				/* ... a little bigger than input */
  o = 0;					/* nothing in output buffer yet */

  q = 0;					/* not in quotes */
  for (i = 0; (c = inbuf[i]) != 0; i ++) {	/* loop through input string */
    if (c == '\\') {				/* check for backslash */
      c = inbuf[++i];				/* that means next char is literal */
      if (c == 0) break;
      outbuf[o++] = '\\';			/* put backslash in output buffer */
						/* ... and copy escaped char to output buffer */
    } else if (c == '\'') {			/* check for single quote */
      q = 1 - q;				/* if so, flip quote flag */
						/* ... and copy it to output buffer */
    } else if (!q && (c == '{')) {		/* check for opening brace */
      c = inbuf[++i];				/* get character following the { */
      if (SYMBOLSTARTCHAR (c)) {		/* special case for {symbolname} */
        for (j = i; (c = inbuf[++j]) != 0;) if (!SYMBOLCHAR (c)) break;
        if (c == '}') {
          inbuf[j] = 0;				/* ok, look up the symbol name */
          symbol = lookup_symbol (inbuf + i, 0, NULL);
          inbuf[j] = '}';
          if (symbol == NULL) {			/* if undefined, ... */
            i = j;				/* ... just skip over it */
            continue;
          }
        }
      }
      sts = eval_string (inbuf + i, &p, &evalbuf, 0); /* ok, evaluate string, should terminate on a } */
      if (sts != OZ_SUCCESS) {
        free (outbuf);				/* evaluation error, free output buffer */
        return (sts);				/* return error status */
      }
      if (*p != '}') {
        oz_sys_io_fs_printf (h_s_error, "oz_cli: expected } terminator at %s\n", p);
        free (outbuf);
        return (OZ_BADPARAM);
      }
      i = p - inbuf;				/* ok, point at the '}' (the i++ of the for stmt will skip over it) */
      l = strlen (evalbuf);			/* get length of result */
      if (o + l >= m) {				/* see if it would overflow output */
        m += l + strlen (inbuf + i) + 8;	/* if so, malloc a new output */
        p = malloc (m);
        memcpy (p, outbuf, o);
        free (outbuf);
        outbuf = p;
      }
      memcpy (outbuf + o, evalbuf, l);		/* concat onto output buffer */
      o += l;
      free (evalbuf);				/* all done with temp buffer */
      continue;					/* don't put } in output buffer */
    }

    /* Put character c in output buffer */

    if (o + 1 >= m) {				/* see if enough room for it and one other */
						/* this allows for this char and a null terminator */
      m += strlen (inbuf + i) + 8;		/* if not, malloc a new output */
      p = malloc (m);
      memcpy (p, outbuf, o);
      free (outbuf);
      outbuf = p;
    }
    outbuf[o++] = c;				/* there is room, put char in buff */
  }

  outbuf[o] = 0;				/* done, null terminate output */
  *outbuf_r = outbuf;				/* return outbuf pointer */
  return (OZ_SUCCESS);				/* return success status */
}

/************************************************************************/
/*									*/
/*  Evaluate the expression up to a terminator character		*/
/*									*/
/************************************************************************/

/************************************************************************/
/*									*/
/*  Evaluate handle expression						*/
/*									*/
/*    Input:								*/
/*									*/
/*	inbuf   = start of expression string				*/
/*	termch  = expected termination char (or 0 to not check)		*/
/*	objtype = object type string ("" if don't care)			*/
/*									*/
/*    Output:								*/
/*									*/
/*	eval_handle = OZ_SUCCESS : successful evaluation		*/
/*	                    else : error status				*/
/*	*inbuf_r  = points after termination character in string	*/
/*	*outval_r = handle result					*/
/*									*/
/************************************************************************/

static uLong eval_handle (char *inbuf, char **inbuf_r, OZ_Handle *outval_r, char *objtype, char termch)

{
  int usedup;
  uLong sts;
  Symbol *symbol;

  sts = evaluate (inbuf, inbuf_r, &symbol, termch);
  if (sts != OZ_SUCCESS) return (sts);

  switch (symbol -> symtype) {
    case SYMTYPE_INTEGER: {
      oz_sys_io_fs_printf (h_s_error, "oz_cli: %s handle value required at %u\n", objtype, symbol -> ivalue);
      free (symbol);
      return (OZ_BADPARAM);
    }
    case SYMTYPE_STRING: {
      if (symbol -> svalue[0] == 0) {
        *outval_r = 0;
        break;
      }
      *outval_r = oz_hw_atoz (symbol -> svalue, &usedup);
      if ((symbol -> svalue[usedup] != ':') || ((objtype[0] != 0) && (strcmp (symbol -> svalue + usedup + 1, objtype) != 0))) {
        oz_sys_io_fs_printf (h_s_error, "oz_cli: %s handle value required at %s\n", objtype, symbol -> svalue);
        free (symbol);
        return (OZ_BADPARAM);
      }
      break;
    }
  }

  free (symbol);
  return (OZ_SUCCESS);
}

/************************************************************************/
/*									*/
/*  Evaluate integer expression						*/
/*									*/
/*    Input:								*/
/*									*/
/*	inbuf = start of expression string				*/
/*	termch = expected termination char (or 0 to not check)		*/
/*									*/
/*    Output:								*/
/*									*/
/*	eval_integer = OZ_SUCCESS : successful evaluation		*/
/*	                     else : error status			*/
/*	*inbuf_r = points after termination character in string		*/
/*	*outval_r = integer result					*/
/*									*/
/************************************************************************/

static uLong eval_integer (char *inbuf, char **inbuf_r, uLong *outval_r, char termch)

{
  int usedup;
  uLong sts;
  Symbol *symbol;

  sts = evaluate (inbuf, inbuf_r, &symbol, termch);
  if (sts != OZ_SUCCESS) return (sts);

  switch (symbol -> symtype) {
    case SYMTYPE_INTEGER: {
      *outval_r = symbol -> ivalue;
      break;
    }
    case SYMTYPE_STRING: {
      *outval_r = oz_hw_atoi (symbol -> svalue, &usedup);
      if (symbol -> svalue[usedup] != 0) {
        oz_sys_io_fs_printf (h_s_error, "oz_cli: integer value required at %s\n", symbol -> svalue);
        free (symbol);
        return (OZ_BADPARAM);
      }
      break;
    }
  }

  free (symbol);
  return (OZ_SUCCESS);
}

/************************************************************************/
/*									*/
/*  Evaluate string expression						*/
/*									*/
/*    Input:								*/
/*									*/
/*	inbuf = start of expression string				*/
/*	termch = expected termination char (or 0 to not check)		*/
/*									*/
/*    Output:								*/
/*									*/
/*	eval_string = OZ_SUCCESS : successful evaluation		*/
/*	                    else : error status				*/
/*	*inbuf_r = points after termination character in string		*/
/*	*outbuf_r = points to null terminated malloc'd result		*/
/*	            (caller must free string when done)			*/
/*									*/
/************************************************************************/

static uLong eval_string (char *inbuf, char **inbuf_r, char **outbuf_r, char termch)

{
  uLong sts;
  Symbol *symbol;

  sts = evaluate (inbuf, inbuf_r, &symbol, termch);
  if (sts == OZ_SUCCESS) {
    *outbuf_r = cvt_sym_to_str (symbol);
    free (symbol);
  }

  return (sts);
}

/************************************************************************/
/*									*/
/*  Evaluate expression and determine its type				*/
/*									*/
/*    Input:								*/
/*									*/
/*	inbuf = start of expression string				*/
/*	termch = expected termination char (or 0 to not check)		*/
/*									*/
/*    Output:								*/
/*									*/
/*	evaluate = OZ_SUCCESS : successful evaluation			*/
/*	                 else : error status				*/
/*	*inbuf_r = points after termination character in string		*/
/*	*symbol_r = points to malloc'd temp symbol-like block		*/
/*	            caller must free it when done with it		*/
/*									*/
/************************************************************************/

static uLong evaluate (char *inbuf, char **inbuf_r, Symbol **symbol_r, char termch)

{
  char *p, *q;
  int cmpstr;
  uLong ivalue, sts;
  Optype optype;
  Symbol *lsymbol, *rsymbol;

  *symbol_r = NULL;

  sts = get_operand (inbuf, &inbuf, &lsymbol);				/* get left-hand operand */
  if (sts != OZ_SUCCESS) return (sts);

get_op:
  optype = get_operator (inbuf, &inbuf);				/* get operator */

  if (optype == OPTYPE_UNKNOWN) {
    if (termch != 0) {							/* maybe check termination character */
      if (*inbuf != termch) {
        oz_sys_io_fs_printf (h_s_error, "oz_cli: bad expression terminator at %s, expected %c\n", inbuf, termch);
        return (OZ_BADPARAM);
      }
      inbuf ++;								/* skip over terminator */
      while ((*inbuf != 0) && (*inbuf <= ' ')) inbuf ++;		/* skip trailing spaces */
    }

    *inbuf_r = inbuf;							/* return pointer to terminating character */
    *symbol_r = lsymbol;
    return (OZ_SUCCESS);
  }

  sts = get_operand (inbuf, &inbuf, &rsymbol);				/* get right-hand operand */
  if (sts != OZ_SUCCESS) return (sts);

  switch (optype) {

    case OPTYPE_ADD: {
      if ((lsymbol -> symtype == SYMTYPE_INTEGER) && (rsymbol -> symtype == SYMTYPE_INTEGER)) {
        lsymbol -> ivalue += rsymbol -> ivalue;
      } else {
        p = cvt_sym_to_str (lsymbol);
        q = cvt_sym_to_str (rsymbol);
        free (lsymbol);
        ivalue = strlen (p) + strlen (q);
        lsymbol = malloc (ivalue + 1 + sizeof *lsymbol);
        lsymbol -> symtype = SYMTYPE_STRING;
        strcpy (lsymbol -> svalue, p);
        strcat (lsymbol -> svalue, q);
        free (p);
        free (q);
      }
      goto free_rsym;
    }

    case OPTYPE_BITAND: {
      if ((lsymbol -> symtype == SYMTYPE_INTEGER) && (rsymbol -> symtype == SYMTYPE_INTEGER)) {
        lsymbol -> ivalue &= rsymbol -> ivalue;
        goto free_rsym;
      }
      oz_sys_io_fs_printf (h_s_error, "oz_cli: can only perform AND between two integers\n");
      return (OZ_BADPARAM);
    }

    case OPTYPE_BITOR: {
      if ((lsymbol -> symtype == SYMTYPE_INTEGER) && (rsymbol -> symtype == SYMTYPE_INTEGER)) {
        lsymbol -> ivalue |= rsymbol -> ivalue;
        goto free_rsym;
      }
      oz_sys_io_fs_printf (h_s_error, "oz_cli: can only perform OR between two integers\n");
      return (OZ_BADPARAM);
    }

    case OPTYPE_BITXOR: {
      if ((lsymbol -> symtype == SYMTYPE_INTEGER) && (rsymbol -> symtype == SYMTYPE_INTEGER)) {
        lsymbol -> ivalue ^= rsymbol -> ivalue;
        goto free_rsym;
      }
      oz_sys_io_fs_printf (h_s_error, "oz_cli: can only perform XOR between two integers\n");
      return (OZ_BADPARAM);
    }

    case OPTYPE_BOOLAND: {
      if ((lsymbol -> symtype == SYMTYPE_INTEGER) && (rsymbol -> symtype == SYMTYPE_INTEGER)) {
        lsymbol -> ivalue = (lsymbol -> ivalue && rsymbol -> ivalue);
        goto free_rsym;
      }
      oz_sys_io_fs_printf (h_s_error, "oz_cli: can only perform AND between two integers\n");
      return (OZ_BADPARAM);
    }

    case OPTYPE_BOOLOR: {
      if ((lsymbol -> symtype == SYMTYPE_INTEGER) && (rsymbol -> symtype == SYMTYPE_INTEGER)) {
        lsymbol -> ivalue = (lsymbol -> ivalue || rsymbol -> ivalue);
        goto free_rsym;
      }
      oz_sys_io_fs_printf (h_s_error, "oz_cli: can only perform OR between two integers\n");
      return (OZ_BADPARAM);
    }

    case OPTYPE_BOOLXOR: {
      if ((lsymbol -> symtype == SYMTYPE_INTEGER) && (rsymbol -> symtype == SYMTYPE_INTEGER)) {
        lsymbol -> ivalue = ((lsymbol -> ivalue != 0) ^ (rsymbol -> ivalue != 0));
        goto free_rsym;
      }
      oz_sys_io_fs_printf (h_s_error, "oz_cli: can only perform XOR between two integers\n");
      return (OZ_BADPARAM);
    }

    case OPTYPE_DIVIDE: {
      if ((lsymbol -> symtype == SYMTYPE_INTEGER) && (rsymbol -> symtype == SYMTYPE_INTEGER)) {
        lsymbol -> ivalue /= rsymbol -> ivalue;
        goto free_rsym;
      }
      oz_sys_io_fs_printf (h_s_error, "oz_cli: can only perform DIVIDE between two integers\n");
      return (OZ_BADPARAM);
    }

    case OPTYPE_EQ: { ivalue = 1; goto compare; }
    case OPTYPE_GT: { ivalue = 2; goto compare; }
    case OPTYPE_GE: { ivalue = 3; goto compare; }
    case OPTYPE_LT: { ivalue = 4; goto compare; }
    case OPTYPE_LE: { ivalue = 5; goto compare; }
    case OPTYPE_NE: { ivalue = 6; goto compare; }

    case OPTYPE_MODULUS: {
      if ((lsymbol -> symtype == SYMTYPE_INTEGER) && (rsymbol -> symtype == SYMTYPE_INTEGER)) {
        lsymbol -> ivalue %= rsymbol -> ivalue;
        goto free_rsym;
      }
      oz_sys_io_fs_printf (h_s_error, "oz_cli: can only perform MODULUS between two integers\n");
      return (OZ_BADPARAM);
    }

    case OPTYPE_MULTIPLY: {
      if ((lsymbol -> symtype == SYMTYPE_INTEGER) && (rsymbol -> symtype == SYMTYPE_INTEGER)) {
        lsymbol -> ivalue *= rsymbol -> ivalue;
        goto free_rsym;
      }
      oz_sys_io_fs_printf (h_s_error, "oz_cli: can only perform MULTIPLY between two integers\n");
      return (OZ_BADPARAM);
    }

    case OPTYPE_SHLEFT: {
      if ((lsymbol -> symtype == SYMTYPE_INTEGER) && (rsymbol -> symtype == SYMTYPE_INTEGER)) {
        lsymbol -> ivalue <<= rsymbol -> ivalue;
        goto free_rsym;
      }
      oz_sys_io_fs_printf (h_s_error, "oz_cli: can only perform SHIFT between two integers\n");
      return (OZ_BADPARAM);
    }

    case OPTYPE_SHRIGHT: {
      if ((lsymbol -> symtype == SYMTYPE_INTEGER) && (rsymbol -> symtype == SYMTYPE_INTEGER)) {
        lsymbol -> ivalue >>= rsymbol -> ivalue;
        goto free_rsym;
      }
      oz_sys_io_fs_printf (h_s_error, "oz_cli: can only perform SHIFT between two integers\n");
      return (OZ_BADPARAM);
    }

    case OPTYPE_SUBTRACT: {
      if ((lsymbol -> symtype == SYMTYPE_INTEGER) && (rsymbol -> symtype == SYMTYPE_INTEGER)) {
        lsymbol -> ivalue -= rsymbol -> ivalue;
      } else {
        p = cvt_sym_to_str (lsymbol);
        q = cvt_sym_to_str (rsymbol);
        free (lsymbol);
        lsymbol = malloc (strlen (p) + 1 + sizeof *lsymbol);
        lsymbol -> symtype = SYMTYPE_STRING;
        strcpy (lsymbol -> svalue, p);
        free (p);
        p = strstr (lsymbol -> svalue, q);
        if (p != NULL) {
          ivalue = strlen (q);
          while ((p[0] = p[ivalue]) != 0) p ++;
        }
        free (q);
      }
      goto free_rsym;
    }

  }

  /* Compare operations: ivalue<0> if eq, ivalue<1> if gt, ivalue<2> if lt */

compare:
  if ((lsymbol -> symtype == SYMTYPE_INTEGER) && (rsymbol -> symtype == SYMTYPE_INTEGER)) {
    if (lsymbol -> ivalue > rsymbol -> ivalue) lsymbol -> ivalue = 2;
    else if (lsymbol -> ivalue < rsymbol -> ivalue) lsymbol -> ivalue = 4;
    else lsymbol -> ivalue = 1;
  } else {
    p = cvt_sym_to_str (lsymbol);
    q = cvt_sym_to_str (rsymbol);
    cmpstr = strcmp (p, q);
    free (p);
    free (q);
    if (cmpstr > 0) lsymbol -> ivalue = 2;
    else if (cmpstr < 0) lsymbol -> ivalue = 4;
    else lsymbol -> ivalue = 1;
    lsymbol -> symtype = SYMTYPE_INTEGER;
  }
  lsymbol -> ivalue = ((lsymbol -> ivalue & ivalue) != 0);
free_rsym:
  free (rsymbol);
  goto get_op;
}

/************************************************************************/
/*									*/
/*  Get operand from string and determine its type			*/
/*									*/
/*    Input:								*/
/*									*/
/*	inbuf = pointer to input string					*/
/*									*/
/*    Output:								*/
/*									*/
/*	get_operand = OZ_SUCCESS : successful				*/
/*	                    else : error status				*/
/*	*inbuf_r = pointer to char following operand			*/
/*	*symbol_r = pointer to temporary symbol-like malloc'd struct	*/
/*	            caller must free it when done with it		*/
/*									*/
/************************************************************************/

static uLong get_operand (char *inbuf, char **inbuf_r, Symbol **symbol_r)

{
  char c, d, *p, *q, *svalue;
  int usedup;
  uLong ivalue, sts;
  Symbol *symbol, *xsymbol;

  *symbol_r = NULL;

  for (p = inbuf; (c = *p) != 0; p ++) if (c > ' ') break;		/* skip spaces */

  /* Maybe it's an integer constant (starts with 0..9) */

  if ((c >= '0') && (c <= '9')) {
    symbol = malloc (strlen (p) + sizeof *symbol);			/* allocate symbol block for the integer */
    symbol -> symtype = SYMTYPE_INTEGER;				/* set its type */
    symbol -> ivalue = oz_hw_atoi (p, &usedup);				/* convert the integer string to binary */
    p += usedup;
    goto rtnsym;
  }

  /* Maybe it's a string constant (enclosed in matching ' or ") */

  if ((c == '"') || (c == '\'')) {					/* check for ' or " */
    symbol = malloc (strlen (p) + sizeof *symbol);			/* ok, allocate symbol buffer big enough to hold it */
    symbol -> symtype = SYMTYPE_STRING;					/* say it is of type string */
    q = symbol -> svalue;						/* point to where to put the string */
    while ((d = *(++ p)) != 0) {					/* get next char in input */
      if (d == c) {							/* check for terminating character */
        p ++;								/* if so, point past the terminating character */
        break;								/* ... and all done */
      }
      if (d == '\\') {							/* check for escape character */
        d = *(++ p);							/* if so, get the following character */
        if (d == 0) break;						/* ... stop if we hit end of input string */
        if (d == 'b') d = '\b';
        if (d == 'n') d = '\n';
        if (d == 'r') d = '\r';
        if (d == 't') d = '\t';
      }
      *(q ++) = d;							/* store character in output buffer */
    }
    *q = 0;								/* done, null terminate output string */
    goto rtnsym;
  }

  /* Symbols start with _, a-z, A-Z */

  if (SYMBOLSTARTCHAR (c)) {
    for (q = p; (c = *q) != 0; q ++) if (!SYMBOLCHAR (c)) break;	/* scan buffer for end of symbol name string */
    *q = 0;								/* null terminate symbol name */
    xsymbol = lookup_symbol (p, 0, NULL);				/* look it up wherever it can be found */
    if (xsymbol == NULL) {
      oz_sys_io_fs_printf (h_s_error, "oz_cli: undefined symbol %s\n", p);
      *q = c;
      return (OZ_UNDEFSYMBOL);
    }
    *q = c;								/* restore terminating character */
    p = q;								/* found, point just past symbol name */

    switch (xsymbol -> symtype) {					/* copy the value to a new temp symbol */

      /* Integer variable */

      case SYMTYPE_INTEGER: {
        if (xsymbol -> func != NULL) {					/* see if it's a function name */
          sts = (*(xsymbol -> func)) (xsymbol, p, &p, &ivalue);		/* if so, execute function */
          if (sts != OZ_SUCCESS) return (sts);				/* abort if error executing function */
        } else {
          ivalue = xsymbol -> ivalue;					/* simple variable, get the value */
        }
        symbol = malloc (sizeof *symbol);				/* put value in a temp symbol block */
        symbol -> symtype = SYMTYPE_INTEGER;
        symbol -> ivalue = ivalue;
        goto rtnsym;
      }

      /* String variable */

      case SYMTYPE_STRING: {
        if (xsymbol -> func != NULL) {					/* see if it's a function name */
          sts = (*(xsymbol -> func)) (xsymbol, p, &p, &svalue);		/* if so, execute function */
          if (sts != OZ_SUCCESS) return (sts);				/* abort if error executing function */
          symbol = malloc (strlen (svalue) + 1 + sizeof *symbol);	/* copy to temp symbol block */
          symbol -> symtype = SYMTYPE_STRING;
          strcpy (symbol -> svalue, svalue);
          free (svalue);
        } else {
          symbol = malloc (strlen (xsymbol -> svalue) + 1 + sizeof *symbol); /* simple variable, copy to temp symbol block */
          symbol -> symtype = SYMTYPE_STRING;
          strcpy (symbol -> svalue, xsymbol -> svalue);
        }
        goto rtnsym;
      }
    }
  }

  /* Maybe it's (<expression>) */

  if (c == '(') return (evaluate (++ p, inbuf_r, symbol_r, ')'));

  oz_sys_io_fs_printf (h_s_error, "oz_cli: invalid operand %s\n", p);
  return (OZ_BADPARAM);

rtnsym:
  *symbol_r = symbol;							/* return pointer to symbol block */
  while (((c = *p) != 0) && (c <= ' ')) p ++;				/* skip following spaces */
  *inbuf_r = p;								/* return pointer to next thing in input */
  return (OZ_SUCCESS);							/* successful */
}

/************************************************************************/
/*									*/
/*  Get operator from input string					*/
/*									*/
/*    Input:								*/
/*									*/
/*	inbuf = pointer to input string					*/
/*									*/
/*    Output:								*/
/*									*/
/*	get_operator = operator type					*/
/*	*inbuf_r = pointer to char following operator			*/
/*									*/
/************************************************************************/

static Optype get_operator (char *inbuf, char **inbuf_r)

{
  char c, *p;
  int i;
  const Operator *operator;

  for (p = inbuf; (c = *p) != 0; p ++) if (c > ' ') break;			/* skip spaces */

  for (operator = operators; operator -> opname != NULL; operator ++) {		/* loop through operator table */
    for (i = 0; operator -> opname[i] == p[i]; i ++) if (p[i] == 0) break;	/* see if the name matches */
    if (operator -> opname[i] == 0) {
      p += i;									/* matches, increment past the string */
      while (((c = *p) != 0) && (c <= ' ')) p ++;				/* skip spaces */
      *inbuf_r = p;
      return (operator -> optype);
    }
  }

  return (OPTYPE_UNKNOWN);
}

/************************************************************************/
/*									*/
/*  Convert symbol to string						*/
/*									*/
/*    Input:								*/
/*									*/
/*	symbol = pointer to symbol block				*/
/*									*/
/*    Output:								*/
/*									*/
/*	cvt_sym_to_str = malloc'd string				*/
/*	                 caller must free it when done with it		*/
/*									*/
/************************************************************************/

static char *cvt_sym_to_str (Symbol *symbol)

{
  char *p;

  switch (symbol -> symtype) {
    case SYMTYPE_INTEGER: {
      p = malloc (32);
      oz_hw_itoa (symbol -> ivalue, 32, p);
      return (p);
    }
    case SYMTYPE_STRING: {
      p = malloc (strlen (symbol -> svalue) + 1);
      strcpy (p, symbol -> svalue);
      return (p);
    }
  }

  return (NULL);
}

/************************************************************************/
/*									*/
/*  All internal symbol functions:					*/
/*									*/
/*    Input:								*/
/*									*/
/*	symbol = pointer to symbol that defines function		*/
/*	strp = pointer to input string just past function name		*/
/*									*/
/*    Output:								*/
/*									*/
/*	func = OZ_SUCCESS : successful evaluation			*/
/*	             else : evaluation error				*/
/*	*valuep = resultant value					*/
/*									*/
/*    Note:								*/
/*									*/
/*	For SYMTYPE_INTEGER, valuep points to a uLong			*/
/*	For SYMTYPE_STRING, valuep points to a char * that is malloc'd 	*/
/*	                    by these functions				*/
/*									*/
/************************************************************************/

/************************************************************************/
/*									*/
/*  Collapse out all whitespace						*/
/*									*/
/*	collapsed = oz_collapse (string)				*/
/*									*/
/************************************************************************/

static uLong func_collapse (Symbol *symbol, char *strp, char **rtnp, void *valuep)

{
  char c, *p, *q, *string;
  uLong sts;

  while ((*strp != 0) && (*strp <= ' ')) strp ++;			/* skip spaces */
  if (*(strp ++) != '(') {						/* make sure it starts with an open paren and skip it */
    oz_sys_io_fs_printf (h_s_error, "oz_cli: missing ( following %s at %s\n", symbol -> name, -- strp);
    return (OZ_MISSINGPARAM);
  }
  sts = eval_string (strp, rtnp, &string, ')');				/* evaluate the string expression */
  if (sts == OZ_SUCCESS) {
    q = string;								/* overwrite input with output */
    for (p = string; (c = *p) != 0; p ++) {				/* scan through input string */
      if (c > ' ') *(q ++) = c;						/* ... and output the printable chars */
    }
    *q = 0;								/* null terminate output string */
    *((char **)valuep) = string;					/* return pointer to string buffer */
  }
  return (sts);
}

/************************************************************************/
/*									*/
/*  Compress out redundant whitespace					*/
/*									*/
/*	compressed = oz_compress (string)				*/
/*									*/
/************************************************************************/

static uLong func_compress (Symbol *symbol, char *strp, char **rtnp, void *valuep)

{
  char c, *p, *q, *string;
  int s;
  uLong sts;

  while ((*strp != 0) && (*strp <= ' ')) strp ++;			/* skip spaces */
  if (*(strp ++) != '(') {						/* make sure it starts with an open paren and skip it */
    oz_sys_io_fs_printf (h_s_error, "oz_cli: missing ( following %s at %s\n", symbol -> name, -- strp);
    return (OZ_MISSINGPARAM);
  }
  sts = eval_string (strp, rtnp, &string, ')');				/* evaluate the string expression */
  if (sts == OZ_SUCCESS) {
    s = 0;								/* we're not skipping spaces yet */
    q = string;								/* overwrite input with output */
    for (p = string; (c = *p) != 0; p ++) {				/* scan through input string */
      if (c > ' ') {							/* check for printable char */
        s = 0;								/* if so, don't skip the first space that follows it */
        *(q ++) = c;							/* ... and output the printable char */
      } else if (!s) {							/* nonprintable, see if redundant */
        s = 1;								/* not redundant, next one would be */
        *(q ++) = ' ';							/* ... and output a space */
      }
    }
    *q = 0;								/* null terminate output string */
    *((char **)valuep) = string;					/* return pointer to string buffer */
  }
  return (sts);
}

/************************************************************************/
/*									*/
/*  Add two date strings						*/
/*									*/
/*	sum = oz_date_add (date1, date2)				*/
/*									*/
/************************************************************************/

static uLong func_date_add (Symbol *symbol, char *strp, char **rtnp, void *valuep)

{
  char *svalue1, *svalue2;
  int rc1, rc2;
  uLong sts;
  OZ_Datebin date1, date2, now;

  while ((*strp != 0) && (*strp <= ' ')) strp ++;
  if (*(strp ++) != '(') {
    oz_sys_io_fs_printf (h_s_error, "oz_cli: missing ( following %s at %s\n", symbol -> name, -- strp);
    return (OZ_MISSINGPARAM);
  }
  sts = eval_string (strp, &strp, &svalue1, ',');
  if (sts != OZ_SUCCESS) return (sts);
  sts = eval_string (strp, &strp, &svalue2, ')');
  if (sts != OZ_SUCCESS) {
    free (svalue1);
    return (sts);
  }
  now = oz_hw_tod_getnow ();
  now = oz_sys_datebin_tzconv (now, OZ_DATEBIN_TZCONV_UTC2LCL, 0);
  rc1 = oz_sys_datebin_encstr2 (strlen (svalue1), svalue1, &date1, now);
  rc2 = oz_sys_datebin_encstr2 (strlen (svalue2), svalue2, &date2, now);
  if (rc1 == 0) {
    oz_sys_io_fs_printf (h_s_error, "oz_cli: bad date string %s\n", svalue1);
    free (svalue1);
    free (svalue2);
    return (OZ_BADPARAM);
  }
  if (rc2 == 0) {
    oz_sys_io_fs_printf (h_s_error, "oz_cli: bad date string %s\n", svalue2);
    free (svalue1);
    free (svalue2);
    return (OZ_BADPARAM);
  }
  if ((rc1 > 0) && (rc2 > 0)) {
    oz_sys_io_fs_printf (h_s_error, "oz_cli: cannot add two absolute dates %s and %s\n", svalue1, svalue2);
    free (svalue1);
    free (svalue2);
    return (OZ_BADPARAM);
  }
  *rtnp = strp;
  free (svalue1);
  free (svalue2);
  OZ_HW_DATEBIN_ADD (date1, date1, date2);
  svalue1 = malloc (32);
  rc1 = (rc1 < 0) && (rc2 < 0);
  oz_sys_datebin_decstr (rc1, date1, 32, svalue1);
  *((char **)valuep) = svalue1;
  return (OZ_SUCCESS);
}

/************************************************************************/
/*									*/
/*  Get day-of-week string						*/
/*									*/
/*	dayofweek = oz_date_dow (date)					*/
/*									*/
/************************************************************************/

static const char *const daysofweek[7] = { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" };

static uLong func_date_dow (Symbol *symbol, char *strp, char **rtnp, void *valuep)

{
  char *svalue;
  int rc;
  uLong datelongs[OZ_DATELONG_ELEMENTS], sts;
  OZ_Datebin date, now;

  while ((*strp != 0) && (*strp <= ' ')) strp ++;
  if (*(strp ++) != '(') {
    oz_sys_io_fs_printf (h_s_error, "oz_cli: missing ( following %s at %s\n", symbol -> name, -- strp);
    return (OZ_MISSINGPARAM);
  }
  sts = eval_string (strp, &strp, &svalue, ')');
  if (sts != OZ_SUCCESS) return (sts);
  now = oz_hw_tod_getnow ();
  now = oz_sys_datebin_tzconv (now, OZ_DATEBIN_TZCONV_UTC2LCL, 0);
  rc  = oz_sys_datebin_encstr2 (strlen (svalue), svalue, &date, now);
  if (rc <= 0) {
    oz_sys_io_fs_printf (h_s_error, "oz_cli: bad date string %s\n", svalue);
    free (svalue);
    return (OZ_BADPARAM);
  }
  *rtnp  = strp;
  svalue = realloc (svalue, 12);
  oz_sys_datebin_decode (date, datelongs);
  strcpy (svalue, daysofweek[oz_sys_daynumber_weekday(datelongs[OZ_DATELONG_DAYNUMBER])]);
  *((char **)valuep) = svalue;
  return (OZ_SUCCESS);
}

/************************************************************************/
/*									*/
/*  Get current datetime						*/
/*									*/
/*	now = oz_date_now						*/
/*									*/
/************************************************************************/

static uLong func_date_now (Symbol *symbol, char *strp, char **rtnp, void *valuep)

{
  char *dates;
  OZ_Datebin dateb;

  *rtnp = strp;
  dateb = oz_hw_tod_getnow ();
  dateb = oz_sys_datebin_tzconv (dateb, OZ_DATEBIN_TZCONV_UTC2LCL, 0);
  dates = malloc (32);
  oz_sys_datebin_decstr (0, dateb, 32, dates);
  *((char **)valuep) = dates;
  return (OZ_SUCCESS);
}

/************************************************************************/
/*									*/
/*  Subtract two date strings						*/
/*									*/
/*	diff = oz_date_sub (date1, date2)				*/
/*									*/
/************************************************************************/

static uLong func_date_sub (Symbol *symbol, char *strp, char **rtnp, void *valuep)

{
  char *svalue1, *svalue2;
  int rc1, rc2;
  uLong sts;
  OZ_Datebin date1, date2, now;

  while ((*strp != 0) && (*strp <= ' ')) strp ++;
  if (*(strp ++) != '(') {
    oz_sys_io_fs_printf (h_s_error, "oz_cli: missing ( following %s at %s\n", symbol -> name, -- strp);
    return (OZ_MISSINGPARAM);
  }
  sts = eval_string (strp, &strp, &svalue1, ',');
  if (sts != OZ_SUCCESS) return (sts);
  sts = eval_string (strp, &strp, &svalue2, ')');
  if (sts != OZ_SUCCESS) {
    free (svalue1);
    return (sts);
  }
  now = oz_hw_tod_getnow ();
  now = oz_sys_datebin_tzconv (now, OZ_DATEBIN_TZCONV_UTC2LCL, 0);
  rc1 = oz_sys_datebin_encstr2 (strlen (svalue1), svalue1, &date1, now);
  rc2 = oz_sys_datebin_encstr2 (strlen (svalue2), svalue2, &date2, now);
  if (rc1 == 0) {
    oz_sys_io_fs_printf (h_s_error, "oz_cli: bad date string %s\n", svalue1);
    free (svalue1);
    free (svalue2);
    return (OZ_BADPARAM);
  }
  if (rc2 == 0) {
    oz_sys_io_fs_printf (h_s_error, "oz_cli: bad date string %s\n", svalue2);
    free (svalue1);
    free (svalue2);
    return (OZ_BADPARAM);
  }
  if ((rc1 < 0) && (rc2 > 0)) {
    oz_sys_io_fs_printf (h_s_error, "oz_cli: cannot subtract absolute date %s from delta date %s\n", svalue2, svalue1);
    free (svalue1);
    free (svalue2);
    return (OZ_BADPARAM);
  }
  *rtnp = strp;
  free (svalue1);
  free (svalue2);
  OZ_HW_DATEBIN_SUB (date1, date1, date2);
  svalue1 = malloc (32);
  rc1 = (rc1 < 0) || (rc2 > 0);
  oz_sys_datebin_decstr (rc1, date1, 32, svalue1);
  *((char **)valuep) = svalue1;
  return (OZ_SUCCESS);
}

/************************************************************************/
/*									*/
/*  Timezone conversion							*/
/*									*/
/*	date = oz_date_tzconv (date, conv)				*/
/*									*/
/************************************************************************/

static uLong func_date_tzconv (Symbol *symbol, char *strp, char **rtnp, void *valuep)

{
  char *svalue1, *svalue2;
  int lcltoutc, rc1;
  uLong sts;
  OZ_Datebin date1, now;

  while ((*strp != 0) && (*strp <= ' ')) strp ++;
  if (*(strp ++) != '(') {
    oz_sys_io_fs_printf (h_s_error, "oz_cli: missing ( following %s at %s\n", symbol -> name, -- strp);
    return (OZ_MISSINGPARAM);
  }
  sts = eval_string (strp, &strp, &svalue1, ',');
  if (sts != OZ_SUCCESS) return (sts);
  sts = eval_string (strp, &strp, &svalue2, ')');
  if (sts != OZ_SUCCESS) {
    free (svalue1);
    return (sts);
  }
  lcltoutc = -1;
  if (strcasecmp (svalue2, "utctolcl") == 0) lcltoutc = 0;
  if (strcasecmp (svalue2, "lcltoutc") == 0) lcltoutc = 1;
  if (lcltoutc < 0) {
    oz_sys_io_fs_printf (h_s_error, "oz_cli: bad conversion type %s ('lcltoutc' or 'utctolcl')\n", svalue2);
    free (svalue1);
    free (svalue2);
    return (OZ_BADPARAM);
  }
  now = 0;					// for 'lcltoutc', things like 'now' or 'today' don't make sense
  if (!lcltoutc) now = oz_hw_tod_getnow ();	// for 'utctolcl', they do sort of
  rc1 = oz_sys_datebin_encstr2 (strlen (svalue1), svalue1, &date1, now);
  if (rc1 <= 0) {
    oz_sys_io_fs_printf (h_s_error, "oz_cli: bad absolute date string %s\n", svalue1);
    free (svalue1);
    free (svalue2);
    return (OZ_BADPARAM);
  }
  *rtnp = strp;
  free (svalue1);
  free (svalue2);
  date1 = oz_sys_datebin_tzconv (date1, lcltoutc ? OZ_DATEBIN_TZCONV_LCL2UTC : OZ_DATEBIN_TZCONV_UTC2LCL, 0);
  svalue1 = malloc (32);
  oz_sys_datebin_decstr (0, date1, 32, svalue1);
  *((char **)valuep) = svalue1;
  return (OZ_SUCCESS);
}

/************************************************************************/
/*									*/
/*  Extract a field							*/
/*									*/
/*	field = oz_field (index, separator, string)			*/
/*									*/
/************************************************************************/

static uLong func_field (Symbol *symbol, char *strp, char **rtnp, void *valuep)

{
  char *p, *q, *separator, *string;
  int l;
  uLong index, sts;

  while ((*strp != 0) && (*strp <= ' ')) strp ++;
  if (*(strp ++) != '(') {
    oz_sys_io_fs_printf (h_s_error, "oz_cli: missing ( following %s at %s\n", symbol -> name, -- strp);
    return (OZ_MISSINGPARAM);
  }
  sts = eval_integer (strp, &strp, &index, ',');
  if (sts != OZ_SUCCESS) return (sts);
  sts = eval_string (strp, &strp, &separator, ',');
  if (sts != OZ_SUCCESS) return (sts);
  sts = eval_string (strp, &strp, &string, ')');
  if (sts != OZ_SUCCESS) {
    free (separator);
    return (sts);
  }
  *rtnp = strp;

  l = strlen (separator);
  for (p = string; (q = strstr (p, separator)) != NULL; p = q + l) {
    if (index == 0) break;
    -- index;
  }
  if (index != 0) {
    free (string);
    *((char **)valuep) = separator;
  } else {
    free (separator);
    *((char **)valuep) = string;
    l = q - p;
    if (q == NULL) l = strlen (p);
    memmove (string, p, l);
    string[l] = 0;
  }
  return (OZ_SUCCESS);
}

/************************************************************************/
/*									*/
/*  Increment / Set event flag value					*/
/*									*/
/*	oz_event_inc/set (handle, value)				*/
/*									*/
/************************************************************************/

static uLong event_incset (uLong (*incset) (OZ_Procmode procmode, OZ_Handle h_event, Long inc, Long *value_r), 
                           Symbol *symbol, char *strp, char **rtnp, void *valuep);

static uLong func_event_inc (Symbol *symbol, char *strp, char **rtnp, void *valuep)

{
  return (event_incset (oz_sys_event_inc, symbol, strp, rtnp, valuep));
}

static uLong func_event_set (Symbol *symbol, char *strp, char **rtnp, void *valuep)

{
  return (event_incset (oz_sys_event_set, symbol, strp, rtnp, valuep));
}

static uLong event_incset (uLong (*incset) (OZ_Procmode procmode, OZ_Handle h_event, Long inc, Long *value_r), 
                           Symbol *symbol, char *strp, char **rtnp, void *valuep)

{
  Long value;
  uLong sts;
  OZ_Handle handle;

  while ((*strp != 0) && (*strp <= ' ')) strp ++;				/* skip spaces */
  if (*(strp ++) != '(') {							/* make sure it starts with an open paren and skip it */
    oz_sys_io_fs_printf (h_s_error, "oz_cli: missing ( following %s at %s\n", symbol -> name, -- strp);
    return (OZ_MISSINGPARAM);
  }
  sts = eval_handle (strp, &strp, &handle, "", ',');				/* get the handle */
  if (sts != OZ_SUCCESS) return (sts);						/* return error status if any failure */
  sts = eval_integer (strp, &strp, &value, ')');				/* get the item string */
  if (sts != OZ_SUCCESS) return (sts);						/* return error status if any failure */
  *rtnp = strp;									/* return pointer just past the ) */
  sts = (*incset) (OZ_PROCMODE_KNL, handle, value, valuep);			/* increment or set the event flag */
  if (sts != OZ_SUCCESS) oz_sys_io_fs_printf (h_s_error, "oz_cli: error %u performing %s\n", sts, symbol -> name);
  return (sts);									/* return status */
}

/************************************************************************/
/*									*/
/*  Get handle info							*/
/*									*/
/*	string = oz_h_info (handle, item)				*/
/*									*/
/************************************************************************/

typedef enum { HINFO_OBJTYPE, HINFO_HANDLE, HINFO_LONG, HINFO_ULONG, HINFO_STRING, HINFO_THREADSTATE, HINFO_DATEBINDEL, HINFO_DATEBINABS, HINFO_LOCKMODE } Hinfo;

static const struct {
	const char *name;       OZ_Handle_code code;                 uLong size;                Hinfo conv; } hinfotbl[] = {
	"objtype",              OZ_HANDLE_CODE_OBJTYPE,              sizeof (OZ_Objtype),       HINFO_OBJTYPE, 
	"user_handle",          OZ_HANDLE_CODE_USER_HANDLE,          sizeof (OZ_Handle),        HINFO_HANDLE, 
	"user_refcount",        OZ_HANDLE_CODE_USER_REFCOUNT,        sizeof (Long),             HINFO_LONG, 
	"user_lognamdir",       OZ_HANDLE_CODE_USER_LOGNAMDIR,       sizeof (OZ_Handle),        HINFO_HANDLE, 
	"user_lognamtbl",       OZ_HANDLE_CODE_USER_LOGNAMTBL,       sizeof (OZ_Handle),        HINFO_HANDLE, 
	"user_name",            OZ_HANDLE_CODE_USER_NAME,            OZ_USERNAME_MAX,           HINFO_STRING, 
	"user_first",           OZ_HANDLE_CODE_USER_FIRST,           sizeof (OZ_Handle),        HINFO_HANDLE, 
	"user_next",            OZ_HANDLE_CODE_USER_NEXT,            sizeof (OZ_Handle),        HINFO_HANDLE, 
	"job_handle",           OZ_HANDLE_CODE_JOB_HANDLE,           sizeof (OZ_Handle),        HINFO_HANDLE, 
	"job_name",             OZ_HANDLE_CODE_JOB_NAME,             OZ_JOBNAME_MAX,            HINFO_STRING, 
	"job_refcount",         OZ_HANDLE_CODE_JOB_REFCOUNT,         sizeof (Long),             HINFO_LONG, 
	"job_lognamdir",        OZ_HANDLE_CODE_JOB_LOGNAMDIR,        sizeof (OZ_Handle),        HINFO_HANDLE, 
	"job_lognamtbl",        OZ_HANDLE_CODE_JOB_LOGNAMTBL,        sizeof (OZ_Handle),        HINFO_HANDLE, 
	"job_processcount",     OZ_HANDLE_CODE_JOB_PROCESSCOUNT,     sizeof (uLong),            HINFO_ULONG, 
	"job_first",            OZ_HANDLE_CODE_JOB_FIRST,            sizeof (OZ_Handle),        HINFO_HANDLE, 
	"job_next",             OZ_HANDLE_CODE_JOB_NEXT,             sizeof (OZ_Handle),        HINFO_HANDLE, 
	"process_handle",       OZ_HANDLE_CODE_PROCESS_HANDLE,       sizeof (OZ_Handle),        HINFO_HANDLE, 
	"process_refcount",     OZ_HANDLE_CODE_PROCESS_REFCOUNT,     sizeof (Long),             HINFO_LONG, 
	"process_name",         OZ_HANDLE_CODE_PROCESS_NAME,         OZ_PROCESS_NAMESIZE,       HINFO_STRING, 
	"process_id",           OZ_HANDLE_CODE_PROCESS_ID,           sizeof (OZ_Processid),     HINFO_ULONG, 
	"process_lognamdir",    OZ_HANDLE_CODE_PROCESS_LOGNAMDIR,    sizeof (OZ_Handle),        HINFO_HANDLE, 
	"process_lognamtbl",    OZ_HANDLE_CODE_PROCESS_LOGNAMTBL,    sizeof (OZ_Handle),        HINFO_HANDLE, 
	"process_threadcount",  OZ_HANDLE_CODE_PROCESS_THREADCOUNT,  sizeof (uLong),            HINFO_LONG, 
	"process_first",        OZ_HANDLE_CODE_PROCESS_FIRST,        sizeof (OZ_Handle),        HINFO_HANDLE, 
	"process_next",         OZ_HANDLE_CODE_PROCESS_NEXT,         sizeof (OZ_Handle),        HINFO_HANDLE, 
	"thread_handle",        OZ_HANDLE_CODE_THREAD_HANDLE,        sizeof (OZ_Handle),        HINFO_HANDLE, 
	"thread_refcount",      OZ_HANDLE_CODE_THREAD_REFCOUNT,      sizeof (Long),             HINFO_LONG, 
	"thread_state",         OZ_HANDLE_CODE_THREAD_STATE,         sizeof (OZ_Thread_state),  HINFO_THREADSTATE, 
	"thread_tis_run",       OZ_HANDLE_CODE_THREAD_TIS_RUN,       sizeof (OZ_Datebin),       HINFO_DATEBINDEL, 
	"thread_tis_com",       OZ_HANDLE_CODE_THREAD_TIS_COM,       sizeof (OZ_Datebin),       HINFO_DATEBINDEL, 
	"thread_tis_wev",       OZ_HANDLE_CODE_THREAD_TIS_WEV,       sizeof (OZ_Datebin),       HINFO_DATEBINDEL, 
	"thread_tis_zom",       OZ_HANDLE_CODE_THREAD_TIS_ZOM,       sizeof (OZ_Datebin),       HINFO_DATEBINDEL, 
	"thread_tis_ini",       OZ_HANDLE_CODE_THREAD_TIS_INI,       sizeof (OZ_Datebin),       HINFO_DATEBINABS, 
	"thread_exitsts",       OZ_HANDLE_CODE_THREAD_EXITSTS,       sizeof (uLong),            HINFO_ULONG, 
	"thread_exitevent",     OZ_HANDLE_CODE_THREAD_EXITEVENT,     sizeof (OZ_Handle),        HINFO_HANDLE, 
	"thread_name",          OZ_HANDLE_CODE_THREAD_NAME,          OZ_THREAD_NAMESIZE,        HINFO_STRING, 
	"thread_id",            OZ_HANDLE_CODE_THREAD_ID,            sizeof (OZ_Threadid),      HINFO_ULONG, 
	"thread_first",         OZ_HANDLE_CODE_THREAD_FIRST,         sizeof (OZ_Handle),        HINFO_HANDLE, 
	"thread_next",          OZ_HANDLE_CODE_THREAD_NEXT,          sizeof (OZ_Handle),        HINFO_HANDLE, 
	"device_handle",        OZ_HANDLE_CODE_DEVICE_HANDLE,        sizeof (OZ_Handle),        HINFO_HANDLE, 
	"device_refcount",      OZ_HANDLE_CODE_DEVICE_REFCOUNT,      sizeof (Long),             HINFO_LONG, 
	"device_iochancount",   OZ_HANDLE_CODE_DEVICE_IOCHANCOUNT,   sizeof (uLong),            HINFO_ULONG, 
	"device_first",         OZ_HANDLE_CODE_DEVICE_FIRST,         sizeof (OZ_Handle),        HINFO_HANDLE, 
	"device_next",          OZ_HANDLE_CODE_DEVICE_NEXT,          sizeof (OZ_Handle),        HINFO_HANDLE, 
	"device_unitname",      OZ_HANDLE_CODE_DEVICE_UNITNAME,      OZ_DEVUNIT_NAMESIZE,       HINFO_STRING, 
	"device_classname",     OZ_HANDLE_CODE_DEVICE_CLASSNAME,     OZ_DEVCLASS_NAMESIZE,      HINFO_STRING, 
	"device_aliasname",     OZ_HANDLE_CODE_DEVICE_ALIASNAME,     OZ_DEVUNIT_ALIASIZE,       HINFO_STRING, 
	"iochan_handle",        OZ_HANDLE_CODE_IOCHAN_HANDLE,        sizeof (OZ_Handle),        HINFO_HANDLE, 
	"iochan_refcount",      OZ_HANDLE_CODE_IOCHAN_REFCOUNT,      sizeof (Long),             HINFO_LONG, 
	"iochan_lockmode",      OZ_HANDLE_CODE_IOCHAN_LOCKMODE,      sizeof (OZ_Lockmode),      HINFO_LOCKMODE, 
	"iochan_first",         OZ_HANDLE_CODE_IOCHAN_FIRST,         sizeof (OZ_Handle),        HINFO_HANDLE, 
	"iochan_next",          OZ_HANDLE_CODE_IOCHAN_NEXT,          sizeof (OZ_Handle),        HINFO_HANDLE, 
	"user_jobcount",        OZ_HANDLE_CODE_USER_JOBCOUNT,        sizeof (uLong),            HINFO_ULONG, 
	"device_unitdesc",      OZ_HANDLE_CODE_DEVICE_UNITDESC,      OZ_DEVUNIT_DESCSIZE,       HINFO_STRING, 
	"system_boottime",      OZ_HANDLE_CODE_SYSTEM_BOOTTIME,      sizeof (OZ_Datebin),       HINFO_DATEBINABS, 
	"system_phypagetotal",  OZ_HANDLE_CODE_SYSTEM_PHYPAGETOTAL,  sizeof (OZ_Mempage),       HINFO_ULONG, 
	"system_phypagefree",   OZ_HANDLE_CODE_SYSTEM_PHYPAGEFREE,   sizeof (OZ_Mempage),       HINFO_ULONG, 
	"system_phypagel2size", OZ_HANDLE_CODE_SYSTEM_PHYPAGEL2SIZE, sizeof (uLong),            HINFO_ULONG, 
	"system_npptotal",      OZ_HANDLE_CODE_SYSTEM_NPPTOTAL,      sizeof (OZ_Memsize),       HINFO_ULONG, 
	"system_nppinuse",      OZ_HANDLE_CODE_SYSTEM_NPPINUSE,      sizeof (OZ_Memsize),       HINFO_ULONG, 
	"system_npppeak",       OZ_HANDLE_CODE_SYSTEM_NPPPEAK,       sizeof (OZ_Memsize),       HINFO_ULONG, 
	"system_pgptotal",      OZ_HANDLE_CODE_SYSTEM_PGPTOTAL,      sizeof (OZ_Memsize),       HINFO_ULONG, 
	"system_pgpinuse",      OZ_HANDLE_CODE_SYSTEM_PGPINUSE,      sizeof (OZ_Memsize),       HINFO_ULONG, 
	"system_pgppeak",       OZ_HANDLE_CODE_SYSTEM_PGPPEAK,       sizeof (OZ_Memsize),       HINFO_ULONG, 
	"system_cpucount",      OZ_HANDLE_CODE_SYSTEM_CPUCOUNT,      sizeof (Long),             HINFO_LONG, 
	"system_cpusavail",     OZ_HANDLE_CODE_SYSTEM_CPUSAVAIL,     sizeof (uLong),            HINFO_ULONG, 
	"system_syspagetotal",  OZ_HANDLE_CODE_SYSTEM_SYSPAGETOTAL,  sizeof (uLong),            HINFO_ULONG, 
	"system_syspagefree",   OZ_HANDLE_CODE_SYSTEM_SYSPAGEFREE,   sizeof (uLong),            HINFO_ULONG, 
	"system_usercount",     OZ_HANDLE_CODE_SYSTEM_USERCOUNT,     sizeof (uLong),            HINFO_ULONG, 
	"system_devicecount",   OZ_HANDLE_CODE_SYSTEM_DEVICECOUNT,   sizeof (uLong),            HINFO_ULONG, 
	"thread_basepri",       OZ_HANDLE_CODE_THREAD_BASEPRI,       sizeof (uLong),            HINFO_ULONG, 
	"thread_curprio",       OZ_HANDLE_CODE_THREAD_CURPRIO,       sizeof (uLong),            HINFO_ULONG, 
	"thread_parent",        OZ_HANDLE_CODE_THREAD_PARENT,        sizeof (OZ_Handle),        HINFO_HANDLE, 
	NULL };

static uLong func_h_info (Symbol *symbol, char *strp, char **rtnp, void *valuep)

{
  char itembuff[256], *item_s, *out;
  int i;
  uLong sts;
  OZ_Handle handle;
  OZ_Handle_item itemlist;
  OZ_Lockmode lockmode;
  OZ_Objtype objtype;
  OZ_Thread_state threadstate;

  /* Parse handle and item arguments */

  while ((*strp != 0) && (*strp <= ' ')) strp ++;				/* skip spaces */
  if (*(strp ++) != '(') {							/* make sure it starts with an open paren and skip it */
    oz_sys_io_fs_printf (h_s_error, "oz_cli: missing ( following %s at %s\n", symbol -> name, -- strp);
    return (OZ_MISSINGPARAM);
  }
  sts = eval_handle (strp, &strp, &handle, "", ',');				/* get the handle */
  if (sts != OZ_SUCCESS) return (sts);						/* return error status if any failure */
  sts = eval_string (strp, &strp, &item_s, ')');				/* get the item string */
  if (sts != OZ_SUCCESS) return (sts);						/* return error status if any failure */
  *rtnp = strp;									/* return pointer just past the ) */

  /* Decode item arg */

  for (i = 0; hinfotbl[i].name != NULL; i ++) {
    if (strcasecmp (hinfotbl[i].name, item_s) == 0) break;
  }
  if (hinfotbl[i].name == NULL) {
    oz_sys_io_fs_printf (h_s_error, "oz_cli: invalid handle item code %s\n", item_s);
    free (item_s);
    return (OZ_BADPARAM);
  }
  free (item_s);

  /* Build item list */

  itemlist.code = hinfotbl[i].code;
  itemlist.size = hinfotbl[i].size;
  itemlist.buff = itembuff;
  itemlist.rlen = NULL;

  if (itemlist.size > sizeof itembuff) oz_crash ("oz_cli: hinfotbl[%d].size is %u", i, itemlist.size);

  /* Get handle info */

  sts = oz_sys_handle_getinfo (handle, 1, &itemlist, NULL);
  if (sts != OZ_SUCCESS) {
    oz_sys_io_fs_printf (h_s_error, "oz_cli: error %u getting handle info\n", sts);
    return (sts);
  }

  /* Produce output string */

  switch (hinfotbl[i].conv) {
    case HINFO_OBJTYPE: {
      objtype = *(OZ_Objtype *)itembuff;
      out = malloc (32);
      strcpy (out, encode_objtype_string (objtype));
      break;
    }
    case HINFO_HANDLE: {
      handle = *(OZ_Handle *)itembuff;
      if (handle == 0) {
        out = malloc (1);
        out[0] = 0;
      } else {
        itemlist.code = OZ_HANDLE_CODE_OBJTYPE;
        itemlist.size = sizeof objtype;
        itemlist.buff = &objtype;
        sts = oz_sys_handle_getinfo (handle, 1, &itemlist, NULL);
        if (sts != OZ_SUCCESS) {
          oz_sys_io_fs_printf (h_s_error, "oz_cli: error %u getting handle info\n", sts);
          return (sts);
        }
        out = malloc (24);
        oz_sys_sprintf (24, out, "%8.8X:%s", handle, encode_objtype_string (objtype));
      }
      break;
    }
    case HINFO_LONG: {
      out = malloc (16);
      oz_sys_sprintf (16, out, "%d", *(Long *)itembuff);
      break;
    }
    case HINFO_STRING: {
      out = malloc (strlen (itembuff) + 1);
      strcpy (out, itembuff);
      break;
    }
    case HINFO_ULONG: {
      out = malloc (16);
      oz_sys_sprintf (16, out, "%u", *(uLong *)itembuff);
      break;
    }
    case HINFO_THREADSTATE: {
      threadstate = *(OZ_Thread_state *)itembuff;
      out = malloc (16);
      switch (threadstate) {
        case OZ_THREAD_STATE_RUN: { strcpy (out, "RUN"); break; }
        case OZ_THREAD_STATE_COM: { strcpy (out, "COM"); break; }
        case OZ_THREAD_STATE_WEV: { strcpy (out, "WEV"); break; }
        case OZ_THREAD_STATE_INI: { strcpy (out, "INI"); break; }
        case OZ_THREAD_STATE_ZOM: { strcpy (out, "ZOM"); break; }
        default: { oz_sys_sprintf (16, out, "%d", threadstate); break; }
      }
      break;
    }
    case HINFO_DATEBINDEL: {
      out = malloc (32);
      oz_sys_datebin_decstr (1, *(OZ_Datebin *)itembuff, 32, out);
      break;
    }
    case HINFO_DATEBINABS: {
      out = malloc (32);
      oz_sys_datebin_decstr (0, *(OZ_Datebin *)itembuff, 32, out);
      break;
    }
    case HINFO_LOCKMODE: {
      lockmode = *(OZ_Lockmode *)itembuff;
      out = malloc (16);
      switch (lockmode) {
        case OZ_LOCKMODE_NL: { strcpy (out, "NL"); break; }
        case OZ_LOCKMODE_CR: { strcpy (out, "CR"); break; }
        case OZ_LOCKMODE_CW: { strcpy (out, "CW"); break; }
        case OZ_LOCKMODE_PR: { strcpy (out, "PR"); break; }
        case OZ_LOCKMODE_PW: { strcpy (out, "PW"); break; }
        case OZ_LOCKMODE_EX: { strcpy (out, "EX"); break; }
        default: { oz_sys_sprintf (16, out, "%d", lockmode); break; }
      }
      break;
    }
  }

  *((char **)valuep) = out;							/* return the substring pointer */
  return (OZ_SUCCESS);								/* successful */
}

/************************************************************************/
/*									*/
/*  Determine length of a string					*/
/*									*/
/*	length = oz_len (string)					*/
/*									*/
/************************************************************************/

static uLong func_len (Symbol *symbol, char *strp, char **rtnp, void *valuep)

{
  char *svalue;
  uLong sts;

  while ((*strp != 0) && (*strp <= ' ')) strp ++;				/* skip spaces */
  if (*(strp ++) != '(') {							/* make sure it starts with an open paren and skip it */
    oz_sys_io_fs_printf (h_s_error, "oz_cli: missing ( following %s at %s\n", symbol -> name, -- strp);
    return (OZ_MISSINGPARAM);
  }
  sts = eval_string (strp, &strp, &svalue, ')');				/* evaluate the string expression */
  if (sts != OZ_SUCCESS) return (sts);						/* return error status if any failure */
  *rtnp = strp;									/* return pointer just past the ) */
  *((uLong *)valuep) = strlen (svalue);						/* return the length of the string */
  free (svalue);								/* free off result malloc'd by eval_string */
  return (OZ_SUCCESS);								/* successful */
}

/************************************************************************/
/*									*/
/*  Get logical name's attributes					*/
/*									*/
/*	attributes = oz_lnm_attrs (h_logical_name, index)		*/
/*									*/
/************************************************************************/

static uLong func_lnm_attrs (Symbol *symbol, char *strp, char **rtnp, void *valuep)

{
  char *out;
  int i;
  uLong index, lognamatr, logvalatr, sts;
  OZ_Handle h_logname;

  while ((*strp != 0) && (*strp <= ' ')) strp ++;
  if (*(strp ++) != '(') {
    oz_sys_io_fs_printf (h_s_error, "oz_cli: missing ( following %s at %s\n", symbol -> name, -- strp);
    return (OZ_MISSINGPARAM);
  }
  sts = eval_handle (strp, &strp, &h_logname, "logname", ',');
  if (sts != OZ_SUCCESS) return (sts);
  sts = eval_integer (strp, rtnp, &index, ')');
  if (sts != OZ_SUCCESS) return (sts);

  /* Get the attributes */

  sts = oz_sys_logname_getattr (h_logname, 0, NULL, NULL, NULL, &lognamatr, NULL, NULL, index, &logvalatr);
  if (sts != OZ_SUCCESS) {
    oz_sys_io_fs_printf (h_s_error, "oz_cli: error %u getting logical's attributes\n", sts);
    return (sts);
  }

  /* Convert bitmask attributes to strings */

  out = malloc (64);
  out[0] = 0;
  if (lognamatr & OZ_LOGNAMATR_NOOUTERMODE) strcat (out, "nooutermode ");
  if (lognamatr & OZ_LOGNAMATR_NOSUPERSEDE) strcat (out, "nosupersede ");
  if (logvalatr & OZ_LOGVALATR_OBJECT)      strcat (out, "object ");
  if (lognamatr & OZ_LOGNAMATR_TABLE)       strcat (out, "table ");
  if (logvalatr & OZ_LOGVALATR_TERMINAL)    strcat (out, "terminal ");
  i = strlen (out);
  if ((i > 0) && (out[i-1] == ' ')) out[--i] = 0;

  *((char **)valuep) = out;
  return (OZ_SUCCESS);
}

/************************************************************************/
/*									*/
/*  Lookup logical name							*/
/*									*/
/*	handle = oz_lnm_lookup ("logical_name", "procmode")		*/
/*									*/
/************************************************************************/

static uLong func_lnm_lookup (Symbol *symbol, char *strp, char **rtnp, void *valuep)

{
  char *logname, *procmode, *out;
  uLong sts;
  OZ_Handle h_logname, h_table;
  OZ_Procmode b_procmode;

  while ((*strp != 0) && (*strp <= ' ')) strp ++;
  if (*(strp ++) != '(') {
    oz_sys_io_fs_printf (h_s_error, "oz_cli: missing ( following %s at %s\n", symbol -> name, -- strp);
    return (OZ_MISSINGPARAM);
  }
  sts = eval_string (strp, &strp, &logname, ',');
  if (sts != OZ_SUCCESS) return (sts);
  sts = eval_string (strp, &strp, &procmode, ')');
  if (sts != OZ_SUCCESS) {
    free (logname);
    return (sts);
  }

  b_procmode = OZ_PROCMODE_USR;
  if (strcasecmp (procmode, "user") == 0) b_procmode = OZ_PROCMODE_USR;
  else if (strcasecmp (procmode, "kernel") == 0) b_procmode = OZ_PROCMODE_KNL;
  else {
    oz_sys_io_fs_printf (h_s_error, "oz_cli: bad processor mode %s (kernel or user)\n", procmode);
    free (logname);
    free (procmode);
    return (OZ_BADPARAM);
  }
  *rtnp = strp;

  /* Look it up */

  sts = oz_sys_logname_lookup (0, OZ_PROCMODE_USR, defaulttables, NULL, NULL, NULL, &h_table);
  if (sts != OZ_SUCCESS) {
    oz_sys_io_fs_printf (h_s_error, "oz_cli: error %u looking up default tables (%s)\n", sts, defaulttables);
    free (logname);
    free (procmode);
    return (sts);
  }
  sts = oz_sys_logname_lookup (h_table, b_procmode, logname, NULL, NULL, NULL, &h_logname);
  oz_sys_handle_release (OZ_PROCMODE_KNL, h_table);
  if (sts != OZ_SUCCESS) {
    out = malloc (1);
    out[0] = 0;
  } else {
    out = malloc (17);
    oz_sys_sprintf (17, out, "%8.8X:logname", h_logname);
  }
  *((char **)valuep) = out;
  free (logname);
  free (procmode);
  return (OZ_SUCCESS);
}

/************************************************************************/
/*									*/
/*  Get logical name's number of values					*/
/*									*/
/*	number_of_values = oz_lnm_nvalues (h_logical_name)		*/
/*									*/
/************************************************************************/

static uLong func_lnm_nvalues (Symbol *symbol, char *strp, char **rtnp, void *valuep)

{
  uLong sts;
  OZ_Handle h_logname;

  while ((*strp != 0) && (*strp <= ' ')) strp ++;
  if (*(strp ++) != '(') {
    oz_sys_io_fs_printf (h_s_error, "oz_cli: missing ( following %s at %s\n", symbol -> name, -- strp);
    return (OZ_MISSINGPARAM);
  }
  sts = eval_handle (strp, rtnp, &h_logname, "logname", ')');
  if (sts != OZ_SUCCESS) return (sts);

  /* Get the number of values the logical name has */

  sts = oz_sys_logname_getattr (h_logname, 0, NULL, NULL, NULL, NULL, valuep, NULL, 0, NULL);
  if (sts != OZ_SUCCESS) {
    oz_sys_io_fs_printf (h_s_error, "oz_cli: error %u getting logical's attributes\n", sts);
  }
  return (sts);
}

/************************************************************************/
/*									*/
/*  Get logical name value's object handle				*/
/*									*/
/*	handle = oz_lnm_object (h_logical_name, index, "objtype")	*/
/*									*/
/************************************************************************/

static uLong func_lnm_object (Symbol *symbol, char *strp, char **rtnp, void *valuep)

{
  char *out, *s_objtype;
  uLong index, sts;
  OZ_Handle h_logname, h_object;
  OZ_Objtype b_objtype;

  while ((*strp != 0) && (*strp <= ' ')) strp ++;
  if (*(strp ++) != '(') {
    oz_sys_io_fs_printf (h_s_error, "oz_cli: missing ( following %s at %s\n", symbol -> name, -- strp);
    return (OZ_MISSINGPARAM);
  }
  sts = eval_handle (strp, &strp, &h_logname, "logname", ',');
  if (sts != OZ_SUCCESS) return (sts);
  sts = eval_integer (strp, &strp, &index, ',');
  if (sts != OZ_SUCCESS) return (sts);
  sts = eval_string (strp, &strp, &s_objtype, ')');
  if (sts != OZ_SUCCESS) return (sts);
  sts = decode_objtype_string (s_objtype, &b_objtype);
  free (s_objtype);
  if (sts != OZ_SUCCESS) return (sts);
  *rtnp = strp;

  /* Get an handle to the object */

  sts = oz_sys_logname_getval (h_logname, index, NULL, 0, NULL, NULL, &h_object, b_objtype, &b_objtype);
  if (sts != OZ_SUCCESS) {
    oz_sys_io_fs_printf (h_s_error, "oz_cli: error %u getting logical value's handle\n", sts);
    return (sts);
  }

  /* Make handle string */

  out = malloc (24);
  out[0] = 0;
  if (h_object != 0) oz_sys_sprintf (24, out, "%8.8X:%s", h_object, encode_objtype_string (b_objtype));
  *((char **)valuep) = out;
  return (OZ_SUCCESS);
}

/************************************************************************/
/*									*/
/*  Get logical name value's string					*/
/*									*/
/*	string = oz_lnm_string (h_logical_name, index)			*/
/*									*/
/************************************************************************/

static uLong func_lnm_string (Symbol *symbol, char *strp, char **rtnp, void *valuep)

{
  char *out;
  uLong index, rlen, sts;
  OZ_Handle h_logname;

  while ((*strp != 0) && (*strp <= ' ')) strp ++;
  if (*(strp ++) != '(') {
    oz_sys_io_fs_printf (h_s_error, "oz_cli: missing ( following %s at %s\n", symbol -> name, -- strp);
    return (OZ_MISSINGPARAM);
  }
  sts = eval_handle (strp, &strp, &h_logname, "logname", ',');
  if (sts != OZ_SUCCESS) return (sts);
  sts = eval_integer (strp, &strp, &index, ')');
  if (sts != OZ_SUCCESS) return (sts);
  *rtnp = strp;

  /* Get string's value */

  sts = oz_sys_logname_getval (h_logname, index, NULL, 0, NULL, &rlen, NULL, 0, NULL);
  if (sts != OZ_SUCCESS) {
    oz_sys_io_fs_printf (h_s_error, "oz_cli: error %u getting logical's value\n", sts);
    return (sts);
  }
  out = malloc (rlen + 1);
  sts = oz_sys_logname_getval (h_logname, index, NULL, rlen + 1, out, NULL, NULL, 0, NULL);
  if (sts != OZ_SUCCESS) {
    oz_sys_io_fs_printf (h_s_error, "oz_cli: error %u getting logical's value\n", sts);
    return (sts);
  }
  out[rlen] = 0;
  *((char **)valuep) = out;
  return (OZ_SUCCESS);
}

/************************************************************************/
/*									*/
/*  Locate 'needle' in 'haystack'					*/
/*									*/
/*	offset = oz_loc (haystack, needle)				*/
/*	length if not found						*/
/*									*/
/************************************************************************/

static uLong func_loc (Symbol *symbol, char *strp, char **rtnp, void *valuep)

{
  char *haystack, *needle, *p;
  uLong sts;

  while ((*strp != 0) && (*strp <= ' ')) strp ++;				/* skip spaces */
  if (*(strp ++) != '(') {							/* make sure it starts with an open paren and skip it */
    oz_sys_io_fs_printf (h_s_error, "oz_cli: missing ( following %s at %s\n", symbol -> name, -- strp);
    return (OZ_MISSINGPARAM);
  }
  sts = eval_string (strp, &strp, &haystack, ',');				/* evaluate the haystack string expression */
  if (sts != OZ_SUCCESS) return (sts);						/* return error status if any failure */
  sts = eval_string (strp, &strp, &needle, ')');				/* evaluate the needle string expression */
  if (sts != OZ_SUCCESS) {
    free (haystack);
    return (sts);
  }
  *rtnp = strp;									/* return pointer just past the ) */
  p = strstr (haystack, needle);						/* do it */
  if (p != NULL) *((uLong *)valuep) = p - haystack;				/* return offset if found */
  else *((uLong *)valuep) = strlen (haystack);					/* return length if not found */
  free (haystack);								/* free off results malloc'd by eval_string */
  free (needle);
  return (OZ_SUCCESS);								/* successful */
}

/************************************************************************/
/*									*/
/*  Convert input string to lower case					*/
/*									*/
/*	lowercase = oz_lowercase (string)				*/
/*									*/
/************************************************************************/

static uLong func_lowercase (Symbol *symbol, char *strp, char **rtnp, void *valuep)

{
  char c, *p, *string;
  uLong sts;

  while ((*strp != 0) && (*strp <= ' ')) strp ++;			/* skip spaces */
  if (*(strp ++) != '(') {						/* make sure it starts with an open paren and skip it */
    oz_sys_io_fs_printf (h_s_error, "oz_cli: missing ( following %s at %s\n", symbol -> name, -- strp);
    return (OZ_MISSINGPARAM);
  }
  sts = eval_string (strp, rtnp, &string, ')');				/* evaluate the string expression */
  if (sts == OZ_SUCCESS) {
    for (p = string; (c = *p) != 0; p ++) if ((c >= 'A') && (c <= 'Z')) *p = c + 'a' - 'A';
    *((char **)valuep) = string;
  }
  return (sts);
}

/************************************************************************/
/*									*/
/*  Find a process by its id number					*/
/*									*/
/*	h_process = oz_process (process_id)				*/
/*									*/
/************************************************************************/

static uLong func_process (Symbol *symbol, char *strp, char **rtnp, void *valuep)

{
  char *out;
  OZ_Handle h_process;
  OZ_Processid processid;
  uLong sts;

  while ((*strp != 0) && (*strp <= ' ')) strp ++;				/* skip spaces */
  if (*(strp ++) != '(') {							/* make sure it starts with an open paren and skip it */
    oz_sys_io_fs_printf (h_s_error, "oz_cli: missing ( following %s at %s\n", symbol -> name, -- strp);
    return (OZ_MISSINGPARAM);
  }
  sts = eval_integer (strp, &strp, &processid, ')');				/* evaluate the processid expression */
  if (sts != OZ_SUCCESS) return (sts);						/* return error status if any failure */

  sts = oz_sys_process_getbyid (processid, &h_process);
  if (sts != OZ_SUCCESS) {
    oz_sys_io_fs_printf (h_s_error, "oz_cli: error %u getting process-id %u handle\n", sts, processid);
    return (sts);
  }

  *rtnp = strp;

  /* Make handle string */

  out = malloc (24);
  oz_sys_sprintf (24, out, "%8.8X:%s", h_process, encode_objtype_string (OZ_OBJTYPE_PROCESS));
  *((char **)valuep) = out;
  return (OZ_SUCCESS);
}

/************************************************************************/
/*									*/
/*  Extract a substring							*/
/*									*/
/*	substring = oz_sub (length, offset, string)			*/
/*									*/
/************************************************************************/

static uLong func_sub (Symbol *symbol, char *strp, char **rtnp, void *valuep)

{
  char *string, *substring;
  uLong length, offset, sts, totalen;

  while ((*strp != 0) && (*strp <= ' ')) strp ++;				/* skip spaces */
  if (*(strp ++) != '(') {							/* make sure it starts with an open paren and skip it */
    oz_sys_io_fs_printf (h_s_error, "oz_cli: missing ( following %s at %s\n", symbol -> name, -- strp);
    return (OZ_MISSINGPARAM);
  }
  sts = eval_integer (strp, &strp, &length, ',');				/* evaluate the length expression */
  if (sts != OZ_SUCCESS) return (sts);						/* return error status if any failure */
  sts = eval_integer (strp, &strp, &offset, ',');				/* evaluate the offset expression */
  if (sts != OZ_SUCCESS) return (sts);						/* return error status if any failure */
  sts = eval_string (strp, &strp, &string, ')');				/* evaluate the string expression */
  if (sts != OZ_SUCCESS) return (sts);						/* return error status if any failure */
  *rtnp = strp;									/* return pointer just past the ) */
  totalen = strlen (string);							/* get total length of the original string */
  if (length > totalen - offset) length = totalen - offset;			/* chop off length at end of string */
  if (offset > totalen) offset = totalen;					/* chop off offset at end of string */
  substring = malloc (length + 1);						/* malloc a substring buffer */
  memcpy (substring, string + offset, length);					/* copy in the substring */
  substring[length] = 0;							/* null terminate it */
  free (string);								/* free off the string buffer */
  *((char **)valuep) = substring;						/* return the substring pointer */
  return (OZ_SUCCESS);								/* successful */
}

/************************************************************************/
/*									*/
/*  Find a thread by its id number					*/
/*									*/
/*	h_thread = oz_thread (thread_id)				*/
/*									*/
/************************************************************************/

static uLong func_thread (Symbol *symbol, char *strp, char **rtnp, void *valuep)

{
  char *out;
  OZ_Handle h_thread;
  OZ_Threadid threadid;
  uLong sts;

  while ((*strp != 0) && (*strp <= ' ')) strp ++;				/* skip spaces */
  if (*(strp ++) != '(') {							/* make sure it starts with an open paren and skip it */
    oz_sys_io_fs_printf (h_s_error, "oz_cli: missing ( following %s at %s\n", symbol -> name, -- strp);
    return (OZ_MISSINGPARAM);
  }
  sts = eval_integer (strp, &strp, &threadid, ')');				/* evaluate the threadid expression */
  if (sts != OZ_SUCCESS) return (sts);						/* return error status if any failure */

  sts = oz_sys_thread_getbyid (threadid, &h_thread);
  if (sts != OZ_SUCCESS) {
    oz_sys_io_fs_printf (h_s_error, "oz_cli: error %u getting thread-id %u handle\n", sts, threadid);
    return (sts);
  }

  *rtnp = strp;

  /* Make handle string */

  out = malloc (24);
  oz_sys_sprintf (24, out, "%8.8X:%s", h_thread, encode_objtype_string (OZ_OBJTYPE_THREAD));
  *((char **)valuep) = out;
  return (OZ_SUCCESS);
}

/************************************************************************/
/*									*/
/*  Trim leading/trailing whitespace					*/
/*									*/
/*	trimmed = oz_trim (string)					*/
/*									*/
/************************************************************************/

static uLong func_trim (Symbol *symbol, char *strp, char **rtnp, void *valuep)

{
  char c, *p, *q, *string;
  uLong sts;

  while ((*strp != 0) && (*strp <= ' ')) strp ++;			/* skip spaces */
  if (*(strp ++) != '(') {						/* make sure it starts with an open paren and skip it */
    oz_sys_io_fs_printf (h_s_error, "oz_cli: missing ( following %s at %s\n", symbol -> name, -- strp);
    return (OZ_MISSINGPARAM);
  }
  sts = eval_string (strp, rtnp, &string, ')');				/* evaluate the string expression */
  if (sts == OZ_SUCCESS) {
    for (p = string; (c = *p) != 0; p ++) if (c > ' ') break;		/* trim leading whitespace */
    for (q = p + strlen (p); q > p; -- q) if (q[-1] > ' ') break;	/* trim trailing whitespace */
    memmove (string, p, q - p);						/* shift result up to beginning of buffer */
    string[q-p] = 0;