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;
}
}
