epickh
/
Parcel
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Cleaned up code and fixed memory leaks

This commit is contained in:
Eric-Paul Ickhorn 2023-11-29 14:00:43 +01:00
parent b8f4fd9feb
commit 3251632dbe
12 changed files with 457 additions and 149 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
checks/print-grammar/src/main.c
View File

@ -4,7 +4,7 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
char * load_file(char *path) char * load_file(char *path, long *len)
{ {
FILE *file = fopen(path, "r"); FILE *file = fopen(path, "r");
if(file == NULL) if(file == NULL)
@ -21,6 +21,9 @@ char * load_file(char *path)
content[length] = 0x00; content[length] = 0x00;
fread(content, 1, length, file); fread(content, 1, length, file);
if(len != NULL)
(*len) = length;
fclose(file); fclose(file);
return content; return content;
} }
@ -32,12 +35,18 @@ int main(int argc, char **argv)
printf("Usage: %s <filename>\n", argv[0]); printf("Usage: %s <filename>\n", argv[0]);
return -1; return -1;
} }
char *source = load_file(argv[1]); usz_t len_source;
char *source = load_file(argv[1], &len_source);
if(source == NULL) if(source == NULL)
{ {
puts("Stopping due to previous error!"); puts("Stopping due to previous error!");
return -2; return -2;
} }
pac_convert_grammar(source); pac_grammar_s grammar = pac_convert_grammar(source, len_source);
free(source);
pac_display_grammar(grammar);
pac_delete_grammar(grammar);
return 0; return 0;
} }

4
checks/print-tokens/src/main.c
View File

@ -23,9 +23,7 @@ char * load_file(char *path, long *len)
fread(content, 1, length, file); fread(content, 1, length, file);
if(len != NULL) if(len != NULL)
{
(*len) = length; (*len) = length;
}
fclose(file); fclose(file);
return content; return content;
@ -46,6 +44,8 @@ int main(int argc, char **argv)
return -2; return -2;
} }
pac_tlist_s tokens = pac_tokenize_grammar(source, len_source); pac_tlist_s tokens = pac_tokenize_grammar(source, len_source);
free(source);
pac_display_tlist(tokens); pac_display_tlist(tokens);
return 0; return 0;

20
core-parser/inc/ast.h
View File

@ -37,6 +37,7 @@ typedef enum
PAC_AST_STATUS_STOP_ESCALATING_IN_ITEM_PARSER, PAC_AST_STATUS_STOP_ESCALATING_IN_ITEM_PARSER,
PAC_AST_STATUS_STOP_ESCALATING_IN_VARIANT_PARSER, PAC_AST_STATUS_STOP_ESCALATING_IN_VARIANT_PARSER,
PAC_AST_STATUS_STOP_ESCALATING_IN_RULE_PARSER, PAC_AST_STATUS_STOP_ESCALATING_IN_RULE_PARSER,
PAC_AST_STATUS_CONTINUE_AFTER_FINDING_NEXT_VARIANT,
PAC_AST_STATUS_CONTINUE_AFTER_FINDING_NEXT_RULE, PAC_AST_STATUS_CONTINUE_AFTER_FINDING_NEXT_RULE,
PAC_AST_STATUS_NOT_RECOVERABLE, PAC_AST_STATUS_NOT_RECOVERABLE,
PAC_AST_STATUS_UNEXPECTED_FILE_END PAC_AST_STATUS_UNEXPECTED_FILE_END
@ -46,7 +47,7 @@ typedef enum
typedef struct pac_ast pac_ast_s; typedef struct pac_ast pac_ast_s;
typedef struct pac_ast_rule pac_ast_rule_s; typedef struct pac_ast_rule pac_ast_rule_s;
typedef struct pac_ast_variant pac_ast_variant_s; typedef struct pac_ast_variant pac_ast_variant_s;
typedef struct pac_ast_literal pac_ast_literal_s; typedef struct pac_ast_string_literal pac_ast_string_literal_s;
typedef struct pac_ast_reference pac_ast_reference_s; typedef struct pac_ast_reference pac_ast_reference_s;
typedef struct pac_ast_item pac_ast_item_s; typedef struct pac_ast_item pac_ast_item_s;
@ -54,6 +55,7 @@ struct pac_ast
{ {
usz_t num_rules; usz_t num_rules;
pac_ast_rule_s *rules; pac_ast_rule_s *rules;
pac_arena_s string_arena;
}; };
struct pac_ast_rule struct pac_ast_rule
@ -78,7 +80,7 @@ struct pac_ast_reference
char *name; char *name;
}; };
struct pac_ast_literal struct pac_ast_string_literal
{ {
usz_t length; usz_t length;
char *string; char *string;
@ -89,7 +91,7 @@ struct pac_ast_item
pac_ast_item_e type; pac_ast_item_e type;
union pac_ast_item_data union pac_ast_item_data
{ {
pac_ast_literal_s literal; pac_ast_string_literal_s string_literal;
pac_ast_set_e set; pac_ast_set_e set;
pac_ast_reference_s reference; pac_ast_reference_s reference;
} data; } data;
@ -101,16 +103,22 @@ typedef struct pac_ast_builder
pac_tlist_s *token_list; pac_tlist_s *token_list;
bool_t failed; bool_t failed;
pac_logger_s logger; pac_logger_s *logger;
pac_arena_s string_arena;
} pac_ast_builder_s; } pac_ast_builder_s;
pac_ast_s pac_build_ast (pac_tlist_s tokens); pac_ast_s pac_build_ast (pac_tlist_s tokens, pac_logger_s *logger);
void pac_delete_ast (pac_ast_s ast);
pac_ast_status_e pac_ast_handle_invalid_reference_name_token (pac_ast_builder_s *builder); pac_ast_status_e pac_ast_handle_invalid_reference_name_token (pac_ast_builder_s *builder);
pac_ast_status_e pac_ast_handle_missing_reference_close_tag (pac_ast_builder_s *builder); pac_ast_status_e pac_ast_handle_missing_reference_close_tag (pac_ast_builder_s *builder);
pac_ast_status_e pac_ast_handle_missing_rule_header_closing_sign (pac_ast_builder_s *builder);
pac_ast_status_e pac_ast_handle_reference_with_equals_sign (pac_ast_builder_s *builder); pac_ast_status_e pac_ast_handle_reference_with_equals_sign (pac_ast_builder_s *builder);
pac_ast_status_e pac_ast_handle_missing_item_delimiter (pac_ast_builder_s *builder); pac_ast_status_e pac_ast_handle_missing_item_delimiter (pac_ast_builder_s *builder, char *rule_name, usz_t variant_index, usz_t item_index);
pac_ast_status_e pac_ast_handle_missing_equals_sign_after_rule_header (pac_ast_builder_s *builder); pac_ast_status_e pac_ast_handle_missing_equals_sign_after_rule_header (pac_ast_builder_s *builder);
pac_ast_status_e pac_ast_handle_unknown_item_type (pac_ast_builder_s *builder, char *rule_name, usz_t variant_index, usz_t item_index);
char * pac_ast_stringify_status (pac_ast_status_e status);
#endif // PARCEL_AST_H #endif // PARCEL_AST_H

127
core-parser/inc/logger.h
View File

