wip

CHANGELOG.md

@@ -1,21 +1,3 @@
-## v3.0.0
-
-### New Features
-
-- Add support for multiple starting rules (#38)
-- Add `p_free_tree()` functions to reclaim generated tree memory
-- Add `free_token_node` grammar statement to reclaim user-allocated memory stored in a Token tree node `pvalue` field
-- Add valgrind memory leak tests to unit tests
-- Fix build issues for C++ to officially support C++ target output
-
-### Improvements
-
-- Document `p_lex()` and `p_token_info_t` in user guide (#37)
-
-### Breaking changes
-
-- Rename AST generation mode to tree generation mode (see [UPGRADING.md]())
-
 ## v2.3.0
 
 ### New Features

Gemfile.lock

@@ -10,7 +10,7 @@ GEM
       date
       stringio
     rake (13.3.1)
-    rdoc (7.2.0)
+    rdoc (7.1.0)
       erb
       psych (>= 4.0.0)
       tsort
@@ -27,7 +27,7 @@ GEM
     rspec-mocks (3.13.7)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.13.0)
-    rspec-support (3.13.7)
+    rspec-support (3.13.6)
     simplecov (0.22.0)
       docile (~> 1.1)
       simplecov-html (~> 0.11)

README.md

@@ -7,9 +7,7 @@ Propane is a LALR Parser Generator (LPG) which:
   * supports UTF-8 lexer inputs
   * generates a table-driven shift/reduce parser to parse input in linear time
   * targets C, C++, or D language outputs
-  * optionally supports automatic full parse tree generation
-  * supports starting parsing from multiple start rules
-  * tracks input text start and end positions for all matched tokens/rules
+  * optionally supports automatic full AST generation
   * is MIT-licensed
   * is distributable as a standalone Ruby script
 

UPGRADING.md

@@ -1,7 +0,0 @@
-## v3.0.0
-
-### Grammar changes
-
-- Rename `ast;` statement to `tree;`.
-- Rename `ast_prefix;` statement to `tree_prefix;`.
-- Rename `ast_suffix;` statement to `tree_suffix;`.

assets/parser.c.erb

@@ -638,7 +638,7 @@ typedef struct
      * reduce action.
      */
     parser_state_id_t n_states;
-<% if @grammar.tree %>
+<% if @grammar.ast %>
 
     /**
      * Map of rule components to rule set child fields.
@@ -646,7 +646,7 @@ typedef struct
     uint16_t const * rule_set_node_field_index_map;
 
     /**
-     * Number of rule set tree node fields.
+     * Number of rule set AST node fields.
      */
     uint16_t rule_set_node_field_array_size;
 
@@ -688,21 +688,21 @@ typedef struct
     /** Parser value from this state. */
     <%= @grammar.prefix %>value_t pvalue;
 
-<% if @grammar.tree %>
-    /** tree node. */
-    void * tree_node;
+<% if @grammar.ast %>
+    /** AST node. */
+    void * ast_node;
 <% end %>
 } state_value_t;
 
-/** Common tree node structure. */
-typedef struct TreeNode_s
+/** Common AST node structure. */
+typedef struct ASTNode_s
 {
     <%= @grammar.prefix %>position_t position;
     <%= @grammar.prefix %>position_t end_position;
     uint16_t n_fields;
     uint8_t is_token;
-    struct TreeNode_s * fields[];
-} TreeNode;
+    struct ASTNode_s * fields[];
+} ASTNode;
 
 /** Parser shift table. */
 static const shift_t parser_shift_table[] = {
@@ -711,7 +711,7 @@ static const shift_t parser_shift_table[] = {
 <%   end %>
 };
 
-<% if @grammar.tree %>
+<% if @grammar.ast %>
 <%   @grammar.rules.each do |rule| %>
 <%     unless rule.flat_rule_set_node_field_index_map? %>
 const uint16_t r_<%= rule.name.gsub("$", "_") %><%= rule.id %>_node_field_index_map[<%= rule.rule_set_node_field_index_map.size %>] = {<%= rule.rule_set_node_field_index_map.map {|v| v.to_s}.join(", ") %>};
@@ -726,14 +726,14 @@ static const reduce_t parser_reduce_table[] = {
         <%= reduce[:token_id] %>u, /* Token: <%= reduce[:token] ? reduce[:token].name : "(any)" %> */
         <%= reduce[:rule_id] %>u, /* Rule ID */
         <%= reduce[:rule_set_id] %>u, /* Rule set ID (<%= reduce[:rule].rule_set.name %>) */
-<%     if @grammar.tree %>
+<%     if @grammar.ast %>
         <%= reduce[:n_states] %>u, /* Number of states */
 <%       if reduce[:rule].flat_rule_set_node_field_index_map? %>
         NULL, /* No rule set node field index map (flat map) */
 <%       else %>
         &r_<%= reduce[:rule].name.gsub("$", "_") %><%= reduce[:rule].id %>_node_field_index_map[0], /* Rule set node field index map */
 <%       end %>
-        <%= reduce[:rule].rule_set.tree_fields.size %>, /* Number of tree fields */
+        <%= reduce[:rule].rule_set.ast_fields.size %>, /* Number of AST fields */
         <%= reduce[:propagate_optional_target] %>}, /* Propagate optional target? */
 <%     else %>
         <%= reduce[:n_states] %>u},
@@ -841,7 +841,7 @@ static void state_values_stack_free(state_values_stack_t * stack)
      free(stack->entries);
 }
 
-<% unless @grammar.tree %>
+<% unless @grammar.ast %>
 /**
  * Execute user code associated with a parser rule.
  *
@@ -924,8 +924,6 @@ static size_t check_reduce(size_t state_id, <%= @grammar.prefix %>token_t token)
  *
  * @param context
  *   Lexer/parser context structure.
- * @start_state_id
- *   ID of the state in which to start.
  *
  * @retval P_SUCCESS
  *   The parser successfully matched the input text. The parse result value
@@ -938,20 +936,19 @@ static size_t check_reduce(size_t state_id, <%= @grammar.prefix %>token_t token)
  * @reval P_UNEXPECTED_INPUT
  *   Input text does not match any lexer pattern.
  */
