diff --git a/assets/parser.c.erb b/assets/parser.c.erb
index 7720c82..ed22631 100644
--- a/assets/parser.c.erb
+++ b/assets/parser.c.erb
@@ -60,6 +60,8 @@ void <%= @grammar.prefix %>context_init(<%= @grammar.prefix %>context_t * contex
     /* Lexer initialization. */
     newcontext.input = input;
     newcontext.input_length = input_length;
+    newcontext.text_position.row = 1u;
+    newcontext.text_position.col = 1u;
     newcontext.mode = <%= @lexer.mode_id("default") %>;
 
     /* 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')
                 {
                     attempt_match.delta_position.row++;
-                    attempt_match.delta_position.col = 0u;
+                    attempt_match.delta_position.col = 1u;
                 }
                 else
                 {
@@ -567,7 +569,7 @@ size_t <%= @grammar.prefix %>lex(<%= @grammar.prefix %>context_t * context, <%=
  *************************************************************************/
 
 /** Invalid position value. */
-#define INVALID_POSITION (<%= @grammar.prefix %>position_t){0xFFFFFFFFu, 0xFFFFFFFFu}
+#define INVALID_POSITION (<%= @grammar.prefix %>position_t){0u, 0u}
 
 /** Reduce ID type. */
 typedef <%= get_type_for(@parser.reduce_table.size) %> reduce_id_t;
diff --git a/assets/parser.d.erb b/assets/parser.d.erb
index 4dac5bd..f7abdbc 100644
--- a/assets/parser.d.erb
+++ b/assets/parser.d.erb
@@ -65,12 +65,12 @@ public struct <%= @grammar.prefix %>position_t
     uint col;
 
     /** 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. */
     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. */
     newcontext.input = input;
+    newcontext.text_position.row = 1u;
+    newcontext.text_position.col = 1u;
     newcontext.mode = <%= @lexer.mode_id("default") %>;
 
     /* 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')
                 {
                     attempt_match.delta_position.row++;
-                    attempt_match.delta_position.col = 0u;
+                    attempt_match.delta_position.col = 1u;
                 }
                 else
                 {
diff --git a/assets/parser.h.erb b/assets/parser.h.erb
index df08c8a..058371c 100644
--- a/assets/parser.h.erb
+++ b/assets/parser.h.erb
@@ -53,7 +53,7 @@ typedef struct
 } <%= @grammar.prefix %>position_t;
 
 /** 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. */
 <%= @grammar.code_blocks.fetch("header", "") %>
diff --git a/doc/user_guide.md b/doc/user_guide.md
index d0ef0ac..f5674d8 100644
--- a/doc/user_guide.md
+++ b/doc/user_guide.md
@@ -777,7 +777,7 @@ A pointer to this instance is passed to the generated functions.
 ### `p_position_t`
 
 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
 querying the `valid` property.
diff --git a/spec/test_ast_invalid_positions.c b/spec/test_ast_invalid_positions.c
index 513dc10..eaac60f 100644
--- a/spec/test_ast_invalid_positions.c
+++ b/spec/test_ast_invalid_positions.c
@@ -11,92 +11,92 @@ int main()
     assert(p_parse(&context) == P_SUCCESS);
     Start * start = p_result(&context);
 
-    assert_eq(1, start->pT1->pToken->position.row);
-    assert_eq(0, start->pT1->pToken->position.col);
-    assert_eq(1, start->pT1->pToken->end_position.row);
-    assert_eq(0, start->pT1->pToken->end_position.col);
+    assert_eq(2, start->pT1->pToken->position.row);
+    assert_eq(1, start->pT1->pToken->position.col);
+    assert_eq(2, start->pT1->pToken->end_position.row);
+    assert_eq(1, start->pT1->pToken->end_position.col);
     assert(p_position_valid(start->pT1->pA->position));
-    assert_eq(2, start->pT1->pA->position.row);
-    assert_eq(2, start->pT1->pA->position.col);
-    assert_eq(2, start->pT1->pA->end_position.row);
-    assert_eq(7, start->pT1->pA->end_position.col);
-    assert_eq(1, start->pT1->position.row);
-    assert_eq(0, start->pT1->position.col);
-    assert_eq(2, start->pT1->end_position.row);
-    assert_eq(7, start->pT1->end_position.col);
+    assert_eq(3, start->pT1->pA->position.row);
+    assert_eq(3, start->pT1->pA->position.col);
+    assert_eq(3, start->pT1->pA->end_position.row);
+    assert_eq(8, start->pT1->pA->end_position.col);
+    assert_eq(2, start->pT1->position.row);
+    assert_eq(1, start->pT1->position.col);
+    assert_eq(3, start->pT1->end_position.row);
+    assert_eq(8, start->pT1->end_position.col);
 
-    assert_eq(1, start->position.row);
-    assert_eq(0, start->position.col);
-    assert_eq(2, start->end_position.row);
-    assert_eq(7, start->end_position.col);
+    assert_eq(2, start->position.row);
+    assert_eq(1, start->position.col);
+    assert_eq(3, start->end_position.row);
+    assert_eq(8, start->end_position.col);
 
     input = "a\nbb";
     p_context_init(&context, (uint8_t const *)input, strlen(input));
     assert(p_parse(&context) == P_SUCCESS);
     start = p_result(&context);
 
-    assert_eq(0, start->pT1->pToken->position.row);
-    assert_eq(0, start->pT1->pToken->position.col);
-    assert_eq(0, start->pT1->pToken->end_position.row);
-    assert_eq(0, start->pT1->pToken->end_position.col);
+    assert_eq(1, start->pT1->pToken->position.row);
+    assert_eq(1, start->pT1->pToken->position.col);
+    assert_eq(1, start->pT1->pToken->end_position.row);
+    assert_eq(1, start->pT1->pToken->end_position.col);
     assert(p_position_valid(start->pT1->pA->position));
-    assert_eq(1, start->pT1->pA->position.row);
-    assert_eq(0, start->pT1->pA->position.col);
-    assert_eq(1, start->pT1->pA->end_position.row);
-    assert_eq(1, start->pT1->pA->end_position.col);
-    assert_eq(0, start->pT1->position.row);
-    assert_eq(0, start->pT1->position.col);
-    assert_eq(1, start->pT1->end_position.row);
-    assert_eq(1, start->pT1->end_position.col);
+    assert_eq(2, start->pT1->pA->position.row);
+    assert_eq(1, start->pT1->pA->position.col);
+    assert_eq(2, start->pT1->pA->end_position.row);
+    assert_eq(2, start->pT1->pA->end_position.col);
+    assert_eq(1, start->pT1->position.row);
+    assert_eq(1, start->pT1->position.col);
+    assert_eq(2, start->pT1->end_position.row);
+    assert_eq(2, start->pT1->end_position.col);
 
-    assert_eq(0, start->position.row);
-    assert_eq(0, start->position.col);
-    assert_eq(1, start->end_position.row);
-    assert_eq(1, start->end_position.col);
+    assert_eq(1, start->position.row);
+    assert_eq(1, start->position.col);
+    assert_eq(2, start->end_position.row);
+    assert_eq(2, start->end_position.col);
 
     input = "a\nc\nc";
     p_context_init(&context, (uint8_t const *)input, strlen(input));
     assert(p_parse(&context) == P_SUCCESS);
     start = p_result(&context);
 
-    assert_eq(0, start->pT1->pToken->position.row);
-    assert_eq(0, start->pT1->pToken->position.col);
-    assert_eq(0, start->pT1->pToken->end_position.row);
-    assert_eq(0, start->pT1->pToken->end_position.col);
+    assert_eq(1, start->pT1->pToken->position.row);
+    assert_eq(1, start->pT1->pToken->position.col);
+    assert_eq(1, start->pT1->pToken->end_position.row);
+    assert_eq(1, start->pT1->pToken->end_position.col);
     assert(p_position_valid(start->pT1->pA->position));
-    assert_eq(1, start->pT1->pA->position.row);
-    assert_eq(0, start->pT1->pA->position.col);
-    assert_eq(2, start->pT1->pA->end_position.row);
-    assert_eq(0, start->pT1->pA->end_position.col);
-    assert_eq(0, start->pT1->position.row);
-    assert_eq(0, start->pT1->position.col);
-    assert_eq(2, start->pT1->end_position.row);
-    assert_eq(0, start->pT1->end_position.col);
+    assert_eq(2, start->pT1->pA->position.row);
+    assert_eq(1, start->pT1->pA->position.col);
+    assert_eq(3, start->pT1->pA->end_position.row);
+    assert_eq(1, start->pT1->pA->end_position.col);
+    assert_eq(1, start->pT1->position.row);
+    assert_eq(1, start->pT1->position.col);
+    assert_eq(3, start->pT1->end_position.row);
+    assert_eq(1, start->pT1->end_position.col);
 
-    assert_eq(0, start->position.row);
-    assert_eq(0, start->position.col);
-    assert_eq(2, start->end_position.row);
-    assert_eq(0, start->end_position.col);
+    assert_eq(1, start->position.row);
+    assert_eq(1, start->position.col);
+    assert_eq(3, start->end_position.row);
+    assert_eq(1, start->end_position.col);
 
     input = "a";
     p_context_init(&context, (uint8_t const *)input, strlen(input));
     assert(p_parse(&context) == P_SUCCESS);
     start = p_result(&context);
 
-    assert_eq(0, start->pT1->pToken->position.row);
-    assert_eq(0, start->pT1->pToken->position.col);
-    assert_eq(0, start->pT1->pToken->end_position.row);
-    assert_eq(0, start->pT1->pToken->end_position.col);
+    assert_eq(1, start->pT1->pToken->position.row);
+    assert_eq(1, start->pT1->pToken->position.col);
+    assert_eq(1, start->pT1->pToken->end_position.row);
+    assert_eq(1, start->pT1->pToken->end_position.col);
     assert(!p_position_valid(start->pT1->pA->position));
-    assert_eq(0, start->pT1->position.row);
-    assert_eq(0, start->pT1->position.col);
-    assert_eq(0, start->pT1->end_position.row);
-    assert_eq(0, start->pT1->end_position.col);
+    assert_eq(1, start->pT1->position.row);
+    assert_eq(1, start->pT1->position.col);
+    assert_eq(1, start->pT1->end_position.row);
+    assert_eq(1, start->pT1->end_position.col);
 
-    assert_eq(0, start->position.row);
-    assert_eq(0, start->position.col);
-    assert_eq(0, start->end_position.row);
-    assert_eq(0, start->end_position.col);
+    assert_eq(1, start->position.row);
+    assert_eq(1, start->position.col);
+    assert_eq(1, start->end_position.row);
+    assert_eq(1, start->end_position.col);
 
     return 0;
 }