@ -8,6 +8,7 @@ typedef enum
{ {
PAC_SYNTAX_ERROR, PAC_SYNTAX_ERROR,
PAC_NAMING_ERROR, PAC_NAMING_ERROR,
PAC_VALIDATION_ERROR,
PAC_INTERNAL_ERROR PAC_INTERNAL_ERROR
} pac_error_e; } pac_error_e;
@ -17,21 +18,53 @@ typedef enum
PAC_SYNTAX_ERROR_UNSPECIFIED, PAC_SYNTAX_ERROR_UNSPECIFIED,
PAC_SYNTAX_ERROR_STRAY, PAC_SYNTAX_ERROR_STRAY,
PAC_SYNTAX_ERROR_MISSING_TOKEN, PAC_SYNTAX_ERROR_MISSING_TOKEN,
PAC_SYNTAX_ERROR_ODD_TOKEN PAC_SYNTAX_ERROR_ODD_TOKEN,
PAC_SYNTAX_ERROR_INVALID_ITEM
} pac_syntax_error_e; } pac_syntax_error_e;
typedef enum typedef enum
{ {
PAC_NAMING_ERROR_INVALID_REFERENCE_NAME,
PAC_NAMING_ERROR_INVALID_RULE_NAME PAC_NAMING_ERROR_INVALID_RULE_NAME
} pac_naming_error_e; } pac_naming_error_e;
typedef struct pac_syntax_error typedef enum
{ {
PAC_VALIDATION_ERROR_UNKNOWN_RULE,
PAC_VALIDATION_ERROR_RULE_NAMING_CONFLICT,
PAC_VALIDATION_ERROR_VARIANT_DUPLICATION,
PAC_VALIDATION_ERROR_CIRCULAR_REFERENCE
} pac_validation_error_e;
typedef enum
{
PAC_INTERNAL_ERROR_INVALID_ARGUMENTS,
PAC_INTERNAL_ERROR_INVALID_RETURNED_STATUS,
PAC_INTERNAL_ERROR_INVALID_FUNCTION_ENTRY,
PAC_INTERNAL_ERROR_NOT_IMPLEMENTED
} pac_internal_error_e;
typedef struct pac_source_location
{
char *file;
usz_t line; usz_t line;
usz_t column; usz_t column;
char *rule;
usz_t variant_index;
usz_t item_index;
} pac_source_location_s;
typedef struct pac_syntax_error
{
pac_source_location_s location;
pac_syntax_error_e type; pac_syntax_error_e type;
union pac_syntax_error_specifics union pac_syntax_error_specifics
{ {
@ -50,10 +83,17 @@ typedef struct pac_syntax_error
{ {
usz_t num_valid_options; usz_t num_valid_options;
char *valid_options[16]; char *valid_options[16];
char *found_token; char *present_token;
char *hint; char *hint;
} odd_token; } odd_token;
struct pac_syntax_error_invalid_item
{
char *present_construct;
char *hint;
} invalid_item;
} specifics; } specifics;
} pac_syntax_error_s; } pac_syntax_error_s;
@ -74,6 +114,80 @@ typedef struct pac_naming_error
} pac_naming_error_s; } pac_naming_error_s;
typedef struct pac_validation_error
{
char *rule;
usz_t variant;
pac_validation_error_e type;
union pac_validation_error_specifics
{
struct pac_naming_error_unknown_rule
{
char *searched_name;
} unknown_rule;
struct pac_naming_error_rule_naming_conflict
{
char *rule_name;
usz_t original_line;
usz_t duplicate_line;
} rule_naming_conflict;
struct pac_naming_error_variant_duplication
{
char *rule_name;
usz_t original;
usz_t duplicate;
} variant_doubling;
} specifics;
} pac_validation_error_s;
typedef struct pac_internal_error
{
pac_internal_error_e type;
union pac_internal_error_specifics
{
struct pac_internal_error_invalid_arguments
{
char *argument;
char *value;
char *error_description;
} invalid_arguments;
struct pac_internal_error_invalid_returned_status
{
char *function;
char *immediate_returner;
char *value;
} invalid_returned_status;
struct pac_internal_error_invalid_function_entry
{
char *function;
char *error_description;
} invalid_function_entry;
struct pac_internal_error_not_implemented
{
char *feature_name;
char *feature_description;
} not_implemented;
} specifics;
} pac_internal_error_s;
typedef struct pac_error typedef struct pac_error
{ {
@ -82,6 +196,9 @@ typedef struct pac_error
{ {
pac_syntax_error_s syntax_error; pac_syntax_error_s syntax_error;
pac_naming_error_s naming_error; pac_naming_error_s naming_error;
pac_validation_error_s validation_error;
pac_internal_error_s internal_error;
} specifics; } specifics;
} pac_error_s; } pac_error_s;
@ -97,8 +214,12 @@ typedef struct pac_logger
} pac_logger_s; } pac_logger_s;
pac_logger_s pac_create_logger (); pac_logger_s pac_create_logger ();
void pac_delete_logger (pac_logger_s logger);
void pac_log_syntax_error (pac_logger_s *logger, pac_syntax_error_s error); void pac_log_syntax_error (pac_logger_s *logger, pac_syntax_error_s error);
void pac_log_naming_error (pac_logger_s *logger, pac_naming_error_s error); void pac_log_naming_error (pac_logger_s *logger, pac_naming_error_s error);
void pac_log_validation_error (pac_logger_s *logger, pac_validation_error_s error);
void pac_log_internal_error (pac_logger_s *logger, pac_internal_error_s error);
void * pac_log_alloc (pac_logger_s *logger, usz_t num_bytes); void * pac_log_alloc (pac_logger_s *logger, usz_t num_bytes);

6
core-parser/inc/parcel.h
View File

@ -3,6 +3,7 @@
#define PARCEL_H #define PARCEL_H
#include <utility.h> #include <utility.h>
#include <logger.h>
typedef struct pac_grammar pac_grammar_s; typedef struct pac_grammar pac_grammar_s;
typedef struct pac_rule pac_rule_s; typedef struct pac_rule pac_rule_s;
@ -71,11 +72,14 @@ struct pac_grammar
usz_t num_rules; usz_t num_rules;
pac_rule_s *rules; pac_rule_s *rules;
pac_logger_s log;
pac_arena_s result_arena;
}; };
pac_grammar_s pac_convert_grammar (char *source); pac_grammar_s pac_convert_grammar (char *source, usz_t len_source);
void pac_delete_grammar (pac_grammar_s grammar); void pac_delete_grammar (pac_grammar_s grammar);
void pac_display_log (pac_grammar_s grammar); void pac_display_log (pac_grammar_s grammar);

6
core-parser/inc/tokenizer.h
View File

@ -50,9 +50,11 @@ struct pac_tlist
pac_token_s *tokens; pac_token_s *tokens;
}; };
pac_token_e pac_word_to_token_type (char *word, usz_t length);
pac_tlist_s pac_tokenize_grammar (char *source, usz_t len_source); pac_tlist_s pac_tokenize_grammar (char *source, usz_t len_source);
char * pac_stringify_token_type (pac_token_e type); void pac_delete_token_list (pac_tlist_s list);
void pac_display_tlist (pac_tlist_s list); void pac_display_tlist (pac_tlist_s list);
pac_token_e pac_word_to_token_type (char *word, usz_t length);
char * pac_stringify_token_type (pac_token_e type);
#endif #endif

