240 lines
6.5 KiB
C
240 lines
6.5 KiB
C
#include <common/fzl_types.h>
|
|
#include <compiler/fzl_analyzer.h>
|
|
#include <compiler/fzl_parser.h>
|
|
#include <compiler/fzl_token.h>
|
|
#include <compiler/internals/analyzer.h>
|
|
#include <compiler/utils/fzl_symtable.h>
|
|
#include <stdbool.h>
|
|
#include <stddef.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
char *tmp_method_name = NULL;
|
|
char *tmp_fnname = NULL;
|
|
char *tmp_classname = NULL;
|
|
|
|
// Try to get symbol name from callee
|
|
char *resolve_callee(fzl_analyzer_t *analyzer, fzl_node_t *callee, bool *method)
|
|
{
|
|
*method = false;
|
|
|
|
if (callee->type == FZL_NODETYPE_IDENTIFIER)
|
|
return (char *)callee->token->value;
|
|
|
|
if (callee->type != FZL_NODETYPE_FIELD)
|
|
{
|
|
an_push_error(analyzer, callee->token, "unknown call format");
|
|
return NULL;
|
|
}
|
|
|
|
*method = true;
|
|
fzl_an_res_t parent_res = analyze_common(analyzer, callee->memb.parent);
|
|
if (parent_res.type != FZL_TYPE_OBJECT || !parent_res.classname)
|
|
return NULL;
|
|
|
|
char *fn_name = callee->memb.field->token->value;
|
|
tmp_fnname = fn_name;
|
|
tmp_classname = parent_res.classname;
|
|
size_t classname_len = strlen(parent_res.classname);
|
|
size_t methodname_len = strlen(fn_name);
|
|
tmp_method_name = malloc(classname_len + methodname_len + 2);
|
|
if (!tmp_method_name)
|
|
{
|
|
an_push_error(analyzer, callee->token, "out of memory");
|
|
return NULL;
|
|
}
|
|
|
|
strcpy(tmp_method_name, parent_res.classname);
|
|
tmp_method_name[classname_len] = '_';
|
|
strcpy(tmp_method_name + classname_len + 1, fn_name);
|
|
tmp_method_name[classname_len + methodname_len + 1] = 0;
|
|
|
|
return tmp_method_name;
|
|
}
|
|
|
|
// Analyze call node
|
|
fzl_an_res_t analyze_call(fzl_analyzer_t *analyzer, fzl_node_t *call_node)
|
|
{
|
|
if (!call_node || call_node->type != FZL_NODETYPE_CALL)
|
|
{
|
|
an_push_error(analyzer, NULL, "node is not call");
|
|
return (fzl_an_res_t){.error = true};
|
|
}
|
|
|
|
fzl_node_t *callee = call_node->call.callee;
|
|
|
|
bool is_method = false;
|
|
char *callee_name = resolve_callee(analyzer, callee, &is_method);
|
|
if (!callee_name)
|
|
{
|
|
an_push_error(analyzer, callee->token, "expression is not callable");
|
|
|
|
if (tmp_method_name != NULL)
|
|
{
|
|
free(tmp_method_name);
|
|
tmp_method_name = NULL;
|
|
}
|
|
|
|
return (fzl_an_res_t){.error = true};
|
|
}
|
|
|
|
// NOTE: move into `compiler/analyzer/builtins.c`
|
|
if (strcmp(callee_name, "printline") == 0 || strcmp(callee_name, "exit") == 0)
|
|
{
|
|
if (call_node->call.args_count != 1)
|
|
{
|
|
snprintf(an_problem, sizeof(an_problem),
|
|
"'%s' builtin should be called with 1 argument instead of %zu",
|
|
callee_name, call_node->call.args_count);
|
|
an_push_error(analyzer, call_node->token, an_problem);
|
|
|
|
if (tmp_method_name != NULL)
|
|
{
|
|
free(tmp_method_name);
|
|
tmp_method_name = NULL;
|
|
}
|
|
|
|
return (fzl_an_res_t){.error = true};
|
|
}
|
|
|
|
if (tmp_method_name != NULL)
|
|
{
|
|
free(tmp_method_name);
|
|
tmp_method_name = NULL;
|
|
}
|
|
|
|
return (fzl_an_res_t){
|
|
.error = false, .type = FZL_TYPE_NULL, .classname = NULL};
|
|
}
|
|
|
|
fzl_sym_t sym;
|
|
bool sym_found = false;
|
|
for (ssize_t i = analyzer->symbols_top - 1; i >= 0; i--)
|
|
{
|
|
if ((sym_found = fzl_symt_get(analyzer->symbols[i], callee_name, &sym)))
|
|
break;
|
|
}
|
|
|
|
if (!sym_found)
|
|
{
|
|
snprintf(an_problem, sizeof(an_problem), "cannot resolve symbol '%s'",
|
|
callee_name);
|
|
an_push_error(analyzer, call_node->token, an_problem);
|
|
|
|
if (tmp_method_name != NULL)
|
|
{
|
|
free(tmp_method_name);
|
|
tmp_method_name = NULL;
|
|
}
|
|
|
|
return (fzl_an_res_t){.error = true};
|
|
}
|
|
|
|
if (sym.node->type != FZL_NODETYPE_FUNCTION)
|
|
{
|
|
snprintf(an_problem, sizeof(an_problem), "'%s' is not callable",
|
|
callee_name);
|
|
an_push_error(analyzer, call_node->token, an_problem);
|
|
|
|
if (tmp_method_name != NULL)
|
|
{
|
|
free(tmp_method_name);
|
|
tmp_method_name = NULL;
|
|
}
|
|
|
|
return (fzl_an_res_t){.error = true};
|
|
}
|
|
|
|
size_t offset = is_method ? 1 : 0;
|
|
if ((sym.node->fn.args_count - offset) != call_node->call.args_count)
|
|
{
|
|
if (is_method)
|
|
{
|
|
snprintf(an_problem, sizeof(an_problem),
|
|
"method '%s.%s' is expecting %zu argument(s), got %zu",
|
|
tmp_classname, tmp_fnname, sym.node->fn.args_count,
|
|
call_node->call.args_count - offset);
|
|
}
|
|
else
|
|
{
|
|
snprintf(an_problem, sizeof(an_problem),
|
|
"function '%s' is expecting %zu argument(s), got %zu",
|
|
callee_name, sym.node->fn.args_count,
|
|
call_node->call.args_count - offset);
|
|
}
|
|
an_push_error(analyzer, call_node->token, an_problem);
|
|
|
|
if (tmp_method_name != NULL)
|
|
{
|
|
free(tmp_method_name);
|
|
tmp_method_name = NULL;
|
|
}
|
|
|
|
return (fzl_an_res_t){.error = true};
|
|
}
|
|
|
|
for (size_t i = offset; i < sym.node->fn.args_count; i++)
|
|
{
|
|
fzl_node_t *arg = sym.node->fn.args[i];
|
|
fzl_type_t req_type = an_toktotype(arg->var.type);
|
|
char *req_classname = NULL;
|
|
if (req_type == FZL_TYPE_OBJECT)
|
|
req_classname = arg->var.type->value;
|
|
|
|
fzl_an_res_t got =
|
|
analyze_common(analyzer, call_node->call.args[i - offset]);
|
|
if (got.error)
|
|
{
|
|
if (tmp_method_name != NULL)
|
|
{
|
|
free(tmp_method_name);
|
|
tmp_method_name = NULL;
|
|
}
|
|
return (fzl_an_res_t){.error = true};
|
|
}
|
|
|
|
if (!an_is_compatible(req_type, got.type, req_classname, got.classname))
|
|
{
|
|
if (is_method)
|
|
{
|
|
snprintf(an_problem, sizeof(an_problem),
|
|
"method '%s.%s' is expecting %zu argument to have type '%s', "
|
|
"got '%s'",
|
|
tmp_classname, tmp_fnname, i + 1 - offset,
|
|
an_typetostr(req_type, req_classname),
|
|
an_typetostr(got.type, got.classname));
|
|
}
|
|
else
|
|
{
|
|
snprintf(an_problem, sizeof(an_problem),
|
|
"function '%s' is expecting %zu argument to have type '%s', "
|
|
"got '%s'",
|
|
callee_name, i + 1 - offset,
|
|
an_typetostr(req_type, req_classname),
|
|
an_typetostr(got.type, got.classname));
|
|
}
|
|
an_push_error(analyzer, call_node->token, an_problem);
|
|
|
|
if (tmp_method_name != NULL)
|
|
{
|
|
free(tmp_method_name);
|
|
tmp_method_name = NULL;
|
|
}
|
|
|
|
return (fzl_an_res_t){.error = true};
|
|
}
|
|
}
|
|
|
|
fzl_type_t type = an_toktotype(sym.node->fn.type);
|
|
char *classname = sym.classname;
|
|
|
|
if (tmp_method_name != NULL)
|
|
{
|
|
free(tmp_method_name);
|
|
tmp_method_name = NULL;
|
|
}
|
|
|
|
return (fzl_an_res_t){.error = false, .type = type, .classname = classname};
|
|
}
|