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