treetop 1.1.4 → 1.2.0

data/lib/treetop/compiler/metagrammar.treetop

@@ -297,19 +297,31 @@ module Treetop
       end
 
       rule terminal
-        single_quoted_string / double_quoted_string / character_class / anything_symbol
+        quoted_string / character_class / anything_symbol
+      end
+      
+      rule quoted_string
+        (single_quoted_string / double_quoted_string) {
+          def string
+            super.text_value
+          end
+        }
       end
       
       rule double_quoted_string
-        '"' (!'"' ("\\\\" / '\"' / .))* '"' <Terminal>
+        '"' string:(!'"' ("\\\\" / '\"' / .))* '"' <Terminal>
       end
 
       rule single_quoted_string
-        "'" (!"'" ("\\\\" / "\\'" / .))* "'" <Terminal>
+        "'" string:(!"'" ("\\\\" / "\\'" / .))* "'" <Terminal>
       end
 
       rule character_class
-        '[' (!']' ('\]'/.))+ ']' <CharacterClass>
+        '[' characters:(!']' ('\]'/.))+ ']' <CharacterClass> {
+          def characters
+            super.text_value
+          end
+        }
       end
 
       rule anything_symbol
@@ -377,8 +389,16 @@ module Treetop
       end
 
       rule space
-        [ \t\n\r]+
+        (white / comment_to_eol)+
+      end
+
+      rule comment_to_eol
+        '#' (!"\n" .)+
+      end
+
+      rule white
+        [ \t\n\r]
       end
     end
   end
-end
+end

data/lib/treetop/compiler/node_classes/anything_symbol.rb

@@ -3,8 +3,16 @@ module Treetop
     class AnythingSymbol < AtomicExpression
       def compile(address, builder, parent_expression = nil)
         super
-        assign_result "parse_anything(#{node_class_name}#{optional_arg(inline_module_name)})"
+        builder.if__ "index < input_length" do
+          assign_result "(#{node_class_name}).new(input, index...(index + 1))"
+          extend_result_with_inline_module
+          builder << "@index += 1"
+        end
+        builder.else_ do
+          builder << 'terminal_parse_failure("any character")'
+          assign_result 'nil'
+        end
       end
     end
   end
-end
+end

data/lib/treetop/compiler/node_classes/atomic_expression.rb

@@ -4,6 +4,10 @@ module Treetop
       def inline_modules
         []
       end
+      
+      def single_quote(string)
+        "'#{string.gsub(/'$/, "\\'")}'"
+      end
     end
   end
 end

data/lib/treetop/compiler/node_classes/character_class.rb

@@ -3,7 +3,16 @@ module Treetop
     class CharacterClass < AtomicExpression
       def compile(address, builder, parent_expression = nil)
         super
-        assign_result "parse_char_class(/#{text_value}/, '#{elements[1].text_value.gsub(/'$/, "\\\\'")}', #{node_class_name}#{optional_arg(inline_module_name)})"
+        
+        builder.if__ "input.index(/#{text_value}/, index) == index" do
+          assign_result "(#{node_class_name}).new(input, index...(index + 1))"
+          extend_result_with_inline_module
+          builder << "@index += 1"
+        end
+        builder.else_ do
+          "terminal_parse_failure(#{single_quote(characters)})"
+          assign_result 'nil'
+        end
       end
     end
   end

data/lib/treetop/compiler/node_classes/choice.rb

@@ -4,7 +4,7 @@ module Treetop
       def compile(address, builder, parent_expression = nil)
         super
         begin_comment(self)
-        use_vars :result, :start_index, :nested_results
+        use_vars :result, :start_index
         compile_alternatives(alternatives)
         end_comment(self)
       end
@@ -12,17 +12,15 @@ module Treetop
       def compile_alternatives(alternatives)
         obtain_new_subexpression_address
         alternatives.first.compile(subexpression_address, builder)
-        accumulate_nested_result
         builder.if__ subexpression_success? do
           assign_result subexpression_result_var
           extend_result_with_declared_module
           extend_result_with_inline_module
-          builder << "#{subexpression_result_var}.update_nested_results(#{nested_results_var})"
         end
         builder.else_ do
           if alternatives.size == 1
             reset_index
-            assign_failure start_index_var, nested_results_var
+            assign_failure start_index_var
           else
             compile_alternatives(alternatives[1..-1])
           end

data/lib/treetop/compiler/node_classes/parsing_expression.rb

@@ -41,11 +41,7 @@ module Treetop
       def accumulator_var
         var(:accumulator)
       end
-    
-      def nested_results_var
-        var(:nested_results)
-      end
-    
+      
       def start_index_var
         var(:start_index)
       end
@@ -55,17 +51,13 @@ module Treetop
       end
     
       def subexpression_success?
-        subexpression_result_var + ".success?"
+        subexpression_result_var
       end
     
       def obtain_new_subexpression_address
         @subexpression_address = builder.next_address
       end
