char
moto_isVarGlobal(MotoEnv *env, char *name) {
MotoVar* var;
if ((var = (MotoVar *)stab_get(env->frame->symtab, name)) == NULL) {
int i = env->frameindex;
while (--i >= 0) {
MotoFrame *frame = (MotoFrame *)vec_get(env->frames, i);
SymbolTable *symtab = frame->symtab;
if ((var = (MotoVar *)stab_get(symtab, name)) != NULL) {
break;
}
if (frame->type == FN_FRAME)
break;
}
}
/* If we still don't have it, check the globals */
if(var==NULL) {
var=stab_get(env->globals, name);
if(var!=NULL) return '\1';
}
return '\0';
}
static int addr_exp_data(stab_t stab,
struct addr_exp_state *s, const char *text)
{
int value;
if (!s->last_operator || s->last_operator == ')') {
fprintf(stderr, "syntax error at token %s\n", text);
return -1;
}
/* Hex value */
if (*text == '0' && text[1] == 'x')
value = strtoul(text + 2, NULL, 16);
else if (isdigit(*text))
value = atoi(text);
else if (stab_get(stab, text, &value) < 0) {
fprintf(stderr, "can't parse token: %s\n", text);
return -1;
}
if (s->data_stack_size + 1 > ARRAY_LEN(s->data_stack)) {
fprintf(stderr, "data stack overflow at token %s\n", text);
return -1;
}
s->data_stack[s->data_stack_size++] = value;
s->last_operator = 0;
return 0;
}
static int addr_exp_data(struct addr_exp_state *s, const char *text)
{
address_t value;
if (!s->last_operator || s->last_operator == ')') {
printc_err("syntax error at token %s\n", text);
return -1;
}
/* Hex value */
if (*text == '0' && text[1] == 'x') {
value = strtoul(text + 2, NULL, 16);
} else if (*text == '0' && text[1] == 'd') {
value = atoi(text + 2);
} else if (stab_get(text, &value) < 0) {
char *end;
value = strtol(text, &end, opdb_get_numeric("iradix"));
if (*end) {
printc_err("can't parse token: %s\n", text);
return -1;
}
}
if (s->data_stack_size + 1 > ARRAY_LEN(s->data_stack)) {
printc_err("data stack overflow at token %s\n", text);
return -1;
}
s->data_stack[s->data_stack_size++] = value;
s->last_operator = 0;
return 0;
}
MotoMacro *motopp_getMacro(MotoPP *ppenv, char *name) {
MotoMacro *m = NULL;
int size = stack_size(ppenv->macrostack);
int i;
for (i = 1; i <= size; i++) {
SymbolTable *macros = stack_peekAt(ppenv->macrostack, i);
if ((m = stab_get(macros, name)) != NULL) {
break;
}
}
return m;
}
void
moto_emitCGlobals(MotoEnv *env, StringBuffer *out) {
Enumeration* e;
buf_puts(out, "/* BEGIN GENERATED GLOBAL DECLARATIONS */\n\n");
e = stab_getKeys(env->globals);
while (enum_hasNext(e)) {
char* n = (char*)enum_next(e);
MotoVar* mv = stab_get(env->globals,n);
buf_printf(out,"static %s _G_%s=%s;\n", moto_valToCType(mv->vs), n,moto_defaultValForCType(mv->vs));
}
enum_free(e);
buf_puts(out, "/* END GENERATED GLOBAL DECLARATIONS */\n\n");
}
MotoVar *
moto_declareVar(MotoEnv *env, char* varn, char *typen, int dim , char isGlobal) {
MotoVar *var;
var = stab_get(env->frame->symtab, varn);
/* Blow up if the var has already been defined in this frame */
excp_assert(var == NULL, THROW_D("IllegalArgumentException"));
var = moto_createVar(env,varn,typen,dim,'\0',NULL);
if(isGlobal)
stab_put(env->globals, var->n, var);
else
stab_put(env->frame->symtab, var->n, var);
return var;
}
void motopp_freeFrame(MotoPP *ppenv) {
MotoPPFrame *frame;
Enumeration *e;
if (stack_size(ppenv->frames) <= 1) {
frame = stack_pop(ppenv->frames);
buf_cat(ppenv->out, frame->out);
ppenv->frame = NULL;
}
else {
MotoPPVal *val;
MotoPPFrame *pframe;
SymbolTable *macros;
MotoMacro *m;
char *catstr;
int catstrlen;
frame = stack_pop(ppenv->frames);
pframe = stack_peek(ppenv->frames);
switch (frame->type) {
case MACRO_FRAME:
m = frame->macro;
val = motopp_createVal(ppenv);
if (ppenv->flags & MACRO_DEBUG_FLAG) {
buf_printf(frame->out, LINE_FMT_2, pframe->filename, pframe->lineno);
}
val->sval = buf_toString(frame->out);
stack_push(pframe->opstack, val);
macros = stack_pop(ppenv->macrostack);
e = stab_getKeys(macros);
while (enum_hasNext(e)) {
char *name = (char *)enum_next(e);
MotoMacro *m = (MotoMacro *)stab_get(macros, name);
motopp_freeMacro(m);
}
stab_free(macros);
enum_free(e);
break;
case INCLUDE_FRAME:
catstr = buf_data(frame->out);
catstrlen = strlen(catstr);
if (catstr[catstrlen - 1] == '\n') {
catstr[catstrlen - 1] = '\0';
}
buf_puts(pframe->out, catstr);
if (ppenv->flags & MACRO_DEBUG_FLAG) {
buf_printf(pframe->out, LINE_FMT_2, pframe->filename, pframe->lineno);
}
break;
default:
buf_cat(pframe->out, frame->out);
break;
}
/* reset pplineno */
pplineno = pframe->lineno;
/* reset frame */
ppenv->frame = pframe;
}
if (frame->yybuf != NULL) {
if (shared_check(frame->yybuf)) {
motopp_freeYYBuffer(frame->yybuf);
}
}
if (frame->yybufmem != NULL) {
free(frame->yybufmem);
}
buf_free(frame->out);
stack_free(frame->opstack);
free(frame->filename);
free(frame->relative_root);
free(frame);
}
void motopp_freeEnv(MotoPP *ppenv) {
Enumeration *e;
log_debug(__FILE__, ">>> motopp_freeEnv\n");
buf_free(ppenv->out);
buf_free(ppenv->err);
buf_free(ppenv->argbuf);
istack_free(ppenv->dirstack);
stack_free(ppenv->frames);
/* free vals */
e = hset_elements(ppenv->vallist);
while (enum_hasNext(e)) {
MotoPPVal *val = enum_next(e);
if (shared_check(val->sval)) {
free(val->sval);
hset_remove(ppenv->ptrs, val->sval);
}
free(val);
}
enum_free(e);
hset_free(ppenv->vallist);
/* free macros */
while (stack_size(ppenv->macrostack) > 0) {
SymbolTable *macros = stack_pop(ppenv->macrostack);
e = stab_getKeys(macros);
while (enum_hasNext(e)) {
char *name = (char *)enum_next(e);
MotoMacro *m = (MotoMacro *)stab_get(macros, name);
motopp_freeMacro(m);
}
stab_free(macros);
enum_free(e);
}
/* free all remaining sys pointers */
e = hset_elements(ppenv->sysptrs);
while (enum_hasNext(e)) {
void *ptr = enum_next(e);
if (ptr) {
sys_free(ptr);
}
}
enum_free(e);
/* free all remaining pointers */
e = hset_elements(ppenv->ptrs);
while (enum_hasNext(e)) {
void *ptr = enum_next(e);
if (shared_check(ptr)) {
free(ptr);
}
}
enum_free(e);
/* free remaining pooled memory */
mpool_free(ppenv->mpool);
/* free remainder of env struct */
hset_free(ppenv->sysptrs);
hset_free(ppenv->ptrs);
stack_free(ppenv->macrostack);
free(ppenv);
log_debug(__FILE__, "<<< motopp_freeEnv\n");
}
void
moto_freeFrame(MotoEnv *env) {
MotoFrame *frame = env->frame;
MotoFrame *pframe = NULL;
StringBuffer *pout = NULL;
Enumeration *e;
/* Append declarations if in compiler mode and not in a function frame*/
if (env->mode == COMPILER_MODE && frame->type != FN_FRAME) {
if (frame->type == MAIN_FRAME)
pout = env->out;
else if(frame->type == SUB_FRAME)
pout = ((MotoFrame *)vec_get(env->frames, env->frameindex - 1))->out;
e = stab_getKeys(frame->symtab);
while (enum_hasNext(e)) {
int indent = env->frameindex+1;
char* n = (char*)enum_next(e);
MotoVar* mv = (MotoVar*)stab_get(frame->symtab,n);
while (--indent >= 0)
buf_puts(pout, " ");
buf_printf(pout,"%s %s=%s;\n", moto_valToCType(mv->vs), n,moto_defaultValForCType(mv->vs));
}
enum_free(e);
buf_puts(pout, "\n");
if (frame->type == MAIN_FRAME) /* FIXME : big hack to get out buffer set for functions */
buf_printf(pout,"out = outputBuffer;\n");
}
switch (frame->type) {
case MAIN_FRAME:
/* append buffer from frame to env main buffer */
pout = env->out;
buf_cat(pout, frame->out);
break;
case FN_FRAME:
if (env->mode != COMPILER_MODE) {
/* append buffer from frame current function buffer */
pframe = (MotoFrame *)vec_get(env->frames, env->frameindex - 1);
buf_cat(pframe->out, frame->out);
} else {
/* append buffer from frame current function buffer */
buf_cat(env->fcodebuffer, frame->out);
}
break;
case SUB_FRAME:
default:
/* append buffer from frame to buffer in parent frame */
pframe = (MotoFrame *)vec_get(env->frames, env->frameindex - 1);
buf_cat(pframe->out, frame->out);
break;
}
/* Release the frame's output buffer */
opool_release(env->bufpool,frame->out);
/* Free frame structure */
opool_release(env->stkpool,frame->opstack);
/* Free vars and associated vals */
e = stab_getKeys(frame->symtab);
while (enum_hasNext(e)) {
char* n = (char*)enum_next(e);
MotoVar* var = (MotoVar*)stab_get(frame->symtab,n);
/* Do not free vars that are class member vars */
if(env->mode != COMPILER_MODE) {
moto_freeVal(env,var->vs);
} else {
opool_release(env->valpool,var->vs);
}
free(var);
}
enum_free(e);
stab_free(frame->symtab);
/* set new frame */
vec_removeAt(env->frames, env->frameindex);
env->frameindex = env->frameindex - 1;
if(env->frameindex < 0)
env->frame = NULL;
else
env->frame = vec_get(env->frames, env->frameindex);
free(frame);
}
void
moto_freeEnv(MotoEnv *env) {
Enumeration *e;
/* Free any outstanding frames */
while(vec_size(env->frames) > 0) {
moto_freeFrame(env);
}
/* Free all the globals */
e = stab_getKeys(env->globals);
while (enum_hasNext(e)) {
char* n = (char*)enum_next(e);
MotoVar* var = stab_get(env->globals,n);
if(env->mode != COMPILER_MODE) {
moto_freeVal(env,var->vs);
} else {
opool_release(env->valpool,var->vs);
}
free(var);
}
enum_free(e);
stab_free(env->globals);
/* free all cached regular expressions */
e = stab_getKeys(env->rxcache);
while (enum_hasNext(e)) {
char *rx = (char *)enum_next(e);
MDFA *mdfa = (MDFA *)stab_get(env->rxcache, rx);
if (mdfa != NULL) {
mdfa_free(mdfa);
}
}
enum_free(e);
/* free all remaining pointers */
e = hset_elements(env->ptrs);
while (enum_hasNext(e)) {
void *ptr = enum_next(e);
if (shared_check(ptr)) {
free(ptr);
}
}
enum_free(e);
/* free all errors */
e = sset_elements(env->errs);
while (enum_hasNext(e)) {
void *ptr = enum_next(e);
if (shared_check(ptr)) {
free(ptr);
}
}
enum_free(e);
/* free all scopes */
e = stack_elements(env->scope);
while (enum_hasNext(e)) {
free(enum_next(e));
}
enum_free(e);
/* free all cells */
moto_freeTreeCells(env);
/* free all class defs */
stab_free(env->cdefs);
/* free remainder of env struct */
hset_free(env->ptrs);
buf_free(env->out);
buf_free(env->err);
stab_free(env->types);
vec_free(env->frames);
ftab_free(env->ftable);
/* Free all the stuff that got put in the mpool ... this includes
MotoFunctions and MotoClassDefinitions */
mpool_free(env->mpool);
stack_free(env->scope);
stab_free(env->rxcache);
//stack_free(env->callstack);
sset_free(env->errs);
sset_free(env->uses);
sset_free(env->includes);
buf_free(env->fcodebuffer);
istack_free(env->scopeIDStack);
htab_free(env->fdefs);
htab_free(env->adefs);
buf_free(env->constantPool);
moto_freeTree(env->tree);
opool_free(env->valpool);
opool_free(env->bufpool);
opool_free(env->stkpool);
e = stab_getKeys(env->fcache);
while (enum_hasNext(e))
free((char *)enum_next(e));
enum_free(e);
stab_free(env->fcache);
free(env);
}
void
moto_clearEnv(MotoEnv *env) {
Enumeration *e;
int size;
//hset_free(env->ptrs);
//mpool_free(env->mpool);
/* Clear out the globals */
e = stab_getKeys(env->globals);
while (enum_hasNext(e)) {
char* n = (char*)enum_next(e);
MotoVar* var = stab_get(env->globals,n);
if(env->mode != COMPILER_MODE) {
moto_freeVal(env,var->vs);
} else {
opool_release(env->valpool,var->vs);
}
free(var);
}
enum_free(e);
stab_clear(env->globals);
/* Clear out the frames */
size = vec_size(env->frames);
while (--size >= 0) {
MotoFrame *frame = (MotoFrame *)vec_get(env->frames, size);
stack_free(frame->opstack);
stab_free(frame->symtab);
buf_free(frame->out);
free(frame);
}
vec_clear(env->frames);
e = stack_elements(env->scope);
while (enum_hasNext(e)) {
free(enum_next(e));
}
enum_free(e);
stack_clear(env->scope);
buf_clear(env->out);
buf_clear(env->err);
// stab_free(env->types);
// ftab_free(env->ftable);
// stab_free(env->rxcache);
// stack_clear(env->callstack);
sset_clear(env->errs);
// sset_clear(env->uses);
if (env->mode == COMPILER_MODE) {
sset_free(env->includes);
htab_free(env->fdefs);
htab_free(env->adefs);
buf_free(env->constantPool);
buf_free(env->fcodebuffer);
istack_free(env->scopeIDStack);
}
env->frameindex = -1;
/* error stuff */
env->meta.filename = env->filename;
env->meta.caller = NULL;
env->meta.macroname = NULL;
env->meta.lineno = 1;
env->errflag = 0;
//free(env);
}
MotoClassDefinition*
moto_getMotoClassDefinition(MotoEnv* env, char* name) {
return (MotoClassDefinition*)stab_get(env->cdefs,name);
}
MotoVar *
moto_getGlobalVar(MotoEnv *env, char *name) {
return stab_get(env->globals, name);
}
MotoVar *
moto_getFrameVar(MotoEnv *env, char *name) {
return stab_get(env->frame->symtab, name);
}