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

Use 1-based row and column values for position values - close #30

Browse Source
This commit is contained in:
Josh Holtrop 2024-09-25 15:58:03 -04:00
parent 98e10d3d14
commit 1d468b6d3c
14 changed files with 303 additions and 299 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
assets/parser.c.erb
View File

@ -60,6 +60,8 @@ void <%= @grammar.prefix %>context_init(<%= @grammar.prefix %>context_t * contex
/* Lexer initialization. */ /* Lexer initialization. */
newcontext.input = input; newcontext.input = input;
newcontext.input_length = input_length; newcontext.input_length = input_length;
newcontext.text_position.row = 1u;
newcontext.text_position.col = 1u;
newcontext.mode = <%= @lexer.mode_id("default") %>; newcontext.mode = <%= @lexer.mode_id("default") %>;
/* Copy to the user's context structure. */ /* Copy to the user's context structure. */
@ -365,7 +367,7 @@ static size_t find_longest_match(<%= @grammar.prefix %>context_t * context,
if (code_point == '\n') if (code_point == '\n')
{ {
attempt_match.delta_position.row++; attempt_match.delta_position.row++;
attempt_match.delta_position.col = 0u; attempt_match.delta_position.col = 1u;
} }
else else
{ {
@ -567,7 +569,7 @@ size_t <%= @grammar.prefix %>lex(<%= @grammar.prefix %>context_t * context, <%=
*************************************************************************/ *************************************************************************/
/** Invalid position value. */ /** Invalid position value. */
#define INVALID_POSITION (<%= @grammar.prefix %>position_t){0xFFFFFFFFu, 0xFFFFFFFFu} #define INVALID_POSITION (<%= @grammar.prefix %>position_t){0u, 0u}
/** Reduce ID type. */ /** Reduce ID type. */
typedef <%= get_type_for(@parser.reduce_table.size) %> reduce_id_t; typedef <%= get_type_for(@parser.reduce_table.size) %> reduce_id_t;

8
assets/parser.d.erb
View File

@ -65,12 +65,12 @@ public struct <%= @grammar.prefix %>position_t
uint col; uint col;
/** Invalid position value. */ /** Invalid position value. */
enum INVALID = <%= @grammar.prefix %>position_t(0xFFFF_FFFF, 0xFFFF_FFFF); enum INVALID = <%= @grammar.prefix %>position_t(0u, 0u);
/** Return whether the position is valid. */ /** Return whether the position is valid. */
public @property bool valid() public @property bool valid()
{ {
return row != 0xFFFF_FFFFu; return row != 0u;
} }
} }
@ -235,6 +235,8 @@ public void <%= @grammar.prefix %>context_init(<%= @grammar.prefix %>context_t *
/* Lexer initialization. */ /* Lexer initialization. */
newcontext.input = input; newcontext.input = input;
newcontext.text_position.row = 1u;
newcontext.text_position.col = 1u;
newcontext.mode = <%= @lexer.mode_id("default") %>; newcontext.mode = <%= @lexer.mode_id("default") %>;
/* Copy to the user's context structure. */ /* Copy to the user's context structure. */
@ -534,7 +536,7 @@ private size_t find_longest_match(<%= @grammar.prefix %>context_t * context,
if (code_point == '\n') if (code_point == '\n')
{ {
attempt_match.delta_position.row++; attempt_match.delta_position.row++;
attempt_match.delta_position.col = 0u; attempt_match.delta_position.col = 1u;
} }
else else
{ {

2
assets/parser.h.erb
View File

@ -53,7 +53,7 @@ typedef struct
} <%= @grammar.prefix %>position_t; } <%= @grammar.prefix %>position_t;
/** Return whether the position is valid. */ /** Return whether the position is valid. */
#define <%= @grammar.prefix %>position_valid(p) ((p).row != 0xFFFFFFFFu) #define <%= @grammar.prefix %>position_valid(p) ((p).row != 0u)
/** User header code blocks. */ /** User header code blocks. */
<%= @grammar.code_blocks.fetch("header", "") %> <%= @grammar.code_blocks.fetch("header", "") %>

2
doc/user_guide.md
View File

@ -777,7 +777,7 @@ A pointer to this instance is passed to the generated functions.
### `p_position_t` ### `p_position_t`
The `p_position_t` structure contains two fields `row` and `col`. The `p_position_t` structure contains two fields `row` and `col`.
These fields contain the 0-based row and column describing a parser position. These fields contain the 1-based row and column describing a parser position.
For D targets, the `p_position_t` structure can be checked for validity by For D targets, the `p_position_t` structure can be checked for validity by
querying the `valid` property. querying the `valid` property.

120
spec/test_ast_invalid_positions.c
View File

@ -11,92 +11,92 @@ int main()
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(2, start->pT1->pToken->position.row);
assert_eq(0, start->pT1->pToken->position.col); assert_eq(1, start->pT1->pToken->position.col);
assert_eq(1, start->pT1->pToken->end_position.row); assert_eq(2, start->pT1->pToken->end_position.row);
assert_eq(0, start->pT1->pToken->end_position.col); assert_eq(1, start->pT1->pToken->end_position.col);
assert(p_position_valid(start->pT1->pA->position)); assert(p_position_valid(start->pT1->pA->position));
assert_eq(2, start->pT1->pA->position.row); assert_eq(3, start->pT1->pA->position.row);
assert_eq(2, start->pT1->pA->position.col); assert_eq(3, start->pT1->pA->position.col);
assert_eq(2, start->pT1->pA->end_position.row); assert_eq(3, start->pT1->pA->end_position.row);
assert_eq(7, start->pT1->pA->end_position.col); assert_eq(8, start->pT1->pA->end_position.col);
assert_eq(1, start->pT1->position.row); assert_eq(2, start->pT1->position.row);
assert_eq(0, start->pT1->position.col); assert_eq(1, start->pT1->position.col);
assert_eq(2, start->pT1->end_position.row); assert_eq(3, start->pT1->end_position.row);
assert_eq(7, start->pT1->end_position.col); assert_eq(8, start->pT1->end_position.col);
assert_eq(1, start->position.row); assert_eq(2, start->position.row);
assert_eq(0, start->position.col); assert_eq(1, start->position.col);
assert_eq(2, start->end_position.row); assert_eq(3, start->end_position.row);
assert_eq(7, start->end_position.col); assert_eq(8, start->end_position.col);
input = "a\nbb"; input = "a\nbb";
p_context_init(&context, (uint8_t const *)input, strlen(input)); p_context_init(&context, (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(0, start->pT1->pToken->position.row); assert_eq(1, start->pT1->pToken->position.row);
assert_eq(0, start->pT1->pToken->position.col); assert_eq(1, start->pT1->pToken->position.col);
assert_eq(0, start->pT1->pToken->end_position.row); assert_eq(1, start->pT1->pToken->end_position.row);
assert_eq(0, start->pT1->pToken->end_position.col); assert_eq(1, start->pT1->pToken->end_position.col);
assert(p_position_valid(start->pT1->pA->position)); assert(p_position_valid(start->pT1->pA->position));
assert_eq(1, start->pT1->pA->position.row); assert_eq(2, start->pT1->pA->position.row);
assert_eq(0, start->pT1->pA->position.col); assert_eq(1, start->pT1->pA->position.col);
assert_eq(1, start->pT1->pA->end_position.row); assert_eq(2, start->pT1->pA->end_position.row);
assert_eq(1, start->pT1->pA->end_position.col); assert_eq(2, start->pT1->pA->end_position.col);
assert_eq(0, start->pT1->position.row); assert_eq(1, start->pT1->position.row);
assert_eq(0, start->pT1->position.col); assert_eq(1, start->pT1->position.col);
assert_eq(1, start->pT1->end_position.row); assert_eq(2, start->pT1->end_position.row);
assert_eq(1, start->pT1->end_position.col); assert_eq(2, start->pT1->end_position.col);
assert_eq(0, start->position.row); assert_eq(1, start->position.row);
assert_eq(0, start->position.col); assert_eq(1, start->position.col);
assert_eq(1, start->end_position.row); assert_eq(2, start->end_position.row);
assert_eq(1, start->end_position.col); assert_eq(2, start->end_position.col);
input = "a\nc\nc"; input = "a\nc\nc";
p_context_init(&context, (uint8_t const *)input, strlen(input)); p_context_init(&context, (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(0, start->pT1->pToken->position.row); assert_eq(1, start->pT1->pToken->position.row);
assert_eq(0, start->pT1->pToken->position.col); assert_eq(1, start->pT1->pToken->position.col);
assert_eq(0, start->pT1->pToken->end_position.row); assert_eq(1, start->pT1->pToken->end_position.row);
assert_eq(0, start->pT1->pToken->end_position.col); assert_eq(1, start->pT1->pToken->end_position.col);
assert(p_position_valid(start->pT1->pA->position)); assert(p_position_valid(start->pT1->pA->position));
assert_eq(1, start->pT1->pA->position.row); assert_eq(2, start->pT1->pA->position.row);
assert_eq(0, start->pT1->pA->position.col); assert_eq(1, start->pT1->pA->position.col);
assert_eq(2, start->pT1->pA->end_position.row); assert_eq(3, start->pT1->pA->end_position.row);
assert_eq(0, start->pT1->pA->end_position.col); assert_eq(1, start->pT1->pA->end_position.col);
assert_eq(0, start->pT1->position.row); assert_eq(1, start->pT1->position.row);
assert_eq(0, start->pT1->position.col); assert_eq(1, start->pT1->position.col);
assert_eq(2, start->pT1->end_position.row); assert_eq(3, start->pT1->end_position.row);
assert_eq(0, start->pT1->end_position.col); assert_eq(1, start->pT1->end_position.col);
assert_eq(0, start->position.row); assert_eq(1, start->position.row);
assert_eq(0, start->position.col); assert_eq(1, start->position.col);
assert_eq(2, start->end_position.row); assert_eq(3, start->end_position.row);
assert_eq(0, start->end_position.col); assert_eq(1, start->end_position.col);
input = "a"; input = "a";
p_context_init(&context, (uint8_t const *)input, strlen(input)); p_context_init(&context, (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(0, start->pT1->pToken->position.row); assert_eq(1, start->pT1->pToken->position.row);
assert_eq(0, start->pT1->pToken->position.col); assert_eq(1, start->pT1->pToken->position.col);
assert_eq(0, start->pT1->pToken->end_position.row); assert_eq(1, start->pT1->pToken->end_position.row);
assert_eq(0, start->pT1->pToken->end_position.col); assert_eq(1, start->pT1->pToken->end_position.col);
assert(!p_position_valid(start->pT1->pA->position)); assert(!p_position_valid(start->pT1->pA->position));
assert_eq(0, start->pT1->position.row); assert_eq(1, start->pT1->position.row);
assert_eq(0, start->pT1->position.col); assert_eq(1, start->pT1->position.col);
assert_eq(0, start->pT1->end_position.row); assert_eq(1, start->pT1->end_position.row);
assert_eq(0, start->pT1->end_position.col); assert_eq(1, start->pT1->end_position.col);
assert_eq(0, start->position.row); assert_eq(1, start->position.row);
assert_eq(0, start->position.col); assert_eq(1, start->position.col);
assert_eq(0, start->end_position.row); assert_eq(1, start->end_position.row);
assert_eq(0, start->end_position.col); assert_eq(1, start->end_position.col);
return 0; return 0;
} }

120
spec/test_ast_invalid_positions.d
View File

@ -15,90 +15,90 @@ unittest
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(2, start.pT1.pToken.position.row);
assert_eq(0, start.pT1.pToken.position.col); assert_eq(1, start.pT1.pToken.position.col);
assert_eq(1, start.pT1.pToken.end_position.row); assert_eq(2, start.pT1.pToken.end_position.row);
assert_eq(0, start.pT1.pToken.end_position.col); assert_eq(1, start.pT1.pToken.end_position.col);
assert(start.pT1.pA.position.valid); assert(start.pT1.pA.position.valid);
assert_eq(2, start.pT1.pA.position.row); assert_eq(3, start.pT1.pA.position.row);
assert_eq(2, start.pT1.pA.position.col); assert_eq(3, start.pT1.pA.position.col);
assert_eq(2, start.pT1.pA.end_position.row); assert_eq(3, start.pT1.pA.end_position.row);
assert_eq(7, start.pT1.pA.end_position.col); assert_eq(8, start.pT1.pA.end_position.col);
assert_eq(1, start.pT1.position.row); assert_eq(2, start.pT1.position.row);
assert_eq(0, start.pT1.position.col); assert_eq(1, start.pT1.position.col);
assert_eq(2, start.pT1.end_position.row); assert_eq(3, start.pT1.end_position.row);
assert_eq(7, start.pT1.end_position.col); assert_eq(8, start.pT1.end_position.col);
assert_eq(1, start.position.row); assert_eq(2, start.position.row);
assert_eq(0, start.position.col); assert_eq(1, start.position.col);
assert_eq(2, start.end_position.row); assert_eq(3, start.end_position.row);
assert_eq(7, start.end_position.col); assert_eq(8, start.end_position.col);
input = "a\nbb"; input = "a\nbb";
p_context_init(&context, input); p_context_init(&context, input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(&context) == P_SUCCESS);
start = p_result(&context); start = p_result(&context);
assert_eq(0, start.pT1.pToken.position.row); assert_eq(1, start.pT1.pToken.position.row);
assert_eq(0, start.pT1.pToken.position.col); assert_eq(1, start.pT1.pToken.position.col);
assert_eq(0, start.pT1.pToken.end_position.row); assert_eq(1, start.pT1.pToken.end_position.row);
assert_eq(0, start.pT1.pToken.end_position.col); assert_eq(1, start.pT1.pToken.end_position.col);
assert(start.pT1.pA.position.valid); assert(start.pT1.pA.position.valid);
assert_eq(1, start.pT1.pA.position.row); assert_eq(2, start.pT1.pA.position.row);
assert_eq(0, start.pT1.pA.position.col); assert_eq(1, start.pT1.pA.position.col);
assert_eq(1, start.pT1.pA.end_position.row); assert_eq(2, start.pT1.pA.end_position.row);
assert_eq(1, start.pT1.pA.end_position.col); assert_eq(2, start.pT1.pA.end_position.col);
assert_eq(0, start.pT1.position.row); assert_eq(1, start.pT1.position.row);
assert_eq(0, start.pT1.position.col); assert_eq(1, start.pT1.position.col);
assert_eq(1, start.pT1.end_position.row); assert_eq(2, start.pT1.end_position.row);
assert_eq(1, start.pT1.end_position.col); assert_eq(2, start.pT1.end_position.col);
assert_eq(0, start.position.row); assert_eq(1, start.position.row);
assert_eq(0, start.position.col); assert_eq(1, start.position.col);
assert_eq(1, start.end_position.row); assert_eq(2, start.end_position.row);
assert_eq(1, start.end_position.col); assert_eq(2, start.end_position.col);
input = "a\nc\nc"; input = "a\nc\nc";
p_context_init(&context, input); p_context_init(&context, input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(&context) == P_SUCCESS);
start = p_result(&context); start = p_result(&context);
assert_eq(0, start.pT1.pToken.position.row); assert_eq(1, start.pT1.pToken.position.row);
assert_eq(0, start.pT1.pToken.position.col); assert_eq(1, start.pT1.pToken.position.col);
assert_eq(0, start.pT1.pToken.end_position.row); assert_eq(1, start.pT1.pToken.end_position.row);
assert_eq(0, start.pT1.pToken.end_position.col); assert_eq(1, start.pT1.pToken.end_position.col);
assert(start.pT1.pA.position.valid); assert(start.pT1.pA.position.valid);
assert_eq(1, start.pT1.pA.position.row); assert_eq(2, start.pT1.pA.position.row);
assert_eq(0, start.pT1.pA.position.col); assert_eq(1, start.pT1.pA.position.col);
assert_eq(2, start.pT1.pA.end_position.row); assert_eq(3, start.pT1.pA.end_position.row);
assert_eq(0, start.pT1.pA.end_position.col); assert_eq(1, start.pT1.pA.end_position.col);
assert_eq(0, start.pT1.position.row); assert_eq(1, start.pT1.position.row);
assert_eq(0, start.pT1.position.col); assert_eq(1, start.pT1.position.col);
assert_eq(2, start.pT1.end_position.row); assert_eq(3, start.pT1.end_position.row);
assert_eq(0, start.pT1.end_position.col); assert_eq(1, start.pT1.end_position.col);
assert_eq(0, start.position.row); assert_eq(1, start.position.row);
assert_eq(0, start.position.col); assert_eq(1, start.position.col);
assert_eq(2, start.end_position.row); assert_eq(3, start.end_position.row);
assert_eq(0, start.end_position.col); assert_eq(1, start.end_position.col);
input = "a"; input = "a";
p_context_init(&context, input); p_context_init(&context, input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(&context) == P_SUCCESS);
start = p_result(&context); start = p_result(&context);
assert_eq(0, start.pT1.pToken.position.row); assert_eq(1, start.pT1.pToken.position.row);
assert_eq(0, start.pT1.pToken.position.col); assert_eq(1, start.pT1.pToken.position.col);
assert_eq(0, start.pT1.pToken.end_position.row); assert_eq(1, start.pT1.pToken.end_position.row);
assert_eq(0, start.pT1.pToken.end_position.col); assert_eq(1, start.pT1.pToken.end_position.col);
assert(!start.pT1.pA.position.valid); assert(!start.pT1.pA.position.valid);
assert_eq(0, start.pT1.position.row); assert_eq(1, start.pT1.position.row);
assert_eq(0, start.pT1.position.col); assert_eq(1, start.pT1.position.col);
assert_eq(0, start.pT1.end_position.row); assert_eq(1, start.pT1.end_position.row);
assert_eq(0, start.pT1.end_position.col); assert_eq(1, start.pT1.end_position.col);
assert_eq(0, start.position.row); assert_eq(1, start.position.row);
assert_eq(0, start.position.col); assert_eq(1, start.position.col);
assert_eq(0, start.end_position.row); assert_eq(1, start.end_position.row);
assert_eq(0, start.end_position.col); assert_eq(1, start.end_position.col);
} }

112
spec/test_ast_token_positions.c
View File

@ -11,74 +11,74 @@ int main()
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(&context) == P_SUCCESS);
Start * start = p_result(&context); Start * start = p_result(&context);
assert_eq(0, start->pT1->pToken->position.row); assert_eq(1, start->pT1->pToken->position.row);
assert_eq(0, start->pT1->pToken->position.col); assert_eq(1, start->pT1->pToken->position.col);
assert_eq(0, start->pT1->pToken->end_position.row); assert_eq(1, start->pT1->pToken->end_position.row);
assert_eq(0, start->pT1->pToken->end_position.col); assert_eq(1, start->pT1->pToken->end_position.col);
assert_eq(0, start->pT1->position.row); assert_eq(1, start->pT1->position.row);
assert_eq(0, start->pT1->position.col); assert_eq(1, start->pT1->position.col);
assert_eq(0, start->pT1->end_position.row); assert_eq(1, start->pT1->end_position.row);
assert_eq(0, start->pT1->end_position.col); assert_eq(1, start->pT1->end_position.col);
assert_eq(0, start->pT2->pToken->position.row); assert_eq(1, start->pT2->pToken->position.row);
assert_eq(1, start->pT2->pToken->position.col); assert_eq(2, start->pT2->pToken->position.col);
assert_eq(0, start->pT2->pToken->end_position.row); assert_eq(1, start->pT2->pToken->end_position.row);
assert_eq(2, start->pT2->pToken->end_position.col); assert_eq(3, start->pT2->pToken->end_position.col);
assert_eq(0, start->pT2->position.row); assert_eq(1, start->pT2->position.row);
assert_eq(1, start->pT2->position.col); assert_eq(2, start->pT2->position.col);
assert_eq(0, start->pT2->end_position.row); assert_eq(1, start->pT2->end_position.row);
assert_eq(2, start->pT2->end_position.col); assert_eq(3, start->pT2->end_position.col);
assert_eq(0, start->pT3->pToken->position.row); assert_eq(1, start->pT3->pToken->position.row);
assert_eq(3, start->pT3->pToken->position.col); assert_eq(4, start->pT3->pToken->position.col);
assert_eq(0, start->pT3->pToken->end_position.row); assert_eq(1, start->pT3->pToken->end_position.row);
assert_eq(5, start->pT3->pToken->end_position.col); assert_eq(6, start->pT3->pToken->end_position.col);
assert_eq(0, start->pT3->position.row); assert_eq(1, start->pT3->position.row);
assert_eq(3, start->pT3->position.col); assert_eq(4, start->pT3->position.col);
assert_eq(0, start->pT3->end_position.row); assert_eq(1, start->pT3->end_position.row);
assert_eq(5, start->pT3->end_position.col); assert_eq(6, start->pT3->end_position.col);
assert_eq(0, start->position.row); assert_eq(1, start->position.row);
assert_eq(0, start->position.col); assert_eq(1, start->position.col);
assert_eq(0, start->end_position.row); assert_eq(1, start->end_position.row);
assert_eq(5, 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, (uint8_t const *)input, strlen(input)); p_context_init(&context, (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(2, start->pT1->pToken->position.row); assert_eq(3, start->pT1->pToken->position.row);
assert_eq(2, start->pT1->pToken->position.col); assert_eq(3, start->pT1->pToken->position.col);
assert_eq(2, start->pT1->pToken->end_position.row); assert_eq(3, start->pT1->pToken->end_position.row);
assert_eq(3, start->pT1->pToken->end_position.col); assert_eq(4, start->pT1->pToken->end_position.col);
assert_eq(2, start->pT1->position.row); assert_eq(3, start->pT1->position.row);
assert_eq(2, start->pT1->position.col); assert_eq(3, start->pT1->position.col);
assert_eq(2, start->pT1->end_position.row); assert_eq(3, start->pT1->end_position.row);
assert_eq(3, start->pT1->end_position.col); assert_eq(4, start->pT1->end_position.col);
assert_eq(3, start->pT2->pToken->position.row); assert_eq(4, start->pT2->pToken->position.row);
assert_eq(0, start->pT2->pToken->position.col); assert_eq(1, start->pT2->pToken->position.col);
assert_eq(4, start->pT2->pToken->end_position.row); assert_eq(5, start->pT2->pToken->end_position.row);
assert_eq(1, start->pT2->pToken->end_position.col); assert_eq(2, start->pT2->pToken->end_position.col);
assert_eq(3, start->pT2->position.row); assert_eq(4, start->pT2->position.row);
assert_eq(0, start->pT2->position.col); assert_eq(1, start->pT2->position.col);
assert_eq(4, start->pT2->end_position.row); assert_eq(5, start->pT2->end_position.row);
assert_eq(1, start->pT2->end_position.col); assert_eq(2, start->pT2->end_position.col);
assert_eq(6, start->pT3->pToken->position.row); assert_eq(7, start->pT3->pToken->position.row);
assert_eq(5, start->pT3->pToken->position.col); assert_eq(6, start->pT3->pToken->position.col);
assert_eq(6, start->pT3->pToken->end_position.row); assert_eq(7, start->pT3->pToken->end_position.row);
assert_eq(5, start->pT3->pToken->end_position.col); assert_eq(6, start->pT3->pToken->end_position.col);
assert_eq(6, start->pT3->position.row); assert_eq(7, start->pT3->position.row);
assert_eq(5, start->pT3->position.col); assert_eq(6, start->pT3->position.col);
assert_eq(6, start->pT3->end_position.row); assert_eq(7, start->pT3->end_position.row);
assert_eq(5, start->pT3->end_position.col); assert_eq(6, start->pT3->end_position.col);
assert_eq(2, start->position.row); assert_eq(3, start->position.row);
assert_eq(2, start->position.col); assert_eq(3, start->position.col);
assert_eq(6, start->end_position.row); assert_eq(7, start->end_position.row);
assert_eq(5, start->end_position.col); assert_eq(6, start->end_position.col);
return 0; return 0;
} }

112
spec/test_ast_token_positions.d
View File

@ -15,72 +15,72 @@ unittest
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(&context) == P_SUCCESS);
Start * start = p_result(&context); Start * start = p_result(&context);
assert_eq(0, start.pT1.pToken.position.row); assert_eq(1, start.pT1.pToken.position.row);
assert_eq(0, start.pT1.pToken.position.col); assert_eq(1, start.pT1.pToken.position.col);
assert_eq(0, start.pT1.pToken.end_position.row); assert_eq(1, start.pT1.pToken.end_position.row);
assert_eq(0, start.pT1.pToken.end_position.col); assert_eq(1, start.pT1.pToken.end_position.col);
assert_eq(0, start.pT1.position.row); assert_eq(1, start.pT1.position.row);
assert_eq(0, start.pT1.position.col); assert_eq(1, start.pT1.position.col);
assert_eq(0, start.pT1.end_position.row); assert_eq(1, start.pT1.end_position.row);
assert_eq(0, start.pT1.end_position.col); assert_eq(1, start.pT1.end_position.col);
assert_eq(0, start.pT2.pToken.position.row); assert_eq(1, start.pT2.pToken.position.row);
assert_eq(1, start.pT2.pToken.position.col); assert_eq(2, start.pT2.pToken.position.col);
assert_eq(0, start.pT2.pToken.end_position.row); assert_eq(1, start.pT2.pToken.end_position.row);
assert_eq(2, start.pT2.pToken.end_position.col); assert_eq(3, start.pT2.pToken.end_position.col);
assert_eq(0, start.pT2.position.row); assert_eq(1, start.pT2.position.row);
assert_eq(1, start.pT2.position.col); assert_eq(2, start.pT2.position.col);
assert_eq(0, start.pT2.end_position.row); assert_eq(1, start.pT2.end_position.row);
assert_eq(2, start.pT2.end_position.col); assert_eq(3, start.pT2.end_position.col);
assert_eq(0, start.pT3.pToken.position.row); assert_eq(1, start.pT3.pToken.position.row);
assert_eq(3, start.pT3.pToken.position.col); assert_eq(4, start.pT3.pToken.position.col);
assert_eq(0, start.pT3.pToken.end_position.row); assert_eq(1, start.pT3.pToken.end_position.row);
assert_eq(5, start.pT3.pToken.end_position.col); assert_eq(6, start.pT3.pToken.end_position.col);
assert_eq(0, start.pT3.position.row); assert_eq(1, start.pT3.position.row);
assert_eq(3, start.pT3.position.col); assert_eq(4, start.pT3.position.col);
assert_eq(0, start.pT3.end_position.row); assert_eq(1, start.pT3.end_position.row);
assert_eq(5, start.pT3.end_position.col); assert_eq(6, start.pT3.end_position.col);
assert_eq(0, start.position.row); assert_eq(1, start.position.row);
assert_eq(0, start.position.col); assert_eq(1, start.position.col);
assert_eq(0, start.end_position.row); assert_eq(1, start.end_position.row);
assert_eq(5, 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); p_context_init(&context, input);
assert(p_parse(&context) == P_SUCCESS); assert(p_parse(&context) == P_SUCCESS);
start = p_result(&context); start = p_result(&context);
assert_eq(2, start.pT1.pToken.position.row); assert_eq(3, start.pT1.pToken.position.row);
assert_eq(2, start.pT1.pToken.position.col); assert_eq(3, start.pT1.pToken.position.col);
assert_eq(2, start.pT1.pToken.end_position.row); assert_eq(3, start.pT1.pToken.end_position.row);
assert_eq(3, start.pT1.pToken.end_position.col); assert_eq(4, start.pT1.pToken.end_position.col);
assert_eq(2, start.pT1.position.row); assert_eq(3, start.pT1.position.row);
assert_eq(2, start.pT1.position.col); assert_eq(3, start.pT1.position.col);
assert_eq(2, start.pT1.end_position.row); assert_eq(3, start.pT1.end_position.row);
assert_eq(3, start.pT1.end_position.col); assert_eq(4, start.pT1.end_position.col);
assert_eq(3, start.pT2.pToken.position.row); assert_eq(4, start.pT2.pToken.position.row);
assert_eq(0, start.pT2.pToken.position.col); assert_eq(1, start.pT2.pToken.position.col);
assert_eq(4, start.pT2.pToken.end_position.row); assert_eq(5, start.pT2.pToken.end_position.row);
assert_eq(1, start.pT2.pToken.end_position.col); assert_eq(2, start.pT2.pToken.end_position.col);
assert_eq(3, start.pT2.position.row); assert_eq(4, start.pT2.position.row);
assert_eq(0, start.pT2.position.col); assert_eq(1, start.pT2.position.col);
assert_eq(4, start.pT2.end_position.row); assert_eq(5, start.pT2.end_position.row);
assert_eq(1, start.pT2.end_position.col); assert_eq(2, start.pT2.end_position.col);
assert_eq(6, start.pT3.pToken.position.row); assert_eq(7, start.pT3.pToken.position.row);
assert_eq(5, start.pT3.pToken.position.col); assert_eq(6, start.pT3.pToken.position.col);
assert_eq(6, start.pT3.pToken.end_position.row); assert_eq(7, start.pT3.pToken.end_position.row);
assert_eq(5, start.pT3.pToken.end_position.col); assert_eq(6, start.pT3.pToken.end_position.col);
assert_eq(6, start.pT3.position.row); assert_eq(7, start.pT3.position.row);
assert_eq(5, start.pT3.position.col); assert_eq(6, start.pT3.position.col);
assert_eq(6, start.pT3.end_position.row); assert_eq(7, start.pT3.end_position.row);
assert_eq(5, start.pT3.end_position.col); assert_eq(6, start.pT3.end_position.col);
assert_eq(2, start.position.row); assert_eq(3, start.position.row);
assert_eq(2, start.position.col); assert_eq(3, start.position.col);
assert_eq(6, start.end_position.row); assert_eq(7, start.end_position.row);
assert_eq(5, start.end_position.col); assert_eq(6, start.end_position.col);
} }

16
spec/test_error_positions.c
View File

@ -12,28 +12,28 @@ int main()
input = "a\n123\na a"; input = "a\n123\na a";
p_context_init(&context, (uint8_t const *)input, strlen(input)); p_context_init(&context, (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 == 2); assert(p_position(&context).row == 3);
assert(p_position(&context).col == 3); assert(p_position(&context).col == 4);
assert(p_token(&context) == TOKEN_a); assert(p_token(&context) == TOKEN_a);
input = "12"; input = "12";
p_context_init(&context, (uint8_t const *)input, strlen(input)); p_context_init(&context, (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 == 0); assert(p_position(&context).row == 1);
assert(p_position(&context).col == 0); assert(p_position(&context).col == 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, (uint8_t const *)input, strlen(input)); p_context_init(&context, (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 == 2); assert(p_position(&context).row == 3);
assert(p_position(&context).col == 1); assert(p_position(&context).col == 2);
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)); p_context_init(&context, (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 == 5); assert(p_position(&context).row == 6);
assert(p_position(&context).col == 4); 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);

8
spec/test_error_positions.d
View File

@ -16,24 +16,24 @@ unittest
input = "a\n123\na a"; input = "a\n123\na a";
p_context_init(&context, input); p_context_init(&context, input);
assert(p_parse(&context) == P_UNEXPECTED_TOKEN); assert(p_parse(&context) == P_UNEXPECTED_TOKEN);
assert(p_position(&context) == p_position_t(2, 3)); 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); p_context_init(&context, input);
assert(p_parse(&context) == P_UNEXPECTED_TOKEN); assert(p_parse(&context) == P_UNEXPECTED_TOKEN);
assert(p_position(&context) == p_position_t(0, 0)); 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); p_context_init(&context, input);
assert(p_parse(&context) == P_UNEXPECTED_INPUT); assert(p_parse(&context) == P_UNEXPECTED_INPUT);
assert(p_position(&context) == p_position_t(2, 1)); 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); p_context_init(&context, input);
assert(p_parse(&context) == P_DECODE_ERROR); assert(p_parse(&context) == P_DECODE_ERROR);
assert(p_position(&context) == p_position_t(5, 4)); 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");

72
spec/test_lexer.c
View File

@ -41,68 +41,68 @@ int main()
p_context_t context; p_context_t context;
p_context_init(&context, (uint8_t const *)input, strlen(input)); p_context_init(&context, (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 == 0u); assert(token_info.position.row == 1u);
assert(token_info.position.col == 0u); assert(token_info.position.col == 1u);
assert(token_info.end_position.row == 0u); assert(token_info.end_position.row == 1u);
assert(token_info.end_position.col == 0u); 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 == 0u); assert(token_info.position.row == 1u);
assert(token_info.position.col == 2u); assert(token_info.position.col == 3u);
assert(token_info.end_position.row == 0u); assert(token_info.end_position.row == 1u);
assert(token_info.end_position.col == 2u); 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 == 0u); assert(token_info.position.row == 1u);
assert(token_info.position.col == 4u); assert(token_info.position.col == 5u);
assert(token_info.end_position.row == 0u); assert(token_info.end_position.row == 1u);
assert(token_info.end_position.col == 4u); 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 == 0u); assert(token_info.position.row == 1u);
assert(token_info.position.col == 6u); assert(token_info.position.col == 7u);
assert(token_info.end_position.row == 0u); assert(token_info.end_position.row == 1u);
assert(token_info.end_position.col == 6u); 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 == 1u); assert(token_info.position.row == 2u);
assert(token_info.position.col == 0u); assert(token_info.position.col == 1u);
assert(token_info.end_position.row == 1u); assert(token_info.end_position.row == 2u);
assert(token_info.end_position.col == 2u); 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 == 1u); assert(token_info.position.row == 2u);
assert(token_info.position.col == 4u); assert(token_info.position.col == 5u);
assert(token_info.end_position.row == 1u); assert(token_info.end_position.row == 2u);
assert(token_info.end_position.col == 4u); 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 == 1u); assert(token_info.position.row == 2u);
assert(token_info.position.col == 6u); assert(token_info.position.col == 7u);
assert(token_info.end_position.row == 1u); assert(token_info.end_position.row == 2u);
assert(token_info.end_position.col == 8u); 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 == 1u); assert(token_info.position.row == 2u);
assert(token_info.position.col == 9u); assert(token_info.position.col == 10u);
assert(token_info.end_position.row == 1u); assert(token_info.end_position.row == 2u);
assert(token_info.end_position.col == 9u); 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_init(&context, (uint8_t const *)"", 0u); p_context_init(&context, (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 == 0u); assert(token_info.position.row == 1u);
assert(token_info.position.col == 0u); assert(token_info.position.col == 1u);
assert(token_info.end_position.row == 0u); assert(token_info.end_position.row == 1u);
assert(token_info.end_position.col == 0u); 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);

