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

spec/test_basic_math_grammar.c

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

spec/test_basic_math_grammar.d

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

spec/test_drop_code_block.c

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

spec/test_drop_code_block.d

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

spec/test_error_positions.c

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

spec/test_error_positions.d

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

spec/test_field_aliases.c

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

spec/test_field_aliases.d

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

spec/test_free_tree_token_node_memory.c

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

spec/test_lexer.c

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

spec/test_lexer.d

@@ -44,26 +44,26 @@ unittest
 {
     p_token_info_t token_info;
     string input = "5 + 4 * \n677 + 567";
-    p_context_t context;
-    p_context_init(&context, input);
-    assert(p_lex(&context, &token_info) == P_SUCCESS);
+    p_context_t * context;
+    context = p_context_new(input);
+    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(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(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(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(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(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(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(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));
 
-    p_context_init(&context, "");
-    assert(p_lex(&context, &token_info) == P_SUCCESS);
+    context = p_context_new("");
+    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));
 }

spec/test_lexer_match_text.c

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

spec/test_lexer_match_text.d

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

spec/test_lexer_modes.c

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

spec/test_lexer_modes.d

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

spec/test_lexer_multiple_modes.c

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

spec/test_lexer_multiple_modes.d

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

spec/test_lexer_result_value.c

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

spec/test_lexer_result_value.d

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

spec/test_lexer_unknown_character.c

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

spec/test_lexer_unknown_character.d

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

spec/test_match_backslashes.c

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

spec/test_match_backslashes.d

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

spec/test_multiple_parsers.c

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

spec/test_multiple_parsers.d

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

spec/test_named_optional_rule_component_tree.c

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

spec/test_named_optional_rule_component_tree.d

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

spec/test_optional_rule_component.c

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

spec/test_optional_rule_component.d

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

spec/test_optional_rule_component_tree.c

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

spec/test_optional_rule_component_tree.d

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

spec/test_parser_identical_rules_lookahead.c

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

spec/test_parser_identical_rules_lookahead.d

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

spec/test_parser_rule_from_multiple_states.c

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

spec/test_parser_rule_from_multiple_states.d

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

spec/test_parser_rule_user_code.c

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

spec/test_parser_rule_user_code.d

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

spec/test_parsing_json.c

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

spec/test_parsing_json.d

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

spec/test_parsing_lists.c

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

spec/test_parsing_lists.d

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

spec/test_pattern.c

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

spec/test_pattern.d

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

spec/test_return_token_from_pattern.c

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

spec/test_return_token_from_pattern.d

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

spec/test_start_rule_tree.c

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

spec/test_start_rule_tree.d

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

spec/test_starting_rules.c

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

spec/test_starting_rules.d

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

spec/test_starting_rules_tree.c

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

spec/test_starting_rules_tree.d

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

spec/test_tree.c

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

spec/test_tree.d

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

spec/test_tree_field_aliases.c

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

spec/test_tree_field_aliases.d

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

spec/test_tree_invalid_positions.c

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

spec/test_tree_invalid_positions.d

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

spec/test_tree_node_memory_remains.c

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

spec/test_tree_node_memory_remains.d

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

spec/test_tree_ps.c

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

spec/test_tree_ps.d

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

spec/test_tree_token_positions.c

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

spec/test_tree_token_positions.d

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

spec/test_user_code.c

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

spec/test_user_code.d

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

spec/test_user_context_fields.c

@@ -7,13 +7,14 @@
 int main()
 {
     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_init(&context, (uint8_t const *)input, strlen(input));
-    assert(p_parse(&context) == P_SUCCESS);
+    p_context_t * context;
+    context = p_context_new((uint8_t const *)input, strlen(input));
+    assert(p_parse(context) == P_SUCCESS);
 
-    fprintf(stderr, "comments: %s", context.comments);
-    fprintf(stderr, "acount: %u\n", context.acount);
-    free(context.comments);
+    fprintf(stderr, "comments: %s", context->comments);
+    fprintf(stderr, "acount: %u\n", context->acount);
+    free(context->comments);
+    p_context_delete(context);
 
     return 0;
 }

spec/test_user_context_fields.d

@@ -10,9 +10,9 @@ int main()
 unittest
 {
     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_init(&context, input);
-    assert(p_parse(&context) == P_SUCCESS);
+    p_context_t * context;
+    context = p_context_new(input);
+    assert(p_parse(context) == P_SUCCESS);
 
     stderr.writeln("comments: ", context.comments);
     stderr.writeln("acount: ", context.acount);

spec/test_user_terminate.c

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

spec/test_user_terminate.d

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

spec/test_user_terminate_lexer.c

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

spec/test_user_terminate_lexer.d

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