/* 翻译表达式 */
static void TranslateExpressionStatement (AstStatement stmt)
{
AstExpressionStatement exprStmt = AsExpr(stmt);
if (exprStmt->expr != NULL) {
TranslateExpression (exprStmt->expr);
}
}
/* 翻译一个复合语句 */
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);
}
}
/**
* 翻译return 语句
* A return statement terminates execution of current function.
*/
static void TranslateReturnStatement (AstStatement stmt)
{
AstReturnStatement retStmt = AsRet(stmt);
if (retStmt->expr) {
GenerateReturn (retStmt->expr->ty, TranslateExpression (retStmt->expr));
}
GenerateJump (FSYM->exitBB);
StartBBlock (CreateBBlock());
}
/**
* 翻译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);
}
/* 翻译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);
}
void TranslateExpressionHeader(const SyntaxTree& tree, ostream& stream, int indentation)
{
TranslateExpression(*tree.Children[0], stream, indentation);
RemoveLastSymbol(stream);
}
