1518 lines
37 KiB
C
1518 lines
37 KiB
C
#include <compiler/fzl_parser.h>
|
|
#include <compiler/fzl_token.h>
|
|
#include <stdbool.h>
|
|
#include <stddef.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
char plast_err[256];
|
|
fzl_token_t *last_known_tok = NULL;
|
|
|
|
fzl_token_t null_tok = {
|
|
.type = FZL_TOKTYPE_TYPE,
|
|
.filename = "",
|
|
.ln = 0,
|
|
.cn = 0,
|
|
.store_value = false,
|
|
.value = "null",
|
|
.value_sz = 4,
|
|
};
|
|
|
|
fzl_token_t this_tok = {.type = FZL_TOKTYPE_NAME,
|
|
.filename = "",
|
|
.ln = 0,
|
|
.cn = 0,
|
|
.store_value = false,
|
|
.value = "this",
|
|
.value_sz = 4};
|
|
|
|
fzl_parser_t *fzl_mkparser(fzl_reader_ll_t *first)
|
|
{
|
|
if (!first)
|
|
return NULL;
|
|
|
|
fzl_parser_t *parser = malloc(sizeof(fzl_parser_t));
|
|
if (!parser)
|
|
return NULL;
|
|
|
|
parser->root = NULL;
|
|
parser->cursor = first->next;
|
|
if (!parser->cursor)
|
|
return NULL;
|
|
|
|
return parser;
|
|
}
|
|
|
|
// --- Parse zone ---
|
|
|
|
// Make a new node
|
|
fzl_node_t *fzl_mknode(fzl_nodetype_t type, fzl_token_t *token)
|
|
{
|
|
fzl_node_t *node = malloc(sizeof(fzl_node_t));
|
|
memset(node, 0, sizeof(fzl_node_t));
|
|
|
|
if (!node)
|
|
return NULL;
|
|
node->type = type;
|
|
node->token = token;
|
|
node->parent = NULL;
|
|
node->next = NULL;
|
|
|
|
return node;
|
|
}
|
|
|
|
// Get token at cursor
|
|
static fzl_token_t *peek(fzl_parser_t *parser)
|
|
{
|
|
if (!parser || !parser->cursor)
|
|
return NULL;
|
|
|
|
last_known_tok = parser->cursor->token;
|
|
return parser->cursor->token;
|
|
}
|
|
|
|
// Consume token at cursor and move to the next
|
|
static fzl_token_t *consume(fzl_parser_t *parser)
|
|
{
|
|
if (!parser || !parser->cursor || !parser->cursor->token)
|
|
return NULL;
|
|
|
|
fzl_token_t *tok = parser->cursor->token;
|
|
parser->cursor = parser->cursor->next;
|
|
return tok;
|
|
}
|
|
|
|
// Check if current token have the same type as specified
|
|
static bool is(fzl_parser_t *parser, fzl_toktype_t type)
|
|
{
|
|
if (!parser)
|
|
return false;
|
|
|
|
fzl_token_t *tok = peek(parser);
|
|
if (!tok)
|
|
return false;
|
|
|
|
return tok->type == type;
|
|
}
|
|
|
|
// Convert arithmetic operator token type to node type
|
|
static fzl_nodetype_t math_op_to_type(fzl_toktype_t type)
|
|
{
|
|
switch (type)
|
|
{
|
|
case FZL_TOKTYPE_PLUS:
|
|
return FZL_NODETYPE_ADD;
|
|
case FZL_TOKTYPE_MINUS:
|
|
return FZL_NODETYPE_SUB;
|
|
case FZL_TOKTYPE_STAR:
|
|
return FZL_NODETYPE_MUL;
|
|
case FZL_TOKTYPE_SLASH:
|
|
return FZL_NODETYPE_DIV;
|
|
case FZL_TOKTYPE_CARET:
|
|
return FZL_NODETYPE_POW;
|
|
case FZL_TOKTYPE_PERCENT:
|
|
return FZL_NODETYPE_MOD;
|
|
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
static fzl_nodetype_t unary_op_to_type(fzl_toktype_t type)
|
|
{
|
|
switch (type)
|
|
{
|
|
case FZL_TOKTYPE_PLUS:
|
|
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;
|
|
}
|
|
}
|
|
|
|
fzl_node_t *parse_expression(fzl_parser_t *parser);
|
|
|
|
// Parse primary
|
|
fzl_node_t *parse_primary(fzl_parser_t *parser)
|
|
{
|
|
if (!parser || !peek(parser))
|
|
return NULL;
|
|
|
|
if (is(parser, FZL_TOKTYPE_STR_LITERAL) ||
|
|
is(parser, FZL_TOKTYPE_NUM_LITERAL) ||
|
|
is(parser, FZL_TOKTYPE_BOOL_LITERAL) ||
|
|
is(parser, FZL_TOKTYPE_NULL_LITERAL))
|
|
{
|
|
fzl_token_t *tok = consume(parser);
|
|
return fzl_mknode(FZL_NODETYPE_LITERAL, tok);
|
|
}
|
|
else if (is(parser, FZL_TOKTYPE_STR_FORMAT_START))
|
|
{
|
|
consume(parser);
|
|
|
|
size_t remainder = 2;
|
|
size_t count = 0;
|
|
fzl_node_t **entries = malloc(remainder * sizeof(fzl_node_t *));
|
|
if (!entries)
|
|
{
|
|
snprintf(plast_err, sizeof(plast_err), "out of memory");
|
|
return NULL;
|
|
}
|
|
|
|
while (peek(parser) && peek(parser)->type != FZL_TOKTYPE_STR_FORMAT_END)
|
|
{
|
|
if (is(parser, FZL_TOKTYPE_STR_FORMAT_END))
|
|
break;
|
|
|
|
if (remainder <= count)
|
|
{
|
|
remainder *= 2;
|
|
fzl_node_t **newentries =
|
|
realloc(entries, remainder * sizeof(fzl_node_t *));
|
|
if (!newentries)
|
|
{
|
|
snprintf(plast_err, sizeof(plast_err), "out of memory");
|
|
for (size_t i = 0; i < count; i++)
|
|
fzl_freeast(entries[i]);
|
|
|
|
free(entries);
|
|
return NULL;
|
|
}
|
|
|
|
entries = newentries;
|
|
}
|
|
|
|
fzl_node_t *expr = parse_expression(parser);
|
|
if (expr == NULL)
|
|
{
|
|
for (size_t i = 0; i < count; i++)
|
|
fzl_freeast(entries[i]);
|
|
|
|
free(entries);
|
|
return NULL;
|
|
}
|
|
|
|
entries[count++] = expr;
|
|
}
|
|
|
|
fzl_token_t *end = consume(parser);
|
|
if (end->type != FZL_TOKTYPE_STR_FORMAT_END)
|
|
{
|
|
snprintf(plast_err, sizeof(plast_err),
|
|
"'%s':%zu:%zu => unterminated format string",
|
|
last_known_tok->filename, last_known_tok->ln,
|
|
last_known_tok->cn);
|
|
|
|
for (size_t i = 0; i < count; i++)
|
|
fzl_freeast(entries[i]);
|
|
|
|
free(entries);
|
|
}
|
|
|
|
if (count < 1)
|
|
{
|
|
snprintf(plast_err, sizeof(plast_err),
|
|
"'%s':%zu:%zu => do you really need empty format string?",
|
|
last_known_tok->filename, last_known_tok->ln,
|
|
last_known_tok->cn);
|
|
|
|
for (size_t i = 0; i < count; i++)
|
|
fzl_freeast(entries[i]);
|
|
|
|
free(entries);
|
|
return NULL;
|
|
}
|
|
|
|
fzl_node_t *node = fzl_mknode(FZL_NODETYPE_FMT_STRING, entries[0]->token);
|
|
if (!node)
|
|
{
|
|
snprintf(plast_err, sizeof(plast_err), "out of memory");
|
|
for (size_t i = 0; i < count; i++)
|
|
fzl_freeast(entries[i]);
|
|
|
|
free(entries);
|
|
return NULL;
|
|
}
|
|
|
|
node->list.entries = entries;
|
|
node->list.entry_count = count;
|
|
|
|
return node;
|
|
}
|
|
else if (is(parser, FZL_TOKTYPE_LPAREN))
|
|
{
|
|
consume(parser);
|
|
fzl_node_t *node = parse_expression(parser);
|
|
if (!is(parser, FZL_TOKTYPE_RPAREN))
|
|
{
|
|
snprintf(plast_err, sizeof(plast_err), "'%s': expected ')' at %ld:%ld",
|
|
last_known_tok->filename, last_known_tok->ln,
|
|
last_known_tok->cn);
|
|
fzl_freeast(node);
|
|
return NULL;
|
|
}
|
|
consume(parser);
|
|
return node;
|
|
}
|
|
else if (is(parser, FZL_TOKTYPE_NAME))
|
|
{
|
|
fzl_token_t *name = consume(parser);
|
|
if (!is(parser, FZL_TOKTYPE_NAME))
|
|
return fzl_mknode(FZL_NODETYPE_IDENTIFIER, name);
|
|
|
|
fzl_token_t *realname = consume(parser); // :D
|
|
fzl_node_t *decl = fzl_mknode(FZL_NODETYPE_DECLARATION, name);
|
|
decl->var.type = name;
|
|
decl->var.identifier = fzl_mknode(FZL_NODETYPE_IDENTIFIER, realname);
|
|
return decl;
|
|
}
|
|
else if (is(parser, FZL_TOKTYPE_TYPE))
|
|
{
|
|
fzl_token_t *type = consume(parser);
|
|
fzl_token_t *name = consume(parser);
|
|
if (!name || name->type != FZL_TOKTYPE_NAME)
|
|
{
|
|
snprintf(plast_err, sizeof(plast_err),
|
|
"'%s': expected name after type at %ld:%ld",
|
|
last_known_tok->filename, last_known_tok->ln,
|
|
last_known_tok->cn);
|
|
return NULL;
|
|
}
|
|
|
|
fzl_node_t *decl = fzl_mknode(FZL_NODETYPE_DECLARATION, type);
|
|
decl->var.type = type;
|
|
decl->var.identifier = fzl_mknode(FZL_NODETYPE_IDENTIFIER, name);
|
|
return decl;
|
|
}
|
|
|
|
if (!plast_err[0])
|
|
snprintf(plast_err, sizeof(plast_err),
|
|
"'%s': expected expression at %ld:%ld", last_known_tok->filename,
|
|
last_known_tok->ln, last_known_tok->cn);
|
|
return NULL;
|
|
}
|
|
|
|
// Parse postfix expressions (parens, index access, dots)
|
|
fzl_node_t *parse_postfix(fzl_parser_t *parser)
|
|
{
|
|
if (!parser)
|
|
return NULL;
|
|
|
|
fzl_node_t *left = parse_primary(parser);
|
|
|
|
if (!left)
|
|
return NULL;
|
|
|
|
if (is(parser, FZL_TOKTYPE_LPAREN) || is(parser, FZL_TOKTYPE_DOT))
|
|
{
|
|
while (is(parser, FZL_TOKTYPE_LPAREN) || is(parser, FZL_TOKTYPE_DOT))
|
|
{
|
|
fzl_token_t *post = consume(parser);
|
|
|
|
if (post->type == FZL_TOKTYPE_LPAREN)
|
|
{
|
|
size_t args_capacity = 2;
|
|
size_t args_count = 0;
|
|
fzl_node_t **args = malloc(args_capacity * sizeof(fzl_node_t *));
|
|
|
|
while (!is(parser, FZL_TOKTYPE_RPAREN))
|
|
{
|
|
fzl_node_t *arg = parse_expression(parser);
|
|
if (!arg)
|
|
{
|
|
for (size_t i = 0; i < args_count; i++)
|
|
fzl_freeast(args[i]);
|
|
free(args);
|
|
fzl_freeast(left);
|
|
return NULL;
|
|
}
|
|
|
|
if (args_capacity <= args_count)
|
|
{
|
|
args_capacity *= 2;
|
|
args = realloc(args, args_capacity * sizeof(fzl_node_t *));
|
|
}
|
|
|
|
args[args_count] = arg;
|
|
args_count++;
|
|
|
|
if (is(parser, FZL_TOKTYPE_COMMA))
|
|
consume(parser);
|
|
}
|
|
|
|
fzl_token_t *rparen = consume(parser);
|
|
if (!rparen || rparen->type != FZL_TOKTYPE_RPAREN)
|
|
{
|
|
for (size_t i = 0; i < args_count; i++)
|
|
fzl_freeast(args[i]);
|
|
free(args);
|
|
fzl_freeast(left);
|
|
snprintf(plast_err, sizeof(plast_err),
|
|
"'%s': expected ')' after argument list at %ld:%ld",
|
|
last_known_tok->filename, last_known_tok->ln,
|
|
last_known_tok->cn);
|
|
return NULL;
|
|
}
|
|
|
|
fzl_node_t *node = fzl_mknode(FZL_NODETYPE_CALL, left->token);
|
|
node->call.callee = left;
|
|
node->call.args = args;
|
|
node->call.args_count = args_count;
|
|
|
|
left = node;
|
|
}
|
|
else if (post->type == FZL_TOKTYPE_DOT)
|
|
{
|
|
if (!is(parser, FZL_TOKTYPE_NAME))
|
|
{
|
|
fzl_freeast(left);
|
|
snprintf(plast_err, sizeof(plast_err),
|
|
"'%s': expected name after '.' at %ld:%ld",
|
|
last_known_tok->filename, last_known_tok->ln,
|
|
last_known_tok->cn);
|
|
return NULL;
|
|
}
|
|
|
|
fzl_token_t *name = consume(parser);
|
|
fzl_node_t *node = fzl_mknode(FZL_NODETYPE_FIELD, name);
|
|
node->memb.parent = left;
|
|
node->memb.field = fzl_mknode(FZL_NODETYPE_IDENTIFIER, name);
|
|
|
|
left = node;
|
|
}
|
|
}
|
|
}
|
|
|
|
return left;
|
|
}
|
|
|
|
// Parse unary operations
|
|
fzl_node_t *parse_unary(fzl_parser_t *parser)
|
|
{
|
|
if (!parser)
|
|
return NULL;
|
|
|
|
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);
|
|
fzl_node_t *operand = parse_unary(parser);
|
|
|
|
if (!operand)
|
|
return NULL;
|
|
|
|
fzl_node_t *result = fzl_mknode(unary_op_to_type(op->type), op);
|
|
result->unary_op.operand = operand;
|
|
|
|
return result;
|
|
}
|
|
|
|
fzl_node_t *parse_power(fzl_parser_t *parser)
|
|
{
|
|
if (!parser)
|
|
return NULL;
|
|
|
|
fzl_node_t *left = parse_unary(parser);
|
|
fzl_node_t *right = NULL;
|
|
|
|
if (!left)
|
|
return NULL;
|
|
|
|
if (is(parser, FZL_TOKTYPE_CARET))
|
|
{
|
|
fzl_token_t *caret = consume(parser);
|
|
|
|
right = parse_unary(parser);
|
|
if (!right)
|
|
{
|
|
fzl_freeast(left);
|
|
if (!plast_err[0])
|
|
snprintf(plast_err, sizeof(plast_err),
|
|
"'%s': expected expression at %ld:%ld",
|
|
last_known_tok->filename, last_known_tok->ln,
|
|
last_known_tok->cn);
|
|
return NULL;
|
|
}
|
|
|
|
fzl_node_t *node = fzl_mknode(FZL_NODETYPE_POW, caret);
|
|
node->binary_op.left = left;
|
|
node->binary_op.right = right;
|
|
|
|
left = node;
|
|
}
|
|
|
|
return left;
|
|
}
|
|
|
|
// Parse FACTOR: multiplication and division
|
|
fzl_node_t *parse_factor(fzl_parser_t *parser)
|
|
{
|
|
if (!parser)
|
|
return NULL;
|
|
|
|
fzl_node_t *left = parse_power(parser);
|
|
fzl_node_t *right = NULL;
|
|
|
|
if (!left)
|
|
return NULL;
|
|
|
|
while (is(parser, FZL_TOKTYPE_STAR) || is(parser, FZL_TOKTYPE_SLASH) ||
|
|
is(parser, FZL_TOKTYPE_PERCENT))
|
|
{
|
|
fzl_token_t *op = consume(parser);
|
|
|
|
right = parse_factor(parser);
|
|
if (!right)
|
|
{
|
|
fzl_freeast(left);
|
|
if (!plast_err[0])
|
|
snprintf(plast_err, sizeof(plast_err),
|
|
"'%s': expected expression at %ld:%ld",
|
|
last_known_tok->filename, last_known_tok->ln,
|
|
last_known_tok->cn);
|
|
return NULL;
|
|
}
|
|
|
|
fzl_node_t *node = fzl_mknode(math_op_to_type(op->type), op);
|
|
node->binary_op.left = left;
|
|
node->binary_op.right = right;
|
|
left = node;
|
|
}
|
|
|
|
return left;
|
|
}
|
|
|
|
// Parse TERM: addition and subtraction
|
|
fzl_node_t *parse_term(fzl_parser_t *parser)
|
|
{
|
|
if (!parser)
|
|
return NULL;
|
|
|
|
fzl_node_t *left = parse_factor(parser);
|
|
fzl_node_t *right = NULL;
|
|
|
|
if (!left)
|
|
return NULL;
|
|
|
|
while (is(parser, FZL_TOKTYPE_PLUS) || is(parser, FZL_TOKTYPE_MINUS))
|
|
{
|
|
fzl_token_t *op = consume(parser);
|
|
|
|
right = parse_factor(parser);
|
|
if (!right)
|
|
{
|
|
fzl_freeast(left);
|
|
if (!plast_err[0])
|
|
snprintf(plast_err, sizeof(plast_err),
|
|
"'%s': expected expression at %ld:%ld",
|
|
last_known_tok->filename, last_known_tok->ln,
|
|
last_known_tok->cn);
|
|
return NULL;
|
|
}
|
|
|
|
fzl_node_t *node = fzl_mknode(math_op_to_type(op->type), op);
|
|
node->binary_op.left = left;
|
|
node->binary_op.right = right;
|
|
left = node;
|
|
}
|
|
|
|
return left;
|
|
}
|
|
|
|
// Parse conditional operations
|
|
fzl_node_t *parse_cond(fzl_parser_t *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)
|
|
{
|
|
fzl_freeast(left);
|
|
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)
|
|
{
|
|
fzl_freeast(left);
|
|
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)
|
|
{
|
|
fzl_freeast(left);
|
|
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;
|
|
}
|
|
|
|
// Object construct parsing
|
|
fzl_node_t *parse_new(fzl_parser_t *parser)
|
|
{
|
|
if (!is(parser, FZL_TOKTYPE_NEW))
|
|
return parse_or(parser);
|
|
|
|
fzl_token_t *new = consume(parser);
|
|
fzl_node_t *objname = parse_or(parser);
|
|
if (!objname || (objname->type != FZL_NODETYPE_IDENTIFIER &&
|
|
objname->type != FZL_NODETYPE_FIELD))
|
|
{
|
|
fzl_freeast(objname);
|
|
snprintf(plast_err, sizeof(plast_err),
|
|
"'%s': expected class name after 'new' keyword at %ld:%ld",
|
|
last_known_tok->filename, last_known_tok->ln, last_known_tok->cn);
|
|
return NULL;
|
|
}
|
|
|
|
fzl_node_t *node = fzl_mknode(FZL_NODETYPE_CONSTRUCT, new);
|
|
node->construct.name = objname;
|
|
|
|
return node;
|
|
}
|
|
|
|
// Assignments parsing
|
|
fzl_node_t *parse_assignment(fzl_parser_t *parser)
|
|
{
|
|
fzl_node_t *left = parse_new(parser);
|
|
if (!left)
|
|
return NULL;
|
|
|
|
if (is(parser, FZL_TOKTYPE_EQ))
|
|
{
|
|
fzl_token_t *asn = consume(parser);
|
|
if (!left || (left->type != FZL_NODETYPE_IDENTIFIER &&
|
|
left->type != FZL_NODETYPE_DECLARATION &&
|
|
left->type != FZL_NODETYPE_FIELD))
|
|
{
|
|
fzl_freeast(left);
|
|
snprintf(plast_err, sizeof(plast_err),
|
|
"'%s': cannot assign to '%s' at %ld:%ld",
|
|
last_known_tok->filename, (char *)left->token->value,
|
|
last_known_tok->ln, last_known_tok->cn);
|
|
return NULL;
|
|
}
|
|
|
|
fzl_node_t *right = parse_assignment(parser);
|
|
if (!right)
|
|
{
|
|
fzl_freeast(left);
|
|
return NULL;
|
|
}
|
|
|
|
fzl_node_t *node = fzl_mknode(FZL_NODETYPE_ASSIGN, asn);
|
|
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_assignment(parser);
|
|
}
|
|
|
|
fzl_node_t *parse_statement(fzl_parser_t *parser);
|
|
|
|
// Parse class definition
|
|
fzl_node_t *parse_class(fzl_parser_t *parser)
|
|
{
|
|
if (!parser)
|
|
return NULL;
|
|
|
|
fzl_token_t *class = consume(parser);
|
|
fzl_token_t *name = consume(parser);
|
|
if (!name || name->type != FZL_TOKTYPE_NAME)
|
|
{
|
|
snprintf(plast_err, sizeof(plast_err),
|
|
"'%s': expected class name at %ld:%ld", last_known_tok->filename,
|
|
last_known_tok->ln, last_known_tok->cn);
|
|
return NULL;
|
|
}
|
|
|
|
fzl_token_t *lbrace = consume(parser);
|
|
if (!lbrace || lbrace->type != FZL_TOKTYPE_LBRACE)
|
|
{
|
|
snprintf(plast_err, sizeof(plast_err),
|
|
"'%s': expected '{' after class name at %ld:%ld",
|
|
last_known_tok->filename, last_known_tok->ln, last_known_tok->cn);
|
|
return NULL;
|
|
}
|
|
|
|
size_t fremainder = 2;
|
|
size_t fcount = 0;
|
|
fzl_node_t **fields = malloc(fremainder * sizeof(fzl_node_t *));
|
|
if (!fields)
|
|
{
|
|
snprintf(plast_err, sizeof(plast_err),
|
|
"failed to allocate space for class fields");
|
|
return NULL;
|
|
}
|
|
|
|
size_t mremainder = 2;
|
|
size_t mcount = 0;
|
|
fzl_node_t **methods = malloc(mremainder * sizeof(fzl_node_t *));
|
|
if (!methods)
|
|
{
|
|
snprintf(plast_err, sizeof(plast_err),
|
|
"failed to allocate space for class fields");
|
|
free(fields);
|
|
return NULL;
|
|
}
|
|
|
|
while (!is(parser, FZL_TOKTYPE_RBRACE))
|
|
{
|
|
fzl_node_t *node = parse_statement(parser);
|
|
if (!node)
|
|
return NULL;
|
|
|
|
if (node->type == FZL_NODETYPE_DECLARATION)
|
|
{
|
|
if (fremainder <= fcount)
|
|
{
|
|
fremainder *= 2;
|
|
fields = realloc(fields, fremainder * sizeof(fzl_node_t *));
|
|
if (!fields)
|
|
{
|
|
snprintf(plast_err, sizeof(plast_err),
|
|
"failed to resize fields array");
|
|
fzl_freeast(node);
|
|
free(methods);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
fields[fcount++] = node;
|
|
}
|
|
else if (node->type == FZL_NODETYPE_FUNCTION)
|
|
{
|
|
if (mremainder <= mcount)
|
|
{
|
|
mremainder *= 2;
|
|
methods = realloc(methods, mremainder * sizeof(fzl_node_t *));
|
|
if (!methods)
|
|
{
|
|
snprintf(plast_err, sizeof(plast_err),
|
|
"failed to resize methods array");
|
|
fzl_freeast(node);
|
|
free(fields);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
fzl_node_t **new_args = realloc(node->fn.args, (++node->fn.args_count) *
|
|
sizeof(fzl_node_t *));
|
|
if (!new_args)
|
|
{
|
|
snprintf(plast_err, sizeof(plast_err),
|
|
"failed to reallocate method args list");
|
|
free(fields);
|
|
fzl_freeast(node);
|
|
return NULL;
|
|
}
|
|
|
|
if (node->fn.args_count > 1)
|
|
memmove(&new_args[1], new_args,
|
|
(node->fn.args_count - 1) * sizeof(fzl_node_t *));
|
|
|
|
fzl_node_t *this_id = fzl_mknode(FZL_NODETYPE_IDENTIFIER, &this_tok);
|
|
fzl_node_t *this_dec = fzl_mknode(FZL_NODETYPE_DECLARATION, name);
|
|
this_dec->var.type = name;
|
|
this_dec->var.identifier = this_id;
|
|
|
|
new_args[0] = this_dec;
|
|
node->fn.args = new_args;
|
|
methods[mcount++] = node;
|
|
}
|
|
else
|
|
{
|
|
fzl_freeast(node);
|
|
snprintf(plast_err, sizeof(plast_err),
|
|
"'%s': unknown type of class member at %ld:%ld",
|
|
last_known_tok->filename, last_known_tok->ln,
|
|
last_known_tok->cn);
|
|
free(fields);
|
|
free(methods);
|
|
return NULL;
|
|
}
|
|
}
|
|
fzl_token_t *rbra = consume(parser);
|
|
if (rbra->type != FZL_TOKTYPE_RBRACE)
|
|
{
|
|
snprintf(plast_err, sizeof(plast_err),
|
|
"'%s': expected '}' after class definition at %ld:%ld",
|
|
last_known_tok->filename, last_known_tok->ln, last_known_tok->cn);
|
|
free(fields);
|
|
free(methods);
|
|
return NULL;
|
|
}
|
|
|
|
fzl_node_t *node = fzl_mknode(FZL_NODETYPE_CLASS, class);
|
|
node->class.name = name;
|
|
node->class.fields = fields;
|
|
node->class.fields_count = fcount;
|
|
node->class.methods = methods;
|
|
node->class.methods_count = mcount;
|
|
|
|
return node;
|
|
}
|
|
|
|
// Functions parsing
|
|
fzl_node_t *parse_function(fzl_parser_t *parser)
|
|
{
|
|
if (!parser)
|
|
return NULL;
|
|
|
|
fzl_token_t *fn = consume(parser);
|
|
if (!fn || fn->type != FZL_TOKTYPE_FUNCTION)
|
|
{
|
|
snprintf(plast_err, sizeof(plast_err),
|
|
"'%s': expected keyword 'fn' at %ld:%ld", last_known_tok->filename,
|
|
last_known_tok->ln, last_known_tok->cn);
|
|
return NULL;
|
|
}
|
|
|
|
fzl_token_t *name = consume(parser);
|
|
if (!name || name->type != FZL_TOKTYPE_NAME)
|
|
{
|
|
snprintf(plast_err, sizeof(plast_err),
|
|
"'%s': expected function name at %ld:%ld",
|
|
last_known_tok->filename, last_known_tok->ln, last_known_tok->cn);
|
|
return NULL;
|
|
}
|
|
|
|
fzl_token_t *lpar = consume(parser);
|
|
if (!lpar || lpar->type != FZL_TOKTYPE_LPAREN)
|
|
{
|
|
snprintf(plast_err, sizeof(plast_err), "'%s': expected '(' at %ld:%ld",
|
|
last_known_tok->filename, last_known_tok->ln, last_known_tok->cn);
|
|
return NULL;
|
|
}
|
|
|
|
size_t remainder = 1;
|
|
size_t count = 0;
|
|
fzl_node_t **args = malloc(remainder * sizeof(fzl_node_t *));
|
|
|
|
while (peek(parser) && !is(parser, FZL_TOKTYPE_RPAREN))
|
|
{
|
|
fzl_node_t *arg = parse_expression(parser);
|
|
if (!arg)
|
|
return NULL;
|
|
|
|
if (remainder <= count)
|
|
{
|
|
remainder *= 2;
|
|
args = realloc(args, remainder * sizeof(fzl_node_t *));
|
|
}
|
|
|
|
args[count++] = arg;
|
|
|
|
if (is(parser, FZL_TOKTYPE_COMMA))
|
|
consume(parser);
|
|
}
|
|
|
|
fzl_token_t *rpar = consume(parser);
|
|
if (!rpar || rpar->type != FZL_TOKTYPE_RPAREN)
|
|
{
|
|
free(args);
|
|
snprintf(plast_err, sizeof(plast_err),
|
|
"'%s': expected ')' after argument list at %ld:%ld",
|
|
last_known_tok->filename, last_known_tok->ln, last_known_tok->cn);
|
|
return NULL;
|
|
}
|
|
|
|
fzl_token_t *type = NULL;
|
|
if (is(parser, FZL_TOKTYPE_TYPE) || is(parser, FZL_TOKTYPE_NAME))
|
|
type = consume(parser);
|
|
|
|
if (!type)
|
|
type = &null_tok;
|
|
|
|
if (!is(parser, FZL_TOKTYPE_LBRACE))
|
|
{
|
|
free(args);
|
|
snprintf(plast_err, sizeof(plast_err),
|
|
"'%s': expected '{' after function declaration at %ld:%ld",
|
|
last_known_tok->filename, last_known_tok->ln, last_known_tok->cn);
|
|
return NULL;
|
|
}
|
|
|
|
fzl_node_t *body = parse_statement(parser);
|
|
if (!body)
|
|
{
|
|
free(args);
|
|
return NULL;
|
|
}
|
|
|
|
fzl_node_t *node = fzl_mknode(FZL_NODETYPE_FUNCTION, name);
|
|
node->fn.args = args;
|
|
node->fn.args_count = count;
|
|
node->fn.body = body;
|
|
node->fn.name = name;
|
|
node->fn.type = type;
|
|
|
|
return node;
|
|
}
|
|
|
|
// Return parsing
|
|
fzl_node_t *parse_return(fzl_parser_t *parser)
|
|
{
|
|
if (!parser)
|
|
return NULL;
|
|
|
|
fzl_token_t *ret = consume(parser);
|
|
fzl_node_t *node = fzl_mknode(FZL_NODETYPE_RETURN, ret);
|
|
|
|
if (!is(parser, FZL_TOKTYPE_SEMICOLON))
|
|
{
|
|
fzl_node_t *retval = parse_expression(parser);
|
|
if (!retval)
|
|
{
|
|
fzl_freeast(node);
|
|
return NULL;
|
|
}
|
|
|
|
node->ret.value = retval;
|
|
}
|
|
|
|
return node;
|
|
}
|
|
|
|
fzl_node_t *parse_if(fzl_parser_t *parser)
|
|
{
|
|
if (!parser)
|
|
return NULL;
|
|
|
|
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),
|
|
"'%s': expected '(' before condition at %ld:%ld", lparen->filename,
|
|
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)
|
|
{
|
|
fzl_freeast(condition);
|
|
snprintf(plast_err, sizeof(plast_err),
|
|
"'%s': expected ')' after condition at %ld:%ld", rparen->filename,
|
|
rparen->ln, rparen->cn);
|
|
return NULL;
|
|
}
|
|
|
|
fzl_node_t *else_block = NULL;
|
|
fzl_node_t *true_block = parse_statement(parser);
|
|
if (!true_block)
|
|
{
|
|
fzl_freeast(condition);
|
|
return NULL;
|
|
}
|
|
|
|
if (is(parser, FZL_TOKTYPE_ELSE))
|
|
{
|
|
consume(parser); // else
|
|
else_block = parse_statement(parser);
|
|
if (!else_block)
|
|
{
|
|
fzl_freeast(condition);
|
|
fzl_freeast(true_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;
|
|
}
|
|
|
|
// Block statement parsing
|
|
fzl_node_t *parse_block(fzl_parser_t *parser)
|
|
{
|
|
if (!parser)
|
|
return NULL;
|
|
|
|
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)
|
|
{
|
|
free(stmts);
|
|
return NULL;
|
|
}
|
|
|
|
if (remainder <= count)
|
|
{
|
|
remainder *= 2;
|
|
stmts = realloc(stmts, remainder * sizeof(fzl_node_t *));
|
|
}
|
|
|
|
stmts[count++] = node;
|
|
}
|
|
fzl_token_t *rbrace = consume(parser);
|
|
if (!rbrace || rbrace->type != FZL_TOKTYPE_RBRACE)
|
|
{
|
|
for (size_t i = 0; i < count; i++)
|
|
fzl_freeast(stmts[i]);
|
|
free(stmts);
|
|
|
|
snprintf(plast_err, sizeof(plast_err),
|
|
"'%s': missing '}' after block at %ld:%ld",
|
|
last_known_tok->filename, last_known_tok->ln, last_known_tok->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;
|
|
}
|
|
|
|
// For-loop parsing
|
|
fzl_node_t *parse_for(fzl_parser_t *parser)
|
|
{
|
|
fzl_token_t *tok = consume(parser);
|
|
fzl_token_t *lpar = consume(parser);
|
|
if (!lpar || lpar->type != FZL_TOKTYPE_LPAREN)
|
|
{
|
|
snprintf(plast_err, sizeof(plast_err),
|
|
"'%s': expected '(' after for keyword at %ld:%ld",
|
|
last_known_tok->filename, last_known_tok->ln, last_known_tok->cn);
|
|
return NULL;
|
|
}
|
|
|
|
fzl_node_t *start = NULL;
|
|
if (!is(parser, FZL_TOKTYPE_SEMICOLON))
|
|
{
|
|
start = parse_expression(parser);
|
|
if (!start)
|
|
{
|
|
snprintf(plast_err, sizeof(plast_err),
|
|
"'%s': expected loop init or ';' at %ld:%ld",
|
|
last_known_tok->filename, last_known_tok->ln,
|
|
last_known_tok->cn);
|
|
return NULL;
|
|
}
|
|
|
|
fzl_token_t *sc = consume(parser);
|
|
if (!sc || sc->type != FZL_TOKTYPE_SEMICOLON)
|
|
{
|
|
fzl_freeast(start);
|
|
snprintf(plast_err, sizeof(plast_err),
|
|
"'%s': missing ';' after init section at %ld:%ld",
|
|
last_known_tok->filename, last_known_tok->ln,
|
|
last_known_tok->cn);
|
|
return NULL;
|
|
}
|
|
}
|
|
else
|
|
consume(parser);
|
|
|
|
fzl_node_t *condition = NULL;
|
|
if (!is(parser, FZL_TOKTYPE_SEMICOLON))
|
|
{
|
|
condition = parse_expression(parser);
|
|
if (!condition)
|
|
{
|
|
fzl_freeast(start);
|
|
snprintf(plast_err, sizeof(plast_err),
|
|
"'%s': expected loop condition or ';' at %ld:%ld",
|
|
last_known_tok->filename, last_known_tok->ln,
|
|
last_known_tok->cn);
|
|
return NULL;
|
|
}
|
|
|
|
fzl_token_t *sc = consume(parser);
|
|
if (!sc || sc->type != FZL_TOKTYPE_SEMICOLON)
|
|
{
|
|
fzl_freeast(start);
|
|
fzl_freeast(condition);
|
|
snprintf(plast_err, sizeof(plast_err),
|
|
"'%s': missing ';' after condition at %ld:%ld",
|
|
last_known_tok->filename, last_known_tok->ln,
|
|
last_known_tok->cn);
|
|
return NULL;
|
|
}
|
|
}
|
|
else
|
|
consume(parser);
|
|
|
|
fzl_node_t *step = NULL;
|
|
if (!is(parser, FZL_TOKTYPE_RPAREN))
|
|
{
|
|
step = parse_expression(parser);
|
|
if (!step)
|
|
{
|
|
fzl_freeast(start);
|
|
fzl_freeast(condition);
|
|
snprintf(plast_err, sizeof(plast_err),
|
|
"'%s': expected loop step end or ')' at %ld:%ld",
|
|
last_known_tok->filename, last_known_tok->ln,
|
|
last_known_tok->cn);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
fzl_token_t *rpar = consume(parser);
|
|
if (!rpar || rpar->type != FZL_TOKTYPE_RPAREN)
|
|
{
|
|
fzl_freeast(start);
|
|
fzl_freeast(condition);
|
|
fzl_freeast(step);
|
|
snprintf(plast_err, sizeof(plast_err),
|
|
"'%s': missing ')' after loop setup at %ld:%ld",
|
|
last_known_tok->filename, last_known_tok->ln, last_known_tok->cn);
|
|
return NULL;
|
|
}
|
|
|
|
fzl_node_t *body = parse_statement(parser);
|
|
if (!body)
|
|
{
|
|
fzl_freeast(start);
|
|
fzl_freeast(condition);
|
|
fzl_freeast(step);
|
|
snprintf(plast_err, sizeof(plast_err),
|
|
"'%s': missing body of for loop at %ld:%ld",
|
|
last_known_tok->filename, last_known_tok->ln, last_known_tok->cn);
|
|
return NULL;
|
|
}
|
|
|
|
fzl_node_t *node = fzl_mknode(FZL_NODETYPE_LOOP, tok);
|
|
node->loop.init = start;
|
|
node->loop.cond = condition;
|
|
node->loop.step = step;
|
|
node->loop.body = body;
|
|
|
|
return node;
|
|
}
|
|
|
|
// While-loop parsing
|
|
fzl_node_t *parse_while(fzl_parser_t *parser)
|
|
{
|
|
fzl_token_t *tok = consume(parser);
|
|
fzl_token_t *lpar = consume(parser);
|
|
if (!lpar || lpar->type != FZL_TOKTYPE_LPAREN)
|
|
{
|
|
snprintf(plast_err, sizeof(plast_err),
|
|
"'%s': missing '(' after while keyword at %ld:%ld",
|
|
last_known_tok->filename, last_known_tok->ln, last_known_tok->cn);
|
|
return NULL;
|
|
}
|
|
|
|
fzl_node_t *condition = parse_expression(parser);
|
|
if (!condition)
|
|
{
|
|
snprintf(plast_err, sizeof(plast_err),
|
|
"'%s': missing condition for 'while' at %ld:%ld",
|
|
last_known_tok->filename, last_known_tok->ln, last_known_tok->cn);
|
|
return NULL;
|
|
}
|
|
|
|
fzl_token_t *rpar = consume(parser);
|
|
if (!rpar || rpar->type != FZL_TOKTYPE_RPAREN)
|
|
{
|
|
fzl_freeast(condition);
|
|
snprintf(plast_err, sizeof(plast_err),
|
|
"'%s': missing ')' after while loop condition at %ld:%ld",
|
|
last_known_tok->filename, last_known_tok->ln, last_known_tok->cn);
|
|
return NULL;
|
|
}
|
|
|
|
fzl_node_t *body = parse_statement(parser);
|
|
if (!body)
|
|
{
|
|
fzl_freeast(condition);
|
|
snprintf(plast_err, sizeof(plast_err),
|
|
"'%s': missing while loop body at %ld:%ld",
|
|
last_known_tok->filename, last_known_tok->ln, last_known_tok->cn);
|
|
return NULL;
|
|
}
|
|
|
|
fzl_node_t *node = fzl_mknode(FZL_NODETYPE_LOOP, tok);
|
|
node->loop.cond = condition;
|
|
node->loop.body = body;
|
|
|
|
return node;
|
|
}
|
|
|
|
// `while` and `for` loops
|
|
fzl_node_t *parse_loop(fzl_parser_t *parser)
|
|
{
|
|
if (!peek(parser))
|
|
return NULL;
|
|
|
|
if (is(parser, FZL_TOKTYPE_FOR))
|
|
return parse_for(parser);
|
|
else if (is(parser, FZL_TOKTYPE_WHILE))
|
|
return parse_while(parser);
|
|
|
|
snprintf(plast_err, sizeof(plast_err),
|
|
"'%s': unknown type of loop at %ld:%ld", last_known_tok->filename,
|
|
last_known_tok->ln, last_known_tok->cn);
|
|
return NULL;
|
|
}
|
|
|
|
// `break` keyword parsing
|
|
fzl_node_t *parse_break(fzl_parser_t *parser)
|
|
{
|
|
fzl_token_t *tok = consume(parser);
|
|
if (!tok)
|
|
{
|
|
snprintf(plast_err, sizeof(plast_err), "'%s': EOF",
|
|
last_known_tok->filename);
|
|
return NULL;
|
|
}
|
|
|
|
return fzl_mknode(FZL_NODETYPE_BREAK, tok);
|
|
}
|
|
|
|
// Statement parsing
|
|
fzl_node_t *parse_statement(fzl_parser_t *parser)
|
|
{
|
|
if (!peek(parser))
|
|
return NULL;
|
|
|
|
fzl_node_t *res = NULL;
|
|
|
|
if (is(parser, FZL_TOKTYPE_CLASS))
|
|
return parse_class(parser);
|
|
else if (is(parser, FZL_TOKTYPE_FUNCTION))
|
|
return parse_function(parser);
|
|
else if (is(parser, FZL_TOKTYPE_RETURN))
|
|
res = parse_return(parser);
|
|
else if (is(parser, FZL_TOKTYPE_IF))
|
|
return parse_if(parser);
|
|
else if (is(parser, FZL_TOKTYPE_LBRACE))
|
|
return parse_block(parser);
|
|
else if (is(parser, FZL_TOKTYPE_FOR) || is(parser, FZL_TOKTYPE_WHILE))
|
|
return parse_loop(parser);
|
|
else if (is(parser, FZL_TOKTYPE_BREAK))
|
|
res = parse_break(parser);
|
|
|
|
if (!res)
|
|
res = parse_expression(parser);
|
|
|
|
if (!res)
|
|
{
|
|
fzl_freeast(res);
|
|
return NULL;
|
|
}
|
|
|
|
if (!is(parser, FZL_TOKTYPE_SEMICOLON))
|
|
{
|
|
fzl_freeast(res);
|
|
snprintf(plast_err, sizeof(plast_err), "'%s': missing ';' at %ld:%ld",
|
|
last_known_tok->filename, last_known_tok->ln, last_known_tok->cn);
|
|
return NULL;
|
|
}
|
|
while (is(parser, FZL_TOKTYPE_SEMICOLON))
|
|
consume(parser);
|
|
|
|
return res;
|
|
}
|
|
|
|
// Internal parsing entry point
|
|
fzl_node_t *parse_program(fzl_parser_t *parser)
|
|
{
|
|
if (!peek(parser))
|
|
return NULL;
|
|
|
|
fzl_node_t *first = NULL;
|
|
fzl_node_t *last = NULL;
|
|
fzl_node_t *node = NULL;
|
|
while (peek(parser) != NULL)
|
|
{
|
|
node = parse_statement(parser);
|
|
if (!node)
|
|
{
|
|
fzl_freeast(first);
|
|
return NULL;
|
|
}
|
|
|
|
if (!last)
|
|
{
|
|
first = node;
|
|
last = node;
|
|
}
|
|
else
|
|
{
|
|
last->next = node;
|
|
last = node;
|
|
}
|
|
}
|
|
|
|
if (!first)
|
|
{
|
|
snprintf(plast_err, sizeof(plast_err), "nothing to parse >:(");
|
|
return NULL;
|
|
}
|
|
|
|
return first;
|
|
}
|
|
|
|
// Parse tokens and build AST
|
|
int fzl_parse(fzl_parser_t *parser)
|
|
{
|
|
last_known_tok = NULL;
|
|
|
|
fzl_node_t *ast = parse_program(parser);
|
|
if (!ast)
|
|
return -1;
|
|
|
|
parser->root = ast;
|
|
return 0;
|
|
}
|
|
|
|
// --- Parse zone end ---
|
|
|
|
char *fzl_parser_geterror() { return plast_err; }
|
|
|
|
void fzl_freenode(fzl_node_t *node)
|
|
{
|
|
if (!node)
|
|
return;
|
|
free(node);
|
|
}
|
|
|
|
void fzl_freeast(fzl_node_t *root)
|
|
{
|
|
if (!root)
|
|
return;
|
|
|
|
while (root)
|
|
{
|
|
switch (root->type)
|
|
{
|
|
case FZL_NODETYPE_BREAK:
|
|
case FZL_NODETYPE_IDENTIFIER:
|
|
case FZL_NODETYPE_LITERAL:
|
|
break;
|
|
|
|
case FZL_NODETYPE_FMT_STRING:
|
|
case FZL_NODETYPE_BLOCK:
|
|
if (root->list.entries)
|
|
{
|
|
for (size_t i = 0; i < root->list.entry_count; i++)
|
|
fzl_freeast(root->list.entries[i]);
|
|
|
|
free(root->list.entries);
|
|
}
|
|
break;
|
|
|
|
case FZL_NODETYPE_CALL:
|
|
fzl_freeast(root->call.callee);
|
|
|
|
if (root->call.args_count)
|
|
{
|
|
for (size_t i = 0; i < root->call.args_count; i++)
|
|
fzl_freeast(root->call.args[i]);
|
|
}
|
|
if (root->call.args)
|
|
free(root->call.args);
|
|
break;
|
|
|
|
case FZL_NODETYPE_CONDITIONAL:
|
|
fzl_freeast(root->cond.condition);
|
|
fzl_freeast(root->cond.true_block);
|
|
fzl_freeast(root->cond.else_block);
|
|
break;
|
|
|
|
case FZL_NODETYPE_LOOP:
|
|
fzl_freeast(root->loop.init);
|
|
fzl_freeast(root->loop.cond);
|
|
fzl_freeast(root->loop.step);
|
|
fzl_freeast(root->loop.body);
|
|
break;
|
|
|
|
case FZL_NODETYPE_ADD:
|
|
case FZL_NODETYPE_SUB:
|
|
case FZL_NODETYPE_MUL:
|
|
case FZL_NODETYPE_DIV:
|
|
case FZL_NODETYPE_POW:
|
|
case FZL_NODETYPE_MOD:
|
|
case FZL_NODETYPE_OR:
|
|
case FZL_NODETYPE_AND:
|
|
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_ASSIGN:
|
|
fzl_freeast(root->binary_op.left);
|
|
fzl_freeast(root->binary_op.right);
|
|
break;
|
|
|
|
case FZL_NODETYPE_UNARY_PLUS:
|
|
case FZL_NODETYPE_UNARY_MINUS:
|
|
case FZL_NODETYPE_NOT:
|
|
fzl_freeast(root->unary_op.operand);
|
|
break;
|
|
|
|
case FZL_NODETYPE_FUNCTION:
|
|
if (root->fn.args_count)
|
|
for (size_t i = 0; i < root->fn.args_count; i++)
|
|
fzl_freeast(root->fn.args[i]);
|
|
free(root->fn.args);
|
|
fzl_freeast(root->fn.body);
|
|
break;
|
|
|
|
case FZL_NODETYPE_RETURN:
|
|
fzl_freeast(root->ret.value);
|
|
break;
|
|
|
|
case FZL_NODETYPE_CLASS:
|
|
if (root->class.fields_count)
|
|
for (size_t i = 0; i < root->class.fields_count; i++)
|
|
fzl_freeast(root->class.fields[i]);
|
|
free(root->class.fields);
|
|
|
|
if (root->class.methods_count)
|
|
for (size_t i = 0; i < root->class.methods_count; i++)
|
|
fzl_freeast(root->class.methods[i]);
|
|
free(root->class.methods);
|
|
break;
|
|
|
|
case FZL_NODETYPE_CONSTRUCT:
|
|
fzl_freeast(root->construct.name);
|
|
break;
|
|
|
|
case FZL_NODETYPE_FIELD:
|
|
fzl_freeast(root->memb.field);
|
|
fzl_freeast(root->memb.parent);
|
|
break;
|
|
|
|
case FZL_NODETYPE_DECLARATION:
|
|
fzl_freeast(root->var.identifier);
|
|
break;
|
|
}
|
|
|
|
fzl_node_t *next = root->next;
|
|
fzl_freenode(root);
|
|
root = next;
|
|
}
|
|
}
|
|
|
|
void fzl_freeparser(fzl_parser_t *parser)
|
|
{
|
|
if (!parser)
|
|
return;
|
|
free(parser);
|
|
}
|