josh/propane
1
0
Fork 0
Code Issues 3 Pull Requests Projects Releases Wiki Activity

Replace p_context_init() with p_context_new()/p_context_delete()

Browse Source
This commit is contained in:
Josh Holtrop 2026-02-17 18:40:33 -05:00
parent 9f2fe6f84b
commit 6fd5186159
77 changed files with 728 additions and 610 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
CHANGELOG.md
View File

@ -1,3 +1,9 @@
## v4.0.0
### Breaking Changes
- Replace `p_context_init()` with `p_context_new()` and `p_context_delete()`.
## v3.0.0 ## v3.0.0
### New Features ### New Features
@ -12,7 +18,7 @@
- Document `p_lex()` and `p_token_info_t` in user guide (#37) - Document `p_lex()` and `p_token_info_t` in user guide (#37)
### Breaking changes ### Breaking Changes
- Rename AST generation mode to tree generation mode (see [UPGRADING.md](UPGRADING.md)) - Rename AST generation mode to tree generation mode (see [UPGRADING.md](UPGRADING.md))

13
UPGRADING.md
View File

@ -1,6 +1,17 @@
## v4.0.0
### API Changes
- Replace any calls to `p_context_init()` with `p_context_new()`.
- Replace any references to the address of a statically allocated context
structure with the pointer returned from `p_context_init()` (e.g. `&context`
-> `context`).
- Add a call to `p_context_delete()` (for C or C++) after lexing/parsing to
reclaim context memory.
## v3.0.0 ## v3.0.0
### Grammar changes ### Grammar Changes
- Rename `ast;` statement to `tree;`. - Rename `ast;` statement to `tree;`.
- Rename `ast_prefix;` statement to `tree_prefix;`. - Rename `ast_prefix;` statement to `tree_prefix;`.

46
assets/parser.c.erb
View File

@ -43,30 +43,48 @@ const char * <%= @grammar.prefix %>token_names[] = {
*************************************************************************/ *************************************************************************/
/** /**
* Initialize lexer/parser context structure. * Allocate and initialize lexer/parser context structure.
*
* Deinitialize and deallocate with <%= @grammar.prefix %>context_delete().
* *
* @param[out] context
* Lexer/parser context structure.
* @param input * @param input
* Text input. * Text input.
* @param input_length * @param input_length
* Text input length. * Text input length.
*
* @return Context structure for lexer/parser.
*/ */
void <%= @grammar.prefix %>context_init(<%= @grammar.prefix %>context_t * context, uint8_t const * input, size_t input_length) <%= @grammar.prefix %>context_t * <%= @grammar.prefix %>context_new(uint8_t const * input, size_t input_length)
{ {
/* New default-initialized context structure. */ <% if @cpp %>
<%= @grammar.prefix %>context_t newcontext; <%= @grammar.prefix %>context_t * context = new <%= @grammar.prefix %>context_t();
memset(&newcontext, 0, sizeof(newcontext)); <% else %>
<%= @grammar.prefix %>context_t * context = (<%= @grammar.prefix %>context_t *)calloc(1, sizeof(<%= @grammar.prefix %>context_t));
<% end %>
/* Lexer initialization. */ /* Lexer initialization. */
newcontext.input = input; context->input = input;
newcontext.input_length = input_length; context->input_length = input_length;
newcontext.text_position.row = 1u; context->text_position.row = 1u;
newcontext.text_position.col = 1u; context->text_position.col = 1u;
newcontext.mode = <%= @lexer.mode_id("default") %>; context->mode = <%= @lexer.mode_id("default") %>;
/* Copy to the user's context structure. */ return context;
*context = newcontext; }
/**
* Deinitialize and deallocate lexer/parser context structure.
*
* @param context
* Lexer/parser context structure allocated with <%= @grammar.prefix %>context_new().
*/
void <%= @grammar.prefix %>context_delete(<%= @grammar.prefix %>context_t * context)
{
<% if @cpp %>
delete context;
<% else %>
free(context);
<% end %>
} }
/************************************************************************** /**************************************************************************

24
assets/parser.d.erb
View File

@ -225,26 +225,28 @@ private enum size_t INVALID_ID = cast(size_t)-1;
*************************************************************************/ *************************************************************************/
/** /**
* Initialize lexer/parser context structure.
* *
* @param[out] context * Deinitialize and deallocate with <%= @grammar.prefix %>context_delete().
* Lexer/parser context structure. *
* @param input * @param input
* Text input. * Text input.
* @param input_length
* Text input length.
*
* @return Context structure for lexer/parser.
*/ */
public void <%= @grammar.prefix %>context_init(<%= @grammar.prefix %>context_t * context, string input) <%= @grammar.prefix %>context_t * <%= @grammar.prefix %>context_new(string input)
{ {
/* New default-initialized context structure. */ /* New default-initialized context structure. */
<%= @grammar.prefix %>context_t newcontext; <%= @grammar.prefix %>context_t * context = new <%= @grammar.prefix %>context_t;
/* Lexer initialization. */ /* Lexer initialization. */
newcontext.input = input; context.input = input;
newcontext.text_position.row = 1u; context.text_position.row = 1u;
newcontext.text_position.col = 1u; context.text_position.col = 1u;
newcontext.mode = <%= @lexer.mode_id("default") %>; context.mode = <%= @lexer.mode_id("default") %>;
/* Copy to the user's context structure. */ return context;
*context = newcontext;
} }
/************************************************************************** /**************************************************************************

4
assets/parser.h.erb
View File

@ -184,7 +184,9 @@ typedef struct
/** Token names. */ /** Token names. */
extern const char * <%= @grammar.prefix %>token_names[]; extern const char * <%= @grammar.prefix %>token_names[];
void <%= @grammar.prefix %>context_init(<%= @grammar.prefix %>context_t * context, uint8_t const * input, size_t input_length); <%= @grammar.prefix %>context_t * <%= @grammar.prefix %>context_new(uint8_t const * input, size_t input_length);
void <%= @grammar.prefix %>context_delete(<%= @grammar.prefix %>context_t * context);
size_t <%= @grammar.prefix %>decode_code_point(uint8_t const * input, size_t input_length, size_t <%= @grammar.prefix %>decode_code_point(uint8_t const * input, size_t input_length,
<%= @grammar.prefix %>code_point_t * out_code_point, uint8_t * out_code_point_length); <%= @grammar.prefix %>code_point_t * out_code_point, uint8_t * out_code_point_length);

95
doc/user_guide.md
View File

@ -319,10 +319,9 @@ example parse:
``` ```
string input = "a, ((b)), b"; string input = "a, ((b)), b";
p_context_t context; p_context_t * context = p_context_new(input);
p_context_init(&context, input); assert_eq(P_SUCCESS, p_parse(context));
assert_eq(P_SUCCESS, p_parse(&context)); Start * start = p_result(context);
Start * start = p_result(&context);
assert(start.pItems1 !is null); assert(start.pItems1 !is null);
assert(start.pItems !is null); assert(start.pItems !is null);
Items * items = start.pItems; Items * items = start.pItems;
@ -370,10 +369,9 @@ Then the types would be used as such instead:
``` ```
string input = "a, ((b)), b"; string input = "a, ((b)), b";
p_context_t context; p_context_t * context = p_context_new(input);
p_context_init(&context, input); assert_eq(P_SUCCESS, p_parse(context));
assert_eq(P_SUCCESS, p_parse(&context)); ABCStartXYZ * start = p_result(context);
ABCStartXYZ * start = p_result(&context);
assert(start.pItems1 !is null); assert(start.pItems1 !is null);
assert(start.pItems !is null); assert(start.pItems !is null);
ABCItemsXYZ * items = start.pItems; ABCItemsXYZ * items = start.pItems;
@ -843,7 +841,7 @@ prefix myparser_;
``` ```
With a parser generated with this `prefix` statement, instead of calling With a parser generated with this `prefix` statement, instead of calling
`p_context_init()` you would call `myparser_context_init()`. `p_context_new()` you would call `myparser_context_new()`.
The `prefix` statement can be optionally used if you would like to change the The `prefix` statement can be optionally used if you would like to change the
prefix used by your generated lexer and parser to something other than the prefix used by your generated lexer and parser to something other than the
@ -1025,27 +1023,32 @@ fields `pExpB`, `pExpB3`, and `right` will all point to the same child node
##> Functions ##> Functions
### `p_context_init` ### `p_context_new`
The `p_context_init()` function must be called to initialize the context The `p_context_new()` function must be called to allocate and initialize the
structure. context structure.
The input to be used for lexing/parsing is passed in when initializing the The input to be used for lexing/parsing is passed in when initializing the
context structure. context structure.
C example: C example:
``` ```
p_context_t context; p_context_t * context = p_context_new(input, input_length);
p_context_init(&context, input, input_length);
``` ```
D example: D example:
``` ```
p_context_t context; p_context_t * context = p_context_new(input);
p_context_init(&context, input);
``` ```
### `p_context_delete`
The `p_context_delete()` function must be called to deinitialize and deallocate
a context structure allocated by `p_context_init()`.
This function is not available for D language since D has a garbage collector.
### `p_lex` ### `p_lex`
The `p_lex()` function is the main entry point to the lexer. The `p_lex()` function is the main entry point to the lexer.
@ -1057,10 +1060,9 @@ generated lexer in a standalone mode.
Example: Example:
``` ```
p_context_t context; p_context_t * context = p_context_new(input, input_length);
p_context_init(&context, input, input_length);
p_token_info_t token_info; p_token_info_t token_info;
size_t result = p_lex(&context, &token_info); size_t result = p_lex(context, &token_info);
switch (result) switch (result)
{ {
case P_DECODE_ERROR: case P_DECODE_ERROR:
@ -1092,9 +1094,8 @@ It must be passed a pointer to an initialized context structure.
Example: Example:
``` ```
p_context_t context; p_context_t * context = p_context_new(input, input_length);
p_context_init(&context, input, input_length); size_t result = p_parse(context);
size_t result = p_parse(&context);
``` ```
When multiple start rules are specified, a separate parse function is generated When multiple start rules are specified, a separate parse function is generated
@ -1102,7 +1103,7 @@ for each which starts parsing at the given rule.
For example, if `Statement` is specified as a start rule: For example, if `Statement` is specified as a start rule:
``` ```
size_t result = p_parse_Statement(&context); size_t result = p_parse_Statement(context);
``` ```
In this case, the parser will start parsing with the `Statement` rule. In this case, the parser will start parsing with the `Statement` rule.
@ -1133,12 +1134,11 @@ The `p_result()` function can be used to retrieve the final parse value after
Example: Example:
``` ```
p_context_t context; p_context_t * context = p_context_new(input, input_length);
p_context_init(&context, input, input_length); size_t result = p_parse(context);
size_t result = p_parse(&context); if (p_parse(context) == P_SUCCESS)
if (p_parse(&context) == P_SUCCESS)
{ {
result = p_result(&context); result = p_result(context);
} }
``` ```
@ -1150,12 +1150,11 @@ for each which returns the parse result for the corresponding rule.
For example, if `Statement` is specified as a start rule: For example, if `Statement` is specified as a start rule:
``` ```
p_context_t context; p_context_t * context = p_context_new(input, input_length);
p_context_init(&context, input, input_length); size_t result = p_parse(context);
size_t result = p_parse(&context); if (p_parse_Statement(context) == P_SUCCESS)
if (p_parse_Statement(&context) == P_SUCCESS)
{ {
result = p_result_Statement(&context); result = p_result_Statement(context);
} }
``` ```
@ -1170,12 +1169,11 @@ an error occurred.
Example: Example:
``` ```
p_context_t context; p_context_t * context = p_context_new(input, input_length);
p_context_init(&context, input, input_length); size_t result = p_parse(context);
size_t result = p_parse(&context); if (p_parse(context) == P_UNEXPECTED_TOKEN)
if (p_parse(&context) == P_UNEXPECTED_TOKEN)
{ {
p_position_t error_position = p_position(&context); p_position_t error_position = p_position(context);
fprintf(stderr, "Error: unexpected token at row %u column %u\n", fprintf(stderr, "Error: unexpected token at row %u column %u\n",
error_position.row + 1, error_position.col + 1); error_position.row + 1, error_position.col + 1);
} }
@ -1192,9 +1190,9 @@ They have no particular meaning to Propane.
Example: Example:
``` ```
if (p_parse(&context) == P_USER_TERMINATED) if (p_parse(context) == P_USER_TERMINATED)
{ {
size_t user_terminate_code = p_user_terminate_code(&context); size_t user_terminate_code = p_user_terminate_code(context);
} }
``` ```
@ -1208,9 +1206,9 @@ indicate what token the parser was not expecting.
Example: Example:
``` ```
if (p_parse(&context) == P_UNEXPECTED_TOKEN) if (p_parse(context) == P_UNEXPECTED_TOKEN)
{ {
p_token_t unexpected_token = p_token(&context); p_token_t unexpected_token = p_token(context);
} }
``` ```
@ -1257,7 +1255,7 @@ p_free_tree_Statement(statement_tree);
``` ```
In this case, Propane will free a `Statement` tree structure returned by the In this case, Propane will free a `Statement` tree structure returned by the
`p_parse_Statement(&context)` function. `p_parse_Statement(context)` function.
##> Data ##> Data
@ -1269,14 +1267,13 @@ It is indexed by the token ID.
C example: C example:
``` ```
p_context_t context; p_context_t * context = p_context_new(input, input_length);
p_context_init(&context, input, input_length); size_t result = p_parse(context);
size_t result = p_parse(&context); if (p_parse(context) == P_UNEXPECTED_TOKEN)
if (p_parse(&context) == P_UNEXPECTED_TOKEN)
{ {
p_position_t error_position = p_position(&context); p_position_t error_position = p_position(context);
fprintf(stderr, "Error: unexpected token `%s' at row %u column %u\n", fprintf(stderr, "Error: unexpected token `%s' at row %u column %u\n",
p_token_names[context.token], p_token_names[context->token],
error_position.row + 1, error_position.col + 1); error_position.row + 1, error_position.col + 1);
} }
``` ```

30
spec/test_basic_math_grammar.c
View File

@ -5,25 +5,29 @@
int main() int main()
{ {
char const * input = "1 + 2 * 3 + 4"; char const * input = "1 + 2 * 3 + 4";
p_context_t context; p_context_t * context;
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert_eq(P_SUCCESS, p_parse(&context)); assert_eq(P_SUCCESS, p_parse(context));
assert_eq(11, p_result(&context)); assert_eq(11, p_result(context));
p_context_delete(context);
input = "1 * 2 ** 4 * 3"; input = "1 * 2 ** 4 * 3";
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert_eq(P_SUCCESS, p_parse(&context)); assert_eq(P_SUCCESS, p_parse(context));
assert_eq(48, p_result(&context)); assert_eq(48, p_result(context));
p_context_delete(context);
input = "(1 + 2) * 3 + 4"; input = "(1 + 2) * 3 + 4";
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert_eq(P_SUCCESS, p_parse(&context)); assert_eq(P_SUCCESS, p_parse(context));
assert_eq(13, p_result(&context)); assert_eq(13, p_result(context));
p_context_delete(context);
input = "(2 * 2) ** 3 + 4 + 5"; input = "(2 * 2) ** 3 + 4 + 5";
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert_eq(P_SUCCESS, p_parse(&context)); assert_eq(P_SUCCESS, p_parse(context));
assert_eq(73, p_result(&context)); assert_eq(73, p_result(context));
p_context_delete(context);
return 0; return 0;
} }

26
spec/test_basic_math_grammar.d
View File

@ -10,23 +10,23 @@ int main()
unittest unittest
{ {
string input = "1 + 2 * 3 + 4"; string input = "1 + 2 * 3 + 4";
p_context_t context; p_context_t * context;
p_context_init(&context, input); context = p_context_new(input);
assert_eq(P_SUCCESS, p_parse(&context)); assert_eq(P_SUCCESS, p_parse(context));
assert_eq(11, p_result(&context)); assert_eq(11, p_result(context));
input = "1 * 2 ** 4 * 3"; input = "1 * 2 ** 4 * 3";
p_context_init(&context, input); context = p_context_new(input);
assert_eq(P_SUCCESS, p_parse(&context)); assert_eq(P_SUCCESS, p_parse(context));
assert_eq(48, p_result(&context)); assert_eq(48, p_result(context));
input = "(1 + 2) * 3 + 4"; input = "(1 + 2) * 3 + 4";
p_context_init(&context, input); context = p_context_new(input);
assert_eq(P_SUCCESS, p_parse(&context)); assert_eq(P_SUCCESS, p_parse(context));
assert_eq(13, p_result(&context)); assert_eq(13, p_result(context));
input = "(2 * 2) ** 3 + 4 + 5"; input = "(2 * 2) ** 3 + 4 + 5";
p_context_init(&context, input); context = p_context_new(input);
assert_eq(P_SUCCESS, p_parse(&context)); assert_eq(P_SUCCESS, p_parse(context));
assert_eq(73, p_result(&context)); assert_eq(73, p_result(context));
} }

7
spec/test_drop_code_block.c
View File

@ -6,9 +6,10 @@
int main() int main()
{ {
char const * input = " # comment 1\n# comment 2\na\n"; char const * input = " # comment 1\n# comment 2\na\n";
p_context_t context; p_context_t * context;
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
p_context_delete(context);
return 0; return 0;
} }

6
spec/test_drop_code_block.d
View File

@ -10,7 +10,7 @@ int main()
unittest unittest
{ {
string input = " # comment 1\n# comment 2\na\n"; string input = " # comment 1\n# comment 2\na\n";
p_context_t context; p_context_t * context;
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
} }

47
spec/test_error_positions.c
View File

@ -5,38 +5,43 @@
int main() int main()
{ {
char const * input = "a 42"; char const * input = "a 42";
p_context_t context; p_context_t * context;
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
p_context_delete(context);
input = "a\n123\na a"; input = "a\n123\na a";
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_UNEXPECTED_TOKEN); assert(p_parse(context) == P_UNEXPECTED_TOKEN);
assert(p_position(&context).row == 3); assert(p_position(context).row == 3);
assert(p_position(&context).col == 4); assert(p_position(context).col == 4);
assert(p_token(&context) == TOKEN_a); assert(p_token(context) == TOKEN_a);
p_context_delete(context);
input = "12"; input = "12";
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_UNEXPECTED_TOKEN); assert(p_parse(context) == P_UNEXPECTED_TOKEN);
assert(p_position(&context).row == 1); assert(p_position(context).row == 1);
assert(p_position(&context).col == 1); assert(p_position(context).col == 1);
assert(p_token(&context) == TOKEN_num); assert(p_token(context) == TOKEN_num);
p_context_delete(context);
input = "a 12\n\nab"; input = "a 12\n\nab";
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_UNEXPECTED_INPUT); assert(p_parse(context) == P_UNEXPECTED_INPUT);
assert(p_position(&context).row == 3); assert(p_position(context).row == 3);
assert(p_position(&context).col == 2); assert(p_position(context).col == 2);
p_context_delete(context);
input = "a 12\n\na\n\n77\na \xAA"; input = "a 12\n\na\n\n77\na \xAA";
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_DECODE_ERROR); assert(p_parse(context) == P_DECODE_ERROR);
assert(p_position(&context).row == 6); assert(p_position(context).row == 6);
assert(p_position(&context).col == 5); assert(p_position(context).col == 5);
assert(strcmp(p_token_names[TOKEN_a], "a") == 0); assert(strcmp(p_token_names[TOKEN_a], "a") == 0);
assert(strcmp(p_token_names[TOKEN_num], "num") == 0); assert(strcmp(p_token_names[TOKEN_num], "num") == 0);
p_context_delete(context);
return 0; return 0;
} }

