3 * (C) Copyright Apr 15 1995, Edmond J. Breen.
5 * This code may be copied for personal, non-profit use only.
29 extern char EiC_LEXEM[];
30 extern token_t *token;
32 int EiC_listcodeON = 0;
37 int EiC_memdumpON = 0;
38 int EiC_memtraceON = 0;
40 int EiC_traceFunc = 0;
41 int EiC_verboseON = 0;
43 int EiC_interActive=1;
44 int EiC_showIncludes = 0;
48 static void outputval(int obj, void *v)
51 case t_char: fprintf(stdout,"%d",*(char *) v);break;
52 case t_uchar: fprintf(stdout,"%d",*(unsigned char *) v); break;
53 case t_short: fprintf(stdout,"%d",*(short *) v); break;
54 case t_ushort: fprintf(stdout,"%d",*(unsigned short*) v); break;
55 case t_int: fprintf(stdout,"%d",*(int *) v); break;
56 case t_uint: fprintf(stdout,"%u",*(unsigned *) v); break;
57 case t_long: fprintf(stdout,"%ld",*(long *) v); break;
58 case t_ulong: fprintf(stdout,"%lu",*(long *) v); break;
62 case t_llong: fprintf(stdout,"%Ld",*(eic_llong *) v); break;
64 case t_llong: fprintf(stdout,"%ld",*(eic_llong *) v); break;
67 case t_float: fprintf(stdout,"%.9g",*(float *) v); break;
68 case t_double: fprintf(stdout,"%.9g",*(double *) v); break;
70 case t_pointer: fprintf(stdout,"%p",(void*)*(long *) v); break;
71 case t_void: fprintf(stdout,"(void)"); break;
72 case t_enum: fprintf(stdout,"(enumeration)"); break;
73 case STR: fprintf(stdout,"%.100s",*(char **) v); break;
74 default: fprintf(stdout,"Unknown type"); break;
79 static void showstruct(AR_t * arg)
84 S = (struct_t *) EiC_getInf(arg->type);
88 fputs("(null struct) ", stdout);
90 for (i = 0; i < S->n; i++) {
91 switch ((t = EiC_gettype(S->type[i]))) {
93 fputs("Array", stdout);
96 fputs("Union",stdout);
99 fputs("Struct", stdout);
102 outputval(t, &D[S->offset[i]]);
107 fputs("\b}", stdout);
110 void EiC_showvalue(AR_t * arg)
114 if(!EiC_interActive || !arg->type)
119 t = EiC_gettype(arg->type);
121 if(isconst(arg->type) && t != t_pointer) {
122 outputval(t, &arg->v);
127 switch ((t = EiC_gettype(arg->type))) {
128 case t_union: fputs("(Union)",stdout); break;
129 case t_struct: showstruct(arg); break;
130 case t_char: case t_uchar: case t_short:
131 case t_ushort: outputval(t_int, &arg->v.ival); break;
132 case t_float: outputval(t_double, &arg->v.ival); break;
135 if (EiC_gettype(nextType(arg->type)) == t_char)
140 outputval(t, &arg->v);
147 static void EiC_showdectype(type_expr *, int, FILE *);
149 static void showFunc(type_expr **t, FILE *fp)
151 static int level = 0;
155 F = (func_t *) EiC_getInf(*t);
158 if (F && getFNp(F)) {
159 for (i = 0; i < getFNp(F); i++) {
164 printf("%s: ",getFPname(F,i));
165 EiC_showdectype(getFPty(F,i), 0,fp);
174 fputs(") returning ", fp);
177 EiC_showdectype(*t,0,fp);
184 fprintf(fp,"\n\n /* %s/\n", getFComm(F)); /**/
189 static void EiC_showdectype(type_expr * t, int expand, FILE *fp)
194 static int level = 0;
197 if(isconst(t) || isconstp(t))
200 switch (EiC_gettype(t)) {
201 case t_var: fputs("...", fp); break;
202 case t_enum: fputs("enum ", fp); break;
203 case t_char: fputs("char ", fp); break;
204 case t_uchar: fputs("unsigned char ", fp); break;
205 case t_short: fputs("short ", fp); break;
206 case t_ushort:fputs("unsigned short ", fp); break;
207 case t_int: fputs("int ", fp); break;
208 case t_uint: fputs("unsigned ", fp); break;
209 case t_long: fputs("long int ", fp); break;
210 case t_ulong: fputs("unsigned long int ", fp); break;
211 case t_llong: fputs("long long ",fp); break;
212 case t_float: fputs("float ", fp); break;
213 case t_double:fputs("double ", fp); break;
217 fputs("unsafe ", fp);
219 fputs("safe ", fp);*/
224 case t_void: fputs("void ", fp); break;
225 case t_hidden: fputs("hidden ",fp); break;
227 case t_funcdec: fputs("dec_", fp); showFunc(&t,fp); break;
228 case t_func: showFunc(&t,fp); break;
229 case t_builtin: fputs("Builtin ",fp); showFunc(&t,fp); break;
232 fprintf(fp,"ARY[%d]",(int) EiC_getInf(t));
238 fputs("Incomplete", fp);
241 if (EiC_gettype(t) == t_struct)
242 fprintf(fp,"struct: size %u bytes",S->tsize);
244 fprintf(fp,"union: size %u bytes",S->tsize);
250 for (i = 0; i < S->n; i++) {
251 for (j = 0; j < level; j++)
255 EiC_showdectype(S->type[i], expand,fp);
262 case t_ref: fputs("Reference ",fp);break;
263 case ID: fputs("Identifier ", fp); break;
264 default: fputs("Uknown identifier", fp); return;
270 static int IsObject(int t)
272 if(t != t_func && t !=t_funcdec && t != t_builtin)
278 int EiC_IsFunc(int t)
283 static void displaySclass(symentry_t *sym)
285 /* display storage class */
286 if (sym->sclass == c_typedef)
287 fputs("typedef ", stdout);
288 else if(sym->sclass & c_private)
289 fprintf(stdout,"private to %s: ", sym->fname);
290 else if (sym->sclass & c_static)
291 fputs("static ", stdout);
292 if (sym->typequal == q_const)
293 fputs("const ", stdout);
294 else if (sym->typequal == q_volatile)
295 fputs("volatile ", stdout);
298 static void showtab(int tab, int expand, token_t * e1, char *fname, int allowed())
303 for (i = 0; i < HSIZE; i++)
304 for (sym = EiC_HTAB[i]; sym; sym = sym->next) {
306 if ((t = EiC_gettype(sym->type)) == t_eic || sym->nspace != tab)
309 if(e1 && e1->Type && ! EiC_sametypes(e1->Type,sym->type))
312 /*printf("looking at [%s]\n",sym->fname);*/
313 if(fname && strcmp(fname,sym->fname) != 0)
316 if(allowed && !allowed(t))
319 fputs(sym->id, stdout);
320 fputs(" -> ", stdout);
321 EiC_showdectype(sym->type, expand,stdout);
327 static int show(void)
330 int h = EiC_work_tab;
333 EiC_work_tab = stand_tab;
335 if ((t = EiC_lexan()) == ID || t == TYPENAME) {
336 if(!EiC_showMacro(token->Val.sym->id)) { /* test macros first */
337 t = EiC_gettype(token->Val.sym->type);
339 EiC_remsym(token->Val.sym);
341 * check for struct/union tag name.
343 if ((token->Val.sym = EiC_lookup(tag_tab, EiC_LEXEM)) == NULL) {
344 EiC_error("Unknown identifier %s",EiC_LEXEM);
347 fputs("Tag::",stdout);
350 displaySclass(token->Val.sym);
351 fputs(token->Val.sym->id, stdout);
352 fputs(" -> ", stdout);
353 EiC_showdectype(token->Val.sym->type, 1,stdout);
356 /* -----------------------------------------------------*/
358 t = EiC_gettype(token->Val.sym->type);
359 if (! (token->Val.sym->sclass == c_typedef ||
360 (t==t_builtin) || (t==t_func) || (t==t_funcdec)))
362 fputs("value= ", stdout);
364 arg.v=EiC_ENV->AR[token->Val.sym->val.ival].v;
365 arg.type = token->Val.sym->type;
372 /* -------------------------------------------------*/
373 if (t == t_func && EiC_listcodeON) {
374 if (EiC_ENV->AR[token->Val.sym->val.ival].v.p.p)
375 EiC_listcode(EiC_ENV->AR[token->Val.sym->val.ival].v.p.p);
378 EiC_remsym(token->Val.sym);
380 EiC_error("Expected identifier");
385 static char *getNextInput()
389 static char buf[256];
391 while(isspace(c = EiC_nextchar()));
393 while( c && c != DONE && !isspace(c)) {
403 static int ResetEiC()
406 void EiCp_ResetStart(void);
407 void EiCp_setResetStart(void);
409 buf = getNextInput();
411 if(strcmp(buf,"here") == 0)
412 EiCp_setResetStart();
414 EiC_error("Unrecgonised command `%s' for reset",buf);
421 static int filesCommand(void)
423 void EiC_showIncludedFiles(void);
424 void EiC_showFileMacros(char *fname);
425 char EiC_nextchar(void);
427 int EiC_IsIncluded(char *fname);
430 buf = getNextInput();
433 if(!EiC_IsIncluded(buf))
434 EiC_warningerror("Failed to find %s",buf);
436 EiC_showFileMacros(buf);
437 showtab(stand_tab,0,NULL,buf,IsObject);
438 showtab(stand_tab,0,NULL,buf,EiC_IsFunc);
441 EiC_showIncludedFiles();
446 static int clearCommand(void)
449 * syntax :clear file1[,file]*
452 int EiC_lutClearFileEntries(char *FileName);
453 void EiC_ClearFileMacros(char *fname);
454 void EiC_rmIncludeFileName(char *fname);
456 char EiC_nextchar(void);
458 int EiC_IsIncluded(char *fname);
461 buf = getNextInput();
470 if(!EiC_IsIncluded(buf))
471 EiC_warningerror("Failed to find %s",buf);
473 int r = EiC_lutClearFileEntries(buf);
474 EiC_ClearFileMacros(buf);
476 EiC_rmIncludeFileName(buf);
484 EiC_error("Expected file name");
491 static int setnextinf(void *info)
496 for (i = 0; i < HSIZE; i++)
497 for (sym = EiC_HTAB[i]; sym; sym = sym->next)
498 if ((t = EiC_gettype(sym->type)) == t_union || t == t_struct)
499 for (type = sym->type; type; type = nextType(type))
500 if (type->alias && EiC_getInf(type) == info) {
507 static void checktype(type_expr * type)
511 if ((t = EiC_gettype(type)) == t_struct || t == t_union)
513 if (setnextinf(EiC_getInf(type)))
515 type = nextType(type);
520 static long getmitem(val_t *v, int t)
523 case INT: return v->ival;
524 case UINT: return v->uival;
525 case LONG: return v->lval;
526 case ULONG: return v->ulval;
535 int t, h = EiC_work_tab;
536 EiC_work_tab = stand_tab;
538 switch(EiC_lexan()) {
541 t = EiC_gettype(token->Val.sym->type);
543 EiC_remsym(token->Val.sym);
545 * check for a tag name.
547 if((token->Val.sym = EiC_lookup(tag_tab,EiC_LEXEM)) == NULL) {
548 EiC_error("Unknown identifier %s",EiC_LEXEM);
550 checktype(token->Val.sym->type);
551 EiC_remsym(token->Val.sym);
553 } else if (t == t_builtin) {
554 EiC_error("Cannot remove builtin functions");
556 checktype(token->Val.sym->type);
557 EiC_remsym(token->Val.sym);
564 mitem = getmitem(&token->Val,token->Tok);
565 if(EiC_getMemMark(mitem) == MEM_LEAK)
566 EiC_freeMemItem(mitem);
568 EiC_error("Memory item %ld is not a leak\n", mitem);
571 EiC_error("UnExpected input to rm");
575 } while (EiC_lexan() == ',');
582 static int showhashtab(void)
587 EiC_work_tab = tab = stand_tab; /* standard name space */
590 switch(EiC_lexan()) {
597 if(strcmp(EiC_LEXEM,"tags") == 0)
599 else if(strcmp(EiC_LEXEM,"builtin") == 0)
600 e1.Type = EiC_addtype(t_builtin,0);
608 showtab(tab, 0,&e1,NULL,NULL);
609 EiC_freetype(e1.Type);
611 showtab(tab,0,NULL,NULL,IsObject);
612 showtab(tab,0,NULL,NULL,EiC_IsFunc);
617 static int extra_option(char * option)
619 EiC_work_tab = stand_tab; /* standard name space */
620 if (EiC_lexan() == ID) {
621 if(strcmp(EiC_LEXEM,option) == 0)
632 extern FILE *EiChist;
635 fputs("EiC Bye\n", stdout);
642 static int toggle_verbose()
644 EiC_verboseON = !EiC_verboseON;
645 return EiC_verboseON;
648 static int toggle_interface()
650 interfaceON = !interfaceON;
655 static int toggle_memdump()
657 EiC_memdumpON = !EiC_memdumpON;
658 return EiC_memdumpON;
661 static int toggle_memtrace()
663 EiC_memtraceON = !EiC_memtraceON;
664 return EiC_memtraceON;
667 static int toggle_showline()
669 EiC_SHOWLINE = !EiC_SHOWLINE;
674 static int toggle_timer()
676 EiC_TIMER = !EiC_TIMER;
680 static int toggle_interp()
682 EiC_interpON = !EiC_interpON;
686 static int toggle_includes()
688 EiC_showIncludes= !EiC_showIncludes;
689 return EiC_showIncludes;
692 static int toggle_trace()
694 if(extra_option("funcs"))
695 EiC_traceFunc = !EiC_traceFunc;
702 EiC_traceON = !EiC_traceON;
707 static int toggle_listcode()
709 if(extra_option("linenums"))
710 EiC_lineNums = !EiC_lineNums;
717 EiC_listcodeON = !EiC_listcodeON;
719 return EiC_listcodeON;
723 static int showhistory()
726 void EiC_show_history(FILE *fp);
727 EiC_show_history(stdout);
732 static int showHelp()
734 puts("-----------------------------------------------------------------------------\n"
735 "EiC-COMMAND SUMMARY DESCRIPTION\n"
736 "-----------------------------------------------------------------------------\n"
737 ":-I path Append path to the include-file search list.\n"
738 ":-L List search paths.\n"
739 ":-R path Remove path from the include-file search list.\n"
740 ":clear fname Removes the contents of file fname from EiC.\n"
741 ":exit Terminates an EiC session.\n"
742 ":files Display the names of all included files.\n"
743 ":files fname Summarize the contents of the included file `fname'.\n"
744 ":gen fname Generates EiC interface of the included file `fname'.\n"
745 ":gen fname [<\"outfile\">] Places the interface in outfile\n"
746 ":gen fname 4 Generates EiC interface with 4 levels of multiplexing.\n"
747 ":help Display summary of EiC commands.\n"
748 ":history List the history of all input commands.\n"
749 ":includes Display path of include files when loaded.\n"
750 ":interpreter Execute input commands. By default it is on.\n"
751 ":listcode List stack code.\n"
752 ":listcode linenums List stack code with associated line numbers.\n"
753 ":memdump Show potential memory leaks.\n"
754 ":reset Reset EiC back to its start state.\n"
755 ":reset here Set the `reset' state to EiC's current state.\n"
756 ":rm dddd Remove memory item dddd, which is a constant integer value.\n"
757 ":rm f Removes f's definition from the symbol tables.\n"
758 ":show f Shows type or macro definition of `f'.\n"
759 ":showline Show input line after macro expansion.\n"
760 ":status Display the status of the toggle switches.\n"
761 ":timer Time in seconds of execution.\n"
762 ":trace Trace function calls and line numbers during code execution.\n"
763 ":trace funcs Trace function calls only during code execution.\n"
764 ":variables Display declared variables and interpreter-ed function names.\n"
765 ":variables tags Display the tag identifiers.\n"
766 ":variables type-name Display variables of type `type-name'.\n"
767 ":verbose Suppresses EiC's copyright and warning messages on start up.\n"
768 "------------------------------------------------------------------------------\n"
773 static int EiCstatus()
779 {"includes",&EiC_showIncludes},
780 {"interpreter", &EiC_interpON},
781 {"listcode",&EiC_listcodeON},
782 {"memdump", &EiC_memdumpON},
783 {"showline",&EiC_SHOWLINE},
784 {"timer",&EiC_TIMER},
785 {"trace",&EiC_traceON},
786 {"verbose",&EiC_verboseON},
788 int n = sizeof(toggles)/sizeof(struct toggle);
791 printf("\t%-15s %d\n",toggles[n].name, *toggles[n].val);
797 static symentry_t *add_eicfunc(char *name, int (*func) ())
800 sym = EiC_insertLUT(eic_tab, name, t_eic);
802 sym->val.func = func;
806 symentry_t *EiC_add_builtinfunc(char *name, val_t(*vfunc) ())
808 symentry_t *sym = EiC_lookup(1, name);
811 sym = EiC_insertLUT(stand_tab, name, ID);
812 EiC_freetype(sym->type);
814 sym->val.vfunc = vfunc;
815 sym->type = EiC_addtype(t_builtin,NULL);
820 sym->val.vfunc = vfunc;
821 sym->type->obj = t_builtin;
822 /* EiC_freetype(sym->type->nxt);
830 void EiC_comm_switch(void)
832 int EiC_insertpath(char *);
833 int EiC_removepath(char *);
834 void EiC_listpath(void);
835 char EiC_nextchar(void);
838 if (EiC_lexan() == ID) {
839 if(EiC_gettype(token->Val.sym->type) == ID) {
840 EiC_remsym(token->Val.sym);
843 buf = getNextInput();
845 switch(EiC_LEXEM[0]) {
847 if(!*buf || !EiC_insertpath(buf))
848 EiC_warningerror("Failed to add path");
851 if(!*buf || !EiC_removepath(buf))
852 EiC_warningerror("Failed to remove path");
855 EiC_listpath();break;
857 EiC_error("Unknown command switch");
861 EiC_error("Expected command switch");
868 /* Jean-Bruno Richard personal Modification inside eicmod.c */
870 /* Semi-automatic module code generation */
871 /* functions. Thanks to the function prototype, it's possible to */
872 /* generate it's interfacing function to EiC. */
873 /* Few manual modification of the generated code are sometimes needed, */
874 /* but it helps a lot.... */
875 /* How to use it : */
876 /* Launch EiC, #include the desired header file */
877 /* (Example #include "gl.h") */
878 /* and use the new EiC command :gen with the name of the header file */
879 /* (In the example :gen gl.h) EiC will output the interface to stdout */
880 /* Hope it helps..... : */
881 /* jean-bruno.richard@mg2.com */
888 static int callBack=0;
889 static int * callNo =NULL;
890 static int *callpos = NULL;
891 static int Ncalls = 0;
892 static char *callName="EiC_Cfunc_";
893 static char *middleName="MiddleOne_";
894 static int MULTIPLEX = 1;
896 static void EiC__generateType(type_expr *t, char *id,FILE *fp, int level)
907 switch(EiC_gettype(t)) {
908 case t_pointer: /* pointer */
909 sprintf(tmp,"*%s",out);
913 case t_char: sprintf(tmp,"%s %s", "char", out); strcpy(out,tmp); break;
914 case t_uchar: sprintf(tmp,"%s %s", "unsigned char",out);strcpy(out,tmp); break;
915 case t_short: sprintf(tmp,"%s %s", "short",out);strcpy(out,tmp);break;
916 case t_ushort: sprintf(tmp,"%s %s", "unsigned short",out);strcpy(out,tmp);break;
917 case t_int: sprintf(tmp,"%s %s", "int",out);strcpy(out,tmp);break;
918 case t_uint: sprintf(tmp,"%s %s", "unsigned",out);strcpy(out,tmp);break;
919 case t_long: sprintf(tmp,"%s %s", "long",out);strcpy(out,tmp);break;
920 case t_ulong: sprintf(tmp,"%s %s", "unsigned long",out);strcpy(out,tmp);break;
921 case t_float: sprintf(tmp,"%s %s", "float",out);strcpy(out,tmp);break;
922 case t_double: sprintf(tmp,"%s %s", "double",out);strcpy(out,tmp);break;
923 case t_void: sprintf(tmp,"%s %s", "void",out);strcpy(out,tmp);break;
927 if(EiC_gettype(t) == t_union)
930 fputs("struct {",fp);
934 fputs("Incomplete", fp);
940 for (i = 0; i < S->n; i++) {
941 EiC__generateType(S->type[i], S->id[i], fp,level);
945 sprintf(tmp,"} %s ",out);
950 case t_array: /* array */
952 sprintf(tmp,"(%s)%s",out,"[]");
955 sprintf(tmp,"[%d]",(int)EiC_getInf(t));
963 } while ( (t=nextType(t)));
965 fprintf(fp,"%s",out);
968 static int DoCallBackNames(func_t *F, FILE *fp)
973 callpos = realloc(callpos,sizeof(int)*getFNp(F));
974 for (i = 0; i < getFNp(F); i++) {
975 type_expr *t = getFPty(F,i);
976 if(EiC_gettype(t) == t_pointer &&
977 EiC_IsFunc(EiC_gettype(nextType(t)))) {
978 callNo = realloc(callNo, sizeof(*callNo) * (x+1));
980 callNo[x] = callBack++;
981 fprintf(fp,"static void * %s%d = NULL;\n",callName,callNo[x]);
990 static void genCallBackFunc(type_expr *ty,
1000 t = getFPty(F,callpos[p]);
1004 fprintf(fp,"static ");
1005 EiC_showdectype(nextType(t),0,fp);
1007 fprintf(fp," %s%d(",middleName,callNo[p]);
1009 /* check 4 varadic function calls */
1010 for(i=0;i<getFNp(F2);i++)
1011 if(EiC_gettype(getFPty(F2,i)) == t_var) {
1017 for(i=0;i<getFNp(F2)-1;i++) {
1018 if((v=EiC_gettype(getFPty(F2,i))) == t_void)
1020 sprintf(buff,"x%d, ",i);
1021 EiC__generateType(getFPty(F2,i),buff,fp,1);
1024 if((v=EiC_gettype(getFPty(F2,i))) != t_void) {
1025 sprintf(buff,"x%d ",i);
1026 EiC__generateType(getFPty(F2,i),buff,fp,1);
1028 fprintf(fp,")\n{\n");
1030 for (i = 0; i < getFNp(F2); i++) {
1031 if(EiC_gettype(getFPty(F2,i)) == t_void)
1033 fprintf(fp," setArg(%d, %s%d, ",i,callName,callNo[p]);
1035 EiC__generateType(getFPty(F2,i),"",fp,1);
1037 fprintf(fp,",x%d);\n",i);
1041 fprintf(fp," va_alist ) va_dcl\n{\n");
1042 fprintf(fp," void Auto_EiC_CallBack(code_t *callback, va_list ap);\n");
1043 fprintf(fp," va_list ap; va_start(ap);\n");
1044 fprintf(fp," Auto_EiC_CallBack(%s%d,ap);\n",callName,callNo[p]);
1047 fprintf(fp,"\n EiC_callBack(%s%d);\n",callName,callNo[p]);
1049 if(EiC_gettype(nextType(t)) != t_void) {
1050 fputs(" return EiC_ReturnValue( ",fp);
1051 /*EiC_showdectype(nextType(t),0,fp);*/
1052 EiC__generateType(nextType(t),"",fp,1);
1056 fputs(" va_end(ap);\n",fp);
1064 static void genArg(type_expr * t, int idx, FILE *fp)
1067 if ((ob = EiC_gettype(t)) == t_void) {
1071 if(ob == t_pointer) {
1072 int k = EiC_gettype((nextType(t)));
1075 while(k<Ncalls && callpos[k] != idx) k++;
1076 fprintf(fp,"%s%d",middleName,callNo[k]+adjustNum);
1082 fprintf(fp,"%d",idx);
1083 fputs(",getargs(),",fp);
1086 case t_char: fputs("char)", fp); break;
1087 case t_uchar: fputs("char)", fp); break;
1088 case t_short: fputs("short)", fp); break;
1089 case t_ushort:fputs("short)", fp); break;
1090 case t_int: fputs("int)", fp); break;
1091 case t_uint: fputs("unsigned)", fp); break;
1092 case t_long: fputs("long) ", fp); break;
1093 case t_ulong: fputs("unsigned long)", fp); break;
1094 case t_float: fputs("float)", fp); break;
1095 case t_double:fputs("double)", fp); break;
1097 fputs("ptr_t).p",fp);
1099 default: fputs("Uknown identifier", fp); return;
1103 static void genAffect(type_expr * t, int expand, FILE *fp)
1107 switch (EiC_gettype(t)) {
1110 case t_int: fputs("v.ival = ", fp); break;
1113 case t_uint: fputs("v.uival = ", fp); break;
1114 case t_long: fputs("v.lval = ", fp); break;
1115 case t_ulong: fputs("v.ulval = ", fp); break;
1117 case t_double:fputs("v.dval = ", fp); break;
1121 fputs("v.p.ep = (void*)ULONG_MAX;\n"
1122 "\tv.p.sp = v.p.p = ",fp);
1124 fputs("v.p.ep = v.p.sp = v.p.p = ", fp);
1127 case t_hidden: break;
1130 fprintf(fp,"ARY[%d]",(int) EiC_getInf(t));
1136 fputs("Incomplete", fp);
1139 if (EiC_gettype(t) == t_struct)
1140 fprintf(fp,"struct: size %u bytes",S->tsize);
1142 fprintf(fp,"union: size %u bytes",S->tsize);
1148 for (i = 0; i < S->n; i++) {
1149 for (j = 0; j < level; j++)
1151 fputs(S->id[i], fp);
1153 EiC_showdectype(S->type[i], expand,fp);
1160 case t_ref: fputs("Reference ",fp);break;
1161 case ID: fputs("Identifier ", fp); break;
1163 default: fputs("Uknown identifier", fp); return;
1167 static void genCall(type_expr *t, char *fname, FILE *fp)
1169 static int level = 0;
1173 F = (func_t *) EiC_getInf(t);
1180 for(k=0;k<Ncalls;++k)
1181 fprintf(fp,"\t%s%d = arg(%d,getargs(),ptr_t).p;\n",
1182 callName,callNo[k],callpos[k]);
1195 if (F && getFNp(F)) {
1196 for (i = 0; i < getFNp(F); i++) {
1197 genArg(getFPty(F,i), i, fp);
1198 if(i < getFNp(F)-1) {
1211 static void genMultiCall(type_expr *t, char *fname, FILE *fp)
1213 static int level = 0;
1218 F = (func_t *) EiC_getInf(t);
1221 fputs("\tstatic int nb = 0;\n\n",fp);
1223 fprintf(fp,"\tswitch(nb)\n");
1224 fprintf(fp,"\t{\n");
1225 for (n = 0;n < MULTIPLEX;++n)
1227 adjustNum = n+1-MULTIPLEX;
1228 fprintf(fp,"\tcase %d :\n",n);
1232 for(k=0;k<Ncalls;++k)
1233 fprintf(fp,"\t%s%d = arg(%d,getargs(),ptr_t).p;\n",
1234 callName,callNo[k]+adjustNum,callpos[k]);
1256 if (F && getFNp(F)) {
1257 for (i = 0; i < getFNp(F); i++) {
1258 genArg(getFPty(F,i), i, fp);
1259 if(i < getFNp(F)-1) {
1270 fprintf(fp,"\tbreak;\n");
1272 fprintf(fp,"\t}\n");
1273 fprintf(fp,"\t++nb;\n");
1274 fprintf(fp,"\tnb %%= %d;\n",MULTIPLEX);
1279 static void genFunctions(int tab, int expand,
1282 int allowed(), FILE *fp)
1288 for (i = 0; i < HSIZE; i++)
1289 for (sym = EiC_HTAB[i]; sym; sym = sym->next) {
1290 if ((t = EiC_gettype(sym->type)) == t_eic || sym->nspace != tab)
1293 if(e1 && e1->Type && ! EiC_sametypes(e1->Type,sym->type))
1296 if(mname && strcmp(mname,sym->fname) != 0)
1299 if(allowed && !allowed(t))
1306 if(DoCallBackNames(EiC_getInf(sym->type),fp)) {
1314 genCallBackFunc(sym->type,k++,fp);
1320 fputs("static val_t eic_",fp);
1322 fputs("(void)\n",fp);
1325 fputs("\tval_t v;\n",fp);
1326 /*fputs("\tstatic int nb = 0;\n",fp);*/
1330 genMultiCall(sym->type, sym->id, fp);
1334 genCall(sym->type, sym->id, fp);
1338 fputs("\treturn v;\n",fp);
1349 static void genInterface(int tab,
1360 strcpy(iname,mname);
1361 pt = strrchr(iname,'.');
1366 pt = strrchr(iname,'/');
1376 fputs("/**********************************/\n\n",fp);
1378 fprintf(fp,"void module_%s()\n",pt);
1382 for (i = 0; i < HSIZE; i++)
1383 for (sym = EiC_HTAB[i]; sym; sym = sym->next) {
1385 if ((t = EiC_gettype(sym->type)) == t_eic || sym->nspace != tab)
1388 if(e1 && e1->Type && ! EiC_sametypes(e1->Type,sym->type))
1391 if(mname && strcmp(mname,sym->fname) != 0)
1394 if(EiC_IsFunc(t) || sym->sclass == c_typedef || sym->sclass == c_enum)
1397 fprintf(fp,"\tEiC_parseString(\"");
1398 EiC__generateType(sym->type,sym->id,fp,1);
1399 fprintf(fp," @ %%ld;\", (long)&%s);\n",sym->id);
1404 for (i = 0; i < HSIZE; i++)
1405 for (sym = EiC_HTAB[i]; sym; sym = sym->next) {
1407 if ((t = EiC_gettype(sym->type)) == t_eic || sym->nspace != tab)
1410 if(e1 && e1->Type && ! EiC_sametypes(e1->Type,sym->type))
1413 if(mname && strcmp(mname,sym->fname) != 0)
1419 fprintf(fp,"\tEiC_add_builtinfunc(\"%s\",eic_%s);\n",sym->id,sym->id);
1423 fputs("/**********************************/\n\n",fp);
1426 static void genHeader(char *mname, FILE *fp)
1428 fputs("#include <stdlib.h>\n"
1429 "#include <varargs.h>\n"
1430 "#include <limits.h>\n"
1431 "#include \"eic.h\"\n",fp);
1432 fprintf(fp,"#include \"%s\"\n",mname);
1436 static void genModule(int tab, int expand, token_t * e1, char *mname)
1440 if(EiC_lexan() == INT)
1441 MULTIPLEX = token->Val.ival;
1445 if(EiC_lexan() == STR) {
1446 fp = fopen(token->Val.p.p,"w");
1447 EiC_formatMessage("redirecting to [%s]\n",(char*)token->Val.p.p);
1449 EiC_warningerror("Failed to open file %s\n", token->Val.p.p);
1455 genHeader(mname,fp);
1456 genFunctions(tab, expand, e1, mname, EiC_IsFunc,fp);
1457 genInterface(tab, expand, e1, mname,fp);
1467 * By Jean-Bruno Richard
1470 static int genCommand(void)
1472 char EiC_nextchar(void);
1473 int EiC_IsIncluded(char *fname);
1477 buf = getNextInput();
1479 if(!EiC_IsIncluded(buf))
1480 EiC_warningerror("Failed to find %s",buf);
1482 genModule(stand_tab,0,NULL,buf);
1485 EiC_warningerror("Need a included file name for generating module");
1492 static void establish_ARs(void)
1494 EiC_ENV->LARsize = 4000;
1495 EiC_ENV->ARsize = 3000;
1496 EiC_ENV->LAR =(AR_t*)xmalloc(sizeof(AR_t)*EiC_ENV->LARsize);
1497 EiC_ENV->AR = (AR_t*)xmalloc(sizeof(AR_t)*EiC_ENV->ARsize);
1500 void EiC_init_EiC(void)
1502 EiC_ENV = (environ_t *) xcalloc(1, sizeof(environ_t));
1503 EiC_ENV->CODE.Filename = "::EiC::";
1507 EiC_work_tab = stand_tab;
1508 /*init_hashtab(31);*/
1509 /* add EiC command line functions */
1510 add_eicfunc("listcode", toggle_listcode);
1511 add_eicfunc("interpreter", toggle_interp);
1512 add_eicfunc("variables", showhashtab);
1513 add_eicfunc("exit", EiC_exit_EiC);
1514 add_eicfunc("quit", EiC_exit_EiC);
1515 add_eicfunc("timer", toggle_timer);
1516 add_eicfunc("showline", toggle_showline);
1517 add_eicfunc("show", show);
1518 add_eicfunc("memdump", toggle_memdump);
1519 add_eicfunc("memtrace", toggle_memtrace);
1520 add_eicfunc("rm", rm);
1521 add_eicfunc("trace",toggle_trace);
1522 add_eicfunc("verbose",toggle_verbose);
1523 add_eicfunc("interface",toggle_interface);
1526 add_eicfunc("history",showhistory);
1528 add_eicfunc("help", showHelp);
1529 add_eicfunc("status",EiCstatus);
1530 add_eicfunc("includes",toggle_includes);
1531 add_eicfunc("files",filesCommand);
1532 add_eicfunc("clear",clearCommand);
1534 add_eicfunc("gen",genCommand);
1535 add_eicfunc("reset",ResetEiC);
1536 /* Remenber to modify help message too... */