rozalang
/
roza
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: rozalang:5b8748b843d082a4fc8ceefa9673979f15b21be4
Branches Tags
rozalang:main
..
compare: rozalang:4f6f3253c251e69aaacb88fcc0290aca5387a037
Branches Tags
rozalang:main

No commits in common. "5b8748b843d082a4fc8ceefa9673979f15b21be4" and "4f6f3253c251e69aaacb88fcc0290aca5387a037" have entirely different histories.
5b8748b843 ... 4f6f3253c2

19 changed files with 31 additions and 394 deletions
Show Stats Expand all files Collapse all files

6
doc/roza.bnf
View File

@ -1,10 +1,8 @@
MOD ::= EXPR*
EXPR ::=
| ASSERT
| OR
| EQNE
ASSERT ::= assert EXPR
OR ::= AND (or AND)*
AND ::= EQNE (and EQNE)*
EQNE ::=
| CMP
| CMP eq CMP
@ -13,6 +11,6 @@ CMP ::= TERM ((lt | le | ge | gt) TERM)?
TERM ::= FACTOR ((add | sub) FACTOR)*
FACTOR ::= POWER ((mul | div | mod) POWER)*
POWER ::= UNARY (pow UNARY)?
UNARY ::= sub? GROUP | not? GROUP
UNARY ::= sub? GROUP
GROUP ::= BUILTIN | opar EXPR cpar
BUILTIN ::= num | bool | str

84
lib/compiler.c
View File

@ -1,6 +1,5 @@
#include "compiler.h"
#include "lib/commons.h"
#include "lib/mod.h"
void compiler_init(compiler_t* compiler, mod_t* mod, tysy_t* tysy, err_t* err)
{
@ -121,17 +120,6 @@ void compiler_run(compiler_t* compiler, node_t* node)
{
op = OP_USUB;
}
else if (node->type == NODE_ADD
&& node_find_first(node, NODE_STR))
{
op = OP_STRCAT;
}
else if (node->type == NODE_MUL
&& node_find_first(node, NODE_STR)
&& node_find_first(node, NODE_NUM))
{
op = OP_STRDUP;
}
else
{
switch (node->type)
@ -150,78 +138,6 @@ void compiler_run(compiler_t* compiler, node_t* node)
} break;
case NODE_AND: {
size_t const SZ = 512;
size_t to_false[SZ];
size_t sz = 0;
for (size_t i=0; i<node->children.size; i++)
{
compiler_run(compiler, node_child(node, i));
size_t addr = mod_push_instr(compiler->mod, OP_BRF, RZ_NO_PARAM);
to_false[sz++] = addr;
}
// True case
value_t* t = tysy_new_bool(compiler->tysy, 1, node->line);
param_t t_param = mod_push_new_value(compiler->mod, t);
mod_push_instr(compiler->mod, OP_PUSH, t_param);
size_t to_end = mod_push_instr(compiler->mod, OP_BR, RZ_NO_PARAM);
// False case
size_t program_sz = compiler->mod->program.size;
for (size_t i=0; i<sz; i++)
{
compiler->mod->program.params[to_false[i]] = program_sz;
}
value_t* f = tysy_new_bool(compiler->tysy, 0, node->line);
param_t f_param = mod_push_new_value(compiler->mod, f);
mod_push_instr(compiler->mod, OP_PUSH, f_param);
compiler->mod->program.params[to_end] = compiler->mod->program.size;
} break;
case NODE_OR: {
size_t const SZ = 512;
size_t to_true[SZ];
size_t sz = 0;
for (size_t i=0; i<node->children.size; i++)
{
compiler_run(compiler, node_child(node, i));
size_t addr = mod_push_instr(compiler->mod, OP_BRT, RZ_NO_PARAM);
to_true[sz++] = addr;
}
// False case
value_t* f = tysy_new_bool(compiler->tysy, 0, node->line);
param_t f_param = mod_push_new_value(compiler->mod, f);
mod_push_instr(compiler->mod, OP_PUSH, f_param);
size_t to_end = mod_push_instr(compiler->mod, OP_BR, RZ_NO_PARAM);
// True case
size_t program_sz = compiler->mod->program.size;
for (size_t i=0; i<sz; i++)
{
compiler->mod->program.params[to_true[i]] = program_sz;
}
value_t* t = tysy_new_bool(compiler->tysy, 1, node->line);
param_t t_param = mod_push_new_value(compiler->mod, t);
mod_push_instr(compiler->mod, OP_PUSH, t_param);
compiler->mod->program.params[to_end] = compiler->mod->program.size;
} break;
case NODE_NOT: {
assert(node->children.size > 0);
compiler_run(compiler, (node_t*) node->children.data[0]);
mod_push_instr(compiler->mod, OP_NOT, RZ_NO_PARAM);
} break;
default: {
fprintf(stderr, "Cannot compile unknown node '%s'",
NodeTypeStr[node->type]);

8
lib/lexer.c
View File

@ -70,9 +70,6 @@ node_t* lexer_try_new_next(lexer_t* lexer)
// Keywords
// ========
RZ_KEYWORD("and", NODE_AND, 0);
RZ_KEYWORD("or", NODE_OR, 0);
RZ_KEYWORD("not", NODE_NOT, 0);
RZ_KEYWORD("true", NODE_BOOL, 1);
RZ_KEYWORD("false", NODE_BOOL, 1);
RZ_KEYWORD("assert", NODE_ASSERT, 0);
@ -351,8 +348,5 @@ int lexer_is_sep(lexer_t* lexer, size_t idx)
|| c == '/'
|| c == '%'
|| c == '^'
|| c == '!'
|| c == '('
|| c == ')'
;
|| c == '!';
}

16
lib/loader.c
View File

@ -63,7 +63,6 @@ int loader_ldfile(loader_t* loader, char const* path, int debug)
parser_init(&parser, &lex, &err);
node_t* node = parser_try_new_tree(&parser);
assert(node);
if (debug)
{
@ -110,13 +109,6 @@ int loader_ldfile(loader_t* loader, char const* path, int debug)
abort();
}
if (debug)
{
char msg[RZ_STR_LIMIT];
mod_str(&mod, msg, RZ_STR_LIMIT);
printf("%s", msg);
}
// execute
{
vm_t vm;
@ -138,12 +130,20 @@ int loader_ldfile(loader_t* loader, char const* path, int debug)
}
if (debug)
{
{
char msg[RZ_STR_LIMIT];
mod_str(&mod, msg, RZ_STR_LIMIT);
printf("%s", msg);
}
{
char msg[RZ_STR_LIMIT];
vm_stack_str(&vm, msg, RZ_STR_LIMIT);
printf("\n======== STACK ========\n");
printf("%s\n", msg);
}
}
vm_free(&vm);
}

