291 lines
8.0 KiB
C
291 lines
8.0 KiB
C
#include "parser.h"
|
|
#include "log.h"
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <stdio.h>
|
|
|
|
// /**
|
|
// * Parses an import declaration.
|
|
// *
|
|
// * @param ts The token stream to parse from.
|
|
// * @param module The module being parsed.
|
|
// * @returns true on success, false on failure.
|
|
// */
|
|
// static bool parse_import(TokenStream* ts, Module* module) {
|
|
// ImportDeclaration* new_imports = realloc(module->imports, (module->import_count + 1) * sizeof(ImportDeclaration));
|
|
// if (!new_imports) {
|
|
// fprintf(stderr, "Out of memory\n");
|
|
// exit(1);
|
|
// }
|
|
// module->imports = new_imports;
|
|
|
|
// Token t = tokenstream_next(ts);
|
|
// bool is_public = false;
|
|
// if (t.token == TOKEN_PUBLIC) {
|
|
// is_public = true;
|
|
// t = tokenstream_next(ts);
|
|
// }
|
|
|
|
// if (t.token != TOKEN_IDENTIFIER) {
|
|
// log_on_line(&t.location, t.location.column_end, "expected module name to import");
|
|
// return false;
|
|
// }
|
|
|
|
// char* name = (char*)malloc(t.text.length + 1);
|
|
// memcpy(name, t.text.data, t.text.length);
|
|
// name[t.text.length] = '\0';
|
|
|
|
// module->imports[module->import_count] = (ImportDeclaration){ .module_name = name, .is_public = is_public };
|
|
// module->import_count++;
|
|
|
|
// t = tokenstream_next(ts);
|
|
// if (t.token != TOKEN_SEMICOLON) {
|
|
// log_on_line(&t.location, t.location.column_end, "expected ';' after import");
|
|
// return false;
|
|
// }
|
|
// return true;
|
|
// }
|
|
|
|
// /**
|
|
// * Parses an alias declaration.
|
|
// *
|
|
// * @param ts The token stream to parse from.
|
|
// * @param module The module being parsed.
|
|
// * @returns true on success, false on failure.
|
|
// */
|
|
// static bool parse_alias(TokenStream* ts, Module* module) {
|
|
// AliasDeclaration* new_aliases = realloc(module->aliases, (module->alias_count + 1) * sizeof(AliasDeclaration));
|
|
// if (!new_aliases) {
|
|
// fprintf(stderr, "Out of memory\n");
|
|
// exit(1);
|
|
// }
|
|
// module->aliases = new_aliases;
|
|
|
|
// Token t = tokenstream_next(ts);
|
|
// if (t.token != TOKEN_IDENTIFIER) {
|
|
// log_on_line(&t.location, t.location.column_end, "expected alias name");
|
|
// return false;
|
|
// }
|
|
// char* name = (char*)malloc(t.text.length + 1);
|
|
// memcpy(name, t.text.data, t.text.length);
|
|
// name[t.text.length] = '\0';
|
|
// AliasDeclaration alias;
|
|
// alias.name = name;
|
|
|
|
// t = tokenstream_next(ts);
|
|
// if (t.token != TOKEN_ASSIGN) {
|
|
// log_on_line(&t.location, t.location.column_end, "expected '='");
|
|
// return false;
|
|
// }
|
|
|
|
// t = tokenstream_next(ts);
|
|
|
|
// TypeExpression type;
|
|
// if (t.token == TOKEN_IDENTIFIER && strncmp(t.text.data, "int32", t.text.length) == 0) {
|
|
// type = (TypeExpression){ .tag = TYPE_EXPRESSION_BUILTIN, .builtin = { .bitSize = 32, .isSigned = true } };
|
|
// t = tokenstream_next(ts);
|
|
// if (t.token == TOKEN_BRACKET_OPEN) {
|
|
// t = tokenstream_next(ts);
|
|
// if (t.token != TOKEN_BRACKET_CLOSE) {
|
|
// log_on_line(&t.location, t.location.column_end, "expected ']'");
|
|
// return false;
|
|
// }
|
|
// TypeExpression* inner = malloc(sizeof(TypeExpression));
|
|
// *inner = type;
|
|
// type = (TypeExpression){ .tag = TYPE_EXPRESSION_ARRAY, .array = { .array = inner } };
|
|
// t = tokenstream_next(ts);
|
|
// }
|
|
// } else {
|
|
// log_on_line(&t.location, t.location.column_end, "expected type");
|
|
// return false;
|
|
// }
|
|
|
|
// alias.value = type;
|
|
|
|
// module->aliases[module->alias_count] = alias;
|
|
// module->alias_count++;
|
|
|
|
// if (t.token != TOKEN_SEMICOLON) {
|
|
// log_on_line(&t.location, t.location.column_end, "expected ';'");
|
|
// return false;
|
|
// }
|
|
// return true;
|
|
// }
|
|
|
|
typedef struct {
|
|
TokenStream* ts;
|
|
Token token;
|
|
} Parser;
|
|
|
|
/**
|
|
* Reads a new token into p->token.
|
|
*/
|
|
static void parser_next_token(Parser* p) {
|
|
p->token = tokenstream_next(p->ts);
|
|
}
|
|
|
|
/**
|
|
* Reads a new token if the current token is equal to the expected token.
|
|
*
|
|
* If they are equal, it continues to the next token.
|
|
*
|
|
* @param p
|
|
* @param token The expected token.
|
|
* @returns `true` if the current token matches the expected, `false` if it does not.
|
|
*/
|
|
static bool parser_accept(Parser* p, TokenType token) {
|
|
if (p->token.token == token) {
|
|
parser_next_token(p);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* @copilot todo
|
|
*/
|
|
static bool parser_expect(Parser* p, TokenType token, const char* msg) {
|
|
if (parser_accept(p, token)) {
|
|
return true;
|
|
}
|
|
log_on_line(&p->token.location, msg);
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* @copilot todo add docs
|
|
*/
|
|
static bool parser_peek(Parser* p, TokenType token) {
|
|
if (p->token.token == token) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* @copilot todo add docs
|
|
*/
|
|
static bool parser_require(Parser* p, TokenType token, const char* msg) {
|
|
if (parser_peek(p, token)) {
|
|
return true;
|
|
}
|
|
log_on_line(&p->token.location, msg);
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Converts the current token to a string.
|
|
* @copilot add proper docs
|
|
*/
|
|
static char* parser_to_text(Parser* p) {
|
|
char* str = string_copy(p->token.text);
|
|
parser_next_token(p);
|
|
return str;
|
|
}
|
|
|
|
/**
|
|
* Parses the "module" keyword
|
|
*/
|
|
static bool parse_declaration_module(Parser* p, Module* module) {
|
|
if (!parser_expect(p, TOKEN_MODULE, "expected keyword 'module'")) {
|
|
return false;
|
|
}
|
|
|
|
if (!parser_require(p, TOKEN_IDENTIFIER, "expected module identifier")) {
|
|
return false;
|
|
}
|
|
module->name = parser_to_text(p);
|
|
|
|
return parser_expect(p, TOKEN_SEMICOLON, "expected ';' after module name");
|
|
}
|
|
|
|
static bool parse_import(Parser* p, Module* module, bool is_public) {
|
|
module->import_count++;
|
|
module->imports = realloc(module->imports, sizeof(ImportDeclaration) * module->import_count);
|
|
ImportDeclaration* import = &module->imports[module->import_count - 1];
|
|
|
|
if (!parser_expect(p, TOKEN_IDENTIFIER, "expected module identifier")) {
|
|
return false;
|
|
}
|
|
|
|
import->module_name = parser_to_text(p);
|
|
import->is_public = is_public;
|
|
return true;
|
|
}
|
|
|
|
static bool parse_alias(Parser* p, Module* module, bool is_public) {
|
|
// @copilot implement
|
|
return true;
|
|
}
|
|
|
|
Module* parser_parse(TokenStream* ts) {
|
|
Parser* p = malloc(sizeof(Parser));
|
|
p->ts = ts;
|
|
parser_next_token(p);
|
|
|
|
Module* module = malloc(sizeof(Module));
|
|
memset(module, 0, sizeof(Module));
|
|
if (!parse_declaration_module(p, module)) {
|
|
goto fail;
|
|
}
|
|
|
|
while (!parser_peek(p, TOKEN_EOF)) {
|
|
bool is_public = false;
|
|
bool terminal = false;
|
|
do {
|
|
if (parser_accept(p, TOKEN_IMPORT)) {
|
|
if (!parse_import(p, module, is_public)) {
|
|
goto fail;
|
|
}
|
|
terminal = true;
|
|
} else if (parser_accept(p, TOKEN_ALIAS)) {
|
|
if (!parse_alias(p, module, is_public)) {
|
|
goto fail;
|
|
}
|
|
terminal = true;
|
|
} else if (parser_accept(p, TOKEN_PUBLIC)) {
|
|
is_public = true;
|
|
} else {
|
|
log_on_line(&p->token.location, "unexpected token");
|
|
goto fail;
|
|
}
|
|
} while (!terminal);
|
|
}
|
|
|
|
return module;
|
|
fail:
|
|
free(module);
|
|
return NULL;
|
|
}
|
|
|
|
void free_type_expression(TypeExpression* expr) {
|
|
if (expr->tag == TYPE_EXPRESSION_ARRAY) {
|
|
free_type_expression(expr->array.array);
|
|
free(expr->array.array);
|
|
}
|
|
}
|
|
|
|
void parser_free(Module* module) {
|
|
if (module == NULL) {
|
|
return;
|
|
}
|
|
|
|
if (module->imports != NULL) {
|
|
for(size_t i = 0; i < module->import_count; i++) {
|
|
free(module->imports[i].module_name);
|
|
}
|
|
free(module->imports);
|
|
}
|
|
|
|
if (module->aliases != NULL) {
|
|
for(size_t i = 0; i < module->alias_count; i++) {
|
|
free(module->aliases[i].name);
|
|
free_type_expression(&module->aliases[i].value);
|
|
}
|
|
free(module->aliases);
|
|
}
|
|
|
|
free(module->name);
|
|
free(module);
|
|
}
|