Add simple if condition support

.github/workflows/build.yml

@@ -64,31 +64,27 @@ jobs:
  - name: Build
  run: npm run build
 
- - name: Compile
+ - name: Compile, Assemble, Link, and Run
  run: |
- npm run start tests/inputs/simple.c
- npm run start tests/inputs/fn.c
+ INPUTS=("simple" "fn" "if")
 
- - name: Assemble and Link
- run: |
- nasm -f elf32 simple.asm -o simple.o
- gcc -m32 -o simple simple.o
- nasm -f elf32 fn.asm -o fn.o
- gcc -m32 -o fn fn.o
+ for FILE in "${INPUTS[@]}"; do
+ npm run start "tests/inputs/$FILE.c"
+ done
+
+ for FILE in "${INPUTS[@]}"; do
+ nasm -f elf32 "$FILE.asm" -o "$FILE.o"
+ gcc -m32 -o "$FILE" "$FILE.o"
+ done
 
- - name: Run the executables
- run: |
  set +e
- ./simple
- RETURN_VALUE=$?
- if [[ $RETURN_VALUE -ne 5 ]]; then
- echo "Unexpected return value from the executable: $RETURN_VALUE"
- exit 1
- fi
- ./fn
- RETURN_VALUE=$?
- if [[ $RETURN_VALUE -ne 5 ]]; then
- echo "Unexpected return value from the executable: $RETURN_VALUE"
- exit 2
- fi
+ for FILE in "${INPUTS[@]}"; do
+ ./"$FILE"
+ RETURN_VALUE=$?
+ if [[ $RETURN_VALUE -ne 5 ]]; then
+ echo "Unexpected return value from the $FILE executable: $RETURN_VALUE"
+ exit 1
+ fi
+ done
+
  exit 0

src/ast.ts

@@ -7,7 +7,8 @@ export type ASTNode =
  | ReturnStatementNode
  | FunctionDeclarationNode
  | ParameterNode