34
spec/test_error_positions.d
View File

@ -9,31 +9,31 @@ int main()
unittest unittest
{ {
string input = "a 42"; string input = "a 42";
p_context_t context; p_context_t * context;
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
input = "a\n123\na a"; input = "a\n123\na a";
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_UNEXPECTED_TOKEN); assert(p_parse(context) == P_UNEXPECTED_TOKEN);
assert(p_position(&context) == p_position_t(3, 4)); assert(p_position(context) == p_position_t(3, 4));
assert(p_token(&context) == TOKEN_a); assert(p_token(context) == TOKEN_a);
input = "12"; input = "12";
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_UNEXPECTED_TOKEN); assert(p_parse(context) == P_UNEXPECTED_TOKEN);
assert(p_position(&context) == p_position_t(1, 1)); assert(p_position(context) == p_position_t(1, 1));
assert(p_token(&context) == TOKEN_num); assert(p_token(context) == TOKEN_num);
input = "a 12\n\nab"; input = "a 12\n\nab";
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_UNEXPECTED_INPUT); assert(p_parse(context) == P_UNEXPECTED_INPUT);
assert(p_position(&context) == p_position_t(3, 2)); assert(p_position(context) == p_position_t(3, 2));
input = "a 12\n\na\n\n77\na \xAA"; input = "a 12\n\na\n\n77\na \xAA";
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_DECODE_ERROR); assert(p_parse(context) == P_DECODE_ERROR);
assert(p_position(&context) == p_position_t(6, 5)); assert(p_position(context) == p_position_t(6, 5));
assert(p_token_names[TOKEN_a] == "a"); assert(p_token_names[TOKEN_a] == "a");
assert(p_token_names[TOKEN_num] == "num"); assert(p_token_names[TOKEN_num] == "num");