diff --git a/spec/test_ast_invalid_positions.d b/spec/test_ast_invalid_positions.d
index 0737454..19fc744 100644
--- a/spec/test_ast_invalid_positions.d
+++ b/spec/test_ast_invalid_positions.d
@@ -15,90 +15,90 @@ unittest
     assert(p_parse(&context) == P_SUCCESS);
     Start * start = p_result(&context);
 
-    assert_eq(1, start.pT1.pToken.position.row);
-    assert_eq(0, start.pT1.pToken.position.col);
-    assert_eq(1, start.pT1.pToken.end_position.row);
-    assert_eq(0, start.pT1.pToken.end_position.col);
+    assert_eq(2, start.pT1.pToken.position.row);
+    assert_eq(1, start.pT1.pToken.position.col);
+    assert_eq(2, start.pT1.pToken.end_position.row);
+    assert_eq(1, start.pT1.pToken.end_position.col);
     assert(start.pT1.pA.position.valid);
-    assert_eq(2, start.pT1.pA.position.row);
-    assert_eq(2, start.pT1.pA.position.col);
-    assert_eq(2, start.pT1.pA.end_position.row);
-    assert_eq(7, start.pT1.pA.end_position.col);
-    assert_eq(1, start.pT1.position.row);
-    assert_eq(0, start.pT1.position.col);
-    assert_eq(2, start.pT1.end_position.row);
-    assert_eq(7, start.pT1.end_position.col);
+    assert_eq(3, start.pT1.pA.position.row);
+    assert_eq(3, start.pT1.pA.position.col);
+    assert_eq(3, start.pT1.pA.end_position.row);
+    assert_eq(8, start.pT1.pA.end_position.col);
+    assert_eq(2, start.pT1.position.row);
+    assert_eq(1, start.pT1.position.col);
+    assert_eq(3, start.pT1.end_position.row);
+    assert_eq(8, start.pT1.end_position.col);
 
