Timerix/TCPU
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

rename fix

Browse Source
This commit is contained in:
Timerix 2025-01-28 15:18:20 +03:00
parent 7f606dfaff
commit 2d3e66dd38
5 changed files with 0 additions and 309 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
src/compiler/compiler.h
View File

@ -1,34 +0,0 @@
#pragma once
#include "../std.h"
#include "../collections/List.h"
#include "Token.h"
#include "AST.h"
typedef enum CompilerState {
CompilerState_Initial,
CompilerState_Lexing,
CompilerState_Parsing,
CompilerState_Compiling,
CompilerState_Error,
CompilerState_Success
} CompilerState;
typedef struct Compiler {
char* code;
u32 code_len;
u32 column; // > 0 if code parsing started
u32 pos;
CompilerState state;
NULLABLE(char* error_message);
List_Token tokens;
List_u32 line_lengths;
AST ast;
u32 tok_i;
} Compiler;
void Compiler_init(Compiler* cmp);
void Compiler_free(Compiler* cmp);
/// @brief compile assembly language code to machine code
/// @return true if no errors, false if any error occured (check cmp->error_message)
bool Compiler_compile(Compiler* cmp, cstr source_file_name, cstr out_file_name, bool debug);

29
src/compiler/compiler_internal.h
View File

@ -1,29 +0,0 @@
#include "Compiler.h"
void _Compiler_setError(Compiler* cmp, cstr context, cstr format, ...) __attribute__((__format__(__printf__, 3, 4)));
#define Compiler_setError(cmp, format, ...) _Compiler_setError(cmp, __func__, format ,##__VA_ARGS__)
#define returnError(FORMAT, ...) {\
setError(FORMAT, ##__VA_ARGS__);\
return false;\
}
#define returnErrorIf(STATEMENT, FORMAT, ...) if(STATEMENT) returnError(FORMAT, ##__VA_ARGS__)
#define returnErrorIf_auto(STATEMENT) returnErrorIf(STATEMENT, #STATEMENT)
typedef struct CodePos {
u32 line; // 0 on error
u32 column; // 0 on error
} CodePos;
#define CodePos_create(L, C) ((CodePos){ .line = L, .column = C })
/// @param pos index in code buffer
CodePos Compiler_getLineAndColumn(Compiler* cmp, u32 pos);
char* Compiler_extractTokenStr(Compiler* cmp, Token t);
bool Compiler_lex(Compiler* cmp);
bool Compiler_parse(Compiler* cmp);

193
src/compiler/parser.c
View File

