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;
}
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;
}
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 void success(int ival)
{
int i, size;
size = (int) (lex_curpos - lex_lastpos);
memcpy(EiC_LEXEM, &lex_buff[lex_lastpos], size);
EiC_LEXEM[size] = '\0';
if (Lseen) size--;
if (Useen) size--;
if (Fseen) size--;
Hseen = 0;
switch (ival) {
case ID:
if ((token->Tok = EiC_iskeyword(cwords, EiC_LEXEM,
sizeof(cwords) / sizeof(keyword_t))) == 0)
{
if(size > 64) //maks: avoid crash when enter a very long identifier
{
EiC_error("Identifier is too large");
return;
}
token->Tok = ID;
/* search for id in various name spaces */
if ((token->Val.sym = EiC_lookup(EiC_work_tab, EiC_LEXEM)) == NULL)
if(bCanInsertSymbol) token->Val.sym = EiC_insertLUT(EiC_work_tab, EiC_LEXEM, ID); //maks
if (token->Val.sym)
if (token->Val.sym->sclass == c_typedef)
token->Tok = TYPENAME;
}
break;
case OCTAL:
if (Fseen)
EiC_error("Declaration syntax error");
for (lexival = 0, i = 0; i < size; i++)
lexival = lexival * 8 + getoct(EiC_LEXEM[i]);
Hseen = 1;
setintval();
break;
case HEX:
for (lexival = 0, i = 2; i < size; i++)
lexival = lexival * 16 + gethex(EiC_LEXEM[i]);
Hseen = 1;
setintval();
break;
case TOKEN_INT:
for (lexival = 0, i = 0; i < size; i++)
lexival = lexival * 10 + EiC_LEXEM[i] - '0';
setintval();
break;
case TOKEN_FLOAT:
if (Useen)
EiC_error("Declaration syntax error");
lexfval = atof(EiC_LEXEM);
setfloatval();
break;
case RELOP:
case MISC:
break;
}
}