-    assert_eq(1, start.position.row);
-    assert_eq(0, start.position.col);
-    assert_eq(2, start.end_position.row);
-    assert_eq(7, start.end_position.col);
+    assert_eq(2, start.position.row);
+    assert_eq(1, start.position.col);
+    assert_eq(3, start.end_position.row);
+    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);
 
-    assert_eq(0, start.pT1.pToken.position.row);
-    assert_eq(0, start.pT1.pToken.position.col);
-    assert_eq(0, start.pT1.pToken.end_position.row);
-    assert_eq(0, start.pT1.pToken.end_position.col);
+    assert_eq(1, start.pT1.pToken.position.row);
+    assert_eq(1, start.pT1.pToken.position.col);
+    assert_eq(1, start.pT1.pToken.end_position.row);
+    assert_eq(1, start.pT1.pToken.end_position.col);
     assert(start.pT1.pA.position.valid);
-    assert_eq(1, start.pT1.pA.position.row);
-    assert_eq(0, start.pT1.pA.position.col);
-    assert_eq(1, start.pT1.pA.end_position.row);
-    assert_eq(1, start.pT1.pA.end_position.col);
-    assert_eq(0, start.pT1.position.row);
-    assert_eq(0, start.pT1.position.col);
-    assert_eq(1, start.pT1.end_position.row);
-    assert_eq(1, start.pT1.end_position.col);
+    assert_eq(2, start.pT1.pA.position.row);
+    assert_eq(1, start.pT1.pA.position.col);
+    assert_eq(2, start.pT1.pA.end_position.row);
+    assert_eq(2, start.pT1.pA.end_position.col);
+    assert_eq(1, start.pT1.position.row);
+    assert_eq(1, start.pT1.position.col);
+    assert_eq(2, start.pT1.end_position.row);
+    assert_eq(2, start.pT1.end_position.col);
 
