scarlett/compiler-the-translators
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

latest version still not working #t51

Browse Source
This commit is contained in:
Meyer Simon
2025-04-15 10:59:38 -04:00
parent 7296a24c74
commit f8010f463b
2 changed files with 124 additions and 74 deletions
Download Patch File Download Diff File Expand all files Collapse all files

103
src/intermediate_code.c
View File

@ -4,13 +4,16 @@
Instruction * begin;
Instruction * current;
char * temp = NULL;
// TODO: this is here to bring your attention to the comment bellow.
// check if start is NULL if it is assign it to the start globle variable
// otherwise make it next of current and set cur to your instruction.
void emit_helper(void){
TNodeOrConst * tn_or_const(Op op, RegConstUnion r);
static void emit_helper(void){
Instruction * inst = calloc(1, sizeof(*inst));
if(begin == NULL){
begin = current = inst;
@ -23,7 +26,7 @@ void emit_helper(void){
}
}
void emit_binary_op(TableNode * result, Op op, TableNode * arg1, TableNode * arg2){
void emit_binary_op(Op op, TableNode * result, TNodeOrConst * arg1, TableNode * arg2){
emit_helper();
current->opcode = op;
current->result = result;
@ -32,7 +35,7 @@ void emit_helper(void){
return;
}
void emit_unary_op(TableNode * result, Op op, TableNode * arg){
void emit_unary_op(Op op, TableNode * result, TNodeOrConst * arg){
emit_helper();
current->opcode = op;
current->result = result;
@ -40,11 +43,11 @@ void emit_helper(void){
return;
}
void emit_assignment(char* target, char* source){
void emit_assignment(TableNode * target, TNodeOrConst * source){
emit_helper();
current->opcode = ADD; // TODO: replace with move
current->result = look_up(cur, target);
current->operand1 = look_up(cur, source);
current->opcode = E_ASSIGN; // TODO: replace with move
current->result = target;
current->operand1 = source;
return;
}
@ -60,48 +63,77 @@ void emit_as_file(FILE * out_file, Instruction * instr_arr){
void emit_label(char* label){
emit_helper();
current->opcode = LABEL;
current->opcode = E_LABEL;
current->label = label;
return;
}
void emit_jump(char* label){
emit_helper();
current->opcode = GOTO;
current->opcode = E_GOTO;
current->label = label;
return;
}
void emit_conditional_jump(char* condition, char* label){
void emit_conditional_jump(int count, ...){
// it apears that I cant do what I want So we will have to deal with
// the limitations presented.
// arg_count is the number of args passed to the function
// from there the sequence is Op, char * , TableNode * , and an optional
// extra TableNode *.
// when this instruction is a conditional jump then ... is 1
// when the inst is a cond with a Relational op then ... is 2
emit_helper();
current->opcode = CGOTO; // I am positive this needs to be 2 instructions
va_list argptr;
va_start(argptr, count);
Op condition = va_arg(argptr, Op);
char * label = va_arg(argptr, char *);
current->opcode = condition;
current->label = label;
TNodeOrConst * n1;
TableNode * n2;
switch (condition) {
case E_IF_X_TRUE: case E_IF_X_FALSE:
n1 = va_arg(argptr, TNodeOrConst *);
current->operand1 = n1;
break;
case E_LESSTHEN: case E_EQUALTO:
n1 = va_arg(argptr, TNodeOrConst *);
n2 = va_arg(argptr, TableNode *);
current->operand1 = n1;
current->operand2 = n2;
break;
}
return;
}
void emit_function_start(char* name){
void emit_function_start(char * name){
emit_helper(); // actualy what is this?
current->opcode = LABLE; // I think this is right TODO: ask
current->label = name;
current->opcode = E_LABEL; // I think this is right TODO: ask
current->label = name; // wait what is a function start
// this is probabaly a func decleration
return;
}
void emit_parameter(char* param){
void emit_parameter(TNodeOrConst * param){
emit_helper();
current->opcode = PARAM;
current->operand1 = look_up(cur, param);
current->opcode = E_PARAM;
current->operand1 = param;
return;
}
void emit_function_call(char* result, char* name){
void emit_function_call(TableNode * result, int param_count, TableNode * name){
emit_helper();
current->opcode = CALL;
current->operand1 = look_up(cur, name);
current->result = look_up(cur, result);
current->opcode = E_CALL;
TNodeOrConst * count = calloc(1, sizeof(*count));
count->d = INTEGER;
count->rc_union->integer = param_count;
current->operand1 = count;
current->operand2 = name;
current->result = result;
return;
}
void emit_return(char* value){
void emit_return(TNodeOrConst * value){
emit_helper();
current->opcode = RETURN;
current->operand1 = look_up(cur, name);
current->opcode = E_RETURN;
current->operand1 = value;
return;
}
void emit_reserve(char* result, char* type_name, int size){
@ -115,11 +147,30 @@ void emit_release(char* pointer){
void emit_field_access(char* result, char* record, char* field){
emit_helper();
return;
}
void emit_array_access(char* result, char* array, char* index, char* dimension){
emit_helper();
return;
}
void emit_bounds_check(char* index, char* size, char* error_label){
emit_helper();
return;
}
// * Implement temp variable generator function that produces unique names (t1, t2, etc.)
char * temp_var_gen(){
char * ret = calloc(9, sizeof(*ret));
sprintf(ret, "$t%d", temp_count);
temp_count++;
return ret;
}
char * lable_gen(){
char * ret = calloc( 9, sizeof(*ret));
sprintf(ret, "L_%d", label_count);
label_count++;
return ret;
}

95
src/intermediate_code.h
View File

@ -1,48 +1,46 @@
// Track 1: Core Infrastructure & Basic Expressions
// * Create intermediate_code.h/.c defining the instruction structure:
// - Struct with fields for: opcode, result, operand1, operand2, label
// - Enum for all operation types (ADD, SUB, MUL, DIV, etc.)
// * Implement temp variable generator function that produces unique names (t1, t2, etc.)
// * Create specific code emission functions:
// - emit_binary_op(char* result, char* op, char* arg1, char* arg2)
// - emit_unary_op(char* result, char* op, char* arg)
// - emit_assignment(char* target, char* source)
// * Add Bison actions for arithmetic expressions:
// - Addition: $$ = new_temp(); emit_binary_op($$, "ADD", $1, $3);
// - Subtraction, multiplication, division, modulo
#include "symbol_table.h"
#include <stdarg.h>
// these are from page 364
typedef enum {
LABEL, // this is not in the book
ADD, // 1 from the list
SUB, // 1
MUL, // 1
DIV, // 1
MOD, // 1
OR, // 1
AND, // 1
NEG, // 2
NOT, // 2
ASSIGN, // 3
GOTO, // 4
CGOTO, // 5
LESSTHEN, // 6 rule 1 + 5
EQUALTO, // 6 rule 1 + 5
CALL, // 7
PARAM, // 7
RETURN // 7
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_LESSTHEN, // 6 rule 1 + 5
E_EQUALTO, // 6 rule 1 + 5
E_CALL, // 7
E_PARAM, // 7
E_RETURN, // 7
E_INDEX_COPY_RIGHT, // 8
E_INDEX_COPY_LEFT, // 8
E_ADDRESS_OF // 9
/* for x = *y and *y = x we can just use index copy right and left with
index 0*/
} Op;
typedef enum {
NODE,
INTEGER,
STRING,
CHARACTER,
ADDRESS,
BOOLEAN
NODE = 11000, // TableNode
INTEGER, // int
STRING, // char *
CHARACTER, // char
ADDRESS, // void *
BOOLEAN // bool
} Discriminant;
typedef union {
@ -52,39 +50,41 @@ typedef union {
char character;
void * address;
bool Boolean;
} Register_union;
} RegConstUnion;
typedef struct {
Discriminant d;
Register_union r_union;
RegConstUnion * rc_union;
} TNodeOrConst;
typedef struct Instruction Instruction;
typedef struct Instruction {
Op opcode;
TableNode * result;
TableNode * operand1;
TNodeOrConst * operand1;
TableNode * operand2;
char * label;
int index;
Instruction * prev;
Instruction * next;
} Instruction;
extern Instruction * begin;
extern Instruction * current;
int temp_count = 0;
int label_count = 0;
bool code_gen = true;
void emit_binary_op(char* result, Op op, char* arg1, char* arg2);
void emit_unary_op(char* result, Op op, char* arg);
void emit_assignment(char* target, char* source);
void emit_binary_op(Op op, TableNode * result, TNodeOrConst * arg1, TableNode * arg2);
void emit_unary_op(Op op, TableNode * result, TNodeOrConst * arg);
void emit_assignment(TableNode * target, TNodeOrConst * source);
// TODO: Find out what these are suposed to do. Guess is create an entry in
// the list of instructions. Guess is that its suposed to ret a struct ptr
// * Implement integer/boolean/character specific operation handling
// TODO: Find out what this means.
@ -95,16 +95,15 @@ void emit_as_file(FILE * out_file, Instruction * instr_arr);
void emit_label(char* label);
void emit_jump(char* label);
void emit_conditional_jump(char* condition, char* label);
void emit_conditional_jump(int count, ...);
void emit_function_start(char* name);
void emit_parameter(char* param);
void emit_function_call(char* result, char* name);
void emit_return(char* value);
void emit_parameter(TNodeOrConst * param);
void emit_function_call(TNodeOrConst * result, TNodeOrConst * name);
void emit_return(TNodeOrConst * value);
void emit_reserve(char* result, char* type_name, int size);
void emit_release(char* pointer);
void emit_field_access(char* result, char* record, char* field);
void emit_array_access(char* result, char* array, char* index, char* dimension);
void emit_bounds_check(char* index, char* size, char* error_label);