void TranslateStatementListBody(const SyntaxTree& tree, ostream& stream, int indentation) { stream << endl; if (tree.Children.size() == 1) { TranslateStatement(*tree.Children[0], stream, indentation); } else { TranslateStatement(*tree.Children[0], stream, indentation); TranslateStatementListBody(*tree.Children[1], stream, indentation); } }
/* 翻译一个函数 */ static void TranslateFunction (AstFunction func) { BBlock bb; FSYM = func->fsym; if (!FSYM->defined) return; TempNum = 0; /* 创建函数中间代码的开始结束 */ FSYM->entryBB = CreateBBlock (); FSYM->exitBB = CreateBBlock (); /* 当前中间代码的入口点 */ CurrentBB = FSYM->entryBB; /* 翻译函数体中的语句 */ TranslateStatement (func->stmt); /* 函数结束 */ StartBBlock (FSYM->exitBB); /* 中间代码优化 */ Optimize (FSYM); static int i = 0; /* 给基本块创建名字 */ for (bb = FSYM->entryBB; bb; bb = bb->next) { if (bb->ref != 0) { bb->sym = CreateLabel (); } } }
/* 翻译default 语句 */ static void TranslateDefaultStatement (AstStatement stmt) { AstDefaultStatement defStmt = AsDef(stmt); /* 在switch 中已经创建 */ StartBBlock (defStmt->respBB); TranslateStatement (defStmt->stmt); }
/* 翻译case 语句 */ static void TranslateCaseStatement(AstStatement stmt) { AstCaseStatement caseStmt = AsCase(stmt); /* 在switch 中已经创建 */ StartBBlock (caseStmt->respBB); TranslateStatement (caseStmt->stmt); }
/* 翻译一个复合语句 */ static void TranslateCompoundStatement (AstStatement stmt) { AstCompoundStatement compStmt = AsComp (stmt); AstNode p; Vector ilocals = compStmt->ilocals; Symbol v; int i; /* 翻译局部变量 */ for (i = 0; i < LEN (ilocals); ++i) { InitData initd; Type ty; Symbol dst, src; int size; v = GET_ITEM (ilocals, i); initd = AsVar(v)->idata; size = 0; while (initd != NULL) { if (initd->offset != size) { dst = CreateOffset (T(UCHAR), v, size); GenerateClear (dst, initd->offset - size); } ty = initd->expr->ty; if (initd->expr->op == OP_STR) { String str = initd->expr->val.p; src = AddString (ArrayOf (str->len + 1, ty->bty), str); } else { src = TranslateExpression (initd->expr); } dst = CreateOffset (ty, v, initd->offset); /* 赋值 */ GenerateMove (ty, dst, src); size = initd->offset + ty->size; initd = initd->next; } if (size < v->ty->size) { dst = CreateOffset (T(UCHAR), v, size); GenerateClear (dst, v->ty->size - size); } } for (p = compStmt->stmts; p; p = p->next) { TranslateStatement ((AstStatement)p); } }
/* 翻译if 语句 * * if (expr) stmt is translated into: * if ! expr goto nextBB * trueBB: * stmt * nextBB: * ... * * if (expr) stmt1 else stmt2 is translated into: * if ! expr goto falseBB * trueBB: * stmt1 * goto nextBB * falseBB: * stmt2 * nextBB: * ... */ static void TranslateIfStatement(AstStatement stmt) { AstIfStatement ifStmt = AsIf(stmt); BBlock nextBB; BBlock trueBB; BBlock falseBB; nextBB = CreateBBlock (); trueBB = CreateBBlock (); if (ifStmt->elseStmt == NULL) { /* 没有false 模块,如果条件不成立则直接跳到if 之后的模块 */ TranslateBranch (Not (ifStmt->expr), nextBB, trueBB); /* 条件成立,进入if 内 */ StartBBlock (trueBB); /* 翻译if 分支语句 */ TranslateStatement (ifStmt->thenStmt); } else { falseBB = CreateBBlock (); TranslateBranch (Not(ifStmt->expr), falseBB, trueBB); StartBBlock (trueBB); TranslateStatement (ifStmt->thenStmt); /* if 语句出来直接跳转到 next */ GenerateJump (nextBB); /* else 模块 */ StartBBlock (falseBB); TranslateStatement (ifStmt->elseStmt); } /* if 之后的模块 */ StartBBlock (nextBB); }
/* 翻译并行语句 */ static void TranslateParallelStatement (AstStatement stmt) { AstParallelStatement parall = AsParall(stmt); /* 设置并行块标志 */ isParall = 1; parall->respBB = CreateBBlock (); StartBBlock (parall->respBB); /* 该模块中创建的所有块都是并行块 */ TranslateStatement (parall->stmt); /* 并行块翻译完成 */ isParall = 0; StartBBlock (CreateBBlock ()); }
/* 翻译标签语句 */ static void TranslateLabelStatement (AstStatement stmt) { AstLabelStatement labelStmt = AsLabel(stmt); /* 若标签没有被引用,则直接翻译后边的语句 */ if (labelStmt->label->ref > 0) { if (labelStmt->label->respBB == NULL) { labelStmt->label->respBB = CreateBBlock (); } /* 将标签的基本块设置为当前基本块 */ StartBBlock (labelStmt->label->respBB); } /* 翻译标签后的语句 */ TranslateStatement (labelStmt->stmt); }
/** * 翻译do 语句 * * do stmt while (expr) is translated into: * loopBB: * stmt * contBB: * if (expr) goto loopBB * nextBB: * ... */ static void TranslateDoStatement (AstStatement stmt) { AstLoopStatement doStmt = AsLoop(stmt); doStmt->loopBB = CreateBBlock (); doStmt->contBB = CreateBBlock (); doStmt->nextBB = CreateBBlock (); /* do 语句先执行循环体 */ StartBBlock (doStmt->loopBB); TranslateStatement (doStmt->stmt); /* 判断条件,分支 */ StartBBlock (doStmt->contBB); TranslateBranch (doStmt->expr, doStmt->loopBB, doStmt->nextBB); StartBBlock (doStmt->nextBB); }
/** * 翻译for 语句 * * for (expr1; expr2; expr3) stmt is translated into * expr1 * goto testBB * loopBB: * stmt * contBB: * expr3 * testBB: * if expr2 goto loopBB (goto loopBB if expr2 is NULL) * nextBB: * ... * Please pay attention to the difference between for and while * The continue point and loop test point is same for a while statemnt, * but different for a for statment. */ static void TranslateForStatement(AstStatement stmt) { AstForStatement forStmt = AsFor(stmt); forStmt->loopBB = CreateBBlock (); forStmt->contBB = CreateBBlock (); forStmt->testBB = CreateBBlock (); forStmt->nextBB = CreateBBlock (); /* for 的初始条件 */ if (forStmt->initExpr) { TranslateExpression (forStmt->initExpr); } /* 跳转到条件判断 */ GenerateJump (forStmt->testBB); /* 循环体 */ StartBBlock (forStmt->loopBB); TranslateStatement (forStmt->stmt); /* 步长 */ StartBBlock (forStmt->contBB); if (forStmt->incrExpr) { TranslateExpression (forStmt->incrExpr); } /* 测试条件,是否跳转 */ StartBBlock (forStmt->testBB); if (forStmt->expr) { TranslateBranch (forStmt->expr, forStmt->loopBB, forStmt->nextBB); } else { GenerateJump (forStmt->loopBB); } StartBBlock (forStmt->nextBB); }
/** * 翻译while 语句 * * while (expr) stmt is translated into: * goto contBB * loopBB: * stmt * contBB: * if (expr) goto loopBB * nextBB: * ... */ static void TranslateWhileStatement (AstStatement stmt) { AstLoopStatement whileStmt = AsLoop(stmt); /* 循环体基本块 */ whileStmt->loopBB = CreateBBlock (); /* 继续判断条件 */ whileStmt->contBB = CreateBBlock (); /* 循环结束后基本块 */ whileStmt->nextBB = CreateBBlock (); /* 条件 */ GenerateJump (whileStmt->contBB); /* 循环体 */ StartBBlock (whileStmt->loopBB); TranslateStatement (whileStmt->stmt); /* 判断条件,分支 */ StartBBlock (whileStmt->contBB); TranslateBranch (whileStmt->expr, whileStmt->loopBB, whileStmt->nextBB); StartBBlock (whileStmt->nextBB); }
/* 翻译switch 语句 * 创建case default 基本块 */ static void TranslateSwitchStatement (AstStatement stmt) { AstSwitchStatement swtchStmt = AsSwitch(stmt); AstCaseStatement p, q; SwitchBucket bucket, b; SwitchBucket *bucketArray; int i, val; Symbol sym; /* 翻译switch 的表达式 */ sym = TranslateExpression (swtchStmt->expr); bucket = b = NULL; p = swtchStmt->cases; /* 创建基本块, 并给case 语句排序 */ while ( p ) { q = p; p = p->nextCase; /* 给case 创建基本块 */ q->respBB = CreateBBlock (); /* case 的表达式 */ val = q->expr->val.i[0]; if (bucket && (bucket->ncase + 1) * 2 > (val - bucket->minVal)) { bucket->ncase++; bucket->maxVal = val; *bucket->tail = q; bucket->tail = &(q->nextCase); swtchStmt->nbucket -= MergeSwitchBucket (&bucket); } else { CALLOC(b); b->cases = q; b->ncase = 1; /* 初始化最小大值 */ b->minVal = b->maxVal = val; b->tail = &(q->nextCase); b->prev = bucket; bucket = b; swtchStmt->nbucket++; } } swtchStmt->buckets = bucket; bucketArray = HeapAllocate (CurrentHeap, swtchStmt->nbucket * sizeof (SwitchBucket)); for (i = swtchStmt->nbucket - 1; i >= 0; i--) { bucketArray[i] = bucket; *bucket->tail = NULL; bucket = bucket->prev; } /* default 语句 */ swtchStmt->defBB = CreateBBlock(); if (swtchStmt->defStmt) { swtchStmt->defStmt->respBB = swtchStmt->defBB; swtchStmt->nextBB = CreateBBlock(); } else { swtchStmt->nextBB = swtchStmt->defBB; } TranslateSwitchBuckets (bucketArray, 0, swtchStmt->nbucket - 1, sym, NULL, swtchStmt->defBB); TranslateStatement (swtchStmt->stmt); StartBBlock (swtchStmt->nextBB); }