- | FunctionCallNode;
+ | FunctionCallNode
+ | IfStatementNode;
 
 export interface IdentifierNode {
  type: 'Identifier';
@@ -60,3 +61,9 @@ export interface FunctionCallNode {
  identifier: IdentifierNode;
  arguments: ASTNode[];
 }
+
+export interface IfStatementNode {
+ type: 'IfStatement';
+ condition: ASTNode;
+ body: ASTNode[];
+}

src/codegen.ts

@@ -7,6 +7,7 @@ import {
 
 let assemblyCode = '';
 let dataSegment = 'section .data\n';
+let labelCounter = 0;
 
 function generateAssemblyCode(ast: ASTNode[]): string {
  assemblyCode = '';
@@ -69,6 +70,15 @@ function generateStatement(node: ASTNode, parameters: ParameterNode[]): void {
  generateExpression(node.argument, parameters);
  break;
 
+ case 'IfStatement': {
+ const endLabel = generateUniqueLabel('end_if');
+ generateCondition(node.condition, endLabel, parameters);
+ node.body.forEach((statement) =>
+ generateStatement(statement, parameters),
+ );
+ assemblyCode += `${endLabel}:\n`;
+ break;
+ }
  default:
  throw new Error(`Unsupported statement type: ${node.type}`);
  }
@@ -124,6 +134,20 @@ function isParameter(
  );
 }
 
+function generateCondition(
+ node: ASTNode,
+ endLabel: string,
+ parameters: ParameterNode[],
+): void {
+ generateExpression(node, parameters);
+ assemblyCode += 'test eax, eax\n';
+ assemblyCode += `je ${endLabel}\n`;
+}
+
+function generateUniqueLabel(base: string): string {
+ return `${base}_${labelCounter++}`;
+}
+
 function getParameterOffset(
  parameters: ParameterNode[],
  paramName: IdentifierNode,

src/parser.ts

@@ -9,6 +9,7 @@ import {
  BinaryExpressionNode,
  ParameterNode,
  FunctionCallNode,
+ IfStatementNode,
 } from './ast';
 
 let tokens: Token[] = [];
@@ -81,6 +82,8 @@ function parseStatement(): ASTNode {
  return parseReturnStatement();
  } else if (tokens[cursor].type === TokenType.Identifier) {
  return parseFunctionCallOrAssignment();
+ } else if (tokens[cursor].type === TokenType.IfKeyword) {
+ return parseIfStatement();
  } else {
  throw new Error(`Unexpected token: ${tokens[cursor].type}`);
  }
@@ -114,6 +117,20 @@ function parseFunctionCallOrAssignment(): ASTNode {
  }
 }
 
+function parseIfStatement(): IfStatementNode {
+ match(TokenType.IfKeyword);
+ match(TokenType.LeftParen);
+ const condition = parseExpression();
+ match(TokenType.RightParen);
+ const body = parseBlock();
+
+ return {
+ type: 'IfStatement',
+ condition,
+ body,
+ };
+}
+
 function parseArguments(): ASTNode[] {
  const args: ASTNode[] = [];
  match(TokenType.LeftParen);

src/semantic.ts

@@ -28,6 +28,11 @@ export function performSemanticAnalysis(asts: ASTNode[]): void {
  node.arguments.forEach(traverse);
  break;
 
+ case 'IfStatement':
+ traverse(node.condition);
+ node.body.forEach(traverse);
+ break;
+
  case 'Identifier':
  case 'Literal':
  // No semantic analysis needed for identifiers and literals

src/tokenizer.ts

@@ -14,6 +14,7 @@ export enum TokenType {
  LeftParen = 'LEFT_PAREN',
  RightParen = 'RIGHT_PAREN',
  Comma = 'COMMA',
+ IfKeyword = 'IF_KEYWORD',
 }
 
 export interface Token {
@@ -22,8 +23,6 @@ export interface Token {
 }
 
 export function tokenize(code: string): Token[] {
- const keywords = new Set(['int']);
-
  const tokens: Token[] = [];
  let cursor = 0;
 
@@ -84,13 +83,15 @@ export function tokenize(code: string): Token[] {
  identifier += code[cursor];
  }
 
- if (keywords.has(identifier)) {
+ if (identifier === 'int') {
  tokens.push({ type: TokenType.IntKeyword, value: identifier });
  } else if (identifier === 'return') {
  tokens.push({
  type: TokenType.ReturnKeyword,
  value: identifier,
  });
+ } else if (identifier === 'if') {
+ tokens.push({ type: TokenType.IfKeyword, value: identifier });
  } else {
  tokens.push({ type: TokenType.Identifier, value: identifier });
  }

tests/inputs/if.c

@@ -0,0 +1,10 @@
+int main() {
+ int c = 0;
+ if (c) {
+ c = c + 9;
+ }
+ if (1) {
+ c = c + 5;
+ }
+ return c;
+}

tests/silly.test.ts

@@ -63,6 +63,41 @@ add esp, 4
 mov [c], eax
 mov eax, [c]
 ret
+`;
+
+ const generatedCode = compile(code);
+ expect(generatedCode).toEqual(expectedAssemblyCode);
+ });
+
+ test('should compile if.c', () => {
+ const code = readFileSync(`${testFilePath}/if.c`, 'utf8');
+ const expectedAssemblyCode = `section .data
+c dd 0
+section .text
+global main
+main:
+mov eax, [c]
+test eax, eax
+je end_if_0
+mov eax, 9
+push eax
+mov eax, [c]
+pop ebx
+add eax, ebx
+mov [c], eax
+end_if_0:
+mov eax, 1
+test eax, eax
+je end_if_1
+mov eax, 5
+push eax
+mov eax, [c]
+pop ebx
+add eax, ebx
+mov [c], eax
+end_if_1:
+mov eax, [c]
+ret
 `;
 
  const generatedCode = compile(code);