7
spec/test_field_aliases.c
View File

@ -6,8 +6,9 @@
int main() int main()
{ {
char const * input = "foo1\nbar2"; char const * input = "foo1\nbar2";
p_context_t context; p_context_t * context;
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
p_context_delete(context);
return 0; return 0;
} }

6
spec/test_field_aliases.d
View File

@ -9,7 +9,7 @@ int main()
unittest unittest
{ {
string input = "foo1\nbar2"; string input = "foo1\nbar2";
p_context_t context; p_context_t * context;
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
} }

9
spec/test_free_tree_token_node_memory.c
View File

@ -6,14 +6,15 @@
int main() int main()
{ {
char const * input = "ab"; char const * input = "ab";
p_context_t context; p_context_t * context;
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert_eq(P_SUCCESS, p_parse(&context)); assert_eq(P_SUCCESS, p_parse(context));
Start * start = p_result(&context); Start * start = p_result(context);
assert(start->a != NULL); assert(start->a != NULL);
assert(*start->a->pvalue == 1); assert(*start->a->pvalue == 1);
assert(start->b != NULL); assert(start->b != NULL);
assert(*start->b->pvalue == 2); assert(*start->b->pvalue == 2);
p_free_tree(start); p_free_tree(start);
p_context_delete(context);
} }

26
spec/test_lexer.c
View File

@ -38,73 +38,75 @@ int main()
p_token_info_t token_info; p_token_info_t token_info;
char const * input = "5 + 4 * \n677 + 567"; char const * input = "5 + 4 * \n677 + 567";
p_context_t context; p_context_t * context;
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_lex(&context, &token_info) == P_SUCCESS); assert(p_lex(context, &token_info) == P_SUCCESS);
assert(token_info.position.row == 1u); assert(token_info.position.row == 1u);
assert(token_info.position.col == 1u); assert(token_info.position.col == 1u);
assert(token_info.end_position.row == 1u); assert(token_info.end_position.row == 1u);
assert(token_info.end_position.col == 1u); assert(token_info.end_position.col == 1u);
assert(token_info.length == 1u); assert(token_info.length == 1u);
assert(token_info.token == TOKEN_int); assert(token_info.token == TOKEN_int);
assert(p_lex(&context, &token_info) == P_SUCCESS); assert(p_lex(context, &token_info) == P_SUCCESS);
assert(token_info.position.row == 1u); assert(token_info.position.row == 1u);
assert(token_info.position.col == 3u); assert(token_info.position.col == 3u);
assert(token_info.end_position.row == 1u); assert(token_info.end_position.row == 1u);
assert(token_info.end_position.col == 3u); assert(token_info.end_position.col == 3u);
assert(token_info.length == 1u); assert(token_info.length == 1u);
assert(token_info.token == TOKEN_plus); assert(token_info.token == TOKEN_plus);
assert(p_lex(&context, &token_info) == P_SUCCESS); assert(p_lex(context, &token_info) == P_SUCCESS);
assert(token_info.position.row == 1u); assert(token_info.position.row == 1u);
assert(token_info.position.col == 5u); assert(token_info.position.col == 5u);
assert(token_info.end_position.row == 1u); assert(token_info.end_position.row == 1u);
assert(token_info.end_position.col == 5u); assert(token_info.end_position.col == 5u);
assert(token_info.length == 1u); assert(token_info.length == 1u);
assert(token_info.token == TOKEN_int); assert(token_info.token == TOKEN_int);
assert(p_lex(&context, &token_info) == P_SUCCESS); assert(p_lex(context, &token_info) == P_SUCCESS);
assert(token_info.position.row == 1u); assert(token_info.position.row == 1u);
assert(token_info.position.col == 7u); assert(token_info.position.col == 7u);
assert(token_info.end_position.row == 1u); assert(token_info.end_position.row == 1u);
assert(token_info.end_position.col == 7u); assert(token_info.end_position.col == 7u);
assert(token_info.length == 1u); assert(token_info.length == 1u);
assert(token_info.token == TOKEN_times); assert(token_info.token == TOKEN_times);
assert(p_lex(&context, &token_info) == P_SUCCESS); assert(p_lex(context, &token_info) == P_SUCCESS);
assert(token_info.position.row == 2u); assert(token_info.position.row == 2u);
assert(token_info.position.col == 1u); assert(token_info.position.col == 1u);
assert(token_info.end_position.row == 2u); assert(token_info.end_position.row == 2u);
assert(token_info.end_position.col == 3u); assert(token_info.end_position.col == 3u);
assert(token_info.length == 3u); assert(token_info.length == 3u);
assert(token_info.token == TOKEN_int); assert(token_info.token == TOKEN_int);
assert(p_lex(&context, &token_info) == P_SUCCESS); assert(p_lex(context, &token_info) == P_SUCCESS);
assert(token_info.position.row == 2u); assert(token_info.position.row == 2u);
assert(token_info.position.col == 5u); assert(token_info.position.col == 5u);
assert(token_info.end_position.row == 2u); assert(token_info.end_position.row == 2u);
assert(token_info.end_position.col == 5u); assert(token_info.end_position.col == 5u);
assert(token_info.length == 1u); assert(token_info.length == 1u);
assert(token_info.token == TOKEN_plus); assert(token_info.token == TOKEN_plus);
assert(p_lex(&context, &token_info) == P_SUCCESS); assert(p_lex(context, &token_info) == P_SUCCESS);
assert(token_info.position.row == 2u); assert(token_info.position.row == 2u);
assert(token_info.position.col == 7u); assert(token_info.position.col == 7u);
assert(token_info.end_position.row == 2u); assert(token_info.end_position.row == 2u);
assert(token_info.end_position.col == 9u); assert(token_info.end_position.col == 9u);
assert(token_info.length == 3u); assert(token_info.length == 3u);
assert(token_info.token == TOKEN_int); assert(token_info.token == TOKEN_int);
assert(p_lex(&context, &token_info) == P_SUCCESS); assert(p_lex(context, &token_info) == P_SUCCESS);
assert(token_info.position.row == 2u); assert(token_info.position.row == 2u);
assert(token_info.position.col == 10u); assert(token_info.position.col == 10u);
assert(token_info.end_position.row == 2u); assert(token_info.end_position.row == 2u);
assert(token_info.end_position.col == 10u); assert(token_info.end_position.col == 10u);
assert(token_info.length == 0u); assert(token_info.length == 0u);
assert(token_info.token == TOKEN___EOF); assert(token_info.token == TOKEN___EOF);
p_context_delete(context);
p_context_init(&context, (uint8_t const *)"", 0u); context = p_context_new((uint8_t const *)"", 0u);
assert(p_lex(&context, &token_info) == P_SUCCESS); assert(p_lex(context, &token_info) == P_SUCCESS);
assert(token_info.position.row == 1u); assert(token_info.position.row == 1u);
assert(token_info.position.col == 1u); assert(token_info.position.col == 1u);
assert(token_info.end_position.row == 1u); assert(token_info.end_position.row == 1u);
assert(token_info.end_position.col == 1u); assert(token_info.end_position.col == 1u);
assert(token_info.length == 0u); assert(token_info.length == 0u);
assert(token_info.token == TOKEN___EOF); assert(token_info.token == TOKEN___EOF);
p_context_delete(context);
return 0; return 0;
} }

24
spec/test_lexer.d
View File

@ -44,26 +44,26 @@ unittest
{ {
p_token_info_t token_info; p_token_info_t token_info;
string input = "5 + 4 * \n677 + 567"; string input = "5 + 4 * \n677 + 567";
p_context_t context; p_context_t * context;
p_context_init(&context, input); context = p_context_new(input);
assert(p_lex(&context, &token_info) == P_SUCCESS); assert(p_lex(context, &token_info) == P_SUCCESS);
assert(token_info == p_token_info_t(p_position_t(1, 1), p_position_t(1, 1), 1, TOKEN_int)); assert(token_info == p_token_info_t(p_position_t(1, 1), p_position_t(1, 1), 1, TOKEN_int));
assert(p_lex(&context, &token_info) == P_SUCCESS); assert(p_lex(context, &token_info) == P_SUCCESS);
assert(token_info == p_token_info_t(p_position_t(1, 3), p_position_t(1, 3), 1, TOKEN_plus)); assert(token_info == p_token_info_t(p_position_t(1, 3), p_position_t(1, 3), 1, TOKEN_plus));
assert(p_lex(&context, &token_info) == P_SUCCESS); assert(p_lex(context, &token_info) == P_SUCCESS);
assert(token_info == p_token_info_t(p_position_t(1, 5), p_position_t(1, 5), 1, TOKEN_int)); assert(token_info == p_token_info_t(p_position_t(1, 5), p_position_t(1, 5), 1, TOKEN_int));
assert(p_lex(&context, &token_info) == P_SUCCESS); assert(p_lex(context, &token_info) == P_SUCCESS);
assert(token_info == p_token_info_t(p_position_t(1, 7), p_position_t(1, 7), 1, TOKEN_times)); assert(token_info == p_token_info_t(p_position_t(1, 7), p_position_t(1, 7), 1, TOKEN_times));
assert(p_lex(&context, &token_info) == P_SUCCESS); assert(p_lex(context, &token_info) == P_SUCCESS);
assert(token_info == p_token_info_t(p_position_t(2, 1), p_position_t(2, 3), 3, TOKEN_int)); assert(token_info == p_token_info_t(p_position_t(2, 1), p_position_t(2, 3), 3, TOKEN_int));
assert(p_lex(&context, &token_info) == P_SUCCESS); assert(p_lex(context, &token_info) == P_SUCCESS);
assert(token_info == p_token_info_t(p_position_t(2, 5), p_position_t(2, 5), 1, TOKEN_plus)); assert(token_info == p_token_info_t(p_position_t(2, 5), p_position_t(2, 5), 1, TOKEN_plus));
assert(p_lex(&context, &token_info) == P_SUCCESS); assert(p_lex(context, &token_info) == P_SUCCESS);
assert(token_info == p_token_info_t(p_position_t(2, 7), p_position_t(2, 9), 3, TOKEN_int)); assert(token_info == p_token_info_t(p_position_t(2, 7), p_position_t(2, 9), 3, TOKEN_int));
assert(p_lex(&context, &token_info) == P_SUCCESS); assert(p_lex(context, &token_info) == P_SUCCESS);
assert(token_info == p_token_info_t(p_position_t(2, 10), p_position_t(2, 10), 0, TOKEN___EOF)); assert(token_info == p_token_info_t(p_position_t(2, 10), p_position_t(2, 10), 0, TOKEN___EOF));
p_context_init(&context, ""); context = p_context_new("");
assert(p_lex(&context, &token_info) == P_SUCCESS); assert(p_lex(context, &token_info) == P_SUCCESS);
assert(token_info == p_token_info_t(p_position_t(1, 1), p_position_t(1, 1), 0, TOKEN___EOF)); assert(token_info == p_token_info_t(p_position_t(1, 1), p_position_t(1, 1), 0, TOKEN___EOF));
} }

