Skip to content

Commit 1be8edf

Browse files
ovrovr
committed
Feature(compiler): Extract code to IfStatementCodeGenerator
1 parent a2fbb0d commit 1be8edf

2 files changed

Lines changed: 63 additions & 54 deletions

File tree

‎src/backend/llvm/code-generation/if-statement.ts‎

Lines changed: 51 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,51 @@
1+
2+
import * as ts from "typescript";
3+
import * as llvm from 'llvm-node';
4+
import {NodeGenerateInterface} from "../node-generate.interface";
5+
import {Context} from "../context";
6+
import {emitCondition, passNode} from "../index";
7+
8+
export class IfStatementCodeGenerator implements NodeGenerateInterface<ts.IfStatement, void> {
9+
generate(node: ts.IfStatement, ctx: Context, builder: llvm.IRBuilder): void {
10+
const positiveBlock = llvm.BasicBlock.create(ctx.llvmContext, "if.true");
11+
ctx.scope.enclosureFunction.llvmFunction.addBasicBlock(positiveBlock);
12+
13+
const next = llvm.BasicBlock.create(ctx.llvmContext, "if.end");
14+
ctx.scope.enclosureFunction.llvmFunction.addBasicBlock(next);
15+
16+
if (node.elseStatement) {
17+
const negativeBlock = llvm.BasicBlock.create(ctx.llvmContext, "if.false");
18+
ctx.scope.enclosureFunction.llvmFunction.addBasicBlock(negativeBlock);
19+
20+
emitCondition(
21+
node.expression,
22+
ctx,
23+
builder,
24+
positiveBlock,
25+
negativeBlock
26+
);
27+
28+
builder.setInsertionPoint(negativeBlock);
29+
passNode(node.elseStatement, ctx, builder);
30+
31+
builder.createBr(next);
32+
} else {
33+
emitCondition(
34+
node.expression,
35+
ctx,
36+
builder,
37+
positiveBlock,
38+
next
39+
);
40+
}
41+
42+
builder.setInsertionPoint(positiveBlock);
43+
passNode(node.thenStatement, ctx, builder);
44+
45+
if (!positiveBlock.getTerminator()) {
46+
builder.createBr(next);
47+
}
48+
49+
builder.setInsertionPoint(next);
50+
}
51+
}

‎src/backend/llvm/index.ts‎

Lines changed: 12 additions & 54 deletions
Original file line numberDiff line numberDiff line change
@@ -29,49 +29,7 @@ import {ClassDeclarationGenerator} from "./code-generation/class-statement";
2929
import {NewExpressionGenerator} from "./code-generation/new-expression";
3030
import {ArrayLiteralExpressionCodeGenerator} from "./code-generation/array-literal-expression";
3131
import {ArrayLiteralExpression} from "typescript";
32-
33-
export function passIfStatement(parent: ts.IfStatement, ctx: Context, builder: llvm.IRBuilder) {
34-
const positiveBlock = llvm.BasicBlock.create(ctx.llvmContext, "if.true");
35-
ctx.scope.enclosureFunction.llvmFunction.addBasicBlock(positiveBlock);
36-
37-
const next = llvm.BasicBlock.create(ctx.llvmContext, "if.end");
38-
ctx.scope.enclosureFunction.llvmFunction.addBasicBlock(next);
39-
40-
if (parent.elseStatement) {
41-
const negativeBlock = llvm.BasicBlock.create(ctx.llvmContext, "if.false");
42-
ctx.scope.enclosureFunction.llvmFunction.addBasicBlock(negativeBlock);
43-
44-
emitCondition(
45-
parent.expression,
46-
ctx,
47-
builder,
48-
positiveBlock,
49-
negativeBlock
50-
);
51-
52-
builder.setInsertionPoint(negativeBlock);
53-
passNode(parent.elseStatement, ctx, builder);
54-
55-
builder.createBr(next);
56-
} else {
57-
emitCondition(
58-
parent.expression,
59-
ctx,
60-
builder,
61-
positiveBlock,
62-
next
63-
);
64-
}
65-
66-
builder.setInsertionPoint(positiveBlock);
67-
passNode(parent.thenStatement, ctx, builder);
68-
69-
if (!positiveBlock.getTerminator()) {
70-
builder.createBr(next);
71-
}
72-
73-
builder.setInsertionPoint(next);
74-
}
32+
import {IfStatementCodeGenerator} from "./code-generation/if-statement";
7533