-    
-      def accumulate_nested_result
-        builder.accumulate nested_results_var, subexpression_result_var
-      end
-    
+        
       def accumulate_subexpression_result
         builder.accumulate accumulator_var, subexpression_result_var
       end
@@ -91,11 +83,11 @@ module Treetop
       end
       
       def epsilon_node
-        "SyntaxNode.new(input, index...index, #{subexpression_result_var}.nested_failures)"
+        "SyntaxNode.new(input, index...index)"
       end
       
-      def assign_failure(start_index_var, nested_results_var)
-        assign_result("ParseFailure.new(input, #{start_index_var}, #{nested_results_var})")
+      def assign_failure(start_index_var)
+        assign_result("nil")
       end
     
       def var_initialization
@@ -117,7 +109,6 @@ module Treetop
         case var_symbol
         when :result then "r#{address}"
         when :accumulator then "s#{address}"
-        when :nested_results then "nr#{address}"
         when :start_index then "i#{address}"
         else raise "Unknown var symbol #{var_symbol}."
         end
@@ -125,7 +116,7 @@ module Treetop
     
       def init_value(var_symbol)
         case var_symbol
-        when :accumulator, :nested_results then '[]'
+        when :accumulator then '[]'
         when :start_index then 'index'
         else nil
         end
@@ -144,4 +135,4 @@ module Treetop
       end
     end
   end
-end
+end

data/lib/treetop/compiler/node_classes/parsing_rule.rb

@@ -32,9 +32,9 @@ module Treetop
       end
       
       def generate_cache_lookup(builder)
-        builder.assign 'cached', "node_cache[:#{name}][index]"
-        builder.if_ 'cached' do
-          builder << '@index = cached.interval.end'
+        builder.if_ "node_cache[:#{name}].has_key?(index)" do
+          builder.assign 'cached', "node_cache[:#{name}][index]"
+          builder << '@index = cached.interval.end if cached'
           builder << 'return cached'
         end
       end

data/lib/treetop/compiler/node_classes/predicate.rb

@@ -13,7 +13,7 @@ module Treetop
       end
       
       def assign_failure
-        super(start_index_var, "#{subexpression_result_var}.nested_failures")
+        super(start_index_var)
       end
       
       def assign_success

data/lib/treetop/compiler/node_classes/repetition.rb

@@ -5,12 +5,11 @@ module Treetop
         super
         repeated_expression = parent_expression.atomic
         begin_comment(parent_expression)
-        use_vars :result, :accumulator, :nested_results, :start_index
+        use_vars :result, :accumulator, :start_index
 
         builder.loop do
           obtain_new_subexpression_address
           repeated_expression.compile(subexpression_address, builder)
-          accumulate_nested_result
           builder.if__ subexpression_success? do
             accumulate_subexpression_result
           end
@@ -25,7 +24,7 @@ module Treetop
       end
       
       def assign_and_extend_result
-        assign_result "#{node_class_name}.new(input, #{start_index_var}...index, #{accumulator_var}, #{nested_results_var})"
+        assign_result "#{node_class_name}.new(input, #{start_index_var}...index, #{accumulator_var})"
         extend_result_with_inline_module
       end
     end
@@ -44,7 +43,7 @@ module Treetop
         super
         builder.if__ "#{accumulator_var}.empty?" do
           reset_index
-          assign_failure start_index_var, nested_results_var
+          assign_failure start_index_var
         end
         builder.else_ do
           assign_and_extend_result

data/lib/treetop/compiler/node_classes/sequence.rb

@@ -4,16 +4,16 @@ module Treetop
       def compile(address, builder, parent_expression = nil)
         super
         begin_comment(self)
-        use_vars :result, :start_index, :accumulator, :nested_results
+        use_vars :result, :start_index, :accumulator
         compile_sequence_elements(sequence_elements)
-        builder.if__ "#{accumulator_var}.last.success?" do
+        builder.if__ "#{accumulator_var}.last" do
           assign_result "(#{node_class_name}).new(input, #{start_index_var}...index, #{accumulator_var})"
           extend_result sequence_element_accessor_module_name if sequence_element_accessor_module_name
           extend_result_with_inline_module
         end
         builder.else_ do
           reset_index
-          assign_failure start_index_var, accumulator_var
+          assign_failure start_index_var
         end
         end_comment(self)
       end
@@ -65,4 +65,4 @@ module Treetop
       end
     end
   end
-end
+end

data/lib/treetop/compiler/node_classes/terminal.rb

@@ -3,7 +3,17 @@ module Treetop
     class Terminal < AtomicExpression
       def compile(address, builder, parent_expression = nil)
         super