7
spec/test_lexer_match_text.c
View File

@ -6,10 +6,11 @@
int main() int main()
{ {
char const * input = "identifier_123"; char const * input = "identifier_123";
p_context_t context; p_context_t * context;
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
printf("pass1\n"); printf("pass1\n");
p_context_delete(context);
return 0; return 0;
} }

6
spec/test_lexer_match_text.d
View File

@ -9,8 +9,8 @@ int main()
unittest unittest
{ {
string input = `identifier_123`; string input = `identifier_123`;
p_context_t context; p_context_t * context;
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
writeln("pass1"); writeln("pass1");
} }

12
spec/test_lexer_modes.c
View File

@ -6,15 +6,17 @@
int main() int main()
{ {
char const * input = "abc \"a string\" def"; char const * input = "abc \"a string\" def";
p_context_t context; p_context_t * context;
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
printf("pass1\n"); printf("pass1\n");
p_context_delete(context);
input = "abc \"abc def\" def"; input = "abc \"abc def\" def";
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
printf("pass2\n"); printf("pass2\n");
p_context_delete(context);
return 0; return 0;
} }

10
spec/test_lexer_modes.d
View File

@ -9,13 +9,13 @@ int main()
unittest unittest
{ {
string input = `abc "a string" def`; string input = `abc "a string" def`;
p_context_t context; p_context_t * context;
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
writeln("pass1"); writeln("pass1");
input = `abc "abc def" def`; input = `abc "abc def" def`;
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
writeln("pass2"); writeln("pass2");
} }

12
spec/test_lexer_multiple_modes.c
View File

@ -6,15 +6,17 @@
int main() int main()
{ {
char const * input = "abc.def"; char const * input = "abc.def";
p_context_t context; p_context_t * context;
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
printf("pass1\n"); printf("pass1\n");
p_context_delete(context);
input = "abc . abc"; input = "abc . abc";
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
printf("pass2\n"); printf("pass2\n");
p_context_delete(context);
return 0; return 0;
} }

10
spec/test_lexer_multiple_modes.d
View File

@ -9,13 +9,13 @@ int main()
unittest unittest
{ {
string input = `abc.def`; string input = `abc.def`;
p_context_t context; p_context_t * context;
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
writeln("pass1"); writeln("pass1");
input = `abc . abc`; input = `abc . abc`;
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
writeln("pass2"); writeln("pass2");
} }

16
spec/test_lexer_result_value.c
View File

@ -5,15 +5,17 @@
int main() int main()
{ {
char const * input = "x"; char const * input = "x";
p_context_t context; p_context_t * context;
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
assert(p_result(&context) == 1u); assert(p_result(context) == 1u);
p_context_delete(context);
input = "fabulous"; input = "fabulous";
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
assert(p_result(&context) == 8u); assert(p_result(context) == 8u);
p_context_delete(context);
return 0; return 0;
} }

14
spec/test_lexer_result_value.d
View File

@ -9,13 +9,13 @@ int main()
unittest unittest
{ {
string input = `x`; string input = `x`;
p_context_t context; p_context_t * context;
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
assert(p_result(&context) == 1u); assert(p_result(context) == 1u);
input = `fabulous`; input = `fabulous`;
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
assert(p_result(&context) == 8u); assert(p_result(context) == 8u);
} }

14
spec/test_lexer_unknown_character.c
View File

@ -5,14 +5,16 @@
int main() int main()
{ {
char const * input = "x"; char const * input = "x";
p_context_t context; p_context_t * context;
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_UNEXPECTED_INPUT); assert(p_parse(context) == P_UNEXPECTED_INPUT);
p_context_delete(context);
input = "123"; input = "123";
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
assert(p_result(&context) == 123u); assert(p_result(context) == 123u);
p_context_delete(context);
return 0; return 0;
} }

12
spec/test_lexer_unknown_character.d
View File

@ -9,12 +9,12 @@ int main()
unittest unittest
{ {
string input = `x`; string input = `x`;
p_context_t context; p_context_t * context;
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_UNEXPECTED_INPUT); assert(p_parse(context) == P_UNEXPECTED_INPUT);
input = `123`; input = `123`;
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
assert(p_result(&context) == 123u); assert(p_result(context) == 123u);
} }

7
spec/test_match_backslashes.c
View File

@ -5,9 +5,10 @@
int main() int main()
{ {
char const * input = "\a\b\t\n\v\f\rt"; char const * input = "\a\b\t\n\v\f\rt";
p_context_t context; p_context_t * context;
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
p_context_delete(context);
return 0; return 0;
} }

6
spec/test_match_backslashes.d
View File

@ -9,7 +9,7 @@ int main()
unittest unittest
{ {
string input = "\a\b\t\n\v\f\rt"; string input = "\a\b\t\n\v\f\rt";
p_context_t context; p_context_t * context;
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
} }

14
spec/test_multiple_parsers.c
View File

@ -6,14 +6,16 @@
int main() int main()
{ {
char const * input1 = "a\n1"; char const * input1 = "a\n1";
myp1_context_t context1; myp1_context_t * context1;
myp1_context_init(&context1, (uint8_t const *)input1, strlen(input1)); context1 = myp1_context_new((uint8_t const *)input1, strlen(input1));
assert(myp1_parse(&context1) == MYP1_SUCCESS); assert(myp1_parse(context1) == MYP1_SUCCESS);
myp1_context_delete(context1);
char const * input2 = "bcb"; char const * input2 = "bcb";
myp2_context_t context2; myp2_context_t * context2;
myp2_context_init(&context2, (uint8_t const *)input2, strlen(input2)); context2 = myp2_context_new((uint8_t const *)input2, strlen(input2));
assert(myp2_parse(&context2) == MYP2_SUCCESS); assert(myp2_parse(context2) == MYP2_SUCCESS);
myp2_context_delete(context2);
return 0; return 0;
} }

12
spec/test_multiple_parsers.d
View File

@ -10,12 +10,12 @@ int main()
unittest unittest
{ {
string input1 = "a\n1"; string input1 = "a\n1";
myp1_context_t context1; myp1_context_t * context1;
myp1_context_init(&context1, input1); context1 = myp1_context_new(input1);
assert(myp1_parse(&context1) == MYP1_SUCCESS); assert(myp1_parse(context1) == MYP1_SUCCESS);
string input2 = "bcb"; string input2 = "bcb";
myp2_context_t context2; myp2_context_t * context2;
myp2_context_init(&context2, input2); context2 = myp2_context_new(input2);
assert(myp2_parse(&context2) == MYP2_SUCCESS); assert(myp2_parse(context2) == MYP2_SUCCESS);
} }

23
spec/test_named_optional_rule_component_tree.c
View File

@ -6,10 +6,10 @@
int main() int main()
{ {
char const * input = "b"; char const * input = "b";
p_context_t context; p_context_t * context;
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
Start * start = p_result(&context); Start * start = p_result(context);
assert(start->a == NULL); assert(start->a == NULL);
assert(start->pToken2 != NULL); assert(start->pToken2 != NULL);
assert_eq(TOKEN_b, start->pToken2->token); assert_eq(TOKEN_b, start->pToken2->token);
@ -18,11 +18,12 @@ int main()
assert(start->r == NULL); assert(start->r == NULL);
p_free_tree(start); p_free_tree(start);
p_context_delete(context);
input = "abcd"; input = "abcd";
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
start = p_result(&context); start = p_result(context);
assert(start->a != NULL); assert(start->a != NULL);
assert_eq(TOKEN_a, start->pToken1->token); assert_eq(TOKEN_a, start->pToken1->token);
assert(start->pToken2 != NULL); assert(start->pToken2 != NULL);
@ -34,17 +35,19 @@ int main()
assert_eq(TOKEN_c, start->pR->pToken1->token); assert_eq(TOKEN_c, start->pR->pToken1->token);
p_free_tree(start); p_free_tree(start);
p_context_delete(context);
input = "bdc"; input = "bdc";
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
start = p_result(&context); start = p_result(context);
assert(start->a == NULL); assert(start->a == NULL);
assert(start->pToken2 != NULL); assert(start->pToken2 != NULL);
assert(start->r != NULL); assert(start->r != NULL);
assert_eq(TOKEN_d, start->pR->pToken1->token); assert_eq(TOKEN_d, start->pR->pToken1->token);
p_free_tree(start); p_free_tree(start);
p_context_delete(context);
return 0; return 0;
} }

20
spec/test_named_optional_rule_component_tree.d
View File