4
lib/mod.c
View File

@ -35,7 +35,7 @@ void mod_free(mod_t* mod)
mod->values.cap = 0;
}
size_t mod_push_instr(mod_t* mod, Opcode op, param_t param)
void mod_push_instr(mod_t* mod, Opcode op, param_t param)
{
assert(mod);
@ -58,8 +58,6 @@ size_t mod_push_instr(mod_t* mod, Opcode op, param_t param)
mod->program.ops[mod->program.size] = op;
mod->program.params[mod->program.size] = param;
mod->program.size++;
return mod->program.size - 1;
}
size_t mod_str(mod_t* mod, char* buffer, size_t size)

2
lib/mod.h
View File

@ -23,7 +23,7 @@ typedef struct {
void mod_init(mod_t* mod);
void mod_free(mod_t* mod);
size_t mod_push_instr(mod_t* mod, Opcode op, param_t param);
void mod_push_instr(mod_t* mod, Opcode op, param_t param);
size_t mod_str(mod_t* mod, char* buffer, size_t size);
size_t mod_push_new_value(mod_t* mod, value_t* value);

22
lib/node.c
View File

@ -97,25 +97,3 @@ size_t node_str(node_t* node, char* buffer, size_t size)
return sz;
}
node_t* node_find_first(node_t* node, NodeType type)
{
assert(node);
if (node->type == type)
{
return node;
}
for (size_t i=0; i<node->children.size; i++)
{
node_t* child = node_find_first((node_t*) node->children.data[i], type);
if (child)
{
return child;
}
}
return NULL;
}

4
lib/node.h
View File

@ -10,8 +10,7 @@
G(NODE_EQ), G(NODE_NE), \
G(NODE_LT), G(NODE_LE), G(NODE_GT), G(NODE_GE), \
G(NODE_ADD), G(NODE_SUB), G(NODE_MUL), G(NODE_DIV), \
G(NODE_MODULO), G(NODE_POW), G(NODE_OPAR), G(NODE_CPAR), \
G(NODE_AND), G(NODE_OR), G(NODE_NOT)
G(NODE_MODULO), G(NODE_POW), G(NODE_OPAR), G(NODE_CPAR)
RZ_ENUM_H(NodeType, NODE_TYPE);
@ -34,6 +33,5 @@ void node_add_new_child(node_t* node, node_t* child);
node_t* node_child(node_t* node, size_t index);
size_t node_str(node_t* node, char* buffer, size_t size);
node_t* node_find_first(node_t* node, NodeType type);
#endif