18
spec/test_lexer.d
View File

@ -47,23 +47,23 @@ unittest
p_context_t context; p_context_t context;
p_context_init(&context, input); p_context_init(&context, 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(0, 0), p_position_t(0, 0), 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(0, 2), p_position_t(0, 2), 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(0, 4), p_position_t(0, 4), 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(0, 6), p_position_t(0, 6), 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(1, 0), p_position_t(1, 2), 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(1, 4), p_position_t(1, 4), 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(1, 6), p_position_t(1, 8), 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(1, 9), p_position_t(1, 9), 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, ""); p_context_init(&context, "");
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(0, 0), p_position_t(0, 0), 0, TOKEN___EOF)); assert(token_info == p_token_info_t(p_position_t(1, 1), p_position_t(1, 1), 0, TOKEN___EOF));
} }

4
spec/test_parser_rule_from_multiple_states.c
View File

@ -8,8 +8,8 @@ int main()
p_context_t context; p_context_t context;
p_context_init(&context, (uint8_t const *)input, strlen(input)); p_context_init(&context, (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 == 0); assert(p_position(&context).row == 1);
assert(p_position(&context).col == 1); assert(p_position(&context).col == 2);
assert(context.token == TOKEN___EOF); assert(context.token == TOKEN___EOF);
input = "a b"; input = "a b";

2
spec/test_parser_rule_from_multiple_states.d
View File

@ -12,7 +12,7 @@ unittest
p_context_t context; p_context_t context;
p_context_init(&context, input); p_context_init(&context, input);
assert(p_parse(&context) == P_UNEXPECTED_TOKEN); assert(p_parse(&context) == P_UNEXPECTED_TOKEN);
assert(p_position(&context) == p_position_t(0, 1)); 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";