-static size_t parse_from(<%= @grammar.prefix %>context_t * context, size_t start_state_id)
+size_t <%= @grammar.prefix %>parse(<%= @grammar.prefix %>context_t * context)
 {
     <%= @grammar.prefix %>token_info_t token_info;
     <%= @grammar.prefix %>token_t token = INVALID_TOKEN_ID;
     state_values_stack_t statevalues;
     size_t reduced_rule_set = INVALID_ID;
-<% if @grammar.tree %>
+<% if @grammar.ast %>
     void * reduced_parser_node;
 <% else %>
     <%= @grammar.prefix %>value_t reduced_parser_value;
 <% end %>
     state_values_stack_init(&statevalues);
     state_values_stack_push(&statevalues);
-    state_values_stack_index(&statevalues, -1)->state_id = start_state_id;
     size_t result;
     for (;;)
     {
@@ -976,8 +973,8 @@ static size_t parse_from(<%= @grammar.prefix %>context_t * context, size_t start
             if ((shift_state != INVALID_ID) && (token == TOKEN___EOF))
             {
                 /* Successful parse. */
-<% if @grammar.tree %>
-                context->parse_result = state_values_stack_index(&statevalues, -1)->tree_node;
+<% if @grammar.ast %>
+                context->parse_result = state_values_stack_index(&statevalues, -1)->ast_node;
 <% else %>
                 context->parse_result = state_values_stack_index(&statevalues, -1)->pvalue;
 <% end %>
@@ -993,15 +990,15 @@ static size_t parse_from(<%= @grammar.prefix %>context_t * context, size_t start
             if (reduced_rule_set == INVALID_ID)
             {
                 /* We shifted a token, mark it consumed. */
-<% if @grammar.tree %>
-                <%= @grammar.tree_prefix %>Token<%= @grammar.tree_suffix %> * token_tree_node = (<%= @grammar.tree_prefix %>Token<%= @grammar.tree_suffix %> *)malloc(sizeof(<%= @grammar.tree_prefix %>Token<%= @grammar.tree_suffix %>));
-                token_tree_node->position = token_info.position;
-                token_tree_node->end_position = token_info.end_position;
-                token_tree_node->n_fields = 0u;
-                token_tree_node->is_token = 1u;
-                token_tree_node->token = token;
-                token_tree_node->pvalue = token_info.pvalue;
-                state_values_stack_index(&statevalues, -1)->tree_node = token_tree_node;
+<% if @grammar.ast %>
+                <%= @grammar.ast_prefix %>Token<%= @grammar.ast_suffix %> * token_ast_node = (<%= @grammar.ast_prefix %>Token<%= @grammar.ast_suffix %> *)malloc(sizeof(<%= @grammar.ast_prefix %>Token<%= @grammar.ast_suffix %>));
+                token_ast_node->position = token_info.position;
+                token_ast_node->end_position = token_info.end_position;
+                token_ast_node->n_fields = 0u;
+                token_ast_node->is_token = 1u;
+                token_ast_node->token = token;
+                token_ast_node->pvalue = token_info.pvalue;
+                state_values_stack_index(&statevalues, -1)->ast_node = token_ast_node;
 <% else %>
                 state_values_stack_index(&statevalues, -1)->pvalue = token_info.pvalue;
 <% end %>
@@ -1010,8 +1007,8 @@ static size_t parse_from(<%= @grammar.prefix %>context_t * context, size_t start
             else
             {
                 /* We shifted a RuleSet. */
-<% if @grammar.tree %>
-                state_values_stack_index(&statevalues, -1)->tree_node = reduced_parser_node;
+<% if @grammar.ast %>
+                state_values_stack_index(&statevalues, -1)->ast_node = reduced_parser_node;
 <% else %>
                 state_values_stack_index(&statevalues, -1)->pvalue = reduced_parser_value;
                 <%= @grammar.prefix %>value_t new_parse_result;
@@ -1027,16 +1024,16 @@ static size_t parse_from(<%= @grammar.prefix %>context_t * context, size_t start
         if (reduce_index != INVALID_ID)
         {
             /* We have something to reduce. */
-<% if @grammar.tree %>
+<% if @grammar.ast %>
             if (parser_reduce_table[reduce_index].propagate_optional_target)
             {
-                reduced_parser_node = state_values_stack_index(&statevalues, -1)->tree_node;
+                reduced_parser_node = state_values_stack_index(&statevalues, -1)->ast_node;
             }
             else if (parser_reduce_table[reduce_index].n_states > 0)
             {
                 size_t n_fields = parser_reduce_table[reduce_index].rule_set_node_field_array_size;
-                size_t bytes = sizeof(TreeNode) + n_fields * sizeof(void *);
-                TreeNode * node = (TreeNode *)malloc(bytes);
+                size_t bytes = sizeof(ASTNode) + n_fields * sizeof(void *);
+                ASTNode * node = (ASTNode *)malloc(bytes);
                 memset(node, 0, bytes);
                 node->position = INVALID_POSITION;
                 node->end_position = INVALID_POSITION;
@@ -1045,20 +1042,20 @@ static size_t parse_from(<%= @grammar.prefix %>context_t * context, size_t start
                 {
                     for (size_t i = 0; i < parser_reduce_table[reduce_index].n_states; i++)
                     {
-                        node->fields[i] = (TreeNode *)state_values_stack_index(&statevalues, -(int)parser_reduce_table[reduce_index].n_states + (int)i)->tree_node;
+                        node->fields[i] = (ASTNode *)state_values_stack_index(&statevalues, -(int)parser_reduce_table[reduce_index].n_states + (int)i)->ast_node;
                     }
                 }
                 else
                 {
                     for (size_t i = 0; i < parser_reduce_table[reduce_index].n_states; i++)
                     {
-                        node->fields[parser_reduce_table[reduce_index].rule_set_node_field_index_map[i]] = (TreeNode *)state_values_stack_index(&statevalues, -(int)parser_reduce_table[reduce_index].n_states + (int)i)->tree_node;
+                        node->fields[parser_reduce_table[reduce_index].rule_set_node_field_index_map[i]] = (ASTNode *)state_values_stack_index(&statevalues, -(int)parser_reduce_table[reduce_index].n_states + (int)i)->ast_node;
                     }
                 }
                 bool position_found = false;
                 for (size_t i = 0; i < n_fields; i++)
                 {
-                    TreeNode * child = node->fields[i];
+                    ASTNode * child = node->fields[i];
                     if ((child != NULL) && <%= @grammar.prefix %>position_valid(child->position))
                     {
                         if (!position_found)
@@ -1104,19 +1101,6 @@ static size_t parse_from(<%= @grammar.prefix %>context_t * context, size_t start
     return result;
 }
 
-size_t <%= @grammar.prefix %>parse(<%= @grammar.prefix %>context_t * context)
-{
-    return parse_from(context, 0u);
-}
-
-<% @grammar.start_rules.each_with_index do |start_rule, i| %>
-
-size_t <%= @grammar.prefix %>parse_<%= start_rule %>(<%= @grammar.prefix %>context_t * context)
-{
-    return parse_from(context, <%= i %>u);
-}
-<% end %>
-
 /**
  * Get the parse result value.
  *
@@ -1125,29 +1109,18 @@ size_t <%= @grammar.prefix %>parse_<%= start_rule %>(<%= @grammar.prefix %>conte
  *
  * @return Parse result value.
  */
-<% if @grammar.tree %>
-<%= @grammar.tree_prefix %><%= @grammar.start_rules[0] %><%= @grammar.tree_suffix %> * <%= @grammar.prefix %>result(<%= @grammar.prefix %>context_t * context)
-{
-    return (<%= @grammar.tree_prefix %><%= @grammar.start_rules[0] %><%= @grammar.tree_suffix %> *) context->parse_result;
-}
-<%   @grammar.start_rules.each_with_index do |start_rule, i| %>
-<%= @grammar.tree_prefix %><%= start_rule %><%= @grammar.tree_suffix %> * <%= @grammar.prefix %>result_<%= start_rule %>(<%= @grammar.prefix %>context_t * context)
-{
-    return (<%= @grammar.tree_prefix %><%= start_rule %><%= @grammar.tree_suffix %> *) context->parse_result;
-}
-<%   end %>
+<% if @grammar.ast %>
+<%= @grammar.ast_prefix %><%= @grammar.start_rules[0] %><%= @grammar.ast_suffix %> * <%= @grammar.prefix %>result(<%= @grammar.prefix %>context_t * context)
 <% else %>
 <%= start_rule_type[1] %> <%= @grammar.prefix %>result(<%= @grammar.prefix %>context_t * context)
-{
-    return context->parse_result.v_<%= start_rule_type[0] %>;
-}
-<%   @grammar.start_rules.each_with_index do |start_rule, i| %>
-<%= start_rule_type(i)[1] %> <%= @grammar.prefix %>result_<%= start_rule %>(<%= @grammar.prefix %>context_t * context)
-{
-    return context->parse_result.v_<%= start_rule_type(i)[0] %>;
-}
-<%   end %>
 <% end %>
+{
+<% if @grammar.ast %>
+    return (<%= @grammar.ast_prefix %><%= @grammar.start_rules[0] %><%= @grammar.ast_suffix %> *) context->parse_result;
+<% else %>
+    return context->parse_result.v_<%= start_rule_type[0] %>;
+<% end %>
+}
 
 /**
  * Get the current text input position.
@@ -1184,14 +1157,14 @@ size_t <%= @grammar.prefix %>user_terminate_code(<%= @grammar.prefix %>context_t
 {
     return context->token;
 }
-<% if @grammar.tree %>
+<% if @grammar.ast %>
 
-static void free_tree_node(TreeNode * node)
+static void free_ast_node(ASTNode * node)
 {
     if (node->is_token)
     {
 <%   if @grammar.free_token_node %>
-        <%= @grammar.free_token_node %>((<%= @grammar.tree_prefix %>Token<%= @grammar.tree_suffix %> *) node);
+        <%= @grammar.free_token_node %>((<%= @grammar.ast_prefix %>Token<%= @grammar.ast_suffix %> *) node);
 <%   end %>
         /* TODO: free value_t */
     }
@@ -1201,7 +1174,7 @@ static void free_tree_node(TreeNode * node)
         {
             if (node->fields[i] != NULL)
             {
-                free_tree_node(node->fields[i]);
+                free_ast_node(node->fields[i]);
             }
         }
     }
@@ -1209,20 +1182,10 @@ static void free_tree_node(TreeNode * node)
 }
 
 /**
- * Free all tree node memory.
+ * Free all AST node memory.
  */
-void <%= @grammar.prefix %>free_tree(<%= @grammar.tree_prefix %><%= @grammar.start_rules[0] %><%= @grammar.tree_suffix %> * tree)
+void <%= @grammar.prefix %>free_ast(<%= @grammar.ast_prefix %><%= @grammar.start_rules[0] %><%= @grammar.ast_suffix %> * ast)
 {
-    free_tree_node((TreeNode *)tree);
+    free_ast_node((ASTNode *)ast);
 }
-<%   @grammar.start_rules.each_with_index do |start_rule, i| %>
-
-/**
- * Free all tree node memory.
- */
-void <%= @grammar.prefix %>free_tree_<%= start_rule %>(<%= @grammar.tree_prefix %><%= start_rule %><%= @grammar.tree_suffix %> * tree)
-{
-    free_tree_node((TreeNode *)tree);
-}
-<%   end %>
 <% end %>

assets/parser.d.erb

@@ -75,7 +75,7 @@ public struct <%= @grammar.prefix %>position_t
     }
 }
 
-<% if @grammar.tree %>
+<% if @grammar.ast %>
 /** Parser values type. */
 public alias <%= @grammar.prefix %>value_t = <%= @grammar.ptype %>;
 <% else %>
@@ -88,19 +88,19 @@ public union <%= @grammar.prefix %>value_t
 }
 <% end %>
 
-<% if @grammar.tree %>
-/** Common tree node structure. */
-private struct TreeNode
+<% if @grammar.ast %>
+/** Common AST node structure. */
+private struct ASTNode
 {
     <%= @grammar.prefix %>position_t position;
     <%= @grammar.prefix %>position_t end_position;
     void *[0] fields;
 }
 
-/** Tree node types. @{ */
-public struct <%= @grammar.tree_prefix %>Token<%= @grammar.tree_suffix %>
+/** AST node types. @{ */
+public struct <%= @grammar.ast_prefix %>Token<%= @grammar.ast_suffix %>
 {
-    /* TreeNode fields must be present in the same order here. */
+    /* ASTNode fields must be present in the same order here. */
     <%= @grammar.prefix %>position_t position;
     <%= @grammar.prefix %>position_t end_position;
     <%= @grammar.prefix %>token_t token;
@@ -110,11 +110,11 @@ public struct <%= @grammar.tree_prefix %>Token<%= @grammar.tree_suffix %>
 <%   @parser.rule_sets.each do |name, rule_set| %>
 <%     next if name.start_with?("$") %>
 <%     next if rule_set.optional? %>
-public struct <%= @grammar.tree_prefix %><%= name %><%= @grammar.tree_suffix %>
+public struct <%= @grammar.ast_prefix %><%= name %><%= @grammar.ast_suffix %>
 {
     <%= @grammar.prefix %>position_t position;
     <%= @grammar.prefix %>position_t end_position;
-<%     rule_set.tree_fields.each do |fields| %>
+<%     rule_set.ast_fields.each do |fields| %>
     union
     {
 <%       fields.each do |field_name, type| %>
@@ -172,7 +172,7 @@ public struct <%= @grammar.prefix %>context_t
     /* Parser context data. */
 
     /** Parse result value. */
-<% if @grammar.tree %>
+<% if @grammar.ast %>
     void * parse_result;
 <% else %>
     <%= @grammar.prefix %>value_t parse_result;
@@ -797,7 +797,7 @@ private struct reduce_t
      * reduce action.
      */
     parser_state_id_t n_states;
-<% if @grammar.tree %>
+<% if @grammar.ast %>
 
     /**
      * Map of rule components to rule set child fields.
@@ -805,7 +805,7 @@ private struct reduce_t
     immutable(ushort) * rule_set_node_field_index_map;
 
     /**
-     * Number of rule set tree node fields.
+     * Number of rule set AST node fields.
      */
     ushort rule_set_node_field_array_size;
 
@@ -847,9 +847,9 @@ private struct state_value_t
     /** Parser value from this state. */
     <%= @grammar.prefix %>value_t pvalue;
 
-<% if @grammar.tree %>
-    /** Tree node. */
-    void * tree_node;
+<% if @grammar.ast %>
+    /** AST node. */
+    void * ast_node;
 <% end %>
 
     this(size_t state_id)
@@ -865,7 +865,7 @@ private immutable shift_t[] parser_shift_table = [
 <%   end %>
 ];
 
-<% if @grammar.tree %>
+<% if @grammar.ast %>
 <%   @grammar.rules.each do |rule| %>
 <%     unless rule.flat_rule_set_node_field_index_map? %>
 immutable ushort[<%= rule.rule_set_node_field_index_map.size %>] r_<%= rule.name.gsub("$", "_") %><%= rule.id %>_node_field_index_map = [<%= rule.rule_set_node_field_index_map.map {|v| v.to_s}.join(", ") %>];
@@ -880,14 +880,14 @@ private immutable reduce_t[] parser_reduce_table = [
         <%= reduce[:token_id] %>u, /* Token: <%= reduce[:token] ? reduce[:token].name : "(any)" %> */
         <%= reduce[:rule_id] %>u, /* Rule ID */
         <%= reduce[:rule_set_id] %>u, /* Rule set ID (<%= reduce[:rule].rule_set.name %>) */
-<%     if @grammar.tree %>
+<%     if @grammar.ast %>
         <%= reduce[:n_states] %>u, /* Number of states */
 <%       if reduce[:rule].flat_rule_set_node_field_index_map? %>
         null, /* No rule set node field index map (flat map) */
 <%       else %>
         &r_<%= reduce[:rule].name.gsub("$", "_") %><%= reduce[:rule].id %>_node_field_index_map[0], /* Rule set node field index map */
 <%       end %>
-        <%= reduce[:rule].rule_set.tree_fields.size %>, /* Number of tree fields */
+        <%= reduce[:rule].rule_set.ast_fields.size %>, /* Number of AST fields */
         <%= reduce[:propagate_optional_target] %>), /* Propagate optional target? */
 <%     else %>
         <%= reduce[:n_states] %>u), /* Number of states */
@@ -902,7 +902,7 @@ private immutable parser_state_t[] parser_state_table = [
 <%   end %>
 ];
 
-<% unless @grammar.tree %>
+<% unless @grammar.ast %>
 /**
  * Execute user code associated with a parser rule.
  *
@@ -985,8 +985,6 @@ private size_t check_reduce(size_t state_id, <%= @grammar.prefix %>token_t token
  *
  * @param context
  *   Lexer/parser context structure.
- * @start_state_id
- *   ID of the state in which to start.
  *
  * @retval P_SUCCESS
  *   The parser successfully matched the input text. The parse result value
@@ -999,14 +997,13 @@ private size_t check_reduce(size_t state_id, <%= @grammar.prefix %>token_t token
  * @reval P_UNEXPECTED_INPUT
  *   Input text does not match any lexer pattern.
  */
-private size_t parse_from(<%= @grammar.prefix %>context_t * context, size_t start_state_id)
+public size_t <%= @grammar.prefix %>parse(<%= @grammar.prefix %>context_t * context)
 {
     <%= @grammar.prefix %>token_info_t token_info;
     <%= @grammar.prefix %>token_t token = INVALID_TOKEN_ID;
     state_value_t[] statevalues = new state_value_t[](1);
-    statevalues[0].state_id = start_state_id;
     size_t reduced_rule_set = INVALID_ID;
-<% if @grammar.tree %>
+<% if @grammar.ast %>
     void * reduced_parser_node;
 <% else %>
     <%= @grammar.prefix %>value_t reduced_parser_value;
@@ -1033,8 +1030,8 @@ private size_t parse_from(<%= @grammar.prefix %>context_t * context, size_t star
             if ((shift_state != INVALID_ID) && (token == TOKEN___EOF))
             {
                 /* Successful parse. */
-<% if @grammar.tree %>
-                context.parse_result = statevalues[$-1].tree_node;
+<% if @grammar.ast %>
+                context.parse_result = statevalues[$-1].ast_node;
 <% else %>
                 context.parse_result = statevalues[$-1].pvalue;
 <% end %>
@@ -1048,9 +1045,9 @@ private size_t parse_from(<%= @grammar.prefix %>context_t * context, size_t star
             if (reduced_rule_set == INVALID_ID)
             {
                 /* We shifted a token, mark it consumed. */
-<% if @grammar.tree %>
-                <%= @grammar.tree_prefix %>Token<%= @grammar.tree_suffix %> * token_tree_node = new <%= @grammar.tree_prefix %>Token<%= @grammar.tree_suffix %>(token_info.position, token_info.end_position, token, token_info.pvalue);
-                statevalues[$-1].tree_node = token_tree_node;
+<% if @grammar.ast %>
+                <%= @grammar.ast_prefix %>Token<%= @grammar.ast_suffix %> * token_ast_node = new <%= @grammar.ast_prefix %>Token<%= @grammar.ast_suffix %>(token_info.position, token_info.end_position, token, token_info.pvalue);
+                statevalues[$-1].ast_node = token_ast_node;
 <% else %>
                 statevalues[$-1].pvalue = token_info.pvalue;
 <% end %>
@@ -1059,8 +1056,8 @@ private size_t parse_from(<%= @grammar.prefix %>context_t * context, size_t star
             else
             {
                 /* We shifted a RuleSet. */
-<% if @grammar.tree %>
-                statevalues[$-1].tree_node = reduced_parser_node;
+<% if @grammar.ast %>
+                statevalues[$-1].ast_node = reduced_parser_node;
 <% else %>
                 statevalues[$-1].pvalue = reduced_parser_value;
                 <%= @grammar.prefix %>value_t new_parse_result;
@@ -1075,16 +1072,16 @@ private size_t parse_from(<%= @grammar.prefix %>context_t * context, size_t star
         if (reduce_index != INVALID_ID)
         {
             /* We have something to reduce. */
-<% if @grammar.tree %>
+<% if @grammar.ast %>
             if (parser_reduce_table[reduce_index].propagate_optional_target)
             {
-                reduced_parser_node = statevalues[$ - 1].tree_node;
+                reduced_parser_node = statevalues[$ - 1].ast_node;
             }
             else if (parser_reduce_table[reduce_index].n_states > 0)
             {
                 size_t n_fields = parser_reduce_table[reduce_index].rule_set_node_field_array_size;
-                size_t node_size = TreeNode.sizeof + n_fields * (void *).sizeof;
-                TreeNode * node = cast(TreeNode *)malloc(node_size);
+                size_t node_size = ASTNode.sizeof + n_fields * (void *).sizeof;
+                ASTNode * node = cast(ASTNode *)malloc(node_size);
                 GC.addRange(node, node_size);
                 node.position = <%= @grammar.prefix %>position_t.INVALID;
                 node.end_position = <%= @grammar.prefix %>position_t.INVALID;
@@ -1096,20 +1093,20 @@ private size_t parse_from(<%= @grammar.prefix %>context_t * context, size_t star
                 {
                     foreach (i; 0..parser_reduce_table[reduce_index].n_states)
                     {
-                        node.fields[i] = statevalues[$ - parser_reduce_table[reduce_index].n_states + i].tree_node;
+                        node.fields[i] = statevalues[$ - parser_reduce_table[reduce_index].n_states + i].ast_node;
                     }
                 }
                 else
                 {
                     foreach (i; 0..parser_reduce_table[reduce_index].n_states)
                     {
-                        node.fields[parser_reduce_table[reduce_index].rule_set_node_field_index_map[i]] = statevalues[$ - parser_reduce_table[reduce_index].n_states + i].tree_node;
+                        node.fields[parser_reduce_table[reduce_index].rule_set_node_field_index_map[i]] = statevalues[$ - parser_reduce_table[reduce_index].n_states + i].ast_node;
                     }
                 }
                 bool position_found = false;
                 foreach (i; 0..n_fields)
                 {
-                    TreeNode * child = cast(TreeNode *)node.fields[i];
+                    ASTNode * child = cast(ASTNode *)node.fields[i];
                     if (child && child.position.valid)
                     {
                         if (!position_found)
@@ -1150,19 +1147,6 @@ private size_t parse_from(<%= @grammar.prefix %>context_t * context, size_t star
     }
 }
 
-public size_t <%= @grammar.prefix %>parse(<%= @grammar.prefix %>context_t * context)
-{
-    return parse_from(context, 0u);
-}
-
-<% @grammar.start_rules.each_with_index do |start_rule, i| %>
-
-public size_t <%= @grammar.prefix %>parse_<%= start_rule %>(<%= @grammar.prefix %>context_t * context)
-{
-    return parse_from(context, <%= i %>u);
-}
-<% end %>
-
 /**
  * Get the parse result value.
  *
@@ -1171,29 +1155,18 @@ public size_t <%= @grammar.prefix %>parse_<%= start_rule %>(<%= @grammar.prefix
  *
  * @return Parse result value.
  */
-<% if @grammar.tree %>
-public <%= @grammar.tree_prefix %><%= @grammar.start_rules[0] %><%= @grammar.tree_suffix %> * <%= @grammar.prefix %>result(<%= @grammar.prefix %>context_t * context)
-{
-    return cast(<%= @grammar.tree_prefix %><%= @grammar.start_rules[0] %><%= @grammar.tree_suffix %> *)context.parse_result;
-}
-<%   @grammar.start_rules.each_with_index do |start_rule, i| %>
-public <%= @grammar.tree_prefix %><%= start_rule %><%= @grammar.tree_suffix %> * <%= @grammar.prefix %>result_<%= start_rule %>(<%= @grammar.prefix %>context_t * context)
-{
-    return cast(<%= @grammar.tree_prefix %><%= start_rule %><%= @grammar.tree_suffix %> *)context.parse_result;
-}
-<%   end %>
+<% if @grammar.ast %>
+public <%= @grammar.ast_prefix %><%= @grammar.start_rules[0] %><%= @grammar.ast_suffix %> * <%= @grammar.prefix %>result(<%= @grammar.prefix %>context_t * context)
 <% else %>
 public <%= start_rule_type[1] %> <%= @grammar.prefix %>result(<%= @grammar.prefix %>context_t * context)
-{
-    return context.parse_result.v_<%= start_rule_type[0] %>;
-}
-<%   @grammar.start_rules.each_with_index do |start_rule, i| %>
-public <%= start_rule_type(i)[1] %> <%= @grammar.prefix %>result_<%= start_rule %>(<%= @grammar.prefix %>context_t * context)
-{
-    return context.parse_result.v_<%= start_rule_type(i)[0] %>;
-}
-<%   end %>
 <% end %>
+{
+<% if @grammar.ast %>
+    return cast(<%= @grammar.ast_prefix %><%= @grammar.start_rules[0] %><%= @grammar.ast_suffix %> *)context.parse_result;
+<% else %>
+    return context.parse_result.v_<%= start_rule_type[0] %>;
+<% end %>
+}
 
 /**
  * Get the current text input position.

assets/parser.h.erb

@@ -58,7 +58,7 @@ typedef struct
 /** User header code blocks. */
 <%= @grammar.code_blocks.fetch("header", "") %>
 
-<% if @grammar.tree %>
+<% if @grammar.ast %>
 /** Parser values type. */
 typedef <%= @grammar.ptype %> <%= @grammar.prefix %>value_t;
 <% else %>
@@ -71,18 +71,18 @@ typedef union
 } <%= @grammar.prefix %>value_t;
 <% end %>
 
-<% if @grammar.tree %>
-/** Tree node types. @{ */
-typedef struct <%= @grammar.tree_prefix %>Token<%= @grammar.tree_suffix %>
+<% if @grammar.ast %>
+/** AST node types. @{ */
+typedef struct <%= @grammar.ast_prefix %>Token<%= @grammar.ast_suffix %>
 {
-    <% # TreeNode fields must be present in the same order here. # %>
+    <% # ASTNode fields must be present in the same order here. # %>
     <%= @grammar.prefix %>position_t position;
     <%= @grammar.prefix %>position_t end_position;
     uint16_t n_fields;
     uint8_t is_token;
     <%= @grammar.prefix %>token_t token;
     <%= @grammar.prefix %>value_t pvalue;
-} <%= @grammar.tree_prefix %>Token<%= @grammar.tree_suffix %>;
+} <%= @grammar.ast_prefix %>Token<%= @grammar.ast_suffix %>;
 
 <%   @parser.rule_sets.each do |name, rule_set| %>
 <%     next if name.start_with?("$") %>
@@ -93,14 +93,14 @@ struct <%= name %>;
 <%   @parser.rule_sets.each do |name, rule_set| %>
 <%     next if name.start_with?("$") %>
 <%     next if rule_set.optional? %>
-typedef struct <%= @grammar.tree_prefix %><%= name %><%= @grammar.tree_suffix %>
+typedef struct <%= @grammar.ast_prefix %><%= name %><%= @grammar.ast_suffix %>
 {
-    <% # TreeNode fields must be present in the same order here. # %>
+    <% # ASTNode fields must be present in the same order here. # %>
     <%= @grammar.prefix %>position_t position;
     <%= @grammar.prefix %>position_t end_position;
     uint16_t n_fields;
     uint8_t is_token;
-<%     rule_set.tree_fields.each do |fields| %>
+<%     rule_set.ast_fields.each do |fields| %>
     union
     {
 <%       fields.each do |field_name, type| %>
@@ -108,7 +108,7 @@ typedef struct <%= @grammar.tree_prefix %><%= name %><%= @grammar.tree_suffix %>
 <%       end %>
     };
 <%     end %>
-} <%= @grammar.tree_prefix %><%= name %><%= @grammar.tree_suffix %>;
+} <%= @grammar.ast_prefix %><%= name %><%= @grammar.ast_suffix %>;
 
 <%   end %>
 /** @} */
@@ -161,7 +161,7 @@ typedef struct
     /* Parser context data. */
 
     /** Parse result value. */
-<% if @grammar.tree %>
+<% if @grammar.ast %>
     void * parse_result;
 <% else %>
     <%= @grammar.prefix %>value_t parse_result;
@@ -189,27 +189,13 @@ size_t <%= @grammar.prefix %>decode_code_point(uint8_t const * input, size_t inp
 size_t <%= @grammar.prefix %>lex(<%= @grammar.prefix %>context_t * context, <%= @grammar.prefix %>token_info_t * out_token_info);
 
 size_t <%= @grammar.prefix %>parse(<%= @grammar.prefix %>context_t * context);
-<%   @grammar.start_rules.each_with_index do |start_rule, i| %>
-size_t <%= @grammar.prefix %>parse_<%= start_rule %>(<%= @grammar.prefix %>context_t * context);
-<%   end %>
 
-<% if @grammar.tree %>
-<%= @grammar.tree_prefix %><%= @grammar.start_rules[0] %><%= @grammar.tree_suffix %> * <%= @grammar.prefix %>result(<%= @grammar.prefix %>context_t * context);
-<%   @grammar.start_rules.each_with_index do |start_rule, i| %>
-<%= @grammar.tree_prefix %><%= start_rule %><%= @grammar.tree_suffix %> * <%= @grammar.prefix %>result_<%= start_rule %>(<%= @grammar.prefix %>context_t * context);
-<%   end %>
+<% if @grammar.ast %>
+<%= @grammar.ast_prefix %><%= @grammar.start_rules[0] %><%= @grammar.ast_suffix %> * <%= @grammar.prefix %>result(<%= @grammar.prefix %>context_t * context);
+
+void <%= @grammar.prefix %>free_ast(<%= @grammar.ast_prefix %><%= @grammar.start_rules[0] %><%= @grammar.ast_suffix %> * ast);
 <% else %>
 <%= start_rule_type[1] %> <%= @grammar.prefix %>result(<%= @grammar.prefix %>context_t * context);
-<%   @grammar.start_rules.each_with_index do |start_rule, i| %>
-<%= start_rule_type(i)[1] %> <%= @grammar.prefix %>result_<%= start_rule %>(<%= @grammar.prefix %>context_t * context);
-<%   end %>
-<% end %>
-
-<% if @grammar.tree %>
-void <%= @grammar.prefix %>free_tree(<%= @grammar.tree_prefix %><%= @grammar.start_rules[0] %><%= @grammar.tree_suffix %> * tree);
-<%   @grammar.start_rules.each_with_index do |start_rule, i| %>
-void <%= @grammar.prefix %>free_tree_<%= start_rule %>(<%= @grammar.tree_prefix %><%= start_rule %><%= @grammar.tree_suffix %> * tree);
-<%   end %>
 <% end %>
 
 <%= @grammar.prefix %>position_t <%= @grammar.prefix %>position(<%= @grammar.prefix %>context_t * context);

doc/user_guide.md

@@ -14,8 +14,7 @@ Propane is a LALR Parser Generator (LPG) which:
   * supports UTF-8 lexer inputs
   * generates a table-driven shift/reduce parser to parse input in linear time
   * targets C, C++, or D language outputs
-  * optionally supports automatic full parse tree generation
-  * supports starting parsing from multiple start rules
+  * optionally supports automatic full AST generation
   * tracks input text start and end positions for all matched tokens/rules
   * is MIT-licensed
   * is distributable as a standalone Ruby script
@@ -190,21 +189,21 @@ rule.
 Parser values for the rules or tokens in the rule pattern can be accessed
 positionally with tokens `$1`, `$2`, `$3`, etc...
 
-Parser rule code blocks are not available in tree generation mode.
-In tree generation mode, a full parse tree is automatically constructed in
+Parser rule code blocks are not available in AST generation mode.
+In AST generation mode, a full parse tree is automatically constructed in
 memory for user code to traverse after parsing is complete.
 
-##> Tree generation mode - the `tree` statement
+##> AST generation mode - the `ast` statement
 
-To activate tree generation mode, place the `tree` statement in your grammar file:
+To activate AST generation mode, place the `ast` statement in your grammar file:
 
 ```
-tree;
+ast;
 ```
 
 It is recommended to place this statement early in the grammar.
 
-In tree generation mode various aspects of propane's behavior are changed:
+In AST generation mode various aspects of propane's behavior are changed:
 
   * Only one `ptype` is allowed.
   * Parser user code blocks are not supported.
@@ -215,10 +214,10 @@ In tree generation mode various aspects of propane's behavior are changed:
   with the `start` grammar statement, the name of the start struct will be
   given by the user-specified start rule instead of `Start`.
 
-Example tree generation grammar:
+Example AST generation grammar:
 
 ```
-tree;
+ast;
 
 ptype int;
 
@@ -285,23 +284,23 @@ assert_eq(22, itemsmore.item.pToken1.pvalue);
 assert(itemsmore.pItemsMore is null);
 ```
 
-## `tree_prefix` and `tree_suffix` statements
+## `ast_prefix` and `ast_suffix` statements
 
-In tree generation mode, structure types are defined and named based on the
+In AST generation mode, structure types are defined and named based on the
 rules in the grammar.
 Additionally, a structure type called `Token` is generated to hold parsed
 token information.
 
-These structure names can be modified by using the `tree_prefix` or `tree_suffix`
+These structure names can be modified by using the `ast_prefix` or `ast_suffix`
 statements in the grammar file.
 The field names that point to instances of the structures are not affected by
-the `tree_prefix` or `tree_suffix` values.
+the `ast_prefix` or `ast_suffix` values.
 
 For example, if the following two lines were added to the example above:
 
 ```
-tree_prefix ABC;
-tree_suffix XYZ;
+ast_prefix ABC;
+ast_suffix XYZ;
 ```
 
 Then the types would be used as such instead:
@@ -331,7 +330,7 @@ assert(itemsmore.pItem.pItem.pItem.pToken1 !is null);
 
 If user lexer code block allocates memory to store in a token node's `pvalue`,
 the `free_token_node` grammar statement can be used to specify the name of a
-function which will be called during the `p_free_tree()` call to free the memory
+function which will be called during the `p_free_ast()` call to free the memory
 associated with a token node.
 
 Example:
@@ -343,7 +342,7 @@ static void free_token(Token * token)
     free(token->pvalue);
 }
 >>
-tree;
+ast;
 free_token_node free_token;
 ptype int *;
 token a <<
@@ -642,7 +641,7 @@ In this example:
   * a reduced `Values`'s parser value has a type of `Value[]`.
   * a reduced `KeyValue`'s parser value has a type of `Value[string]`.
 
-When tree generation mode is active, the `ptype` functionality works differently.
+When AST generation mode is active, the `ptype` functionality works differently.
 In this mode, only one `ptype` is used by the parser.
 Lexer user code blocks may assign a parse value to the generated `Token` node
 by assigning to `$$` within a lexer code block.
@@ -701,8 +700,8 @@ A field can be immediately followed by a `?` character to signify that it is
 optional.
 A field can optionally be followed by a `:` and then a field alias name.
 If present, the field alias name is used to refer to the field value in user
-code blocks, or if tree generation mode is active, the field alias name is used
-as the field name in the generated tree node structure.
+code blocks, or if AST mode is active, the field alias name is used as the
+field name in the generated AST node structure.
 An optional and named field must use the format `field?:name`.
 Example:
 
@@ -726,7 +725,7 @@ The `$$` symbol accesses the output parser value for this rule.
 The above examples demonstrate how the parser values for the rule components
 can be used to produce the parser value for the accepted rule.
 
-Parser rule code blocks are not allowed and not used when tree generation mode
+Parser rule code blocks are not allowed and not used when AST generation mode
 is active.
 
 ##> Specifying the parser start rule name - the `start` statement
@@ -739,22 +738,6 @@ Example:
 start MyStartRule;
 ```
 
-Multiple start rules can be specified, either with multiple `start` statements
-or one `start` statement listing multiple start rules.
-Example:
-
-```
-start Module ModuleItem Statement Expression;
-```
-
-When multiple start rules are specified, multiple `p_parse_*()` functions,
-`p_result_*()`, and `p_free_tree_*()` functions (in tree mode) are generated.
-A default `p_parse()`, `p_result()`, `p_free_tree()` are generated corresponding
-to the first start rule.
-Additionally, each start rule causes the generation of another version of each
-of these functions, for example `p_parse_Statement()`, `p_result_Statement()`,
-and `p_free_tree_Statement()`.
-
 ##> Specifying the parser module name - the `module` statement
 
 The `module` statement can be used to specify the module name for a generated
@@ -874,17 +857,17 @@ The `p_token_info_t` structure contains the following fields:
 * `token` (`p_token_t`) holds the token ID of the lexed token
 * `pvalue` (`p_value_t`) holds the parser value associated with the token.
 
-### Tree Node Types
+### AST Node Types
 
-If tree generation mode is enabled, a structure type for each rule will be
+If AST generation mode is enabled, a structure type for each rule will be
 generated.
 The name of the structure type is given by the name of the rule.
-Additionally a structure type called `Token` is generated to represent a
-tree node which refers to a raw parser token rather than a composite rule.
+Additionally a structure type called `Token` is generated to represent an
+AST node which refers to a raw parser token rather than a composite rule.
 
-#### Tree Node Fields
+#### AST Node Fields
 
-All tree nodes have a `position` field specifying the text position of the
+All AST nodes have a `position` field specifying the text position of the
 beginning of the matched token or rule, and an `end_position` field specifying
 the text position of the end of the matched token or rule.
 Each of these fields are instances of the `p_position_t` structure.
@@ -903,7 +886,7 @@ A `Token` node has the following additional fields:
   * `pvalue` which specifies the parser value for the token. If a lexer user
   code block assigned to `$$`, the assigned value will be stored here.
 
-Tree node structures for rules contain generated fields based on the
+AST node structures for rules contain generated fields based on the
 right hand side components specified for all rules of a given name.
 
 In this example:
@@ -926,10 +909,10 @@ The `Items` structure will have fields:
   * `pItemsMore` and `pItemsMore2` which point to the parsed `ItemsMore` structure.
 
 If a rule can be empty (for example in the second `Items` rule above), then
-an instance of a pointer to that rule's generated tree node will be null if the
+an instance of a pointer to that rule's generated AST node will be null if the
 parser matches the empty rule pattern.
 
-The non-positional tree node field pointer will not be generated if there are
+The non-positional AST node field pointer will not be generated if there are
 multiple positions in which an instance of the node it points to could be
 present.
 For example, in the below rules:
@@ -949,7 +932,7 @@ If the first rule is matched, then `pOne1` and `pTwo2` will be non-null while
 If the second rule is matched instead, then the opposite would be the case.
 
 If a field alias is present in a rule definition, an additional field will be
-generated in the tree node with the field alias name.
+generated in the AST node with the field alias name.
 For example:
 
 ```
@@ -1035,16 +1018,6 @@ p_context_init(&context, input, input_length);
 size_t result = p_parse(&context);
 ```
 
-When multiple start rules are specified, a separate parse function is generated
-for each which starts parsing at the given rule.
-For example, if `Statement` is specified as a start rule:
-
-```
-size_t result = p_parse_Statement(&context);
-```
-
-In this case, the parser will start parsing with the `Statement` rule.
-
 ### `p_position_valid`
 
 The `p_position_valid()` function is only generated for C targets.
@@ -1080,25 +1053,8 @@ if (p_parse(&context) == P_SUCCESS)
 }
 ```
 
-If tree generation mode is active, then the `p_result()` function returns a
-`Start *` pointing to the `Start` tree node structure.
-
-When multiple start rules are specified, a separate result function is generated
-for each which returns the parse result for the corresponding rule.
-For example, if `Statement` is specified as a start rule:
-
-```
-p_context_t context;
-p_context_init(&context, input, input_length);
-size_t result = p_parse(&context);
-if (p_parse_Statement(&context) == P_SUCCESS)
-{
-    result = p_result_Statement(&context);
-}
-```
-
-In this case, the parser will start parsing with the `Statement` rule and the
-parse result from the `Statement` rule will be returned.
+If AST generation mode is active, then the `p_result()` function returns a
+`Start *` pointing to the `Start` AST structure.
 
 ### `p_position`
 
@@ -1172,31 +1128,20 @@ assert(code_point == 0x1F9E1u);
 assert(code_point_length == 4u);
 ```
 
-### `p_free_tree`
+### `p_free_ast`
 
-The `p_free_tree()` function can be used to free the memory used by the tree.
+The `p_free_ast()` function can be used to free the memory used by the AST.
 It should be passed the same value that is returned by `p_result()`.
 
-The `p_free_tree()` function is only available for C/C++ output targets.
+The `p_free_ast()` function is only available for C/C++ output targets.
 
 Note that if any lexer user code block allocates memory to store in a token's
 `pvalue`, in order to properly free this memory a `free_token_node` function
 should be specified in the grammar file.
 If specified, the `free_token_node` function will be called during the
-`p_free_tree()` process to allow user code to free any memory associated with
+`p_free_ast()` process to allow user code to free any memory associated with
 a token node's `pvalue`.
 
-When multiple start rules are specified, a separate `p_free_tree` function is
-generated for each which frees the tree resulting from parsing the given rule.
-For example, if `Statement` is specified as a start rule:
-
-```
-p_free_tree_Statement(statement_tree);
-```
-
-In this case, Propane will free a `Statement` tree structure returned by the
-`p_parse_Statement(&context)` function.
-
 ##> Data
 
 ### `p_token_names`

extra/vim/syntax/propane.vim

@@ -20,7 +20,7 @@ syn match propaneOperator "->"
 syn match propaneFieldAlias ":[a-zA-Z0-9_]\+" contains=propaneFieldOperator
 syn match propaneFieldOperator ":" contained
 syn match propaneOperator "?"
-syn keyword propaneKeyword drop free_token_node module prefix ptype start token tokenid tree tree_prefix tree_suffix
+syn keyword propaneKeyword ast ast_prefix ast_suffix drop module prefix ptype start token tokenid
 
 syn region propaneRegex start="/" end="/" skip="\v\\\\|\\/"
 

lib/propane/generator.rb

@@ -71,15 +71,14 @@ class Propane
         end
         tokens_by_name[token.name] = token
       end
-      # Create real start rule(s).
-      real_start_rules = @grammar.start_rules.map do |start_rule|
+      # Check for user start rules.
+      @grammar.start_rules.each_with_index do |start_rule, i|
         unless @grammar.rules.find {|rule| rule.name == start_rule}
           raise Error.new("Start rule `#{start_rule}` not found")
         end
-        Rule.new("$#{start_rule}", [start_rule, "$EOF"], nil, nil, nil)
+        # Add "real" start rule.
+        @grammar.rules.unshift(Rule.new("$#{start_rule}", [start_rule, "$EOF"], nil, nil, nil))
       end
-      # Add real start rules before user-given rules.
-      @grammar.rules = real_start_rules + @grammar.rules
       # Generate and add rules for optional components.
       generate_optional_component_rules!(tokens_by_name)
       # Build rule sets.
@@ -298,7 +297,7 @@ class Propane
         end
       else
         code = code.gsub(/\$\$/) do |match|
-          if @grammar.tree
+          if @grammar.ast
             case @language
             when "c"
               "out_token_info->pvalue"

lib/propane/grammar.rb

@@ -5,13 +5,13 @@ class Propane
     # Reserve identifiers beginning with a double-underscore for internal use.
     IDENTIFIER_REGEX = /(?:[a-zA-Z]|_[a-zA-Z0-9])[a-zA-Z_0-9]*/
 
-    attr_reader :tree
-    attr_reader :tree_prefix
-    attr_reader :tree_suffix
+    attr_reader :ast
+    attr_reader :ast_prefix
+    attr_reader :ast_suffix
     attr_reader :free_token_node
     attr_reader :modulename
     attr_reader :patterns
-    attr_accessor :rules
+    attr_reader :rules
     attr_reader :start_rules
     attr_reader :tokens
     attr_reader :code_blocks
@@ -30,9 +30,9 @@ class Propane
       @input = input.gsub("\r\n", "\n")
       @ptypes = {"default" => "void *"}
       @prefix = "p_"
-      @tree = false
-      @tree_prefix = ""
-      @tree_suffix = ""
+      @ast = false
+      @ast_prefix = ""
+      @ast_suffix = ""
       @free_token_node = nil
       parse_grammar!
       @start_rules << "Start" if @start_rules.empty?
@@ -62,9 +62,9 @@ class Propane
       if parse_white_space!
       elsif parse_comment_line!
       elsif @modeline.nil? && parse_mode_label!
-      elsif parse_tree_statement!
-      elsif parse_tree_prefix_statement!
-      elsif parse_tree_suffix_statement!
+      elsif parse_ast_statement!
+      elsif parse_ast_prefix_statement!
+      elsif parse_ast_suffix_statement!
       elsif parse_free_token_node_statement!
       elsif parse_module_statement!
       elsif parse_ptype_statement!
@@ -98,21 +98,21 @@ class Propane
       consume!(/#.*\n/)
     end
 
-    def parse_tree_statement!
-      if consume!(/tree\s*;/)
-        @tree = true
+    def parse_ast_statement!
+      if consume!(/ast\s*;/)
+        @ast = true
       end
     end
 
-    def parse_tree_prefix_statement!
-      if md = consume!(/tree_prefix\s+(\w+)\s*;/)
-        @tree_prefix = md[1]
+    def parse_ast_prefix_statement!
+      if md = consume!(/ast_prefix\s+(\w+)\s*;/)
+        @ast_prefix = md[1]
       end
     end
 
-    def parse_tree_suffix_statement!
-      if md = consume!(/tree_suffix\s+(\w+)\s*;/)
-        @tree_suffix = md[1]
+    def parse_ast_suffix_statement!
+      if md = consume!(/ast_suffix\s+(\w+)\s*;/)
+        @ast_suffix = md[1]
       end
     end
 
@@ -136,8 +136,8 @@ class Propane
       if consume!(/ptype\s+/)
         name = "default"
         if md = consume!(/(#{IDENTIFIER_REGEX})\s*=\s*/)
-          if @tree
-            raise Error.new("Multiple ptypes are unsupported in tree mode")
+          if @ast
+            raise Error.new("Multiple ptypes are unsupported in AST mode")
           end
           name = md[1]
         end
@@ -151,8 +151,8 @@ class Propane
         md = consume!(/(#{IDENTIFIER_REGEX})\s*/, "expected token name")
         name = md[1]
         if md = consume!(/\((#{IDENTIFIER_REGEX})\)\s*/)
-          if @tree
-            raise Error.new("Multiple ptypes are unsupported in tree mode")
+          if @ast
+            raise Error.new("Multiple ptypes are unsupported in AST mode")
           end
           ptypename = md[1]
         end
@@ -175,8 +175,8 @@ class Propane
         md = consume!(/(#{IDENTIFIER_REGEX})\s*/, "expected token name")
         name = md[1]
         if md = consume!(/\((#{IDENTIFIER_REGEX})\)\s*/)
-          if @tree
-            raise Error.new("Multiple ptypes are unsupported in tree mode")
+          if @ast
+            raise Error.new("Multiple ptypes are unsupported in AST mode")
           end
           ptypename = md[1]
         end
@@ -205,12 +205,12 @@ class Propane
     def parse_rule_statement!
       if md = consume!(/(#{IDENTIFIER_REGEX})\s*(?:\((#{IDENTIFIER_REGEX})\))?\s*->\s*/)
         rule_name, ptypename = *md[1, 2]
-        if @tree && ptypename
-          raise Error.new("Multiple ptypes are unsupported in tree mode")
+        if @ast && ptypename
+          raise Error.new("Multiple ptypes are unsupported in AST mode")
         end
         md = consume!(/((?:#{IDENTIFIER_REGEX}\??(?::#{IDENTIFIER_REGEX})?\s*)*)\s*/, "expected rule component list")
         components = md[1].strip.split(/\s+/)
-        if @tree
+        if @ast
           consume!(/;/, "expected `;'")
         else
           unless code = parse_code_block!
@@ -227,8 +227,8 @@ class Propane
       if pattern = parse_pattern!
         consume!(/\s+/)
         if md = consume!(/\((#{IDENTIFIER_REGEX})\)\s*/)
-          if @tree
-            raise Error.new("Multiple ptypes are unsupported in tree mode")
+          if @ast
+            raise Error.new("Multiple ptypes are unsupported in AST mode")
           end
           ptypename = md[1]
         end
@@ -242,11 +242,8 @@ class Propane
     end
 
     def parse_start_statement!
-      if md = consume!(/start\s+([\w\s]*);/)
-        start_rules = md[1].split(/\s+/).map(&:strip)
-        start_rules.each do |start_rule|
-          @start_rules << start_rule unless @start_rules.include?(start_rule)
-        end
+      if md = consume!(/start\s+(\w+)\s*;/)
+        @start_rules << md[1] unless @start_rules.include?(md[1])
       end
     end
 

lib/propane/parser.rb

@@ -16,20 +16,11 @@ class Propane
       @warnings = Set.new
       @errors = Set.new
       @options = options
-      start_items = grammar.rules[0...grammar.start_rules.length].map do |start_rule|
-        Item.new(start_rule, 0)
-      end
-      start_item_sets = start_items.map {|item| ItemSet.new([item])}
-      eval_item_sets = Set[*start_item_sets]
+      start_item = Item.new(grammar.rules.first, 0)
+      eval_item_sets = Set[ItemSet.new([start_item])]
 
       while eval_item_sets.size > 0
-        item_set =
-          if start_item_sets.size > 0
-            # Ensure we evaluate start_item_sets first in order
-            start_item_sets.slice!(0)
-          else
-            eval_item_sets.first
-          end
+        item_set = eval_item_sets.first
         eval_item_sets.delete(item_set)
         unless @item_sets_set.include?(item_set)
           item_set.id = @item_sets.size

lib/propane/rule.rb

@@ -36,7 +36,7 @@ class Propane
 
     # @return [Array<Integer>]
     #   Map this rule's components to their positions in the parent RuleSet's
-    #   node field pointer array. This is used for tree construction.
+    #   node field pointer array. This is used for AST construction.
     attr_accessor :rule_set_node_field_index_map
 
     # Construct a Rule.

lib/propane/rule_set.rb

@@ -4,8 +4,8 @@ class Propane
   class RuleSet
 
     # @return [Array<Hash>]
-    #   tree fields.
-    attr_reader :tree_fields
+    #   AST fields.
+    attr_reader :ast_fields
 
     # @return [Integer]
     #   ID of the RuleSet.
@@ -100,28 +100,28 @@ class Propane
 
     # Finalize a RuleSet after adding all Rules to it.
     def finalize(grammar)
-      if grammar.tree
-        build_tree_fields(grammar)
+      if grammar.ast
+        build_ast_fields(grammar)
       end
     end
 
     private
 
-    # Build the set of tree fields for this RuleSet.
+    # Build the set of AST fields for this RuleSet.
     #
     # This is an Array of Hashes. Each entry in the Array corresponds to a
-    # field location in the tree node. The entry is a Hash. It could have one or
+    # field location in the AST node. The entry is a Hash. It could have one or
     # two keys. It will always have the field name with a positional suffix as
     # a key. It may also have the field name without the positional suffix if
     # that field only exists in one position across all Rules in the RuleSet.
     #
     # @return [void]
-    def build_tree_fields(grammar)
-      field_tree_node_indexes = {}
+    def build_ast_fields(grammar)
+      field_ast_node_indexes = {}
       field_indexes_across_all_rules = {}
-      # Stores the index into @tree_fields by field alias name.
+      # Stores the index into @ast_fields by field alias name.
       field_aliases = {}
-      @tree_fields = []
+      @ast_fields = []
       @rules.each do |rule|
         rule.components.each_with_index do |component, i|
           if component.is_a?(RuleSet) && component.optional?
@@ -132,25 +132,25 @@ class Propane
           else
             node_name = component.name
           end
-          struct_name = "#{grammar.tree_prefix}#{node_name}#{grammar.tree_suffix}"
+          struct_name = "#{grammar.ast_prefix}#{node_name}#{grammar.ast_suffix}"
           field_name = "p#{node_name}#{i + 1}"
-          unless field_tree_node_indexes[field_name]
-            field_tree_node_indexes[field_name] = @tree_fields.size
-            @tree_fields << {field_name => struct_name}
+          unless field_ast_node_indexes[field_name]
+            field_ast_node_indexes[field_name] = @ast_fields.size
+            @ast_fields << {field_name => struct_name}
           end
           rule.aliases.each do |alias_name, index|
             if index == i
-              alias_tree_fields_index = field_tree_node_indexes[field_name]
-              if field_aliases[alias_name] && field_aliases[alias_name] != alias_tree_fields_index
-                raise Error.new("Error: conflicting tree node field positions for alias `#{alias_name}` in rule #{rule.name} defined on line #{rule.line_number}")
+              alias_ast_fields_index = field_ast_node_indexes[field_name]
+              if field_aliases[alias_name] && field_aliases[alias_name] != alias_ast_fields_index
+                raise Error.new("Error: conflicting AST node field positions for alias `#{alias_name}` in rule #{rule.name} defined on line #{rule.line_number}")
               end
-              field_aliases[alias_name] = alias_tree_fields_index
-              @tree_fields[alias_tree_fields_index][alias_name] = @tree_fields[alias_tree_fields_index].first[1]
+              field_aliases[alias_name] = alias_ast_fields_index
+              @ast_fields[alias_ast_fields_index][alias_name] = @ast_fields[alias_ast_fields_index].first[1]
             end
           end
           field_indexes_across_all_rules[node_name] ||= Set.new
-          field_indexes_across_all_rules[node_name] << field_tree_node_indexes[field_name]
-          rule.rule_set_node_field_index_map[i] = field_tree_node_indexes[field_name]
+          field_indexes_across_all_rules[node_name] << field_ast_node_indexes[field_name]
+          rule.rule_set_node_field_index_map[i] = field_ast_node_indexes[field_name]
         end
       end
       field_indexes_across_all_rules.each do |node_name, indexes_across_all_rules|
@@ -158,8 +158,8 @@ class Propane
           # If this field was only seen in one position across all rules,
           # then add an alias to the positional field name that does not
           # include the position.
-          @tree_fields[indexes_across_all_rules.first]["p#{node_name}"] =
-            "#{grammar.tree_prefix}#{node_name}#{grammar.tree_suffix}"
+          @ast_fields[indexes_across_all_rules.first]["p#{node_name}"] =
+            "#{grammar.ast_prefix}#{node_name}#{grammar.ast_suffix}"
         end
       end
     end

lib/propane/version.rb

@@ -1,3 +1,3 @@
 class Propane
-  VERSION = "3.0.0"
+  VERSION = "2.3.0"
 end

spec/ast_node_memory_remains.c.propane

@@ -1,5 +1,5 @@
-tree;
-tree_prefix P;
+ast;
+ast_prefix P;
 
 <<header
 #include <stdio.h>

spec/ast_node_memory_remains.d.propane

@@ -1,5 +1,5 @@
-tree;
-tree_prefix P;
+ast;
+ast_prefix P;
 
 <<
 import std.bigint;

spec/propane_spec.rb

@@ -245,20 +245,20 @@ EOF
     expect(results.status).to_not eq 0
   end
 
-  it "errors when an alias is in different positions for different rules in a rule set when tree mode is enabled" do
+  it "errors when an alias is in different positions for different rules in a rule set when AST mode is enabled" do
     write_grammar <<EOF
-tree;
+ast;
 token a;
 token b;
 Start -> a:foo b;
 Start -> b b:foo;
 EOF
     results = run_propane(extra_args: %w[-w], capture: true)
-    expect(results.stderr).to match %r{Error: conflicting tree node field positions for alias `foo`}
+    expect(results.stderr).to match %r{Error: conflicting AST node field positions for alias `foo`}
     expect(results.status).to_not eq 0
   end
 
-  it "does not error when an alias is in different positions for different rules in a rule set when tree mode is not enabled" do
+  it "does not error when an alias is in different positions for different rules in a rule set when AST mode is not enabled" do
     write_grammar <<EOF
 token a;
 token b;
@@ -996,9 +996,9 @@ EOF
         run_propane(language: language)
       end
 
-      it "generates a tree" do
+      it "generates an AST" do
         write_grammar <<EOF
-tree;
+ast;
 
 ptype int;
 
@@ -1032,17 +1032,17 @@ One -> one;
 Two -> two;
 EOF
         run_propane(language: language)
-        compile("spec/test_tree.#{language}", language: language)
+        compile("spec/test_ast.#{language}", language: language)
         results = run_test(language: language)
         expect(results.stderr).to eq ""
         expect(results.status).to eq 0
       end
 
-      it "supports tree node prefix and suffix" do
+      it "supports AST node prefix and suffix" do
         write_grammar <<EOF
-tree;
-tree_prefix P ;
-tree_suffix  S;
+ast;
+ast_prefix P ;
+ast_suffix  S;
 
 ptype int;
 
@@ -1076,7 +1076,7 @@ One -> one;
 Two -> two;
 EOF
         run_propane(language: language)
-        compile("spec/test_tree_ps.#{language}", language: language)
+        compile("spec/test_ast_ps.#{language}", language: language)
         results = run_test(language: language)
         expect(results.stderr).to eq ""
         expect(results.status).to eq 0
@@ -1092,15 +1092,15 @@ EOF
         compile("spec/test_start_rule.#{language}", language: language)
       end
 
-      it "allows specifying a different start rule with tree generation" do
+      it "allows specifying a different start rule with AST generation" do
         write_grammar <<EOF
-tree;
+ast;
 token hi;
 start Top;
 Top -> hi;
 EOF
         run_propane(language: language)
-        compile("spec/test_start_rule_tree.#{language}", language: language)
+        compile("spec/test_start_rule_ast.#{language}", language: language)
       end
 
       it "allows marking a rule component as optional" do
@@ -1167,10 +1167,10 @@ EOF
         ])
       end
 
-      it "allows marking a rule component as optional in tree generation mode" do
+      it "allows marking a rule component as optional in AST generation mode" do
         if language == "d"
           write_grammar <<EOF
-tree;
+ast;
 
 <<
 import std.stdio;
@@ -1186,7 +1186,7 @@ R -> d c;
 EOF
         else
           write_grammar <<EOF
-tree;
+ast;
 
 <<
 #include <stdio.h>
@@ -1202,16 +1202,16 @@ R -> d c;
 EOF
         end
         run_propane(language: language)
-        compile("spec/test_optional_rule_component_tree.#{language}", language: language)
+        compile("spec/test_optional_rule_component_ast.#{language}", language: language)
         results = run_test(language: language)
         expect(results.stderr).to eq ""
         expect(results.status).to eq 0
       end
 
-      it "allows naming an optional rule component in tree generation mode" do
+      it "allows naming an optional rule component in AST generation mode" do
         if language == "d"
           write_grammar <<EOF
-tree;
+ast;
 
 <<
 import std.stdio;
@@ -1227,7 +1227,7 @@ R -> d c;
 EOF
         else
           write_grammar <<EOF
-tree;
+ast;
 
 <<
 #include <stdio.h>
@@ -1243,15 +1243,15 @@ R -> d c;
 EOF
         end
         run_propane(language: language)
-        compile("spec/test_named_optional_rule_component_tree.#{language}", language: language)
+        compile("spec/test_named_optional_rule_component_ast.#{language}", language: language)
         results = run_test(language: language)
         expect(results.stderr).to eq ""
         expect(results.status).to eq 0
       end
 
-      it "stores token and rule positions in tree nodes" do
+      it "stores token and rule positions in AST nodes" do
         write_grammar <<EOF
-tree;
+ast;
 
 token a;
 token bb;
@@ -1263,7 +1263,7 @@ T -> bb;
 T -> c;
 EOF
         run_propane(language: language)
-        compile("spec/test_tree_token_positions.#{language}", language: language)
+        compile("spec/test_ast_token_positions.#{language}", language: language)
         results = run_test(language: language)
         expect(results.stderr).to eq ""
         expect(results.status).to eq 0
@@ -1271,7 +1271,7 @@ EOF
 
       it "stores invalid positions for empty rule matches" do
         write_grammar <<EOF
-tree;
+ast;
 
 token a;
 token bb;
@@ -1283,15 +1283,15 @@ T -> a A;
 A -> bb? c?;
 EOF
         run_propane(language: language)
-        compile("spec/test_tree_invalid_positions.#{language}", language: language)
+        compile("spec/test_ast_invalid_positions.#{language}", language: language)
         results = run_test(language: language)
         expect(results.stderr).to eq ""
         expect(results.status).to eq 0
       end
 
-      it "allows specifying field aliases in tree mode" do
+      it "allows specifying field aliases in AST mode" do
         write_grammar <<EOF
-tree;
+ast;
 
 token a;
 token b;
@@ -1303,15 +1303,15 @@ T -> b;
 T -> c;
 EOF
         run_propane(language: language)
-        compile("spec/test_tree_field_aliases.#{language}", language: language)
+        compile("spec/test_ast_field_aliases.#{language}", language: language)
         results = run_test(language: language)
         expect(results.stderr).to eq ""
         expect(results.status).to eq 0
       end
 
-      it "aliases the correct field when multiple rules are in a rule set in tree mode" do
+      it "aliases the correct field when multiple rules are in a rule set in AST mode" do
         write_grammar <<EOF
-tree;
+ast;
 
 token a;
 token b;
@@ -1326,13 +1326,13 @@ T -> b;
 T -> c;
 EOF
         run_propane(language: language)
-        compile("spec/test_tree_field_aliases.#{language}", language: language)
+        compile("spec/test_ast_field_aliases.#{language}", language: language)
         results = run_test(language: language)
         expect(results.stderr).to eq ""
         expect(results.status).to eq 0
       end
 
-      it "allows specifying field aliases when tree mode is not enabled" do
+      it "allows specifying field aliases when AST mode is not enabled" do
         if language == "d"
           write_grammar <<EOF
 <<
@@ -1378,7 +1378,7 @@ EOF
         expect(results.stdout).to match /first is foo1.*second is bar2/m
       end
 
-      it "aliases the correct field when multiple rules are in a rule set when tree mode is not enabled" do
+      it "aliases the correct field when multiple rules are in a rule set when AST mode is not enabled" do
         if language == "d"
           write_grammar <<EOF
 <<
@@ -1430,59 +1430,18 @@ EOF
         expect(results.stdout).to match /first is foo1.*second is bar2/m
       end
 
-      it "does not free memory allocated for tree nodes" do
+      it "does not free memory allocated for AST nodes" do
         ext = language == "cpp" ? "c" : language
-        write_grammar(File.read("spec/tree_node_memory_remains.#{ext}.propane"))
+        write_grammar(File.read("spec/ast_node_memory_remains.#{ext}.propane"))
         run_propane(language: language)
-        compile("spec/test_tree_node_memory_remains.#{language}", language: language)
-        results = run_test(language: language)
-        expect(results.stderr).to eq ""
-        expect(results.status).to eq 0
-      end
-
-      it "allows multiple starting rules" do
-    write_grammar <<EOF
-ptype int;
-token a << $$ = 1; >>
-token b << $$ = 2; >>
-token c << $$ = 3; >>
-Start -> a b R;
-Start -> Bs:bs << $$ = $1; >>
-R -> c:c << $$ = $1; >>
-Bs -> << $$ = 0; >>
-Bs -> b:b Bs:bs << $$ = $1 + $2; >>
-start Start R Bs;
-EOF
-        run_propane(language: language)
-        compile("spec/test_starting_rules.#{language}", language: language)
-        results = run_test(language: language)
-        expect(results.stderr).to eq ""
-        expect(results.status).to eq 0
-      end
-
-      it "allows multiple starting rules in tree mode" do
-    write_grammar <<EOF
-tree;
-ptype int;
-token a << $$ = 1; >>
-token b << $$ = 2; >>
-token c << $$ = 3; >>
-Start -> a b R;
-Start -> Bs:bs;
-R -> c:c;
-Bs -> ;
-Bs -> b:b Bs:bs;
-start Start R Bs;
-EOF
-        run_propane(language: language)
-        compile("spec/test_starting_rules_tree.#{language}", language: language)
+        compile("spec/test_ast_node_memory_remains.#{language}", language: language)
         results = run_test(language: language)
         expect(results.stderr).to eq ""
         expect(results.status).to eq 0
       end
 
       if %w[c cpp].include?(language)
-        it "allows a user function to free token node memory in tree mode" do
+        it "allows a user function to free token node memory in AST mode" do
     write_grammar <<EOF
 <<
 static void free_token(Token * token)
@@ -1490,7 +1449,7 @@ static void free_token(Token * token)
     free(token->pvalue);
 }
 >>
-tree;
+ast;
 free_token_node free_token;
 ptype int *;
 token a <<
@@ -1504,7 +1463,7 @@ token b <<
 Start -> a:a b:b;
 EOF
           run_propane(language: language)
-          compile("spec/test_free_tree_token_node_memory.#{language}", language: language)
+          compile("spec/test_free_ast_token_node_memory.#{language}", language: language)
           results = run_test(language: language)
           expect(results.stderr).to eq ""
           expect(results.status).to eq 0

spec/test_ast.c

@@ -33,7 +33,7 @@ int main()
     assert_eq(22, itemsmore->pItem->pToken1->pvalue);
     assert(itemsmore->pItemsMore == NULL);
 
-    p_free_tree(start);
+    p_free_ast(start);
 
     input = "";
     p_context_init(&context, (uint8_t const *)input, strlen(input));
@@ -41,7 +41,7 @@ int main()
     start = p_result(&context);
     assert(start->pItems == NULL);
 
-    p_free_tree(start);
+    p_free_ast(start);
 
     input = "2 1";
     p_context_init(&context, (uint8_t const *)input, strlen(input));
@@ -55,7 +55,7 @@ int main()
     assert(start->pItems->pItem->pDual->pTwo2 == NULL);
     assert(start->pItems->pItem->pDual->pOne1 == NULL);
 
-    p_free_tree(start);
+    p_free_ast(start);
 
     return 0;
 }

spec/test_ast_field_aliases.c

@@ -15,7 +15,7 @@ int main()
     assert_eq(TOKEN_b, start->second->pToken->token);
     assert_eq(TOKEN_c, start->third->pToken->token);
 
-    p_free_tree(start);
+    p_free_ast(start);
 
     return 0;
 }

spec/test_ast_invalid_positions.c

@@ -30,7 +30,7 @@ int main()
     assert_eq(3, start->end_position.row);
     assert_eq(8, start->end_position.col);
 
-    p_free_tree(start);
+    p_free_ast(start);
 
     input = "a\nbb";
     p_context_init(&context, (uint8_t const *)input, strlen(input));
@@ -56,7 +56,7 @@ int main()
     assert_eq(2, start->end_position.row);
     assert_eq(2, start->end_position.col);
 
-    p_free_tree(start);
+    p_free_ast(start);
 
     input = "a\nc\nc";
     p_context_init(&context, (uint8_t const *)input, strlen(input));
@@ -82,7 +82,7 @@ int main()
     assert_eq(3, start->end_position.row);
     assert_eq(1, start->end_position.col);
 
-    p_free_tree(start);
+    p_free_ast(start);
 
     input = "a";
     p_context_init(&context, (uint8_t const *)input, strlen(input));
@@ -104,7 +104,7 @@ int main()
     assert_eq(1, start->end_position.row);
     assert_eq(1, start->end_position.col);
 
-    p_free_tree(start);
+    p_free_ast(start);
 
     return 0;
 }

spec/test_ast_node_memory_remains.c

@@ -412,7 +412,7 @@ int main(int argc, char * argv[])
     }
 
     free(pfds);
-    p_free_tree(pmod);
+    p_free_ast(pmod);
 
     return 0;
 }

spec/test_ast_ps.c

@@ -33,7 +33,7 @@ int main()
     assert_eq(22, itemsmore->pItem->pToken1->pvalue);
     assert(itemsmore->pItemsMore == NULL);
 
-    p_free_tree(start);
+    p_free_ast(start);
 
     input = "";
     p_context_init(&context, (uint8_t const *)input, strlen(input));
@@ -41,7 +41,7 @@ int main()
     start = p_result(&context);
     assert(start->pItems == NULL);
 
-    p_free_tree(start);
+    p_free_ast(start);
 
     input = "2 1";
     p_context_init(&context, (uint8_t const *)input, strlen(input));
@@ -55,7 +55,7 @@ int main()
     assert(start->pItems->pItem->pDual->pTwo2 == NULL);
     assert(start->pItems->pItem->pDual->pOne1 == NULL);
 
-    p_free_tree(start);
+    p_free_ast(start);
 
     return 0;
 }

spec/test_ast_token_positions.c

@@ -43,7 +43,7 @@ int main()
     assert_eq(1, start->end_position.row);
     assert_eq(6, start->end_position.col);
 
-    p_free_tree(start);
+    p_free_ast(start);
 
     input = "\n\n  bb\nc\ncc\n\n     a";
     p_context_init(&context, (uint8_t const *)input, strlen(input));
@@ -82,7 +82,7 @@ int main()
     assert_eq(7, start->end_position.row);
     assert_eq(6, start->end_position.col);
 
-    p_free_tree(start);
+    p_free_ast(start);
 
     return 0;
 }

spec/test_free_ast_token_node_memory.c

@@ -15,5 +15,5 @@ int main()
     assert(start->b != NULL);
     assert(*start->b->pvalue == 2);
 
-    p_free_tree(start);
+    p_free_ast(start);
 }

spec/test_named_optional_rule_component_ast.c

@@ -17,7 +17,7 @@ int main()
     assert(start->pR == NULL);
     assert(start->r == NULL);
 
-    p_free_tree(start);
+    p_free_ast(start);
 
     input = "abcd";
     p_context_init(&context, (uint8_t const *)input, strlen(input));
@@ -33,7 +33,7 @@ int main()
     assert(start->pR == start->r);
     assert_eq(TOKEN_c, start->pR->pToken1->token);
 
-    p_free_tree(start);
+    p_free_ast(start);
 
     input = "bdc";
     p_context_init(&context, (uint8_t const *)input, strlen(input));
@@ -44,7 +44,7 @@ int main()
     assert(start->r != NULL);
     assert_eq(TOKEN_d, start->pR->pToken1->token);
 
-    p_free_tree(start);
+    p_free_ast(start);
 
     return 0;
 }

spec/test_optional_rule_component_ast.c

@@ -16,7 +16,7 @@ int main()
     assert(start->pR3 == NULL);
     assert(start->pR == NULL);
 
-    p_free_tree(start);
+    p_free_ast(start);
 
     input = "abcd";
     p_context_init(&context, (uint8_t const *)input, strlen(input));
@@ -30,7 +30,7 @@ int main()
     assert(start->pR == start->pR3);
     assert_eq(TOKEN_c, start->pR->pToken1->token);
 
-    p_free_tree(start);
+    p_free_ast(start);
 
     input = "bdc";
     p_context_init(&context, (uint8_t const *)input, strlen(input));
@@ -41,7 +41,7 @@ int main()
     assert(start->pR != NULL);
     assert_eq(TOKEN_d, start->pR->pToken1->token);
 
-    p_free_tree(start);
+    p_free_ast(start);
 
     return 0;
 }

spec/test_start_rule_ast.c

@@ -13,7 +13,7 @@ int main()
     assert(top->pToken != NULL);
     assert_eq(TOKEN_hi, top->pToken->token);
 
-    p_free_tree(top);
+    p_free_ast(top);
 
     return 0;
 }

spec/test_starting_rules.c

@@ -1,27 +0,0 @@
-#include "testparser.h"
-#include <assert.h>
-#include <string.h>
-#include "testutils.h"
-
-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);
-    assert_eq(8, result);
-
-    p_context_init(&context, (uint8_t const *)input, strlen(input));
-    assert(p_parse_Bs(&context) == P_SUCCESS);
-    result = p_result_Bs(&context);
-    assert_eq(8, result);
-
-    input = "c";
-    p_context_init(&context, (uint8_t const *)input, strlen(input));
-    assert(p_parse_R(&context) == P_SUCCESS);
-    result = p_result_R(&context);
-    assert_eq(3, result);
-
-    return 0;
-}

spec/test_starting_rules.d

@@ -1,29 +0,0 @@
-import testparser;
-import std.stdio;
-import testutils;
-
-int main()
-{
-    return 0;
-}
-
-unittest
-{
-    string input = "bbbb";
-    p_context_t context;
-    p_context_init(&context, 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);
-    assert(result == 8);
-
-    input = "c";
-    p_context_init(&context, input);
-    assert(p_parse_R(&context) == P_SUCCESS);
-    result = p_result_R(&context);
-    assert(result == 3);
-}

spec/test_starting_rules_tree.c

@@ -1,37 +0,0 @@
-#include "testparser.h"
-#include <assert.h>
-#include <string.h>
-#include "testutils.h"
-
-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);
-    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_init(&context, (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);
-
-    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);
-    assert_not_null(r->c);
-    p_free_tree_R(r);
-
-    return 0;
-}

spec/test_starting_rules_tree.d

@@ -1,36 +0,0 @@
-import testparser;
-import std.stdio;
-import testutils;
-
-int main()
-{
-    return 0;
-}
-
-unittest
-{
-    string input = "bbbb";
-    p_context_t context;
-    p_context_init(&context, 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);
-    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);
-    assert(r.c);
-}

spec/testutils.c

@@ -14,24 +14,6 @@ void assert_eq_size_t_i(size_t expected, size_t actual, char const * file, size_
     }
 }
 
-void assert_ne_size_t_i(size_t expected, size_t actual, char const * file, size_t line)
-{
-    if (expected == actual)
-    {
-        fprintf(stderr, "%s:%lu: expected not %lu, got %lu\n", file, line, expected, actual);
-        assert(false);
-    }
-}
-
-void assert_not_null_i(void * ptr, char const * file, size_t line)
-{
-    if (ptr == NULL)
-    {
-        fprintf(stderr, "%s:%lu: expected not NULL\n", file, line);
-        assert(false);
-    }
-}
-
 void str_init(str_t * str, char const * cs)
 {
     size_t length = strlen(cs);

spec/testutils.h

@@ -5,16 +5,6 @@ void assert_eq_size_t_i(size_t expected, size_t actual, char const * file, size_
 #define assert_eq(expected, actual) \
     assert_eq_size_t_i(expected, actual, __FILE__, __LINE__)
 
-void assert_ne_size_t_i(size_t expected, size_t actual, char const * file, size_t line);
-
-#define assert_ne(expected, actual) \
-    assert_ne_size_t_i(expected, actual, __FILE__, __LINE__)
-
-void assert_not_null_i(void * ptr, char const * file, size_t line);
-
-#define assert_not_null(ptr) \
-    assert_not_null_i(ptr, __FILE__, __LINE__)
-
 typedef struct
 {
     char * cs;