-    assert_eq(0, start.position.row);
-    assert_eq(0, start.position.col);
-    assert_eq(1, start.end_position.row);
-    assert_eq(1, start.end_position.col);
+    assert_eq(1, start.position.row);
+    assert_eq(1, start.position.col);
+    assert_eq(2, start.end_position.row);
+    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);
 
-    assert_eq(0, start.pT1.pToken.position.row);
-    assert_eq(0, start.pT1.pToken.position.col);
-    assert_eq(0, start.pT1.pToken.end_position.row);
-    assert_eq(0, start.pT1.pToken.end_position.col);
+    assert_eq(1, start.pT1.pToken.position.row);
+    assert_eq(1, start.pT1.pToken.position.col);
+    assert_eq(1, start.pT1.pToken.end_position.row);
+    assert_eq(1, start.pT1.pToken.end_position.col);
     assert(start.pT1.pA.position.valid);
-    assert_eq(1, start.pT1.pA.position.row);
-    assert_eq(0, start.pT1.pA.position.col);
-    assert_eq(2, start.pT1.pA.end_position.row);
-    assert_eq(0, start.pT1.pA.end_position.col);
-    assert_eq(0, start.pT1.position.row);
-    assert_eq(0, start.pT1.position.col);
-    assert_eq(2, start.pT1.end_position.row);
-    assert_eq(0, start.pT1.end_position.col);
+    assert_eq(2, start.pT1.pA.position.row);
+    assert_eq(1, start.pT1.pA.position.col);
+    assert_eq(3, start.pT1.pA.end_position.row);
+    assert_eq(1, start.pT1.pA.end_position.col);
+    assert_eq(1, start.pT1.position.row);
+    assert_eq(1, start.pT1.position.col);
+    assert_eq(3, start.pT1.end_position.row);
+    assert_eq(1, start.pT1.end_position.col);
 
-    assert_eq(0, start.position.row);
-    assert_eq(0, start.position.col);
-    assert_eq(2, start.end_position.row);
-    assert_eq(0, start.end_position.col);
+    assert_eq(1, start.position.row);
+    assert_eq(1, start.position.col);
+    assert_eq(3, start.end_position.row);
+    assert_eq(1, start.end_position.col);
 
     input = "a";
     p_context_init(&context, input);
     assert(p_parse(&context) == P_SUCCESS);
     start = p_result(&context);
 
-    assert_eq(0, start.pT1.pToken.position.row);
-    assert_eq(0, start.pT1.pToken.position.col);
-    assert_eq(0, start.pT1.pToken.end_position.row);
-    assert_eq(0, start.pT1.pToken.end_position.col);
+    assert_eq(1, start.pT1.pToken.position.row);
+    assert_eq(1, start.pT1.pToken.position.col);
+    assert_eq(1, start.pT1.pToken.end_position.row);
+    assert_eq(1, start.pT1.pToken.end_position.col);
     assert(!start.pT1.pA.position.valid);
-    assert_eq(0, start.pT1.position.row);
-    assert_eq(0, start.pT1.position.col);
-    assert_eq(0, start.pT1.end_position.row);
-    assert_eq(0, start.pT1.end_position.col);
+    assert_eq(1, start.pT1.position.row);
+    assert_eq(1, start.pT1.position.col);
+    assert_eq(1, start.pT1.end_position.row);
+    assert_eq(1, start.pT1.end_position.col);
 
-    assert_eq(0, start.position.row);
-    assert_eq(0, start.position.col);
-    assert_eq(0, start.end_position.row);
-    assert_eq(0, start.end_position.col);
+    assert_eq(1, start.position.row);
+    assert_eq(1, start.position.col);
+    assert_eq(1, start.end_position.row);
+    assert_eq(1, start.end_position.col);
 }
diff --git a/spec/test_ast_token_positions.c b/spec/test_ast_token_positions.c
index ff4ea79..91c0437 100644
--- a/spec/test_ast_token_positions.c
+++ b/spec/test_ast_token_positions.c
@@ -11,74 +11,74 @@ int main()
     assert(p_parse(&context) == P_SUCCESS);
     Start * start = p_result(&context);
 