6
lib/opcodes.h
View File

@ -9,11 +9,7 @@
G(OP_EQ), G(OP_NE), \
G(OP_LT), G(OP_LE), G(OP_GT), G(OP_GE), \
G(OP_ADD), G(OP_SUB), G(OP_MUL), G(OP_DIV), \
G(OP_MODULO), G(OP_POW), G(OP_USUB), \
G(OP_AND), G(OP_OR), G(OP_NOT), \
G(OP_BRF), G(OP_BRT), G(OP_BR), \
G(OP_STRCAT), G(OP_STRDUP)
G(OP_MODULO), G(OP_POW), G(OP_USUB)
RZ_ENUM_H(Opcode, OPCODES);

74
lib/parser.c
View File

@ -61,7 +61,7 @@ node_t* parser_try_new_expr(parser_t* parser)
return parser_try_new_assert(parser);
}
return parser_try_new_or(parser);
return parser_try_new_eqne(parser);
}
node_t* parser_try_new_assert(parser_t* parser)
@ -77,52 +77,10 @@ node_t* parser_try_new_assert(parser_t* parser)
return node;
}
node_t* parser_try_new_or(parser_t* parser)
{
assert(parser);
node_t* lhs = parser_try_new_and(parser);
while (1)
{
int next = lexer_peek(parser->lexer, 1);
if (next != NODE_OR) { break; }
node_t* node = parser_try_new_consume(parser, next);
node_add_new_child(node, lhs);
node_add_new_child(node, parser_try_new_and(parser));
lhs = node;
}
return lhs;
}
node_t* parser_try_new_and(parser_t* parser)
{
assert(parser);
node_t* lhs = parser_try_new_eqne(parser);
while (1)
{
int next = lexer_peek(parser->lexer, 1);
if (next != NODE_AND) { break; }
node_t* node = parser_try_new_consume(parser, next);
assert(node);
node_add_new_child(node, lhs);
node_t* eqne = parser_try_new_eqne(parser);
assert(eqne);
node_add_new_child(node, eqne);
lhs = node;
}
return lhs;
}
node_t* parser_try_new_eqne(parser_t* parser)
{
assert(parser);
node_t* lhs = parser_try_new_cmp(parser);
assert(lhs);
while (1)
{
@ -150,7 +108,6 @@ node_t* parser_try_new_cmp(parser_t* parser)
{
assert(parser);
node_t* lhs = parser_try_new_term(parser);
assert(lhs);
int next = lexer_peek(parser->lexer, 1);
@ -173,7 +130,6 @@ node_t* parser_try_new_term(parser_t* parser)
{
assert(parser);
node_t* lhs = parser_try_new_factor(parser);
assert(lhs);
while (1)
{
@ -201,7 +157,6 @@ node_t* parser_try_new_factor(parser_t* parser)
{
assert(parser);
node_t* lhs = parser_try_new_power(parser);
assert(lhs);
while (1)
{
@ -230,7 +185,6 @@ node_t* parser_try_new_power(parser_t* parser)
{
assert(parser);
node_t* lhs = parser_try_new_unary(parser);
assert(lhs);
NodeType next = lexer_peek(parser->lexer, 1);
@ -253,27 +207,11 @@ node_t* parser_try_new_unary(parser_t* parser)
if (next == NODE_SUB)
{
node_t* node = parser_try_new_consume(parser, next);
assert(node);
node_add_new_child(node, parser_try_new_group(parser));
assert(node);
return node;
}
if (next == NODE_NOT)
{
node_t* node = parser_try_new_consume(parser, next);
assert(node);
node_add_new_child(node, parser_try_new_unary(parser));
return node;
}
node_t* group = parser_try_new_group(parser);
assert(group);
return group;
return parser_try_new_group(parser);
}
node_t* parser_try_new_group(parser_t* parser)
@ -285,17 +223,11 @@ node_t* parser_try_new_group(parser_t* parser)
{
lexer_skip_next(parser->lexer);
node_t* node = parser_try_new_expr(parser);
assert(node);
assert(lexer_peek(parser->lexer, 1) == NODE_CPAR);
lexer_skip_next(parser->lexer);
return node;
}
node_t* builtin = parser_try_new_builtin(parser);
assert(builtin);
return builtin;
return parser_try_new_builtin(parser);
}
node_t* parser_try_new_builtin(parser_t* parser)

2
lib/parser.h
View File

@ -17,8 +17,6 @@ node_t* parser_try_new_tree(parser_t* parser);
node_t* parser_try_new_mod(parser_t* parser);
node_t* parser_try_new_expr(parser_t* parser);
node_t* parser_try_new_assert(parser_t* parser);
node_t* parser_try_new_or(parser_t* parser);
node_t* parser_try_new_and(parser_t* parser);
node_t* parser_try_new_eqne(parser_t* parser);
node_t* parser_try_new_cmp(parser_t* parser);
node_t* parser_try_new_term(parser_t* parser);

7
lib/prepass.c
View File

@ -37,12 +37,7 @@ void prepass_run(prepass_t* prepass, node_t* node)
case NODE_MUL:
case NODE_DIV:
case NODE_MODULO:
case NODE_POW:
case NODE_OR:
case NODE_AND:
case NODE_NOT:
{
case NODE_POW:{
for (size_t i=0; i<node->children.size; i++)
{
prepass_run(prepass, (node_t*) node->children.data[i]);

131
lib/vm.c
View File

@ -21,7 +21,7 @@ void vm_free(vm_t* vm)
assert(vm);
}
void vm_push_new_value(vm_t* vm, mod_t* mod, value_t* value)
void vm_push_value(vm_t* vm, mod_t* mod, value_t* value)
{
assert(vm);
assert(value);
@ -146,7 +146,7 @@ int vm_exec_instr(vm_t* vm, mod_t* mod, Opcode op, param_t param)
: (!same_type || !eq)),
rhs->line);
vm_push_new_value(vm, mod, res);
vm_push_value(vm, mod, res);
vm->pc++;
} break;
@ -176,7 +176,7 @@ int vm_exec_instr(vm_t* vm, mod_t* mod, Opcode op, param_t param)
}
value_t* res = tysy_new_bool(vm->tysy, val, lhs->line);
vm_push_new_value(vm, mod, res);
vm_push_value(vm, mod, res);
vm->pc++;
} break;
@ -210,89 +210,7 @@ int vm_exec_instr(vm_t* vm, mod_t* mod, Opcode op, param_t param)
}
value_t* res = tysy_new_num(vm->tysy, val, lhs->line);
vm_push_new_value(vm, mod, res);
vm->pc++;
} break;
case OP_STRCAT: {
int r = vm_pop(vm);
int l = vm_pop(vm);
value_t* lhs = mod->values.data[l];
value_t* rhs = mod->values.data[r];
vm_ensure_type(vm, lhs, TYPE_STR);
vm_ensure_type(vm, rhs, TYPE_STR);
str_t res;
str_init(&res);
str_append(&res, lhs->value.str);
str_append(&res, rhs->value.str);
value_t* value = tysy_new_str(vm->tysy, res.data, lhs->line);
str_free(&res);
vm_push_new_value(vm, mod, value);
vm->pc++;
} break;
case OP_STRDUP: {
int r = vm_pop(vm);
int l = vm_pop(vm);
value_t* lhs = mod->values.data[l];
value_t* rhs = mod->values.data[r];
if (lhs->type->kind != TYPE_NUM)
{
value_t* tmp = lhs;
lhs = rhs;
rhs = tmp;
}
vm_ensure_type(vm, lhs, TYPE_NUM);
vm_ensure_type(vm, rhs, TYPE_STR);
str_t res;
str_init(&res);
for (int i=0; i<(int) lhs->value.num; i++)
{
str_append(&res, rhs->value.str);
}
value_t* value = tysy_new_str(vm->tysy, res.data, lhs->line);
str_free(&res);
vm_push_new_value(vm, mod, value);
vm->pc++;
} break;
case OP_AND:
case OP_OR: {
int r = vm_pop(vm);
int l = vm_pop(vm);
value_t* lhs = mod->values.data[l];
value_t* rhs = mod->values.data[r];
vm_ensure_type(vm, lhs, TYPE_BOOL);
vm_ensure_type(vm, rhs, TYPE_BOOL);
int val = 0;
switch (op)
{
case OP_AND: val = lhs->value.bool && rhs->value.bool; break;
case OP_OR: val = lhs->value.bool || rhs->value.bool; break;
default: assert(0); break;
}
value_t* res = tysy_new_bool(vm->tysy, val, lhs->line);
vm_push_new_value(vm, mod, res);
vm_push_value(vm, mod, res);
vm->pc++;
} break;
@ -307,49 +225,11 @@ int vm_exec_instr(vm_t* vm, mod_t* mod, Opcode op, param_t param)
double val = -lhs->value.num;
value_t* res = tysy_new_num(vm->tysy, val, lhs->line);
vm_push_new_value(vm, mod, res);
vm_push_value(vm, mod, res);
vm->pc++;
} break;
case OP_NOT: {
int l = vm_pop(vm);
value_t* lhs = mod->values.data[l];
vm_ensure_type(vm, lhs, TYPE_BOOL);
int val = !lhs->value.bool;
value_t* res = tysy_new_bool(vm->tysy, val, lhs->line);
vm_push_new_value(vm, mod, res);
vm->pc++;
} break;
case OP_BRT:
case OP_BRF: {
param_t p = vm_pop(vm);
value_t* value = mod->values.data[p];
vm_ensure_type(vm, value, TYPE_BOOL);
if (op == OP_BRT && value->value.bool)
{
vm->pc = param;
}
else if (op == OP_BRF && !value->value.bool)
{
vm->pc = param;
}
else
{
vm->pc++;
}
} break;
case OP_BR: {
vm->pc = param;
} break;
default: {
fprintf(stderr, "Cannot execute unknown opcode '%s'.\n",
OpcodeStr[op]);
@ -376,6 +256,5 @@ void vm_ensure_type(vm_t* vm, value_t* value, TypeKind want)
TypeKindStr[got] + strlen("TYPE_"));
err_fatal(vm->err, msg, line);
err_dump(vm->err);
}
}