@ -10,10 +10,10 @@ int main()
unittest unittest
{ {
string input = "b"; string input = "b";
p_context_t context; p_context_t * context;
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
Start * start = p_result(&context); Start * start = p_result(context);
assert(start.pToken1 is null); assert(start.pToken1 is null);
assert(start.pToken2 !is null); assert(start.pToken2 !is null);
assert_eq(TOKEN_b, start.pToken2.token); assert_eq(TOKEN_b, start.pToken2.token);
@ -22,9 +22,9 @@ unittest
assert(start.r is null); assert(start.r is null);
input = "abcd"; input = "abcd";
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
start = p_result(&context); start = p_result(context);
assert(start.pToken1 != null); assert(start.pToken1 != null);
assert_eq(TOKEN_a, start.pToken1.token); assert_eq(TOKEN_a, start.pToken1.token);
assert(start.pToken2 != null); assert(start.pToken2 != null);
@ -36,9 +36,9 @@ unittest
assert_eq(TOKEN_c, start.pR.pToken1.token); assert_eq(TOKEN_c, start.pR.pToken1.token);
input = "bdc"; input = "bdc";
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
start = p_result(&context); start = p_result(context);
assert(start.pToken1 is null); assert(start.pToken1 is null);
assert(start.pToken2 !is null); assert(start.pToken2 !is null);
assert(start.pR !is null); assert(start.pR !is null);

17
spec/test_optional_rule_component.c
View File

@ -5,17 +5,20 @@
int main() int main()
{ {
char const * input = "b"; char const * input = "b";
p_context_t context; p_context_t * context;
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
p_context_delete(context);
input = "abcd"; input = "abcd";
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
p_context_delete(context);
input = "abdc"; input = "abdc";
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
p_context_delete(context);
return 0; return 0;
} }

14
spec/test_optional_rule_component.d
View File

@ -9,15 +9,15 @@ int main()
unittest unittest
{ {
string input = "b"; string input = "b";
p_context_t context; p_context_t * context;
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
input = "abcd"; input = "abcd";
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
input = "abdc"; input = "abdc";
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
} }

23
spec/test_optional_rule_component_tree.c
View File

@ -6,10 +6,10 @@
int main() int main()
{ {
char const * input = "b"; char const * input = "b";
p_context_t context; p_context_t * context;
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
Start * start = p_result(&context); Start * start = p_result(context);
assert(start->pToken1 == NULL); assert(start->pToken1 == NULL);
assert(start->pToken2 != NULL); assert(start->pToken2 != NULL);
assert_eq(TOKEN_b, start->pToken2->token); assert_eq(TOKEN_b, start->pToken2->token);
@ -17,11 +17,12 @@ int main()
assert(start->pR == NULL); assert(start->pR == NULL);
p_free_tree(start); p_free_tree(start);
p_context_delete(context);
input = "abcd"; input = "abcd";
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
start = p_result(&context); start = p_result(context);
assert(start->pToken1 != NULL); assert(start->pToken1 != NULL);
assert_eq(TOKEN_a, start->pToken1->token); assert_eq(TOKEN_a, start->pToken1->token);
assert(start->pToken2 != NULL); assert(start->pToken2 != NULL);
@ -31,17 +32,19 @@ int main()
assert_eq(TOKEN_c, start->pR->pToken1->token); assert_eq(TOKEN_c, start->pR->pToken1->token);
p_free_tree(start); p_free_tree(start);
p_context_delete(context);
input = "bdc"; input = "bdc";
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
start = p_result(&context); start = p_result(context);
assert(start->pToken1 == NULL); assert(start->pToken1 == NULL);
assert(start->pToken2 != NULL); assert(start->pToken2 != NULL);
assert(start->pR != NULL); assert(start->pR != NULL);
assert_eq(TOKEN_d, start->pR->pToken1->token); assert_eq(TOKEN_d, start->pR->pToken1->token);
p_free_tree(start); p_free_tree(start);
p_context_delete(context);
return 0; return 0;
} }

20
spec/test_optional_rule_component_tree.d
View File

@ -10,10 +10,10 @@ int main()
unittest unittest
{ {
string input = "b"; string input = "b";
p_context_t context; p_context_t * context;
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
Start * start = p_result(&context); Start * start = p_result(context);
assert(start.pToken1 is null); assert(start.pToken1 is null);
assert(start.pToken2 !is null); assert(start.pToken2 !is null);
assert_eq(TOKEN_b, start.pToken2.token); assert_eq(TOKEN_b, start.pToken2.token);
@ -21,9 +21,9 @@ unittest
assert(start.pR is null); assert(start.pR is null);
input = "abcd"; input = "abcd";
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
start = p_result(&context); start = p_result(context);
assert(start.pToken1 != null); assert(start.pToken1 != null);
assert_eq(TOKEN_a, start.pToken1.token); assert_eq(TOKEN_a, start.pToken1.token);
assert(start.pToken2 != null); assert(start.pToken2 != null);
@ -33,9 +33,9 @@ unittest
assert_eq(TOKEN_c, start.pR.pToken1.token); assert_eq(TOKEN_c, start.pR.pToken1.token);
input = "bdc"; input = "bdc";
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
start = p_result(&context); start = p_result(context);
assert(start.pToken1 is null); assert(start.pToken1 is null);
assert(start.pToken2 !is null); assert(start.pToken2 !is null);
assert(start.pR !is null); assert(start.pR !is null);

12
spec/test_parser_identical_rules_lookahead.c
View File

@ -5,13 +5,15 @@
int main() int main()
{ {
char const * input = "aba"; char const * input = "aba";
p_context_t context; p_context_t * context;
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
p_context_delete(context);
input = "abb"; input = "abb";
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
p_context_delete(context);
return 0; return 0;
} }

10
spec/test_parser_identical_rules_lookahead.d
View File

@ -9,11 +9,11 @@ int main()
unittest unittest
{ {
string input = "aba"; string input = "aba";
p_context_t context; p_context_t * context;
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
input = "abb"; input = "abb";
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
} }

23
spec/test_parser_rule_from_multiple_states.c
View File

@ -5,20 +5,23 @@
int main() int main()
{ {
char const * input = "a"; char const * input = "a";
p_context_t context; p_context_t * context;
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_UNEXPECTED_TOKEN); assert(p_parse(context) == P_UNEXPECTED_TOKEN);
assert(p_position(&context).row == 1); assert(p_position(context).row == 1);
assert(p_position(&context).col == 2); assert(p_position(context).col == 2);
assert(context.token == TOKEN___EOF); assert(context->token == TOKEN___EOF);
p_context_delete(context);
input = "a b"; input = "a b";
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
p_context_delete(context);
input = "bb"; input = "bb";
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
p_context_delete(context);
return 0; return 0;
} }

16
spec/test_parser_rule_from_multiple_states.d
View File

@ -9,17 +9,17 @@ int main()
unittest unittest
{ {
string input = "a"; string input = "a";
p_context_t context; p_context_t * context;
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_UNEXPECTED_TOKEN); assert(p_parse(context) == P_UNEXPECTED_TOKEN);
assert(p_position(&context) == p_position_t(1, 2)); assert(p_position(context) == p_position_t(1, 2));
assert(context.token == TOKEN___EOF); assert(context.token == TOKEN___EOF);
input = "a b"; input = "a b";
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
input = "bb"; input = "bb";
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
} }

7
spec/test_parser_rule_user_code.c
View File

@ -5,9 +5,10 @@
int main() int main()
{ {
char const * input = "ab"; char const * input = "ab";
p_context_t context; p_context_t * context;
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
p_context_delete(context);
return 0; return 0;
} }

6
spec/test_parser_rule_user_code.d
View File

@ -9,7 +9,7 @@ int main()
unittest unittest
{ {
string input = "ab"; string input = "ab";
p_context_t context; p_context_t * context;
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
} }

53
spec/test_parsing_json.c
View File

@ -6,51 +6,58 @@
int main() int main()
{ {
char const * input = ""; char const * input = "";
p_context_t context; p_context_t * context;
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
p_context_delete(context);
input = "{}"; input = "{}";
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
assert(p_result(&context)->id == JSON_OBJECT); assert(p_result(context)->id == JSON_OBJECT);
p_context_delete(context);
input = "[]"; input = "[]";
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
assert(p_result(&context)->id == JSON_ARRAY); assert(p_result(context)->id == JSON_ARRAY);
p_context_delete(context);
input = "-45.6"; input = "-45.6";
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
assert(p_result(&context)->id == JSON_NUMBER); assert(p_result(context)->id == JSON_NUMBER);
assert(p_result(&context)->number == -45.6); assert(p_result(context)->number == -45.6);
p_context_delete(context);
input = "2E-2"; input = "2E-2";
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
assert(p_result(&context)->id == JSON_NUMBER); assert(p_result(context)->id == JSON_NUMBER);
assert(p_result(&context)->number == 0.02); assert(p_result(context)->number == 0.02);
p_context_delete(context);
input = "{\"hi\":true}"; input = "{\"hi\":true}";
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
JSONValue * o = p_result(&context); JSONValue * o = p_result(context);
assert(o->id == JSON_OBJECT); assert(o->id == JSON_OBJECT);
assert_eq(1, o->object.size); assert_eq(1, o->object.size);
assert(strcmp(o->object.entries[0].name, "hi") == 0); assert(strcmp(o->object.entries[0].name, "hi") == 0);
assert(o->object.entries[0].value->id == JSON_TRUE); assert(o->object.entries[0].value->id == JSON_TRUE);
p_context_delete(context);
input = "{\"ff\": false, \"nn\": null}"; input = "{\"ff\": false, \"nn\": null}";
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
o = p_result(&context); o = p_result(context);
assert(o->id == JSON_OBJECT); assert(o->id == JSON_OBJECT);
assert_eq(2, o->object.size); assert_eq(2, o->object.size);
assert(strcmp(o->object.entries[0].name, "ff") == 0); assert(strcmp(o->object.entries[0].name, "ff") == 0);
assert(o->object.entries[0].value->id == JSON_FALSE); assert(o->object.entries[0].value->id == JSON_FALSE);
assert(strcmp(o->object.entries[1].name, "nn") == 0); assert(strcmp(o->object.entries[1].name, "nn") == 0);
assert(o->object.entries[1].value->id == JSON_NULL); assert(o->object.entries[1].value->id == JSON_NULL);
p_context_delete(context);
return 0; return 0;
} }

50
spec/test_parsing_json.d
View File

@ -10,45 +10,45 @@ int main()
unittest unittest
{ {
string input = ``; string input = ``;
p_context_t context; p_context_t * context;
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
input = `{}`; input = `{}`;
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
assert(cast(JSONObject)p_result(&context)); assert(cast(JSONObject)p_result(context));
input = `[]`; input = `[]`;
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
assert(cast(JSONArray)p_result(&context)); assert(cast(JSONArray)p_result(context));
input = `-45.6`; input = `-45.6`;
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
assert(cast(JSONNumber)p_result(&context)); assert(cast(JSONNumber)p_result(context));
assert((cast(JSONNumber)p_result(&context)).value == -45.6); assert((cast(JSONNumber)p_result(context)).value == -45.6);
input = `2E-2`; input = `2E-2`;
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
assert(cast(JSONNumber)p_result(&context)); assert(cast(JSONNumber)p_result(context));
assert((cast(JSONNumber)p_result(&context)).value == 0.02); assert((cast(JSONNumber)p_result(context)).value == 0.02);
input = `{"hi":true}`; input = `{"hi":true}`;
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
assert(cast(JSONObject)p_result(&context)); assert(cast(JSONObject)p_result(context));
JSONObject o = cast(JSONObject)p_result(&context); JSONObject o = cast(JSONObject)p_result(context);
assert(o.value["hi"]); assert(o.value["hi"]);
assert(cast(JSONTrue)o.value["hi"]); assert(cast(JSONTrue)o.value["hi"]);
input = `{"ff": false, "nn": null}`; input = `{"ff": false, "nn": null}`;
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
assert(cast(JSONObject)p_result(&context)); assert(cast(JSONObject)p_result(context));
o = cast(JSONObject)p_result(&context); o = cast(JSONObject)p_result(context);
assert(o.value["ff"]); assert(o.value["ff"]);
assert(cast(JSONFalse)o.value["ff"]); assert(cast(JSONFalse)o.value["ff"]);
assert(o.value["nn"]); assert(o.value["nn"]);

23
spec/test_parsing_lists.c
View File

@ -5,20 +5,23 @@
int main() int main()
{ {
char const * input = "a"; char const * input = "a";
p_context_t context; p_context_t * context;
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
assert(p_result(&context) == 1u); assert(p_result(context) == 1u);
p_context_delete(context);
input = ""; input = "";
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
assert(p_result(&context) == 0u); assert(p_result(context) == 0u);
p_context_delete(context);
input = "aaaaaaaaaaaaaaaa"; input = "aaaaaaaaaaaaaaaa";
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
assert(p_result(&context) == 16u); assert(p_result(context) == 16u);
p_context_delete(context);
return 0; return 0;
} }

20
spec/test_parsing_lists.d
View File

@ -9,18 +9,18 @@ int main()
unittest unittest
{ {
string input = "a"; string input = "a";
p_context_t context; p_context_t * context;
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
assert(p_result(&context) == 1u); assert(p_result(context) == 1u);
input = ""; input = "";
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
assert(p_result(&context) == 0u); assert(p_result(context) == 0u);
input = "aaaaaaaaaaaaaaaa"; input = "aaaaaaaaaaaaaaaa";
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
assert(p_result(&context) == 16u); assert(p_result(context) == 16u);
} }

12
spec/test_pattern.c
View File

@ -6,15 +6,17 @@
int main() int main()
{ {
char const * input = "abcdef"; char const * input = "abcdef";
p_context_t context; p_context_t * context;
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
printf("pass1\n"); printf("pass1\n");
p_context_delete(context);
input = "defabcdef"; input = "defabcdef";
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
printf("pass2\n"); printf("pass2\n");
p_context_delete(context);
return 0; return 0;
} }

10
spec/test_pattern.d
View File

@ -9,13 +9,13 @@ int main()
unittest unittest
{ {
string input = "abcdef"; string input = "abcdef";
p_context_t context; p_context_t * context;
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
writeln("pass1"); writeln("pass1");
input = "defabcdef"; input = "defabcdef";
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
writeln("pass2"); writeln("pass2");
} }

7
spec/test_return_token_from_pattern.c
View File

@ -5,9 +5,10 @@
int main() int main()
{ {
char const * input = "defghidef"; char const * input = "defghidef";
p_context_t context; p_context_t * context;
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
p_context_delete(context);
return 0; return 0;
} }

6
spec/test_return_token_from_pattern.d
View File

@ -9,7 +9,7 @@ int main()
unittest unittest
{ {
string input = "defghidef"; string input = "defghidef";
p_context_t context; p_context_t * context;
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
} }

9
spec/test_start_rule_tree.c
View File

@ -6,14 +6,15 @@
int main() int main()
{ {
char const * input = "hi"; char const * input = "hi";
p_context_t context; p_context_t * context;
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert_eq(P_SUCCESS, p_parse(&context)); assert_eq(P_SUCCESS, p_parse(context));
Top * top = p_result(&context); Top * top = p_result(context);
assert(top->pToken != NULL); assert(top->pToken != NULL);
assert_eq(TOKEN_hi, top->pToken->token); assert_eq(TOKEN_hi, top->pToken->token);
p_free_tree(top); p_free_tree(top);
p_context_delete(context);
return 0; return 0;
} }

8
spec/test_start_rule_tree.d
View File

@ -10,10 +10,10 @@ int main()
unittest unittest
{ {
string input = "hi"; string input = "hi";
p_context_t context; p_context_t * context;
p_context_init(&context, input); context = p_context_new(input);
assert_eq(P_SUCCESS, p_parse(&context)); assert_eq(P_SUCCESS, p_parse(context));
Top * top = p_result(&context); Top * top = p_result(context);
assert(top.pToken !is null); assert(top.pToken !is null);
assert_eq(TOKEN_hi, top.pToken.token); assert_eq(TOKEN_hi, top.pToken.token);
} }

23
spec/test_starting_rules.c
View File

@ -6,22 +6,25 @@
int main() int main()
{ {
char const * input = "bbbb"; char const * input = "bbbb";
p_context_t context; p_context_t * context;
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
int result = p_result(&context); int result = p_result(context);
assert_eq(8, result); assert_eq(8, result);
p_context_delete(context);
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse_Bs(&context) == P_SUCCESS); assert(p_parse_Bs(context) == P_SUCCESS);
result = p_result_Bs(&context); result = p_result_Bs(context);
assert_eq(8, result); assert_eq(8, result);
p_context_delete(context);
input = "c"; input = "c";
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse_R(&context) == P_SUCCESS); assert(p_parse_R(context) == P_SUCCESS);
result = p_result_R(&context); result = p_result_R(context);
assert_eq(3, result); assert_eq(3, result);
p_context_delete(context);
return 0; return 0;
} }

20
spec/test_starting_rules.d
View File

@ -10,20 +10,20 @@ int main()
unittest unittest
{ {
string input = "bbbb"; string input = "bbbb";
p_context_t context; p_context_t * context;
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
int result = p_result(&context); int result = p_result(context);
assert(result == 8); assert(result == 8);
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse_Bs(&context) == P_SUCCESS); assert(p_parse_Bs(context) == P_SUCCESS);
result = p_result_Bs(&context); result = p_result_Bs(context);
assert(result == 8); assert(result == 8);
input = "c"; input = "c";
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse_R(&context) == P_SUCCESS); assert(p_parse_R(context) == P_SUCCESS);
result = p_result_R(&context); result = p_result_R(context);
assert(result == 3); assert(result == 3);
} }