-    assert_eq(0, start->pT1->pToken->position.row);
-    assert_eq(0, start->pT1->pToken->position.col);
-    assert_eq(0, start->pT1->pToken->end_position.row);
-    assert_eq(0, start->pT1->pToken->end_position.col);
-    assert_eq(0, start->pT1->position.row);
-    assert_eq(0, start->pT1->position.col);
-    assert_eq(0, start->pT1->end_position.row);
-    assert_eq(0, start->pT1->end_position.col);
+    assert_eq(1, start->pT1->pToken->position.row);
+    assert_eq(1, start->pT1->pToken->position.col);
+    assert_eq(1, start->pT1->pToken->end_position.row);
+    assert_eq(1, start->pT1->pToken->end_position.col);
+    assert_eq(1, start->pT1->position.row);
+    assert_eq(1, start->pT1->position.col);
+    assert_eq(1, start->pT1->end_position.row);
+    assert_eq(1, start->pT1->end_position.col);
 
-    assert_eq(0, start->pT2->pToken->position.row);
-    assert_eq(1, start->pT2->pToken->position.col);
-    assert_eq(0, start->pT2->pToken->end_position.row);
-    assert_eq(2, start->pT2->pToken->end_position.col);
-    assert_eq(0, start->pT2->position.row);
-    assert_eq(1, start->pT2->position.col);
-    assert_eq(0, start->pT2->end_position.row);
-    assert_eq(2, start->pT2->end_position.col);
+    assert_eq(1, start->pT2->pToken->position.row);
+    assert_eq(2, start->pT2->pToken->position.col);
+    assert_eq(1, start->pT2->pToken->end_position.row);
+    assert_eq(3, start->pT2->pToken->end_position.col);
+    assert_eq(1, start->pT2->position.row);
+    assert_eq(2, start->pT2->position.col);
+    assert_eq(1, start->pT2->end_position.row);
+    assert_eq(3, start->pT2->end_position.col);
 
-    assert_eq(0, start->pT3->pToken->position.row);
-    assert_eq(3, start->pT3->pToken->position.col);
-    assert_eq(0, start->pT3->pToken->end_position.row);
-    assert_eq(5, start->pT3->pToken->end_position.col);
-    assert_eq(0, start->pT3->position.row);
-    assert_eq(3, start->pT3->position.col);
-    assert_eq(0, start->pT3->end_position.row);
-    assert_eq(5, start->pT3->end_position.col);
+    assert_eq(1, start->pT3->pToken->position.row);
+    assert_eq(4, start->pT3->pToken->position.col);
+    assert_eq(1, start->pT3->pToken->end_position.row);
+    assert_eq(6, start->pT3->pToken->end_position.col);
+    assert_eq(1, start->pT3->position.row);
+    assert_eq(4, start->pT3->position.col);
+    assert_eq(1, start->pT3->end_position.row);
+    assert_eq(6, start->pT3->end_position.col);
 
-    assert_eq(0, start->position.row);
-    assert_eq(0, start->position.col);
-    assert_eq(0, start->end_position.row);
-    assert_eq(5, start->end_position.col);
+    assert_eq(1, start->position.row);
+    assert_eq(1, start->position.col);
+    assert_eq(1, start->end_position.row);
+    assert_eq(6, start->end_position.col);
 
     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);
 
-    assert_eq(2, start->pT1->pToken->position.row);
-    assert_eq(2, start->pT1->pToken->position.col);
-    assert_eq(2, start->pT1->pToken->end_position.row);
-    assert_eq(3, start->pT1->pToken->end_position.col);
-    assert_eq(2, start->pT1->position.row);
-    assert_eq(2, start->pT1->position.col);
-    assert_eq(2, start->pT1->end_position.row);
-    assert_eq(3, start->pT1->end_position.col);
+    assert_eq(3, start->pT1->pToken->position.row);
+    assert_eq(3, start->pT1->pToken->position.col);
+    assert_eq(3, start->pT1->pToken->end_position.row);
+    assert_eq(4, start->pT1->pToken->end_position.col);
+    assert_eq(3, start->pT1->position.row);
+    assert_eq(3, start->pT1->position.col);
+    assert_eq(3, start->pT1->end_position.row);
+    assert_eq(4, start->pT1->end_position.col);
 
