From f7cd87f13feac25dec6d409ca3e06afba2e7786f Mon Sep 17 00:00:00 2001 From: Garritt McCune Date: Sun, 2 Oct 2022 22:54:18 -0500 Subject: [PATCH] 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. --- includes/parser.h | 25 +- includes/symbols_table.h | 2 +- src/main.c | 14 +- src/opcodes.c | 2 + src/parser.c | 744 +++++++++++++++++++++++---------------- src/symbols_table.c | 2 +- 6 files changed, 449 insertions(+), 340 deletions(-) diff --git a/includes/parser.h b/includes/parser.h index 294b732..8f47a47 100644 --- a/includes/parser.h +++ b/includes/parser.h @@ -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; diff --git a/includes/symbols_table.h b/includes/symbols_table.h index c4dd749..155b560 100644 --- a/includes/symbols_table.h +++ b/includes/symbols_table.h @@ -9,7 +9,7 @@ #define SYMBOLSTABLE_DEFAULT_CAPACITY 128 typedef enum { - Data, + ValueAt, Address } SymbolType; diff --git a/src/main.c b/src/main.c index 31df72d..74b63f2 100644 --- a/src/main.c +++ b/src/main.c @@ -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); diff --git a/src/opcodes.c b/src/opcodes.c index d8d78cc..234a46e 100644 --- a/src/opcodes.c +++ b/src/opcodes.c @@ -35,6 +35,8 @@ Instruction* CreateInstruction(Mnemonic mnemonic) { } instruction->Mnemonic = mnemonic; + instruction->ParameterOneType = NoParameter; + instruction->ParameterTwoType = NoParameter; return instruction; } diff --git a/src/parser.c b/src/parser.c index 45aad7a..4fa9081 100644 --- a/src/parser.c +++ b/src/parser.c @@ -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; diff --git a/src/symbols_table.c b/src/symbols_table.c index f634270..ce7442c 100644 --- a/src/symbols_table.c +++ b/src/symbols_table.c @@ -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; }