ReturnCode REGARGS
AddVar(struct Data *scr, /* pointer to struct Data */
struct Identifier *ident,/* identifier struct pointer */
struct Local **local,
uchar output)
{
ReturnCode ret;
struct Local *temp;
if(ret=AddIdentifier(scr, ident))
INFO(scr, CERROR_IDENTIFIER_USED, ident->name);
else {
GETMEM(temp, sizeof(struct Local));
temp->next=*local;
temp->ident=ident;
*local=temp;
scr->currvariables++; /* increase number of current symbols */
scr->totalvariables++; /* increase total number of symbols */
ident->number= ++IdentNumber;
if(output) {
CALL(PutArg(scr, COMP_DECLARE, ident->flags));
if(!(ident->flags&FPL_EXPORT_SYMBOL)) {
CALL(PutArg(scr, COMP_NOTHING, ident->number));
}
else {
CALL(PutArg(scr, COMP_NOTHING, ident->hash));
}
CALL(PutString(scr, COMP_NOTHING, ident->name, -1));
}
}
return(ret);
}
BOOL CIdentifiers::AddIdentifier(CString &String, DWORD Type, POINTER *pPointer)
{
char *pName;
String.GetString(&pName);
return AddIdentifier(pName, false, Type, pPointer);
}
static ReturnCode INLINE InitHash(struct Data *scr)
{
ReturnCode ret;
static struct ShitData internal_functions[]={
{"abs", FNC_ABS, 'I', "I"},
{"atoi", FNC_ATOI, 'I', "S"},
{"closelib", FNC_CLOSELIB, 'I', "S"}, /* amiga only */
{"debug", FNC_DEBUG, 'I', "i"},
{"eval", FNC_EVAL, 'I', "S"},
{"exists", FNC_EXISTS, 'I', "Si"},
{"interpret", FNC_INTERPRET, 'I', "S"},
{"itoa", FNC_ITOA, 'S', "I"},
{"itoc", FNC_ITOC, 'S', "I"},
{"joinstr", FNC_JOINSTR, 'S', "s>"},
{"ltostr", FNC_LTOSTR, 'S', "Ii"},
{"openlib", FNC_OPENLIB, 'I', "SI"}, /* amiga only */
{"rename", FNC_RENAME, 'I', "SS"},
{"sprintf", FNC_SPRINTF, 'S', "Sa>"},
{"sscanf", FNC_SSCANF, 'I', "SSa>"},
{"strcmp", FNC_STRCMP, 'I', "SS"},
{"stricmp", FNC_STRICMP, 'I', "SS"},
{"strlen", FNC_STRLEN, 'I', "S"},
{"strncmp", FNC_STRNCMP, 'I', "SSI"},
{"strnicmp", FNC_STRNICMP, 'I', "SSI"},
{"strstr", FNC_STRSTR, 'I', "SSi"},
{"stristr", FNC_STRISTR, 'I', "SSi"},
{"strtol", FNC_STRTOL, 'I', "Si"},
{"substr", FNC_SUBSTR, 'S', "SII"},
};
/* FPL keywords. "else" is not included (treated special). Is is
defines as KEYWORD_ELSE */
static struct MoreShitData keywords[]={
{"auto", CMD_AUTO, FPL_KEYWORD_DECLARE},
{"break", CMD_BREAK, 0},
{"case", CMD_CASE, 0},
{"char", CMD_INT, FPL_KEYWORD_DECLARE|FPL_CHAR_VARIABLE},
{"const", CMD_CONST, FPL_KEYWORD_DECLARE},
{"continue", CMD_CONTINUE, 0},
{"default", CMD_DEFAULT, 0},
{"do", CMD_DO, 0},
{"double", CMD_DOUBLE, FPL_IGNORE},
{"else", CMD_ELSE, 0},
{"enum", CMD_ENUM, FPL_IGNORE},
{"exit", CMD_EXIT, 0},
{"export", CMD_EXPORT, FPL_KEYWORD_DECLARE},
{"float", CMD_FLOAT, FPL_IGNORE},
{"for", CMD_FOR, 0},
{"if", CMD_IF, 0},
{"int", CMD_INT, FPL_KEYWORD_DECLARE},
{"long", CMD_INT, FPL_KEYWORD_DECLARE},
{"register",CMD_REGISTER, FPL_KEYWORD_DECLARE},
{"resize", CMD_RESIZE, 0},
{"return", CMD_RETURN, 0},
{"short", CMD_INT, FPL_KEYWORD_DECLARE|FPL_SHORT_VARIABLE},
{"signed", CMD_SIGNED, FPL_KEYWORD_DECLARE|FPL_IGNORE},
{"static", CMD_STATIC, FPL_KEYWORD_DECLARE},
{"string", CMD_STRING, FPL_KEYWORD_DECLARE},
{"struct", CMD_STRUCT, FPL_IGNORE},
{"switch", CMD_SWITCH, 0},
{"typedef", CMD_TYPEDEF, FPL_KEYWORD_DECLARE},
{"union", CMD_UNION, FPL_IGNORE},
{"unsigned",CMD_UNSIGNED, FPL_KEYWORD_DECLARE|FPL_IGNORE},
{"void", CMD_VOID, FPL_KEYWORD_DECLARE},
{"volatile",CMD_VOLATILE, FPL_KEYWORD_DECLARE|FPL_IGNORE},
{"while", CMD_WHILE, 0},
};
long i;
struct Identifier *ident;
GETMEMA(scr->hash, sizeof(struct Identifier *)* FPL_HASH_SIZE);
memset((void *)scr->hash, 0, sizeof(struct Identifier *)*FPL_HASH_SIZE);
/*
* The hash table initialization gives us a brilliant chance to bring up
* the execution speed even more by inserting the few internal functions
* into this same table. The functions will then act *EXACTLY* the same
* and we can shorten the code and much easier write internal functions
* that return strings...
*/
for(i=0; i<sizeof(internal_functions)/sizeof(struct ShitData);i++) {
GETMEMA(ident, sizeof(struct Identifier));
ident->name=internal_functions[i].name;
ident->data.external.ID=internal_functions[i].ID;
ident->data.external.ret=internal_functions[i].ret;
ident->data.external.format=internal_functions[i].format;
ident->flags=FPL_INTERNAL_FUNCTION|FPL_EXPORT_SYMBOL;
ident->level=0;
ident->func=NULL; /* all functions */
ident->file= "<FPL>"; /* internal */
ident->number = 0;
ret=AddIdentifier(scr, ident);
if(ret)
break;
}
for(i=0; i<sizeof(keywords)/sizeof(struct MoreShitData);i++) {
GETMEMA(ident, sizeof(struct Identifier));
ident->name=keywords[i].name;
ident->data.external.ID=keywords[i].ID; /* dirty enum work! */
ident->flags=FPL_EXPORT_SYMBOL|FPL_KEYWORD|keywords[i].flags;
ident->level=0;
ident->func=NULL; /* all functions */
ident->file= "<FPL>"; /* internal */
ident->number = 0;
ret=AddIdentifier(scr, ident);
if(ret)
break;
}
return(ret);
}
