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

updated grammar to pass up instances. Still need IR to compile to properly emit

Browse Source
This commit is contained in:
Partho
2025-04-23 18:49:09 -04:00
parent 7a49701712
commit e0c577a7ef
5 changed files with 305 additions and 111 deletions
Download Patch File Download Diff File Expand all files Collapse all files

327
src/grammar.y
View File

@ -29,6 +29,7 @@
%union {
int integ;
char* words;
char letter;
void* tn;
}
@ -538,30 +539,22 @@ WHILE L_PAREN expression R_PAREN sblock {
simple_statement:
assignable ASSIGN expression
{
{ printdebug("simple statement");
TableNode* node;
if((getAdInfoType((TableNode*)$1) == TYPE_PRIMITIVE_TYPE||
getAdInfoType((TableNode*)$1) == TYPE_ARRAY_TYPE||
getAdInfoType((TableNode*)$1) == TYPE_RECORD_TYPE||
getAdInfoType((TableNode*)$1) == TYPE_FUNCTION_TYPE)){
node = (TableNode*)$1;
}else if((getAdInfoType((TableNode*)$1) == TYPE_FUNCTION_DECLARATION)||
if((getAdInfoType((TableNode*)$1) == TYPE_FUNCTION_DECLARATION)||
(getAdInfoType((TableNode*)$1) == TYPE_ARRAY)||
(getAdInfoType((TableNode*)$1) == TYPE_RECORD)||
(getAdInfoType((TableNode*)$1) == TYPE_PRIMITIVE)){
node = getTypeEntry((TableNode*)$1);
node = ((TableNode*)$1);
} else{
error_type(undefined, undefined, "Invalid type passed to assignable.");
node = undefined;
}
if((getAdInfoType(node) == TYPE_ARRAY_TYPE||
getAdInfoType(node) == TYPE_RECORD_TYPE) &&
(strcmp(getName((TableNode*)$3),"address") == 0)){
printdebug("%s[☺] Passed array/record type check; %s = %s", COLOR_GREEN, getName(node), getName((TableNode*)$3));
}
else if(getAdInfoType(node) == getAdInfoType((TableNode*)$3)){
if(getAdInfoType(node) == getAdInfoType((TableNode*)$3)){
//EMIT ASSIGN INSTRUCTION HERE
printdebug("%s[☺] Passed type check; %s = %s", COLOR_GREEN, getName(node), getName((TableNode*)$3));
} else {
error_type(node, (TableNode*)$3, "");
@ -571,7 +564,7 @@ simple_statement:
}
| RETURN expression {$$ = $2;}
| RETURN expression {$$ = getTypeEntry((TableNode*)$2);}
;
@ -592,6 +585,7 @@ ablock:
argument_list:
//NEED TO EMIT PARAMETERS HERE. MAYBE USE STACK STRUCTURE
expression COMMA argument_list
{
CreateEntry(cur,getAdInfoType((TableNode*)$1), (TableNode*)$1, getName((TableNode*)$1), NULL);
@ -618,160 +612,188 @@ expression:
| SUB_OR_NEG expression %prec UMINUS
{
printdebug("negative expression");
if((TableNode*)$2 != integ) {
printdebug("cant negate something not an integer at line %d and column %d",@2.first_line,@2.first_column);
$$=undefined;
if(getTypeEntry((TableNode*)$2) == integ) {
char* temp = temp_var_gen();
TableNode* node = CreateEntry(cur,TYPE_PRIMITIVE, integ, temp, NULL);
//NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK)
//result of unary operation
$$ = node;
} else {
$$=(TableNode*)$2;
$$=undefined;
error_type(getTypeEntry((TableNode*)$2), integ, "");
}
}
| NOT expression
{
printdebug("not expression");
if((TableNode*)$2 == boo) {
$$=(TableNode*)$2;
if(getTypeEntry((TableNode*)$2) == boo) {
char* temp = temp_var_gen();
TableNode* node = CreateEntry(cur,TYPE_PRIMITIVE, boo, temp, NULL);
//NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK)
//result of unary operation
$$ = node;
} else {
$$=undefined;
error_type((TableNode*)$2, boo, "");
error_type(getTypeEntry((TableNode*)$2), boo, "");
}
}
| expression ADD expression
{
printdebug("add expression");
if((TableNode*)$1 == (TableNode*)$3 && (TableNode*)$1 == integ) {
$$=(TableNode*)$1;
if((getTypeEntry((TableNode*)$1) == getTypeEntry((TableNode*)$3)) && getTypeEntry((TableNode*)$1) == integ) {
char* temp = temp_var_gen();
TableNode* node = CreateEntry(cur,TYPE_PRIMITIVE, integ, temp, NULL);
//NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK)
//result of binary operation
$$ = node;
} else {
$$=undefined;
error_type((TableNode*)$1, (TableNode*)$3, "");
error_type(getTypeEntry((TableNode*)$1), getTypeEntry((TableNode*)$3), "");
}
}
| expression SUB_OR_NEG expression
{
printdebug("sub or neg expression");
if((TableNode*)$1 == (TableNode*)$3 && (TableNode*)$1 == integ) {
$$=(TableNode*)$1;
if((getTypeEntry((TableNode*)$1) == getTypeEntry((TableNode*)$3)) && getTypeEntry((TableNode*)$1) == integ) {
char* temp = temp_var_gen();
TableNode* node = CreateEntry(cur,TYPE_PRIMITIVE, integ, temp, NULL);
//NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK)
//result of binary operation
$$ = node;
} else {
$$=undefined;
error_type((TableNode*)$1, (TableNode*)$3, "");
error_type(getTypeEntry((TableNode*)$1), getTypeEntry((TableNode*)$3), "");
}
}
| expression MUL expression
{
printdebug("multiply expression");
if((TableNode*)$1 == (TableNode*)$3 && (TableNode*)$1 == integ) {
$$=(TableNode*)$1;
} else{
if((getTypeEntry((TableNode*)$1) == getTypeEntry((TableNode*)$3)) && getTypeEntry((TableNode*)$1) == integ) {
char* temp = temp_var_gen();
TableNode* node = CreateEntry(cur,TYPE_PRIMITIVE, integ, temp, NULL);
//NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK)
//result of binary operation
$$ = node;
} else {
$$=undefined;
error_type((TableNode*)$1, (TableNode*)$3, "");
error_type(getTypeEntry((TableNode*)$1), getTypeEntry((TableNode*)$3), "");
}
}
| expression DIV expression
{
printdebug("divide expression");
if((strcmp(getName((TableNode*)$1),getName((TableNode*)$3))==0) && ((TableNode*)$1 == integ)) {
$$=(TableNode*)$1;
if((getTypeEntry((TableNode*)$1) == getTypeEntry((TableNode*)$3)) && getTypeEntry((TableNode*)$1) == integ) {
char* temp = temp_var_gen();
TableNode* node = CreateEntry(cur,TYPE_PRIMITIVE, integ, temp, NULL);
//NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK)
//result of binary operation
$$ = node;
} else {
$$=undefined;
error_type((TableNode*)$1, (TableNode*)$3, "");
error_type(getTypeEntry((TableNode*)$1), getTypeEntry((TableNode*)$3), "");
}
}
| expression REM expression
{
printdebug("remainder expression");
if($1 == $3 && $1 == integ) {
$$=$1;
if((getTypeEntry((TableNode*)$1) == getTypeEntry((TableNode*)$3)) && getTypeEntry((TableNode*)$1) == integ) {
char* temp = temp_var_gen();
TableNode* node = CreateEntry(cur,TYPE_PRIMITIVE, integ, temp, NULL);
//NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK)
//result of binary operation
$$ = node;
} else {
$$=undefined;
error_type((TableNode*)$1, (TableNode*)$3, "");
error_type(getTypeEntry((TableNode*)$1), getTypeEntry((TableNode*)$3), "");
}
}
| expression AND expression
{
printdebug("AND expression");
if($1 == $3 && $1 == boo){
$$=$1;
} else{
printdebug("AND");
if((getTypeEntry((TableNode*)$1)==getTypeEntry((TableNode*)$3)) && getTypeEntry((TableNode*)$1) == boo) {
char* temp = temp_var_gen();
TableNode* node = CreateEntry(cur,TYPE_PRIMITIVE, boo, temp, NULL);
//NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK)
//result of comparison
$$ = node;
} else {
$$=undefined;
error_type((TableNode*)$1, (TableNode*)$3, "");
error_type(getTypeEntry((TableNode*)$1), getTypeEntry((TableNode*)$3), "");
}
}
| expression OR expression
{
printdebug("OR");
if((strcmp(getName((TableNode*)$1),getName((TableNode*)$3))==0) && $1 == boo) {
$$=$1;
if((getTypeEntry((TableNode*)$1)==getTypeEntry((TableNode*)$3)) && getTypeEntry((TableNode*)$1) == boo) {
char* temp = temp_var_gen();
TableNode* node = CreateEntry(cur,TYPE_PRIMITIVE, boo, temp, NULL);
//NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK)
//result of comparison
$$ = node;
} else {
$$=undefined;
error_type((TableNode*)$1, (TableNode*)$3, "");
error_type(getTypeEntry((TableNode*)$1), getTypeEntry((TableNode*)$3), "");
}
}
| expression LESS_THAN expression
{
printdebug("less than expression");
if($1 == $3 && $1==integ) {
$$=boo;
if(getTypeEntry((TableNode*)$1) == getTypeEntry((TableNode*)$3) && getTypeEntry((TableNode*)$1)==integ) {
char* temp = temp_var_gen();
TableNode* node = CreateEntry(cur,TYPE_PRIMITIVE, boo, temp, NULL);
//NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK)
//result of comparison
$$ = node;
} else {
$$=undefined;
error_type((TableNode*)$1, (TableNode*)$3, "");
error_type(getTypeEntry((TableNode*)$1), getTypeEntry((TableNode*)$3), "");
}
}
| expression EQUAL_TO expression
{
printdebug("equals check expression");
if($1 == $3 && $1 != undefined) {
$$=boo;
if(getTypeEntry((TableNode*)$1) == getTypeEntry((TableNode*)$3) && getTypeEntry((TableNode*)$1) != undefined) {
char* temp = temp_var_gen();
TableNode* node = CreateEntry(cur,TYPE_PRIMITIVE, boo, temp, NULL);
//NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK)
//result of compariosn
$$ = node;
} else {
$$ = undefined;
error_type((TableNode*)$1, (TableNode*)$3, "");
error_type(getTypeEntry((TableNode*)$1), getTypeEntry((TableNode*)$3), "");
}
}
| assignable
{
printdebug("assignable expression. current type is %s",getName((TableNode*)$1));
if(getAdInfoType((TableNode*)$1) == TYPE_PRIMITIVE||
getAdInfoType((TableNode*)$1) == TYPE_ARRAY ||
getAdInfoType((TableNode*)$1) == TYPE_RECORD){
printdebug("assignable passing up to expression is primitive, array instance, or record instance. Passing up its type");
$$= getTypeEntry((TableNode*)$1);
}
else if(getAdInfoType((TableNode*)$1) == TYPE_ARRAY_TYPE||
getAdInfoType((TableNode*)$1) == TYPE_RECORD_TYPE||
getAdInfoType((TableNode*)$1) == TYPE_FUNCTION_TYPE||
getAdInfoType((TableNode*)$1) == TYPE_PRIMITIVE_TYPE ||
getAdInfoType((TableNode*)$1) == TYPE_FUNCTION_DECLARATION){
printdebug("assignable passing up to expression is array type, record type, function type, or function declaration");
$$= ((TableNode*)$1);
}
else {
error_type(undefined, undefined, "Invalid type passed to expression.");
$$= ((TableNode*)$1);
}
$$ = $1;
}
| L_PAREN expression R_PAREN
{
printdebug("paren expression. current type is %s",getName((TableNode*)$2));
printdebug("paren expression. current type is %s",getType((TableNode*)$2));
$$=$2;
}
| memOp assignable
{
int d = getAdInfoType((TableNode*)$2);
if(d == TYPE_ARRAY_TYPE || d == TYPE_ARRAY || d == TYPE_RECORD_TYPE || d == TYPE_RECORD) {
$$ = addr;
if(d == TYPE_ARRAY ||d == TYPE_RECORD) {
char* temp = temp_var_gen();
TableNode* node = CreateEntry(cur,TYPE_PRIMITIVE, addr, temp, NULL);
//NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK)
$$ = node;
} else {
error_type(undefined, undefined, "Invalid memOp expression (%s).", getName((TableNode*)$2));
$$=undefined;
@ -788,8 +810,9 @@ expression:
assignable:
ID
{
$$ = getTypeEntry(look_up(cur,$1));
printdebug("[ASSIGNABLE - RULE 1] assignable = type: %s | ID = %s", getName((TableNode*)$$), $1);
TableNode* pass = look_up(cur,$1);
$$ = pass;
printdebug("[ASSIGNABLE - RULE 1] assignable = type: %s | ID = %s", getType(pass), getName(pass));
}
| assignable
@ -797,22 +820,24 @@ assignable:
printdebug("%sBeginning rule 2 of assignable.", COLOR_CYAN);
cur = CreateScope(cur, -1,-1);
}
//we have to consider emmissions in ablocks
ablock
{
int type = getAdInfoType(look_up(getParent(cur), getName((TableNode*)$1)));
//int type = getAdInfoType(look_up(getParent(cur), getName((TableNode*)$1)));
int type = getAdInfoType(getTypeEntry((TableNode*)$1));
printdebug("%stype is %d", COLOR_PURPLE, type);
printdebug("%s", getName((TableNode*)$1));
if (type == TYPE_FUNCTION_TYPE) {
printdebug("%sEntering function call", COLOR_LIGHTGREEN);
if (look_up(getParent(cur), getName((TableNode*)$1))->additionalinfo->FunDecAdInfo->regularoras) {
if (look_up(getParent(cur), getType((TableNode*)$1))->additionalinfo->FunDecAdInfo->regularoras) {
printdebug("as function");
//char *funtype = getType(look_up(cur, $1));
// printdebug("%s", getType(look_up(cur, getName((TableNode*)$1))));
//printdebug("%s", getType(look_up(cur, getName((TableNode*)$1))));
TableNode * typeNode = $1;
TableNode * typeNode = getTypeEntry((TableNode*)$1);
TableNode *param = getParameter(typeNode);
printTableNode(param);
@ -853,7 +878,7 @@ assignable:
}
}
} else {
char *expected = getName(getParameter(look_up(getParent(cur), getName((TableNode*)$1))));
char *expected = getName(getParameter(look_up(getParent(cur), getType((TableNode*)$1))));
char *actual = getType(getFirstEntry(cur));
if (strcmp(expected, actual) != 0) {
printdebug("expected %s expression in function call but got %s at line %d and column %d",expected, actual, @3.first_line, @3.first_column);
@ -862,29 +887,99 @@ assignable:
printdebug("expected 1 argument but got %d", $3);
}
}
printTableNode(getReturn($1));
$$ = getReturn($1);
printdebug("[ASSIGNABLE - RULE 2] assignable = type: %s | name_func = %s", getName((TableNode*)$$), getName((TableNode*)$1));
printTableNode(getReturn(getTypeEntry((TableNode*)$1)));
//
char* temp = temp_var_gen();
TableNode* typeNode2 = getReturn(getTypeEntry($1));
int t = -1;
if(getAdInfoType(typeNode2) == TYPE_PRIMITIVE_TYPE){
t = TYPE_PRIMITIVE;
}
else if(getAdInfoType(typeNode2) == TYPE_ARRAY_TYPE){
t = TYPE_ARRAY;
}
else if(getAdInfoType(typeNode2) == TYPE_RECORD_TYPE){
t = TYPE_RECORD;
}
else if(getAdInfoType(typeNode2) == TYPE_FUNCTION_TYPE){
t = TYPE_FUNCTION_DECLARATION;
}else{
t= TYPE_UNDEFINED;
printdebug("CHANGE ME [TYPE CHECK] Undefined type stored in record. improper.");
}
TableNode* node = CreateEntry(cur,t, typeNode2, temp, NULL);
$$ = node;
//NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK for function call)
printdebug("[ASSIGNABLE - RULE 2] assignable = type: %s | name_func = %s", getName(typeNode2), getName((TableNode*)$1));
} else if (type == TYPE_ARRAY_TYPE) {
printdebug("%sEntering array call", COLOR_LIGHTGREEN);
if (getNumArrDim(look_up(getParent(cur), getName((TableNode*)$1))) != $<integ>2) {
if (getNumArrDim(look_up(getParent(cur), getType((TableNode*)$1))) != $<integ>2) {
printdebug("expected %d arguments but had %d at line %d and column %d\n", getNumArrDim(look_up(cur, getName((TableNode*)$1))), $<integ>2, @2.first_line, @2.first_column);
}
$$ = getArrType(look_up(cur, getName((TableNode*)$1)));
printdebug("[ASSIGNABLE - RULE 2] assignable = type: %s | name_func = %s", getName((TableNode*)$$), getName((TableNode*)$1));
printdebug("[ASSIGNABLE - RULE 2] assignable = type: %s | name_func = %s", getName((TableNode*)$$), getName((TableNode*)$1));
char* temp = temp_var_gen();
TableNode* typeNode2 = getArrType(look_up(getAncestor(cur), getType((TableNode*)$1)));
int t = -1;
if(getAdInfoType(typeNode2) == TYPE_PRIMITIVE_TYPE){
t = TYPE_PRIMITIVE;
}
else if(getAdInfoType(typeNode2) == TYPE_ARRAY_TYPE){
t = TYPE_ARRAY;
}
else if(getAdInfoType(typeNode2) == TYPE_RECORD_TYPE){
t = TYPE_RECORD;
}
else if(getAdInfoType(typeNode2) == TYPE_FUNCTION_TYPE){
t = TYPE_FUNCTION_DECLARATION;
}else{
t= TYPE_UNDEFINED;
printdebug("CHANGE ME [TYPE CHECK] Undefined type stored in record. improper.");
}
TableNode* node = CreateEntry(cur,t, typeNode2, temp, NULL);
//emit assign here
//emit_array_access(char* node, char* array, ...)
$$ = node;
printdebug("[ASSIGNABLE - RULE 2] assignable = type: %s | name_func = %s", getType((TableNode*)$1), getName((TableNode*)$1));
}
cur = getParent(cur);
}
| assignable rec_op ID
{
if(undefined != table_lookup(getRecList(table_lookup(getAncestor(cur), getName((TableNode*)$1))), $3)) {
{
if(getAdInfoType((TableNode*)$1) != TYPE_RECORD_TYPE){
printdebug("CHANGE ME [TYPE CHECK]Invalid type passed to record access");
}
else if(undefined != table_lookup(getRecList(table_lookup(getAncestor(cur), getName(getTypeEntry((TableNode*)$1)))), $3)) {
$$ = table_lookup(getRecList(table_lookup(getAncestor(cur), getName((TableNode*)$1))), $3);
TableNode* type = table_lookup(getRecList(table_lookup(getAncestor(cur), getName(getTypeEntry((TableNode*)$1)))), $3);
char* temp = temp_var_gen();
int t = -1;
if(getAdInfoType(type) == TYPE_PRIMITIVE_TYPE){
t = TYPE_PRIMITIVE;
}
else if(getAdInfoType(type) == TYPE_ARRAY_TYPE){
t = TYPE_ARRAY;
}
else if(getAdInfoType(type) == TYPE_RECORD_TYPE){
t = TYPE_RECORD;
}
else if(getAdInfoType(type) == TYPE_FUNCTION_TYPE){
t = TYPE_FUNCTION_DECLARATION;
}else{
t= TYPE_UNDEFINED;
printdebug("CHANGE ME [TYPE CHECK] Undefined type stored in record. improper.");
}
TableNode* node = CreateEntry(cur,t, type, temp, NULL);
//NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK)
//emit_field_access(char* node, char* record, $3)
$$=node;
}else{
printdebug("CHANGE ME [TYPE CHECK] undefined type (Field Access Lookup failed)");
$$=undefined;
}
printdebug("[ASSIGNABLE - RULE 3] assignable = type: %s | ID = %s", getName((TableNode*)($$)), getName($1));
printdebug("[ASSIGNABLE - RULE 3] record = name: %s | field = %s", getName((TableNode*)($1)), getName((TableNode*)$3));
}
;
@ -908,38 +1003,56 @@ memOp:
constant:
C_STRING
{
$$ = $1;
printdebug("string of C_STRING in constant is %s",getName((TableNode*)$1));
char* temp = temp_var_gen();
TableNode* node = CreateEntry(cur,TYPE_PRIMITIVE, stri, temp, NULL);
//NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK)
printdebug("string of C_STRING in constant is %s", $1);
$$ = node;
}
| C_INTEGER
{
$$ = integ;
printdebug("string of C_INTEGER in constant is integer");
char* temp = temp_var_gen();
TableNode* node = CreateEntry(cur,TYPE_PRIMITIVE, integ, temp, NULL);
//NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK)
printdebug("number of C_INTEGER in constant is %d", $1);
$$ = node;
}
| C_NULL
{
$$ = $1;
printdebug("string of C_NULL in constant is %s",getName((TableNode*)$1));
char* temp = temp_var_gen();
TableNode* node = CreateEntry(cur,TYPE_PRIMITIVE, addr, temp, NULL);
//NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK)
printdebug("string of C_NULL in constant is NULL");
$$ = node;
}
| C_CHARACTER
{
$$ = $1;
printdebug("string of C_CHARACTER in constant is %s",getName((TableNode*)$1));
char* temp = temp_var_gen();
TableNode* node = CreateEntry(cur,TYPE_PRIMITIVE, chara, temp, NULL);
//NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK)
printdebug("string of C_CHARACTER in constant is %s",$1);
$$ = node;
}
| C_TRUE
{
$$ = $1;
printdebug("string of C_TRUE in constant is %s",getName((TableNode*)$1));
char* temp = temp_var_gen();
TableNode* node = CreateEntry(cur,TYPE_PRIMITIVE, boo, temp, NULL);
//NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK)
printdebug("string of C_TRUE in constant is true");
$$ = node;
}
| C_FALSE
{
$$ = $1;
printdebug("string of C_FALSE in constant is %s",getName((TableNode*)$1));
char* temp = temp_var_gen();
TableNode* node = CreateEntry(cur,TYPE_PRIMITIVE, boo, temp, NULL);
//NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK)
printdebug("string of C_FALSE in constant is false");
$$ = node;
}
;

4
src/lexicalStructure.lex
View File

@ -83,8 +83,8 @@ SCHAR \\n|\\t|\\\"|[^\"\n\\]
"->" {if(DEBUG) {printf( "ARROW: %s (%d)\n", yytext, ARROW);} else {if(tok_flag != NULL){print_tok(ARROW);}incr(line_number,column_number,ARROW);return ARROW;}}
{DIGIT}+ {if(DEBUG) {printf( "C_INTEGER: %s (%d)\n", yytext, C_INTEGER);} else {if(tok_flag != NULL){print_tok(C_INTEGER);}incr(line_number,column_number,C_INTEGER);yylval.integ = atoi(yytext)/*words = strdup("integer")*/;return C_INTEGER;}}
'{CHAR}' {if(DEBUG) {printf( "C_CHARACTER: %s (%d)\n", yytext, C_CHARACTER);} else {if(tok_flag != NULL){print_tok(C_CHARACTER);}incr(line_number,column_number,C_CHARACTER);yylval.tn = chara;return C_CHARACTER;}}
\"{SCHAR}*\" {if(DEBUG) {printf( "C_STRING: %s (%d)\n", yytext, C_STRING);} else {if(tok_flag != NULL){print_tok(C_STRING);}incr(line_number,column_number,C_STRING);yylval.tn = stri;return C_STRING;}}
'{CHAR}' {if(DEBUG) {printf( "C_CHARACTER: %s (%d)\n", yytext, C_CHARACTER);} else {if(tok_flag != NULL){print_tok(C_CHARACTER);}incr(line_number,column_number,C_CHARACTER);char* token = strdup(yytext)/*yylval.tn = chara*/;yylval.letter = token[1];return C_CHARACTER;}}
\"{SCHAR}*\" {if(DEBUG) {printf( "C_STRING: %s (%d)\n", yytext, C_STRING);} else {if(tok_flag != NULL){print_tok(C_STRING);}incr(line_number,column_number,C_STRING);int k = strlen(yytext);yytext[k-1] = '\0';yylval.words = strdup(&yytext[1]);return C_STRING;}}
{COMMENT} {if(DEBUG) {printf( "COMMENT: %s (%d)\n", yytext, COMMENT);} else {if(tok_flag != NULL){print_tok(COMMENT);}incr(line_number,column_number,COMMENT);/*return COMMENT;*/}}
"(" {if(DEBUG) {printf( "L_PAREN: %s (%d)\n", yytext, L_PAREN);} else {if(tok_flag != NULL){print_tok(L_PAREN);}incr(line_number,column_number,L_PAREN);return L_PAREN;}}

73
src/symbol_table.c
View File

@ -3,6 +3,9 @@
#include "symbol_table.h"
Constant_Stack* head = NULL;
int temp2_count = 0;
void printdebug_impl(char *file, int line, const char *format, ...) {
if (DEBUG) {
printf("%s<%s> [%d]%s ", COLOR_DARKGRAY, file, line,
@ -15,6 +18,76 @@ void printdebug_impl(char *file, int line, const char *format, ...) {
}
}
char * temp_var_gen(){
char * ret = calloc(9, sizeof(*ret));
sprintf(ret, "$t%d", temp2_count);
temp2_count++;
return ret;
}
Constant_Stack *Push(TableNode *type, void *value, bool isConst) {
if (type == NULL || type == undefined) {
printdebug(
"passed a NULL reference/undefined reference to "
"CreateConstantStack. Invalid.");
return NULL;
}
Constant_Stack *cs = (Constant_Stack *)malloc(sizeof(Constant_Stack));
cs->theType = type;
cs->theValue = value;
cs->isConst = isConst;
if(head == NULL){
head = cs;
cs->next = NULL;
}else{
cs->next = head;
head = cs;
}
return cs;
}
Constant_Stack *Pop() {
if (head == NULL) {
printf("cannot pop from an empty stack. Invalid.\n");
return NULL;
}
Constant_Stack *cs = head;
head = head->next;
printf("Popped something of type %s\n", getName(cs->theType));
return cs;
}
Constant_Stack* Print_Stack(){
if (head == NULL) {
printdebug("cannot print an empty stack. Invalid.");
return NULL;
}
Constant_Stack *cs = head;
while (cs != NULL) {
if(cs->theValue == NULL){
printf("Type: %s, Value: NULL", getName(cs->theType));
}
if(cs->theType == stri){
printf("Type: %s, Value: %s\n", getName(cs->theType), *(char*)(cs->theValue));
}
if(cs->theType == integ){
printf("Type: %s, Value: %d\n", getName(cs->theType), (int *)(cs->theValue));
}
if(cs->theType == chara){
printf("Type: %s, Value: %c\n", getName(cs->theType), *(char *)cs->theValue);
}
if(cs->theType == boo){
if(*(bool *)cs->theValue == true){
printf("Type: %s, Value: true\n", getName(cs->theType));}
else{
printf("Type: %s, Value: false\n", getName(cs->theType));
}
}
cs = cs->next;
}
return cs;
}
// primitive additional info only stores the size of that type
AdInfo *CreatePrimitiveInfo(int size) {
AdInfo *info = (AdInfo *)malloc(sizeof(AdInfo));

10
src/symbol_table.h
View File

@ -11,6 +11,13 @@
struct TableNode;
typedef struct Constant_Stack {
struct TableNode *theType;
void *theValue;
struct Constant_Stack *next;
bool isConst;
} Constant_Stack;
typedef struct {
int size;
} primitive_info;
@ -141,7 +148,7 @@ extern int line_number;
extern int column_number;
extern FILE *yyin;
extern bool DEBUG;
extern int temp2_count;
extern TableNode *funprime;
extern TableNode *arrayprim;
extern TableNode *integ;
@ -152,6 +159,7 @@ extern TableNode *boo;
extern TableNode *recprime;
extern TableNode *funtypeprime;
extern TableNode *undefined;
extern Constant_Stack *head;
extern char *COLOR_RED;
extern char *COLOR_GREEN;

2
tests/sprint2/test/sp2_simple.alpha
View File

@ -3,5 +3,5 @@ function entry: main
entry(arg) := {
[integer : x]
return 0;
return 2;
}