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 "symbols_table.h"
#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;
//#define HIGHMEMORY 65535 //64KiB - 1 AKA 0xFFFF
typedef struct {
List* Instructions;
includes/symbols_table.h
+1 -1
View File
@@ -9,7 +9,7 @@
#define SYMBOLSTABLE_DEFAULT_CAPACITY 128
typedef enum {
Data,
ValueAt,
Address
} SymbolType;
src/main.c
+10 -4
View File
@@ -7,7 +7,6 @@
#include "../includes/parser.h"
#include "../includes/futil.h"
#include "../includes/scanner.h"
#include "../includes/disass.h"
int main(int argc, char* args[]) {
if (argc == 1) {
@@ -23,9 +22,16 @@ int main(int argc, char* args[]) {
List* list = GenerateTokenList(source_code);
char mnemonic[12];
printf("PRINTING TOKENS\n");
for(int i = 0; i < list->size; i++) {
Token* t = (Token*) list->content[i];
if (t->EndOfFile) {
printf("EOF\n");
break;
}
if (t->Class == PunctuationClass){
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;
@@ -54,13 +60,13 @@ int main(int argc, char* args[]) {
}
if (t->Class == NumberClass) {
printf("%d ", t->Value.Number);
printf("[N]%d ", t->Value.Number);
continue;
}
if (t->Class == MnemonicClass) {
GetMnemonicText(t->Value.Mnemonic, mnemonic);
printf("%s ", mnemonic);
printf("[M]%s ", mnemonic);
continue;
}
@@ -74,7 +80,7 @@ int main(int argc, char* args[]) {
}
}
//IRState* image = ParseTokens(list);
IRState* image = ParseTokens(list);
//Disassemble(image);
//for(int i = 0; i < image->Opcodes->size; i++) {
// 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->ParameterOneType = NoParameter;
instruction->ParameterTwoType = NoParameter;
return instruction;
}
src/parser.c
+434 -310
View File
@@ -41,7 +41,8 @@ IRState* ParseTokens(List* tokens) {
switch(t->Class) {
case DirectiveClass:
HandleAssemblerDirective();
//HandleAssemblerDirective();
//while(!ParserAtEnd() && (PeekToken()->Class == PunctuationClass && PeekToken()->Value.Punctuation != NewLine)) AdvanceParser();
break;
case MnemonicClass:
HandleOperation();
@@ -52,6 +53,8 @@ IRState* ParseTokens(List* tokens) {
//AddSymbol(t, 2, ProgramCounter, 1);
break;
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;
}
@@ -60,6 +63,16 @@ IRState* ParseTokens(List* tokens) {
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);
//memcpy(&Heap[HeapTop], Memory, ProgramCounter);
@@ -80,352 +93,462 @@ IRState* ParseTokens(List* tokens) {
return &MachineState;
}
void HandleAssemblerDirective(void) {
if (PeekToken()->Value.Directive == DB) {
AdvanceParser();
OpcodeParameter GetParameterType(Token** sourceToken) {
Token* token = PeekToken();
Token* identifier = PeekToken();
while(!ParserAtEnd()) {
if (token->EndOfFile || (token->Class == PunctuationClass && token->Value.Punctuation == NewLine)) break;
if (!Expect(1, IdentifierClass)) {
fprintf(stderr, "Expected identifier on line %d\n", identifier->LineNumber);
exit(1);
if (token->Class == RegisterClass) {
*sourceToken = token;
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();
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);
*sourceToken = token;
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;
}
if (PeekToken()->Class == PunctuationClass && PeekToken()->Value.Punctuation != RBracket) {
//error
fprintf(stderr, "[Error] Line %d Expected closing bracket.\n", token->LineNumber);
exit(1);
}
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;
default:
fprintf(stderr, "[Line: %d] Expected either a number or string after identifier '%s'.\n", PeekToken()->LineNumber, identifier->Lemexe);
exit(1);
}
else if (PeekToken()->Value.Punctuation != Comma) {
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) {
//Memory[ProgramCounter] = mask;
// void HandleAssemblerDirective(void) {
//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) {
//Memory[ProgramCounter - 1] |= (PeekToken()->type - R1) & 0x07;
opcode->ParameterOneType = RegisterParameter;
AdvanceParser();
}
else if (token->Class & AddressClass && token->Value.Mnemonic == COPY) {
//opcode->ParameterOneType = Address;
// switch(identifier->Class) {
// case CharacterClass:
// //printf("[INFO] %s = '%s' (%#04X)\n", identifier->lexeme, identifier->lexeme, HeapTop);
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) {
opcode->ParameterOneType = AddressParameter;
//AddSymbol(token, 2, 0, 0);
opcode->ParameterOne.Symbol = AddSymbolToTable(token->Lemexe, NULL, strlen(token->Lemexe), MachineState.SymbolsTable);
}
else opcode->ParameterOne.Address = symbol;//CreateSymbol(token, symbol->address, symbol->resolved);
}
else {
fprintf(stderr, "[Error] Line %d: Expected register operand.\n", token->LineNumber);
exit(1);
}
// if (!symbol) {
// opcode->ParameterOneType = AddressParameter;
// //AddSymbol(token, 2, 0, 0);
// opcode->ParameterOne.Symbol = AddSymbolToTable(token->Lemexe, NULL, strlen(token->Lemexe), MachineState.SymbolsTable);
// }
// else opcode->ParameterOne.Address = symbol;//CreateSymbol(token, symbol->address, symbol->resolved);
// }
// else {
// fprintf(stderr, "[Error] Line %d: Expected register operand.\n", token->LineNumber);
// exit(1);
// }
token = PeekToken();
// token = PeekToken();
if (!Expect(1, Comma)) {
fprintf(stderr, "[Error] Expected comma on line %d.\n", token->LineNumber);
exit(1);
}
// if (!Expect(1, Comma)) {
// fprintf(stderr, "[Error] Expected comma on line %d.\n", token->LineNumber);
// exit(1);
// }
token = PeekToken();
// token = PeekToken();
if (token->Class & AddressClass) {
opcode->ParameterTwoType = IdentifierClass;
Symbol* symbol = GetSymbol(token->Lemexe);
// if (token->Class & AddressClass) {
// opcode->ParameterTwoType = IdentifierClass;
// Symbol* symbol = GetSymbol(token->Lemexe);
// if (!symbol) {
// fprintf(stderr, "[Error] Line %d: %s is undefined.\n", token->line, token->lexeme);
// exit(1);
// }
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);
// // if (!symbol) {
// // fprintf(stderr, "[Error] Line %d: %s is undefined.\n", token->line, token->lexeme);
// // exit(1);
// // }
// 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);
// Memory[ProgramCounter - 1] |= 0x10;//0b00010000;
// // Memory[ProgramCounter - 1] |= 0x10;//0b00010000;
// Memory[ProgramCounter] = 2 >> symbol->address & 0xFF;
// Memory[ProgramCounter + 1] = symbol->address & 0xFF;
// // Memory[ProgramCounter] = 2 >> symbol->address & 0xFF;
// // Memory[ProgramCounter + 1] = symbol->address & 0xFF;
AdvanceParser();
}
else if (token->Class == NumberClass) {
//opcode->ParameterTwoType = ;
// AdvanceParser();
// }
// else if (token->Class == NumberClass) {
// //opcode->ParameterTwoType = ;
opcode->ParameterTwo.Constant = PeekToken()->Value.Number;
// Memory[ProgramCounter - 1] |= 0x08; //0b00001000;
// opcode->ParameterTwo.Constant = PeekToken()->Value.Number;
// // Memory[ProgramCounter - 1] |= 0x08; //0b00001000;
// int* value = PeekToken()->value;
// // int* value = PeekToken()->value;
// Memory[ProgramCounter] = 2 >> *value & 0xFF;
// Memory[ProgramCounter + 1] = *value & 0xFF;
// // Memory[ProgramCounter] = 2 >> *value & 0xFF;
// // Memory[ProgramCounter + 1] = *value & 0xFF;
AdvanceParser();
}
else if (token->Class == RegisterClass) {
//opcode->ParameterTwoType = ;
opcode->ParameterTwo.Constant = PeekToken()->Value.Register &0x07;
//Memory[ProgramCounter] = (PeekToken()->type - R1) & 0x07;
// AdvanceParser();
// }
// else if (token->Class == RegisterClass) {
// //opcode->ParameterTwoType = ;
// opcode->ParameterTwo.Constant = PeekToken()->Value.Register &0x07;
// //Memory[ProgramCounter] = (PeekToken()->type - R1) & 0x07;
AdvanceParser();
// AdvanceParser();
ProgramCounter++;
return;
}
else {
fprintf(stderr, "[Error] Expected operand, got %s\n", token->Lemexe);
exit(1);
}
// ProgramCounter++;
// return;
// }
// else {
// fprintf(stderr, "[Error] Expected operand, got %s\n", token->Lemexe);
// exit(1);
// }
ProgramCounter += 2;
// ProgramCounter += 2;
AddListItem(opcode, sizeof(IROpcode), MachineState.Opcodes);
}
// AddListItem(opcode, sizeof(IROpcode), MachineState.Opcodes);
// }
void HandleOperation(void) {
Token* token = PeekToken();
//const Instruction* inst = GetOpcodeDetails(opcode->type);
const unsigned char registerBasedOpcodeMask = 0xE0;
// void HandleOperation(void) {
// Token* token = PeekToken();
// //const Instruction* inst = GetOpcodeDetails(opcode->type);
// 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) {
HandleRegisterBasedOpcode(mask);
return;
}
// if (mask & registerBasedOpcodeMask) {
// HandleRegisterBasedOpcode(mask);
// return;
// }
IROpcode* opcode = CreateIROpcode(token->Value.Mnemonic);
//opcode->ParameterTwoType = None;
// IROpcode* opcode = CreateIROpcode(token->Value.Mnemonic);
// //opcode->ParameterTwoType = None;
AdvanceParser();
// AdvanceParser();
switch (mask) {
case 0: //NOP
//Memory[ProgramCounter] = 0x00;
//opcode->ParameterOneType = None;
// switch (mask) {
// case 0: //NOP
// //Memory[ProgramCounter] = 0x00;
// //opcode->ParameterOneType = None;
ProgramCounter++;
return;
case 1: //JZ
//Memory[ProgramCounter] = 0x01;
// ProgramCounter++;
// return;
// case 1: //JZ
// //Memory[ProgramCounter] = 0x01;
ProgramCounter++;
// ProgramCounter++;
if (PeekToken()->Class == IdentifierClass || PeekToken()->Class == LabelClass) {
Symbol* symbol = GetSymbol(PeekToken()->Lemexe);
//opcode->ParameterOneType = Address;
// if (PeekToken()->Class == IdentifierClass || PeekToken()->Class == LabelClass) {
// Symbol* symbol = GetSymbol(PeekToken()->Lemexe);
// //opcode->ParameterOneType = Address;
if (!symbol) opcode->ParameterOne.Address = AddSymbol(PeekToken(), 2, 0, 0);
else opcode->ParameterOne.Address = symbol;
// if (!symbol) {
// fprintf(stderr, "[Error] %s is undefined.\n", PeekToken()->lexeme);
// exit(1);
// }
// if (!symbol) opcode->ParameterOne.Address = AddSymbol(PeekToken(), 2, 0, 0);
// else opcode->ParameterOne.Address = symbol;
// // if (!symbol) {
// // fprintf(stderr, "[Error] %s is undefined.\n", PeekToken()->lexeme);
// // exit(1);
// // }
// Memory[ProgramCounter] = 2 >> symbol->address & 0xFF;
// Memory[ProgramCounter + 1] = symbol->address & 0xFF;
}
else if (PeekToken()->Class == NumberClass) {
//opcode->ParameterOneType = Constant;
opcode->ParameterOne.Constant = PeekToken()->Value.Number;
// int* value = PeekToken()->value;
// // Memory[ProgramCounter] = 2 >> symbol->address & 0xFF;
// // Memory[ProgramCounter + 1] = symbol->address & 0xFF;
// }
// else if (PeekToken()->Class == NumberClass) {
// //opcode->ParameterOneType = Constant;
// opcode->ParameterOne.Constant = PeekToken()->Value.Number;
// // int* value = PeekToken()->value;
// Memory[ProgramCounter] = 2 >> *value & 0xFF;
// Memory[ProgramCounter + 1] = *value & 0xFF;
}
else {
fprintf(stderr, "[Error] Line: %d: Expected address after jump if zero (JZ) instruction.\n", ((Token*) TokensList->content[CurrentToken - 1])->LineNumber);
exit(1);
}
// // Memory[ProgramCounter] = 2 >> *value & 0xFF;
// // Memory[ProgramCounter + 1] = *value & 0xFF;
// }
// else {
// fprintf(stderr, "[Error] Line: %d: Expected address after jump if zero (JZ) instruction.\n", ((Token*) TokensList->content[CurrentToken - 1])->LineNumber);
// exit(1);
// }
ProgramCounter += 2;
// ProgramCounter += 2;
return;
case 2: //INT
//Memory[ProgramCounter] = 0x02;
// return;
// case 2: //INT
// //Memory[ProgramCounter] = 0x02;
ProgramCounter++;
// ProgramCounter++;
if (PeekToken()->Class == NumberClass) {
// int* value = PeekToken()->value;
//opcode->ParameterOneType = ;
opcode->ParameterOne.Constant = PeekToken()->Value.Number;
// if (PeekToken()->Class == NumberClass) {
// // int* value = PeekToken()->value;
// //opcode->ParameterOneType = ;
// opcode->ParameterOne.Constant = PeekToken()->Value.Number;
// Memory[ProgramCounter] = 2 >> *value & 0xFF;
// Memory[ProgramCounter + 1] = *value & 0xFF;
}
else {
fprintf(stderr, "[Error] Line %d: Expected Interrupt vector.\n", PeekToken()->LineNumber);
exit(1);
}
// // Memory[ProgramCounter] = 2 >> *value & 0xFF;
// // Memory[ProgramCounter + 1] = *value & 0xFF;
// }
// else {
// fprintf(stderr, "[Error] Line %d: Expected Interrupt vector.\n", PeekToken()->LineNumber);
// exit(1);
// }
ProgramCounter += 2;
// ProgramCounter += 2;
return;
case 3: //YLD
//Memory[ProgramCounter] = 0x03;
//opcode->ParameterOneType = ;
// return;
// case 3: //YLD
// //Memory[ProgramCounter] = 0x03;
// //opcode->ParameterOneType = ;
ProgramCounter++;
break;
case 4: //RET
//Memory[ProgramCounter] = 0x04;
//opcode->ParameterOneType = ;
// ProgramCounter++;
// break;
// case 4: //RET
// //Memory[ProgramCounter] = 0x04;
// //opcode->ParameterOneType = ;
ProgramCounter++;
break;
case 5: //CALL
//Memory[ProgramCounter] = 0x05;
// ProgramCounter++;
// break;
// case 5: //CALL
// //Memory[ProgramCounter] = 0x05;
ProgramCounter++;
// ProgramCounter++;
if (PeekToken()->Class == IdentifierClass || PeekToken()->Class == LabelClass) {
Symbol* symbol = GetSymbol(PeekToken()->Lemexe);
//opcode->ParameterOneType = ;
// if (PeekToken()->Class == IdentifierClass || PeekToken()->Class == LabelClass) {
// Symbol* symbol = GetSymbol(PeekToken()->Lemexe);
// //opcode->ParameterOneType = ;
// if (!symbol) {
// fprintf(stderr, "[Error] Line %d: %s is undefined.\n", PeekToken()->line, PeekToken()->lexeme);
// exit(1);
// }
if (!symbol) opcode->ParameterOne.Address = AddSymbol(PeekToken(), 2, 0, 0);
else opcode->ParameterOne.Address = symbol;
//Memory[ProgramCounter] = 2 >> symbol->address & 0xFF;
//Memory[ProgramCounter + 1] = symbol->address & 0xFF;
}
else {
fprintf(stderr, "[Error] Line %d: Expected address or label.\n", PeekToken()->LineNumber);
exit(1);
}
// // if (!symbol) {
// // fprintf(stderr, "[Error] Line %d: %s is undefined.\n", PeekToken()->line, PeekToken()->lexeme);
// // exit(1);
// // }
// if (!symbol) opcode->ParameterOne.Address = AddSymbol(PeekToken(), 2, 0, 0);
// else opcode->ParameterOne.Address = symbol;
// //Memory[ProgramCounter] = 2 >> symbol->address & 0xFF;
// //Memory[ProgramCounter + 1] = symbol->address & 0xFF;
// }
// else {
// fprintf(stderr, "[Error] Line %d: Expected address or label.\n", PeekToken()->LineNumber);
// exit(1);
// }
ProgramCounter += 2;
break;
case 6: //JMP
//Memory[ProgramCounter] = 0x06;
// ProgramCounter += 2;
// break;
// case 6: //JMP
// //Memory[ProgramCounter] = 0x06;
ProgramCounter++;
// ProgramCounter++;
if (PeekToken()->Class == IdentifierClass || PeekToken()->Class == LabelClass) {
Symbol* symbol = GetSymbol(PeekToken()->Lemexe);
//opcode->ParameterOneType = Address;
// if (PeekToken()->Class == IdentifierClass || PeekToken()->Class == LabelClass) {
// Symbol* symbol = GetSymbol(PeekToken()->Lemexe);
// //opcode->ParameterOneType = Address;
// if (!symbol) {
// fprintf(stderr, "[Error] Line %d: %s is undefined.\n", PeekToken()->line, PeekToken()->lexeme);
// exit(1);
// }
if (!symbol) opcode->ParameterOne.Address = AddSymbol(PeekToken(), 2, 0, 0);
else opcode->ParameterOne.Address = symbol;
// // if (!symbol) {
// // fprintf(stderr, "[Error] Line %d: %s is undefined.\n", PeekToken()->line, PeekToken()->lexeme);
// // exit(1);
// // }
// if (!symbol) opcode->ParameterOne.Address = AddSymbol(PeekToken(), 2, 0, 0);
// else opcode->ParameterOne.Address = symbol;
// Memory[ProgramCounter] = 2 >> symbol->address & 0xFF;
// Memory[ProgramCounter + 1] = symbol->address & 0xFF;
}
else {
fprintf(stderr, "[Error] Line %d: Expected address or label.\n", PeekToken()->LineNumber);
exit(1);
}
// // Memory[ProgramCounter] = 2 >> symbol->address & 0xFF;
// // Memory[ProgramCounter + 1] = symbol->address & 0xFF;
// }
// else {
// fprintf(stderr, "[Error] Line %d: Expected address or label.\n", PeekToken()->LineNumber);
// exit(1);
// }
ProgramCounter += 2;
break;
case 7: //IN
//Memory[ProgramCounter] = 0x07;
// ProgramCounter += 2;
// break;
// case 7: //IN
// //Memory[ProgramCounter] = 0x07;
ProgramCounter++;
// ProgramCounter++;
if (PeekToken()->Class == NumberClass) {
//opcode->ParameterOneType = ;
opcode->ParameterOne.Constant = PeekToken()->Value.Number;
// int* value = PeekToken()->value;
// if (PeekToken()->Class == NumberClass) {
// //opcode->ParameterOneType = ;
// opcode->ParameterOne.Constant = PeekToken()->Value.Number;
// // int* value = PeekToken()->value;
// Memory[ProgramCounter] = 2 >> *value & 0xFF;
// Memory[ProgramCounter + 1] = *value & 0xFF;
}
else {
fprintf(stderr, "[Error] Line %d: Expected port number.\n", PeekToken()->LineNumber);
exit(1);
}
// // Memory[ProgramCounter] = 2 >> *value & 0xFF;
// // Memory[ProgramCounter + 1] = *value & 0xFF;
// }
// else {
// fprintf(stderr, "[Error] Line %d: Expected port number.\n", PeekToken()->LineNumber);
// exit(1);
// }
ProgramCounter += 2;
break;
case 8: //OUT
//Memory[ProgramCounter] = 0x08;
// ProgramCounter += 2;
// break;
// case 8: //OUT
// //Memory[ProgramCounter] = 0x08;
ProgramCounter++;
// ProgramCounter++;
if (PeekToken()->Class == NumberClass) {
//opcode->ParameterOneType = ;
opcode->ParameterOne.Constant = PeekToken()->Value.Number;
// int* value = PeekToken()->value;
// if (PeekToken()->Class == NumberClass) {
// //opcode->ParameterOneType = ;
// opcode->ParameterOne.Constant = PeekToken()->Value.Number;
// // int* value = PeekToken()->value;
// Memory[ProgramCounter] = 2 >> *value & 0xFF;
// Memory[ProgramCounter + 1] = *value & 0xFF;
}
else {
fprintf(stderr, "[Error] Line %d: Expected port number.\n", PeekToken()->LineNumber);
exit(1);
}
// // Memory[ProgramCounter] = 2 >> *value & 0xFF;
// // Memory[ProgramCounter + 1] = *value & 0xFF;
// }
// else {
// fprintf(stderr, "[Error] Line %d: Expected port number.\n", PeekToken()->LineNumber);
// exit(1);
// }
ProgramCounter += 2;
break;
}
// ProgramCounter += 2;
// break;
// }
AddListItem(opcode, sizeof(IROpcode), MachineState.Opcodes);
// AddListItem(opcode, sizeof(IROpcode), MachineState.Opcodes);
return;
}
// return;
// }
int Expect(int count, ...) {
va_list list;
@@ -448,70 +571,71 @@ int Expect(int count, ...) {
void PrintSymbols(void) {
printf("-----SYMBOLS-----\n");
for(int i = 0; i < MachineState.SymbolsTable->size; i++) {
Symbol* symbol = MachineState.SymbolsTable->content[i];
printf("[%#06X] %s\n", symbol->address, symbol->token->Lemexe);
for(int i = 0; i < MachineState.SymbolsTable->Size; i++) {
Symbol* symbol = MachineState.SymbolsTable->Symbols[i];
printf("[Resolved? %d] %s\n", symbol->Resolved, symbol->Name);//symbol->address, symbol->token->Lemexe);
}
printf("-----SYMBOLS-----\n");
}
Symbol* AddSymbol(Token* token, int length, int address, int resolved) {
if (!token) return NULL;
if (token->Class != IdentifierClass && token->Class != LabelClass) return NULL;
// Symbol* AddSymbol(Token* token, int length, int address, int resolved) {
// if (!token) return NULL;
// if (token->Class != IdentifierClass && token->Class != LabelClass) return NULL;
for(int i = 0; i < MachineState.SymbolsTable->size; i++) {
Symbol* s = MachineState.SymbolsTable->content[i];
// for(int i = 0; i < MachineState.SymbolsTable->size; i++) {
// Symbol* s = MachineState.SymbolsTable->content[i];
if (strcmp(s->token->Lemexe, token->Lemexe) == 0) {
if (s->resolved) {
fprintf(stderr, "[Error] Line %d: Attempted to redeclare %s.\n", token->LineNumber, token->Lemexe);
exit(1);
}
s->resolved = resolved;
s->address = address;
s->length = length;
return s;
}
}
// if (strcmp(s->token->Lemexe, token->Lemexe) == 0) {
// if (s->resolved) {
// fprintf(stderr, "[Error] Line %d: Attempted to redeclare %s.\n", token->LineNumber, token->Lemexe);
// exit(1);
// }
// s->resolved = resolved;
// s->address = address;
// s->length = length;
// 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) {
if (!name) return NULL;
// Symbol* GetSymbol(char* name) {
// if (!name) return NULL;
for(int i = 0; i < MachineState.SymbolsTable->size; i++) {
Symbol* s = MachineState.SymbolsTable->content[i];
// for(int i = 0; i < MachineState.SymbolsTable->size; 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* symbol = calloc(1, sizeof(Symbol));
// Symbol* CreateSymbol(Token* token, int length, int address, int resolved) {
// Symbol* symbol = calloc(1, sizeof(Symbol));
if (!symbol) return NULL;
// if (!symbol) return NULL;
symbol->token = token;
symbol->address = address;
symbol->resolved = resolved;
// symbol->token = token;
// symbol->address = address;
// symbol->resolved = resolved;
return symbol;
}
// return symbol;
// }
IROpcode* CreateIROpcode(Mnemonic mnemonic) {
IROpcode* opcode = calloc(1, sizeof(IROpcode));
// IROpcode* CreateIROpcode(Mnemonic mnemonic) {
// IROpcode* opcode = calloc(1, sizeof(IROpcode));
opcode->Mnemonic = mnemonic;
// opcode->Mnemonic = mnemonic;
return opcode;
}
// return opcode;
// }
void AdvanceParser(void) {
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->Name = name;
symbol->Value = value;
//symbol->Value = value;
return symbol;
}