23
spec/test_starting_rules_tree.c
View File

@ -6,32 +6,35 @@
int main() int main()
{ {
char const * input = "bbbb"; char const * input = "bbbb";
p_context_t context; p_context_t * context;
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
Start * start = p_result(&context); Start * start = p_result(context);
assert_not_null(start->bs); assert_not_null(start->bs);
assert_not_null(start->bs->b); assert_not_null(start->bs->b);
assert_not_null(start->bs->bs->b); assert_not_null(start->bs->bs->b);
assert_not_null(start->bs->bs->bs->b); assert_not_null(start->bs->bs->bs->b);
assert_not_null(start->bs->bs->bs->bs->b); assert_not_null(start->bs->bs->bs->bs->b);
p_free_tree(start); p_free_tree(start);
p_context_delete(context);
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse_Bs(&context) == P_SUCCESS); assert(p_parse_Bs(context) == P_SUCCESS);
Bs * bs = p_result_Bs(&context); Bs * bs = p_result_Bs(context);
assert_not_null(bs->b); assert_not_null(bs->b);
assert_not_null(bs->bs->b); assert_not_null(bs->bs->b);
assert_not_null(bs->bs->bs->b); assert_not_null(bs->bs->bs->b);
assert_not_null(bs->bs->bs->bs->b); assert_not_null(bs->bs->bs->bs->b);
p_free_tree_Bs(bs); p_free_tree_Bs(bs);
p_context_delete(context);
input = "c"; input = "c";
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse_R(&context) == P_SUCCESS); assert(p_parse_R(context) == P_SUCCESS);
R * r = p_result_R(&context); R * r = p_result_R(context);
assert_not_null(r->c); assert_not_null(r->c);
p_free_tree_R(r); p_free_tree_R(r);
p_context_delete(context);
return 0; return 0;
} }

20
spec/test_starting_rules_tree.d
View File

@ -10,27 +10,27 @@ int main()
unittest unittest
{ {
string input = "bbbb"; string input = "bbbb";
p_context_t context; p_context_t * context;
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
Start * start = p_result(&context); Start * start = p_result(context);
assert(start.bs); assert(start.bs);
assert(start.bs.b); assert(start.bs.b);
assert(start.bs.bs.b); assert(start.bs.bs.b);
assert(start.bs.bs.bs.b); assert(start.bs.bs.bs.b);
assert(start.bs.bs.bs.bs.b); assert(start.bs.bs.bs.bs.b);
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse_Bs(&context) == P_SUCCESS); assert(p_parse_Bs(context) == P_SUCCESS);
Bs * bs = p_result_Bs(&context); Bs * bs = p_result_Bs(context);
assert(bs.b); assert(bs.b);
assert(bs.bs.b); assert(bs.bs.b);
assert(bs.bs.bs.b); assert(bs.bs.bs.b);
assert(bs.bs.bs.bs.b); assert(bs.bs.bs.bs.b);
input = "c"; input = "c";
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse_R(&context) == P_SUCCESS); assert(p_parse_R(context) == P_SUCCESS);
R * r = p_result_R(&context); R * r = p_result_R(context);
assert(r.c); assert(r.c);
} }

23
spec/test_tree.c
View File

