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