samsonium/fz-lang
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

feat: implement conditions

Browse Source
This commit is contained in:
samsonium
2026-10-14 19:56:27 +03:00
parent 4a908f9fd8
commit 83ff0b5774
11 changed files with 731 additions and 25 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/compiler/fzl_debug.c
+25
View File
@@ -63,6 +63,19 @@ void print_node(fzl_node_t *node, int level)
printf("%s Literal '%s'\n", levelbuf, (char *)node->token->value);
break;
case FZL_NODETYPE_CONDITIONAL:
printf("%s Conditional block:\n", levelbuf);
printf("-%s Condition:\n", levelbuf);
print_node(node->cond.condition, level + 2);
printf("-%s True block:\n", levelbuf);
print_node(node->cond.true_block, level + 2);
if (node->cond.else_block)
{
printf("-%s Else block:\n", levelbuf);
print_node(node->cond.else_block, level + 2);
}
break;
case FZL_NODETYPE_BLOCK:
printf("%s Block: ", levelbuf);
@@ -77,6 +90,18 @@ void print_node(fzl_node_t *node, int level)
print_node(node->list.entries[i], level + 1);
break;
case FZL_NODETYPE_NOT:
printf("%s Inverse:\n", levelbuf);
print_node(node->unary_op.operand, level + 1);
break;
case FZL_NODETYPE_EQUAL:
case FZL_NODETYPE_NEQUAL:
case FZL_NODETYPE_LESS:
case FZL_NODETYPE_LESS_EQUAL:
case FZL_NODETYPE_GREATER:
case FZL_NODETYPE_GREATER_EQUAL:
case FZL_NODETYPE_ADD:
case FZL_NODETYPE_SUB:
case FZL_NODETYPE_MUL:
src/compiler/fzl_parser.c
+213 -4
View File
@@ -120,6 +120,8 @@ static fzl_nodetype_t unary_op_to_type(fzl_toktype_t type)
return FZL_NODETYPE_UNARY_PLUS;
case FZL_TOKTYPE_MINUS:
return FZL_NODETYPE_UNARY_MINUS;
case FZL_TOKTYPE_NOT:
return FZL_NODETYPE_NOT;
default:
return 0;
@@ -144,6 +146,11 @@ fzl_node_t *parse_primary(fzl_parser_t *parser)
fzl_token_t *tok = consume(parser);
return fzl_mknode(FZL_NODETYPE_LITERAL, tok);
}
else if (is(parser, FZL_TOKTYPE_BOOL_LITERAL))
{
fzl_token_t *tok = consume(parser);
return fzl_mknode(FZL_NODETYPE_LITERAL, tok);
}
else if (is(parser, FZL_TOKTYPE_LPAREN))
{
consume(parser);
@@ -241,7 +248,8 @@ fzl_node_t *parse_unary(fzl_parser_t *parser)
if (!parser)
return NULL;
if (!is(parser, FZL_TOKTYPE_MINUS) && !is(parser, FZL_TOKTYPE_PLUS))
if (!is(parser, FZL_TOKTYPE_MINUS) && !is(parser, FZL_TOKTYPE_PLUS) &&
!is(parser, FZL_TOKTYPE_NOT))
return parse_postfix(parser);
fzl_token_t *op = consume(parser);
@@ -372,12 +380,131 @@ fzl_node_t *parse_term(fzl_parser_t *parser)
return left;
}
// Expression parsing
fzl_node_t *parse_expression(fzl_parser_t *parser)
// Parse conditional operations
fzl_node_t *parse_cond(fzl_parser_t *parser)
{
return parse_term(parser);
if (!parser)
return NULL;
fzl_node_t *left = parse_term(parser);
fzl_node_t *right = NULL;
if (!left)
return NULL;
while (is(parser, FZL_TOKTYPE_EQEQ) || is(parser, FZL_TOKTYPE_NEQ) ||
is(parser, FZL_TOKTYPE_LANGLE) || is(parser, FZL_TOKTYPE_LEQ) ||
is(parser, FZL_TOKTYPE_RANGLE) || is(parser, FZL_TOKTYPE_REQ))
{
fzl_token_t *op = consume(parser);
right = parse_term(parser);
if (!right)
{
snprintf(plast_err, sizeof(plast_err), "unfinished expression at %ld:%ld",
op->ln, op->cn);
return NULL;
}
fzl_node_t *result;
switch (op->type)
{
case FZL_TOKTYPE_EQEQ:
result = fzl_mknode(FZL_NODETYPE_EQUAL, op);
break;
case FZL_TOKTYPE_NEQ:
result = fzl_mknode(FZL_NODETYPE_NEQUAL, op);
break;
case FZL_TOKTYPE_LANGLE:
result = fzl_mknode(FZL_NODETYPE_LESS, op);
break;
case FZL_TOKTYPE_LEQ:
result = fzl_mknode(FZL_NODETYPE_LESS_EQUAL, op);
break;
case FZL_TOKTYPE_RANGLE:
result = fzl_mknode(FZL_NODETYPE_GREATER, op);
break;
case FZL_TOKTYPE_REQ:
result = fzl_mknode(FZL_NODETYPE_GREATER_EQUAL, op);
break;
default:
return NULL;
}
result->binary_op.left = left;
result->binary_op.right = right;
left = result;
}
return left;
}
// Parse conditional &&
fzl_node_t *parse_and(fzl_parser_t *parser)
{
if (!parser)
return NULL;
fzl_node_t *left = parse_cond(parser);
fzl_node_t *right = NULL;
if (!left)
return NULL;
while (is(parser, FZL_TOKTYPE_DAMPERSAND))
{
fzl_token_t * or = consume(parser);
right = parse_cond(parser);
if (!right)
{
snprintf(plast_err, sizeof(plast_err), "unfinished expression at %ld:%ld",
or->ln, or->cn);
return NULL;
}
fzl_node_t *node = fzl_mknode(FZL_NODETYPE_AND, or);
node->binary_op.left = left;
node->binary_op.right = right;
left = node;
}
return left;
}
// Parse conditional ||
fzl_node_t *parse_or(fzl_parser_t *parser)
{
if (!parser)
return NULL;
fzl_node_t *left = parse_and(parser);
fzl_node_t *right = NULL;
if (!left)
return NULL;
while (is(parser, FZL_TOKTYPE_DVBAR))
{
fzl_token_t * or = consume(parser);
right = parse_and(parser);
if (!right)
{
snprintf(plast_err, sizeof(plast_err), "unfinished expression at %ld:%ld",
or->ln, or->cn);
return NULL;
}
fzl_node_t *node = fzl_mknode(FZL_NODETYPE_OR, or);
node->binary_op.left = left;
node->binary_op.right = right;
left = node;
}
return left;
}
// Expression parsing
fzl_node_t *parse_expression(fzl_parser_t *parser) { return parse_and(parser); }
// Statement parsing
fzl_node_t *parse_statement(fzl_parser_t *parser)
{
@@ -447,6 +574,88 @@ fzl_node_t *parse_statement(fzl_parser_t *parser)
return left;
}
if (is(parser, FZL_TOKTYPE_IF))
{
fzl_token_t *if_tok = consume(parser);
fzl_token_t *lparen = consume(parser);
if (lparen->type != FZL_TOKTYPE_LPAREN)
{
snprintf(plast_err, sizeof(plast_err),
"expected '(' before condition at %ld:%ld", lparen->ln,
lparen->cn);
return NULL;
}
fzl_node_t *condition = parse_expression(parser);
if (!condition)
return NULL;
fzl_token_t *rparen = consume(parser);
if (rparen->type != FZL_TOKTYPE_RPAREN)
{
snprintf(plast_err, sizeof(plast_err),
"expected ')' after condition at %ld:%ld", rparen->ln,
rparen->cn);
return NULL;
}
fzl_node_t *else_block = NULL;
fzl_node_t *true_block = parse_statement(parser);
if (!true_block)
return NULL;
if (is(parser, FZL_TOKTYPE_ELSE))
{
consume(parser); // else
else_block = parse_statement(parser);
if (!else_block)
return NULL;
}
fzl_node_t *stmt_node = fzl_mknode(FZL_NODETYPE_CONDITIONAL, if_tok);
stmt_node->cond.condition = condition;
stmt_node->cond.true_block = true_block;
stmt_node->cond.else_block = else_block;
return stmt_node;
}
if (is(parser, FZL_TOKTYPE_LBRACE))
{
fzl_token_t *block_tok = consume(parser);
size_t remainder = 2;
size_t count = 0;
fzl_node_t **stmts = malloc(remainder * sizeof(fzl_node_t *));
while (peek(parser) && !is(parser, FZL_TOKTYPE_RBRACE))
{
fzl_node_t *node = parse_statement(parser);
if (!node)
return NULL;
if (remainder <= count)
{
remainder *= 2;
stmts = realloc(stmts, remainder);
}
stmts[count++] = node;
}
fzl_token_t *rbrace = consume(parser);
if (!rbrace || rbrace->type != FZL_TOKTYPE_RBRACE)
{
snprintf(plast_err, sizeof(plast_err),
"missing '}' after block at %ld:%ld", rbrace->ln, rbrace->cn);
return NULL;
}
fzl_node_t *node = fzl_mknode(FZL_NODETYPE_BLOCK, block_tok);
node->list.entries = stmts;
node->list.entry_count = count;
return node;
}
return parse_expression(parser);
}
src/compiler/fzl_reader.c
+44 -6
View File
@@ -74,12 +74,19 @@ fzl_token_t *parse_name(fzl_reader_t *reader)
size_t line = reader->line_n;
size_t pos = start - reader->line_start;
if (strcmp(value, "str") == 0 || strcmp(value, "char") == 0 ||
strcmp(value, "uint") == 0 || strcmp(value, "int") == 0 ||
strcmp(value, "i8") == 0 || strcmp(value, "i16") == 0 ||
strcmp(value, "i32") == 0 || strcmp(value, "i64") == 0 ||
strcmp(value, "u8") == 0 || strcmp(value, "u16") == 0 ||
strcmp(value, "u32") == 0 || strcmp(value, "u64") == 0)
if (strcmp(value, "if") == 0)
tok = fzl_mktoken(FZL_TOKTYPE_IF, line, pos, value, size);
else if (strcmp(value, "else") == 0)
tok = fzl_mktoken(FZL_TOKTYPE_ELSE, line, pos, value, size);
else if (strcmp(value, "true") == 0 || strcmp(value, "false") == 0)
tok = fzl_mktoken(FZL_TOKTYPE_BOOL_LITERAL, line, pos, value, size);
else if (strcmp(value, "str") == 0 || strcmp(value, "char") == 0 ||
strcmp(value, "bool") == 0 || strcmp(value, "uint") == 0 ||
strcmp(value, "int") == 0 || strcmp(value, "i8") == 0 ||
strcmp(value, "i16") == 0 || strcmp(value, "i32") == 0 ||
strcmp(value, "i64") == 0 || strcmp(value, "u8") == 0 ||
strcmp(value, "u16") == 0 || strcmp(value, "u32") == 0 ||
strcmp(value, "u64") == 0)
tok = fzl_mktoken(FZL_TOKTYPE_TYPE, line, pos, value, size);
else
tok = fzl_mktoken(FZL_TOKTYPE_NAME, line, pos, value, size);
@@ -175,6 +182,13 @@ fzl_token_t *add_single(fzl_reader_t *reader, fzl_toktype_t type)
return fzl_mktoken(type, reader->line_n, p - reader->line_start, NULL, 0);
}
// Add double-char token
fzl_token_t *add_double(fzl_reader_t *reader, fzl_toktype_t type)
{
size_t p = move(reader, 2);
return fzl_mktoken(type, reader->line_n, p - reader->line_start, NULL, 0);
}
int fzl_read(fzl_reader_t *reader)
{
if (reader->position >= reader->size)
@@ -194,6 +208,30 @@ int fzl_read(fzl_reader_t *reader)
if (curr == '\'' || curr == '"')
token = parse_string_literal(reader);
else if (curr == '=' && reader->source[p + 1] == '=')
token = add_double(reader, FZL_TOKTYPE_EQEQ);
else if (curr == '>' && reader->source[p + 1] == '=')
token = add_double(reader, FZL_TOKTYPE_REQ);
else if (curr == '<' && reader->source[p + 1] == '=')
token = add_double(reader, FZL_TOKTYPE_LEQ);
else if (curr == '!' && reader->source[p + 1] == '=')
token = add_double(reader, FZL_TOKTYPE_NEQ);
else if (curr == '|' && reader->source[p + 1] == '|')
token = add_double(reader, FZL_TOKTYPE_DVBAR);
else if (curr == '&' && reader->source[p + 1] == '&')
token = add_double(reader, FZL_TOKTYPE_DAMPERSAND);
else if (curr == '>')
token = add_single(reader, FZL_TOKTYPE_RANGLE);
else if (curr == '<')
token = add_single(reader, FZL_TOKTYPE_LANGLE);
else if (curr == '!')
token = add_single(reader, FZL_TOKTYPE_NOT);
else if (curr == ';')
token = add_single(reader, FZL_TOKTYPE_SEMICOLON);
else if (curr == '{')
token = add_single(reader, FZL_TOKTYPE_LBRACE);
else if (curr == '}')
token = add_single(reader, FZL_TOKTYPE_RBRACE);
else if (curr == '(')
token = add_single(reader, FZL_TOKTYPE_LPAREN);
else if (curr == ')')
src/compiler/fzl_walker.c
+156 -1
View File
@@ -13,6 +13,9 @@
#include <stdlib.h>
#include <string.h>
// TODO: implement backpatching struct for jumping on if/else blocks
// TODO: implement conditional binops; conditions
char wlast_err[256];
fzl_walker_t *fzl_mkwalker(fzl_node_t *root)
@@ -52,6 +55,9 @@ fzl_walker_t *fzl_mkwalker(fzl_node_t *root)
return NULL;
}
memset(walker->bp_table, 0, sizeof(walker->bp_table));
walker->bp_top = 0;
return walker;
}
@@ -152,8 +158,139 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
{
switch (node->type)
{
case FZL_NODETYPE_UNARY_PLUS:
case FZL_NODETYPE_NOT:
{
fzl_walk_res_t res = walk(walker, node->unary_op.operand);
if (res.error)
return res;
push_op(walker, FZL_OPCODE_NOT);
current_res = (fzl_walk_res_t){.type = FZL_TYPE_BOOL, .error = false};
break;
}
case FZL_NODETYPE_EQUAL:
case FZL_NODETYPE_NEQUAL:
case FZL_NODETYPE_LESS:
case FZL_NODETYPE_LESS_EQUAL:
case FZL_NODETYPE_GREATER:
case FZL_NODETYPE_GREATER_EQUAL:
{
fzl_walk_res_t left = walk(walker, node->binary_op.left);
if (left.error)
return left;
fzl_walk_res_t right = walk(walker, node->binary_op.right);
if (right.error)
return right;
if (!is_compatible(left.type, right.type))
{
snprintf(wlast_err, sizeof(wlast_err),
"incompatible types at %ld:%ld", node->token->ln,
node->token->cn);
return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
}
switch (node->type)
{
case FZL_NODETYPE_EQUAL:
push_op(walker, FZL_OPCODE_CMP_EQ);
break;
case FZL_NODETYPE_NEQUAL:
push_op(walker, FZL_OPCODE_CMP_NEQ);
break;
case FZL_NODETYPE_LESS:
push_op(walker, FZL_OPCODE_CMP_LT);
break;
case FZL_NODETYPE_LESS_EQUAL:
push_op(walker, FZL_OPCODE_CMP_LTEQ);
break;
case FZL_NODETYPE_GREATER:
push_op(walker, FZL_OPCODE_CMP_GT);
break;
case FZL_NODETYPE_GREATER_EQUAL:
push_op(walker, FZL_OPCODE_CMP_GTEQ);
break;
default:
break;
}
current_res = (fzl_walk_res_t){.type = left.type, .error = false};
break;
}
case FZL_NODETYPE_OR:
case FZL_NODETYPE_AND:
{
fzl_walk_res_t left = walk(walker, node->binary_op.left);
if (left.error)
return left;
fzl_walk_res_t right = walk(walker, node->binary_op.right);
if (right.error)
return right;
if (!is_compatible(left.type, right.type))
{
snprintf(wlast_err, sizeof(wlast_err),
"incompatible types at %ld:%ld", node->token->ln,
node->token->cn);
return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
}
if (node->type == FZL_NODETYPE_AND)
push_op(walker, FZL_OPCODE_AND);
else
push_op(walker, FZL_OPCODE_OR);
current_res = (fzl_walk_res_t){.type = left.type, .error = false};
break;
}
case FZL_NODETYPE_CONDITIONAL:
{
fzl_walk_res_t cres = walk(walker, node->cond.condition);
if (cres.error)
return cres;
push_op(walker, FZL_OPCODE_JZ);
size_t jz_if = walker->op_count;
push_word(walker, (uint64_t)0);
fzl_walk_res_t tblock_res = walk(walker, node->cond.true_block);
if (tblock_res.error)
return tblock_res;
push_op(walker, FZL_OPCODE_JMP);
size_t jmp_else = walker->op_count;
push_word(walker, (uint64_t)0);
walker->ops[jz_if] = walker->op_count;
if (node->cond.else_block)
{
fzl_walk_res_t fblock_res = walk(walker, node->cond.else_block);
if (fblock_res.error)
return fblock_res;
}
walker->ops[jmp_else] = walker->op_count;
current_res = (fzl_walk_res_t){.type = FZL_TYPE_NULL, .error = false};
break;
}
case FZL_NODETYPE_UNARY_PLUS:
{
fzl_walk_res_t res = walk(walker, node->unary_op.operand);
if (res.error)
return res;
current_res = res;
break;
}
case FZL_NODETYPE_IDENTIFIER:
{
@@ -248,6 +385,15 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
push_word(walker, num);
current_res = (fzl_walk_res_t){.type = FZL_TYPE_INT, .error = false};
}
else if (node->token->type == FZL_TOKTYPE_BOOL_LITERAL)
{
fzl_token_t *tok = node->token;
uint64_t val = strcmp(tok->value, "true") == 0 ? 1 : 0;
push_op(walker, FZL_OPCODE_PUSHBOOL);
push_word(walker, val);
current_res = (fzl_walk_res_t){.type = FZL_TYPE_BOOL, .error = false};
}
break;
case FZL_NODETYPE_ADD:
@@ -423,6 +569,12 @@ int fzl_walk(fzl_walker_t *walker)
fzl_walk_res_t result = walk(walker, walker->root);
push_op(walker, FZL_OPCODE_RM_ENVTABLE);
if (walker->bp_top > 0)
{
snprintf(wlast_err, sizeof(wlast_err), "unfinished conditional block");
return -1;
}
if (result.error && !wlast_err[0])
snprintf(wlast_err, sizeof(wlast_err), "%s", result.error_msg);
@@ -443,5 +595,8 @@ void fzl_freewalker(fzl_walker_t *walker)
if (walker->ops)
free(walker->ops);
while (walker->sym_top > 0)
fzl_freesymt(walker->syms[--walker->sym_top]);
free(walker);
}