@ -6,10 +6,10 @@
int main() int main()
{ {
char const * input = "a, ((b)), b"; char const * input = "a, ((b)), b";
p_context_t context; p_context_t * context;
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert_eq(P_SUCCESS, p_parse(&context)); assert_eq(P_SUCCESS, p_parse(context));
Start * start = p_result(&context); Start * start = p_result(context);
assert(start->pItems1 != NULL); assert(start->pItems1 != NULL);
assert(start->pItems != NULL); assert(start->pItems != NULL);
Items * items = start->pItems; Items * items = start->pItems;
@ -34,19 +34,21 @@ int main()
assert(itemsmore->pItemsMore == NULL); assert(itemsmore->pItemsMore == NULL);
p_free_tree(start); p_free_tree(start);
p_context_delete(context);
input = ""; input = "";
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert_eq(P_SUCCESS, p_parse(&context)); assert_eq(P_SUCCESS, p_parse(context));
start = p_result(&context); start = p_result(context);
assert(start->pItems == NULL); assert(start->pItems == NULL);
p_free_tree(start); p_free_tree(start);
p_context_delete(context);
input = "2 1"; input = "2 1";
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert_eq(P_SUCCESS, p_parse(&context)); assert_eq(P_SUCCESS, p_parse(context));
start = p_result(&context); start = p_result(context);
assert(start->pItems != NULL); assert(start->pItems != NULL);
assert(start->pItems->pItem != NULL); assert(start->pItems->pItem != NULL);
assert(start->pItems->pItem->pDual != NULL); assert(start->pItems->pItem->pDual != NULL);
@ -56,6 +58,7 @@ int main()
assert(start->pItems->pItem->pDual->pOne1 == NULL); assert(start->pItems->pItem->pDual->pOne1 == NULL);
p_free_tree(start); p_free_tree(start);
p_context_delete(context);
return 0; return 0;
} }

20
spec/test_tree.d
View File

@ -10,10 +10,10 @@ int main()
unittest unittest
{ {
string input = "a, ((b)), b"; string input = "a, ((b)), b";
p_context_t context; p_context_t * context;
p_context_init(&context, input); context = p_context_new(input);
assert_eq(P_SUCCESS, p_parse(&context)); assert_eq(P_SUCCESS, p_parse(context));
Start * start = p_result(&context); Start * start = p_result(context);
assert(start.pItems1 !is null); assert(start.pItems1 !is null);
assert(start.pItems !is null); assert(start.pItems !is null);
Items * items = start.pItems; Items * items = start.pItems;
@ -38,15 +38,15 @@ unittest
assert(itemsmore.pItemsMore is null); assert(itemsmore.pItemsMore is null);
input = ""; input = "";
p_context_init(&context, input); context = p_context_new(input);
assert_eq(P_SUCCESS, p_parse(&context)); assert_eq(P_SUCCESS, p_parse(context));
start = p_result(&context); start = p_result(context);
assert(start.pItems is null); assert(start.pItems is null);
input = "2 1"; input = "2 1";
p_context_init(&context, input); context = p_context_new(input);
assert_eq(P_SUCCESS, p_parse(&context)); assert_eq(P_SUCCESS, p_parse(context));
start = p_result(&context); start = p_result(context);
assert(start.pItems !is null); assert(start.pItems !is null);
assert(start.pItems.pItem !is null); assert(start.pItems.pItem !is null);
assert(start.pItems.pItem.pDual !is null); assert(start.pItems.pItem.pDual !is null);

9
spec/test_tree_field_aliases.c
View File

@ -6,16 +6,17 @@
int main() int main()
{ {
char const * input = "\na\nb\nc"; char const * input = "\na\nb\nc";
p_context_t context; p_context_t * context;
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
Start * start = p_result(&context); Start * start = p_result(context);
assert_eq(TOKEN_a, start->first->pToken->token); assert_eq(TOKEN_a, start->first->pToken->token);
assert_eq(TOKEN_b, start->second->pToken->token); assert_eq(TOKEN_b, start->second->pToken->token);
assert_eq(TOKEN_c, start->third->pToken->token); assert_eq(TOKEN_c, start->third->pToken->token);
p_free_tree(start); p_free_tree(start);
p_context_delete(context);
return 0; return 0;
} }

8
spec/test_tree_field_aliases.d
View File

@ -10,10 +10,10 @@ int main()
unittest unittest
{ {
string input = "\na\nb\nc"; string input = "\na\nb\nc";
p_context_t context; p_context_t * context;
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
Start * start = p_result(&context); Start * start = p_result(context);
assert_eq(TOKEN_a, start.first.pToken.token); assert_eq(TOKEN_a, start.first.pToken.token);
assert_eq(TOKEN_b, start.second.pToken.token); assert_eq(TOKEN_b, start.second.pToken.token);

30
spec/test_tree_invalid_positions.c
View File

@ -6,10 +6,10 @@
int main() int main()
{ {
char const * input = "\na\n bb ccc"; char const * input = "\na\n bb ccc";
p_context_t context; p_context_t * context;
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
Start * start = p_result(&context); Start * start = p_result(context);
assert_eq(2, start->pT1->pToken->position.row); assert_eq(2, start->pT1->pToken->position.row);
assert_eq(1, start->pT1->pToken->position.col); assert_eq(1, start->pT1->pToken->position.col);
@ -31,11 +31,12 @@ int main()
assert_eq(8, start->end_position.col); assert_eq(8, start->end_position.col);
p_free_tree(start); p_free_tree(start);
p_context_delete(context);
input = "a\nbb"; input = "a\nbb";
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
start = p_result(&context); start = p_result(context);
assert_eq(1, start->pT1->pToken->position.row); assert_eq(1, start->pT1->pToken->position.row);
assert_eq(1, start->pT1->pToken->position.col); assert_eq(1, start->pT1->pToken->position.col);
@ -57,11 +58,12 @@ int main()
assert_eq(2, start->end_position.col); assert_eq(2, start->end_position.col);
p_free_tree(start); p_free_tree(start);
p_context_delete(context);
input = "a\nc\nc"; input = "a\nc\nc";
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
start = p_result(&context); start = p_result(context);
assert_eq(1, start->pT1->pToken->position.row); assert_eq(1, start->pT1->pToken->position.row);
assert_eq(1, start->pT1->pToken->position.col); assert_eq(1, start->pT1->pToken->position.col);
@ -83,11 +85,12 @@ int main()
assert_eq(1, start->end_position.col); assert_eq(1, start->end_position.col);
p_free_tree(start); p_free_tree(start);
p_context_delete(context);
input = "a"; input = "a";
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
start = p_result(&context); start = p_result(context);
assert_eq(1, start->pT1->pToken->position.row); assert_eq(1, start->pT1->pToken->position.row);
assert_eq(1, start->pT1->pToken->position.col); assert_eq(1, start->pT1->pToken->position.col);
@ -105,6 +108,7 @@ int main()
assert_eq(1, start->end_position.col); assert_eq(1, start->end_position.col);
p_free_tree(start); p_free_tree(start);
p_context_delete(context);
return 0; return 0;
} }

26
spec/test_tree_invalid_positions.d
View File

@ -10,10 +10,10 @@ int main()
unittest unittest
{ {
string input = "\na\n bb ccc"; string input = "\na\n bb ccc";
p_context_t context; p_context_t * context;
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
Start * start = p_result(&context); Start * start = p_result(context);
assert_eq(2, start.pT1.pToken.position.row); assert_eq(2, start.pT1.pToken.position.row);
assert_eq(1, start.pT1.pToken.position.col); assert_eq(1, start.pT1.pToken.position.col);
@ -35,9 +35,9 @@ unittest
assert_eq(8, start.end_position.col); assert_eq(8, start.end_position.col);
input = "a\nbb"; input = "a\nbb";
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
start = p_result(&context); start = p_result(context);
assert_eq(1, start.pT1.pToken.position.row); assert_eq(1, start.pT1.pToken.position.row);
assert_eq(1, start.pT1.pToken.position.col); assert_eq(1, start.pT1.pToken.position.col);
@ -59,9 +59,9 @@ unittest
assert_eq(2, start.end_position.col); assert_eq(2, start.end_position.col);
input = "a\nc\nc"; input = "a\nc\nc";
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
start = p_result(&context); start = p_result(context);
assert_eq(1, start.pT1.pToken.position.row); assert_eq(1, start.pT1.pToken.position.row);
assert_eq(1, start.pT1.pToken.position.col); assert_eq(1, start.pT1.pToken.position.col);
@ -83,9 +83,9 @@ unittest
assert_eq(1, start.end_position.col); assert_eq(1, start.end_position.col);
input = "a"; input = "a";
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
start = p_result(&context); start = p_result(context);
assert_eq(1, start.pT1.pToken.position.row); assert_eq(1, start.pT1.pToken.position.row);
assert_eq(1, start.pT1.pToken.position.col); assert_eq(1, start.pT1.pToken.position.col);

9
spec/test_tree_node_memory_remains.c
View File

@ -369,11 +369,11 @@ int main(int argc, char * argv[])
{"size_t_to_ulong", TOKEN_ulong}, {"size_t_to_ulong", TOKEN_ulong},
{"main", TOKEN_int}, {"main", TOKEN_int},
}; };
p_context_t context; p_context_t * context;
p_context_init(&context, (const uint8_t *)input, strlen(input)); context = p_context_new((const uint8_t *)input, strlen(input));
size_t result = p_parse(&context); size_t result = p_parse(context);
assert_eq(P_SUCCESS, result); assert_eq(P_SUCCESS, result);
PModule * pmod = p_result(&context); PModule * pmod = p_result(context);
PModuleItems * pmis = pmod->pModuleItems; PModuleItems * pmis = pmod->pModuleItems;
PFunctionDefinition ** pfds; PFunctionDefinition ** pfds;
size_t n_pfds = 0u; size_t n_pfds = 0u;
@ -413,6 +413,7 @@ int main(int argc, char * argv[])
free(pfds); free(pfds);
p_free_tree(pmod); p_free_tree(pmod);
p_context_delete(context);
return 0; return 0;
} }

8
spec/test_tree_node_memory_remains.d
View File

@ -374,11 +374,11 @@ def main() -> int
Expected("size_t_to_ulong", TOKEN_ulong), Expected("size_t_to_ulong", TOKEN_ulong),
Expected("main", TOKEN_int), Expected("main", TOKEN_int),
]; ];
p_context_t context; p_context_t * context;
p_context_init(&context, input); context = p_context_new(input);
size_t result = p_parse(&context); size_t result = p_parse(context);
assert_eq(P_SUCCESS, result); assert_eq(P_SUCCESS, result);
PModule * pmod = p_result(&context); PModule * pmod = p_result(context);
PModuleItems * pmis = pmod.pModuleItems; PModuleItems * pmis = pmod.pModuleItems;
PFunctionDefinition *[] pfds; PFunctionDefinition *[] pfds;
while (pmis !is null) while (pmis !is null)

