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

🤯🤯🤯🤯🤯🤯🤯🤯🤯

Browse Source
This commit is contained in:
Scarlett
2025-05-04 23:54:42 -04:00
parent 8b0d191409
commit 0fc796aa25
32 changed files with 867 additions and 1021 deletions
Download Patch File Download Diff File Expand all files Collapse all files

44
genx.sh
View File

@ -44,17 +44,57 @@ if [ ! -d "binaries" ]; then
mkdir -p binaries
fi
appendStd() {
if [ ! -f "$1" ]; then
echo "File not found: $1"
return 1
fi
backup_file="${1}.bak"
cp "$1" "$backup_file"
temp_file=$(mktemp)
while IFS= read -r line || [ -n "$line" ]; do
echo "$line" >> "$temp_file"
if [[ $line =~ ^#include\ \"[^\"]+\" ]]; then
include_file=$(echo "$line" | sed -n 's/.*"\([^"]*\)".*/\1/p')
if [[ $include_file == "std.alpha" ]]; then
echo -e "${GREEN}[GenX] ${WHITE}Including ${BLUE}std.alpha${WHITE}..."
if [ -f "library/std.alpha" ]; then
cat library/std.alpha >> "$temp_file"
else
echo -e "${RED}[GenX] ${YELLOW}File library/std.alpha not found!${WHITE}"
rm "$temp_file"
return 1
fi
fi
fi
done < "$1"
mv "$temp_file" "$1"
}
if [ $# -eq 1 ]; then
if [ -f "$1" ]; then
if [[ "$1" == *.alpha ]]; then
appendStd "$1"
./alpha -cg "$1"
backup_file="${1}.bak"
if [ -f "$backup_file" ]; then
mv "$backup_file" "$1"
echo -e "${GREEN}[GenX] ${WHITE}Reverted $1 to its original state."
fi
filename=$(basename -- "$1")
filename="${filename:0:${#filename}-6}"
s_name="out/${filename}.s"
echo -e "${GREEN}[GenX] ${WHITE}Generated .s file..."
echo -e "${GREEN}[GenX] ${WHITE}Generated .s file."
gcc ${s_name} library/alpha_lib_reg.s library/alpha_driver.s -no-pie -o binaries/${filename}
if [ $? -eq 0 ]; then
echo -e "${GREEN}[GenX] ${WHITE}Generated executable file..."
echo -e "${GREEN}[GenX] ${WHITE}Generated executable file."
echo -e "${GREEN}[GenX] ${WHITE}Executable file: binaries/${filename}"
echo -e "${GREEN}[GenX] ${WHITE}Done!"
else

61
library/Makefile
View File

@ -1,61 +0,0 @@
# Makefile to make executables from alpha source code files
# and also make executables from some sample assembly files execising the alpha library
#
# Carl Alphonce
# April 20, 2024
# The alpha compiler and flags (adjust the flags as needed)
AC := ./alpha
AFLAGS := -tok -asc -tc -st -ir -cg
# The preprocessor and flags (you should not adjust these)
CPP := cpp
CPPFLAGS := -P -x c
# Adjust for the library your team is using (register-based or stack-based parameter passing)
ALPHA_LIB = alpha_lib_reg.s ## Register-based parameter passing
#ALPHA_LIB = alpha_lib_st.s ## Stack-based parameter passing
# Adjust for the parameter passing approach your compiler uses:
# alpha_driver_reg.s for register-based parameter passing
# alpha_driver_st.s for stack-based parameter passing
# This file provides a main function that packages up argv[1] (or "") as an alpha string
# (type 1->character) and calls entry with that argument
ALPHA_DRIVER = alpha_driver_reg.s ## Register-based parameter passing
#ALPHA_DRIVER = alpha_driver_st.s ## Stack-based parameter passing
# Create an assembly (.s) file from an alpha source file
# This involves several steps:
%.s : %.alpha
@mv $< $<._temporary_ # 1. rename input file so we can us it as
@$(CPP) $(CPPFLAGS) $<._temporary_ > $< # 2. input to CPP, writing output to original filename
@$(AC) $(AFLAGS) $< # 3. run the alpha compiler on the pre-processed file
@mv $<._temporary_ $< # 4. restore the original input file
# Examples of assembly code using the alpha library files
# In these examples the calling code is in assembly, and defines main (so the driver is not included here)
# Example #1: calling the printBoolean function
printBoolean : printBoolean_reg.s
@gcc $< $(ALPHA_LIB) -no-pie -o $@
# Example #2: calling the printInt function
printInt : printInt_reg.s
@gcc $< $(ALPHA_LIB) -no-pie -o $@
# Example #3: calling the reserve and release functions
reserve_release : reserve_release_reg.s
@gcc $< $(ALPHA_LIB) -no-pie -o $@
# The rule for assembling .s files and linking them together (using the gcc compiler driver)
# to produce an executable (assuming no earlier make rule triggers first)
% : %.s $(ALPHA_LIB) $(ALPHA_DRIVER)
@gcc $< $(ALPHA_LIB) $(ALPHA_DRIVER) -no-pie -o $@

26
library/printBoolean_reg.s
View File

@ -1,26 +0,0 @@
.file "printBoolean.c"
.text
.globl main
.type main, @function
main:
.LFB0:
pushq %rbp
movq %rsp, %rbp
movb $1, %dil # the representation of 'true'
call printBoolean
movb $10, %dil
call printCharacter
movb $0, %dil # the representation of 'false'
call printBoolean
movb $10, %dil
call printCharacter
movl $0, %eax
popq %rbp
ret
.LFE0:
.size main, .-main
.ident "GCC: (GNU) 6.4.0"
.section .note.GNU-stack,"",@progbits

22
library/printInt_reg.s
View File

@ -1,22 +0,0 @@
.file "printInt.c"
.text
.globl main
.type main, @function
main:
.LFB0:
pushq %rbp
movq %rsp, %rbp
movl $10, %edi # Move the immediate value 10 to %edi
call printInteger # call the alpha_lib function printInteger
movl $10, %edi # Put the \n character (decimal 10) into %edi
call printCharacter # then call the alpha_lib function printCharacter
movl $0, %eax
popq %rbp
ret
.LFE0:
.size main, .-main
.ident "GCC: (GNU) 6.4.0"
.section .note.GNU-stack,"",@progbits

37
library/reserve_release_reg.s
View File

@ -1,37 +0,0 @@
.file "reserve_release.c"
.text
.globl main
.type main, @function
main:
.LFB0:
pushq %rbp
movq %rsp, %rbp
subq $16, %rsp
movl $8, %edi # move sizeof(*a) into %edi
call reserve # call alpha_lib_reg function reserve
movq %rax, -8(%rbp) # put the returned pointer on the stack at offset -8
movq -8(%rbp), %rax # put base pointer of struct (a) into %rax
movl $20, (%rax) # put value 20 into location pointed at by %rax --> (*a).x
movq -8(%rbp), %rax # put base pointer of struct (a) into %rax
movl $45, 4(%rax) # put value 45 into location 4(%rax) --> (*a).y
movq -8(%rbp), %rax # put base pointer of struct (a) into %rax
movl 4(%rax), %eax # move (*a).y into %eax
movl %eax, %edi # and then into %edi
call printInteger # call alpha_lib_reg function printInteger
movl $10, %edi # move '\n' into %edi
call printCharacter # call alpha_lib_reg function printCharacter
movq -8(%rbp), %rax # put base pointer of struct (a) into %rax
movq %rax, %rdi # and then into %rdi
call release # call alpha_lib_reg function reserve
movl $0, %eax
leave
ret
.LFE0:
.size main, .-main
.ident "GCC: (GNU) 6.4.0"
.section .note.GNU-stack,"",@progbits

24
library/std.alpha Normal file
View File

@ -0,0 +1,24 @@
(* Standard Alpha Library - Provided by Carl *)
type string: 1 -> character
type BooleanXBoolean: [Boolean: x; Boolean: y]
type characterXcharacter: [character: x; character: y]
type integerXinteger: [integer: x; integer: y]
type Boolean2Boolean: Boolean -> Boolean
type integer2integer: integer -> integer
type character2integer: character -> integer
type Boolean2integer: Boolean -> integer
type string2integer: string -> integer
type integerXinteger2integer: integerXinteger -> integer
type integerXinteger2Boolean: integerXinteger -> Boolean
type characterXcharacter2Boolean: characterXcharacter -> Boolean
type BooleanXBoolean2Boolean: BooleanXBoolean -> Boolean
type integer2address: integer -> address
type address2integer: address -> integer
external function printInteger: integer2integer
external function printCharacter: character2integer
external function printBoolean: Boolean2integer
function entry: string2integer

238
src/codegen.c
View File

@ -3,87 +3,86 @@
#include "codegen.h"
int generate(){
int generate() {
offset = 0;
currentsp = 0;
Instruction *i = begin;
// temporary
fprintf(cg_flag, ".globl entry\n");
while (i != NULL) {
switch(getOp(i)) {
case E_LABEL:
generateLabel(i);
break;
case E_ADD:
generateAdd(i);
break;
case E_SUB:
generateSub(i);
break;
case E_MUL:
generateMult(i);
break;
case E_DIV:
generateDiv(i);
break;
case E_MOD:
generateMod(i);
break;
case E_OR:
generateOr(i);
break;
case E_AND:
generateAnd(i);
break;
case E_NEG:
generateNeg(i);
break;
case E_NOT:
generateNot(i);
break;
case E_ASSIGN:
generateAssign(i);
break;
case E_GOTO:
generateGoto(i);
break;
case E_IF_X_TRUE:
generateIfTrue(i);
break;
case E_IF_X_FALSE:
generateIfFalse(i);
break;
case E_LESS_THAN:
generateLessThan(i);
break;
case E_EQUAL_TO:
generateEqualTo(i);
break;
case E_CALL:
generateCall(i);
break;
case E_PARAM:
generateParam(i);
break;
case E_RETURN:
generateReturn(i);
break;
case E_INDEX_COPY_RIGHT:
generateCopyRight(i);
break;
case E_INDEX_COPY_LEFT:
generateCopyLeft(i);
break;
case E_ADDRESS_OF:
generateAddressOf(i);
break;
case E_FUNC_START:
generateFunctionStart(i);
break;
default:
;
switch (getOp(i)) {
case E_LABEL:
generateLabel(i);
break;
case E_ADD:
generateAdd(i);
break;
case E_SUB:
generateSub(i);
break;
case E_MUL:
generateMult(i);
break;
case E_DIV:
generateDiv(i);
break;
case E_MOD:
generateMod(i);
break;
case E_OR:
generateOr(i);
break;
case E_AND:
generateAnd(i);
break;
case E_NEG:
generateNeg(i);
break;
case E_NOT:
generateNot(i);
break;
case E_ASSIGN:
generateAssign(i);
break;
case E_GOTO:
generateGoto(i);
break;
case E_IF_X_TRUE:
generateIfTrue(i);
break;
case E_IF_X_FALSE:
generateIfFalse(i);
break;
case E_LESS_THAN:
generateLessThan(i);
break;
case E_EQUAL_TO:
generateEqualTo(i);
break;
case E_CALL:
generateCall(i);
break;
case E_PARAM:
generateParam(i);
break;
case E_RETURN:
generateReturn(i);
break;
case E_INDEX_COPY_RIGHT:
generateCopyRight(i);
break;
case E_INDEX_COPY_LEFT:
generateCopyLeft(i);
break;
case E_ADDRESS_OF:
generateAddressOf(i);
break;
case E_FUNC_START:
generateFunctionStart(i);
break;
default:;
}
i = i->next;
}
@ -133,14 +132,13 @@ CGNode *addCG(TableNode *tn, int sp) {
return cg;
}
int generateLabel(Instruction *inst) {
if (inst == NULL) {
return -1;
}
fprintf(cg_flag, ".L%d:\n", getLabel(inst));
return 0;
}
int generateAdd(Instruction *inst) {
@ -162,7 +160,6 @@ int generateAdd(Instruction *inst) {
cg = addCG(getResult(inst), offset);
}
CGNode *op1CG = findCG(getTN(op1));
CGNode *op2CG = findCG(getTN(op2));
if (op1CG == NULL) {
@ -181,7 +178,7 @@ int generateAdd(Instruction *inst) {
}
int generateSub(Instruction *instruction) {
/*
/*
Both immediate:
One immediate:
Neither immediate:
@ -217,8 +214,8 @@ int generateSub(Instruction *instruction) {
return 0;
}
int generateMult(Instruction *inst){
/*
int generateMult(Instruction *inst) {
/*
Both immediate:
One immediate:
Neither immediate:
@ -254,7 +251,7 @@ int generateMult(Instruction *inst){
}
int generateDiv(Instruction *inst) {
/*
/*
Both immediate:
One immediate:
Neither immediate:
@ -284,10 +281,10 @@ int generateDiv(Instruction *inst) {
return -1;
}
fprintf(cg_flag, "\tmovl\t%d(%%rbp), %%eax\t#division start\n", getAddress(op1CG)); //moves dividend into eax
fprintf(cg_flag, "\tcltd\n"); //sign extends the dividend in eax
fprintf(cg_flag, "\tidivl\t%d(%%rbp)\n", getAddress(op2CG));//divides edx by value accessed from stack
fprintf(cg_flag, "\tmovl\t%%eax, %d(%%rbp)\t#division end\n", getAddress(cg)); //stores result
fprintf(cg_flag, "\tmovl\t%d(%%rbp), %%eax\t#division start\n", getAddress(op1CG)); //moves dividend into eax
fprintf(cg_flag, "\tcltd\n"); //sign extends the dividend in eax
fprintf(cg_flag, "\tidivl\t%d(%%rbp)\n", getAddress(op2CG)); //divides edx by value accessed from stack
fprintf(cg_flag, "\tmovl\t%%eax, %d(%%rbp)\t#division end\n", getAddress(cg)); //stores result
return 0;
}
@ -321,15 +318,15 @@ int generateMod(Instruction *inst) {
return -1;
}
fprintf(cg_flag, "\tmovl\t%d(%%rbp), %%eax\t#mod start\n", getAddress(op1CG)); //moves dividend into eax
fprintf(cg_flag, "\tcltd\n"); //sign extends the dividend in eax
fprintf(cg_flag, "\tidivl\t%d(%%rbp)\n", getAddress(op2CG));//divides edx by value accessed from stack
fprintf(cg_flag, "\tmovl\t%%edx, %d(%%rbp)\t#mod end\n", getAddress(cg)); //stores result from edx (remainder)
fprintf(cg_flag, "\tmovl\t%d(%%rbp), %%eax\t#mod start\n", getAddress(op1CG)); //moves dividend into eax
fprintf(cg_flag, "\tcltd\n"); //sign extends the dividend in eax
fprintf(cg_flag, "\tidivl\t%d(%%rbp)\n", getAddress(op2CG)); //divides edx by value accessed from stack
fprintf(cg_flag, "\tmovl\t%%edx, %d(%%rbp)\t#mod end\n", getAddress(cg)); //stores result from edx (remainder)
return 0;
}
int generateOr(Instruction *inst) {
/*
/*
Both immediate:
One immediate:
Neither immediate:
@ -376,7 +373,7 @@ int generateOr(Instruction *inst) {
fprintf(cg_flag, ".L%dor4:\n", label);
fprintf(cg_flag, "\tmovb\t%%al, %d(%%rbp)\n", getAddress(cg));
fprintf(cg_flag, "\tandb\t$1, %d(%%rbp)\t#or end\n", getAddress(cg)); //stores result
fprintf(cg_flag, "\tandb\t$1, %d(%%rbp)\t#or end\n", getAddress(cg)); //stores result
return 0;
}
@ -410,7 +407,7 @@ int generateAnd(Instruction *inst) {
printdebug("generateAnd failed, %s is not initialized/in CG", getName(getTN(op2)));
return -1;
}
int label = label_gen();
int label = label_gen();
fprintf(cg_flag, "\tcmpl\t$0, %d(%%rbp)\t#start and\n", getAddress(op1CG));
fprintf(cg_flag, "\tje\t.L%dor2\n", label);
@ -426,7 +423,7 @@ int generateAnd(Instruction *inst) {
fprintf(cg_flag, ".L%dor3:\n", label);
fprintf(cg_flag, "\tmovb\t%%al, %d(%%rbp)\n", getAddress(cg));
fprintf(cg_flag, "\tandb\t$1, %d(%%rbp)\t#and end\n", getAddress(cg)); //stores result
fprintf(cg_flag, "\tandb\t$1, %d(%%rbp)\t#and end\n", getAddress(cg)); //stores result
return 0;
}
int generateNeg(Instruction *inst) {
@ -486,7 +483,6 @@ int generateAssign(Instruction *inst) {
TNodeOrConst *op1 = getOperand1(inst);
CGNode *cg = findCG(getResult(inst));
if (op1 == NULL) {
printdebug("generateAssign failed, NULL operand");
return -1;
@ -514,7 +510,7 @@ int generateAssign(Instruction *inst) {
return 0;
}
int generateGoto(Instruction *inst){
int generateGoto(Instruction *inst) {
return -1;
}
@ -522,17 +518,17 @@ int generateCondGoto(Instruction *inst) {
return -1;
}
int generateIfTrue(Instruction *inst){
int generateIfTrue(Instruction *inst) {
return -1;
// might just be a goto for where to go if something is true, or returning if something is true, or checking if true and writing goto if thats the case
}
int generateIfFalse(Instruction *inst){
int generateIfFalse(Instruction *inst) {
return -1;
}
int generateLessThan(Instruction *inst){
/*
int generateLessThan(Instruction *inst) {
/*
Both immediate:
One immediate:
Neither immediate:
@ -569,8 +565,8 @@ int generateLessThan(Instruction *inst){
return 0;
}
int generateEqualTo(Instruction *inst){
/*
int generateEqualTo(Instruction *inst) {
/*
Both immediate:
One immediate:
Neither immediate:
@ -606,8 +602,7 @@ int generateEqualTo(Instruction *inst){
fprintf(cg_flag, "\tmovb\t%%al, %d(%%rbp)\t#equal to end\n", getAddress(cg));
return 0;
}
int generateCall(Instruction *inst){
int generateCall(Instruction *inst) {
TNodeOrConst *op1 = getOperand1(inst);
TNodeOrConst *op2 = getOperand2(inst);
if (op1 == NULL) {
@ -630,7 +625,6 @@ int generateCall(Instruction *inst){
// return -1;
//}
fprintf(cg_flag, "\tcall %s\n", getName(getTN(op1)));
//now for the return
@ -643,22 +637,20 @@ int generateCall(Instruction *inst){
fprintf(cg_flag, "\tmovl\t%%eax, %d(%%rbp)\t#store return from call\n", getAddress(cg));
return 0;
}
int generateReturn(Instruction *inst){
int generateReturn(Instruction *inst) {
TNodeOrConst *op1 = getOperand1(inst);
CGNode *cg;
if (op1 == NULL) {
printdebug("generateReturn failed, NULL operand");
return -1;
}
cg = findCG(getTN(op1));
if (cg == NULL) {
printdebug("generateReturn failed, trying to return %s not in CGList", getName(getTN(op1)));
return -1;
return -1;
}
fprintf(cg_flag, "\tmovl\t%d(%%rbp), %%eax\t#return %s\n", getAddress(cg), getName(getTN(op1)));
@ -666,38 +658,38 @@ int generateReturn(Instruction *inst){
fprintf(cg_flag, "\tret\n");
return 0;
}
int generateCopyRight(Instruction *inst){
int generateCopyRight(Instruction *inst) {
return -1;
}
int generateCopyLeft(Instruction *inst){
int generateCopyLeft(Instruction *inst) {
return -1;
}
int generateAddressOf(Instruction *inst){
int generateAddressOf(Instruction *inst) {
return -1;
}
int generateParam(Instruction *inst){
int generateParam(Instruction *inst) {
TNodeOrConst *op1 = getOperand1(inst);
if (op1 == NULL) {
printdebug("generateParam failed, NULL operand");
return -1;
}
CGNode *op1CG = findCG(getTN(op1));
if (op1CG == NULL) {
printdebug("generateParam failed, %s is not in CGlist", getName(getTN(op1)));
return -1;
}
fprintf(cg_flag, "\tmovl\t%d(%%rbp), %%edi\t#adding param start\n", getAddress(op1CG));
fprintf(cg_flag, "\tmovl\t%d(%%rbp), %%edi\t#adding param start\n", getAddress(op1CG));
return 0;
}
int generateFunctionStart(Instruction *inst) {
currentsp = offset;
TableNode *funDecTN = getResult(inst);
if (funDecTN == NULL) {
printdebug("generateFunctionStart failed, NULL tablenode");
return -1;
@ -707,27 +699,27 @@ int generateFunctionStart(Instruction *inst) {
fprintf(cg_flag, "%s:\n", getName(funDecTN));
fprintf(cg_flag, "\tpushq\t%%rbp\n");
fprintf(cg_flag, "\tmovq\t%%rsp, %%rbp\n");
fprintf(cg_flag, "\tsubq\t$%d, %%rsp\n", 128); // [CHANGE ME] 128 is a placeholder for the stack size
fprintf(cg_flag, "\tsubq\t$%d, %%rsp\n", 128); // [CHANGE ME] 128 is a placeholder for the stack size
//now we need to add the CGs of nodes to the CG list by doing assign from the
// have function declararation node
//declaration ->getType: if record, go through each element and load param from stack and store to correct tn cg
// if not, go get one element of type of param
//declaration ->getType->getDefinitionScope?: go through first n entries to get table nodes for params
TableNode *paramTN = getParameter(getTypeEntry(funDecTN));
SymbolTable *st = getFunScope(funDecTN);
int paramOffset = 16;
TableNode *tnToAdd = getFirstEntry(st);
if (getAdInfoType(paramTN) != TYPE_RECORD_TYPE) {
CGNode *paramCG = addCG(tnToAdd, offset);
fprintf(cg_flag, "\tmovl\t%d(%%rbp), %%eax\t#FunctionStart1Param start\n", paramOffset);
fprintf(cg_flag, "\tmovl\t%d(%%rbp), %%eax\t#FunctionStart1Param start\n", paramOffset);
fprintf(cg_flag, "\tmovl\t%%eax, %d(%%rbp)\t#FunctionStart1param end\n", getAddress(paramCG));
} else {
int numParams = getRecLength(paramTN);
for (int i = 0; i < numParams; i++) {
CGNode *paramCG = addCG(tnToAdd, offset);
fprintf(cg_flag, "\tmovl\t%d(%%rbp), %%eax\t#FunctionStart1Param start\n", paramOffset);
CGNode *paramCG = addCG(tnToAdd, offset);
fprintf(cg_flag, "\tmovl\t%d(%%rbp), %%eax\t#FunctionStart1Param start\n", paramOffset);
fprintf(cg_flag, "\tmovl\t%%eax, %d(%%rbp)\t#FunctionStart1param end\n", getAddress(paramCG));
paramOffset = getPrimSize(getTypeEntry(tnToAdd));
tnToAdd = getNextEntry(tnToAdd);

8
src/grammar.h
View File

@ -8,7 +8,7 @@
#include "../src/symbol_table.h"
extern FILE *asc_flag;
extern bool tc_flag;
extern void insert_code_line(char * error_message, int line_number);
extern void insert_code_line(char *error_message, int line_number);
extern bool contains_errors;
typedef enum {
@ -32,6 +32,6 @@ int offset;
int currentsp;
CGNode *cgList;
Stack* stack;
Stack* TrueList;
Stack* FalseList;
Stack *stack;
Stack *TrueList;
Stack *FalseList;

2
src/grammar.y
View File

@ -138,7 +138,7 @@ include_list:
include_statement:
INCLUDE C_STRING
INCLUDE C_STRING
;

935
src/intermediate_code.c
View File

File diff suppressed because it is too large Load Diff

193
src/intermediate_code.h
View File

@ -16,20 +16,20 @@ typedef struct Stack Stack;
typedef struct __Node __Node;
typedef struct __Node {
void * v;
__Node * next;
void *v;
__Node *next;
} __Node;
typedef struct Stack {
__Node * n;
int w;
int size;
__Node *n;
int w;
int size;
} Stack;
Stack * S_Init();
Stack *S_Init();
void S_Free(Stack *s);
void S_Push(Stack * s, void *v, int i);
void * S_Pop(Stack *s);
void * S_Peek(Stack *s);
void S_Push(Stack *s, void *v, int i);
void *S_Pop(Stack *s);
void *S_Peek(Stack *s);
bool S_IsEmpty(Stack *s);
int S_Size(Stack *s);
void S_Merge(Stack *list);
@ -39,137 +39,130 @@ typedef union TNConstUnion TNConstUnion;
typedef struct Instruction Instruction;
typedef struct TNodeOrConst TNodeOrConst;
// these are from page 364
typedef enum { // these are from page 364
E_LABEL = 10000, // this is not in the book
E_FUNC_START,
E_ADD, // 1 from the list
E_SUB, // 1
E_MUL, // 1
E_DIV, // 1
E_MOD, // 1 TODO: Please change to REM
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
typedef enum { // these are from page 364
E_LABEL = 10000, // this is not in the book
E_FUNC_START,
E_ADD, // 1 from the list
E_SUB, // 1
E_MUL, // 1
E_DIV, // 1
E_MOD, // 1 TODO: Please change to REM
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
NODE = 11000, // TableNode
INTEGER, // int
STRING, // char *
CHARACTER, // char
ADDRESS, // void *
BOOLEAN // bool
} Discriminant;
typedef union TNConstUnion {
TableNode * node;
int integer;
char * string;
char character;
void * address;
bool Boolean;
TableNode *node;
int integer;
char *string;
char character;
void *address;
bool Boolean;
} TNConstUnion;
typedef struct TNodeOrConst {
Discriminant d;
TNConstUnion * tnc_union;
Discriminant d;
TNConstUnion *tnc_union;
} TNodeOrConst;
typedef struct Instruction {
Op opcode;
TableNode * result;
TNodeOrConst * operand1;
TNodeOrConst * operand2;
int label;
int index;
Op opcode;
TableNode *result;
TNodeOrConst *operand1;
TNodeOrConst *operand2;
int label;
int index;
Instruction * prev;
Instruction * next;
Instruction *prev;
Instruction *next;
} Instruction;
// NOTE We are not using this We are using the Stack api
typedef struct TFList {
Instruction * i;
TFList * next;
Instruction *i;
TFList *next;
} TFList;
// TFList * make_list(Instruction * i);
// - makelist(i) function to create instruction lists
// - makelist(i) function to create instruction lists
// void merge(TFList * l1, TFList * l2);
// - merge(p1,p2) function to concatenate lists
// - merge(p1,p2) function to concatenate lists
// void backpatch(TFList * l, int label);
// - backpatch(p,i) function to fill in jump targets
// - backpatch(p,i) function to fill in jump targets
// void bp_temp(int n);
extern Instruction * begin;
extern Instruction * current;
extern Instruction *begin;
extern Instruction *current;
extern int label_count;
extern bool code_gen;
extern FILE * ir_flag;
extern FILE *ir_flag;
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);
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(TableNode* 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);
void emit_function_start(TableNode *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);
void emit_goto(int i);
void emit_detach();
void emit_push_all(Stack * s);
void emit_push_all(Stack *s);
int getLabel(Instruction *i);
TableNode *getTN(TNodeOrConst *tnc);
int getConst(TNodeOrConst *tnc);
int getLabel(Instruction * i);
TableNode* getTN(TNodeOrConst* tnc);
int getConst(TNodeOrConst* tnc);
TNodeOrConst * getOperand1(Instruction * i);
TNodeOrConst * getOperand2(Instruction * i);
TableNode * getResult(Instruction * i);
Op getOp(Instruction * i);
int getLabel(Instruction * i);
int get_index(Instruction * i);
void set_label(Instruction * i, int label);
bool isConst(TNodeOrConst * tnc);
TNodeOrConst *getOperand1(Instruction *i);
TNodeOrConst *getOperand2(Instruction *i);
TableNode *getResult(Instruction *i);
Op getOp(Instruction *i);
int getLabel(Instruction *i);
int get_index(Instruction *i);
void set_label(Instruction *i, int label);
bool isConst(TNodeOrConst *tnc);
int label_gen();
void backpatch(Stack *s, int l);
void emit_backpatch(Stack *s, int l);
extern int offset;
extern int currentsp;
extern CGNode* cgList;
extern CGNode *cgList;

5
src/lexicalStructure.h
View File

@ -25,10 +25,11 @@ int line_number = 1;
int column_number = 1;
int yycolumn = 1;
#define YY_USER_ACTION { \
#define YY_USER_ACTION \
{ \
yylloc.first_line = yylineno; \
yylloc.last_line = yylineno; \
yylloc.first_column = yycolumn; \
yylloc.last_column = yycolumn + yyleng - 1; \
yycolumn += yyleng; \
}
}

1
src/runner.c
View File

@ -103,7 +103,6 @@ int run(FILE *alpha) {
int token;
top = cur = init(CreateScope(NULL, 1, 1));
// If file is not found
if (alpha == NULL) {
fprintf(stderr, "INPUT FILE NOT FOUND\n");

12
src/runner.h
View File

@ -59,8 +59,8 @@ bool DEBUG = false;
int no_flag = 0;
int arg;
bool contains_errors = false;
char * cg_name;
char * ir_name;
char *cg_name;
char *ir_name;
TableNode *funprime;
TableNode *arrayprim;
@ -73,9 +73,9 @@ TableNode *recprime;
TableNode *funtypeprime;
TableNode *undefined;
extern Instruction *begin;
extern Stack* stack;
extern Stack* TrueList;
extern Stack* FalseList;
extern Stack *stack;
extern Stack *TrueList;
extern Stack *FalseList;
int main(int argc, char *argv[]);
int check_flag(char *arg, char *alpha);
@ -112,6 +112,6 @@ typedef struct CodeLine {
CodeLine *code_head;
char *file_read_line(FILE *fp);
void insert_code_line(char * error_message, int line_number);
void insert_code_line(char *error_message, int line_number);
void append_code_line(CodeLine *code_line);
void print_code_lines();

46
src/symbol_table.c
View File

@ -116,15 +116,15 @@ int getPrimSize(TableNode *definition) {
"Invalid.");
return -1;
}
if(getAdInfoType(definition) == TYPE_ARRAY_TYPE){
if (getAdInfoType(definition) == TYPE_ARRAY_TYPE) {
//special case to return size for reference to an array
return 8;
}
if(getAdInfoType(definition) == TYPE_FUNCTION_TYPE){
if (getAdInfoType(definition) == TYPE_FUNCTION_TYPE) {
//special case to return size for reference to a function
return 8;
}
if(getAdInfoType(definition) == TYPE_RECORD_TYPE){
if (getAdInfoType(definition) == TYPE_RECORD_TYPE) {
//special case to return size for reference to a record
return getRecTotal(definition);
}
@ -469,7 +469,7 @@ int getRecSize(SymbolTable *tn) {
// multiple inputs Below function also has the line number where the function is
// first defined
AdInfo *CreateFunctionDeclarationInfo(int line, bool asorregular, SymbolTable *scope) {
AdInfo *info = (AdInfo *)calloc(1,sizeof(AdInfo));
AdInfo *info = (AdInfo *)calloc(1, sizeof(AdInfo));
info->FunDecAdInfo = (function_declaration_info *)malloc(
sizeof(function_declaration_info));
info->FunDecAdInfo->startlinenumber = line;
@ -561,12 +561,12 @@ SymbolTable *getFunScope(TableNode *definition) {
"node has NULL additionalinfo. Invalid.");
return NULL;
}
if(definition->additionalinfo->FunDecAdInfo == NULL) {
if (definition->additionalinfo->FunDecAdInfo == NULL) {
printdebug(
"node has NULL additionalinfo. Invalid.");
return NULL;
}
if(definition->additionalinfo->FunDecAdInfo->scope == NULL) {
if (definition->additionalinfo->FunDecAdInfo->scope == NULL) {
printdebug(
"node has no scope initialized.");
return NULL;
@ -587,17 +587,17 @@ TableNode *setFunScope(TableNode *tn, SymbolTable *scope) {
"invalid");
return undefined;
}
if(tn->additionalinfo == NULL) {
if (tn->additionalinfo == NULL) {
printdebug(
"node has NULL additionalinfo. Invalid.");
return undefined;
}
if(tn->additionalinfo->FunDecAdInfo == NULL) {
if (tn->additionalinfo->FunDecAdInfo == NULL) {
printdebug(
"node has NULL additionalinfo. Invalid.");
return undefined;
}
if(scope == NULL) {
if (scope == NULL) {
printdebug(
"passed in an empty scope.");
return undefined;
@ -705,7 +705,7 @@ TableNode *getReturn(TableNode *definition) {
"node has NULL additionalinfo. Invalid.");
return undefined;
}
printdebug("function:%s with return type %s\n",getName(definition),getName(definition->additionalinfo->FunTypeAdInfo->returntype));
printdebug("function:%s with return type %s\n", getName(definition), getName(definition->additionalinfo->FunTypeAdInfo->returntype));
return definition->additionalinfo->FunTypeAdInfo->returntype;
}
@ -862,10 +862,10 @@ SymbolTable *init(SymbolTable *start) {
chara->additionalinfo = CreatePrimitiveInfo(SIZE_CHAR);
stri->additionalinfo = CreateArrayInfo(1, chara);
boo->additionalinfo = CreatePrimitiveInfo(SIZE_BOOL);
reserve->additionalinfo = CreateFunctionDeclarationInfo(0, false,NULL);
reserve->additionalinfo = CreateFunctionDeclarationInfo(0, false, NULL);
reservetype->additionalinfo = CreateFunctionTypeInfo(integ, addr);
releasetype->additionalinfo = CreateFunctionTypeInfo(addr, integ);
release->additionalinfo = CreateFunctionDeclarationInfo(0, false,NULL);
release->additionalinfo = CreateFunctionDeclarationInfo(0, false, NULL);
integ->tag = TYPE_PRIMITIVE_TYPE; // explicitly set the type for integ
addr->tag = TYPE_PRIMITIVE_TYPE; // explicitly set the type for addr
@ -1031,7 +1031,7 @@ TableNode *CreateEntry(SymbolTable *table, int tag, TableNode *typeOf, char *id,
return NULL;
}
*/
if((id != NULL) && table_lookup(cur,id)!=undefined){
if ((id != NULL) && table_lookup(cur, id) != undefined) {
printdebug("This name is already defined in the current scope");
//throw_error(ERROR_TYPE, "Already defined.");
return undefined;
@ -1062,7 +1062,7 @@ TableNode *CreateEntry(SymbolTable *table, int tag, TableNode *typeOf, char *id,
printdebug("[CreateEntry] Adding %s to the symbol table", id);
return newEntry;
} else {
TableNode*oldEntry = table->entries;
TableNode *oldEntry = table->entries;
while (oldEntry->next != NULL) {
oldEntry = oldEntry->next;
}
@ -1309,7 +1309,7 @@ void print_symbol_table(SymbolTable *table, FILE *file_ptr) {
}
for (; entry != NULL; entry = getNextEntry(entry)) {
if((getName(entry)[0] == '$' || getName(entry)[0] == '&') && ir_flag == NULL){
if ((getName(entry)[0] == '$' || getName(entry)[0] == '&') && ir_flag == NULL) {
continue;
}
if (getAdInfoType(entry) == TYPE_ARRAY_TYPE) {
@ -1391,11 +1391,11 @@ void print_symbol_table(SymbolTable *table, FILE *file_ptr) {
if (getAdInfoType(entry) == TYPE_FUNCTION_DECLARATION) {
char *functiontype = (char *)malloc(100);
sprintf(functiontype, " %s", getName(getTypeEntry(entry)));
char* functionScope = (char *)malloc(100);
if(getLine(getFunScope(entry)) < 1){
char *functionScope = (char *)malloc(100);
if (getLine(getFunScope(entry)) < 1) {
sprintf(functionScope, " Function not defined before runtime");
}else{
sprintf(functionScope, " Function Definition that starts at line %d",getLine(getFunScope(entry)));
} else {
sprintf(functionScope, " Function Definition that starts at line %d", getLine(getFunScope(entry)));
}
if (parentScopeNum == 0) {
st_fprint(file_ptr, getName(entry), currentScopeNum, -100, functiontype, functionScope);
@ -1545,7 +1545,13 @@ SymbolTable *getParent(SymbolTable *st) {
ListOfTable *getChildren(SymbolTable *st) { return st->Children_Scope; }
SymbolTable *getFirstChild(ListOfTable *lt) { return lt->table; }
ListOfTable *getRestOfChildren(ListOfTable *lt) { return lt->next; }
TableNode *getFirstEntry(SymbolTable *st) { return st->entries; }
TableNode *getFirstEntry(SymbolTable *st) {
if (st == NULL || st->entries == NULL) {
printdebug("passed a NULL symbol table to getFirstEntry");
return undefined;
}
return st->entries;
}
// Segfaults when passed an invalid table node!
TableNode *getNextEntry(TableNode *tn) {

4
src/symbol_table.h
View File

@ -48,7 +48,7 @@ typedef struct {
typedef struct {
int startlinenumber;
bool regularoras;
SymbolTable* scope;
SymbolTable *scope;
} function_declaration_info;
typedef struct {
@ -122,7 +122,7 @@ int getRecLength(TableNode *definition);
SymbolTable *getRecList(TableNode *definition);
TableNode *setRecSize(TableNode *tn, int n);
int getRecSize(SymbolTable *tn);
AdInfo *CreateFunctionDeclarationInfo(int line, bool asorregular,SymbolTable *scope);
AdInfo *CreateFunctionDeclarationInfo(int line, bool asorregular, SymbolTable *scope);
TableNode *setFunScope(TableNode *tn, SymbolTable *scope);
SymbolTable *getFunScope(TableNode *definition);
int getStartLine(TableNode *definition);

1
tests/programs/test/fib.alpha Normal file
View File

@ -0,0 +1 @@
(* TODO: Prints out fib sequence. *)

1
tests/programs/test/ll.alpha Normal file
View File

@ -0,0 +1 @@
(* TODO: creates a linked list and prints out the chain. *)

25
tests/sprint4/test/sp4_cg_add.alpha
View File

@ -1,35 +1,14 @@
(* TEST: [-asc -tc -cg -ir] *)
type string: 1 -> character
type BooleanXBoolean: [Boolean: x; Boolean: y]
type characterXcharacter: [character: x; character: y]
type integerXinteger: [integer: x; integer: y]
type Boolean2Boolean: Boolean -> Boolean
type integer2integer: integer -> integer
type character2integer: character -> integer
type Boolean2integer0: Boolean -> integer
type string2integer: string -> integer
type integerXinteger2integer: integerXinteger -> integer
type integerXinteger2Boolean: integerXinteger -> Boolean
type characterXcharacter2Boolean: characterXcharacter -> Boolean
type BooleanXBoolean2Boolean: BooleanXBoolean -> Boolean
type integer2address: integer -> address
type address2integer: address -> integer
external function printInteger: integer2integer
external function printCharacter: character2integer
external function printBoolean: Boolean2integer
function entry: string2integer
#include "std.alpha"
entry (arg) := {
[integer:x; integer:y; integer: result]
y := 1;
x := 3;
y := x + y;
result := printInteger(y);
return y;
}

18
tests/sprint4/test/sp4_cg_and.alpha
View File

@ -1,11 +1,13 @@
(* TEST: [-asc -tc -cg -ir] *)
type main: integer -> integer
function test: main
test (a) := {
[Boolean:b; Boolean: c; Boolean: d]
c := true;
d := false;
d := c & d;
return 1;
#include "std.alpha"
entry (arg) := {
[Boolean:b; Boolean: c; Boolean: d]
z := true;
d := false;
d := c & d;
return 1;
}

8
tests/sprint4/test/sp4_cg_demo.alpha
View File

@ -1,8 +0,0 @@
type main: string -> integer
function entry: main
entry(arg) := {
[integer:x]
x := 3 + 2 * 8;
return x;
}

9
tests/sprint4/test/sp4_cg_demo.cg
View File

@ -1,9 +0,0 @@
type main: string -> integer
function entry: main
entry(arg) := {
[integer:x; Boolean b]
x := 3 + 2 * 8;
b := x < 1;
return 0;
}

18
tests/sprint4/test/sp4_cg_div.alpha
View File

@ -1,11 +1,13 @@
(* TEST: [-asc -tc -cg -ir] *)
type main: integer -> integer
function test: main
test (a) := {
[integer:x; integer:y]
y := 1;
x := 3;
y := x / y;
return y;
#include "std.alpha"
entry (arg) := {
[integer:x; integer:y]
y := 1;
x := 3;
y := x / y;
return y;
}

14
tests/sprint4/test/sp4_cg_equal_to.alpha
View File

@ -1,11 +1,13 @@
(* TEST: [-asc -tc -cg -ir] *)
type main: integer -> integer
function test: main
test (a) := {
[Boolean: b; integer: x; integer: y]
x := 1;
#include "std.alpha"
entry (arg) := {
[Boolean: b; integer: x; integer: y]
x := 1;
y := 2;
b := x = y;
return 1;
return 1;
}

18
tests/sprint4/test/sp4_cg_fib.alpha
View File

@ -1,18 +0,0 @@

14
tests/sprint4/test/sp4_cg_less_than.alpha
View File

@ -1,11 +1,13 @@
(* TEST: [-asc -tc -cg -ir] *)
type main: integer -> integer
function test: main
test (a) := {
[Boolean: b; integer: x; integer: y]
character x := 1;
#include "std.alpha"
entry (arg) := {
[Boolean: b; integer: x; integer: y]
x := 1;
y := 2;
b := x < y;
return 1;
return 1;
}

18
tests/sprint4/test/sp4_cg_mod.alpha
View File

@ -1,11 +1,13 @@
(* TEST: [-asc -tc -cg -ir] *)
type main: integer -> integer
function test: main
test (a) := {
[integer:x; integer:y]
y := 1;
x := 3;
y := x % y;
return y;
#include "std.alpha"
entry (arg) := {
[integer:x; integer:y]
y := 1;
x := 3;
y := x % y;
return y;
}

18
tests/sprint4/test/sp4_cg_mult.alpha
View File

@ -1,11 +1,13 @@
(* TEST: [-asc -tc -cg -ir] *)
type main: integer -> integer
function test: main
test (a) := {
[integer:x; integer:y]
y := 1;
x := 3;
y := x * x;
return y;
#include "std.alpha"
entry (arg) := {
[integer:x; integer:y]
y := 1;
x := 3;
y := x * x;
return y;
}

16
tests/sprint4/test/sp4_cg_neg.alpha
View File

@ -1,10 +1,12 @@
(* TEST: [-asc -tc -cg -ir] *)
type main: integer -> integer
function test: main
test (a) := {
[integer:x; integer:y]
x := 3;
y := -x;
return y;
#include "std.alpha"
entry (arg) := {
[integer:x; integer:y]
x := 3;
y := -x;
return y;
}

16
tests/sprint4/test/sp4_cg_not.alpha
View File

@ -1,10 +1,12 @@
(* TEST: [-asc -tc -cg -ir] *)
type main: integer -> integer
function test: main
test (a) := {
[Boolean: c; Boolean: d]
c := true;
d := !c;
return 1;
#include "std.alpha"
entry (arg) := {
[Boolean: c; Boolean: d]
c := true;
d := !c;
return 1;
}

18
tests/sprint4/test/sp4_cg_or.alpha
View File

@ -1,11 +1,13 @@
(* TEST: [-asc -tc -cg -ir] *)
type main: integer -> integer
function test: main
test (a) := {
[Boolean:b; Boolean: c; Boolean: d]
c := true;
d := false;
d := c | d;
return 1;
#include "std.alpha"
entry (arg) := {
[Boolean:b; Boolean: c; Boolean: d]
c := true;
d := false;
d := c | d;
return 1;
}

18
tests/sprint4/test/sp4_cg_sub.alpha
View File

@ -1,11 +1,13 @@
(* TEST: [-asc -tc -cg -ir] *)
type main: integer -> integer
function test: main
test (a) := {
[integer:x; integer:y]
y := 1;
x := 3;
y := x - y;
return y;
#include "std.alpha"
entry (arg) := {
[integer:x; integer:y]
y := 1;
x := 3;
y := x - y;
return y;
}