-    assert_eq(3, start->pT2->pToken->position.row);
-    assert_eq(0, start->pT2->pToken->position.col);
-    assert_eq(4, start->pT2->pToken->end_position.row);
-    assert_eq(1, start->pT2->pToken->end_position.col);
-    assert_eq(3, start->pT2->position.row);
-    assert_eq(0, start->pT2->position.col);
-    assert_eq(4, start->pT2->end_position.row);
-    assert_eq(1, start->pT2->end_position.col);
+    assert_eq(4, start->pT2->pToken->position.row);
+    assert_eq(1, start->pT2->pToken->position.col);
+    assert_eq(5, start->pT2->pToken->end_position.row);
+    assert_eq(2, start->pT2->pToken->end_position.col);
+    assert_eq(4, start->pT2->position.row);
+    assert_eq(1, start->pT2->position.col);
+    assert_eq(5, start->pT2->end_position.row);
+    assert_eq(2, start->pT2->end_position.col);
 
-    assert_eq(6, start->pT3->pToken->position.row);
-    assert_eq(5, start->pT3->pToken->position.col);
-    assert_eq(6, start->pT3->pToken->end_position.row);
-    assert_eq(5, start->pT3->pToken->end_position.col);
-    assert_eq(6, start->pT3->position.row);
-    assert_eq(5, start->pT3->position.col);
-    assert_eq(6, start->pT3->end_position.row);
-    assert_eq(5, start->pT3->end_position.col);
+    assert_eq(7, start->pT3->pToken->position.row);
+    assert_eq(6, start->pT3->pToken->position.col);
+    assert_eq(7, start->pT3->pToken->end_position.row);
+    assert_eq(6, start->pT3->pToken->end_position.col);
+    assert_eq(7, start->pT3->position.row);
+    assert_eq(6, start->pT3->position.col);
+    assert_eq(7, start->pT3->end_position.row);
+    assert_eq(6, start->pT3->end_position.col);
 
-    assert_eq(2, start->position.row);
-    assert_eq(2, start->position.col);
-    assert_eq(6, start->end_position.row);
-    assert_eq(5, start->end_position.col);
+    assert_eq(3, start->position.row);
+    assert_eq(3, start->position.col);
+    assert_eq(7, start->end_position.row);
+    assert_eq(6, start->end_position.col);
 
     return 0;
 }
diff --git a/spec/test_ast_token_positions.d b/spec/test_ast_token_positions.d
index 58fe83e..e5930d7 100644
--- a/spec/test_ast_token_positions.d
+++ b/spec/test_ast_token_positions.d
@@ -15,72 +15,72 @@ unittest
     assert(p_parse(&context) == P_SUCCESS);
     Start * start = p_result(&context);
 
-    assert_eq(0, start.pT1.pToken.position.row);
-    assert_eq(0, start.pT1.pToken.position.col);
-    assert_eq(0, start.pT1.pToken.end_position.row);
-    assert_eq(0, start.pT1.pToken.end_position.col);
-    assert_eq(0, start.pT1.position.row);
-    assert_eq(0, start.pT1.position.col);
-    assert_eq(0, start.pT1.end_position.row);
-    assert_eq(0, start.pT1.end_position.col);
+    assert_eq(1, start.pT1.pToken.position.row);
+    assert_eq(1, start.pT1.pToken.position.col);
+    assert_eq(1, start.pT1.pToken.end_position.row);
+    assert_eq(1, start.pT1.pToken.end_position.col);
+    assert_eq(1, start.pT1.position.row);
+    assert_eq(1, start.pT1.position.col);
+    assert_eq(1, start.pT1.end_position.row);
+    assert_eq(1, start.pT1.end_position.col);
 
-    assert_eq(0, start.pT2.pToken.position.row);
-    assert_eq(1, start.pT2.pToken.position.col);
-    assert_eq(0, start.pT2.pToken.end_position.row);
-    assert_eq(2, start.pT2.pToken.end_position.col);
-    assert_eq(0, start.pT2.position.row);
-    assert_eq(1, start.pT2.position.col);
-    assert_eq(0, start.pT2.end_position.row);
-    assert_eq(2, start.pT2.end_position.col);
+    assert_eq(1, start.pT2.pToken.position.row);
+    assert_eq(2, start.pT2.pToken.position.col);
+    assert_eq(1, start.pT2.pToken.end_position.row);
+    assert_eq(3, start.pT2.pToken.end_position.col);
+    assert_eq(1, start.pT2.position.row);
+    assert_eq(2, start.pT2.position.col);
+    assert_eq(1, start.pT2.end_position.row);
+    assert_eq(3, start.pT2.end_position.col);
 
