glm94/assm-test
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Started reworking the Parser to simplify how instructions will be represented. It will act like a 'first pass' that will do grammar checks but not verify the parameters of the opcodes.

Browse Source
This commit is contained in:
glm94
2022-10-02 22:54:18 -05:00
parent 55f4c32764
commit f7cd87f13f
6 changed files with 449 additions and 340 deletions
Download Patch File Download Diff File Expand all files Collapse all files
includes/parser.h
+1 -24
View File
@@ -9,30 +9,7 @@
#include "opcodes.h" #include "opcodes.h"
#include "symbols_table.h" #include "symbols_table.h"
#define HIGHMEMORY 65535 //64KiB - 1 AKA 0xFFFF //#define HIGHMEMORY 65535 //64KiB - 1 AKA 0xFFFF
// typedef struct {
// Token* token;
// int length;
// int address;
// int resolved;
// } Symbol;
// typedef struct {
// Mnemonic Mnemonic;
// TokenClass ParameterOneType;
// TokenClass ParameterTwoType;
// union {
// uint16_t Constant;
// Symbol* Address;
// } ParameterOne;
// union {
// uint16_t Constant;
// Symbol* Address;
// } ParameterTwo;
// } IROpcode;
typedef struct { typedef struct {
List* Instructions; List* Instructions;
includes/symbols_table.h
+1 -1
View File
@@ -9,7 +9,7 @@
#define SYMBOLSTABLE_DEFAULT_CAPACITY 128 #define SYMBOLSTABLE_DEFAULT_CAPACITY 128
typedef enum { typedef enum {
Data, ValueAt,
Address Address
} SymbolType; } SymbolType;
src/main.c
+10 -4
View File
@@ -7,7 +7,6 @@
#include "../includes/parser.h" #include "../includes/parser.h"
#include "../includes/futil.h" #include "../includes/futil.h"
#include "../includes/scanner.h" #include "../includes/scanner.h"
#include "../includes/disass.h"
int main(int argc, char* args[]) { int main(int argc, char* args[]) {
if (argc == 1) { if (argc == 1) {
@@ -23,9 +22,16 @@ int main(int argc, char* args[]) {
List* list = GenerateTokenList(source_code); List* list = GenerateTokenList(source_code);
char mnemonic[12]; char mnemonic[12];
printf("PRINTING TOKENS\n");
for(int i = 0; i < list->size; i++) { for(int i = 0; i < list->size; i++) {
Token* t = (Token*) list->content[i]; Token* t = (Token*) list->content[i];
if (t->EndOfFile) {
printf("EOF\n");
break;
}
if (t->Class == PunctuationClass){ if (t->Class == PunctuationClass){
if(t->Value.Punctuation == NewLine) { if(t->Value.Punctuation == NewLine) {
if(i - 1 >= 0 && (((Token*)list->content[i - 1])->Class == PunctuationClass && ((Token*)list->content[i - 1])->Value.Punctuation == NewLine)) continue; if(i - 1 >= 0 && (((Token*)list->content[i - 1])->Class == PunctuationClass && ((Token*)list->content[i - 1])->Value.Punctuation == NewLine)) continue;
@@ -54,13 +60,13 @@ int main(int argc, char* args[]) {
} }
if (t->Class == NumberClass) { if (t->Class == NumberClass) {
printf("%d ", t->Value.Number); printf("[N]%d ", t->Value.Number);
continue; continue;
} }
if (t->Class == MnemonicClass) { if (t->Class == MnemonicClass) {
GetMnemonicText(t->Value.Mnemonic, mnemonic); GetMnemonicText(t->Value.Mnemonic, mnemonic);
printf("%s ", mnemonic); printf("[M]%s ", mnemonic);
continue; continue;
} }
@@ -74,7 +80,7 @@ int main(int argc, char* args[]) {
} }
} }
//IRState* image = ParseTokens(list); IRState* image = ParseTokens(list);
//Disassemble(image); //Disassemble(image);
//for(int i = 0; i < image->Opcodes->size; i++) { //for(int i = 0; i < image->Opcodes->size; i++) {
// printf("%d\n", ((IROpcode*) image->Opcodes->content[i])->Mnemonic); // printf("%d\n", ((IROpcode*) image->Opcodes->content[i])->Mnemonic);
src/opcodes.c
+2
View File
@@ -35,6 +35,8 @@ Instruction* CreateInstruction(Mnemonic mnemonic) {
} }
instruction->Mnemonic = mnemonic; instruction->Mnemonic = mnemonic;
instruction->ParameterOneType = NoParameter;
instruction->ParameterTwoType = NoParameter;
return instruction; return instruction;
} }
src/parser.c
+434 -310
View File
@@ -41,7 +41,8 @@ IRState* ParseTokens(List* tokens) {
switch(t->Class) { switch(t->Class) {
case DirectiveClass: case DirectiveClass:
HandleAssemblerDirective(); //HandleAssemblerDirective();
//while(!ParserAtEnd() && (PeekToken()->Class == PunctuationClass && PeekToken()->Value.Punctuation != NewLine)) AdvanceParser();
break; break;
case MnemonicClass: case MnemonicClass:
HandleOperation(); HandleOperation();
@@ -52,6 +53,8 @@ IRState* ParseTokens(List* tokens) {
//AddSymbol(t, 2, ProgramCounter, 1); //AddSymbol(t, 2, ProgramCounter, 1);
break; break;
default: default:
fprintf(stderr, "[Error] Line %d: Syntax error, expected start of expression, got '%c' [%d].\n", t->LineNumber, t->Value.Punctuation, t->Class);
//exit(1);
break; break;
} }
@@ -60,6 +63,16 @@ IRState* ParseTokens(List* tokens) {
if (MachineState.SymbolsTable->Size > 0) PrintSymbols(); if (MachineState.SymbolsTable->Size > 0) PrintSymbols();
for(int i = 0; i < MachineState.Instructions->size; i++) {
char mn[12];
Instruction* ins = MachineState.Instructions->content[i];
GetMnemonicText(ins->Mnemonic, mn);
printf("%s\n", mn);
}
//DestroyList(SymbolsTable); //DestroyList(SymbolsTable);
//memcpy(&Heap[HeapTop], Memory, ProgramCounter); //memcpy(&Heap[HeapTop], Memory, ProgramCounter);
@@ -80,352 +93,462 @@ IRState* ParseTokens(List* tokens) {
return &MachineState; return &MachineState;
} }
void HandleAssemblerDirective(void) {
if (PeekToken()->Value.Directive == DB) { OpcodeParameter GetParameterType(Token** sourceToken) {
AdvanceParser(); Token* token = PeekToken();
Token* identifier = PeekToken(); while(!ParserAtEnd()) {
if (token->EndOfFile || (token->Class == PunctuationClass && token->Value.Punctuation == NewLine)) break;
if (!Expect(1, IdentifierClass)) { if (token->Class == RegisterClass) {
fprintf(stderr, "Expected identifier on line %d\n", identifier->LineNumber); *sourceToken = token;
exit(1);
AdvanceParser();
return RegisterParameter;
} }
Symbol* symbol = AddSymbolToTable(identifier->Lemexe, NULL, strlen(identifier->Lemexe), MachineState.SymbolsTable); if (token->Class == PunctuationClass) {
if (token->Value.Punctuation == LBracket) {
AdvanceParser();
token = PeekToken();
identifier = PeekToken(); *sourceToken = token;
switch(identifier->Class) {
case CharacterClass:
//printf("[INFO] %s = '%s' (%#04X)\n", identifier->lexeme, identifier->lexeme, HeapTop);
// for(int i = 0; i < strlen(identifier->lexeme); i++) {
// //Memory[ProgramCounter + i] = PeekToken()->lexeme[i];
// Heap[HeapTop + i] = identifier->lexeme[i];
// }
//ProgramCounter += strlen(PeekToken()->lexeme);
//HeapTop += strlen(identifier->Lemexe);
symbol->Length = strlen(identifier->Lemexe);
AdvanceParser(); AdvanceParser();
if (PeekToken()->Class == PunctuationClass && PeekToken()->Value.Punctuation == Comma) { if (PeekToken()->Class == PunctuationClass && PeekToken()->Value.Punctuation != RBracket) {
AdvanceParser(); //error
fprintf(stderr, "[Error] Line %d Expected closing bracket.\n", token->LineNumber);
if (PeekToken()-> Class != NumberClass) { exit(1);
fprintf(stderr, "Expected string termination byte on line %d\n", PeekToken()->LineNumber);
exit(1);
}
else {
//Hideous...
// int oldLength = strlen(identifier->lexeme);
// identifier->lexeme = realloc(identifier->lexeme, oldLength + 2);
// identifier->value = identifier->lexeme;
// identifier->lexeme[oldLength + 1] = '\0';//*PeekToken()->lexeme & 0x0F;
symbol->Length++; //Basically, read in the NULL byte at the end of the string.
//HeapTop++;
return;
}
} }
case NumberClass: else AdvanceParser();
return AddressParameter;
}
else {
//error
fprintf(stderr, "[Error] Line: %d Expected opening bracket.\n", token->LineNumber);
exit(1);
}
}
if (token->Class == NumberClass) {
*sourceToken = token;
AdvanceParser();
return ConstantParameter;
}
if (token->Class & AddressClass) {
*sourceToken = token;
AdvanceParser();
return AddressParameter;
}
}
return NoParameter;
}
void HandleOperation() {
Token* token = PeekToken();
char mn[12];
Instruction* ins = CreateInstruction(token->Value.Mnemonic);
GetMnemonicText(ins->Mnemonic, mn);
AdvanceParser();
while(!ParserAtEnd()) {
if (PeekToken()->Class == PunctuationClass && PeekToken()->Value.Punctuation == NewLine) {
break;
}
ins->ParameterOneType = GetParameterType(&token);
if (ins->ParameterOneType == NoParameter) {
AdvanceParser(); //Comsume the line end
break;
}
if (PeekToken()->Class == PunctuationClass) {
if (PeekToken()->Value.Punctuation == NewLine) {
AdvanceParser(); //Comsume end line.
break; break;
default: }
fprintf(stderr, "[Line: %d] Expected either a number or string after identifier '%s'.\n", PeekToken()->LineNumber, identifier->Lemexe); else if (PeekToken()->Value.Punctuation != Comma) {
exit(1); fprintf(stderr, "[Error] Line %d: comma need for %s\n", token->LineNumber, mn);
exit(1);
}
} else {
fprintf(stderr, "[Error] Line %d: comma needed for %s\n", token->LineNumber, mn);
exit(1);
} }
AdvanceParser(); //Comsume the comma
ins->ParameterTwoType = GetParameterType(&token);
AdvanceParser();//comsume the end line.
break;
//AdvanceParser();
} }
AddListItem(ins, sizeof(Instruction), MachineState.Instructions);
free(ins);
} }
void HandleRegisterBasedOpcode(unsigned char mask) { // void HandleAssemblerDirective(void) {
//Memory[ProgramCounter] = mask;
//ProgramCounter++; // if (PeekToken()->Value.Directive == DB) {
// AdvanceParser();
Token* token = PeekToken(); // Token* identifier = PeekToken();
Instruction* opcode = CreateInstruction(token->Value.Mnemonic); //CreateIROpcode(token->Value.Mnemonic); // if (!Expect(1, IdentifierClass)) {
// fprintf(stderr, "Expected identifier on line %d\n", identifier->LineNumber);
// exit(1);
// }
AdvanceParser(); // Symbol* symbol = AddSymbolToTable(identifier->Lemexe, NULL, strlen(identifier->Lemexe), MachineState.SymbolsTable);
token = PeekToken(); // identifier = PeekToken();
if (token->Class == RegisterClass) { // switch(identifier->Class) {
//Memory[ProgramCounter - 1] |= (PeekToken()->type - R1) & 0x07; // case CharacterClass:
opcode->ParameterOneType = RegisterParameter; // //printf("[INFO] %s = '%s' (%#04X)\n", identifier->lexeme, identifier->lexeme, HeapTop);
AdvanceParser();
}
else if (token->Class & AddressClass && token->Value.Mnemonic == COPY) {
//opcode->ParameterOneType = Address;
Symbol* symbol = TryGetSymbol(token->Lemexe, MachineState.SymbolsTable); //GetSymbol(token->Lemexe); // // for(int i = 0; i < strlen(identifier->lexeme); i++) {
// // //Memory[ProgramCounter + i] = PeekToken()->lexeme[i];
// // Heap[HeapTop + i] = identifier->lexeme[i];
// // }
// //ProgramCounter += strlen(PeekToken()->lexeme);
// //HeapTop += strlen(identifier->Lemexe);
// symbol->Length = strlen(identifier->Lemexe);
// AdvanceParser();
// if (PeekToken()->Class == PunctuationClass && PeekToken()->Value.Punctuation == Comma) {
// AdvanceParser();
// if (PeekToken()-> Class != NumberClass) {
// fprintf(stderr, "Expected string termination byte on line %d\n", PeekToken()->LineNumber);
// exit(1);
// }
// else {
// //Hideous...
// // int oldLength = strlen(identifier->lexeme);
// // identifier->lexeme = realloc(identifier->lexeme, oldLength + 2);
// // identifier->value = identifier->lexeme;
// // identifier->lexeme[oldLength + 1] = '\0';//*PeekToken()->lexeme & 0x0F;
// symbol->Length++; //Basically, read in the NULL byte at the end of the string.
// //HeapTop++;
// return;
// }
// }
// case NumberClass:
// break;
// default:
// fprintf(stderr, "[Line: %d] Expected either a number or string after identifier '%s'.\n", PeekToken()->LineNumber, identifier->Lemexe);
// exit(1);
// }
// }
// }
// void HandleRegisterBasedOpcode(unsigned char mask) {
// //Memory[ProgramCounter] = mask;
// //ProgramCounter++;
// Token* token = PeekToken();
// Instruction* opcode = CreateInstruction(token->Value.Mnemonic); //CreateIROpcode(token->Value.Mnemonic);
// AdvanceParser();
// token = PeekToken();
// if (token->Class == RegisterClass) {
// //Memory[ProgramCounter - 1] |= (PeekToken()->type - R1) & 0x07;
// opcode->ParameterOneType = RegisterParameter;
// AdvanceParser();
// }
// else if (token->Class & AddressClass && token->Value.Mnemonic == COPY) {
// //opcode->ParameterOneType = Address;
// Symbol* symbol = TryGetSymbol(token->Lemexe, MachineState.SymbolsTable); //GetSymbol(token->Lemexe);
if (!symbol) { // if (!symbol) {
opcode->ParameterOneType = AddressParameter; // opcode->ParameterOneType = AddressParameter;
//AddSymbol(token, 2, 0, 0); // //AddSymbol(token, 2, 0, 0);
opcode->ParameterOne.Symbol = AddSymbolToTable(token->Lemexe, NULL, strlen(token->Lemexe), MachineState.SymbolsTable); // opcode->ParameterOne.Symbol = AddSymbolToTable(token->Lemexe, NULL, strlen(token->Lemexe), MachineState.SymbolsTable);
} // }
else opcode->ParameterOne.Address = symbol;//CreateSymbol(token, symbol->address, symbol->resolved); // else opcode->ParameterOne.Address = symbol;//CreateSymbol(token, symbol->address, symbol->resolved);
} // }
else { // else {
fprintf(stderr, "[Error] Line %d: Expected register operand.\n", token->LineNumber); // fprintf(stderr, "[Error] Line %d: Expected register operand.\n", token->LineNumber);
exit(1); // exit(1);
} // }
token = PeekToken(); // token = PeekToken();
if (!Expect(1, Comma)) { // if (!Expect(1, Comma)) {
fprintf(stderr, "[Error] Expected comma on line %d.\n", token->LineNumber); // fprintf(stderr, "[Error] Expected comma on line %d.\n", token->LineNumber);
exit(1); // exit(1);
} // }
token = PeekToken(); // token = PeekToken();
if (token->Class & AddressClass) { // if (token->Class & AddressClass) {
opcode->ParameterTwoType = IdentifierClass; // opcode->ParameterTwoType = IdentifierClass;
Symbol* symbol = GetSymbol(token->Lemexe); // Symbol* symbol = GetSymbol(token->Lemexe);
// if (!symbol) { // // if (!symbol) {
// fprintf(stderr, "[Error] Line %d: %s is undefined.\n", token->line, token->lexeme); // // fprintf(stderr, "[Error] Line %d: %s is undefined.\n", token->line, token->lexeme);
// exit(1); // // exit(1);
// } // // }
if (!symbol) opcode->ParameterOne.Address = AddSymbol(token, 2, 0, 0);//CreateSymbol(token, 0, 0); // if (!symbol) opcode->ParameterOne.Address = AddSymbol(token, 2, 0, 0);//CreateSymbol(token, 0, 0);
else opcode->ParameterOne.Address = symbol;//CreateSymbol(token, symbol->address, symbol->resolved); // else opcode->ParameterOne.Address = symbol;//CreateSymbol(token, symbol->address, symbol->resolved);
// Memory[ProgramCounter - 1] |= 0x10;//0b00010000; // // Memory[ProgramCounter - 1] |= 0x10;//0b00010000;
// Memory[ProgramCounter] = 2 >> symbol->address & 0xFF; // // Memory[ProgramCounter] = 2 >> symbol->address & 0xFF;
// Memory[ProgramCounter + 1] = symbol->address & 0xFF; // // Memory[ProgramCounter + 1] = symbol->address & 0xFF;
AdvanceParser(); // AdvanceParser();
} // }
else if (token->Class == NumberClass) { // else if (token->Class == NumberClass) {
//opcode->ParameterTwoType = ; // //opcode->ParameterTwoType = ;
opcode->ParameterTwo.Constant = PeekToken()->Value.Number; // opcode->ParameterTwo.Constant = PeekToken()->Value.Number;
// Memory[ProgramCounter - 1] |= 0x08; //0b00001000; // // Memory[ProgramCounter - 1] |= 0x08; //0b00001000;
// int* value = PeekToken()->value; // // int* value = PeekToken()->value;
// Memory[ProgramCounter] = 2 >> *value & 0xFF; // // Memory[ProgramCounter] = 2 >> *value & 0xFF;
// Memory[ProgramCounter + 1] = *value & 0xFF; // // Memory[ProgramCounter + 1] = *value & 0xFF;
AdvanceParser(); // AdvanceParser();
} // }
else if (token->Class == RegisterClass) { // else if (token->Class == RegisterClass) {
//opcode->ParameterTwoType = ; // //opcode->ParameterTwoType = ;
opcode->ParameterTwo.Constant = PeekToken()->Value.Register &0x07; // opcode->ParameterTwo.Constant = PeekToken()->Value.Register &0x07;
//Memory[ProgramCounter] = (PeekToken()->type - R1) & 0x07; // //Memory[ProgramCounter] = (PeekToken()->type - R1) & 0x07;
AdvanceParser(); // AdvanceParser();
ProgramCounter++; // ProgramCounter++;
return; // return;
} // }
else { // else {
fprintf(stderr, "[Error] Expected operand, got %s\n", token->Lemexe); // fprintf(stderr, "[Error] Expected operand, got %s\n", token->Lemexe);
exit(1); // exit(1);
} // }
ProgramCounter += 2; // ProgramCounter += 2;
AddListItem(opcode, sizeof(IROpcode), MachineState.Opcodes); // AddListItem(opcode, sizeof(IROpcode), MachineState.Opcodes);
} // }
void HandleOperation(void) { // void HandleOperation(void) {
Token* token = PeekToken(); // Token* token = PeekToken();
//const Instruction* inst = GetOpcodeDetails(opcode->type); // //const Instruction* inst = GetOpcodeDetails(opcode->type);
const unsigned char registerBasedOpcodeMask = 0xE0; // const unsigned char registerBasedOpcodeMask = 0xE0;
//if (!inst) return; // //if (!inst) return;
// AdvanceParser(); // // AdvanceParser();
unsigned char mask = GetInstructionMask(token->Value.Mnemonic); // unsigned char mask = GetInstructionMask(token->Value.Mnemonic);
if (mask & registerBasedOpcodeMask) { // if (mask & registerBasedOpcodeMask) {
HandleRegisterBasedOpcode(mask); // HandleRegisterBasedOpcode(mask);
return; // return;
} // }
IROpcode* opcode = CreateIROpcode(token->Value.Mnemonic); // IROpcode* opcode = CreateIROpcode(token->Value.Mnemonic);
//opcode->ParameterTwoType = None; // //opcode->ParameterTwoType = None;
AdvanceParser(); // AdvanceParser();
switch (mask) { // switch (mask) {
case 0: //NOP // case 0: //NOP
//Memory[ProgramCounter] = 0x00; // //Memory[ProgramCounter] = 0x00;
//opcode->ParameterOneType = None; // //opcode->ParameterOneType = None;
ProgramCounter++; // ProgramCounter++;
return; // return;
case 1: //JZ // case 1: //JZ
//Memory[ProgramCounter] = 0x01; // //Memory[ProgramCounter] = 0x01;
ProgramCounter++; // ProgramCounter++;
if (PeekToken()->Class == IdentifierClass || PeekToken()->Class == LabelClass) { // if (PeekToken()->Class == IdentifierClass || PeekToken()->Class == LabelClass) {
Symbol* symbol = GetSymbol(PeekToken()->Lemexe); // Symbol* symbol = GetSymbol(PeekToken()->Lemexe);
//opcode->ParameterOneType = Address; // //opcode->ParameterOneType = Address;
if (!symbol) opcode->ParameterOne.Address = AddSymbol(PeekToken(), 2, 0, 0); // if (!symbol) opcode->ParameterOne.Address = AddSymbol(PeekToken(), 2, 0, 0);
else opcode->ParameterOne.Address = symbol; // else opcode->ParameterOne.Address = symbol;
// if (!symbol) { // // if (!symbol) {
// fprintf(stderr, "[Error] %s is undefined.\n", PeekToken()->lexeme); // // fprintf(stderr, "[Error] %s is undefined.\n", PeekToken()->lexeme);
// exit(1); // // exit(1);
// } // // }
// Memory[ProgramCounter] = 2 >> symbol->address & 0xFF; // // Memory[ProgramCounter] = 2 >> symbol->address & 0xFF;
// Memory[ProgramCounter + 1] = symbol->address & 0xFF; // // Memory[ProgramCounter + 1] = symbol->address & 0xFF;
} // }
else if (PeekToken()->Class == NumberClass) { // else if (PeekToken()->Class == NumberClass) {
//opcode->ParameterOneType = Constant; // //opcode->ParameterOneType = Constant;
opcode->ParameterOne.Constant = PeekToken()->Value.Number; // opcode->ParameterOne.Constant = PeekToken()->Value.Number;
// int* value = PeekToken()->value; // // int* value = PeekToken()->value;
// Memory[ProgramCounter] = 2 >> *value & 0xFF; // // Memory[ProgramCounter] = 2 >> *value & 0xFF;
// Memory[ProgramCounter + 1] = *value & 0xFF; // // Memory[ProgramCounter + 1] = *value & 0xFF;
} // }
else { // else {
fprintf(stderr, "[Error] Line: %d: Expected address after jump if zero (JZ) instruction.\n", ((Token*) TokensList->content[CurrentToken - 1])->LineNumber); // fprintf(stderr, "[Error] Line: %d: Expected address after jump if zero (JZ) instruction.\n", ((Token*) TokensList->content[CurrentToken - 1])->LineNumber);
exit(1); // exit(1);
} // }
ProgramCounter += 2; // ProgramCounter += 2;
return; // return;
case 2: //INT // case 2: //INT
//Memory[ProgramCounter] = 0x02; // //Memory[ProgramCounter] = 0x02;
ProgramCounter++; // ProgramCounter++;
if (PeekToken()->Class == NumberClass) { // if (PeekToken()->Class == NumberClass) {
// int* value = PeekToken()->value; // // int* value = PeekToken()->value;
//opcode->ParameterOneType = ; // //opcode->ParameterOneType = ;
opcode->ParameterOne.Constant = PeekToken()->Value.Number; // opcode->ParameterOne.Constant = PeekToken()->Value.Number;
// Memory[ProgramCounter] = 2 >> *value & 0xFF; // // Memory[ProgramCounter] = 2 >> *value & 0xFF;
// Memory[ProgramCounter + 1] = *value & 0xFF; // // Memory[ProgramCounter + 1] = *value & 0xFF;
} // }
else { // else {
fprintf(stderr, "[Error] Line %d: Expected Interrupt vector.\n", PeekToken()->LineNumber); // fprintf(stderr, "[Error] Line %d: Expected Interrupt vector.\n", PeekToken()->LineNumber);
exit(1); // exit(1);
} // }
ProgramCounter += 2; // ProgramCounter += 2;
return; // return;
case 3: //YLD // case 3: //YLD
//Memory[ProgramCounter] = 0x03; // //Memory[ProgramCounter] = 0x03;
//opcode->ParameterOneType = ; // //opcode->ParameterOneType = ;
ProgramCounter++; // ProgramCounter++;
break; // break;
case 4: //RET // case 4: //RET
//Memory[ProgramCounter] = 0x04; // //Memory[ProgramCounter] = 0x04;
//opcode->ParameterOneType = ; // //opcode->ParameterOneType = ;
ProgramCounter++; // ProgramCounter++;
break; // break;
case 5: //CALL // case 5: //CALL
//Memory[ProgramCounter] = 0x05; // //Memory[ProgramCounter] = 0x05;
ProgramCounter++; // ProgramCounter++;
if (PeekToken()->Class == IdentifierClass || PeekToken()->Class == LabelClass) { // if (PeekToken()->Class == IdentifierClass || PeekToken()->Class == LabelClass) {
Symbol* symbol = GetSymbol(PeekToken()->Lemexe); // Symbol* symbol = GetSymbol(PeekToken()->Lemexe);
//opcode->ParameterOneType = ; // //opcode->ParameterOneType = ;
// if (!symbol) { // // if (!symbol) {
// fprintf(stderr, "[Error] Line %d: %s is undefined.\n", PeekToken()->line, PeekToken()->lexeme); // // fprintf(stderr, "[Error] Line %d: %s is undefined.\n", PeekToken()->line, PeekToken()->lexeme);
// exit(1); // // exit(1);
// } // // }
if (!symbol) opcode->ParameterOne.Address = AddSymbol(PeekToken(), 2, 0, 0); // if (!symbol) opcode->ParameterOne.Address = AddSymbol(PeekToken(), 2, 0, 0);
else opcode->ParameterOne.Address = symbol; // else opcode->ParameterOne.Address = symbol;
//Memory[ProgramCounter] = 2 >> symbol->address & 0xFF; // //Memory[ProgramCounter] = 2 >> symbol->address & 0xFF;
//Memory[ProgramCounter + 1] = symbol->address & 0xFF; // //Memory[ProgramCounter + 1] = symbol->address & 0xFF;
} // }
else { // else {
fprintf(stderr, "[Error] Line %d: Expected address or label.\n", PeekToken()->LineNumber); // fprintf(stderr, "[Error] Line %d: Expected address or label.\n", PeekToken()->LineNumber);
exit(1); // exit(1);
} // }
ProgramCounter += 2; // ProgramCounter += 2;
break; // break;
case 6: //JMP // case 6: //JMP
//Memory[ProgramCounter] = 0x06; // //Memory[ProgramCounter] = 0x06;
ProgramCounter++; // ProgramCounter++;
if (PeekToken()->Class == IdentifierClass || PeekToken()->Class == LabelClass) { // if (PeekToken()->Class == IdentifierClass || PeekToken()->Class == LabelClass) {
Symbol* symbol = GetSymbol(PeekToken()->Lemexe); // Symbol* symbol = GetSymbol(PeekToken()->Lemexe);
//opcode->ParameterOneType = Address; // //opcode->ParameterOneType = Address;
// if (!symbol) { // // if (!symbol) {
// fprintf(stderr, "[Error] Line %d: %s is undefined.\n", PeekToken()->line, PeekToken()->lexeme); // // fprintf(stderr, "[Error] Line %d: %s is undefined.\n", PeekToken()->line, PeekToken()->lexeme);
// exit(1); // // exit(1);
// } // // }
if (!symbol) opcode->ParameterOne.Address = AddSymbol(PeekToken(), 2, 0, 0); // if (!symbol) opcode->ParameterOne.Address = AddSymbol(PeekToken(), 2, 0, 0);
else opcode->ParameterOne.Address = symbol; // else opcode->ParameterOne.Address = symbol;
// Memory[ProgramCounter] = 2 >> symbol->address & 0xFF; // // Memory[ProgramCounter] = 2 >> symbol->address & 0xFF;
// Memory[ProgramCounter + 1] = symbol->address & 0xFF; // // Memory[ProgramCounter + 1] = symbol->address & 0xFF;
} // }
else { // else {
fprintf(stderr, "[Error] Line %d: Expected address or label.\n", PeekToken()->LineNumber); // fprintf(stderr, "[Error] Line %d: Expected address or label.\n", PeekToken()->LineNumber);
exit(1); // exit(1);
} // }
ProgramCounter += 2; // ProgramCounter += 2;
break; // break;
case 7: //IN // case 7: //IN
//Memory[ProgramCounter] = 0x07; // //Memory[ProgramCounter] = 0x07;
ProgramCounter++; // ProgramCounter++;
if (PeekToken()->Class == NumberClass) { // if (PeekToken()->Class == NumberClass) {
//opcode->ParameterOneType = ; // //opcode->ParameterOneType = ;
opcode->ParameterOne.Constant = PeekToken()->Value.Number; // opcode->ParameterOne.Constant = PeekToken()->Value.Number;
// int* value = PeekToken()->value; // // int* value = PeekToken()->value;
// Memory[ProgramCounter] = 2 >> *value & 0xFF; // // Memory[ProgramCounter] = 2 >> *value & 0xFF;
// Memory[ProgramCounter + 1] = *value & 0xFF; // // Memory[ProgramCounter + 1] = *value & 0xFF;
} // }
else { // else {
fprintf(stderr, "[Error] Line %d: Expected port number.\n", PeekToken()->LineNumber); // fprintf(stderr, "[Error] Line %d: Expected port number.\n", PeekToken()->LineNumber);
exit(1); // exit(1);
} // }
ProgramCounter += 2; // ProgramCounter += 2;
break; // break;
case 8: //OUT // case 8: //OUT
//Memory[ProgramCounter] = 0x08; // //Memory[ProgramCounter] = 0x08;
ProgramCounter++; // ProgramCounter++;
if (PeekToken()->Class == NumberClass) { // if (PeekToken()->Class == NumberClass) {
//opcode->ParameterOneType = ; // //opcode->ParameterOneType = ;
opcode->ParameterOne.Constant = PeekToken()->Value.Number; // opcode->ParameterOne.Constant = PeekToken()->Value.Number;
// int* value = PeekToken()->value; // // int* value = PeekToken()->value;
// Memory[ProgramCounter] = 2 >> *value & 0xFF; // // Memory[ProgramCounter] = 2 >> *value & 0xFF;
// Memory[ProgramCounter + 1] = *value & 0xFF; // // Memory[ProgramCounter + 1] = *value & 0xFF;
} // }
else { // else {
fprintf(stderr, "[Error] Line %d: Expected port number.\n", PeekToken()->LineNumber); // fprintf(stderr, "[Error] Line %d: Expected port number.\n", PeekToken()->LineNumber);
exit(1); // exit(1);
} // }
ProgramCounter += 2; // ProgramCounter += 2;
break; // break;
} // }
AddListItem(opcode, sizeof(IROpcode), MachineState.Opcodes); // AddListItem(opcode, sizeof(IROpcode), MachineState.Opcodes);
return; // return;
} // }
int Expect(int count, ...) { int Expect(int count, ...) {
va_list list; va_list list;
@@ -448,70 +571,71 @@ int Expect(int count, ...) {
void PrintSymbols(void) { void PrintSymbols(void) {
printf("-----SYMBOLS-----\n"); printf("-----SYMBOLS-----\n");
for(int i = 0; i < MachineState.SymbolsTable->size; i++) { for(int i = 0; i < MachineState.SymbolsTable->Size; i++) {
Symbol* symbol = MachineState.SymbolsTable->content[i]; Symbol* symbol = MachineState.SymbolsTable->Symbols[i];
printf("[%#06X] %s\n", symbol->address, symbol->token->Lemexe);
printf("[Resolved? %d] %s\n", symbol->Resolved, symbol->Name);//symbol->address, symbol->token->Lemexe);
} }
printf("-----SYMBOLS-----\n"); printf("-----SYMBOLS-----\n");
} }
Symbol* AddSymbol(Token* token, int length, int address, int resolved) { // Symbol* AddSymbol(Token* token, int length, int address, int resolved) {
if (!token) return NULL; // if (!token) return NULL;
if (token->Class != IdentifierClass && token->Class != LabelClass) return NULL; // if (token->Class != IdentifierClass && token->Class != LabelClass) return NULL;
for(int i = 0; i < MachineState.SymbolsTable->size; i++) { // for(int i = 0; i < MachineState.SymbolsTable->size; i++) {
Symbol* s = MachineState.SymbolsTable->content[i]; // Symbol* s = MachineState.SymbolsTable->content[i];
if (strcmp(s->token->Lemexe, token->Lemexe) == 0) { // if (strcmp(s->token->Lemexe, token->Lemexe) == 0) {
if (s->resolved) { // if (s->resolved) {
fprintf(stderr, "[Error] Line %d: Attempted to redeclare %s.\n", token->LineNumber, token->Lemexe); // fprintf(stderr, "[Error] Line %d: Attempted to redeclare %s.\n", token->LineNumber, token->Lemexe);
exit(1); // exit(1);
} // }
s->resolved = resolved; // s->resolved = resolved;
s->address = address; // s->address = address;
s->length = length; // s->length = length;
return s; // return s;
} // }
} // }
Symbol* symbol = CreateSymbol(token, length, address, resolved); // Symbol* symbol = CreateSymbol(token, length, address, resolved);
AddListItem(symbol, sizeof(Symbol), MachineState.SymbolsTable); // AddListItem(symbol, sizeof(Symbol), MachineState.SymbolsTable);
return symbol; // return symbol;
} // }
Symbol* GetSymbol(char* name) { // Symbol* GetSymbol(char* name) {
if (!name) return NULL; // if (!name) return NULL;
for(int i = 0; i < MachineState.SymbolsTable->size; i++) { // for(int i = 0; i < MachineState.SymbolsTable->size; i++) {
Symbol* s = MachineState.SymbolsTable->content[i]; // Symbol* s = MachineState.SymbolsTable->content[i];
if (strcmp(s->token->Lemexe, name) == 0) return s; // if (strcmp(s->token->Lemexe, name) == 0) return s;
} // }
return NULL; // return NULL;
} // }
Symbol* CreateSymbol(Token* token, int length, int address, int resolved) { // Symbol* CreateSymbol(Token* token, int length, int address, int resolved) {
Symbol* symbol = calloc(1, sizeof(Symbol)); // Symbol* symbol = calloc(1, sizeof(Symbol));
if (!symbol) return NULL; // if (!symbol) return NULL;
symbol->token = token; // symbol->token = token;
symbol->address = address; // symbol->address = address;
symbol->resolved = resolved; // symbol->resolved = resolved;
return symbol; // return symbol;
} // }
IROpcode* CreateIROpcode(Mnemonic mnemonic) { // IROpcode* CreateIROpcode(Mnemonic mnemonic) {
IROpcode* opcode = calloc(1, sizeof(IROpcode)); // IROpcode* opcode = calloc(1, sizeof(IROpcode));
opcode->Mnemonic = mnemonic; // opcode->Mnemonic = mnemonic;
return opcode; // return opcode;
} // }
void AdvanceParser(void) { void AdvanceParser(void) {
if (ParserAtEnd()) return; if (ParserAtEnd()) return;
src/symbols_table.c
+1 -1
View File
@@ -36,7 +36,7 @@ Symbol* CreateSymbol(char* name, void* value, int length) {
symbol->Length = length; symbol->Length = length;
symbol->Name = name; symbol->Name = name;
symbol->Value = value; //symbol->Value = value;
return symbol; return symbol;
} }