23
spec/test_tree_ps.c
View File

@ -6,10 +6,10 @@
int main() int main()
{ {
char const * input = "a, ((b)), b"; char const * input = "a, ((b)), b";
p_context_t context; p_context_t * context;
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert_eq(P_SUCCESS, p_parse(&context)); assert_eq(P_SUCCESS, p_parse(context));
PStartS * start = p_result(&context); PStartS * start = p_result(context);
assert(start->pItems1 != NULL); assert(start->pItems1 != NULL);
assert(start->pItems != NULL); assert(start->pItems != NULL);
PItemsS * items = start->pItems; PItemsS * items = start->pItems;
@ -34,19 +34,21 @@ int main()
assert(itemsmore->pItemsMore == NULL); assert(itemsmore->pItemsMore == NULL);
p_free_tree(start); p_free_tree(start);
p_context_delete(context);
input = ""; input = "";
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert_eq(P_SUCCESS, p_parse(&context)); assert_eq(P_SUCCESS, p_parse(context));
start = p_result(&context); start = p_result(context);
assert(start->pItems == NULL); assert(start->pItems == NULL);
p_free_tree(start); p_free_tree(start);
p_context_delete(context);
input = "2 1"; input = "2 1";
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert_eq(P_SUCCESS, p_parse(&context)); assert_eq(P_SUCCESS, p_parse(context));
start = p_result(&context); start = p_result(context);
assert(start->pItems != NULL); assert(start->pItems != NULL);
assert(start->pItems->pItem != NULL); assert(start->pItems->pItem != NULL);
assert(start->pItems->pItem->pDual != NULL); assert(start->pItems->pItem->pDual != NULL);
@ -56,6 +58,7 @@ int main()
assert(start->pItems->pItem->pDual->pOne1 == NULL); assert(start->pItems->pItem->pDual->pOne1 == NULL);
p_free_tree(start); p_free_tree(start);
p_context_delete(context);
return 0; return 0;
} }

20
spec/test_tree_ps.d
View File

@ -10,10 +10,10 @@ int main()
unittest unittest
{ {
string input = "a, ((b)), b"; string input = "a, ((b)), b";
p_context_t context; p_context_t * context;
p_context_init(&context, input); context = p_context_new(input);
assert_eq(P_SUCCESS, p_parse(&context)); assert_eq(P_SUCCESS, p_parse(context));
PStartS * start = p_result(&context); PStartS * start = p_result(context);
assert(start.pItems1 !is null); assert(start.pItems1 !is null);
assert(start.pItems !is null); assert(start.pItems !is null);
PItemsS * items = start.pItems; PItemsS * items = start.pItems;
@ -38,15 +38,15 @@ unittest
assert(itemsmore.pItemsMore is null); assert(itemsmore.pItemsMore is null);
input = ""; input = "";
p_context_init(&context, input); context = p_context_new(input);
assert_eq(P_SUCCESS, p_parse(&context)); assert_eq(P_SUCCESS, p_parse(context));
start = p_result(&context); start = p_result(context);
assert(start.pItems is null); assert(start.pItems is null);
input = "2 1"; input = "2 1";
p_context_init(&context, input); context = p_context_new(input);
assert_eq(P_SUCCESS, p_parse(&context)); assert_eq(P_SUCCESS, p_parse(context));
start = p_result(&context); start = p_result(context);
assert(start.pItems !is null); assert(start.pItems !is null);
assert(start.pItems.pItem !is null); assert(start.pItems.pItem !is null);
assert(start.pItems.pItem.pDual !is null); assert(start.pItems.pItem.pDual !is null);

16
spec/test_tree_token_positions.c
View File

@ -6,10 +6,10 @@
int main() int main()
{ {
char const * input = "abbccc"; char const * input = "abbccc";
p_context_t context; p_context_t * context;
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
Start * start = p_result(&context); Start * start = p_result(context);
assert_eq(1, start->pT1->pToken->position.row); assert_eq(1, start->pT1->pToken->position.row);
assert_eq(1, start->pT1->pToken->position.col); assert_eq(1, start->pT1->pToken->position.col);
@ -44,11 +44,12 @@ int main()
assert_eq(6, start->end_position.col); assert_eq(6, start->end_position.col);
p_free_tree(start); p_free_tree(start);
p_context_delete(context);
input = "\n\n bb\nc\ncc\n\n a"; input = "\n\n bb\nc\ncc\n\n a";
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
start = p_result(&context); start = p_result(context);
assert_eq(3, start->pT1->pToken->position.row); assert_eq(3, start->pT1->pToken->position.row);
assert_eq(3, start->pT1->pToken->position.col); assert_eq(3, start->pT1->pToken->position.col);
@ -83,6 +84,7 @@ int main()
assert_eq(6, start->end_position.col); assert_eq(6, start->end_position.col);
p_free_tree(start); p_free_tree(start);
p_context_delete(context);
return 0; return 0;
} }

14
spec/test_tree_token_positions.d
View File

@ -10,10 +10,10 @@ int main()
unittest unittest
{ {
string input = "abbccc"; string input = "abbccc";
p_context_t context; p_context_t * context;
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
Start * start = p_result(&context); Start * start = p_result(context);
assert_eq(1, start.pT1.pToken.position.row); assert_eq(1, start.pT1.pToken.position.row);
assert_eq(1, start.pT1.pToken.position.col); assert_eq(1, start.pT1.pToken.position.col);
@ -48,9 +48,9 @@ unittest
assert_eq(6, start.end_position.col); assert_eq(6, start.end_position.col);
input = "\n\n bb\nc\ncc\n\n a"; input = "\n\n bb\nc\ncc\n\n a";
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
start = p_result(&context); start = p_result(context);
assert_eq(3, start.pT1.pToken.position.row); assert_eq(3, start.pT1.pToken.position.row);
assert_eq(3, start.pT1.pToken.position.col); assert_eq(3, start.pT1.pToken.position.col);

12
spec/test_user_code.c
View File

@ -6,15 +6,17 @@
int main() int main()
{ {
char const * input = "abcdef"; char const * input = "abcdef";
p_context_t context; p_context_t * context;
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
printf("pass1\n"); printf("pass1\n");
p_context_delete(context);
input = "abcabcdef"; input = "abcabcdef";
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
printf("pass2\n"); printf("pass2\n");
p_context_delete(context);
return 0; return 0;
} }

10
spec/test_user_code.d
View File

@ -9,13 +9,13 @@ int main()
unittest unittest
{ {
string input = "abcdef"; string input = "abcdef";
p_context_t context; p_context_t * context;
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
writeln("pass1"); writeln("pass1");
input = "abcabcdef"; input = "abcabcdef";
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
writeln("pass2"); writeln("pass2");
} }

13
spec/test_user_context_fields.c
View File

@ -7,13 +7,14 @@
int main() int main()
{ {
char const * input = "aaa\n\n\na\n # comment 1\na a aa\n\naa\n# comment 2\na\n"; char const * input = "aaa\n\n\na\n # comment 1\na a aa\n\naa\n# comment 2\na\n";
p_context_t context; p_context_t * context;
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
fprintf(stderr, "comments: %s", context.comments); fprintf(stderr, "comments: %s", context->comments);
fprintf(stderr, "acount: %u\n", context.acount); fprintf(stderr, "acount: %u\n", context->acount);
free(context.comments); free(context->comments);
p_context_delete(context);
return 0; return 0;
} }

6
spec/test_user_context_fields.d
View File

@ -10,9 +10,9 @@ int main()
unittest unittest
{ {
string input = "aaa\n\n\na\n # comment 1\na a aa\n\naa\n# comment 2\na\n"; string input = "aaa\n\n\na\n # comment 1\na a aa\n\naa\n# comment 2\na\n";
p_context_t context; p_context_t * context;
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
stderr.writeln("comments: ", context.comments); stderr.writeln("comments: ", context.comments);
stderr.writeln("acount: ", context.acount); stderr.writeln("acount: ", context.acount);

14
spec/test_user_terminate.c
View File

@ -6,14 +6,16 @@
int main() int main()
{ {
char const * input = "aacc"; char const * input = "aacc";
p_context_t context; p_context_t * context;
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
p_context_delete(context);
input = "abc"; input = "abc";
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_USER_TERMINATED); assert(p_parse(context) == P_USER_TERMINATED);
assert(p_user_terminate_code(&context) == 4200); assert(p_user_terminate_code(context) == 4200);
p_context_delete(context);
return 0; return 0;
} }

12
spec/test_user_terminate.d
View File

@ -9,12 +9,12 @@ int main()
unittest unittest
{ {
string input = "aacc"; string input = "aacc";
p_context_t context; p_context_t * context;
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
input = "abc"; input = "abc";
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_USER_TERMINATED); assert(p_parse(context) == P_USER_TERMINATED);
assert(p_user_terminate_code(&context) == 4200); assert(p_user_terminate_code(context) == 4200);
} }

14
spec/test_user_terminate_lexer.c
View File

@ -6,14 +6,16 @@
int main() int main()
{ {
char const * input = "a"; char const * input = "a";
p_context_t context; p_context_t * context;
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
p_context_delete(context);
input = "b"; input = "b";
p_context_init(&context, (uint8_t const *)input, strlen(input)); context = p_context_new((uint8_t const *)input, strlen(input));
assert(p_parse(&context) == P_USER_TERMINATED); assert(p_parse(context) == P_USER_TERMINATED);
assert(p_user_terminate_code(&context) == 8675309); assert(p_user_terminate_code(context) == 8675309);
p_context_delete(context);
return 0; return 0;
} }

12
spec/test_user_terminate_lexer.d
View File

@ -9,12 +9,12 @@ int main()
unittest unittest
{ {
string input = "a"; string input = "a";
p_context_t context; p_context_t * context;
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(context) == P_SUCCESS);
input = "b"; input = "b";
p_context_init(&context, input); context = p_context_new(input);
assert(p_parse(&context) == P_USER_TERMINATED); assert(p_parse(context) == P_USER_TERMINATED);
assert(p_user_terminate_code(&context) == 8675309); assert(p_user_terminate_code(context) == 8675309);
} }