2
lib/vm.h
View File

@ -20,7 +20,7 @@ typedef struct {
void vm_init(vm_t* vm, tysy_t* tysy, err_t* err);
void vm_free(vm_t* vm);
void vm_push_new_value(vm_t* vm, mod_t* mod, value_t* value);
void vm_push_value(vm_t* vm, mod_t* mod, value_t* value);
void vm_push(vm_t* vm, param_t param);
param_t vm_pop(vm_t* vm);

16
tests/acceptances/bool.roza
View File

@ -1,16 +0,0 @@
# BOOL ARITHMETIC
# ===============
assert not true == false
assert not false == true
assert false == not true
assert not not true == true
assert not not not false == true
assert (true and true) == true
assert (true and false) == false
assert (false and true) == false
assert (false and false) == false
assert (true or true) == true
assert (true or false) == true
assert (false or true) == true
assert (false or false) == false

4
tests/acceptances/num.roza
View File

@ -1,4 +1,4 @@
# NUM ARITHMETIC
# Num Arithmetic
# ==============
assert 5 + 2 == 7
assert 5 - 2 == 3
@ -9,7 +9,7 @@ assert 12 / 4 == 3
assert 5 / 2 == 2.5
assert 35 % 8 == 3
assert 2^6 == 64
assert -2^3 == -8
assert 1 + 2 * 3 == 7
assert (1 + 2) * 3 == 9
assert 5 == (3 + 2)

14
tests/acceptances/str.roza
View File

@ -1,14 +0,0 @@
# STRING OPERATIONS
# =================
# concatenation with +
assert "hel" + "lo" == "hello"
assert "hello" + " " + "world" == "hello world"
# duplication with *
assert "a" * 3 == "aaa"
assert 4 * "!" == "!!!!"
# bonus
assert ("a" * 2) + "b" == "aab"
assert 4 * ("a" + "b") == "abababab"

7
tests/units/lexer.c
View File

@ -146,10 +146,3 @@ Test(lexer, num_arith) {
"MODULO");
}
Test(lexer, bool_arith) {
test_lexer("and or not", 3,
"AND",
"OR",
"NOT");
}

8
tests/units/parser.c
View File

@ -91,11 +91,3 @@ Test(parser, num_arith) {
test_parser_ok("MOD(DIV(SUB(NUM[1],NUM[2]),NUM[3]))", " (1 - 2) / 3 ");
test_parser_ok("MOD(POW(NUM[2],ADD(NUM[1],NUM[2])))", " 2^(1+2) ");
}
Test(parser, bool_arith) {
test_parser_ok("MOD(OR(AND(BOOL[true],BOOL[false]),NOT(BOOL[true])))",
" true and false or not true ");
test_parser_ok("MOD(ASSERT(AND(BOOL[true],BOOL[false])))",
" assert (true and false) ");
}