-        assign_result "parse_terminal(#{text_value}, #{node_class_name}#{optional_arg(inline_module_name)})"
+        string_length = eval(text_value).length
+        
+        builder.if__ "input.index(#{text_value}, index) == index" do
+          assign_result "(#{node_class_name}).new(input, index...(index + #{string_length}))"
+          extend_result_with_inline_module
+          builder << "@index += #{string_length}"
+        end
+        builder.else_ do
+          builder << "terminal_parse_failure(#{text_value})"
+          assign_result 'nil'
+        end
       end
     end
  end

data/lib/treetop/compiler/ruby_builder.rb

@@ -16,7 +16,7 @@ module Treetop
       end
 
       def newline
-        ruby << indent << "\n"
+        ruby << "\n"
       end
       
       def indented(depth = 2)
@@ -110,4 +110,4 @@ module Treetop
       end
     end
   end
-end
+end

data/lib/treetop/ruby_extensions.rb

@@ -1,2 +1,2 @@
 dir = File.dirname(__FILE__)
-require "#{dir}/ruby_extensions/string"
+require "#{dir}/ruby_extensions/string"

data/lib/treetop/runtime.rb

@@ -1,9 +1,6 @@
 dir = File.dirname(__FILE__)
 require "#{dir}/runtime/compiled_parser"
-require "#{dir}/runtime/parse_result"
 require "#{dir}/runtime/syntax_node"
-require "#{dir}/runtime/parse_failure"
 require "#{dir}/runtime/node_cache"
 require "#{dir}/runtime/parse_cache"
-require "#{dir}/runtime/parse_failure"
 require "#{dir}/runtime/terminal_parse_failure"

data/lib/treetop/runtime/compiled_parser.rb

@@ -3,11 +3,11 @@ module Treetop
     class CompiledParser
       include Treetop::Runtime
       
-      attr_accessor :consume_all_input
+      attr_reader :input, :index, :terminal_failures, :max_terminal_failure_index
       attr_writer :root
+      attr_accessor :consume_all_input
       alias :consume_all_input? :consume_all_input
-      attr_reader :input, :index
-
+      
       def initialize
         self.consume_all_input = true
       end
@@ -16,50 +16,52 @@ module Treetop
         prepare_to_parse(input)
         @index = options[:index] if options[:index]
         result = send("_nt_#{root}")
-        if consume_all_input? && index != input.size
-          return ParseFailure.new(input, index, result.nested_failures)
-        else
-          return result
-        end
+        return nil if (consume_all_input? && index != input.size)
+        return result
       end
-      
+
+      def failure_index
+        max_terminal_failure_index
+      end
+
+      def failure_line
+        terminal_failures && input.line_of(failure_index)
+      end
+
+      def failure_column
+        terminal_failures && input.column_of(failure_index)
+      end
+
+      def failure_reason
+        return nil unless (tf = terminal_failures) && tf.size > 0
+	"Expected " +
+	  (tf.size == 1 ?
+	   tf[0].expected_string :
+           "one of #{tf.map{|f| f.expected_string}.uniq*', '}"
+	  ) +
+          " at line #{failure_line}, column #{failure_column} (byte #{failure_index+1})" +
+          " after #{input[index...failure_index]}"
+      end
+
+
       protected
       
-      attr_reader :node_cache
+      attr_reader :node_cache, :input_length
       attr_writer :index
               
       def prepare_to_parse(input)
         @input = input
+        @input_length = input.length
         reset_index
         @node_cache = Hash.new {|hash, key| hash[key] = Hash.new}
+        @terminal_failures = []
+        @max_terminal_failure_index = 0
       end
       
       def reset_index
         @index = 0
       end
       
-      def parse_char_class(char_class_re, char_class_string, node_class = SyntaxNode, inline_module = nil)
-        if input.index(char_class_re, index) == index
-          result = node_class.new(input, index...(index + 1))
-          result.extend(inline_module) if inline_module
-          @index += 1
-          result
-        else
-          terminal_parse_failure("[#{char_class_string}]")
-        end
-      end
-    
-      def parse_terminal(terminal_string, node_class = SyntaxNode, inline_module = nil)
-        if input.index(terminal_string, index) == index
-          result = node_class.new(input, index...(index + terminal_string.length))
-          result.extend(inline_module) if inline_module
-          @index += terminal_string.length
-          result
-        else
-          terminal_parse_failure(terminal_string)
-        end
-      end
-    
       def parse_anything(node_class = SyntaxNode, inline_module = nil)
         if index < input.length
           result = node_class.new(input, index...(index + 1))
@@ -72,8 +74,14 @@ module Treetop
       end
     
       def terminal_parse_failure(expected_string)
-        TerminalParseFailure.new(input, index, expected_string)
+        return nil if index < max_terminal_failure_index
+        if index > max_terminal_failure_index
+          @max_terminal_failure_index = index
+          @terminal_failures = []
+        end
+        terminal_failures << TerminalParseFailure.new(index, expected_string)
+        return nil
       end
     end
   end
-end
+end