ErrorST
SymTabMgr::leaveToScope(SymTabEntry::Kind kind) {
ErrorST rv=OK;
for (int i = top_; (i > 0) && (scopeStack_[i]->kind() != kind); i--)
rv = leaveScope();
return rv;
}
ErrorST
SymTabMgr::leaveScope(SymTabEntry::Kind kind) {
ErrorST rv = leaveToScope(kind);
if (rv == OK)
return leaveScope();
else return rv;
}
int CG_main(TreeNode* pnode,char * ffname){
int paraSize;
char buf[10000];
codename = fopen("code_part.asm", "w");
dataname = fopen("data_part.asm", "w");
EMITDATA(".INOUT_I:\n");
EMITDATA("\t.string \"%i\"\n");
EMITDATA(".OUTPUT_I_N:\n");
EMITDATA("\t.string \"%i\\n\"\n");
EMITDATA(".INOUT_C:\n");
EMITDATA("\t.string \"%c\"\n");
EMITDATA(".OUTPUT_C_N:\n");
EMITDATA("\t.string \"%c\\n\"\n");
EMITDATA(".INOUT_F:\n");
EMITDATA("\t.string \"%f\"\n");
EMITDATA(".OUTPUT_F_N:\n");
EMITDATA("\t.string \"%f\\n\"\n");
EMITDATA(".INOUT_S:\n");
EMITDATA("\t.string \"%s\"\n");
EMITDATA(".OUTPUT_S_N:\n");
EMITDATA("\t.string \"%s\\n\"\n");
EMITCODE(".text\n");
initScope();
pnode->attr.name="main";
GenCode(pnode);
paraSize=leaveScope();
sprintf(tmp, "addl $%d, %%esp\n", paraSize);
EMITCODE(tmp);
EMITCODE("leave\n");
EMITCODE("ret\n");
fclose(codename);
fclose(dataname);
if (!COMPILE_ERROR){
ff = fopen(ffname, "w");
codename = fopen("code_part.asm", "r");
dataname = fopen("data_part.asm", "r");
while(fgets(buf,BUFSIZ,dataname)!=NULL){
fputs(buf,ff);
}
while(fgets(buf,BUFSIZ,codename)!=NULL){
fputs(buf,ff);
}
fclose(codename);
fclose(dataname);
fclose(ff);
}
}
// handlerDecl ::= 'handler' IDENT (';' | [do] stmt)
std::unique_ptr<Handler> FlowParser::handlerDecl()
{
FNTRACE();
FlowLocation loc(location());
nextToken(); // 'handler'
consume(FlowToken::Ident);
std::string name = stringValue();
if (consumeIf(FlowToken::Semicolon)) { // forward-declaration
loc.update(end());
return std::make_unique<Handler>(name, loc);
}
std::unique_ptr<SymbolTable> st = enterScope("handler-" + name);
std::unique_ptr<Stmt> body = stmt();
leaveScope();
if (!body)
return nullptr;
loc.update(body->location().end);
// forward-declared / previousely -declared?
if (Handler* handler = scope()->lookup<Handler>(name, Lookup::Self)) {
if (handler->body() != nullptr) {
// TODO say where we found the other hand, compared to this one.
reportError("Redeclaring handler '%s'", handler->name().c_str());
return nullptr;
}
handler->implement(std::move(st), std::move(body));
handler->owner()->removeSymbol(handler);
return std::unique_ptr<Handler>(handler);
}
return std::make_unique<Handler>(name, std::move(st), std::move(body), loc);
}
chunk *computeInstruction(ANTLR3_BASE_TREE *node) {
debug(DEBUG_GENERATION, "\033[22;93mCompute instruction\033[0m");
chunk *chunk, *tmp_chunk;
int i, scope_tmp;
static int scope = 0;
switch (node->getType(node)) {
case INTEGER :
case STRING :
case ID :
case FUNC_CALL :
case SUP :
case INF :
case SUP_EQ :
case INF_EQ :
case EQ :
case DIFF :
case AND :
case OR :
case MINUS :
case PLUS :
case DIV :
case MULT :
case NEG :
case ASSIGNE :
return computeExpr(node);
case IF:
return computeIf(node);
case WHILE :
return computeWhile(node);
case FOR :
return computeFor(node);
case VAR_DECLARATION :
return computeVarDeclaration(node);
case FUNC_DECLARATION :
case LET :
enterScopeN(scope);
scope_tmp = scope;
scope = 0;
switch (node->getType(node)) {
case LET:
chunk = computeLet(node);
break;
case FUNC_DECLARATION:
chunk = computeFuncDeclaration(node);
break;
}
scope = scope_tmp;
scope++;
leaveScope();
return chunk;
default:
chunk = initChunk();
// Compute all children
for (i = 0; i < node->getChildCount(node); i++) {
tmp_chunk = computeInstruction(node->getChild(node, i));
appendChunks(chunk, tmp_chunk);
// appendChunks replace chunk->registre with tmp_chunk's one
// but freeChunk free the registre of tmp_chunk
// we don't want chunk->registre to be overwritten !
if (tmp_chunk != NULL)
tmp_chunk->registre = -1;
freeChunk(tmp_chunk);
}
return chunk;
}
}
void GenCode(TreeNode* pnode){
int paraSize;
switch (pnode->nodekind){
case NODE_STATEMENT:
switch (pnode->kind+(NODE_STATEMENT<<4)){
case STMT_ASSIGN:
HandleAssignStmt(pnode);
break;
case STMT_CASE:
HandleCaseStmt(pnode);
break;
case STMT_FOR:
HandleForStmt(pnode);
break;
case STMT_GOTO:
HandleGotoStmt(pnode);
break;
case STMT_IF:
HandleIfStmt(pnode);
break;
case STMT_LABEL:
HandleLabelStmt(pnode);
break;
case STMT_REPEAT:
HandleRepeatStmt(pnode);
break;
case STMT_WHILE:
HandleWhileStmt(pnode);
break;
case STMT_PROC_ID:
HandleProcExc(pnode);
break;
case STMT_PROC_SYS:
switch(pnode->attr.op)
{
case TOKEN_WRITE:
HandleOutStmt(pnode);
break;
case TOKEN_WRITELN:
HandleOutStmt(pnode);
break;
case TOKEN_READ:
HandleInStmt(pnode);
break;
default: break;
}
break;
}
break;
case NODE_EXPRESSION:
HandleNodeExp(pnode);
break;
case NODE_DECLARE:
switch (pnode->kind+(NODE_DECLARE<<4)){
case DECL_ROUTINEHEAD:
paraSize=enterNewScope(pnode);
if (pnode->child[3]!=NULL)
GenCode(pnode->child[3]);
if (strcmp(pnode->attr.name,"main")){
sprintf(tmp, "%s: \n",pnode->attr.name);
EMITCODE(tmp);
}
else {
EMITCODE(".globl main\n");
EMITCODE("\t.type main, @function\n");
EMITCODE("main:\n");
EMITCODE("pushl %ebp\n");
EMITCODE("movl %esp, %ebp\n");
EMITCODE("movl %esp, %ecx\n");
}
sprintf(tmp, "subl $%d, %%esp\n", paraSize);
EMITCODE(tmp);
break;
case DECL_FUNCTION:
funcListInsert(pnode->child[0]);
(pnode->child[1])->attr.name=(pnode->child[0])->attr.name;
GenCode(pnode->child[1]);
paraSize=leaveScope();
sprintf(tmp, "addl $%d, %%esp\n", paraSize);
EMITCODE(tmp);
EMITCODE("ret\n");
break;
case DECL_PROCEDURE:
fflush(stdout);
procListInsert(pnode->child[0]);
(pnode->child[1])->attr.name=(pnode->child[0])->attr.name;
GenCode(pnode->child[1]);
paraSize=leaveScope();
sprintf(tmp, "addl $%d, %%esp\n", paraSize);
EMITCODE(tmp);
EMITCODE("ret\n");
break;
}
break;
case NODE_TYPE:
break;
default: printf("pnode->nodekind Default");
}
if(pnode->sibling!=NULL){
GenCode(pnode->sibling);
}
}