-    assert_eq(0, start.pT3.pToken.position.row);
-    assert_eq(3, start.pT3.pToken.position.col);
-    assert_eq(0, start.pT3.pToken.end_position.row);
-    assert_eq(5, start.pT3.pToken.end_position.col);
-    assert_eq(0, start.pT3.position.row);
-    assert_eq(3, start.pT3.position.col);
-    assert_eq(0, start.pT3.end_position.row);
-    assert_eq(5, start.pT3.end_position.col);
+    assert_eq(1, start.pT3.pToken.position.row);
+    assert_eq(4, start.pT3.pToken.position.col);
+    assert_eq(1, start.pT3.pToken.end_position.row);
+    assert_eq(6, start.pT3.pToken.end_position.col);
+    assert_eq(1, start.pT3.position.row);
+    assert_eq(4, start.pT3.position.col);
+    assert_eq(1, start.pT3.end_position.row);
+    assert_eq(6, start.pT3.end_position.col);
 
-    assert_eq(0, start.position.row);
-    assert_eq(0, start.position.col);
-    assert_eq(0, start.end_position.row);
-    assert_eq(5, start.end_position.col);
+    assert_eq(1, start.position.row);
+    assert_eq(1, start.position.col);
+    assert_eq(1, start.end_position.row);
+    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);
 
-    assert_eq(2, start.pT1.pToken.position.row);
-    assert_eq(2, start.pT1.pToken.position.col);
-    assert_eq(2, start.pT1.pToken.end_position.row);
-    assert_eq(3, start.pT1.pToken.end_position.col);
-    assert_eq(2, start.pT1.position.row);
-    assert_eq(2, start.pT1.position.col);
-    assert_eq(2, start.pT1.end_position.row);
-    assert_eq(3, start.pT1.end_position.col);
+    assert_eq(3, start.pT1.pToken.position.row);
+    assert_eq(3, start.pT1.pToken.position.col);
+    assert_eq(3, start.pT1.pToken.end_position.row);
+    assert_eq(4, start.pT1.pToken.end_position.col);
+    assert_eq(3, start.pT1.position.row);
+    assert_eq(3, start.pT1.position.col);
+    assert_eq(3, start.pT1.end_position.row);
+    assert_eq(4, start.pT1.end_position.col);
 
-    assert_eq(3, start.pT2.pToken.position.row);
-    assert_eq(0, start.pT2.pToken.position.col);
-    assert_eq(4, start.pT2.pToken.end_position.row);
-    assert_eq(1, start.pT2.pToken.end_position.col);
-    assert_eq(3, start.pT2.position.row);
-    assert_eq(0, start.pT2.position.col);
-    assert_eq(4, start.pT2.end_position.row);
-    assert_eq(1, start.pT2.end_position.col);
+    assert_eq(4, start.pT2.pToken.position.row);
+    assert_eq(1, start.pT2.pToken.position.col);
+    assert_eq(5, start.pT2.pToken.end_position.row);
+    assert_eq(2, start.pT2.pToken.end_position.col);
+    assert_eq(4, start.pT2.position.row);
+    assert_eq(1, start.pT2.position.col);
+    assert_eq(5, start.pT2.end_position.row);
+    assert_eq(2, start.pT2.end_position.col);
 
-    assert_eq(6, start.pT3.pToken.position.row);
-    assert_eq(5, start.pT3.pToken.position.col);
-    assert_eq(6, start.pT3.pToken.end_position.row);
-    assert_eq(5, start.pT3.pToken.end_position.col);
-    assert_eq(6, start.pT3.position.row);
-    assert_eq(5, start.pT3.position.col);
-    assert_eq(6, start.pT3.end_position.row);
-    assert_eq(5, start.pT3.end_position.col);
+    assert_eq(7, start.pT3.pToken.position.row);
+    assert_eq(6, start.pT3.pToken.position.col);
+    assert_eq(7, start.pT3.pToken.end_position.row);
+    assert_eq(6, start.pT3.pToken.end_position.col);
+    assert_eq(7, start.pT3.position.row);
+    assert_eq(6, start.pT3.position.col);
+    assert_eq(7, start.pT3.end_position.row);
+    assert_eq(6, start.pT3.end_position.col);
 
-    assert_eq(2, start.position.row);
-    assert_eq(2, start.position.col);
-    assert_eq(6, start.end_position.row);
-    assert_eq(5, start.end_position.col);
+    assert_eq(3, start.position.row);
+    assert_eq(3, start.position.col);
+    assert_eq(7, start.end_position.row);
+    assert_eq(6, start.end_position.col);
 }
diff --git a/spec/test_error_positions.c b/spec/test_error_positions.c
index 6c457f1..7986f83 100644
--- a/spec/test_error_positions.c
+++ b/spec/test_error_positions.c
@@ -12,28 +12,28 @@ int main()
     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 == 2);
-    assert(p_position(&context).col == 3);
+    assert(p_position(&context).row == 3);
+    assert(p_position(&context).col == 4);
     assert(p_token(&context) == TOKEN_a);
 
     input = "12";
     p_context_init(&context, (uint8_t const *)input, strlen(input));
     assert(p_parse(&context) == P_UNEXPECTED_TOKEN);
