assets/parser.c.erb

@@ -1,4 +1,4 @@
-#include "<%= File.basename(output_file).sub(%r{\.[a-z]+$}, "") %>.h"
+#include "<TBD>.h"
 #include <stdbool.h>
 #include <stdlib.h>
 #include <string.h>
@@ -326,15 +326,15 @@ static lexer_state_id_t check_lexer_transition(uint32_t current_state, uint32_t
 static size_t find_longest_match(<%= @grammar.prefix %>context_t * context,
     lexer_match_info_t * out_match_info, size_t * out_unexpected_input_length)
 {
-    lexer_match_info_t longest_match = {0};
+    lexer_match_info_t longest_match;
-    lexer_match_info_t attempt_match = {0};
+    lexer_match_info_t attempt_match;
     *out_match_info = longest_match;
-    uint32_t current_state = lexer_mode_table[context->mode].state_table_offset;
+    uint32_t current_state = lexer_mode_table[context.mode].state_table_offset;
     for (;;)
     {
-        size_t const input_index = context->input_index + attempt_match.length;
+        size_t const input_index = context.input_index + attempt_match.length;
-        uint8_t const * input = &context->input[input_index];
+        uint8_t const * input = &context.input[input_index];
-        size_t input_length = context->input_length - input_index;
+        size_t input_length = context.input_length - input_index;
         <%= @grammar.prefix %>code_point_t code_point;
         uint8_t code_point_length;
         size_t result = <%= @grammar.prefix %>decode_code_point(input, input_length, &code_point, &code_point_length);
@@ -427,8 +427,8 @@ static size_t find_longest_match(<%= @grammar.prefix %>context_t * context,
  */
 static size_t attempt_lex_token(<%= @grammar.prefix %>context_t * context, <%= @grammar.prefix %>token_info_t * out_token_info)
 {
-    <%= @grammar.prefix %>token_info_t token_info = {0};
+    <%= @grammar.prefix %>token_info_t token_info;
-    token_info.position = context->text_position;
+    token_info.position = context.text_position;
     token_info.token = INVALID_TOKEN_ID;
     *out_token_info = token_info; // TODO: remove
     lexer_match_info_t match_info;
@@ -437,12 +437,12 @@ static size_t attempt_lex_token(<%= @grammar.prefix %>context_t * context, <%= @
     switch (result)
     {
     case P_SUCCESS:
-        <%= @grammar.prefix %>token_t token_to_accept = match_info.accepting_state->token;
+        <%= @grammar.prefix %>token_t token_to_accept = match_info.accepting_state.token;
-        if (match_info.accepting_state->code_id != INVALID_USER_CODE_ID)
+        if (match_info.accepting_state.code_id != INVALID_USER_CODE_ID)
         {
-            uint8_t const * match = &context->input[context->input_index];
+            uint8_t const * match = &context.input[context.input_index];
             <%= @grammar.prefix %>token_t user_code_token = lexer_user_code(context,
-                match_info.accepting_state->code_id, match, match_info.length, &token_info);
+                match_info.accepting_state.code_id, match, match_info.length, &token_info);
             /* An invalid token returned from lexer_user_code() means that the
              * user code did not explicitly return a token. So only override
              * the token to return if the user code does explicitly return a
@@ -454,15 +454,15 @@ static size_t attempt_lex_token(<%= @grammar.prefix %>context_t * context, <%= @
         }
 
         /* Update the input position tracking. */
-        context->input_index += match_info.length;
+        context.input_index += match_info.length;
-        context->text_position.row += match_info.delta_position.row;
+        context.text_position.row += match_info.delta_position.row;
         if (match_info.delta_position.row != 0u)
         {
-            context->text_position.col = match_info.delta_position.col;
+            context.text_position.col = match_info.delta_position.col;
         }
         else
         {
-            context->text_position.col += match_info.delta_position.col;
+            context.text_position.col += match_info.delta_position.col;
         }
 
         if (token_to_accept == INVALID_TOKEN_ID)
@@ -481,15 +481,15 @@ static size_t attempt_lex_token(<%= @grammar.prefix %>context_t * context, <%= @
 
     case P_DECODE_ERROR:
         /* Update the input position tracking. */
-        context->input_index += match_info.length;
+        context.input_index += match_info.length;
-        context->text_position.row += match_info.delta_position.row;
+        context.text_position.row += match_info.delta_position.row;
         if (match_info.delta_position.row != 0u)
         {
-            context->text_position.col = match_info.delta_position.col;
+            context.text_position.col = match_info.delta_position.col;
         }
         else
         {
-            context->text_position.col += match_info.delta_position.col;
+            context.text_position.col += match_info.delta_position.col;
         }
         return result;
 
@@ -531,7 +531,7 @@ size_t <%= @grammar.prefix %>lex(<%= @grammar.prefix %>context_t * context, <%=
  *************************************************************************/
 
 /** Reduce ID type. */
-typedef <%= get_type_for(@parser.reduce_table.size) %> reduce_id_t;
+alias reduce_id_t = <%= get_type_for(@parser.reduce_table.size) %>;
 
 /**
  * A symbol ID can hold either a token ID or a rule set ID.
@@ -539,16 +539,16 @@ typedef <%= get_type_for(@parser.reduce_table.size) %> reduce_id_t;
  * Token IDs and rule set IDs share the same namespace, with rule set IDs
  * beginning after token IDs end.
  */
-typedef <%= get_type_for(@parser.rule_sets.map(&:last).map(&:id).max) %> symbol_id_t;
+alias symbol_id_t = <%= get_type_for(@parser.rule_sets.map(&:last).map(&:id).max) %>;
 
 /** Parser state ID type. */
-typedef <%= get_type_for(@parser.state_table.size) %> parser_state_id_t;
+alias parser_state_id_t = <%= get_type_for(@parser.state_table.size) %>;
 
 /** Parser rule ID type. */
-typedef <%= get_type_for(@grammar.rules.size) %> rule_id_t;
+alias rule_id_t = <%= get_type_for(@grammar.rules.size) %>;
 
 /** Parser shift ID type. */
-typedef <%= get_type_for(@parser.shift_table.size) %> shift_id_t;
+alias shift_id_t = <%= get_type_for(@parser.shift_table.size) %>;
 
 /** Shift table entry. */
 typedef struct
@@ -622,25 +622,25 @@ typedef struct
 } state_value_t;
 
 /** Parser shift table. */
-static const shift_t parser_shift_table[] = {
+static immutable shift_t[] parser_shift_table = [
 <%   @parser.shift_table.each do |shift| %>
-    {<%= shift[:symbol_id] %>u, <%= shift[:state_id] %>u},
+    shift_t(<%= shift[:symbol_id] %>u, <%= shift[:state_id] %>u),
 <%   end %>
-};
+];
 
 /** Parser reduce table. */
-static const reduce_t parser_reduce_table[] = {
+static immutable reduce_t[] parser_reduce_table = [
 <%   @parser.reduce_table.each do |reduce| %>
-    {<%= reduce[:token_id] %>u, <%= reduce[:rule_id] %>u, <%= reduce[:rule_set_id] %>u, <%= reduce[:n_states] %>u},
+    reduce_t(<%= reduce[:token_id] %>u, <%= reduce[:rule_id] %>u, <%= reduce[:rule_set_id] %>u, <%= reduce[:n_states] %>u),
 <%   end %>
-};
+];
 
 /** Parser state table. */
-static const parser_state_t parser_state_table[] = {
+static immutable parser_state_t[] parser_state_table = [
 <%   @parser.state_table.each do |state| %>
-    {<%= state[:shift_index] %>u, <%= state[:n_shifts] %>u, <%= state[:reduce_index] %>u, <%= state[:n_reduces] %>u},
+    parser_state_t(<%= state[:shift_index] %>u, <%= state[:n_shifts] %>u, <%= state[:reduce_index] %>u, <%= state[:n_reduces] %>u),
 <%   end %>
-};
+];
 
 /* state_values stack functionality */
 
@@ -658,7 +658,7 @@ typedef struct
  * @param stack
  *   state_values stack structure.
  */
-static void state_values_stack_init(state_values_stack_t * stack)
+void state_values_stack_init(state_values_stack_t * stack)
 {
     const size_t initial_capacity = 10u;
     stack->length = 0u;
@@ -666,35 +666,13 @@ static void state_values_stack_init(state_values_stack_t * stack)
     stack->entries = (state_value_t *)malloc(initial_capacity * sizeof(state_value_t));
 }
 
-/**
- * Index a state_values stack.
- *
- * @param stack
- *   state_values stack structure.
- * @param index
- *   Index to the stack.
- *
- * @return Pointer to the state value structure at the given index.
- */
-static state_value_t * state_values_stack_index(state_values_stack_t * stack, int index)
-{
-    if (index >= 0)
-    {
-        return &stack->entries[index];
-    }
-    else
-    {
-        return &stack->entries[stack->length - (size_t)(unsigned int)(-index)];
-    }
-}
-
 /**
  * Push a new state_value to the state_values stack.
  *
  * @param stack
  *   state_values stack structure.
  */
-static void state_values_stack_push(state_values_stack_t * stack)
+void state_values_stack_push(state_values_stack_t * stack)
 {
     size_t const current_capacity = stack->capacity;
     size_t const current_length = stack->length;
@@ -702,7 +680,7 @@ static void state_values_stack_push(state_values_stack_t * stack)
     {
         size_t const new_capacity = current_capacity * 2u;
         state_value_t * new_entries = malloc(new_capacity * sizeof(state_value_t));
-        memcpy(new_entries, stack->entries, current_length * sizeof(state_value_t));
+        memcpy(new_entries, stack->entries, current_length * sizeof(state_value_t);
         free(stack->entries);
         stack->capacity = new_capacity;
         stack->entries = new_entries;
@@ -711,30 +689,6 @@ static void state_values_stack_push(state_values_stack_t * stack)
     stack->length = current_length + 1u;
 }
 
-/**
- * Pop entries from a state_values stack.
- *
- * @param stack
- *   state_values stack structure.
- * @param n
- *   Number of states to pop.
- */
-static void state_values_stack_pop(state_values_stack_t * stack, size_t n)
-{
-    stack->length -= n;
-}
-
-/**
- * Free memory for a state_values stack structure.
- *
- * @param stack
- *   state_values stack structure.
- */
-static void state_values_stack_free(state_values_stack_t * stack)
-{
-     free(stack->entries);
-}
-
 /**
  * Execute user code associated with a parser rule.
  *
@@ -742,9 +696,9 @@ static void state_values_stack_free(state_values_stack_t * stack)
  *
  * @return Parse value.
  */
-static <%= @grammar.prefix %>value_t parser_user_code(uint32_t rule, state_values_stack_t * statevalues, uint32_t n_states)
+static <%= @grammar.prefix %>value_t parser_user_code(uint32_t rule, state_value_t[] statevalues, uint32_t n_states)
 {
-    <%= @grammar.prefix %>value_t _pvalue = {0};
+    <%= @grammar.prefix %>value_t _pvalue;
 
     switch (rule)
     {
@@ -821,7 +775,7 @@ static size_t check_reduce(size_t state_id, <%= @grammar.prefix %>token_t token)
  *   can be accessed with <%= @grammar.prefix %>result().
  * @retval P_UNEXPECTED_TOKEN
  *   An unexpected token was encountered that does not match any grammar rule.
- *   The value context->token holds the unexpected token.
+ *   The value context.token holds the unexpected token.
  * @reval P_DECODE_ERROR
  *   The decoder encountered invalid text encoding.
  * @reval P_UNEXPECTED_INPUT
@@ -831,12 +785,9 @@ 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;
+    state_value_t[] statevalues = new state_value_t[](1);
     size_t reduced_rule_set = INVALID_ID;
     <%= @grammar.prefix %>value_t reduced_parser_value;
-    state_values_stack_init(&statevalues);
-    state_values_stack_push(&statevalues);
-    size_t result;
     for (;;)
     {
         if (token == INVALID_TOKEN_ID)
@@ -844,56 +795,53 @@ size_t <%= @grammar.prefix %>parse(<%= @grammar.prefix %>context_t * context)
             size_t lexer_result = <%= @grammar.prefix %>lex(context, &token_info);
             if (lexer_result != P_SUCCESS)
             {
-                result = lexer_result;
+                return lexer_result;
-                break;
             }
             token = token_info.token;
         }
         size_t shift_state = INVALID_ID;
         if (reduced_rule_set != INVALID_ID)
         {
-            shift_state = check_shift(state_values_stack_index(&statevalues, -1)->state_id, reduced_rule_set);
+            shift_state = check_shift(statevalues[$-1].state_id, reduced_rule_set);
         }
         if (shift_state == INVALID_ID)
         {
-            shift_state = check_shift(state_values_stack_index(&statevalues, -1)->state_id, token);
+            shift_state = check_shift(statevalues[$-1].state_id, token);
             if ((shift_state != INVALID_ID) && (token == TOKEN___EOF))
             {
                 /* Successful parse. */
-                context->parse_result = state_values_stack_index(&statevalues, -1)->pvalue;
+                context.parse_result = statevalues[$-1].pvalue;
-                result = P_SUCCESS;
+                return P_SUCCESS;
-                break;
             }
         }
         if (shift_state != INVALID_ID)
         {
             /* We have something to shift. */
-            state_values_stack_push(&statevalues);
+            statevalues ~= state_value_t(shift_state);
-            state_values_stack_index(&statevalues, -1)->state_id = shift_state;
             if (reduced_rule_set == INVALID_ID)
             {
                 /* We shifted a token, mark it consumed. */
                 token = INVALID_TOKEN_ID;
-                state_values_stack_index(&statevalues, -1)->pvalue = token_info.pvalue;
+                statevalues[$-1].pvalue = token_info.pvalue;
             }
             else
             {
                 /* We shifted a RuleSet. */
-                state_values_stack_index(&statevalues, -1)->pvalue = reduced_parser_value;
+                statevalues[$-1].pvalue = reduced_parser_value;
-                <%= @grammar.prefix %>value_t new_parse_result = {0};
+                <%= @grammar.prefix %>value_t new_parse_result;
                 reduced_parser_value = new_parse_result;
                 reduced_rule_set = INVALID_ID;
             }
             continue;
         }
 
-        size_t reduce_index = check_reduce(state_values_stack_index(&statevalues, -1)->state_id, token);
+        size_t reduce_index = check_reduce(statevalues[$-1].state_id, token);
         if (reduce_index != INVALID_ID)
         {
             /* We have something to reduce. */
-            reduced_parser_value = parser_user_code(parser_reduce_table[reduce_index].rule, &statevalues, parser_reduce_table[reduce_index].n_states);
+            reduced_parser_value = parser_user_code(parser_reduce_table[reduce_index].rule, statevalues, parser_reduce_table[reduce_index].n_states);
             reduced_rule_set = parser_reduce_table[reduce_index].rule_set;
-            state_values_stack_pop(&statevalues, parser_reduce_table[reduce_index].n_states);
+            statevalues.length -= parser_reduce_table[reduce_index].n_states;
             continue;
         }
 
@@ -902,13 +850,10 @@ size_t <%= @grammar.prefix %>parse(<%= @grammar.prefix %>context_t * context)
          * the context text position to point to the token rather than the text
          * after it, so that if the caller wants to report the error position,
          * it will point to the correct position of the unexpected token. */
-        context->text_position = token_info.position;
+        context.text_position = token_info.position;
-        context->token = token;
+        context.token = token;
-        result = P_UNEXPECTED_TOKEN;
+        return P_UNEXPECTED_TOKEN;
-        break;
     }
-    state_values_stack_free(&statevalues);
-    return result;
 }
 
 /**
@@ -921,7 +866,7 @@ size_t <%= @grammar.prefix %>parse(<%= @grammar.prefix %>context_t * context)
  */
 <%= start_rule_type[1] %> <%= @grammar.prefix %>result(<%= @grammar.prefix %>context_t * context)
 {
-    return context->parse_result.v_<%= start_rule_type[0] %>;
+    return context.parse_result.v_<%= start_rule_type[0] %>;
 }
 
 /**
@@ -934,5 +879,5 @@ size_t <%= @grammar.prefix %>parse(<%= @grammar.prefix %>context_t * context)
  */
 <%= @grammar.prefix %>position_t <%= @grammar.prefix %>position(<%= @grammar.prefix %>context_t * context)
 {
-    return context->text_position;
+    return context.text_position;
 }

assets/parser.h.erb

@@ -8,7 +8,6 @@
 #define PROPANE_PARSER_H
 
 #include <stdint.h>
-#include <stddef.h>
 
 /**************************************************************************
  * Public types
@@ -88,9 +87,6 @@ typedef struct
     /** Input text. */
     uint8_t const * input;
 
-    /** Input text length. */
-    size_t input_length;
-
     /** Input text index (byte offset). */
     size_t input_index;
 
@@ -109,17 +105,4 @@ typedef struct
     <%= @grammar.prefix %>token_t token;
 } <%= @grammar.prefix %>context_t;
 
-void <%= @grammar.prefix %>context_init(<%= @grammar.prefix %>context_t * context, uint8_t const * input, size_t input_length);
-
-size_t <%= @grammar.prefix %>decode_code_point(uint8_t const * input, size_t input_length,
-        <%= @grammar.prefix %>code_point_t * out_code_point, uint8_t * out_code_point_length);
-
-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);
-
-<%= start_rule_type[1] %> <%= @grammar.prefix %>result(<%= @grammar.prefix %>context_t * context);
-
-<%= @grammar.prefix %>position_t <%= @grammar.prefix %>position(<%= @grammar.prefix %>context_t * context);
-
 #endif

lib/propane/generator.rb

@@ -11,28 +11,15 @@ class Propane
         @log = StringIO.new
       end
       @classname = @grammar.classname || File.basename(output_file).sub(%r{[^a-zA-Z0-9].*}, "").capitalize
-      @language =
-        if output_file =~ /\.([a-z]+)$/
-          $1
-        else
-          "d"
-        end
       process_grammar!
     end
 
     def generate
-      extensions = [@language]
+      erb = ERB.new(File.read(File.join(File.dirname(File.expand_path(__FILE__)), "../../assets/parser.d.erb")), trim_mode: "<>")
-      if @language == "c"
-        extensions += %w[h]
-      end
-      extensions.each do |extension|
-        erb = ERB.new(File.read(File.join(File.dirname(File.expand_path(__FILE__)), "../../assets/parser.#{extension}.erb")), trim_mode: "<>")
-        output_file = @output_file.sub(%r{\.[a-z]+$}, ".#{extension}")
       result = erb.result(binding.clone)
-        File.open(output_file, "wb") do |fh|
+      File.open(@output_file, "wb") do |fh|
         fh.write(result)
       end
-      end
       @log.close
     end
 
@@ -204,13 +191,8 @@ class Propane
         end
         code = code.gsub(/\$(\d+)/) do |match|
           index = $1.to_i
-          case @language
-          when "c"
-            "state_value_stack_index(statevalues, -1 - (int)n_states + #{index})->pvalue.v_#{rule.components[index - 1].ptypename}"
-          when "d"
           "statevalues[$-1-n_states+#{index}].pvalue.v_#{rule.components[index - 1].ptypename}"
         end
-        end
       else
         code = code.gsub(/\$\$/) do |match|
           "out_token_info.pvalue.v_#{pattern.ptypename}"
@@ -221,14 +203,9 @@ class Propane
           unless mode_id
             raise Error.new("Lexer mode '#{mode_name}' not found")
           end
-          case @language
-          when "c"
-            "context->mode = #{mode_id}u"
-          when "d"
           "context.mode = #{mode_id}u"
         end
       end
-      end
       code
     end
 
@@ -252,28 +229,13 @@ class Propane
     #   Type.
     def get_type_for(max)
       if max <= 0xFF
-        case @language
-        when "c"
-          "uint8_t"
-        when "d"
         "ubyte"
-        end
       elsif max <= 0xFFFF
-        case @language
-        when "c"
-          "uint16_t"
-        when "d"
         "ushort"
-        end
-      else
-        case @language
-        when "c"
-          "uint32_t"
       else
         "uint"
       end
     end
-    end
 
   end
 

spec/propane_spec.rb

@@ -11,7 +11,7 @@ describe Propane do
 
   def build_parser(options = {})
     options[:name] ||= ""
-    command = %W[./propane.sh spec/run/testparser#{options[:name]}.propane spec/run/testparser#{options[:name]}.#{options[:language]} --log spec/run/testparser#{options[:name]}.log]
+    command = %W[./propane.sh spec/run/testparser#{options[:name]}.propane spec/run/testparser#{options[:name]}.d --log spec/run/testparser#{options[:name]}.log]
     if (options[:capture])
       stdout, stderr, status = Open3.capture3(*command)
       Results.new(stdout, stderr, status)
@@ -25,14 +25,9 @@ describe Propane do
     test_files = Array(test_files)
     options[:parsers] ||= [""]
     parsers = options[:parsers].map do |name|
-      "spec/run/testparser#{name}.#{options[:language]}"
+      "spec/run/testparser#{name}.d"
     end
-    case options[:language]
-    when "c"
-      result = system(*%w[gcc -Wall -o spec/run/testparser -Ispec -Ispec/run], *parsers, *test_files)
-    when "d"
     result = system(*%w[ldc2 --unittest -of spec/run/testparser -Ispec], *parsers, *test_files, "spec/testutils.d")
-    end
     expect(result).to be_truthy
   end
 
@@ -74,10 +69,6 @@ describe Propane do
     FileUtils.mkdir_p("spec/run")
   end
 
-  %w[d c].each do |language|
-
-    context "#{language.upcase} language" do
-
   it "generates a lexer" do
     write_grammar <<EOF
 token int /\\d+/;
@@ -90,8 +81,8 @@ Foo -> int <<
 Foo -> plus <<
 >>
 EOF
-        build_parser(language: language)
+    build_parser
-        compile("spec/test_lexer.#{language}", language: language)
+    compile("spec/test_lexer.d")
     results = run
     expect(results.stderr).to eq ""
     expect(results.status).to eq 0
@@ -113,8 +104,8 @@ Start -> int <<
   $$ = $1;
 >>
 EOF
-        build_parser(language: language)
+    build_parser
-        compile("spec/test_lexer_unknown_character.#{language}", language: language)
+    compile("spec/test_lexer_unknown_character.d")
     results = run
     expect(results.stderr).to eq ""
     expect(results.status).to eq 0
@@ -133,7 +124,7 @@ E -> B;
 B -> zero;
 B -> one;
 EOF
-        build_parser(language: language)
+    build_parser
   end
 
   it "generates a parser that does basic math - user guide example" do
@@ -188,8 +179,8 @@ E4 -> lparen E1 rparen <<
   $$ = $2;
 >>
 EOF
-        build_parser(language: language)
+    build_parser
-        compile("spec/test_basic_math_grammar.#{language}", language: language)
+    compile("spec/test_basic_math_grammar.d")
     results = run
     expect(results.stderr).to eq ""
     expect(results.status).to eq 0
@@ -202,7 +193,7 @@ Start -> E;
 E -> one E;
 E -> one;
 EOF
-        build_parser(language: language)
+    build_parser
   end
 
   it "distinguishes between multiple identical rules with lookahead symbol" do
@@ -214,8 +205,8 @@ Start -> R2 b;
 R1 -> a b;
 R2 -> a b;
 EOF
-        build_parser(language: language)
+    build_parser
-        compile("spec/test_parser_identical_rules_lookahead.#{language}", language: language)
+    compile("spec/test_parser_identical_rules_lookahead.d")
     results = run
     expect(results.status).to eq 0
   end
@@ -229,8 +220,8 @@ Start -> a R1;
 Start -> b R1;
 R1 -> b;
 EOF
-        build_parser(language: language)
+    build_parser
-        compile("spec/test_parser_rule_from_multiple_states.#{language}", language: language)
+    compile("spec/test_parser_rule_from_multiple_states.d")
     results = run
     expect(results.status).to eq 0
   end
@@ -248,8 +239,8 @@ Start -> Abcs def;
 Abcs -> ;
 Abcs -> abc Abcs;
 EOF
-        build_parser(language: language)
+    build_parser
-        compile("spec/test_user_code.#{language}", language: language)
+    compile("spec/test_user_code.d")
     results = run
     expect(results.status).to eq 0
     verify_lines(results.stdout, [
@@ -272,8 +263,8 @@ token abc;
 >>
 Start -> abc;
 EOF
-        build_parser(language: language)
+    build_parser
-        compile("spec/test_pattern.#{language}", language: language)
+    compile("spec/test_pattern.d")
     results = run
     expect(results.status).to eq 0
     verify_lines(results.stdout, [
@@ -300,8 +291,8 @@ token abc;
 >>
 Start -> abc;
 EOF
-        build_parser(language: language)
+    build_parser
-        compile("spec/test_return_token_from_pattern.#{language}", language: language)
+    compile("spec/test_return_token_from_pattern.d")
     results = run
     expect(results.status).to eq 0
     verify_lines(results.stdout, [
@@ -333,8 +324,8 @@ string: /"/ <<
 >>
 Start -> abc string def;
 EOF
-        build_parser(language: language)
+    build_parser
-        compile("spec/test_lexer_modes.#{language}", language: language)
+    compile("spec/test_lexer_modes.d")
     results = run
     expect(results.status).to eq 0
     verify_lines(results.stdout, [
@@ -364,8 +355,8 @@ B -> b <<
   writeln("B!");
 >>
 EOF
-        build_parser(language: language)
+    build_parser
-        compile("spec/test_parser_rule_user_code.#{language}", language: language)
+    compile("spec/test_parser_rule_user_code.d")
     results = run
     expect(results.status).to eq 0
     verify_lines(results.stdout, [
@@ -389,8 +380,8 @@ As -> As a <<
   $$ = $1 + 1u;
 >>
 EOF
-        build_parser(language: language)
+    build_parser
-        compile("spec/test_parsing_lists.#{language}", language: language)
+    compile("spec/test_parsing_lists.d")
     results = run
     expect(results.status).to eq 0
     expect(results.stderr).to eq ""
@@ -410,7 +401,7 @@ Start -> b E d;
 E -> e;
 F -> e;
 EOF
-        results = build_parser(capture: true, language: language)
+    results = build_parser(capture: true)
     expect(results.status).to_not eq 0
     expect(results.stderr).to match %r{reduce/reduce conflict.*\(E\).*\(F\)}
   end
@@ -425,8 +416,8 @@ token id /[a-zA-Z_][a-zA-Z0-9_]*/ <<
 >>
 Start -> id;
 EOF
-        build_parser(language: language)
+    build_parser
-        compile("spec/test_lexer_match_text.#{language}", language: language)
+    compile("spec/test_lexer_match_text.d")
     results = run
     expect(results.status).to eq 0
     verify_lines(results.stdout, [
@@ -445,8 +436,8 @@ Start -> word <<
   $$ = $1;
 >>
 EOF
-        build_parser(language: language)
+    build_parser
-        compile("spec/test_lexer_result_value.#{language}", language: language)
+    compile("spec/test_lexer_result_value.d")
     results = run
     expect(results.stderr).to eq ""
     expect(results.status).to eq 0
@@ -460,8 +451,8 @@ drop /\\s+/;
 Start -> a num Start;
 Start -> a num;
 EOF
-        build_parser(language: language)
+    build_parser
-        compile("spec/test_error_positions.#{language}", language: language)
+    compile("spec/test_error_positions.d")
     results = run
     expect(results.stderr).to eq ""
     expect(results.status).to eq 0
@@ -469,8 +460,8 @@ EOF
 
   it "allows creating a JSON parser" do
     write_grammar(File.read("spec/json_parser.propane"))
-        build_parser(language: language)
+    build_parser
-        compile(["spec/test_parsing_json.#{language}", "spec/json_types.#{language}"], language: language)
+    compile(["spec/test_parsing_json.d", "spec/json_types.d"])
   end
 
   it "allows generating multiple parsers in the same program" do
@@ -481,19 +472,17 @@ token num /\\d+/;
 drop /\\s+/;
 Start -> a num;
 EOF
-        build_parser(name: "myp1", language: language)
+    build_parser(name: "myp1")
     write_grammar(<<EOF, name: "myp2")
 prefix myp2_;
 token b;
 token c;
 Start -> b c b;
 EOF
-        build_parser(name: "myp2", language: language)
+    build_parser(name: "myp2")
-        compile("spec/test_multiple_parsers.#{language}", parsers: %w[myp1 myp2], language: language)
+    compile("spec/test_multiple_parsers.d", parsers: %w[myp1 myp2])
     results = run
     expect(results.stderr).to eq ""
     expect(results.status).to eq 0
   end
-    end
-  end
 end

spec/test_lexer.c

@@ -1,92 +0,0 @@
-#include "testparser.h"
-#include <assert.h>
-#include <string.h>
-
-int main()
-{
-    size_t result;
-    p_code_point_t code_point;
-    uint8_t code_point_length;
-
-    result = p_decode_code_point((uint8_t const *)"5", 1u, &code_point, &code_point_length);
-    assert(result == P_SUCCESS);
-    assert(code_point == '5');
-    assert(code_point_length == 1u);
-
-    result = p_decode_code_point((uint8_t const *)"", 0u, &code_point, &code_point_length);
-    assert(result == P_EOF);
-
-    result = p_decode_code_point((uint8_t const *)"\xC2\xA9", 2u, &code_point, &code_point_length);
-    assert(result == P_SUCCESS);
-    assert(code_point == 0xA9u);
-    assert(code_point_length == 2u);
-
-    result = p_decode_code_point((uint8_t const *)"\xf0\x9f\xa7\xa1", 4u, &code_point, &code_point_length);
-    assert(result == P_SUCCESS);
-    assert(code_point == 0x1F9E1u);
-    assert(code_point_length == 4u);
-
-    result = p_decode_code_point((uint8_t const *)"\xf0\x9f\x27", 3u, &code_point, &code_point_length);
-    assert(result == P_DECODE_ERROR);
-
-    result = p_decode_code_point((uint8_t const *)"\xf0\x9f\xa7\xFF", 4u, &code_point, &code_point_length);
-    assert(result == P_DECODE_ERROR);
-
-    result = p_decode_code_point((uint8_t const *)"\xfe", 1u, &code_point, &code_point_length);
-    assert(result == P_DECODE_ERROR);
-
-
-    p_token_info_t token_info;
-    char const * input = "5 + 4 * \n677 + 567";
-    p_context_t context;
-    p_context_init(&context, (uint8_t const *)input, strlen(input));
-    assert(p_lex(&context, &token_info) == P_SUCCESS);
-    assert(token_info.position.row == 0u);
-    assert(token_info.position.col == 0u);
-    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.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.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.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.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.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.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.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.length == 0u);
-    assert(token_info.token == TOKEN___EOF);
-
-    return 0;
-}