int doEntry() { func_t *F; symentry_t *sym; sym = EiC_lookup(stand_tab,"main"); if(!sym) { if(!ScriptMode) EiC_messageDisplay("Error: Missing `main'\n"); return 0; } if(sym) { if(EiC_gettype(sym->type) != t_func) { EiC_messageDisplay("Error: `main' NOT DECLARED as a function\n"); return 0; } /* check return type of main */ if(EiC_gettype(nextType(sym->type)) != t_int) { EiC_messageDisplay("Error: function `main' MUST return an `int' type\n"); return 0; } /* get number of arguments */ F = EiC_getInf(sym->type); if(getFNp(F) <= 1) /* allow for void argument */ EiC_prolineString(FORMAT1); else if(getFNp(F) <= 2) EiC_prolineString(FORMAT2); else EiC_messageDisplay("Error: too many arguments being " "passed to `main'\n"); /*EiC_prolineString(FORMAT3);*/ } return 1; }
int EiC_checkPeepHole(token_t *e1,int op) { /* * A simple arithmetic optimizer: * do not add or subtract 0 * and do not multiply or divide by 1 */ int v = 0; if (isconst(e1->Type)) { if (op == '+' || op == '-') switch (EiC_gettype(e1->Type)) { CASE_INT: CASE_UINT:v = e1->Val.ival == 0; break; CASE_LONG: CASE_ULONG:v = e1->Val.lval == 0; break; CASE_FLOAT:v = e1->Val.dval == 0; break; } else if (op == '*') switch (EiC_gettype(e1->Type)) { CASE_INT: CASE_UINT:v = e1->Val.ival == 1; break; CASE_LONG: CASE_ULONG:v = e1->Val.lval == 1; break; CASE_FLOAT:v = e1->Val.dval == 1; break; } } return v; }
static int show(void) { int t; int h = EiC_work_tab; AR_t arg; EiC_work_tab = stand_tab; if ((t = EiC_lexan()) == ID || t == TYPENAME) { if(!EiC_showMacro(token->Val.sym->id)) { /* test macros first */ t = EiC_gettype(token->Val.sym->type); if (t == ID) { EiC_remsym(token->Val.sym); /* * check for struct/union tag name. */ if ((token->Val.sym = EiC_lookup(tag_tab, EiC_LEXEM)) == NULL) { EiC_error("Unknown identifier %s",EiC_LEXEM); return 0; } fputs("Tag::",stdout); } displaySclass(token->Val.sym); fputs(token->Val.sym->id, stdout); fputs(" -> ", stdout); EiC_showdectype(token->Val.sym->type, 1,stdout); fputc('\n',stdout); /* -----------------------------------------------------*/ t = EiC_gettype(token->Val.sym->type); if (! (token->Val.sym->sclass == c_typedef || (t==t_builtin) || (t==t_func) || (t==t_funcdec))) { fputs("value= ", stdout); arg.v=EiC_ENV->AR[token->Val.sym->val.ival].v; arg.type = token->Val.sym->type; EiC_showvalue(&arg); } /* -------------------------------------------------*/ if (t == t_func && EiC_listcodeON) { if (EiC_ENV->AR[token->Val.sym->val.ival].v.p.p) EiC_listcode(EiC_ENV->AR[token->Val.sym->val.ival].v.p.p); } } else EiC_remsym(token->Val.sym); } else EiC_error("Expected identifier"); EiC_work_tab = h; return 1; }
void EiC_comm_switch(void) { int EiC_insertpath(char *); int EiC_removepath(char *); void EiC_listpath(void); char EiC_nextchar(void); char *buf; if (EiC_lexan() == ID) { if(EiC_gettype(token->Val.sym->type) == ID) { EiC_remsym(token->Val.sym); } buf = getNextInput(); switch(EiC_LEXEM[0]) { case 'I': if(!*buf || !EiC_insertpath(buf)) EiC_warningerror("Failed to add path"); break; case 'R': if(!*buf || !EiC_removepath(buf)) EiC_warningerror("Failed to remove path"); break; case 'L': EiC_listpath();break; default: EiC_error("Unknown command switch"); } } else EiC_error("Expected command switch"); }
static void showstruct(AR_t * arg) { int i, t; struct_t *S; char *D; S = (struct_t *) EiC_getInf(arg->type); D = arg->v.p.p; fputc('{', stdout); if (!D) fputs("(null struct) ", stdout); else for (i = 0; i < S->n; i++) { switch ((t = EiC_gettype(S->type[i]))) { case t_array: fputs("Array", stdout); break; case t_union: fputs("Union",stdout); break; case t_struct: fputs("Struct", stdout); break; default: outputval(t, &D[S->offset[i]]); break; } fputc(',', stdout); } fputs("\b}", stdout); }
static void showtab(int tab, int expand, token_t * e1, char *fname, int allowed()) { int i, t; symentry_t *sym; for (i = 0; i < HSIZE; i++) for (sym = EiC_HTAB[i]; sym; sym = sym->next) { if ((t = EiC_gettype(sym->type)) == t_eic || sym->nspace != tab) continue; if(e1 && e1->Type && ! EiC_sametypes(e1->Type,sym->type)) continue; /*printf("looking at [%s]\n",sym->fname);*/ if(fname && strcmp(fname,sym->fname) != 0) continue; if(allowed && !allowed(t)) continue; displaySclass(sym); fputs(sym->id, stdout); fputs(" -> ", stdout); EiC_showdectype(sym->type, expand,stdout); fputc('\n', stdout); } }
static int DoCallBackNames(func_t *F, FILE *fp) { int x = 0; if (F) { int i; callpos = realloc(callpos,sizeof(int)*getFNp(F)); for (i = 0; i < getFNp(F); i++) { type_expr *t = getFPty(F,i); if(EiC_gettype(t) == t_pointer && EiC_IsFunc(EiC_gettype(nextType(t)))) { callNo = realloc(callNo, sizeof(*callNo) * (x+1)); callpos[x] = i; callNo[x] = callBack++; fprintf(fp,"static void * %s%d = NULL;\n",callName,callNo[x]); x++; } } } return (Ncalls = x); }
static void checktype(type_expr * type) { int t; while (type) { if ((t = EiC_gettype(type)) == t_struct || t == t_union) if (!type->alias) if (setnextinf(EiC_getInf(type))) type->alias = 1; type = nextType(type); } }
static void genArg(type_expr * t, int idx, FILE *fp) { int ob; if ((ob = EiC_gettype(t)) == t_void) { return; } if(ob == t_pointer) { int k = EiC_gettype((nextType(t))); if(EiC_IsFunc(k)) { k = 0; while(k<Ncalls && callpos[k] != idx) k++; fprintf(fp,"%s%d",middleName,callNo[k]+adjustNum); return ; } } fputs("arg(",fp); fprintf(fp,"%d",idx); fputs(",getargs(),",fp); switch (ob) { case t_char: fputs("char)", fp); break; case t_uchar: fputs("char)", fp); break; case t_short: fputs("short)", fp); break; case t_ushort:fputs("short)", fp); break; case t_int: fputs("int)", fp); break; case t_uint: fputs("unsigned)", fp); break; case t_long: fputs("long) ", fp); break; case t_ulong: fputs("unsigned long)", fp); break; case t_float: fputs("float)", fp); break; case t_double:fputs("double)", fp); break; case t_pointer: fputs("ptr_t).p",fp); break; default: fputs("Uknown identifier", fp); return; } }
static int rm(void) { unsigned long mitem; int t, h = EiC_work_tab; EiC_work_tab = stand_tab; do { switch(EiC_lexan()) { case ID: case TYPENAME: t = EiC_gettype(token->Val.sym->type); if (t == ID) { EiC_remsym(token->Val.sym); /* * check for a tag name. */ if((token->Val.sym = EiC_lookup(tag_tab,EiC_LEXEM)) == NULL) { EiC_error("Unknown identifier %s",EiC_LEXEM); }else { checktype(token->Val.sym->type); EiC_remsym(token->Val.sym); } } else if (t == t_builtin) { EiC_error("Cannot remove builtin functions"); } else { checktype(token->Val.sym->type); EiC_remsym(token->Val.sym); } break; case INT: case UINT: case LONG: case ULONG: mitem = getmitem(&token->Val,token->Tok); if(EiC_getMemMark(mitem) == MEM_LEAK) EiC_freeMemItem(mitem); else EiC_error("Memory item %ld is not a leak\n", mitem); break; default: EiC_error("UnExpected input to rm"); break; } } while (EiC_lexan() == ','); retractlexan(); EiC_work_tab = h; return 1; }
static int setnextinf(void *info) { int i, t; symentry_t *sym; type_expr *type; for (i = 0; i < HSIZE; i++) for (sym = EiC_HTAB[i]; sym; sym = sym->next) if ((t = EiC_gettype(sym->type)) == t_union || t == t_struct) for (type = sym->type; type; type = nextType(type)) if (type->alias && EiC_getInf(type) == info) { type->alias = 0; return 1; } return 0; }
void EiC_showvalue(AR_t * arg) { int t; if(!EiC_interActive || !arg->type) return ; fputc('\t', stdout); t = EiC_gettype(arg->type); if(isconst(arg->type) && t != t_pointer) { outputval(t, &arg->v); fputc('\n', stdout); return; } switch ((t = EiC_gettype(arg->type))) { case t_union: fputs("(Union)",stdout); break; case t_struct: showstruct(arg); break; case t_char: case t_uchar: case t_short: case t_ushort: outputval(t_int, &arg->v.ival); break; case t_float: outputval(t_double, &arg->v.ival); break; case t_array: case t_pointer: if (EiC_gettype(nextType(arg->type)) == t_char) t = STR; else t = t_pointer; default: outputval(t, &arg->v); break; } fputc('\n', stdout); }
static void genCallBackFunc(type_expr *ty, int p, FILE *fp) { char buff[10]; func_t *F, *F2; int i,v, var=0; type_expr *t; F = EiC_getInf(ty); t = getFPty(F,callpos[p]); t = nextType(t); F2 = EiC_getInf(t); fprintf(fp,"static "); EiC_showdectype(nextType(t),0,fp); fprintf(fp," %s%d(",middleName,callNo[p]); /* check 4 varadic function calls */ for(i=0;i<getFNp(F2);i++) if(EiC_gettype(getFPty(F2,i)) == t_var) { var = 1; break; } if(!var) { for(i=0;i<getFNp(F2)-1;i++) { if((v=EiC_gettype(getFPty(F2,i))) == t_void) continue; sprintf(buff,"x%d, ",i); EiC__generateType(getFPty(F2,i),buff,fp,1); } if((v=EiC_gettype(getFPty(F2,i))) != t_void) { sprintf(buff,"x%d ",i); EiC__generateType(getFPty(F2,i),buff,fp,1); } fprintf(fp,")\n{\n"); for (i = 0; i < getFNp(F2); i++) { if(EiC_gettype(getFPty(F2,i)) == t_void) continue; fprintf(fp," setArg(%d, %s%d, ",i,callName,callNo[p]); EiC__generateType(getFPty(F2,i),"",fp,1); fprintf(fp,",x%d);\n",i); } } else { fprintf(fp," va_alist ) va_dcl\n{\n"); fprintf(fp," void Auto_EiC_CallBack(code_t *callback, va_list ap);\n"); fprintf(fp," va_list ap; va_start(ap);\n"); fprintf(fp," Auto_EiC_CallBack(%s%d,ap);\n",callName,callNo[p]); } fprintf(fp,"\n EiC_callBack(%s%d);\n",callName,callNo[p]); if(EiC_gettype(nextType(t)) != t_void) { fputs(" return EiC_ReturnValue( ",fp); /*EiC_showdectype(nextType(t),0,fp);*/ EiC__generateType(nextType(t),"",fp,1); fputs(");\n",fp); } if(var) fputs(" va_end(ap);\n",fp); fputs("}\n\n",fp); }
static void EiC__generateType(type_expr *t, char *id,FILE *fp, int level) { struct_t *S; char tmp[100]; char out[100]; strcpy(out,id); do { switch(EiC_gettype(t)) { case t_pointer: /* pointer */ sprintf(tmp,"*%s",out); strcpy(out,tmp); break; case t_char: sprintf(tmp,"%s %s", "char", out); strcpy(out,tmp); break; case t_uchar: sprintf(tmp,"%s %s", "unsigned char",out);strcpy(out,tmp); break; case t_short: sprintf(tmp,"%s %s", "short",out);strcpy(out,tmp);break; case t_ushort: sprintf(tmp,"%s %s", "unsigned short",out);strcpy(out,tmp);break; case t_int: sprintf(tmp,"%s %s", "int",out);strcpy(out,tmp);break; case t_uint: sprintf(tmp,"%s %s", "unsigned",out);strcpy(out,tmp);break; case t_long: sprintf(tmp,"%s %s", "long",out);strcpy(out,tmp);break; case t_ulong: sprintf(tmp,"%s %s", "unsigned long",out);strcpy(out,tmp);break; case t_float: sprintf(tmp,"%s %s", "float",out);strcpy(out,tmp);break; case t_double: sprintf(tmp,"%s %s", "double",out);strcpy(out,tmp);break; case t_void: sprintf(tmp,"%s %s", "void",out);strcpy(out,tmp);break; case t_struct: case t_union: if(EiC_gettype(t) == t_union) fputs("union {",fp); else fputs("struct {",fp); S = EiC_getInf(t); if(!S) { fputs("Incomplete", fp); break; } level++; if (level <= 2) { int i; for (i = 0; i < S->n; i++) { EiC__generateType(S->type[i], S->id[i], fp,level); fputs(";",fp); } } sprintf(tmp,"} %s ",out); strcpy(out,tmp); level--; break; case t_array: /* array */ if(out[0] == '*') { sprintf(tmp,"(%s)%s",out,"[]"); strcpy(out,tmp); } else { sprintf(tmp,"[%d]",(int)EiC_getInf(t)); strcat(out, tmp); } break; } } while ( (t=nextType(t))); fprintf(fp,"%s",out); }
static void EiC_showdectype(type_expr * t, int expand, FILE *fp) { struct_t *S; int i; static int level = 0; while (t) { if(isconst(t) || isconstp(t)) fputs("const ",fp); switch (EiC_gettype(t)) { case t_var: fputs("...", fp); break; case t_enum: fputs("enum ", fp); break; case t_char: fputs("char ", fp); break; case t_uchar: fputs("unsigned char ", fp); break; case t_short: fputs("short ", fp); break; case t_ushort:fputs("unsigned short ", fp); break; case t_int: fputs("int ", fp); break; case t_uint: fputs("unsigned ", fp); break; case t_long: fputs("long int ", fp); break; case t_ulong: fputs("unsigned long int ", fp); break; case t_llong: fputs("long long ",fp); break; case t_float: fputs("float ", fp); break; case t_double:fputs("double ", fp); break; case t_pointer: if(isunsafe(t)) fputs("unsafe ", fp); /*else if(issafe(t)) fputs("safe ", fp);*/ fputs("* ", fp); break; case t_void: fputs("void ", fp); break; case t_hidden: fputs("hidden ",fp); break; case t_funcdec: fputs("dec_", fp); showFunc(&t,fp); break; case t_func: showFunc(&t,fp); break; case t_builtin: fputs("Builtin ",fp); showFunc(&t,fp); break; case t_array: fprintf(fp,"ARY[%d]",(int) EiC_getInf(t)); break; case t_union: case t_struct: S = EiC_getInf(t); if(!S) { fputs("Incomplete", fp); break; } if (EiC_gettype(t) == t_struct) fprintf(fp,"struct: size %u bytes",S->tsize); else fprintf(fp,"union: size %u bytes",S->tsize); if (expand) { level++; fputc('\n', fp); if (level <= 2) { int j; for (i = 0; i < S->n; i++) { for (j = 0; j < level; j++) fputc('\t', fp); fputs(S->id[i], fp); fputs(" -> ", fp); EiC_showdectype(S->type[i], expand,fp); fputc('\n', fp); } } level--; } break; case t_ref: fputs("Reference ",fp);break; case ID: fputs("Identifier ", fp); break; default: fputs("Uknown identifier", fp); return; } t = nextType(t); } }
static void genInterface(int tab, int expand, token_t * e1, char *mname, FILE *fp) { char *pt; int i, t; symentry_t *sym; char iname[255]; strcpy(iname,mname); pt = strrchr(iname,'.'); if (pt) { *pt = '\0'; } pt = strrchr(iname,'/'); if (pt) { ++pt; } else { pt = iname; } fputs("/**********************************/\n\n",fp); fprintf(fp,"void module_%s()\n",pt); fputs("{\n",fp); for (i = 0; i < HSIZE; i++) for (sym = EiC_HTAB[i]; sym; sym = sym->next) { if ((t = EiC_gettype(sym->type)) == t_eic || sym->nspace != tab) continue; if(e1 && e1->Type && ! EiC_sametypes(e1->Type,sym->type)) continue; if(mname && strcmp(mname,sym->fname) != 0) continue; if(EiC_IsFunc(t) || sym->sclass == c_typedef || sym->sclass == c_enum) continue; fprintf(fp,"\tEiC_parseString(\""); EiC__generateType(sym->type,sym->id,fp,1); fprintf(fp," @ %%ld;\", (long)&%s);\n",sym->id); } for (i = 0; i < HSIZE; i++) for (sym = EiC_HTAB[i]; sym; sym = sym->next) { if ((t = EiC_gettype(sym->type)) == t_eic || sym->nspace != tab) continue; if(e1 && e1->Type && ! EiC_sametypes(e1->Type,sym->type)) continue; if(mname && strcmp(mname,sym->fname) != 0) continue; if(!EiC_IsFunc(t)) continue; fprintf(fp,"\tEiC_add_builtinfunc(\"%s\",eic_%s);\n",sym->id,sym->id); } fputs("}\n\n",fp); fputs("/**********************************/\n\n",fp); }
static void genFunctions(int tab, int expand, token_t * e1, char *mname, int allowed(), FILE *fp) { int i, n, t; int multiplexed; symentry_t *sym; for (i = 0; i < HSIZE; i++) for (sym = EiC_HTAB[i]; sym; sym = sym->next) { if ((t = EiC_gettype(sym->type)) == t_eic || sym->nspace != tab) continue; if(e1 && e1->Type && ! EiC_sametypes(e1->Type,sym->type)) continue; if(mname && strcmp(mname,sym->fname) != 0) continue; if(allowed && !allowed(t)) continue; n = 1; multiplexed = 0; while (n) { if(DoCallBackNames(EiC_getInf(sym->type),fp)) { int k = 0; if (!multiplexed) { multiplexed = 1; n = MULTIPLEX; } while(k<Ncalls) { genCallBackFunc(sym->type,k++,fp); } } --n; } fputs("static val_t eic_",fp); fputs(sym->id, fp); fputs("(void)\n",fp); fputs("{\n",fp); fputs("\tval_t v;\n",fp); /*fputs("\tstatic int nb = 0;\n",fp);*/ if (multiplexed) { genMultiCall(sym->type, sym->id, fp); } else { genCall(sym->type, sym->id, fp); } fputs("\n",fp); fputs("\treturn v;\n",fp); fputs("}\n\n",fp); } }
static void genAffect(type_expr * t, int expand, FILE *fp) { fputs("\t", fp); switch (EiC_gettype(t)) { case t_char: case t_short: case t_int: fputs("v.ival = ", fp); break; case t_uchar: case t_ushort: case t_uint: fputs("v.uival = ", fp); break; case t_long: fputs("v.lval = ", fp); break; case t_ulong: fputs("v.ulval = ", fp); break; case t_float: case t_double:fputs("v.dval = ", fp); break; case t_pointer: if(isunsafe(t)) fputs("v.p.ep = (void*)ULONG_MAX;\n" "\tv.p.sp = v.p.p = ",fp); else if(issafe(t)) fputs("v.p.ep = v.p.sp = v.p.p = ", fp); break; case t_void: break; case t_hidden: break; /* case t_array: fprintf(fp,"ARY[%d]",(int) EiC_getInf(t)); break; case t_union: case t_struct: S = EiC_getInf(t); if(!S) { fputs("Incomplete", fp); break; } if (EiC_gettype(t) == t_struct) fprintf(fp,"struct: size %u bytes",S->tsize); else fprintf(fp,"union: size %u bytes",S->tsize); if (expand) { level++; fputc('\n', fp); if (level <= 2) { int j; for (i = 0; i < S->n; i++) { for (j = 0; j < level; j++) fputc('\t', fp); fputs(S->id[i], fp); fputs(" -> ", fp); EiC_showdectype(S->type[i], expand,fp); fputc('\n', fp); } } level--; } break; case t_ref: fputs("Reference ",fp);break; case ID: fputs("Identifier ", fp); break; */ default: fputs("Uknown identifier", fp); return; } }