155 lines
5.3 KiB
C
155 lines
5.3 KiB
C
// Track 1: Core Infrastructure & Basic Expressions
|
|
// * Add Bison actions for arithmetic expressions:
|
|
// - Addition: $$ = new_temp(); emit_binary_op($$, "ADD", $1, $3);
|
|
// - Subtraction, multiplication, division, modulo
|
|
#pragma once
|
|
|
|
#include "symbol_table.h"
|
|
#include <stdio.h>
|
|
#include <stdarg.h>
|
|
|
|
// these are from page 364
|
|
typedef enum {
|
|
E_LABEL = 10000, // this is not in the book
|
|
E_ADD, // 1 from the list
|
|
E_SUB, // 1
|
|
E_MUL, // 1
|
|
E_DIV, // 1
|
|
E_MOD, // 1
|
|
E_OR, // 1
|
|
E_AND, // 1
|
|
E_NEG, // 2
|
|
E_NOT, // 2
|
|
E_ASSIGN, // 3
|
|
E_GOTO, // 4
|
|
E_COND_GOTO, // 5 I don't thik I need this because we could just follow the < or the = and just assume that it's a cond got
|
|
E_IF_X_TRUE, // 5
|
|
E_IF_X_FALSE, // 5
|
|
E_LESS_THAN, // 6 rule 1 + 5
|
|
E_EQUAL_TO, // 6 rule 1 + 5
|
|
E_CALL, // 7
|
|
E_PARAM, // 7
|
|
E_RETURN, // 7
|
|
E_INDEX_COPY_RIGHT, // 8 this is x = y[i]
|
|
E_INDEX_COPY_LEFT, // 8 x[i] = y
|
|
E_ADDRESS_OF, // 9 x = &y
|
|
E_DEREF_RIGHT, // 9 x = *y
|
|
E_DEREF_LEFT // 9 x* = y
|
|
} Op;
|
|
|
|
typedef enum {
|
|
NODE = 11000, // TableNode
|
|
INTEGER, // int
|
|
STRING, // char *
|
|
CHARACTER, // char
|
|
ADDRESS, // void *
|
|
BOOLEAN // bool
|
|
} Discriminant;
|
|
|
|
typedef union {
|
|
TableNode * node;
|
|
int integer;
|
|
char * string;
|
|
char character;
|
|
void * address;
|
|
bool Boolean;
|
|
} TNConstUnion;
|
|
|
|
typedef struct {
|
|
Discriminant d;
|
|
TNConstUnion * tnc_union;
|
|
} TNodeOrConst;
|
|
|
|
typedef struct Instruction Instruction;
|
|
typedef struct Instruction {
|
|
Op opcode;
|
|
TableNode * result;
|
|
TNodeOrConst * operand1;
|
|
TNodeOrConst * operand2;
|
|
int label;
|
|
int index;
|
|
|
|
Instruction * prev;
|
|
Instruction * next;
|
|
} Instruction;
|
|
|
|
|
|
typedef struct TFList {
|
|
Instruction * i;
|
|
TFList * next;
|
|
} TFList;
|
|
|
|
TFList * make_list(Instruction * i);
|
|
// - makelist(i) function to create instruction lists
|
|
void merge(TFList * l1, TFList * l2);
|
|
// - merge(p1,p2) function to concatenate lists
|
|
void backpatch(TFList * l, int label);
|
|
// - backpatch(p,i) function to fill in jump targets
|
|
|
|
|
|
extern Instruction * begin;
|
|
extern Instruction * current;
|
|
int temp_count = 0;
|
|
int label_count = 0;
|
|
bool code_gen = true;
|
|
|
|
|
|
TNodeOrConst * tn_or_const(Discriminant , void * );
|
|
void emit_binary_op(Op op, TableNode * result, TNodeOrConst * arg1, TNodeOrConst * arg2);
|
|
void emit_unary_op(Op op, TableNode * result, TNodeOrConst * arg);
|
|
void emit_assignment(TableNode * target, TNodeOrConst * source);
|
|
void emit_as_file(FILE * out_file, Instruction * instr_arr);
|
|
void emit_label(int label);
|
|
void emit_jump(int label);
|
|
|
|
void emit_conditional_jump(Op condition, int label, ...);
|
|
|
|
void emit_function_start(int name);
|
|
void emit_parameter(TNodeOrConst * param);
|
|
void emit_function_call(TableNode * result, int param_count, TNodeOrConst * name);
|
|
void emit_return(TNodeOrConst * value);
|
|
void emit_reserve(TableNode * result, TNodeOrConst * size);
|
|
void emit_release(TableNode * pointer);
|
|
void emit_field_access(char* result, char* record, char* field);
|
|
void emit_array_access(Op op, TableNode * result, TNodeOrConst * array, TNodeOrConst * index);
|
|
void emit_bounds_check(TNodeOrConst * index, TNodeOrConst * arr, int error_label);
|
|
|
|
// * Implement instruction array storage for backpatching
|
|
/*
|
|
Track 2: Control Flow & Boolean Expressions
|
|
* Implement backpatching infrastructure:
|
|
* Create truelist and falselist attributes for Boolean expressions
|
|
* Create control flow emission functions:
|
|
* Add Bison actions for control structures:
|
|
- if-then-else with backpatching
|
|
- while loops with backpatching
|
|
* Implement short-circuit Boolean operations (&&, ||, !)
|
|
* Add marker (M) nonterminal for recording instruction positions
|
|
*/
|
|
|
|
|
|
/*
|
|
Track 3: Functions & Complex Types
|
|
* Implement function-related emission:
|
|
* Add Bison actions for the 'as' clause
|
|
* Create memory layout calculation functions:
|
|
- calculate_record_size(Record_Type* type) → returns bytes needed
|
|
- calculate_array_size(Array_Type* type, int dimensions[]) → returns total bytes
|
|
- calculate_field_offset(Record_Type* type, char* field_name) → returns offset
|
|
* Add Bison actions for arrays and records
|
|
*/
|
|
|
|
/*
|
|
Track 4: Memory Access & Integration
|
|
* Implement array and record access code:
|
|
- emit_field_access(char* result, char* record, char* field)
|
|
- emit_array_access(char* result, char* array, char* index, char* dimension)
|
|
* Add array dimension access (a._1, a._2, etc.)
|
|
* Implement bounds checking emission:
|
|
- emit_bounds_check(char* index, char* size, char* error_label)
|
|
* Create the code generation driver function
|
|
* Implement common error handling
|
|
* Document the complete intermediate instruction set
|
|
* Build integration test suite covering all language features
|
|
* Implement row-major/column-major array layout calculation
|
|
*/ |