200
core-parser/src/ast.c
View File

@ -1,6 +1,4 @@
#include <ast.h> #include <ast.h>
#include <logger.h>
#include <tokenizer.h>
#include <string.h> #include <string.h>
#include <stdio.h> #include <stdio.h>
@ -11,15 +9,22 @@
#define TOKEN_CURSOR (builder->cursor) #define TOKEN_CURSOR (builder->cursor)
#define SKIP_TOKEN ++builder->cursor #define SKIP_TOKEN ++builder->cursor
#define REWIND_TOKEN --builder->cursor #define REWIND_TOKEN --builder->cursor
#define TOKEN_AT(index) (builder->token_list->tokens[(index)]) #define TOKEN_AT(index) (builder->token_list->tokens[index])
#define STRING_AT(index) &builder->token_list->source[builder->token_list->tokens[index].offset]
#define END_REACHED (builder->cursor >= builder->token_list->num_tokens) #define END_REACHED (builder->cursor >= builder->token_list->num_tokens)
pac_ast_status_e pac_build_ast_reference(pac_ast_builder_s *builder, pac_ast_reference_s *reference) pac_ast_status_e pac_build_ast_reference(pac_ast_builder_s *builder, pac_ast_reference_s *reference)
{ {
usz_t start_cursor = TOKEN_CURSOR;
if(CURRENT_TOKEN.type != PAC_TOKEN_SIGN_OPEN_TAG) if(CURRENT_TOKEN.type != PAC_TOKEN_SIGN_OPEN_TAG)
{ {
// This is only possible with malformed state. pac_internal_error_s error;
error.type = PAC_INTERNAL_ERROR_INVALID_RETURNED_STATUS;
error.specifics.invalid_function_entry.function = "__FILE__:pac_build_ast_reference";
error.specifics.invalid_function_entry.error_description = "The function must be entered while at an opening tag token.";
pac_log_internal_error(builder->logger, error);
return PAC_AST_STATUS_NOT_RECOVERABLE; return PAC_AST_STATUS_NOT_RECOVERABLE;
} }
SKIP_TOKEN; SKIP_TOKEN;
@ -28,8 +33,6 @@ pac_ast_status_e pac_build_ast_reference(pac_ast_builder_s *builder, pac_ast_ref
{ {
return pac_ast_handle_invalid_reference_name_token(builder); return pac_ast_handle_invalid_reference_name_token(builder);
} }
usz_t len_name = CURRENT_TOKEN.length;
char *name = CURRENT_STRING;
SKIP_TOKEN; SKIP_TOKEN;
if(CURRENT_TOKEN.type != PAC_TOKEN_SIGN_CLOSE_TAG) if(CURRENT_TOKEN.type != PAC_TOKEN_SIGN_CLOSE_TAG)
@ -38,32 +41,41 @@ pac_ast_status_e pac_build_ast_reference(pac_ast_builder_s *builder, pac_ast_ref
} }
SKIP_TOKEN; SKIP_TOKEN;
if(CURRENT_TOKEN.type == PAC_TOKEN_SIGN_EQUALS) // Test if this reference is followed by an equals sign. That equals sign shouldn't
{ // be there anyways and it being there can be a hint for a missing semicolon making
return pac_ast_handle_reference_with_equals_sign(builder); // this reference actually be a rule header.
} if(!END_REACHED)
if(CURRENT_TOKEN.type == PAC_TOKEN_SIGN_EQUALS)
return pac_ast_handle_reference_with_equals_sign(builder);
reference->len_name = len_name; reference->len_name = TOKEN_AT(TOKEN_CURSOR-2).length;
reference->name = malloc(len_name+1); reference->name = pac_arena_alloc(&builder->string_arena, reference->len_name + 1);
pac_memory_copy(reference->name, name, len_name); reference->name[reference->len_name] = 0x00;
reference->name[len_name] = 0x00; pac_memory_copy(reference->name, STRING_AT(start_cursor+1), reference->len_name);
return PAC_AST_STATUS_SUCCESS; return PAC_AST_STATUS_SUCCESS;
} }
pac_ast_status_e pac_build_ast_item(pac_ast_builder_s *builder, pac_ast_item_s *item) pac_ast_status_e pac_build_ast_string_literal(pac_ast_builder_s *builder, pac_ast_string_literal_s *literal)
{
usz_t len_literal = CURRENT_TOKEN.length;
char *text = CURRENT_STRING;
literal->length = len_literal;
literal->string = pac_arena_alloc(&builder->string_arena, len_literal + 1);
literal->string[len_literal] = 0x00;
pac_memory_copy(literal->string, text, len_literal);
SKIP_TOKEN;
return PAC_AST_STATUS_SUCCESS;
}
pac_ast_status_e pac_build_ast_item(pac_ast_builder_s *builder, pac_ast_item_s *item, char *rule_name, usz_t variant_index, usz_t item_index)
{ {
item->type = PAC_AST_ITEM_INVALID; item->type = PAC_AST_ITEM_INVALID;
pac_memory_zero(item, sizeof(pac_ast_item_s)); pac_memory_zero(item, sizeof(pac_ast_item_s));
if(CURRENT_TOKEN.type == PAC_TOKEN_LIT_STRING) if(CURRENT_TOKEN.type == PAC_TOKEN_LIT_STRING)
{ {
item->type = PAC_AST_ITEM_LITERAL; item->type = PAC_AST_ITEM_LITERAL;
item->data.literal.length = CURRENT_TOKEN.length; return pac_build_ast_string_literal(builder, &item->data.string_literal);
item->data.literal.string = malloc(item->data.literal.length + 1);
pac_memory_copy(item->data.literal.string, CURRENT_STRING, CURRENT_TOKEN.length);
item->data.literal.string[item->data.literal.length] = 0x00;
SKIP_TOKEN;
return PAC_AST_STATUS_SUCCESS;
} }
if(CURRENT_TOKEN.type == PAC_TOKEN_SIGN_OPEN_TAG) if(CURRENT_TOKEN.type == PAC_TOKEN_SIGN_OPEN_TAG)
@ -87,9 +99,7 @@ pac_ast_status_e pac_build_ast_item(pac_ast_builder_s *builder, pac_ast_item_s *
SKIP_TOKEN; SKIP_TOKEN;
return PAC_AST_STATUS_SUCCESS; return PAC_AST_STATUS_SUCCESS;
} }
builder->failed = TRUE; return pac_ast_handle_unknown_item_type(builder, rule_name, variant_index, item_index);
SKIP_TOKEN; // Skip to (probably) the next item.
return PAC_AST_STATUS_STOP_ESCALATING_IN_VARIANT_PARSER;
} }
pac_ast_status_e pac_build_ast_variant(pac_ast_builder_s *builder, pac_ast_variant_s *variant, char *rule_name, usz_t variant_index) pac_ast_status_e pac_build_ast_variant(pac_ast_builder_s *builder, pac_ast_variant_s *variant, char *rule_name, usz_t variant_index)
@ -105,18 +115,18 @@ pac_ast_status_e pac_build_ast_variant(pac_ast_builder_s *builder, pac_ast_varia
items_capacity *= 2; items_capacity *= 2;
variant->items = calloc(sizeof(pac_ast_item_s), items_capacity); variant->items = calloc(sizeof(pac_ast_item_s), items_capacity);
} }
pac_ast_status_e status = pac_build_ast_item(builder, &variant->items[variant->num_items]); pac_ast_status_e status =
++variant->num_items; pac_build_ast_item(builder, &variant->items[variant->num_items], rule_name, variant->num_items, variant->num_items);
if(status == PAC_AST_STATUS_STOP_ESCALATING_IN_VARIANT_PARSER) if(status == PAC_AST_STATUS_STOP_ESCALATING_IN_VARIANT_PARSER)
{
continue; continue;
}
if(status != PAC_AST_STATUS_SUCCESS) if(status != PAC_AST_STATUS_SUCCESS)
{
return status; return status;
}
++variant->num_items;
// Test for the end of this variant (and possibly the rule it belongs to).
if( if(
(CURRENT_TOKEN.type == PAC_TOKEN_SIGN_VERTICAL_BAR) (CURRENT_TOKEN.type == PAC_TOKEN_SIGN_VERTICAL_BAR)
|| (CURRENT_TOKEN.type == PAC_TOKEN_SIGN_SEMICOLON) || (CURRENT_TOKEN.type == PAC_TOKEN_SIGN_SEMICOLON)
@ -124,11 +134,14 @@ pac_ast_status_e pac_build_ast_variant(pac_ast_builder_s *builder, pac_ast_varia
return PAC_AST_STATUS_SUCCESS; return PAC_AST_STATUS_SUCCESS;
} }
if(CURRENT_TOKEN.type != PAC_TOKEN_SIGN_COMMA) // Test if there is no delimiter and, if three is none, handle the error.
{ if(
pac_ast_status_e comma_missing_status = pac_ast_handle_missing_item_delimiter(builder); (CURRENT_TOKEN.type != PAC_TOKEN_SIGN_COMMA)
if(comma_missing_status != PAC_AST_STATUS_ERROR_HANDLED) return comma_missing_status; && (CURRENT_TOKEN.type != PAC_TOKEN_SIGN_HYPHEN)
) {
status = pac_ast_handle_missing_item_delimiter(builder, rule_name, variant_index, variant->num_items);
if(status != PAC_AST_STATUS_ERROR_HANDLED) return status;
continue;
} }
SKIP_TOKEN; SKIP_TOKEN;
} }
@ -141,7 +154,12 @@ pac_ast_status_e pac_skip_ast_rule_header(pac_ast_builder_s *builder)
{ {
if(CURRENT_TOKEN.type != PAC_TOKEN_SIGN_OPEN_TAG) if(CURRENT_TOKEN.type != PAC_TOKEN_SIGN_OPEN_TAG)
{ {
// Invalid state pac_internal_error_s error;
error.type = PAC_INTERNAL_ERROR_INVALID_RETURNED_STATUS;
error.specifics.invalid_function_entry.function = "__FILE__:pac_skip_ast_rule_header";
error.specifics.invalid_function_entry.error_description = "The function must be entered while at an opening tag token.";
pac_log_internal_error(builder->logger, error);
return PAC_AST_STATUS_NOT_RECOVERABLE; return PAC_AST_STATUS_NOT_RECOVERABLE;
} }
SKIP_TOKEN; SKIP_TOKEN;
@ -158,7 +176,7 @@ pac_ast_status_e pac_skip_ast_rule_header(pac_ast_builder_s *builder)
if(CURRENT_TOKEN.type != PAC_TOKEN_SIGN_CLOSE_TAG) if(CURRENT_TOKEN.type != PAC_TOKEN_SIGN_CLOSE_TAG)
{ {
if((status = pac_ast_handle_missing_rule_closing_sign(builder) != PAC_AST_STATUS_ERROR_HANDLED)) if((status = pac_ast_handle_missing_rule_header_closing_sign(builder) != PAC_AST_STATUS_ERROR_HANDLED))
return status; return status;
} }
SKIP_TOKEN; SKIP_TOKEN;
@ -184,13 +202,11 @@ pac_ast_status_e pac_build_ast_rule(pac_ast_builder_s *builder, pac_ast_rule_s *
usz_t start_index = TOKEN_CURSOR; usz_t start_index = TOKEN_CURSOR;
pac_skip_ast_rule_header(builder); pac_skip_ast_rule_header(builder);
// Parse all variants
usz_t len_name = TOKEN_AT(start_index+1).length; usz_t len_name = TOKEN_AT(start_index+1).length;
usz_t name_offset = TOKEN_AT(start_index+1).offset; usz_t name_offset = TOKEN_AT(start_index+1).offset;
char *name_pointer = &builder->token_list->source[name_offset]; char *name_pointer = &builder->token_list->source[name_offset];
rule->name = malloc(len_name + 1); rule->name = pac_arena_alloc(&builder->string_arena, len_name + 1);
pac_memory_copy(rule->name, name_pointer, len_name); pac_memory_copy(rule->name, name_pointer, len_name);
rule->name[len_name] = 0; rule->name[len_name] = 0;
@ -210,41 +226,39 @@ pac_ast_status_e pac_build_ast_rule(pac_ast_builder_s *builder, pac_ast_rule_s *
{ {
case PAC_AST_STATUS_SUCCESS: case PAC_AST_STATUS_SUCCESS:
break; break;
case PAC_AST_STATUS_NOT_RECOVERABLE:
return PAC_AST_STATUS_NOT_RECOVERABLE;
case PAC_AST_STATUS_NOT_RECOVERABLE:
case PAC_AST_STATUS_CONTINUE_AFTER_FINDING_NEXT_RULE: case PAC_AST_STATUS_CONTINUE_AFTER_FINDING_NEXT_RULE:
puts("Failed parsing a rule's variant, recovering at next rule!"); case PAC_AST_STATUS_UNEXPECTED_FILE_END:
return PAC_AST_STATUS_CONTINUE_AFTER_FINDING_NEXT_RULE; return status;
case PAC_AST_STATUS_STOP_ESCALATING_IN_RULE_PARSER: case PAC_AST_STATUS_STOP_ESCALATING_IN_RULE_PARSER:
{ {
builder->failed = TRUE;
printf("Failed parsing a rule's variant, ");
while(!END_REACHED) while(!END_REACHED)
{ {
// For continuing with the next variant of this rule.
if(CURRENT_TOKEN.type == PAC_TOKEN_SIGN_VERTICAL_BAR) if(CURRENT_TOKEN.type == PAC_TOKEN_SIGN_VERTICAL_BAR)
{
puts("continuing with the next variant.");
break; break;
}
// For exiting this rule and continuing with a possible next one.
if(CURRENT_TOKEN.type == PAC_TOKEN_SIGN_SEMICOLON) if(CURRENT_TOKEN.type == PAC_TOKEN_SIGN_SEMICOLON)
{
puts("continuing with next rule.");
SKIP_TOKEN;
return PAC_AST_STATUS_CONTINUE_AFTER_FINDING_NEXT_RULE; return PAC_AST_STATUS_CONTINUE_AFTER_FINDING_NEXT_RULE;
}
SKIP_TOKEN; SKIP_TOKEN;
} }
} break; } return PAC_AST_STATUS_UNEXPECTED_FILE_END;
case PAC_AST_STATUS_UNEXPECTED_FILE_END:
return PAC_AST_STATUS_UNEXPECTED_FILE_END;
default: default:
printf("Internal Error: An invalid status code was produced: %d\n", status); pac_internal_error_s error;
error.type = PAC_INTERNAL_ERROR_INVALID_RETURNED_STATUS;
error.specifics.invalid_returned_status.function = "__FILE__:pac_build_ast_rule";
error.specifics.invalid_returned_status.immediate_returner = "__FILE__:pac_build_ast_variant";
error.specifics.invalid_returned_status.value = pac_ast_stringify_status(status);
pac_log_internal_error(builder->logger, error);
return PAC_AST_STATUS_NOT_RECOVERABLE; return PAC_AST_STATUS_NOT_RECOVERABLE;
} }
// It only goes here in the case of PAC_AST_STATUS_SUCCESS
if(CURRENT_TOKEN.type == PAC_TOKEN_SIGN_SEMICOLON) if(CURRENT_TOKEN.type == PAC_TOKEN_SIGN_SEMICOLON)
{ {
@ -261,7 +275,7 @@ pac_ast_status_e pac_build_ast_rule(pac_ast_builder_s *builder, pac_ast_rule_s *
return PAC_AST_STATUS_UNEXPECTED_FILE_END; return PAC_AST_STATUS_UNEXPECTED_FILE_END;
} }
void pac_ast_find_next_rule(pac_ast_builder_s *builder) void pac_ast_skip_to_next_rule(pac_ast_builder_s *builder)
{ {
while(!END_REACHED) while(!END_REACHED)
{ {
@ -275,7 +289,7 @@ void pac_ast_find_next_rule(pac_ast_builder_s *builder)
return; return;
} }
pac_ast_s pac_build_ast(pac_tlist_s tokens) pac_ast_s pac_build_ast(pac_tlist_s tokens, pac_logger_s *logger)
{ {
usz_t rules_capacity = 32; usz_t rules_capacity = 32;
pac_ast_s ast; pac_ast_s ast;
@ -284,9 +298,10 @@ pac_ast_s pac_build_ast(pac_tlist_s tokens)
pac_ast_builder_s builder; pac_ast_builder_s builder;
builder.cursor = 0; builder.cursor = 0;
builder.logger = pac_create_logger();
builder.token_list = &tokens; builder.token_list = &tokens;
builder.failed = FALSE; builder.failed = FALSE;
builder.string_arena = pac_create_arena(1024 * 256); // 262144 (2^18)
builder.logger = logger;
while(builder.cursor < tokens.num_tokens) while(builder.cursor < tokens.num_tokens)
{ {
@ -299,20 +314,65 @@ pac_ast_s pac_build_ast(pac_tlist_s tokens)
pac_ast_status_e status = pac_build_ast_rule(&builder, &ast.rules[ast.num_rules]); pac_ast_status_e status = pac_build_ast_rule(&builder, &ast.rules[ast.num_rules]);
if(status == PAC_AST_STATUS_CONTINUE_AFTER_FINDING_NEXT_RULE) if(status == PAC_AST_STATUS_CONTINUE_AFTER_FINDING_NEXT_RULE)
pac_ast_find_next_rule(&builder); pac_ast_skip_to_next_rule(&builder);
if(status == PAC_AST_STATUS_UNEXPECTED_FILE_END) if(status == PAC_AST_STATUS_UNEXPECTED_FILE_END)
{
puts("File ended prematurely!");
break; break;
}
if(status != PAC_AST_STATUS_SUCCESS) if(status != PAC_AST_STATUS_SUCCESS)
{ break;
printf("Failed parsing a rule at index: %lu with status code: %d!\n", builder.cursor, status);
continue;
}
++ast.num_rules; ++ast.num_rules;
} }
ast.string_arena = builder.string_arena;
return ast; return ast;
} }
void pac_delete_ast_variant(pac_ast_variant_s *variant)
{
free(variant->items);
}
void pac_delete_ast_rule(pac_ast_rule_s *rule)
{
usz_t variant_index = 0;
while(variant_index < rule->num_variants)
{
pac_delete_ast_variant(&rule->variants[variant_index]);
++variant_index;
}
free(rule->variants);
}
void pac_delete_ast(pac_ast_s ast)
{
usz_t rule_index = 0;
while(rule_index < ast.num_rules)
{
pac_delete_ast_rule(&ast.rules[rule_index]);
++rule_index;
}
free(ast.rules);
pac_delete_arena(ast.string_arena);
}
char * pac_ast_stringify_status(pac_ast_status_e status)
{
switch(status)
{
case PAC_AST_STATUS_SUCCESS: return "SUCCESS";
case PAC_AST_STATUS_ERROR_HANDLED: return "ERROR_HANDLED";
case PAC_AST_STATUS_STOP_ESCALATING_IN_ITEM_PARSER: return "ESCALATE_TO_ITEM_PARSER";
case PAC_AST_STATUS_STOP_ESCALATING_IN_VARIANT_PARSER: return "ESCALATE_TO_VARIANT_PARSER";
case PAC_AST_STATUS_STOP_ESCALATING_IN_RULE_PARSER: return "ESCALATE_TO_RULE_PARSER";
case PAC_AST_STATUS_CONTINUE_AFTER_FINDING_NEXT_VARIANT: return "FIND_NEXT_VARIANT";
case PAC_AST_STATUS_CONTINUE_AFTER_FINDING_NEXT_RULE: return "FIND_NEXT_RULE";
case PAC_AST_STATUS_NOT_RECOVERABLE: return "NOT_RECOVERABLE";
case PAC_AST_STATUS_UNEXPECTED_FILE_END: return "UNEXPECTED_END";
}
return " - ";
}

139
core-parser/src/ast_errors.c
View File

@ -12,6 +12,15 @@
char * pac_identify_present_construct(pac_ast_builder_s *builder)
{
switch(CURRENT_TOKEN.type)
{
case PAC_TOKEN_SIGN_OPEN_TAG: return "RULE_IDENTIFIER";
default: return "UNKNOWN";
}
}
bool_t pac_ast_builder_forward_seek_token_type(pac_ast_builder_s *builder, pac_token_e type, usz_t max_steps) bool_t pac_ast_builder_forward_seek_token_type(pac_ast_builder_s *builder, pac_token_e type, usz_t max_steps)
{ {
usz_t cursor_backup = TOKEN_CURSOR; usz_t cursor_backup = TOKEN_CURSOR;
@ -58,6 +67,8 @@ bool_t pac_ast_builder_forward_seek_item_start(pac_ast_builder_s *builder, usz_t
pac_ast_status_e pac_ast_handle_invalid_reference_name_token(pac_ast_builder_s *builder) pac_ast_status_e pac_ast_handle_invalid_reference_name_token(pac_ast_builder_s *builder)
{ {
usz_t open_tag_src_offset = TOKEN_AT(TOKEN_CURSOR-1).offset; usz_t open_tag_src_offset = TOKEN_AT(TOKEN_CURSOR-1).offset;
@ -84,7 +95,7 @@ pac_ast_status_e pac_ast_handle_invalid_reference_name_token(pac_ast_builder_s *
char *given_rule_name = pac_log_alloc(&builder->logger, len_reference_name + 1); char *given_rule_name = pac_log_alloc(&builder->logger, len_reference_name + 1);
pac_memory_copy(given_rule_name, &builder->token_list->source[open_tag_src_offset], len_reference_name); pac_memory_copy(given_rule_name, &builder->token_list->source[open_tag_src_offset], len_reference_name);
pac_naming_error_s error; pac_naming_error_s error;
error.type = PAC_NAMING_ERROR_INVALID_RULE_NAME; error.type = PAC_NAMING_ERROR_INVALID_REFERENCE_NAME;
error.line = CURRENT_TOKEN.line; error.line = CURRENT_TOKEN.line;
error.column = CURRENT_TOKEN.column; error.column = CURRENT_TOKEN.column;
error.specifics.invalid_rule_name.given_rule_name = given_rule_name; error.specifics.invalid_rule_name.given_rule_name = given_rule_name;
@ -94,22 +105,23 @@ pac_ast_status_e pac_ast_handle_invalid_reference_name_token(pac_ast_builder_s *
builder->failed = TRUE; builder->failed = TRUE;
if(!pac_ast_builder_forward_seek_item_start(builder, 4)) if(!pac_ast_builder_forward_seek_item_start(builder, 4))
return PAC_AST_STATUS_NOT_RECOVERABLE; return PAC_AST_STATUS_CONTINUE_AFTER_FINDING_NEXT_RULE;
return PAC_AST_STATUS_STOP_ESCALATING_IN_VARIANT_PARSER; return PAC_AST_STATUS_STOP_ESCALATING_IN_VARIANT_PARSER;
} }
pac_ast_status_e pac_ast_handle_missing_reference_close_tag(pac_ast_builder_s *builder) pac_ast_status_e pac_ast_handle_missing_reference_close_tag(pac_ast_builder_s *builder)
{ {
builder->failed = TRUE;
pac_syntax_error_s error; pac_syntax_error_s error;
error.type = PAC_SYNTAX_ERROR_MISSING_TOKEN; error.type = PAC_SYNTAX_ERROR_MISSING_TOKEN;
error.line = CURRENT_TOKEN.line; error.location.line = CURRENT_TOKEN.line;
error.column = CURRENT_TOKEN.column; error.location.column = CURRENT_TOKEN.column;
error.specifics.missing_token.hint = NULL; error.specifics.missing_token.hint = NULL;
error.specifics.missing_token.wanted_token = "Tag Closer (>)"; error.specifics.missing_token.wanted_token = "Tag Closer (>)";
pac_log_syntax_error(&builder->logger, error); pac_log_syntax_error(&builder->logger, error);
builder->failed = TRUE;
return PAC_AST_STATUS_STOP_ESCALATING_IN_VARIANT_PARSER; return PAC_AST_STATUS_STOP_ESCALATING_IN_VARIANT_PARSER;
} }
@ -117,8 +129,8 @@ pac_ast_status_e pac_ast_handle_reference_with_equals_sign(pac_ast_builder_s *bu
{ {
pac_syntax_error_s error; pac_syntax_error_s error;
error.type = PAC_SYNTAX_ERROR_ODD_TOKEN; error.type = PAC_SYNTAX_ERROR_ODD_TOKEN;
error.line = CURRENT_TOKEN.line; error.location.line = CURRENT_TOKEN.line;
error.column = CURRENT_TOKEN.column; error.location.column = CURRENT_TOKEN.column;
error.specifics.odd_token.hint = "There might be a semicolon missing 4 tokens ago."; error.specifics.odd_token.hint = "There might be a semicolon missing 4 tokens ago.";
error.specifics.odd_token.num_valid_options = 1; error.specifics.odd_token.num_valid_options = 1;
error.specifics.odd_token.valid_options[0] = "Any Rule Item"; error.specifics.odd_token.valid_options[0] = "Any Rule Item";
@ -129,62 +141,117 @@ pac_ast_status_e pac_ast_handle_reference_with_equals_sign(pac_ast_builder_s *bu
} }
pac_ast_status_e pac_ast_handle_missing_item_delimiter(pac_ast_builder_s *builder, char *rule_name, usz_t variant_index, usz_t item_index)
pac_ast_status_e pac_ast_handle_unknown_item_type(pac_ast_builder_s *builder)
{ {
builder->failed = TRUE;
pac_syntax_error_s error; pac_syntax_error_s error;
error.type = PAC_SYNTAX_ERROR_ODD_TOKEN; error.type = PAC_SYNTAX_ERROR_ODD_TOKEN;
error.line = CURRENT_TOKEN.line; error.location.line = CURRENT_TOKEN.line;
error.column = CURRENT_TOKEN.column; error.location.column = CURRENT_TOKEN.column;
error.specifics.odd_token.num_valid_options = 1; error.specifics.odd_token.present_token = pac_stringify_token_type(CURRENT_TOKEN.type);
error.specifics.odd_token.valid_options[0] = "Any Rule Item"; error.specifics.odd_token.num_valid_options = 2;
error.specifics.odd_token.valid_options[0] = pac_stringify_token_type(PAC_TOKEN_SIGN_COMMA);
error.specifics.odd_token.valid_options[1] = pac_stringify_token_type(PAC_TOKEN_SIGN_HYPHEN);
pac_log_syntax_error(&builder->logger, error); pac_log_syntax_error(&builder->logger, error);
SKIP_TOKEN;
if(!pac_ast_builder_forward_seek_item_start(builder, 3))
return PAC_AST_STATUS_NOT_RECOVERABLE;
builder->failed = TRUE;
return PAC_AST_STATUS_STOP_ESCALATING_IN_VARIANT_PARSER;
}
pac_ast_status_e pac_ast_handle_missing_item_delimiter(pac_ast_builder_s *builder)
{
SKIP_TOKEN;
puts("Missing the item delimiter!");
builder->failed = TRUE;
return PAC_AST_STATUS_ERROR_HANDLED; return PAC_AST_STATUS_ERROR_HANDLED;
} }
pac_ast_status_e pac_ast_handle_missing_equals_sign_after_rule_header(pac_ast_builder_s *builder) pac_ast_status_e pac_ast_handle_missing_equals_sign_after_rule_header(pac_ast_builder_s *builder)
{ {
puts("Missing Equals sign after rule header!");
builder->failed = TRUE; builder->failed = TRUE;
pac_syntax_error_s error;
error.type = PAC_SYNTAX_ERROR_ODD_TOKEN;
error.location.line = CURRENT_TOKEN.line;
error.location.column = CURRENT_TOKEN.column;
error.specifics.odd_token.present_token = pac_stringify_token_type(CURRENT_TOKEN.type);
error.specifics.odd_token.num_valid_options = 1;
error.specifics.odd_token.valid_options[0] = pac_stringify_token_type(PAC_TOKEN_SIGN_EQUALS);
// Continue at first item (if possible) // Continue at first item (if possible)
if(!pac_ast_builder_forward_seek_item_start(builder, 2)) if(!pac_ast_builder_forward_seek_item_start(builder, 2))
{
error.specifics.odd_token.hint = "Missing equals sign after rule header. Continuing at next rule.";
pac_log_syntax_error(&builder->logger, error);
return PAC_AST_STATUS_CONTINUE_AFTER_FINDING_NEXT_RULE; return PAC_AST_STATUS_CONTINUE_AFTER_FINDING_NEXT_RULE;
}
error.specifics.odd_token.hint = "Missing equals sign after rule header. Continuing at next item.";
pac_log_syntax_error(&builder->logger, error);
return PAC_AST_STATUS_ERROR_HANDLED; return PAC_AST_STATUS_ERROR_HANDLED;
} }
pac_ast_status_e pac_ast_handle_invalid_rule_name(pac_ast_builder_s *builder) pac_ast_status_e pac_ast_handle_invalid_rule_name(pac_ast_builder_s *builder)
{ {
builder->failed = TRUE; builder->failed = TRUE;
pac_syntax_error_s error;
error.type = PAC_SYNTAX_ERROR_ODD_TOKEN;
error.location.line = CURRENT_TOKEN.line;
error.location.column = CURRENT_TOKEN.column;
error.specifics.odd_token.present_token = pac_stringify_token_type(CURRENT_TOKEN.type);
error.specifics.odd_token.num_valid_options = 1;
error.specifics.odd_token.valid_options[0] = pac_stringify_token_type(PAC_TOKEN_WORD);
if(!pac_ast_builder_forward_seek_token_type(builder, PAC_TOKEN_SIGN_EQUALS, 3)) if(!pac_ast_builder_forward_seek_token_type(builder, PAC_TOKEN_SIGN_EQUALS, 3))
{
error.specifics.odd_token.hint = "Invalid rule name. Continuing at next rule due to missing equals sign.";
pac_log_syntax_error(&builder->logger, error);
return PAC_AST_STATUS_CONTINUE_AFTER_FINDING_NEXT_RULE; return PAC_AST_STATUS_CONTINUE_AFTER_FINDING_NEXT_RULE;
}
error.specifics.odd_token.hint = "Invalid rule name. Continuing after the equals sign.";
pac_log_syntax_error(&builder->logger, error);
return PAC_AST_STATUS_ERROR_HANDLED; return PAC_AST_STATUS_ERROR_HANDLED;
} }
pac_ast_status_e pac_ast_handle_missing_rule_closing_sign(pac_ast_builder_s *builder) pac_ast_status_e pac_ast_handle_missing_rule_header_closing_sign(pac_ast_builder_s *builder)
{ {
puts("Missing Tag closing sign!"); builder->failed = TRUE;
builder->failed = TRUE;
// Continue at equals sign (if possible) pac_syntax_error_s error;
if(!pac_ast_builder_forward_seek_token_type(builder, PAC_TOKEN_SIGN_EQUALS, 2)) error.type = PAC_SYNTAX_ERROR_ODD_TOKEN;
return PAC_AST_STATUS_CONTINUE_AFTER_FINDING_NEXT_RULE; error.location.line = CURRENT_TOKEN.line;
error.location.column = CURRENT_TOKEN.column;
error.specifics.odd_token.present_token = pac_stringify_token_type(CURRENT_TOKEN.type);
error.specifics.odd_token.num_valid_options = 1;
error.specifics.odd_token.valid_options[0] = pac_stringify_token_type(PAC_TOKEN_SIGN_CLOSE_TAG);
// The next step in the calling function is to advance and check for the equals sign, // Continue at equals sign (if possible)
// thus, it is necessary to go one back for it to find it again when advancing. if(!pac_ast_builder_forward_seek_token_type(builder, PAC_TOKEN_SIGN_EQUALS, 3))
REWIND_TOKEN; {
return PAC_AST_STATUS_ERROR_HANDLED; return PAC_AST_STATUS_CONTINUE_AFTER_FINDING_NEXT_RULE;
}
error.specifics.odd_token.hint = "Continuing parser process after the next equals sign.";
// The next step in the calling function is to advance and check for the equals sign,
// thus, it is necessary to go one back for it to find it again when advancing.
REWIND_TOKEN;
return PAC_AST_STATUS_ERROR_HANDLED;
}
pac_ast_status_e pac_ast_handle_unknown_item_type(pac_ast_builder_s *builder, char *rule_name, usz_t variant_index, usz_t item_index)
{
builder->failed = TRUE;
pac_syntax_error_s error;
error.type = PAC_SYNTAX_ERROR_ODD_TOKEN;
error.location.line = CURRENT_TOKEN.line;
error.location.column = CURRENT_TOKEN.column;
error.specifics.odd_token.present_token = pac_stringify_token_type(CURRENT_TOKEN.type);
error.specifics.odd_token.num_valid_options = 1;
error.specifics.odd_token.valid_options[0] = pac_stringify_token_type(PAC_TOKEN_SIGN_CLOSE_TAG);
if(!pac_ast_builder_forward_seek_item_start(builder, 5))
{
if(pac_ast_builder_forward_seek_token_type(builder, PAC_TOKEN_SIGN_VERTICAL_BAR, 5))
return PAC_AST_STATUS_CONTINUE_AFTER_FINDING_NEXT_VARIANT;
return PAC_AST_STATUS_CONTINUE_AFTER_FINDING_NEXT_RULE;
}
return PAC_AST_STATUS_STOP_ESCALATING_IN_VARIANT_PARSER;
} }

20
core-parser/src/grammar.c
View File

@ -4,14 +4,21 @@
#include <string.h> #include <string.h>
extern pac_grammar_s pac_link_grammar(pac_ast_s ast); extern void pac_link_grammar(pac_grammar_s *grammar, pac_ast_s ast);
pac_grammar_s pac_convert_grammar(char *source) pac_grammar_s pac_convert_grammar(char *source, usz_t len_source)
{ {
usz_t len_source = strlen(source); pac_logger_s logger = pac_create_logger();
pac_grammar_s grammar;
grammar.result_arena = pac_create_arena(1024 * 1024);
pac_tlist_s tokens = pac_tokenize_grammar(source, len_source); pac_tlist_s tokens = pac_tokenize_grammar(source, len_source);
pac_ast_s ast = pac_build_ast(tokens); pac_ast_s ast = pac_build_ast(tokens, &logger);
pac_grammar_s grammar = pac_link_grammar(ast); grammar.log = logger;
pac_link_grammar(&grammar, ast);
pac_delete_ast(ast);
pac_delete_token_list(tokens);
return grammar; return grammar;
} }
@ -23,5 +30,6 @@ void pac_display_grammar(pac_grammar_s grammar)
void pac_delete_grammar(pac_grammar_s grammar) void pac_delete_grammar(pac_grammar_s grammar)
{ {
pac_delete_arena(grammar.result_arena);
pac_delete_logger(grammar.log);
} }

22
core-parser/src/linker.c
View File

@ -14,7 +14,7 @@ void pac_copy_empty_rules_from_ast_to_grammar(pac_grammar_s *grammar, pac_ast_s
pac_ast_rule_s ast_rule = ast->rules[rule_index]; pac_ast_rule_s ast_rule = ast->rules[rule_index];
pac_rule_s *rule = &grammar->rules[rule_index]; pac_rule_s *rule = &grammar->rules[rule_index];
usz_t len_rule_name = strlen(ast_rule.name); usz_t len_rule_name = strlen(ast_rule.name);
rule->name = malloc(len_rule_name + 1); rule->name = pac_arena_alloc(&grammar->result_arena, len_rule_name + 1);
pac_memory_copy(rule->name, ast_rule.name, len_rule_name); pac_memory_copy(rule->name, ast_rule.name, len_rule_name);
rule->name[len_rule_name] = 0x00; rule->name[len_rule_name] = 0x00;
} }
@ -46,7 +46,7 @@ pac_rule_s * pac_find_rule(pac_grammar_s *grammar, char *name)
void pac_copy_single_variant(pac_grammar_s *grammar, pac_variant_s *variant, pac_ast_variant_s *ast_variant) void pac_copy_single_variant(pac_grammar_s *grammar, pac_variant_s *variant, pac_ast_variant_s *ast_variant)
{ {
variant->num_items = ast_variant->num_items; variant->num_items = ast_variant->num_items;
variant->items = malloc(sizeof(pac_item_s) * variant->num_items); variant->items = pac_arena_alloc(&grammar->result_arena, sizeof(pac_item_s) * variant->num_items);
for(usz_t item_index = 0; item_index < variant->num_items; ++item_index) for(usz_t item_index = 0; item_index < variant->num_items; ++item_index)
{ {
pac_ast_item_s ast_item = ast_variant->items[item_index]; pac_ast_item_s ast_item = ast_variant->items[item_index];
@ -61,8 +61,8 @@ void pac_copy_single_variant(pac_grammar_s *grammar, pac_variant_s *variant, pac
case PAC_AST_ITEM_LITERAL: case PAC_AST_ITEM_LITERAL:
{ {
item->type = PAC_ITEM_LITERAL; item->type = PAC_ITEM_LITERAL;
item->data.literal.length = ast_item.data.literal.length; item->data.literal.length = ast_item.data.string_literal.length;
item->data.literal.string = ast_item.data.literal.string; // TODO: Copy this into a grammar-owned arena! item->data.literal.string = ast_item.data.string_literal.string; // TODO: Copy this into a grammar-owned arena!
} break; } break;
case PAC_AST_ITEM_REFERENCE: case PAC_AST_ITEM_REFERENCE:
@ -88,23 +88,21 @@ void pac_copy_variants_and_link_references(pac_grammar_s *grammar, pac_ast_s *as
pac_ast_rule_s ast_rule = ast->rules[rule_index]; pac_ast_rule_s ast_rule = ast->rules[rule_index];
pac_rule_s *rule = &grammar->rules[rule_index]; pac_rule_s *rule = &grammar->rules[rule_index];
rule->num_variants = ast_rule.num_variants; rule->num_variants = ast_rule.num_variants;
rule->variants = malloc(sizeof(pac_variant_s) * rule->num_variants); rule->variants = pac_arena_alloc(&grammar->result_arena, sizeof(pac_variant_s) * rule->num_variants);
for(usz_t variant_index = 0; variant_index < rule->num_variants; ++variant_index) for(usz_t variant_index = 0; variant_index < rule->num_variants; ++variant_index)
{ {
pac_copy_single_variant(grammar, &rule->variants[variant_index], &ast_rule.variants[variant_index]); pac_copy_single_variant(grammar, &rule->variants[variant_index], &ast_rule.variants[variant_index]);
} }
} }
} }
pac_grammar_s pac_link_grammar(pac_ast_s ast) void pac_link_grammar(pac_grammar_s *grammar, pac_ast_s ast)
{ {
pac_grammar_s grammar; grammar->num_rules = ast.num_rules;
grammar.num_rules = ast.num_rules; grammar->rules = pac_arena_alloc(&grammar->result_arena, sizeof(pac_rule_s) * ast.num_rules);
grammar.rules = malloc(sizeof(pac_rule_s) * ast.num_rules);
pac_copy_empty_rules_from_ast_to_grammar(&grammar, &ast); pac_copy_empty_rules_from_ast_to_grammar(grammar, &ast);
pac_copy_variants_and_link_references(&grammar, &ast); pac_copy_variants_and_link_references(grammar, &ast);
return grammar; return grammar;
} }

30
core-parser/src/logger.c
View File

@ -13,6 +13,12 @@ pac_logger_s pac_create_logger()
return logger; return logger;
} }
void pac_delete_logger(pac_logger_s logger)
{
free(logger.errors);
pac_delete_arena(logger.string_arena);
}
void pac_resize_log_if_needed(pac_logger_s *logger) void pac_resize_log_if_needed(pac_logger_s *logger)
{ {
if(logger->num_errors >= logger->allocated_errors) if(logger->num_errors >= logger->allocated_errors)
@ -26,16 +32,32 @@ void pac_resize_log_if_needed(pac_logger_s *logger)
void pac_log_syntax_error(pac_logger_s *logger, pac_syntax_error_s error) void pac_log_syntax_error(pac_logger_s *logger, pac_syntax_error_s error)
{ {
pac_resize_log_if_needed(logger); pac_resize_log_if_needed(logger);
logger->errors[logger->num_errors].type = PAC_SYNTAX_ERROR; logger->errors[logger->num_errors].type = PAC_SYNTAX_ERROR;
logger->errors[logger->num_errors].specifics.syntax_error = error; logger->errors[logger->num_errors].specifics.syntax_error = error;
++logger->num_errors; ++logger->num_errors;
} }
void pac_log_naming_error(pac_logger_s *logger, pac_naming_error_s error) void pac_log_naming_error(pac_logger_s *logger, pac_naming_error_s error)
{ {
pac_resize_log_if_needed(logger); pac_resize_log_if_needed(logger);
logger->errors[logger->num_errors].type = PAC_NAMING_ERROR; logger->errors[logger->num_errors].type = PAC_NAMING_ERROR;
logger->errors[logger->num_errors].specifics.naming_error = error; logger->errors[logger->num_errors].specifics.naming_error = error;
++logger->num_errors;
}
void pac_log_validation_error(pac_logger_s *logger, pac_validation_error_s error)
{
pac_resize_log_if_needed(logger);
logger->errors[logger->num_errors].type = PAC_VALIDATION_ERROR;
logger->errors[logger->num_errors].specifics.validation_error = error;
++logger->num_errors;
}
void pac_log_internal_error(pac_logger_s *logger, pac_internal_error_s error)
{
pac_resize_log_if_needed(logger);
logger->errors[logger->num_errors].type = PAC_INTERNAL_ERROR;
logger->errors[logger->num_errors].specifics.internal_error = error;
++logger->num_errors; ++logger->num_errors;
} }

11
core-parser/src/tokenizer.c
View File

@ -48,9 +48,11 @@ pac_tlist_s pac_tokenize_grammar(char *source, usz_t len_source)
usz_t tokens_capacity = 1024; usz_t tokens_capacity = 1024;
pac_tlist_s list; pac_tlist_s list;
list.source = source;
list.num_tokens = 0; list.num_tokens = 0;
list.tokens = calloc(sizeof(pac_token_s), tokens_capacity); list.tokens = calloc(sizeof(pac_token_s), tokens_capacity);
list.source = malloc(len_source + 1);
pac_memory_copy(list.source, source, len_source);
list.source[len_source] = 0;
usz_t line = 1; usz_t line = 1;
usz_t column = 1; usz_t column = 1;
@ -258,3 +260,10 @@ void pac_display_tlist(pac_tlist_s list)
); );
} }
} }
void pac_delete_token_list(pac_tlist_s list)
{
free(list.tokens);
free(list.source);
pac_memory_fill(&list, sizeof(pac_tlist_s), 0);
}