JailDoctor/jailbasic
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Files
b62cbd2cdad405489ea7b2a7233e9737934da7f5
jailbasic/parser.cpp

885 lines
25 KiB
C++
Raw Blame History

#include "parser.h"
#include "tokenizer.h"
#include "scope.h"
#include "types.h"
#include "function.h"
#include "error.h"
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <string>
#include <stack>
#include <vector>
#include "decompiler.h"
#define MAX_CODE_SIZE 65536
#define MAX_LABELS 256
#define MAX_FUNCTIONS 256
#define MAX_EXTERNAL_FUNCTIONS 256
#define MAX_IDENTIFIER_LENGTH 40
#define MAX_CONSTANTS 256
#define MAX_STRUCT_MEMBERS 10
struct t_label {
std::string name;
uint32_t address;
};
/*
struct t_external_function {
char name[MAX_IDENTIFIER_LENGTH];
int num_parameters = 0;
};
struct t_string {
unsigned char string[256];
word references[256];
int num_references = 1;
};
*/
static byte* code; // [MAX_CODE_SIZE];
static uint32_t codepos = 0;
static uint32_t lines[32768];
static uint32_t current_line;
static std::vector<t_label> known_labels;
//static int num_known_labels = 0;
static std::vector<t_label> unknown_labels;
//static int num_unknown_labels = 0;
static int num_anonymous_labels = 0;
static std::string breaklabel = "";
static std::string contlabel = "";
/*
static t_variable* variables = nullptr;
static int num_variables = 0;
static bool variable_is_array = false;
static t_external_function external_functions[MAX_EXTERNAL_FUNCTIONS];
static int num_external_functions = 0;
static t_string strings[256];
static int num_strings = 0;
static t_constant constants[MAX_CONSTANTS];
static int num_constants;
*/
static bool parser_finished = false;
static bool global_closed = false;
/****************************************************************************************/
/* GENERIC FUNCTIONS */
/****************************************************************************************/
static const std::string int_to_string(int value) {
std::string label = "0000000";
//for (int i = 0; i < 7; i++) label[i] = '0';
int i = 6;
while (value > 0) {
label[i] = 48 + (value % 10);
value = value / 10;
i--;
}
return label;
}
/****************************************************************************************/
/* BYTECODE GENERATOR */
/****************************************************************************************/
static void emmit(const byte value) {
lines[codepos] = current_line;
code[codepos++] = value;
}
static void emmit_w(const word value) {
lines[codepos] = current_line;
code[codepos++] = value & 255;
lines[codepos] = current_line;
code[codepos++] = value >> 8;
}
static void emmit_dw(const uint32_t value) {
byte *v = (byte*)&value;
lines[codepos] = current_line; code[codepos++] = *(v++);
lines[codepos] = current_line; code[codepos++] = *(v++);
lines[codepos] = current_line; code[codepos++] = *(v++);
lines[codepos] = current_line; code[codepos++] = *(v++);
}
static void emmit_f(const float value) {
byte *v = (byte*)&value;
lines[codepos] = current_line; code[codepos++] = *(v++);
lines[codepos] = current_line; code[codepos++] = *(v++);
lines[codepos] = current_line; code[codepos++] = *(v++);
lines[codepos] = current_line; code[codepos++] = *(v++);
}
static void patch(const uint32_t address, const word dest) {
code[address] = dest & 255;
code[address + 1] = dest >> 8;
}
static void patch_dw(const uint32_t address, const uint32_t dest) {
byte *v = (byte*)&dest;
code[address] = v[0];
code[address+1] = v[1];
code[address+2] = v[2];
code[address+3] = v[3];
}
static const uint32_t get_current_address() {
return codepos;
}
#define EXPECT(X, Y) if (tkn_get_token() != X) { parser_finished = true; error_raise(Y); return; }
#define EXPECT2(X, Y) if (tkn_get_token() != X) { parser_finished = true; error_raise(Y); return -1; }
#define HALT(Y) { parser_finished = true; error_raise(Y); return; }
#define HALT2(Y) { parser_finished = true; error_raise(Y); return -1; }
/****************************************************************************************/
/* LABEL MANAGEMENT */
/****************************************************************************************/
static const uint32_t get_label_address(const std::string name) {
for (auto label : known_labels) if (label.name == name) return label.address;
unknown_labels.push_back({name, get_current_address()});
return 0;
}
static void register_label_address(const std::string name) {
// If the label already exists, vomit an error
for (auto label : known_labels) if (label.name == name) HALT("Duplicate label");
// register new label
known_labels.push_back({name, get_current_address()});
// patch and remove any references awaiting for this label
auto i = std::begin(unknown_labels);
while (i != std::end(unknown_labels)) {
if ((*i).name == name) {
patch_dw((*i).address, get_current_address());
i = unknown_labels.erase(i);
} else {
++i;
}
}
}
static const std::string generate_anonymous_labelname() {
return int_to_string(num_anonymous_labels++);
}
/****************************************************************************************/
/* PARSER */
/****************************************************************************************/
static void parse_expression();
static const bool parse_statements();
/* XXX [RZC 27/04/2021] No usat en JailBasic
//static void parse_strleft();
static void parse_str();
static void parse_chr();
static void parse_strlen();
static void parse_keypressed();
static void parse_anykey();
static void parse_getchar();
static void parse_getcolor();
*/
/*
static void parse_concat_atom() {
if (tkn_get_token() == TOKEN_STRING) {
emmit(OP_SETX);
emmit_w(register_string(tkn_get_string()));
emmit(OP_JSR);
emmit_w(get_label_address("_sys_string_load"));
tkn_next();
return;
}
if (tkn_get_token() == TOKEN_HEXSTRING) {
emmit(OP_SETX);
emmit_w(register_array(tkn_get_array()));
emmit(OP_JSR);
emmit_w(get_label_address("_sys_string_load"));
tkn_next();
return;
}
if (tkn_get_token() == TOKEN_IDENTIFIER) {
int ivar = get_variable_index(tkn_get_string());
if (!is_variable_array()) { parser_finished = true; error_raise("Expected string constant or variable"); return; }
emmit(OP_SETX);
emmit_w(ivar);
emmit(OP_JSR);
emmit_w(get_label_address("_sys_string_load"));
tkn_next();
return;
}
if (tkn_get_token() == TOKEN_STRLEFT) { tkn_next(); parse_strleft(); return; }
if (tkn_get_token() == TOKEN_STR) { tkn_next(); parse_str(); return; }
if (tkn_get_token() == TOKEN_CHR) { tkn_next(); parse_chr(); return; }
parser_finished = true; error_raise("Syntax error");
return;
}
static void parse_concatenation() {
parse_concat_atom();
while (tkn_get_token() == TOKEN_COMMA) {
tkn_next(); parse_concat_atom();
emmit(OP_CONCAT);
}
}
*/
static int get_variable_address() {
int address = scope_get_variable_address();
uint32_t var_length = scope_get_variable_size();
uint32_t var_type = scope_get_variable_type();
while (true) {
// Si es un array...
if (var_length > 1) {
tkn_next(); EXPECT2(TOKEN_LBRACKET, "Expected '['");
tkn_next(); EXPECT2(TOKEN_NUMBER, "Expected number");
const int index = (int)tkn_get_value();
if (tkn_get_value() > index) HALT2("Expected integer value");
if (index >= var_length) HALT2("Index out of bounds");
tkn_next(); EXPECT2(TOKEN_RBRACKET, "Expected ']'");
address += index * types_get_length(var_type);
}
// Si es un struct...
if (var_type >= 2) {
tkn_next(); EXPECT2(TOKEN_DOT, "Expected '.'");
tkn_next(); EXPECT2(TOKEN_IDENTIFIER, "Expected identifier");
const std::string member_name = tkn_get_string();
const int member_num = types_member_exists(var_type, member_name);
if (member_num == -1) HALT2("Unknown member");
address += types_get_member_offset(var_type, member_num);
var_length = types_get_member_length(var_type, member_num);
var_type = types_get_member_type(var_type, member_num);
} else {
return address;
}
}
}
static void parse_expr_atom() {
// NUM, VAR, UNARY, PAREN
if (tkn_get_token() == TOKEN_NUMBER) {
emmit(OP_PUSH);
emmit_f(tkn_get_value());
tkn_next();
return;
}
if (tkn_get_token() == TOKEN_IDENTIFIER) {
if (scope_variable_exists(tkn_get_string())) {
const int address = get_variable_address();
if (address == -1) return;
emmit(scope_is_local() ? OP_LDL : OP_LD);
emmit_dw(address);
tkn_next();
return;
} else {
// TODO [RZC 03/05/2021] Revisar funcions
parser_finished = true; error_raise("Unknown identifier");
return;
}
}
if (tkn_get_token() == TOKEN_MINUS) {
tkn_next();
parse_expr_atom();
emmit(OP_NEG);
return;
}
if (tkn_get_token() == TOKEN_NOT) {
tkn_next();
parse_expr_atom();
emmit(OP_NOT);
return;
}
if (tkn_get_token() == TOKEN_LPAR) {
tkn_next();
parse_expression();
EXPECT(TOKEN_RPAR, "Expected ')'");
tkn_next();
return;
}
parser_finished = true; error_raise("Syntax error");
return;
}
static void parse_expr_mul() {
parse_expr_atom();
while (tkn_get_token() == TOKEN_ASTERISC || tkn_get_token() == TOKEN_SLASH || tkn_get_token() == TOKEN_MOD) {
t_tokentype operat = tkn_get_token();
tkn_next();
parse_expr_atom();
switch (operat) {
case TOKEN_ASTERISC: emmit(OP_MUL); break;
case TOKEN_SLASH: emmit(OP_DIV); break;
case TOKEN_MOD: emmit(OP_MOD); break;
default: /* Impossible */ break;
}
}
}
static void parse_expr_sum() {
parse_expr_mul();
while (tkn_get_token() == TOKEN_PLUS || tkn_get_token() == TOKEN_MINUS) {
t_tokentype operat = tkn_get_token();
tkn_next();
parse_expr_mul();
switch (operat) {
case TOKEN_PLUS: emmit(OP_ADD); break;
case TOKEN_MINUS: emmit(OP_SUB); break;
default: /* Impossible */ break;
}
}
}
static void parse_expr_bool() {
parse_expr_sum();
while (tkn_get_token() == TOKEN_AND || tkn_get_token() == TOKEN_OR) {
t_tokentype operat = tkn_get_token();
tkn_next();
parse_expr_sum();
switch (operat) {
case TOKEN_AND: emmit(OP_AND); break;
case TOKEN_OR: emmit(OP_OR); break;
default: /* Impossible */ break;
}
}
}
static void parse_expression() {
parse_expr_bool();
while (tkn_get_token() == TOKEN_EQ || tkn_get_token() == TOKEN_NEQ || tkn_get_token() == TOKEN_LT || tkn_get_token() == TOKEN_GT || tkn_get_token() == TOKEN_LEQ || tkn_get_token() == TOKEN_GEQ) {
t_tokentype operat = tkn_get_token();
tkn_next();
parse_expr_bool();
switch (operat) {
case TOKEN_EQ: emmit(OP_EQ); break;
case TOKEN_NEQ: emmit(OP_NEQ); break;
case TOKEN_LT: emmit(OP_LT); break;
case TOKEN_GT: emmit(OP_GT); break;
case TOKEN_LEQ: emmit(OP_LEQ); break;
case TOKEN_GEQ: emmit(OP_GEQ); break;
default: /* Impossible */ break;
}
}
}
static bool identifier_exists(const std::string identifier, const bool can_shadow=false) {
if (scope_variable_exists(identifier, can_shadow)) return true;
if (types_exist(identifier) != -1) return true;
if (function_exists(identifier)) return true;
return false;
}
static void parse_const() {
EXPECT(TOKEN_IDENTIFIER, "Expected identifier");
char const_name[40];
strcpy(const_name, tkn_get_string());
if (identifier_exists(const_name, true)) HALT("Identifier already exists");
tkn_next(); EXPECT(TOKEN_AS, "Expected 'as'");
tkn_next(); EXPECT(TOKEN_IDENTIFIER, "Expected type identifier");
char type_name[40];
strcpy(type_name, tkn_get_string());
const int type_num = types_exist(type_name);
if (type_num == -1) HALT("Unknown type");
if (type_num >= 2) HALT("Only 'number' or 'string' constants allowed");
tkn_next(); EXPECT(TOKEN_EQ, "Expected '='");
tkn_next(); parse_expression();
const int var_address = scope_declare_variable(const_name, type_num, 0);
emmit(scope_is_local() ? OP_STL : OP_ST);
emmit_dw(var_address);
}
static void parse_var() {
int var_length = 1;
EXPECT(TOKEN_IDENTIFIER, "Expected identifier");
const std::string var_name = tkn_get_string();
if (identifier_exists(var_name, true)) HALT("Identifier already exists");
tkn_next(); EXPECT(TOKEN_AS, "Expected 'as'");
tkn_next();
if (tkn_get_token() == TOKEN_ARRAY) {
tkn_next(); EXPECT(TOKEN_OF, "Expected 'of'");
tkn_next(); EXPECT(TOKEN_NUMBER, "Expected number");
const float length = tkn_get_value();
var_length = (int)length;
if (length > var_length) HALT("Expected integer value");
tkn_next();
}
EXPECT(TOKEN_IDENTIFIER, "Expected type identifier");
const std::string type_name = tkn_get_string();
const int type_num = types_exist(type_name);
if (type_num == -1) HALT("Unknown type");
tkn_next();
if (tkn_get_token() == TOKEN_EQ) {
if (type_num >= 2) HALT("Only 'number' or 'string' variables can be initialized on declaration")
if (var_length > 1) HALT("Array variables cannot be initialized on declaration")
tkn_next(); parse_expression();
const int var_address = scope_declare_variable(var_name, type_num, var_length);
emmit(scope_is_local() ? OP_STL : OP_ST);
emmit_dw(var_address);
} else {
scope_declare_variable(var_name, type_num, var_length);
//tkn_next();
}
}
static void parse_struct() {
EXPECT(TOKEN_IDENTIFIER, "Expected identifier");
const std::string struct_name = tkn_get_string();
if (identifier_exists(struct_name)) HALT("Identifier already exists");
const int struct_num = types_add(struct_name);
tkn_next();
while (tkn_get_token() != TOKEN_END) {
int member_length = 1;
EXPECT(TOKEN_IDENTIFIER, "Expected identifier");
char member_name[40];
strcpy(member_name, tkn_get_string());
tkn_next(); EXPECT(TOKEN_AS, "Expected 'as'");
tkn_next();
if (tkn_get_token() == TOKEN_ARRAY) {
tkn_next(); EXPECT(TOKEN_OF, "Expected 'of'");
tkn_next(); EXPECT(TOKEN_NUMBER, "Expected number");
member_length = (int)tkn_get_value();
if (tkn_get_value() > member_length) HALT("Expected integer value");
tkn_next();
}
EXPECT(TOKEN_IDENTIFIER, "Expected type identifier");
const std::string type_name = tkn_get_string();
const int type_num = types_exist(type_name);
if (type_num == -1) HALT("Unknown type");
types_add_member(struct_num, member_name, type_num, member_length);
tkn_next();
}
tkn_next();
}
static void parse_function() {
if (!global_closed) {
emmit(OP_RET);
global_closed = true;
}
EXPECT(TOKEN_IDENTIFIER, "Expected identifier");
const std::string function_name = tkn_get_string();
if (identifier_exists(function_name)) HALT("Identifier already exists");
function_register(function_name, codepos);
tkn_next(); EXPECT(TOKEN_LPAR, "Expected '('");
tkn_next();
scope_open_local();
std::stack<uint32_t> addresses;
while (tkn_get_token() != TOKEN_RPAR) {
if (function_get_num_parameters() != 0) {
EXPECT(TOKEN_COMMA, "Expected ',' or ')'");
tkn_next();
}
EXPECT(TOKEN_IDENTIFIER, "Expected identifier");
const std::string param_name = tkn_get_string();
tkn_next(); EXPECT(TOKEN_AS, "Expected 'as'");
tkn_next(); EXPECT(TOKEN_IDENTIFIER, "Expected type identifier");
const std::string type_name = tkn_get_string();
const int type_num = types_exist(type_name);
if (type_num == -1) HALT("Unknown type");
if (!function_parameter_add(param_name, type_num)) HALT("Parameter name already used");
addresses.push(scope_declare_variable(param_name, type_num, 1));
tkn_next();
}
while (!addresses.empty()) {
emmit(OP_STL);
emmit_dw(addresses.top());
addresses.pop();
}
tkn_next();
if (tkn_get_token() == TOKEN_AS) {
tkn_next(); EXPECT(TOKEN_IDENTIFIER, "Expected type identifier");
const std::string type_name = tkn_get_string();
const int type_num = types_exist(type_name);
if (type_num == -1) HALT("Unknown type");
function_set_type(type_num);
tkn_next();
}
if (!parse_statements() && (function_get_type() != -1)) HALT("Not all paths return a value");
scope_close_local();
EXPECT(TOKEN_END, "Expected statement or 'end'");
tkn_next();
}
/*static void parse_dim() {
EXPECT(TOKEN_IDENTIFIER, "Expected variable");
char varname[40];
strcpy(varname, tkn_get_string());
tkn_next(); EXPECT(TOKEN_LPAR, "Expected array size");
tkn_next(); EXPECT(TOKEN_NUMBER, "Expected integer constant as array size");
get_variable_index(varname, tkn_get_value()); // register variable with size, no need to keep ival
tkn_next(); EXPECT(TOKEN_RPAR, "Expected ')'");
tkn_next();
}*/
// XXX [RZC 27/04/2021] Desactivat INC i DEC per ara
/*static void parse_inc() {
EXPECT(TOKEN_IDENTIFIER, "Expected variable");
int ivar = get_variable_index(tkn_get_string());
if (is_variable_array()) {
tkn_next(); EXPECT(TOKEN_LPAR, "Expected array index");
tkn_next(); parse_expr_atom();
EXPECT(TOKEN_RPAR, "Expected ')'");
emmit(OP_SETY);
emmit(OP_LOADI);
emmit_w(ivar);
emmit(OP_INC);
emmit(OP_STOREI);
emmit_w(ivar);
} else {
emmit(OP_LOAD);
emmit_w(ivar);
emmit(OP_INC);
emmit(OP_STORE);
emmit_w(ivar);
}
tkn_next();
}
static void parse_dec() {
EXPECT(TOKEN_IDENTIFIER, "Expected variable");
int ivar = get_variable_index(tkn_get_string());
if (is_variable_array()) {
tkn_next(); EXPECT(TOKEN_LPAR, "Expected array index");
tkn_next(); parse_expr_atom();
EXPECT(TOKEN_RPAR, "Expected ')'");
emmit(OP_SETY);
emmit(OP_LOADI);
emmit_w(ivar);
emmit(OP_DEC);
emmit(OP_STOREI);
emmit_w(ivar);
}
else {
emmit(OP_LOAD);
emmit_w(ivar);
emmit(OP_DEC);
emmit(OP_STORE);
emmit_w(ivar);
}
tkn_next();
}*/
// XXX [RZC 27/04/2021] Desactivat, no se molt be ni què es
/*static void parse_let() {
EXPECT(TOKEN_IDENTIFIER, "Expected variable");
int ivar = get_variable_index(tkn_get_string());
if (is_variable_array()) {
tkn_next();
if (tkn_get_token() == TOKEN_COLON) {
tkn_next(); parse_concatenation();
emmit(OP_SETX);
emmit_w(ivar);
emmit(OP_JSR);
emmit_w(get_label_address("_sys_string_store"));
return;
} else {
EXPECT(TOKEN_LPAR, "Expected ':' or '('");
tkn_next(); parse_expr_atom();
EXPECT(TOKEN_RPAR, "Expected ')'");
emmit(OP_SETY);
}
}
tkn_next();
EXPECT(TOKEN_EQ, "Expected '='");
tkn_next(); parse_expression();
if (is_variable_array()) {
emmit(OP_STOREI);
emmit_w(ivar);
} else {
emmit(OP_STORE);
emmit_w(ivar);
}
}*/
static const bool parse_if() {
bool ret_at_else = true;
const std::string previous_breaklabel = breaklabel;
parse_expression();
EXPECT2(TOKEN_THEN, "Expected 'THEN'");
tkn_next();
emmit(OP_JNT);
const std::string elselabel = generate_anonymous_labelname();
const std::string endlabel = generate_anonymous_labelname();
breaklabel = endlabel;
bool else_visited = false;
emmit_dw(get_label_address(elselabel));
scope_open_block();
const bool ret_at_then = parse_statements();
scope_close_block();
if (tkn_get_token() == TOKEN_ELSE) {
else_visited = true;
emmit(OP_JMP);
emmit_dw(get_label_address(endlabel));
register_label_address(elselabel);
tkn_next();
scope_open_block();
ret_at_else = parse_statements();
scope_close_block();
}
if (tkn_get_token() == TOKEN_END) {
if (!else_visited) register_label_address(elselabel);
register_label_address(endlabel);
tkn_next();
breaklabel = previous_breaklabel;
return ret_at_else && ret_at_then;
}
parser_finished = true;
if (!else_visited) error_raise("Expected 'ELSE', 'END' or a statement"); else error_raise("Expected 'END' or a statement");
return false;
}
/*
static void parse_for() {
char* previous_breaklabel = breaklabel;
char* previous_contlabel = contlabel;
EXPECT(TOKEN_IDENTIFIER, "Expected variable");
int ivar = get_variable_index(tkn_get_string());
tkn_next();
EXPECT(TOKEN_EQ, "Expected '='");
tkn_next();
parse_expression();
emmit(OP_STORE);
emmit_w(ivar);
char forlabel[8];
generate_anonymous_labelname(forlabel);
char endlabel[8];
generate_anonymous_labelname(endlabel);
char continuelabel[8];
generate_anonymous_labelname(continuelabel);
breaklabel = endlabel;
contlabel = continuelabel;
register_label_address(forlabel);
EXPECT(TOKEN_TO, "Expected 'TO'");
tkn_next();
parse_expression();
emmit(OP_LOAD);
emmit_w(ivar);
emmit(OP_EQ);
emmit(OP_JTR);
emmit_w(get_label_address(endlabel));
//int endLabel = GetCurrentAddress();
parse_statements();
EXPECT(TOKEN_END, "Expected 'END'");
tkn_next();
register_label_address(continuelabel);
emmit(OP_LOAD);
emmit_w(ivar);
emmit(OP_INC);
emmit(OP_STORE);
emmit_w(ivar);
emmit(OP_JMP);
emmit_w(get_label_address(forlabel));
register_label_address(endlabel);
//Patch(endLabel, GetCurrentAddress());
breaklabel = previous_breaklabel;
contlabel = previous_contlabel;
}
static void parse_break() {
if (breaklabel == nullptr) { parser_finished = true; error_raise("Can't break outside of a loop or condition"); return; }
emmit(OP_JMP);
emmit_w(get_label_address(breaklabel));
}
static void parse_continue() {
if (contlabel == nullptr) { parser_finished = true; error_raise("Can't continue outside of a loop"); return; }
emmit(OP_JMP);
emmit_w(get_label_address(contlabel));
}
*/
// XXX [RZC 27/04/2021] Ni GOTO ni GOSUB
/*static void parse_goto() {
emmit(OP_JMP);
EXPECT(TOKEN_IDENTIFIER, "Expected label name");
emmit_w(get_label_address(tkn_get_string()));
tkn_next();
}
static void parse_gosub() {
emmit(OP_JSR);
EXPECT(TOKEN_IDENTIFIER, "Expected label name");
emmit_w(get_label_address(tkn_get_string()));
tkn_next();
}*/
static void parse_return() {
const int return_type = function_get_type();
if (return_type != -1) {
if (return_type == 0) {
parse_expression();
} else if (return_type == 1) {
// TODO [RZC 04/05/2021] Falta gestionar tipus string
}
}
emmit(OP_RET);
}
// XXX [RZC 27/04/2021] No hi ha labels
/*static void parse_label() {
register_label_address(tkn_get_string());
tkn_next();
}*/
/*
static void parse_call() {
for (int i = 0; i < num_external_functions; i++) {
if (strcmp(external_functions[i].name, tkn_get_string()) == 0) {
if (external_functions[i].num_parameters == -1) {
tkn_next();
EXPECT(TOKEN_STRING, "Expected string");
emmit(OP_PUSH);
emmit(register_string(tkn_get_string()));
} else {
tkn_next();
for (int j = 0; j < external_functions[i].num_parameters; j++) {
//if (j != 0) EXPECT(TOKEN_COMMA, "Expected comma");
parse_expression();
}
}
emmit(OP_CALL);
emmit(i);
}
}
}
*/
static const bool parse_statements() {
bool return_called = false;
while (!parser_finished) {
current_line = tkn_get_line();
switch (tkn_get_token()) {
case TOKEN_CONST:
tkn_next(); parse_const(); break;
case TOKEN_VAR:
tkn_next(); parse_var(); break;
case TOKEN_IF:
tkn_next(); if (parse_if()) { return_called = true; } break;
/*
case TOKEN_FOR:
tkn_next(); parse_for(); break;
case TOKEN_BREAK:
tkn_next(); parse_break(); break;
case TOKEN_CONTINUE:
tkn_next(); parse_continue(); break;
*/
case TOKEN_RETURN:
tkn_next(); parse_return(); return_called = true; break;
case TOKEN_REM:
tkn_next(); break;
/*
case TOKEN_IDENTIFIER:
for (int i = 0; i < num_external_functions; i++) {
if (strcmp(external_functions[i].name, tkn_get_string()) == 0) { parse_call(); break; }
}
parse_let(); break;
*/
default:
return return_called;
}
}
return return_called;
}
static void parse_global_statements() {
while (!parser_finished) {
current_line = tkn_get_line();
switch (tkn_get_token()) {
case TOKEN_CONST:
tkn_next(); if (!global_closed) { parse_const(); } else { HALT("Global constants must be defined before functions"); } break;
case TOKEN_VAR:
tkn_next(); if (!global_closed) { parse_var(); } else { HALT("Global variables must be defined before functions"); } break;
case TOKEN_STRUCT:
tkn_next(); if (!global_closed) { parse_struct(); } else { HALT("Structs must be defined before functions") } break;
case TOKEN_FUNCTION:
tkn_next(); parse_function(); break;
case TOKEN_REM:
tkn_next(); break;
case TOKEN_ENDFILE:
return;
default:
HALT("Syntax error");
return;
}
}
}
// XXX [RZC 27/04/2021] No usat en JailBasic
/*static void include_labels() {
FILE *f = fopen("rom.lbl", "rb");
byte num_labels;
fread(&num_labels, 1, 1, f);
for (int i = 0; i < num_labels; i++) {
word address; fread(&address, 2, 1, f);
byte len; fread(&len, 1, 1, f);
char label[50];
fread(label, len, 1, f);
label[len] = 0;
strcpy(known_labels[num_known_labels].name, label);
known_labels[num_known_labels++].address = address;
}
fclose(f);
}*/
/****************************************************************************************/
/* INTERFACE */
/****************************************************************************************/
void parser_parse(const char* buffer, byte* mem) {
tkn_init(buffer);
scope_init();
types_init();
parser_finished = false;
//include_labels();
code = mem;
codepos = 2; // XXX [RZC 27/04/2021] Perquè 2?
tkn_next();
parse_global_statements();
//append_strings(); // XXX [RZC 27/04/2021] Encara vull açò? si el bytecode no ha de ser independent, no veig que faça falta
if (error_raised()) { // XXX [RZC 27/04/2021] Res, per ara que printf el error i pete
error_print(NULL);
//codepos = 0xA000;
//emmit(OP_JMP);
//emmit_w(0xA000);
} else {
decompiler_save(code, codepos);
}
//FILE *f = fopen("test.bin", "wb");
//fwrite(mem, codepos, 1, f);
//fclose(f);
//return code;
}
//const int parser_get_codesize() { return codepos; }
//const int parser_get_memory_usage() { return num_variables; }
//unsigned short* parser_get_lines() { return lines; }
/*
void parser_register_external_function(const char* name, const char* parameters, void (*fun)(void)) {
strcpy(external_functions[num_external_functions].name, name);
external_functions[num_external_functions++].num_parameters = num_parameters;
}
*/
Reference in New Issue View Git Blame Copy Permalink