-    assert(p_position(&context).row == 0);
-    assert(p_position(&context).col == 0);
+    assert(p_position(&context).row == 1);
+    assert(p_position(&context).col == 1);
     assert(p_token(&context) == TOKEN_num);
 
     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 == 2);
-    assert(p_position(&context).col == 1);
+    assert(p_position(&context).row == 3);
+    assert(p_position(&context).col == 2);
 
     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 == 5);
-    assert(p_position(&context).col == 4);
+    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);
diff --git a/spec/test_error_positions.d b/spec/test_error_positions.d
index 5ebf7d4..8d20987 100644
--- a/spec/test_error_positions.d
+++ b/spec/test_error_positions.d
@@ -16,24 +16,24 @@ unittest
     input = "a\n123\na  a";
     p_context_init(&context, input);
     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);
 
     input = "12";
     p_context_init(&context, input);
     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);
 
     input = "a 12\n\nab";
     p_context_init(&context, 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";
     p_context_init(&context, input);
     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_num] == "num");
diff --git a/spec/test_lexer.c b/spec/test_lexer.c
index 6ac68b3..ad8d1af 100644
--- a/spec/test_lexer.c
+++ b/spec/test_lexer.c
@@ -41,68 +41,68 @@ int main()
     p_context_t context;
     p_context_init(&context, (uint8_t const *)input, strlen(input));
     assert(p_lex(&context, &token_info) == P_SUCCESS);
-    assert(token_info.position.row == 0u);
-    assert(token_info.position.col == 0u);
-    assert(token_info.end_position.row == 0u);
-    assert(token_info.end_position.col == 0u);
+    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(token_info.position.row == 0u);
-    assert(token_info.position.col == 2u);
-    assert(token_info.end_position.row == 0u);
-    assert(token_info.end_position.col == 2u);
+    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(token_info.position.row == 0u);
-    assert(token_info.position.col == 4u);
-    assert(token_info.end_position.row == 0u);
-    assert(token_info.end_position.col == 4u);
+    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(token_info.position.row == 0u);
-    assert(token_info.position.col == 6u);
-    assert(token_info.end_position.row == 0u);
-    assert(token_info.end_position.col == 6u);
+    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(token_info.position.row == 1u);
-    assert(token_info.position.col == 0u);
-    assert(token_info.end_position.row == 1u);
-    assert(token_info.end_position.col == 2u);
+    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(token_info.position.row == 1u);
-    assert(token_info.position.col == 4u);
-    assert(token_info.end_position.row == 1u);
-    assert(token_info.end_position.col == 4u);
+    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(token_info.position.row == 1u);
-    assert(token_info.position.col == 6u);
-    assert(token_info.end_position.row == 1u);
-    assert(token_info.end_position.col == 8u);
+    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(token_info.position.row == 1u);
-    assert(token_info.position.col == 9u);
-    assert(token_info.end_position.row == 1u);
-    assert(token_info.end_position.col == 9u);
+    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_init(&context, (uint8_t const *)"", 0u);
     assert(p_lex(&context, &token_info) == P_SUCCESS);
-    assert(token_info.position.row == 0u);
-    assert(token_info.position.col == 0u);
-    assert(token_info.end_position.row == 0u);
-    assert(token_info.end_position.col == 0u);
+    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);
 
diff --git a/spec/test_lexer.d b/spec/test_lexer.d
index 9679c3b..a3c2a1c 100644
--- a/spec/test_lexer.d
+++ b/spec/test_lexer.d
@@ -47,23 +47,23 @@ unittest
     p_context_t context;
     p_context_init(&context, input);
     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(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(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(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(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(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(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(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, "");
     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));
 }
diff --git a/spec/test_parser_rule_from_multiple_states.c b/spec/test_parser_rule_from_multiple_states.c
index 3acf0ce..7af1c7f 100644
--- a/spec/test_parser_rule_from_multiple_states.c
+++ b/spec/test_parser_rule_from_multiple_states.c
@@ -8,8 +8,8 @@ int main()
     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 == 0);
-    assert(p_position(&context).col == 1);
+    assert(p_position(&context).row == 1);
+    assert(p_position(&context).col == 2);
     assert(context.token == TOKEN___EOF);
 
     input = "a b";
diff --git a/spec/test_parser_rule_from_multiple_states.d b/spec/test_parser_rule_from_multiple_states.d
index a69b1fe..f37f27f 100644
--- a/spec/test_parser_rule_from_multiple_states.d
+++ b/spec/test_parser_rule_from_multiple_states.d
@@ -12,7 +12,7 @@ unittest
     p_context_t context;
     p_context_init(&context, input);
     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);
 
     input = "a b";