7634
export function emitCondition(
7735
condition: ts.Expression,
@@ -502,7 +460,7 @@ export function passVariableStatement(block: ts.VariableStatement, ctx: Context,
502460
export function passStatement(stmt: ts.Statement, ctx: Context, builder: llvm.IRBuilder) {
503461
switch (stmt.kind) {
504462
case ts.SyntaxKind.Block:
505-
passBlockStatement(<any>stmt, ctx, builder);
463+
passBlockStatement(stmt as ts.Block, ctx, builder);
506464
break;
507465
case ts.SyntaxKind.VariableDeclaration:
508466
passVariableDeclaration(<any>stmt, ctx, builder);
@@ -517,31 +475,31 @@ export function passStatement(stmt: ts.Statement, ctx: Context, builder: llvm.IR
517475
buildFromExpression(<any>stmt, ctx, builder);
518476
break;
519477
case ts.SyntaxKind.FunctionDeclaration:
520-
passFunctionDeclaration(<any>stmt, ctx, builder);
478+
passFunctionDeclaration(stmt as ts.FunctionDeclaration, ctx, builder);
521479
break;
522480
case ts.SyntaxKind.ReturnStatement:
523-
new ReturnStatementCodeGenerator().generate(<any>stmt, ctx, builder);
481+
new ReturnStatementCodeGenerator().generate(stmt as ts.ReturnStatement, ctx, builder);
524482
break;
525483
case ts.SyntaxKind.ClassDeclaration:
526-
new ClassDeclarationGenerator().generate(<any>stmt, ctx, builder);
484+
new ClassDeclarationGenerator().generate(stmt as ts.ClassDeclaration, ctx, builder);
527485
break;
528486
case ts.SyntaxKind.BreakStatement:
529-
new BreakStatementGenerator().generate(<any>stmt, ctx, builder);
487+
new BreakStatementGenerator().generate(stmt as ts.BreakStatement, ctx, builder);
530488
break;
531489
case ts.SyntaxKind.ContinueStatement:
532-
new ContinueStatementGenerator().generate(<any>stmt, ctx, builder);
490+
new ContinueStatementGenerator().generate(stmt as ts.ContinueStatement, ctx, builder);
533491
break;
534492
case ts.SyntaxKind.IfStatement:
535-
passIfStatement(<any>stmt, ctx, builder);
493+
new IfStatementCodeGenerator().generate(stmt as ts.IfStatement, ctx, builder);
536494
break;
537495
case ts.SyntaxKind.ForStatement:
538-
new ForStatementGenerator().generate(<any>stmt, ctx, builder);
496+
new ForStatementGenerator().generate(stmt as ts.ForStatement, ctx, builder);
539497
break;
540498
case ts.SyntaxKind.DoStatement:
541-
new DoStatementGenerator().generate(<any>stmt, ctx, builder);
499+
new DoStatementGenerator().generate(stmt as ts.DoStatement, ctx, builder);
542500
break;
543501
case ts.SyntaxKind.WhileStatement:
544-
new WhileStatementGenerator().generate(<any>stmt, ctx, builder);
502+
new WhileStatementGenerator().generate(stmt as ts.WhileStatement, ctx, builder);
545503
break;
546504
case ts.SyntaxKind.BinaryExpression:
547505
new BinaryExpressionCodeGenerator().generate(<any>stmt, ctx, builder);
@@ -571,7 +529,7 @@ function passBlockStatement(node: ts.Block, ctx: Context, builder: llvm.IRBuilde
571529
}
572530
}
573531

574-
function passNode(node: ts.Node, ctx: Context, builder: llvm.IRBuilder) {
532+
export function passNode(node: ts.Node, ctx: Context, builder: llvm.IRBuilder) {
575533
switch (node.kind) {
576534
case ts.SyntaxKind.Block:
577535
passBlockStatement(<any>node, ctx, builder);

0 commit comments

Comments
 (0)