From owner-freebsd-bugs Mon Jan 27 04:39:15 1997 Return-Path: Received: (from root@localhost) by freefall.freebsd.org (8.8.5/8.8.5) id EAA04432 for bugs-outgoing; Mon, 27 Jan 1997 04:39:15 -0800 (PST) Received: from oxtody.wias-berlin.de (oxtody.wias-berlin.de [192.124.249.175]) by freefall.freebsd.org (8.8.5/8.8.5) with SMTP id EAA04404 for ; Mon, 27 Jan 1997 04:38:48 -0800 (PST) From: griepent@wias-berlin.de Received: from pascal.wias-berlin.de by oxtody.wias-berlin.de (5.65v3.2/1.1.10.5/06Jan97-0122PM) id AA08130; Mon, 27 Jan 1997 13:38:27 +0100 Received: by pascal.wias-berlin.de (5.65v3.2/1.1.10.5/19Dec96-0827AM) id AA32085; Mon, 27 Jan 1997 13:38:23 +0100 Date: Mon, 27 Jan 1997 13:38:23 +0100 Message-Id: <9701271238.AA32085@pascal.wias-berlin.de> Subject: FreeBSD 2.1.5 ci command interpreter test failed Apparently-To: bugs@FreeBSD.org Sender: owner-bugs@FreeBSD.org X-Loop: FreeBSD.org Precedence: bulk Hello, bugs@FreeBSD.org ! I am going to use numerical applications on a X11 Window desktop and I do not want to miss the nice and stable FreeBSD system, because I like it so much, much more than Linux. To stay compatible with our institute I want to work with our self-written command interpreter ci. To compile a test version tci there are necessary the following three files ci.h, ci.c and tci.c: ------------------------------------------------------------------------------ ----------------------------------- ci.h ------------------------------------- ------------------------------------------------------------------------------ /* * $Id: ci.h,v 2.1 1996/09/04 09:19:21 fuhrmann Exp $ */ /*--------------------------------------------------------------------- CI 2.0 Command Interpreter Interface Author: Juergen Fuhrmann Weierstrass-Institut fuer Angewandte Analysis und Stochastik Mohrenstrasse 39 10117 Berlin -------------------------------------------------------------------------*/ #ifndef CI #define CI #include #define DEFAULT_CI #ifndef PARM #ifdef NOPROTO #define PARM(list) () #else #define PARM(list) list #endif #endif #ifndef STRING #ifdef NOACPP #define STRING(x) "x" #define CONCAT(x,y) x/* */y #else #define STRING(x) #x #define CONCAT(x,y) x##y #endif #endif #define CMD(cmd) CONCAT(c_,cmd) #define CI_BUFSIZE 512 #define CI_LINSIZE 256 #define CI_IDTSIZE 32 #define CI_MAXARGS 8 /* Common procedures - always active */ typedef struct tdsc *ciType; ciType ciDefineType PARM(( char * name, int(* xtos ) PARM((char* ,void* )), int(* stox ) PARM((void* ,char* )) )); extern ciType ciString, ciIdent, ciDec, ciHex, ciOct, ciDouble, ciFloat; void ciInit PARM((void)); void ciReInit PARM((void)); void ciBreak PARM((char * prompt)); int ciDummy PARM((void)); /* default ci prototypes */ typedef int (*dciCommandProc) PARM((void)); typedef struct { char * name; dciCommandProc proc; } dciCommandList; int dciGetArguments PARM((void)); void dciDefineModule PARM(( char * name, dciCommandList *commands, int qualify)); void dciDefineArgument PARM(( char * name, void * address, ciType type)); int dciExecute PARM(( FILE * input, FILE * output, char *prompt)); /*-----------------------------------------------------------*/ #ifdef PYTHON #undef DEFAULT_CI /* includes */ #define HAVE_STDLIB_H #include "allobjects.h" #include "modsupport.h" /* interface prototypes */ typedef struct methodlist pyciCommandList; void pyciDefineArgument PARM(( char * name,void * address, ciType type)); int pyciGetArguments PARM(( object *self, object *args)); /* interface definition */ #define ciCommandList pyciCommandList #define ciDefineArgument(name,address,type) pyciDefineArgument(name,address,type) #define ciDefineModule(name,list,qual) initmodule(name,list) #define ciReturn(i) return newintobject(i) #define ciCommand(cmd) object * CMD(cmd) (pyciSelf,pyciArgs) object *pyciSelf,*pyciArgs; #define ciGetArguments if(!pyciGetArguments(pyciSelf,pyciArgs)) ciReturn(1);ciDummy #define ciExecute(in,out,prompt) run(in,prompt) #endif /*-----------------------------------------------------------*/ #ifdef LISSI #undef DEFAULT_CI /* includes */ #include "fp.h" #include "xinterf.h" /* interface prototypes */ typedef int (*xciCommandProc) PARM((int ex)); typedef struct { char * name; xciCommandProc proc; } xciCommandList; int xciGetArguments PARM(( int ex)); void xciDefineArgument PARM(( char * name,void * address, ciType type)); void xciDefineModule PARM(( char * name, xciCommandList *commands,int qualify)); /* interface definition */ #define ciCommandList xciCommandList #define ciDefineArgument(name,address,type) xciDefineArgument(name,address,type) #define ciDefineModule(name,list,qual) xciDefineModule(name,list,qual); #define ciReturn(i) return (!i) #define ciCommand(cmd) int CMD(cmd)(ex) int ex; #define ciGetArguments if(!xciGetArguments(ex)) ciReturn(1);ciDummy #define ciExecute(in,out,prompt) xInterpret(1,prompt,"xxx",in,out,out); #endif /*-----------------------------------------------------------*/ #ifdef TCL #undef DEFAULT_CI typedef int (*tclciCommandProc) PARM((int argc ,char *argv[])); typedef struct { char * name; tclciCommandProc proc; } tclciCommandList int tclciGetArguments PARM(( int argc, char *argv[])) /* interface definition */ #define ciCommandList tclciCommandList #define ciDefineArgument(name,address,type) xDefine(xVariable,name,address,type,1) #define ciDefineModule(name,list,qual) xciDefineModule(name,list,qual); #define ciReturn(i) return (i) #define ciCommand(cmd) int CMD(cmd) (argc,argv) int argc; char*argv[]; #define ciGetArguments() if(!xciGetArguments(argc,argv)ciReturn(1);ciDummy #endif /*-------------------------------------------------------------*/ #ifdef DEFAULT_CI /* interface definition */ #define ciCommandList dciCommandList #define ciDefineArgument(name,address,type) dciDefineArgument(name,address,type) #define ciDefineModule(name,list,qual) dciDefineModule(name,list,qual); #define ciReturn(i) return (i) #define ciCommand(cmd) int CMD(cmd) PARM((void)) #define ciGetArguments if (!dciGetArguments()) ciReturn(1);ciDummy #define ciExecute(in,out,prompt) dciExecute(in,out,prompt) #endif /*--------------------------------------------------------------*/ /* the dummy declarations are for forcing ';'s at the end of variable definitions */ #define ciDoubleVariable(var,inival,callback)\ double var=(inival); static ciCommand(var)\ { ciDefineArgument("value",&var,ciDouble);ciGetArguments();\ printf("ci: %s:=%e\n",STRING(var),var);ciReturn(callback());}int ciDummy PARM((void)) #define ciIntegerVariable(var,inival,callback)\ int var=(inival); static ciCommand(var)\ { ciDefineArgument("value",&var,ciDec);ciGetArguments();\ printf("ci: %s:=%d\n",STRING(var),var);ciReturn(callback());}int ciDummy PARM((void)) #define ciIdentVariable(var,inival,callback)\ char var[32]; static ciCommand(var)\ { static char init=0; if(!init) {strcpy(var,inival);init=1;}\ ciDefineArgument("value",var,ciIdent);ciGetArguments();\ printf("ci: %s:=%s\n",STRING(var),var);ciReturn(callback());}int ciDummy PARM((void)) #define ciDeclareVariable(var) {STRING(var),CMD(var)} #define ciDeclareCommand(cmd) {STRING(cmd),CMD(cmd)} #define ciDeclareEnd {NULL,NULL} #endif /* $Log: ci.h,v $ * Revision 2.1 1996/09/04 09:19:21 fuhrmann * ciReInit() introduced * * Revision 2.0 1996/02/15 19:52:37 fuhrmann * First meta-stable distribution * * Revision 1.1 1995/10/20 15:12:40 fuhrmann * Initial revision * */ ------------------------------------------------------------------------------ ---------------------------------- ci.c -------------------------------------- ------------------------------------------------------------------------------ static char *rcsid= "$Id: ci.c,v 2.1 1996/09/04 09:19:09 fuhrmann Exp $"; /*--------------------------------------------------------------------- CI 2.0 Command Interpreter ----------------------------------------------------------------------*/ #include #include #include #include #include #include "ci.h" #define str2double xstr2double #define TRUE 1 #define FALSE 0 #define lst_new(top,typ) {typ * c;\ c=(typ *)ciAlloc( sizeof(typ) );\ c->prv=top;\ top=c;} #define lst_dsp(top,typ) {typ * c;\ c=top->prv;\ free(top);\ top=c;} typedef struct tdsc typ_dsc; struct tdsc { struct tdsc *prv; char *idt; int (*xtos)PARM((char*,void*)); int (*stox)PARM((void *,char *)); }; typedef struct pdsc{ struct pdsc *prv; char *idt; void *val; typ_dsc *typ; } par_dsc; typedef struct mdsc { struct mdsc *prv; char *idt; } mnu_dsc; typedef struct cdsc { struct cdsc *prv; char *idt; dciCommandProc cmd; par_dsc *par; mnu_dsc *mnu; } cmd_dsc; typedef struct ddsc { struct ddsc *prv; char *idt; char *rpl; } def_dsc; static cmd_dsc *cmd_top=NULL; static def_dsc *def_top=NULL; static mnu_dsc *mnu_top=NULL; static typ_dsc *typ_top=NULL; static FILE *ciIn =NULL, *ciOut =NULL, *hlp_file=NULL, *pro_file=NULL; static int echo =1, is_end =0; int ciBreaked=0; static char ciBuf[CI_BUFSIZE], inp_buf[CI_BUFSIZE]; /*--------------------------------------------------------------*/ /* private */ /*--------------------------------------------------------------*/ #ifndef NOPROTO static void * ciAlloc(int n); static void ciDebug(void); static cmd_dsc *str2cmd(char *s); static int ciPar(cmd_dsc *c); static void readln(char * b); static char * def_replace(char *s); static int get_buf(void); static int get_par(char *ci,char *par,char *val,typ_dsc *typ,char*s); static int ciExecute0(void); #endif static void * ciAlloc(n) int n; { void * p; p=malloc((unsigned)n); if (p==NULL) { printf("ci: FATAL ERROR - cannot xallocate\n"); abort(); }; return p; } static void ciDebug() {;} int ciDummy() {return 1;} static void readln(b) char * b; { fgets(b,CI_LINSIZE,ciIn); if (feof(ciIn)) { /* fputs("%CI: End of file reached in command input\n",ciOut); fflush(ciOut); exit(1); */ *b='\0'; is_end=TRUE; } while (1) { if (*b=='\n') { *b='\0'; return; } if (*b=='\0') { *b='\0'; return; } if (*b=='#') { *b='\0'; return; } b++; } } /*--------------------------------------------------------------*/ static int noalias=0; /*Abschaltung des Alias-Mechanismus */ static char * def_replace(s) char *s; { def_dsc * d; if (noalias) return NULL; d=def_top; while(d!=NULL) { if (strcmp(s,d->idt)==0) return d->rpl; d=d->prv; }; return NULL; } /*--------------------------------------------------------------*/ static int get_buf() { char *tok, *rpl, *bpos; int l; for(bpos=inp_buf; (bpos!=NULL)&&((bpos-inp_buf)stox)(val,s); else if (echo>0) { rc=(*typ->xtos)(id,val); fprintf(ciOut,"_%-8s%10s.%-10s[=%10s]=",typ->idt,ci,par,id); fflush(ciOut); get_buf(); s=strtok(ciBuf," "); if (s!=NULL) rc=(*typ->stox)(val,s); } else { (*typ->xtos)(id,val); fprintf(ciOut,"\nci: The parameter %10s %10s.%-10s=%10s remains unchanged\n",typ->idt,ci,par,id); fflush(ciOut); }; if (rc!=0) fprintf(ciOut,"\nci: type conversion failed for type %s.\n", typ->idt); fflush(ciOut); return rc; } /*--------------------------------------------------------------------*/ /* Belegung der Parameter */ static int ciPar(c) cmd_dsc *c; { int rc; par_dsc *p; char * tok; rc=0; for (p=c->par; p!=NULL; p=p->prv) if (p->typ==ciString) { if ((tok=strtok(NULL,""))==NULL) strcpy(p->val,""); else strcpy(p->val,tok); } else { rc=get_par(c->idt,p->idt,p->val,p->typ,strtok(NULL," ")); if (rc!=0) return rc; } return 0; } /*--------------------------------------------------------------------*/ static cmd_dsc * str2cmd(name) char *name; { cmd_dsc *c=cmd_top,*xc; int len=strlen(name); while (strncmp(name,c->idt,len)!=0) { c=c->prv; if (c==NULL) { fprintf(ciOut,"\nci: No such command : \"%s\"\n",name); fflush(ciOut); return NULL; } } xc=c->prv; if (xc!=NULL) while (strncmp(name,xc->idt,len)!=0) { xc=xc->prv; if (xc==NULL) return c; } else return c; fprintf(ciOut,"\nci: Ambiguous command : \"%s\", try \"%s\" or \"%s\"\n", name,c->idt,xc->idt); fflush(ciOut); return NULL; } /* Test, ob Kommando vorhanden, Ausfuehrung */ static int ciExecute0() { char * tok; cmd_dsc *c; int rc; tok=strtok(ciBuf," "); if (tok==NULL) return 0; c=str2cmd(tok); if (c==NULL) return 1; rc=ciPar(c); if (rc!=0) { fprintf(ciOut,"\nci: Conversion error,no Execution of %s.\n",c->idt); fflush(ciOut); return rc; } rc=(*c->cmd)(); if (!rc) fprintf(ciOut,"\nci: Error in command \"%s\".\n",c->idt); fflush(ciOut); return rc; fflush(ciOut); return rc; } /*--------------------------------------------------------------*/ /* public */ /*--------------------------------------------------------------*/ /* Definition eines Moduls */ int ciArgs(int self,int args) { return args; } static int inCdef=0; int ciCdef(name,proc) char *name; dciCommandProc proc; { int rc; cmd_dsc *c; for(c=cmd_top;c!=NULL;c=c->prv) if ( (strncmp(c->idt,name,strlen(c->idt))* strncmp(c->idt,name,strlen(name)))==0) break; if (c!=NULL) { printf("ci: new command \"%s\" would be ambiguous with \"%s\"\n", name,c->idt); return 1; } lst_new(cmd_top,cmd_dsc); cmd_top->cmd=proc; cmd_top->idt=malloc(strlen(name)); strcpy(cmd_top->idt,name); cmd_top->par=NULL; cmd_top->mnu=mnu_top; inCdef=1; rc=(*proc)(); inCdef=0; if (!rc) printf("ci: initialization of command \"%s\" failed\n",name); return rc; } void dciDefineModule(name,commands,qualify) char *name; dciCommandList commands[]; int qualify; { int i; lst_new(mnu_top,mnu_dsc); mnu_top->idt=name; i=0; while (commands[i].name!=NULL) { if (qualify) { sprintf(ciBuf,"%s.%s",name,commands[i].name); ciCdef(ciBuf,commands[i].proc); } else ciCdef(commands[i].name,commands[i].proc); i++; } return; } /*--------------------------------------------------------------*/ void ciAlias(idt,rpl) char * idt, * rpl; { def_dsc * d=def_top; while(d!=NULL) { if (strcmp(idt,d->idt)==0) { free(d->rpl); d->rpl=(char *)ciAlloc(strlen(rpl)+1); strcpy(d->rpl,rpl); return; } d=d->prv; } lst_new(def_top,def_dsc); def_top->rpl=(char *)ciAlloc(strlen(rpl)+1); strcpy(def_top->rpl,rpl); def_top->idt=(char *)ciAlloc(strlen(idt)+1); strcpy(def_top->idt,idt); return; } /*--------------------------------------------------------------*/ /* Start des Interpreters */ int dciExecute(in,out,pr) FILE *in,*out; char *pr; { int rc; if (in==stdin) echo=1; else echo=0; is_end=FALSE; do { ciIn=in; ciOut=out; ciBreaked=0; if (ciIn==stdin) echo=1; else echo=0; if ((echo>0)&(!is_end)) { fprintf(ciOut,"\n%s>",pr);fflush(ciOut);}; get_buf(); if (!is_end) rc=ciExecute0(); } while (!is_end); is_end=FALSE; return 0; } /* Definition eines Stellungsparameters */ void dciDefineArgument(name,address,type) char *name; void *address; typ_dsc *type; { par_dsc * pnew,*p; cmd_dsc *c; if (!inCdef) return; c=cmd_top; p=c->par; for (;;) { if (p==NULL) break; if (p->prv==NULL) break; p=p->prv; } pnew=(par_dsc *)ciAlloc( sizeof(par_dsc) ); pnew->prv=NULL; if (p==NULL) c->par=pnew; else p->prv=pnew; pnew->idt=name; pnew->val=address; pnew->typ=type; } int dciGetArguments() { if (inCdef) return 0; else return 1; } /*--------------------------------------------------------------*/ /* Definition eines Typs */ ciType ciDefineType(name,_xtos,_stox) char *name; int (*_xtos) PARM ((char * ss,void * xx)); int (*_stox) PARM((void * x, char * s)); { lst_new(typ_top,typ_dsc); typ_top->idt=name; typ_top->xtos=_xtos; typ_top->stox=_stox; return typ_top; } /*--------------------------------------------------------------------*/ /* predefined */ /*--------------------------------------------------------------*/ /* types */ /*--------------------------------------------------------------*/ #ifndef NOPROTO static int dec2str(char *s, void *x); static int str2dec(void *x,char *s); static int oct2str(char *s,void *x); static int str2oct(void *x,char *s); static int hex2str(char *s,void *x); static int str2hex( void *x,char *s); static int double2str(char *s,void *x); static int str2double(void *x,char *s); static int float2str(char *s,void *x); static int str2float(void *x,char *s); static int ident2str(char *s,void *x); static int str2ident(void *x,char *s); #endif static int dec2str(s,x) char *s; void *x; { sprintf(s,"%d",*(int *)x); return 0; } static int str2dec(x,s) char *s; void *x; { *(int*)x=atoi(s); return 0; } /*--------------------------------------------------------------*/ static int oct2str(s,x) char *s;void *x; { sprintf(s,"%o",*(int*)x); return 0; } static int str2oct(x,s) char *s; void *x; { sscanf(s,"%o",(int*)x); return 0; } /*--------------------------------------------------------------*/ static int hex2str(s,x) char *s; void *x; { sprintf(s,"%x",*(int*)x); return 0; } static int str2hex(x,s) char *s; void *x; { sscanf(s,"%x",(int*)x); return 0; } /*--------------------------------------------------------------*/ static int double2str(s,x) char *s; void *x; { sprintf(s,"%e",*(double*)x); return 0; } static int str2double(x,s) char *s; void *x; { *(double*)x=atof(s); return 0; } /*--------------------------------------------------------------*/ static int float2str(s,x) char *s; void *x; { sprintf(s,"%e",*(float*)x); return 0; } static int str2float(x,s) char *s; void *x; { *(float*)x=(float)atof(s); return 0; } /*--------------------------------------------------------------*/ static int ident2str(s,x) char *s; void *x; { strcpy(s,(char *)x); return 0; } static int str2ident(x,s) char *s; void *x; { strcpy((char *)x,s); return 0; } /*--------------------------------------------------------------*/ /*--------------------------------------------------------------*/ /*--------------------------------------------------------------*/ /* commands */ /*--------------------------------------------------------------*/ static char def_lin_buf[CI_LINSIZE]; static char def_idt_buf[CI_IDTSIZE]; ciCommand(alias) { def_dsc * d; int j; ciDefineArgument("string",def_idt_buf,ciIdent); ciDefineArgument("replace",def_lin_buf,ciString); ciGetArguments(); if (strcmp(def_idt_buf,"?")==0) { fputs("%CI : Alias list:\n",ciOut); for(d=def_top,j=10; d!=NULL;j++,d=d->prv) fprintf(ciOut,"%15s = %-s\n",d->idt,d->rpl); if (noalias) fputs("%CI : Alias is off\n",ciOut); else fputs("%CI : Alias is on \n",ciOut); fflush(ciOut); ciReturn(1); } if (strcmp(def_idt_buf,"off")==0) { noalias=1; ciReturn(1); } if (strcmp(def_idt_buf,"on")==0) { noalias=0; ciReturn(1); } ciAlias(def_idt_buf,def_lin_buf); ciReturn(1); } /*--------------------------------------------------------------*/ static char fname[CI_LINSIZE]={'\0'}; static char prompt[CI_LINSIZE]={'\0'}; ciCommand(source) { FILE *in=ciIn; FILE *out=ciOut; ciDefineArgument("file",fname,ciIdent); ciDefineArgument("prompt",prompt,ciString); ciGetArguments(); if (strcmp(fname,"tty")==0) ciIn=stdin; else { if( (ciIn=fopen(fname,"r"))==NULL) { fprintf(ciOut, "\nci: file %s not found.\n", fname); fflush(ciOut); ciIn=in; ciReturn(0); } } if (prompt[0]=='\0') strcpy(prompt,fname); ciExecute(ciIn,ciOut,prompt); if (ciIn!=stdin) fclose(ciIn); ciIn=in; ciOut=out; fname[0]='\0'; prompt[0]='\0'; ciReturn(1); } /*--------------------------------------------------------------*/ ciCommand(quit) { ciGetArguments(); is_end=TRUE; ciReturn(1);} ciCommand(exit) { ciGetArguments(); is_end=TRUE; ciReturn(1);} char hlp_idt_buf[CI_IDTSIZE]={'?','\0'}; ciCommand(help) { int i,j; char locked; cmd_dsc * c; par_dsc * p; mnu_dsc * m; char id[CI_IDTSIZE]; ciDefineArgument("command",hlp_idt_buf,ciIdent); ciGetArguments(); if (strcmp("?",hlp_idt_buf)==0) { for(j=1,c=cmd_top;c!=NULL;j++) { m=c->mnu; printf("\nmodule %s:\n",m->idt); for(;(c!=NULL)&&(c->mnu==m);) { for(i=0;(i<4)&&(c!=NULL)&&(c->mnu==m);i++,c=c->prv) { printf("%-18s",c->idt); } fputs("\n",ciOut); } } fflush(ciOut); goto exit; } else { c=str2cmd(hlp_idt_buf); if(c!=NULL) { fprintf(ciOut,"\nCOMMAND = %s\n",c->idt); fprintf(ciOut, "PARAMETERS : \n"); p=c->par; if (p==NULL) fprintf(ciOut,"none\n"); while(p!=NULL) {if (p->typ==ciString) fprintf(ciOut,"string %-12s %-30s\n",p->idt,p->val); else { (*p->typ->xtos)(id,p->val); fprintf(ciOut,"%-10s %-20s = %s\n", p->typ->idt,p->idt,id); } p=p->prv; } } fprintf(ciOut,"You will get a command list by typing \"help ? \"\n"); goto exit; } exit: fflush(ciOut); ciReturn(1); } /*--------------------------------------------------------------*/ ciCommand(halt) { ciGetArguments(); { fprintf(ciOut,"ci: halt\n"); fflush(ciOut); exit(1); } ciReturn(1); } /*--------------------------------------------------------------*/ static char msg_lin_buf[CI_LINSIZE]={'\0','\0'}; ciCommand(echo) { ciDefineArgument("msg",msg_lin_buf,ciString); ciGetArguments(); fprintf(ciOut,"%s\n",msg_lin_buf); fflush(ciOut); ciReturn(1); } ciCommand(system) { ciDefineArgument("command",msg_lin_buf,ciString); ciGetArguments(); if (strcmp(msg_lin_buf,"")==0) fprintf(ciOut,"ci: system\n"); fflush(ciOut); system(msg_lin_buf); if (strcmp(msg_lin_buf,"")==0) fprintf(ciOut,"ci: back\n"); fflush(ciOut); ciReturn(1); } /*--------------------------------------------------------------*/ /*--------- INTERRUPT HANDLING ---------------------------------*/ ciCommand(break) { ciGetArguments(); ciBreaked=1; is_end=TRUE; ciReturn(1); } void handle_interrupt(isig)int isig; { signal(isig,handle_interrupt); ciExecute(stdin,stdout,"interrupt::ci"); if (ciBreaked) fprintf(ciOut,"\n\nci: break\n"); else fprintf(ciOut,"\n\nci: continue\n"); fflush(ciOut); } void ciBreak(prompt) char * prompt; { ciExecute(stdin,stdout,prompt); } void ci_() { fflush(ciOut); ciExecute(stdin,stdout,"debug::ci"); fflush(ciOut); } ciCommand(debug) { ciGetArguments(); fprintf(ciOut,"ci: debugger\n"); fflush(ciOut); ciDebug(); fprintf(ciOut,"ci: back\n") ; fflush(ciOut); ciReturn(1); } /*-----------------------------------------------------------------------*/ #ifdef PYTHON static char argstr[CI_MAXARGS+3]; static void* argaddr[CI_MAXARGS+1]; static char* stringaddr[CI_MAXARGS+1]; static char* xstringaddr[CI_MAXARGS+1]; int iarg=1; void pyciDefineArgument(name,address,type) char *name; void *address; typ_dsc *type; {int i; if (iarg>=CI_MAXARGS) { printf("ci: define arg: too many args\n"); return; } stringaddr[iarg]=NULL; argaddr[iarg]=address; if (type==ciDec) { argstr[iarg]='i'; argaddr[iarg]=address; } else if (type==ciDouble) { argstr[iarg]='d'; argaddr[iarg]=address; } else if (type==ciFloat) { argstr[iarg]='f'; argaddr[iarg]=address; } else if (type==ciString) { argstr[iarg]='s'; argaddr[iarg]=&xstringaddr[iarg]; stringaddr[iarg]=address; } else if (type==ciIdent) { argstr[iarg]='s'; argaddr[iarg]=&xstringaddr[iarg]; stringaddr[iarg]=address; } else { printf("ci: type not defined\n"); } iarg++; } int pyciGetArguments(self,args) object * self,*args; { register int i,j; if (iarg==1) return 1; if (iarg==2) { argstr[iarg]='\0'; } else { argstr[0]='('; argstr[iarg]=')'; argstr[iarg+1]='\0'; } switch(iarg-1) { case 1: if (!getargs(args,argstr+1,argaddr[1])) goto error; break; case 2: if (!getargs(args,argstr,argaddr[1],argaddr[2])) goto error; break; case 3: if (!getargs(args,argstr,argaddr[1],argaddr[2],argaddr[3])) goto error; break; default: printf("ci: too many args\n"); } for(i=1;i<=iarg;i++) if (stringaddr[i]!=NULL) { strcpy(stringaddr[i],xstringaddr[i]); } iarg=1; return 1; error: printf("ci: python argument conversion error\n"); iarg=1; return 0; } #endif /*--------------------------------------------------------------------------*/ #ifdef LISSI int xciGetArguments PARM(( int ex)) { if (ex<1) return 0; else return 1; } void xciDefineArgument( char * name,void * address, ciType type) { if (inCdef) { if (type==ciDec) { xDefine(xVariable,name,address,1,xInteger); } else if (type==ciDouble) { xDefine(xVariable,name,address,1,xReal); } else if (type==ciString) { xDefine(xVariable,name,address,CI_LINSIZE,xCharacter); } else if (type==ciIdent) { xDefine(xVariable,name,address,CI_IDTSIZE,xCharacter); } else { printf("ci: lissi type not defined\n"); } } } void xciDefineModule ( char * name, xciCommandList *commands, int qualify) { int i; if (qualify) xDefineStructure(name); i=0; while (commands[i].name!=NULL) { xDefineCommand(commands[i].name,commands[i].proc); inCdef=1; commands[i].proc(0); inCdef=0; xEndDefinition(); i++; } if (qualify) xEndDefinition(); return; } #endif /*--------------------------------------------------------------------------*/ ciType ciString, ciIdent, ciDec, ciOct, ciHex, ciDouble, ciFloat, ciFloat_array, ciDouble_array; static ciCommandList systemlist[]={ ciDeclareCommand(echo), ciDeclareCommand(debug), ciDeclareCommand(halt), ciDeclareCommand(break), ciDeclareCommand(system), #ifndef PYTHON ciDeclareCommand(help), ciDeclareCommand(quit), ciDeclareCommand(exit), ciDeclareCommand(alias), ciDeclareCommand(source), #endif ciDeclareEnd}; static void read_profile() { #ifdef PYTHON pro_file=fopen(".pyrc","r"); if(pro_file!=NULL) { run_script(pro_file,"init"); } #endif #ifdef DEFAULT_CI pro_file=fopen(".circ","r"); if(pro_file!=NULL) { ciExecute(pro_file,stdout,"init"); } #endif } static int init_flag=0; void ciInit() { if (init_flag) return; ciString=NULL; ciDouble = ciDefineType("double", double2str, str2double); ciDec = ciDefineType("dec", dec2str, str2dec); ciOct = ciDefineType("oct", oct2str, str2oct); ciHex = ciDefineType("hex", hex2str, str2hex); ciIdent = ciDefineType("ident", ident2str, str2ident); #ifdef PYTHON initall(); #endif #ifdef LISSI xinterfInit(); #endif ciDefineModule("ci",systemlist,0); ciIn=stdin; ciOut=stdout; signal(SIGINT,handle_interrupt); read_profile(); init_flag=1; } void ciReInit() { def_dsc *d=def_top; ciInit(); fprintf(stdout,"ci: reinitialization, alias list cleared\n"); while (def_top!=NULL) { free(def_top->idt); free(def_top->rpl); d=def_top; def_top=d->prv; free(d); } read_profile(); } /* * $Log: ci.c,v $ * Revision 2.1 1996/09/04 09:19:09 fuhrmann * ciReInit() introduced * * Revision 2.0 1996/02/15 19:52:37 fuhrmann * First meta-stable distribution * * Revision 1.2 1995/10/23 20:14:27 fuhrmann * strdup 'rausgenommen * * Revision 1.1 1995/10/20 15:12:12 fuhrmann * Initial revision * */ --------------------------------------------------------------------------- ----------------------------- tci.c --------------------------------------- --------------------------------------------------------------------------- #include "ci.h" void main(int argc, char* argv[]) { ciInit(); ciExecute(stdin,stdout,"tci"); } --------------------------------------------------------------------------- ----------------------------- end of code --------------------------------- --------------------------------------------------------------------------- The command interpreter ci/tci was successfully GCC compiled on several architectures like Linux, DEC UNIX, SunOS 4.1.x and IRIX 5.x, for instance, and it works flawlessly. On my i486/FreeBSD 2.1.5 machine I was also able to compile tci with gcc-2.6.3, but the executable code does not work at all, some of the command interpreter functions are not available. It seems to be a memory allocation problem, because the listing of the interpreter commands (you can get it with the help command) shows the strange ascii symbol "o" as an executable interpreter command! Here you can see a terminal dump: bash$ gcc -o tci tci.c ci.c bash$ ls -l tci* -rwxr-xr-x 1 johnny johnny 18842 Oct 15 18:55 tci* -rw------- 1 johnny johnny 102 Oct 15 14:49 tci.c bash$ ./tci ci: new command "quit" would be ambiguous with "" ci: new command "exit" would be ambiguous with "" ci: new command "alias" would be ambiguous with "" ci: new command "source" would be ambiguous with "" tci>help ? module ci: help system break debug o tci>system ci: system ci: back tci>debug ci: debugger ci: back tci>break bash$ I do not know, whether there is a mistake in our code or somewhere in the operating system. Our code seems to be stable on all of the above architectures. Please, extract and try out our code on one of your machines! It would be very nice, if you could give me an answer to my problem! Jens Griepentrog Weierstrass Institute for Applied Analysis and Stochastics Mohrenstrasse 39 D-10117 Berlin Germany griepent@wias-berlin.de