@ -1,193 +0,0 @@
#include "Compiler_internal.h"
#define setError(FORMAT, ...) {\
cmp->pos = cmp->tokens.data[cmp->tok_i].begin;\
Compiler_setError(cmp, FORMAT, ##__VA_ARGS__);\
}
#define setError_unexpectedToken(T) {\
char* tok_str = Compiler_extractTokenStr(cmp, T);\
cmp->pos = T.begin;\
Compiler_setError(cmp, "unexpected token '%s'", tok_str);\
free(tok_str);\
}
#define setError_unexpectedTokenChar(T, I) {\
cmp->pos = T.begin + I;\
Compiler_setError(cmp, "unexpected token '%c'", cmp->code[cmp->pos]);\
}
#define Error_TokenUnset "token of undefined type"
#define Error_BitSize "invalid size in bits"
static void List_u8_pushBytes(List_u8* l, void* value, u32 startIndex, u32 count){
u8* v = value;
for(u32 byte_i = startIndex; byte_i < startIndex + count; byte_i++){
List_u8_push(l, v[byte_i]);
}
}
static inline bool isVarSizeBits(u32 B) { return (B == 8 && B == 16 && B == 32 && B == 64); }
static NULLABLE(u8*) resolveEscapeSequences(Compiler* cmp, cstr src){
u32 len = strlen(src);
List_u8 resolved = List_u8_alloc(len);
char c;
bool escaped = false;
for(u32 i = 0; i < len; i++){
c = src[i];
if(c == '\\'){
escaped = !escaped;
continue;
}
if(!escaped){
List_u8_push(&resolved, c);
continue;
}
// escape codes
switch(c){
case '0':
List_u8_push(&resolved, '\0');
break;
case 'n':
List_u8_push(&resolved, '\n');
break;
case 'r':
List_u8_push(&resolved, '\r');
break;
case 't':
List_u8_push(&resolved, '\t');
break;
case 'e':
List_u8_push(&resolved, '\e');
break;
default:
setError_unexpectedTokenChar(cmp->tokens.data[cmp->tok_i], i);
free(resolved.data);
return NULL;
}
}
return resolved.data;
}
static void parseDataDefinition(Compiler* cmp, char* instr_name, DataDefinition* ddf){
i32 _element_size_bits;
if(sscanf(instr_name, "const%i", &_element_size_bits) != 1 || !isVarSizeBits(_element_size_bits)){
setError(Error_BitSize);
return;
}
ddf->element_size = _element_size_bits / 8;
Token tok = cmp->tokens.data[++cmp->tok_i];
char* tok_str = Compiler_extractTokenStr(cmp, tok);
u8* processed_str = NULL;
i32 len = 0;
ddf->name = tok_str;
while(++cmp->tok_i < cmp->tokens.len){
switch(tok.type){
case TokenType_Unset:
setError(Error_TokenUnset);
return;
case TokenType_SingleLineComment:
case TokenType_MultiLineComment:
// skip comments
break;
case TokenType_Number:
tok_str = Compiler_extractTokenStr(cmp, tok);
if(cstr_seekChar(tok_str, '.', 0, -1) != -1){
f64 f = atof(tok_str);
List_u8_pushBytes(&ddf->data, &f, 8 - ddf->element_size, ddf->element_size);
}
else {
i64 i = atoll(tok_str);
List_u8_pushBytes(&ddf->data, &i, 8 - ddf->element_size, ddf->element_size);
}
break;
case TokenType_Char:
tok.begin += 1;
tok.length -= 2;
tok_str = Compiler_extractTokenStr(cmp, tok);
processed_str = resolveEscapeSequences(cmp, tok_str);
free(tok_str);
len = strlen(processed_str);
if(len != ddf->element_size){
setError("can't fit char of size %i in %u bit variable", len, _element_size_bits);
return;
}
List_u8_pushBytes(&ddf->data, processed_str, 0, len);
break;
case TokenType_String:
tok.begin += 1;
tok.length -= 2;
tok_str = Compiler_extractTokenStr(cmp, tok);
processed_str = resolveEscapeSequences(cmp, tok_str);
free(tok_str);
len = strlen(processed_str);
List_u8_pushBytes(&ddf->data, processed_str, 0, len);
break;
case TokenType_OperationEnd:
return;
default:
setError_unexpectedToken(tok);
return;
}
}
}
static void parseOperation(Compiler* cmp, char* instr_name, Operation* operPtr){
}
bool Compiler_parse(Compiler* cmp){
returnErrorIf_auto(cmp->state != CompilerState_Lexing);
cmp->state = CompilerState_Parsing;
Token tok;
Section* sec = NULL;
while(cmp->tok_i < cmp->tokens.len){
tok = cmp->tokens.data[cmp->tok_i];
switch(tok.type){
case TokenType_Unset:
returnError(Error_TokenUnset);
case TokenType_SingleLineComment:
case TokenType_MultiLineComment:
// skip comments
break;
case TokenType_Label:
// create new section
sec = List_Section_expand(&cmp->ast.sections);
Section_init(sec, Compiler_extractTokenStr(cmp, tok));
break;
case TokenType_Instruction:
if(sec == NULL)
returnError("no section");
char* instr_name = Compiler_extractTokenStr(cmp, tok);
// data definition starts with const
if(cstr_seek(instr_name, "const", 0, 1)){
DataDefinition* dataDefPtr = List_DataDefinition_expand(&sec->data);
parseDataDefinition(cmp, instr_name, dataDefPtr);
}
else {
Operation* operPtr = List_Operation_expand(&sec->code);
parseOperation(cmp, instr_name, operPtr);
}
break;
default:
setError_unexpectedToken(tok);
return false;
}
if(cmp->state == CompilerState_Error)
return false;
cmp->tok_i++;
}
return true;
}

23
src/compiler/token.c
View File

@ -1,23 +0,0 @@
#include "Token.h"
List_define(Token);
static cstr _TokenType_str[] = {
"Unset",
"SingleLineComment",
"MultiLineComment",
"Instruction",
"Label",
"Number",
"Char",
"String",
"Name",
"NamedDataPointer",
"NamedDataSize"
};
cstr TokenType_toString(TokenType t){
if(t >= ARRAY_SIZE(_TokenType_str))
return "!!INDEX_ERROR!!";
return _TokenType_str[t];
}

30
src/compiler/token.h
View File

@ -1,30 +0,0 @@
#pragma once
#include "../std.h"
#include "../collections/List.h"
typedef enum TokenType {
TokenType_Unset, // initial value
TokenType_SingleLineComment, // //comment
TokenType_MultiLineComment, // /* comment */
TokenType_Instruction, // abc
TokenType_Label, // .abc:
TokenType_Number, // 0123
TokenType_Char, // 'A'
TokenType_String, // "aaaa"
TokenType_Name, // xyz
TokenType_NamedDataPointer, // @xyz
TokenType_NamedDataSize, // #xyz
TokenType_OperationEnd, // EOL or EOF or ;
} TokenType;
cstr TokenType_toString(TokenType t);
typedef struct Token {
u32 begin; // some index in Compiler->code
u32 length : 24; // length in characters (24 bits)
TokenType type : 8; // type of token (8 bits)
} Token;
List_declare(Token);
#define Token_construct(TYPE, BEGIN, LEN) ((Token){ .type = TYPE, .begin = BEGIN, .length = LEN })