If (a > b){

  If (n > 0){

     a = func1();

  }

  Write a;

Else {

  Write b;

}

func1() {

     Int x;

     x = 25;

    Return x;

}

• review all the changes necessary in the Lexer and add keywords, symbols as needed

• review the use and structure of the symbol table (linked list of tables) and make necessary changes

• review your prior decisions about variable declarations, i.e., where do you allow them to be defined

• review your prior decisions about free standing statements

• decide whether an IF-BLOCK has its own scope

• decide on the appropriate structure of the AST representing an IF statement

• add AST generation code to AST.h

• update Bison with necessary rules to support IF and generate appropriate trees

• adapt optimization techniques for expressions to optimizing th IF condition

• adapt optimization techniques for function block, to IF block

IF-Statement AST:

IfNode

/ \

Condition Body

IF-ELSE Statement AST:

  IFNode

          /    \

 Condition    ELSE

    /   \      /   \

 Null  Block  Null  Block

Bison Incomplete code:

/* Add these tokens */

%token IF ELSE

%type <ast> if_statement else_statement condition_expression block_statement

statement

: /* existing rules */

| if_statement

{ $$ = $1; }

;

if_statement

: IF LPAREN condition_expression RPAREN LBRACE block_statement RBRACE

{

$$ = create_if_node($3, $6, NULL);

}

| IF LPAREN condition_expression RPAREN LBRACE block_statement RBRACE ELSE LBRACE block_statement RBRACE

{

$$ = create_if_node($3, $6, $10);

}

;

condition_expression

: expression

{ $$ = $1; }

;

block_statement

: statements

{ $$ = $1; }

;

AST.h incomplete:

ASTNode* create_if_node(ASTNode* condition, ASTNode* if_body, ASTNode* else_body);

AST.c incomplete:

ASTNode* create_if_node(ASTNode* condition, ASTNode* if_body, ASTNode* else_body) {

ASTNode* node = create_node("If", NULL);

node->left = condition;

node->middle = if_body;

field to ASTNode struct

node->right = else_body;

return node;

}

If

/ \

Condition Block

Else-If:

If

/ \

Not Block

/ \

Condition null

Condition:

OP

/ \

ID ID

└── Program [Type: PROGRAM, Value: ]

├── Declaration [Type: DECLARATION, DType: INT, Value: x]

│ └── Assignment [Type: ASSIGN, Value: =]

│ ├── Left:

│ │ └── IDENTIFIER [Type: IDENTIFIER, DType: INT, Value: x]

│ └── Right:

│ └── NUMBER [Type: NUMBER, DType: INT, Value: 10]

├── Declaration [Type: DECLARATION, DType: INT, Value: y]

│ └── Assignment [Type: ASSIGN, Value: =]

│ ├── Left:

│ │ └── IDENTIFIER [Type: IDENTIFIER, DType: INT, Value: y]

│ └── Right:

│ └── NUMBER [Type: NUMBER, DType: INT, Value: 5]

└── If Statement [Type: IF_STATEMENT, Value: ]

├── Condition:

│ └── GREATER_THAN [Type: GREATER_THAN, Value: >]

│ ├── Left:

│ │ └── IDENTIFIER [Type: IDENTIFIER, DType: INT, Value: x]

│ └── Right:

│ └── IDENTIFIER [Type: IDENTIFIER, DType: INT, Value: y]

├── Then:

│ └── Block [Type: BLOCK, Value: ]

│ ├── Declaration [Type: DECLARATION, DType: INT, Value: z]

│ │ └── Assignment [Type: ASSIGN, Value: =]

│ │ ├── Left:

│ │ │ └── IDENTIFIER [Type: IDENTIFIER, DType: INT, Value: z]

│ │ └── Right:

│ │ └── SUBTRACT [Type: SUBTRACT, Value: -]

│ │ ├── Left:

│ │ │ └── IDENTIFIER [Type: IDENTIFIER, DType: INT, Value: x]

│ │ └── Right:

│ │ └── IDENTIFIER [Type: IDENTIFIER, DType: INT, Value: y]

│ └── Function Call [Type: FUNCTION_CALL, Value: write]

│ └── Arguments:

│ └── IDENTIFIER [Type: IDENTIFIER, DType: INT, Value: z]

└── Else:

└── Block [Type: BLOCK, Value: ]

├── Declaration [Type: DECLARATION, DType: INT, Value: z]

│ └── Assignment [Type: ASSIGN, Value: =]

│ ├── Left:

│ │ └── IDENTIFIER [Type: IDENTIFIER, DType: INT, Value: z]

│ └── Right:

│ └── SUBTRACT [Type: SUBTRACT, Value: -]

│ ├── Left:

│ │ └── IDENTIFIER [Type: IDENTIFIER, DType: INT, Value: y]

│ └── Right:

│ └── IDENTIFIER [Type: IDENTIFIER, DType: INT, Value: x]

└── Function Call [Type: FUNCTION_CALL, Value: write]

└── Arguments:

└── IDENTIFIER [Type: IDENTIFIER, DType: INT, Value: z]

Parse code:

func parse(tokens []string, root Node) Node {

body := []*Node{}

for i := 0; i < len(tokens); i++ {

token := tokens[i]

switch token {

case "if":

// Parse the if statement

ifNode, newIndex := parseIfStatement(tokens, i, root)

body = append(body, ifNode)

i = newIndex - 1 // Adjust index since parseIfStatement advances it

// Existing cases...

}

}

root.Body = body

return root

}

func parseIfStatement(tokens []string, currentIndex int, root Node) (Node, int) {

i := currentIndex + 1 // Move past 'if'

// Expect '('

if tokens[i] != "(" {

fmt.Println("Expected '(' after 'if' on line", line)

os.Exit(3)

}

i++

// Find matching ')'

conditionEnd := findMatchingParen(tokens, i)

if conditionEnd == -1 {

fmt.Println("Unmatched '(' in if condition on line", line)

os.Exit(3)

}

// Parse condition expression

conditionTokens := tokens[i:conditionEnd]

conditionNode := parseGeneric(conditionTokens, line, root)

i = conditionEnd + 1 // Move past ')'

// Expect '{'

if tokens[i] != "{" {

fmt.Println("Expected '{' after if condition on line", line)

os.Exit(3)

}

i++

// Parse the 'then' body

thenBodyTokens, nextIndex := extractBlock(tokens, i)

thenNode := &Node{Type: "BLOCK", Body: parse(thenBodyTokens, root).Body}

i = nextIndex

// Check for 'else' clause

var elseNode *Node

if i < len(tokens) && tokens[i] == "else" {

i++

// Expect '{'

if tokens[i] != "{" {

fmt.Println("Expected '{' after 'else' on line", line)

os.Exit(3)

}

i++

// Parse the 'else' body

elseBodyTokens, nextIndex := extractBlock(tokens, i)

elseNode = &Node{Type: "BLOCK", Body: parse(elseBodyTokens, root).Body}

i = nextIndex

}

// Create the if statement node

ifNode := &Node{

Type: "IF_STATEMENT",

Condition: conditionNode,

Then: thenNode,

Else: elseNode,

}

return ifNode, i

}

This is hypothetical code for our compiler we are building in go

IfStmt = IF LPAREN Condition RPAREN IfBlock Else {

$$->malloc(sizeof(ASTNODE))

//set node type to ifStmt

$3->ifStmt.condition

$5->ifStmt.block

$6->ifStmt.elseBlock

}

Else {//could be empty}

| ELSE IfBlock {

//set node type to else

$$->malloc(sizeof(ASTNODE))

$2->else.block

}

AST.h

typedef struct ASTNode {

NodeType type;

....

union {

struct{

struct ASTNode* condition;

struct ASTNode* block;

struct ASTNode* elseBlock;

} IfStmt;

AST:

If

Condition Else

Null. Block. NULL

If

Block. Condition

Null. NULL. Block

           /    \

          /      \

     Condition    ELSE

       /   \      /   \

    Null  Block  Null  Block

IF

           /    \

          /      \

     Condition    Null

       /   \     

    Null  Block 

├─ Condition

│ └─ Expression

├─ Statement is True

│ └─ Block

└─ Statement is False

└─ Block

Parser starter code for IF:

statement:

IF LPAREN condition RPAREN LBRACE statement RBRACE

| IF LPAREN condition RPAREN LBRACE statement RBRACE ELSE LBRACE statement RBRACE

;

condition:

Expr EQUALS Expr

| Expr GREATER Expr

| Expr LESS Expr

;

// AST Node Structure and Creation Functions

define ASTNode with properties:

- type (IF, IF_ELSE, CONDITION, BODY)

- condition (pointer to condition node)

- thenBody (pointer to then body node)

- elseBody (pointer to else body node, for IF-ELSE)

function createIfNode(condition, thenBody):

create node of type IF

set node.condition = condition

set node.thenBody = thenBody

return node

function createIfElseNode(condition, thenBody, elseBody):

create node of type IF_ELSE

set node.condition = condition

set node.thenBody = thenBody

set node.elseBody = elseBody

return node

// Bison Grammar Rules

program:

statement { root = $1 } // Start AST with the root node

statement:

'IF' condition body { $$ = createIfNode($2, $3) }

| 'IF' condition body 'ELSE' body { $$ = createIfElseNode($2, $3, $5) }

condition:

'condition_expr' { $$ = createConditionNode() }

body:

'body_statements' { $$ = createBodyNode() }

// Parsing and Error Handling

main():

parse input with yyparse()

process AST starting at root

error:

print "Syntax error"

// AST Node Structure and Creation Functions

define ASTNode with properties:

- type (IF, IF_ELSE, CONDITION, BODY)

- condition (pointer to condition node)

- thenBody (pointer to then body node)

- elseBody (pointer to else body node, for IF-ELSE)

function createIfNode(condition, thenBody):

create node of type IF

set node.condition = condition

set node.thenBody = thenBody

return node

function createIfElseNode(condition, thenBody, elseBody):

create node of type IF_ELSE

set node.condition = condition

set node.thenBody = thenBody

set node.elseBody = elseBody

return node

// Bison Grammar Rules

program:

statement { root = $1 } // Start AST with the root node

statement:

'IF' condition body { $$ = createIfNode($2, $3) }

| 'IF' condition body 'ELSE' body { $$ = createIfElseNode($2, $3, $5) }

condition:

'condition_expr' { $$ = createConditionNode() }

body:

'body_statements' { $$ = createBodyNode() }

// Parsing and Error Handling

main():

parse input with yyparse()

process AST starting at root

error:

print "Syntax error"

NodeType_IfStmnt:

Condition: ...

VarDeclList: ...

StmntList: ...

Else: {} (empty/null for lone ifs)

IF-ELSE:

NodeType_IfStmnt:

Condition: ....

VarDeclList: ...

StmntList: ....

NodeType_Else:

VarDeclList: ...

StmntList: ....

Our initial thought is for ifs to have a condition, VarDeclList, StmntList, and an Else. For if statements the else would be empty/NULL an for if-else statements the else would be filled with another

├── CONDITION

| └── [Condition Expression Node]

└── THEN

└── [Then Statement Node]

IF

├── CONDITION

| └── [Condition Expression Node]

└── THEN

| └── [Then Statement Node]

└── ELSE

└── [Else Statement Node]

IF

/ \

Condition Block

/ \

NULL Block

IF ELSE:

IF

/ \

Condition ELSE

/ \ / \

NULL Block NULL Block

IF ELSE-IF:

IF

/ \

Condition ELSE-IF

/ \ / \

NULL Block Condition Block

/ \ \

NULL Block ELSE-IF

/ \

Condition Block

/ \

NULL ELSE

/ \

NULL Block

├─ Condition

│ └─ Expression

├─ Statement is True

│ └─ Block

└─ Statement is False

└─ Block

Parser starter code for IF:

statement:

IF LPAREN condition RPAREN LBRACE statement RBRACE

| IF LPAREN condition RPAREN LBRACE statement RBRACE ELSE LBRACE statement RBRACE

;

condition:

Expr EQUALS Expr

| Expr GREATER Expr

| Expr LESS Expr

;

Functions

Statements

---------------------------------

Global Variable Declarations

Functions

Main Function

----------------------------------

Global Variable Declarations

Statements

Functions

Statements

More Global Variable Declarations

Statements

etc.

---------------------------------

WHAT ABOUT BLOCKS?

• function block

• if block

• while block

• global block (outside a function)

-----------------------------

FuncDecl: TYPE ID (PARAMLIST) FuncBlock

FuncBlock: { VarDeclist StatementsList Return}

vs.

FuncDecl: TYPE ID (PARAMLIST) {Block Return }

Block: { VarDeclist StatementsList }

------------------------------------------

Stmt: AssgnStmt | IfStmt | WhileStmt | WriteStmt...

IfStmt: IF ( Condition ) Block

Block: VarDeclList StmtList | StmtList

WhileStmt: WHILE ( Condition ) Block

Block: VarDeclList StmtList

----------------------------------

What if you don't allow VarDecl inside IF or While?

IfStmt: IF ( Condition ) {StmtList}

WhileStmt: WHILE ( Condition ) {StmtList }

Condition: ...

CaseList: ...

Default: {} (empty/null if no default case)

typedef struct Case {

int value;

ASTNode* stmntList;

} Case;

typedef struct CaseList {

Case* caseNode;

struct CaseList* caseList;

} CaseList;

typedef struct SwitchStatement {

ASTNode* condition;

CaseList* caseList;

ASTNode* defaultStmt;

} SwitchStatement;

# An if statement with an optional else statement.

IfStmt: IF LPARA Condition RPARA Block ElseStmt {}

# An optional else statement can be empty or contain an else block.

ElseStmt: (null) {}

| ELSE Block {}

# A condition that needs to be met

Condition: Value {}

| Value COMPARISON Value {}

| LPARA Condition RPARA LOGIC_OPERATOR LPARA Condition RPARA {}

typedef enum { NODE_IF, NODE_IF_ELSE, NODE_EXPR, NODE_STMT } NodeType;

// Base AST Node

typedef struct ASTNode {

NodeType type;

struct ASTNode* left; // Left child

struct ASTNode* right; // Right child

} ASTNode;

// If Statement (if <condition> <then-branch>)

typedef struct {

NodeType type;

ASTNode* condition; // Condition expression

ASTNode* thenBranch; // Then branch statement

} IfStmt;

// If-Else Statement (if <condition> <then-branch> else <else-branch>)

typedef struct {

NodeType type;

ASTNode* condition; // Condition expression

ASTNode* thenBranch; // Then branch statement

ASTNode* elseBranch; // Else branch statement

} IfElseStmt;

// Function prototypes

ASTNode* createIfStmt(ASTNode* condition, ASTNode* thenBranch);

ASTNode* createIfElseStmt(ASTNode* condition, ASTNode* thenBranch, ASTNode* elseBranch);

void freeAST(ASTNode* node);

Considerations:

• No free standing statements in our language.

• Variable declarations are at the top of the block before the expressions.

• IF Block does not have its own scope

• AST for IF Statement:

  • IF

    ├─ Condition

    │ └─ Expression

    ├─ Statement is True

    │ └─ Block

    └─ Statement is False

    └─ Block

    Parser starter code for IF:

    statement:

    IF LPAREN condition RPAREN LBRACE statement RBRACE

    | IF LPAREN condition RPAREN LBRACE statement RBRACE ELSE LBRACE statement RBRACE

If

/ \

Condition Block

Else-If:

If

/ \

Else Block

/ \

Condition null

Considerations:

• Various tokens need to be added such as ||, &&, = >, =<, if, else, etc.

• We don't anticipate any changes to the symbol table

• Variable declaration will be allowed in function declarations and after function declarations

• statements will only be allowed after variable declarations and in IFS

• an IF block will not have its own scope

  AST for IFS

  IF:

  NodeType_IfStmnt:

  |______Condition: ...

  |______VarDeclList: ...

  |______StmntList: ...

  |______Else: {} (empty/null for lone ifs)

  
  

  IF-ELSE:

  NodeType_IfStmnt:

  |______Condition: ....

  |______VarDeclList: ...

  |______StmntList: ....

  |______NodeType_Else:

  |________________VarDeclList: ...

  |________________StmntList: ....

  
  

%{

#include "AST.h"

%}

%union {

ASTNode* node;

}

%token IF ELSE

%type <node> stmt expr if_stmt if_else_stmt

%%

stmt:

if_stmt

| if_else_stmt

;

if_stmt:

IF '(' expr ')' stmt {

$$ = createIfStmt($3, $5);

}

;

if_else_stmt:

IF '(' expr ')' stmt ELSE stmt {

$$ = createIfElseStmt($3, $5, $7);

}

;

expr:

// Define expression rules here that return ASTNode* for expressions

;

We are still working on finalizing the code generation and optimization of functions

Abstract Syntax Tree (AST):

Program

Function Definition: add, Return Type: int

Parameters:

Param: a, Type: int

Param: b, Type: int

Param: c, Type: int

Block:

Assignment: x

Number: 25

Assignment: result

Binary Operation: +

Identifier: a

Binary Operation: *

Identifier: b

Number: 9

Write Statement: x

Return Statement

Identifier: result

Function Definition: test, Return Type: int

Parameters:

Param: value, Type: int

Block:

Variable Declaration: result, Type: int

If Statement:

Condition:

Binary Operation: <

Identifier: value

Number: 10

If Body:

Assignment: result

Number: 1

Write Statement: result

Else If Statement:

Condition:

Binary Operation: ==

Identifier: value

Number: 10

Else If Body:

Assignment: result

Number: 2

Write Statement: result

Else Statement:

Assignment: result

Number: 3

Write Statement: result

If Statement:

Condition:

Binary Operation: &&

Binary Operation: >

Identifier: value

Number: 5

Binary Operation: <

Identifier: value

Number: 15

If Body:

Assignment: result

Number: 4

Write Statement: result

Return Statement

Identifier: result

Main Function: main

Block:

Assignment: sum

Function Call: add

Argument List:

Arg:

Number: 6

Arg:

Number: 3

Arg:

Number: 9

Array Declaration: arr, Type: int

Array Sizes:

Initializer:

Assignment:

Number: 10

Number: 20

Number: 30

Number: 40

Number: 50

Number: 60

Number: 70

Assignment: x

Number: 25

Write Array Element: arr

Number: 4

Write Statement: sum

Function Call: test

Argument List:

Arg:

Number: 4

Function Call: test

Argument List:

Arg:

Number: 10

Function Call: test

Argument List:

Arg:

Number: 20

Return Statement

Number: 0

main = (null) function (null)

# First IF condition: if (a > b)

t0 = a > b cmp (null)

t0 = false goto else_1

# Nested IF condition: if (n > 0)

t1 = n > 0 cmp (null)

t1 = false goto ifEnd_1

# Inside inner IF: a = func1()

t2 = func1 call (null)

a = t2 assign (null)

# Write a

ifEnd_1 = (null) contBranch (null)

write = a output (null)

# Else condition: Write b

else_1 = (null) elseBranch (null)

b = (null) write (null)

# Function definition for func1

func1 = (null) function (null)

x = 25 assign (null)

x =(null) return (null)

exit = (null) exit (null)

T7 = 25

T0 = T7

GOTO CONTINUE2

Main:

T0 = a

T1 = b

T2 = T0 - T1

IF T2 <= 0

Output T1

GOTO CONTINUE1

T3 = n

T4 = 0

T5 = T3 - T4

IF T5 >= 0

GOTO Func1

CONTINUE2

Output T0

GOTO CONTINUE1

CONTINUE1 Output End

func1:

t0 = 25

x = t0

return x

# Main control flow

t1 = a > b

if_false t1 goto L1

t2 = n > 0

if_false t2 goto L2

t3 = call func1, 0

a = t3

L2:

print a

goto L3

L1:

print b

L3:

func addTwoNums

a0 param a

a1 param b

result declare

t2 = t0 + t1

result = t2

return result

func main

x declare

arr array, size 5

arr[3] = 2

t3 = arr[3]

x = t3

write x

return 0

arg = 1

t2 = n > 0

t3 = call func1

a = t3

t4 = a

t5 = b

// Pseudo-code to represent conditional writes

if t1 == true:

if t2 == true:

a = t3

call write(t4)

else:

call write(t5)

func func1:

x = 25

return x

end func

IR for main:

i0 = a store.int (null)

i1 = b store.int (null)

i2 = i0 >.int i1

(null) = i2 startIf (null)

i3 = 0 assign.int (null)

i4 = n <.int 0

(null) = i4 startIf (null)

(null) = func1 funcCall (null)

a = returnInt store.int (null)

(null) = (null) endIf (null)

i5 = a store.int (null)

(null) = i5 write.int (null)

(null) = (null) endIf (null)

(null) = (null) startElse (null)

i6 = b store.int (null)

(null) = i6 write.int (null)

(null) = (null) endElse (null)

IR for func():

(null) = (null) functionStart (null)

x = 25 assign.int (null)

returnInt = x store.int (null)

(null) = (null) return (null)

goto L2

if n > 0 goto

goto L5

t1 = call func1

a = t1

goto L5

write a

goto L3

func func1

x = 25

return x

endfunc

if a > b goto if1

goto else1

if1:

if n > 0 goto if2

goto write_a

if2:

t1 = func1()

a = t1

goto write_a

write_a:

write a

goto end

else1:

write b

goto end

func1:

t2 = 25

return t2

end:

t0 = a

t1 = b

if(t0 > t1)

goto ifStatement1

else

print t0

ifStatment1:

t0 = n

if(n > 0)

goto ifStatement2

ifStatement2:

t0 = call func1

func1:

t0 = x

x = 25

return x

if t1 goto L1

goto L2

L1:

x = x + 1

goto L3

L2:

x = x - 1

L3:

We enhanced the symbol table by implementing a linked list structure that supports scopes, which allows for proper variable declaration and resolution within their respective scopes, including nested blocks like functions and `if` statements. This hierarchical symbol table ensures that variables are correctly scoped and prevents naming conflicts across different parts of the program.

We reviewed our prior decisions about where variable declarations are allowed and decided to permit them in appropriate places such as within `if` blocks, which now introduce their own scopes. This flexibility allows for cleaner and more intuitive code, as variables can be declared closer to where they are used.

We updated the Abstract Syntax Tree (AST) to accurately represent `if` statements by adding the necessary node structures to reflect the conditional logic in the program. Additionally, we added AST generation code to handle these new structures effectively, ensuring that the parser builds the correct tree representation of the program's flow.

We modified the parsing rules to support `if` statements, ensuring that the parser generates appropriate AST nodes for them. This included handling the parsing of conditional expressions and block statements within the `if` and `else` branches. We also made sure that the parser correctly manages nested `if` statements and scopes.

Finally, we adapted optimization techniques that were previously applied to expressions and function blocks so that they also optimize `if` conditions and `if` blocks. This has improved the overall efficiency of the compiler by reducing unnecessary computations and simplifying control flow where possible. We implemented constant folding and dead code elimination within conditional statements to enhance performance.

Overall, these changes have significantly enhanced our compiler's capabilities, allowing it to handle more complex language features while maintaining efficient performance. We are confident that these updates will provide a solid foundation for further development and support for additional language constructs in the future.

1. Are you done with functions?

2. Have you started to work on if-statements?

• simple if-statement

• if-else statement

• nested if-statement

For example:

if (x == 5){

   doSomething();

}

-----------------------

if (x > 1 && x < 10} {

    doSomething();

}

else {

    doSomethingElse();

}

---------------------------

if (!(b > 0)) {

    if (n > 100) {

        doThis();

    }

    else {

         if (c == 10) {

             doThat();

          }

    }

}

if(test)

{ if(anotherTest)

{ x = 2; }

} else

{ x = 3; }

write x;

if x > 0:

if y > 0:

z = 1

else:

z = -1

else:

z = 0

int x;

int y;

x = 10;

if (x > 0) {

y = 4;

if (y > 4)

{

write y;

}

else

{

write x;

}

}

Yes

Update your post on if, and repost today, demonstrating a more complete and debugged implementation

Formatted Output:

Global Scope (Level 0):

Function main with return type void

Function getX with return type int

Function getY with return type int

Scope Level 1 (main):

Variable result of type int

Variable flag of type bool

Scope Level 1 (getX):

Parameter value of type int

Tokens: [int x = 10

]

Raw Line: "int y = 5"

Tokens: [int y = 5

]

Raw Line: ""

Tokens: [

]

Raw Line: "if (x > 0) {"

Tokens: [if ( x > 0 ) {

]

Raw Line: " if (y > 0){"

Tokens: [if ( y > 0 ) {

]

Raw Line: " write(y)"

Tokens: [write ( y )

]

Raw Line: " }else{"

Tokens: [} else {

]

Raw Line: " write(x)"

Tokens: [write ( x )

]

Raw Line: " }"

Tokens: [}

]

Raw Line: "}else{"

Tokens: [} else {

]

Raw Line: " write(0)"

Tokens: [write ( 0 )

]

Raw Line: "}"

Tokens: [}

]

Parsing...

Finished Parsing! Beginning Optimization...

Finished Optimization! Outputting Tac...

Tac Complete! Compiling to MIPS...

MIPS code has been written to output.mips

Finished! 【=◈ ︿ ◈=】

int x = 10

int y = 5

if (x > 0) {

if (y > 0){

write(y)

}else{

write(x)

}

}else{

write(0)

}

1. How are the ASTs different?

2. How do you manage GOTO statements?

3. How are you handling complex IF/WHILE conditions?

Show the code snippets that illustrate the above

Code Snippet:

func parseIfStatement(tokens []string, lineNumber int) *Node {
	var newNode Node
	openParen := 0

	newNode.Type = "IF_STATEMENT"
	newNode.DType = "IF"

	if tokens[1] != "(" {
		fmt.Println("Expected \"(\" got " + tokens[1] + " on line " + strconv.Itoa(lineNumber))
		os.Exit(3)
	} else {
		openParen++
	}

	closeParenIndex := slices.Index(tokens, ")")

	if closeParenIndex == -1 {
		fmt.Println("Expected \")\" got " + tokens[2] + " on line " + strconv.Itoa(lineNumber))
		os.Exit(3)
	} else {
		openParen--
	}

	if closeParenIndex != 3 {
		conditions := tokens[2:closeParenIndex]

		ampersandIndex := slices.Index(tokens, "&")

		if ampersandIndex == len(conditions)-1 {
			fmt.Println("Invalid \"&\" usage! Line:", lineNumber)
			os.Exit(3)
		}

		pipeIndex := slices.Index(tokens, "|")

		if pipeIndex == len(conditions)-1 {
			fmt.Println("Invalid \"|\" usage! Line:", lineNumber)
			os.Exit(3)
		}

		for i := 1; i < (len(conditions) + 1); i += 3 {
			newNode.Params = append(newNode.Params, parseConditions(conditions[i:i+2], lineNumber))
		}
	}

The image attached is our current grammar for Ifs and our grammar for While loops will likely be very similar to the way IfStmt looks.

For TAC, while loops require labels and GOTO statements to enable looping. We’ll generate a label at the start of the loop for the condition, a conditional jump to exit the loop if false, and a GOTO back to the start after the body executes. An end label ensures the program continues correctly after the loop ends.

We’ll reuse ConditionList to manage complex conditions for while, just like we do for if. This includes logical operators like AND and OR and nested conditions. The TAC generation will evaluate these, making sure both constructs handle conditions consistently.

• Function parsing, AST, semantic analysis, Assembly

• IF-Statements parsing, AST, semantic Analysis, Assembly

• Started to implement WHILE-statements

If statements is mostly complete, only complex booleans need to be fixed

Looking into while loops