builder_t* builder_create(const char* description)
{
if(description == NULL)
return NULL;
source_t* source = source_open_string(description);
symtab_t* symtab = symtab_new();
ast_t* ast = build_ast(source, symtab);
if(ast == NULL)
{
// Error, tidy up
source_close(source);
symtab_free(symtab);
return NULL;
}
// Success, create builder
builder_t* builder = POOL_ALLOC(builder_t);
builder->sources = NULL;
builder->defs = symtab;
builder->dummy_root = ast_blank(TK_TEST);
ast_add(builder->dummy_root, ast);
add_source(builder, source);
return builder;
}
bool parse(ast_t* package, source_t* source, rule_t start,
const char* expected)
{
assert(package != NULL);
assert(source != NULL);
assert(expected != NULL);
// Open the lexer
lexer_t* lexer = lexer_open(source);
if(lexer == NULL)
return false;
// Create a parser and attach the lexer
parser_t* parser = POOL_ALLOC(parser_t);
parser->source = source;
parser->lexer = lexer;
parser->token = lexer_next(lexer);
parser->last_matched = NULL;
parser->last_token_line = 0;
parser->next_flags = 0;
parser->failed = false;
// Parse given start rule
builder_fn_t build_fn;
ast_t* ast = start(parser, &build_fn, expected);
if(ast == PARSE_ERROR)
ast = NULL;
if(ast == RULE_NOT_FOUND)
{
syntax_error(parser, expected, NULL, NULL);
ast = NULL;
}
if(parser->failed)
{
ast_free(ast);
ast = NULL;
}
lexer_close(lexer);
token_free(parser->token);
POOL_FREE(parser_t, parser);
if(ast == NULL)
{
source_close(source);
return false;
}
assert(ast_id(ast) == TK_MODULE);
assert(ast_data(ast) == NULL);
ast_setdata(ast, source);
ast_add(package, ast);
return true;
}
void builder_free(builder_t* builder)
{
if(builder == NULL)
return;
ast_free(builder->dummy_root);
symtab_free(builder->defs);
builder_src_t* p = builder->sources;
while(p != NULL)
{
builder_src_t* next = p->next;
source_close(p->source);
POOL_FREE(builder_src_t, p);
p = next;
}
POOL_FREE(builder_t, builder);
}
static ast_t* builder_add_ast(builder_t* builder, const char* description)
{
assert(builder != NULL);
assert(description != NULL);
source_t* source = source_open_string(description);
ast_t* ast = build_ast(source, builder->defs);
if(ast == NULL)
{
// Error, tidy up
source_close(source);
return NULL;
}
// Success, add new source to builder
add_source(builder, source);
return ast;
}
static void closeFile() {
i32 local_DEBUG;
i32 local_endOfFile;
source_close();
local_DEBUG = DEBUG;
if (local_DEBUG) {
printf("Source ACTION: closeFile\n");
printf("Source STATE: ReadFileDone\n");
printf("-------------------------\n");
}
endOfFile = 1;
local_endOfFile = endOfFile;
tokens_EOF[(index_EOF + (0)) % SIZE_EOF] = local_endOfFile;
// Update ports indexes
index_EOF += 1;
}
void ast_free(ast_t* ast)
{
if(ast == NULL)
return;
ast_t* child = ast->child;
ast_t* next;
while(child != NULL)
{
next = child->sibling;
ast_free(child);
child = next;
}
ast_free(ast->type);
switch(token_get_id(ast->t))
{
case TK_PROGRAM:
program_free((program_t*)ast->data);
break;
case TK_PACKAGE:
package_free((package_t*)ast->data);
break;
case TK_MODULE:
source_close((source_t*)ast->data);
break;
default:
break;
}
token_free(ast->t);
symtab_free(ast->symtab);
POOL_FREE(ast_t, ast);
}
int release_source(source_t *as)
{
source_close(as);
free(as);
return 0;
}
