mack 0.8.2 → 0.8.3

data/lib/gems/treetop-1.2.4/lib/treetop/compiler/node_classes/character_class.rb

@@ -0,0 +1,19 @@
+module Treetop
+  module Compiler    
+    class CharacterClass < AtomicExpression
+      def compile(address, builder, parent_expression = nil)
+        super
+        
+        builder.if__ "input.index(Regexp.new(#{single_quote(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
+end

data/lib/gems/treetop-1.2.4/lib/treetop/compiler/node_classes/choice.rb

@@ -0,0 +1,31 @@
+module Treetop
+  module Compiler
+    class Choice < ParsingExpression
+      def compile(address, builder, parent_expression = nil)
+        super
+        begin_comment(self)
+        use_vars :result, :start_index
+        compile_alternatives(alternatives)
+        end_comment(self)
+      end
+      
+      def compile_alternatives(alternatives)
+        obtain_new_subexpression_address
+        alternatives.first.compile(subexpression_address, builder)
+        builder.if__ subexpression_success? do
+          assign_result subexpression_result_var
+          extend_result_with_declared_module
+          extend_result_with_inline_module
+        end
+        builder.else_ do
+          if alternatives.size == 1
+            reset_index
+            assign_failure start_index_var
+          else
+            compile_alternatives(alternatives[1..-1])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gems/treetop-1.2.4/lib/treetop/compiler/node_classes/declaration_sequence.rb

@@ -0,0 +1,24 @@
+module Treetop
+  module Compiler
+    class DeclarationSequence < Runtime::SyntaxNode
+
+      def compile(builder)
+        unless rules.empty?
+          builder.method_declaration("root") do
+            builder << "@root || :#{rules.first.name}"
+          end
+          builder.newline
+        end
+        
+        declarations.each do |declaration|
+          declaration.compile(builder)
+          builder.newline
+        end
+      end
+      
+      def rules
+        declarations.select { |declaration| declaration.instance_of?(ParsingRule) }
+      end
+    end
+  end
+end

data/lib/gems/treetop-1.2.4/lib/treetop/compiler/node_classes/grammar.rb

@@ -0,0 +1,28 @@
+module Treetop
+  module Compiler
+    class Grammar < Runtime::SyntaxNode
+      def compile
+        builder = RubyBuilder.new
+        
+        builder.module_declaration "#{grammar_name.text_value}" do
+          builder.in(indent_level) # account for initial indentation of grammar declaration
+          builder << "include Treetop::Runtime"
+          builder.newline
+          declaration_sequence.compile(builder)
+        end
+        builder.newline
+        builder.class_declaration "#{parser_name} < Treetop::Runtime::CompiledParser" do
+          builder << "include #{grammar_name.text_value}"
+        end
+      end
+      
+      def indent_level
+        input.column_of(interval.begin) - 1
+      end
+      
+      def parser_name
+        grammar_name.text_value + 'Parser'
+      end
+    end
+ end 
+end

data/lib/gems/treetop-1.2.4/lib/treetop/compiler/node_classes/inline_module.rb

@@ -0,0 +1,27 @@
+module Treetop
+  module Compiler
+    module InlineModuleMixin
+      attr_reader :module_name
+      
+      def compile(index, rule, builder)
+        @module_name = "#{rule.name.treetop_camelize}#{index}"
+      end
+    end
+    
+    class InlineModule < Runtime::SyntaxNode
+
+      include InlineModuleMixin
+      
+      def compile(index, rule, builder)
+        super
+        builder.module_declaration(module_name) do
+          builder << ruby_code.gsub(/\A\n/, '').rstrip
+        end
+      end
+      
+      def ruby_code
+        elements[1].text_value
+      end
+    end
+  end
+end

data/lib/gems/treetop-1.2.4/lib/treetop/compiler/node_classes/nonterminal.rb

@@ -0,0 +1,13 @@
+module Treetop
+  module Compiler    
+    class Nonterminal < AtomicExpression
+      def compile(address, builder, parent_expression = nil)
+        super
+        use_vars :result
+        assign_result text_value == 'super' ? 'super' : "_nt_#{text_value}"
+        extend_result_with_declared_module
+        extend_result_with_inline_module
+      end
+    end
+  end
+end

data/lib/gems/treetop-1.2.4/lib/treetop/compiler/node_classes/optional.rb

@@ -0,0 +1,19 @@
+module Treetop
+  module Compiler
+    class Optional < ParsingExpression
+      def compile(address, builder, parent_expression)
+        super
+        use_vars :result
+        obtain_new_subexpression_address
+        parent_expression.atomic.compile(subexpression_address, builder)
+        
+        builder.if__ subexpression_success? do
+          assign_result subexpression_result_var
+        end
+        builder.else_ do
+          assign_result epsilon_node
+        end
+      end
+    end
+  end
+end

data/lib/gems/treetop-1.2.4/lib/treetop/compiler/node_classes/parenthesized_expression.rb

@@ -0,0 +1,9 @@
+module Treetop
+  module Compiler    
+    class ParenthesizedExpression < ParsingExpression
+      def compile(address, builder, parent_expression = nil)
+        elements[2].compile(address, builder, parent_expression)
+      end
+    end
+  end
+end

data/lib/gems/treetop-1.2.4/lib/treetop/compiler/node_classes/parsing_expression.rb

@@ -0,0 +1,138 @@
+module Treetop
+  module Compiler
+    class ParsingExpression < Runtime::SyntaxNode
+      attr_reader :address, :builder, :subexpression_address, :var_symbols, :parent_expression
+    
+      def compile(address, builder, parent_expression)
+        @address = address
+        @builder = builder
+        @parent_expression = parent_expression
+      end
+      
+      def node_class_name
+        parent_expression && parent_expression.node_class_name || 'SyntaxNode'
+      end
+      
+      def declared_module_name
+        parent_expression && parent_expression.node_class_name
+      end
+      
+      def inline_module_name
+        parent_expression && parent_expression.inline_module_name
+      end
+      
+      def optional_arg(arg)
+        if arg
+          ", #{arg}"
+        else
+          ''
+        end
+      end
+    
+      def use_vars(*var_symbols)
+        @var_symbols = var_symbols
+        builder << var_initialization
+      end
+    
+      def result_var
+        var(:result)
+      end
+    
+      def accumulator_var
+        var(:accumulator)
+      end
+      
+      def start_index_var
+        var(:start_index)
+      end
+    
+      def subexpression_result_var
+        "r#{subexpression_address}"
+      end
+    
+      def subexpression_success?
+        subexpression_result_var
+      end
+    
+      def obtain_new_subexpression_address
+        @subexpression_address = builder.next_address
+      end
+        
+      def accumulate_subexpression_result
+        builder.accumulate accumulator_var, subexpression_result_var
+      end
+    
+      def assign_result(value_ruby)
+        builder.assign result_var, value_ruby
+      end
+      
+      def extend_result(module_name)
+        builder.extend result_var, module_name
+      end
+
+      def extend_result_with_declared_module
+        extend_result declared_module_name if declared_module_name
+      end
+      
+      def extend_result_with_inline_module
+        extend_result inline_module_name if inline_module_name
+      end
+    
+      def reset_index
+        builder.assign 'self.index', start_index_var
+      end
+      
+      def epsilon_node
+        "SyntaxNode.new(input, index...index)"
+      end
+      
+      def assign_failure(start_index_var)
+        assign_result("nil")
+      end
+    
+      def var_initialization
+        left, right = [], []
+        var_symbols.each do |symbol|
+          if init_value(symbol)
+            left << var(symbol)
+            right << init_value(symbol)
+          end
+        end
+        if left.empty?
+          ""
+        else
+          left.join(', ') + ' = ' + right.join(', ')
+        end
+      end
+    
+      def var(var_symbol)
+        case var_symbol
+        when :result then "r#{address}"
+        when :accumulator then "s#{address}"
+        when :start_index then "i#{address}"
+        else raise "Unknown var symbol #{var_symbol}."
+        end
+      end
+    
+      def init_value(var_symbol)
+        case var_symbol
+        when :accumulator then '[]'
+        when :start_index then 'index'
+        else nil
+        end
+      end
+      
+      def begin_comment(expression)
+        #builder << "# begin #{on_one_line(expression)}"
+      end
+      
+      def end_comment(expression)
+        #builder << "# end #{on_one_line(expression)}"
+      end
+      
+      def on_one_line(expression)
+        expression.text_value.tr("\n", ' ')
+      end
+    end
+  end
+end

data/lib/gems/treetop-1.2.4/lib/treetop/compiler/node_classes/parsing_rule.rb

@@ -0,0 +1,55 @@
+module Treetop
+  module Compiler
+    class ParsingRule < Runtime::SyntaxNode
+
+      def compile(builder)
+        compile_inline_module_declarations(builder)
+        generate_method_definition(builder)
+      end
+      
+      def compile_inline_module_declarations(builder)
+        parsing_expression.inline_modules.each_with_index do |inline_module, i|
+          inline_module.compile(i, self, builder)
+          builder.newline
+        end
+      end
+      
+      def generate_method_definition(builder)
+        builder.reset_addresses
+        expression_address = builder.next_address
+        result_var = "r#{expression_address}"
+        
+        builder.method_declaration(method_name) do
+          builder.assign 'start_index', 'index'
+          generate_cache_lookup(builder)
+          builder.newline
+          parsing_expression.compile(expression_address, builder)
+          builder.newline
+          generate_cache_storage(builder, result_var)
+          builder.newline          
+          builder << "return #{result_var}"
+        end
+      end
+      
+      def generate_cache_lookup(builder)
+        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
+      
+      def generate_cache_storage(builder, result_var)
+        builder.assign "node_cache[:#{name}][start_index]", result_var
+      end
+      
+      def method_name
+        "_nt_#{name}"
+      end
+      
+      def name
+        nonterminal.text_value
+      end
+    end
+  end
+end

data/lib/gems/treetop-1.2.4/lib/treetop/compiler/node_classes/predicate.rb

@@ -0,0 +1,45 @@
+module Treetop
+  module Compiler
+    class Predicate < ParsingExpression
+      def compile(address, builder, parent_expression)
+        super
+        begin_comment(parent_expression)
+        use_vars :result, :start_index
+        obtain_new_subexpression_address
+        parent_expression.prefixed_expression.compile(subexpression_address, builder)
+        builder.if__(subexpression_success?) { when_success }
+        builder.else_ { when_failure }
+        end_comment(parent_expression)
+      end
+      
+      def assign_failure
+        super(start_index_var)
+      end
+      
+      def assign_success
+        reset_index
+        assign_result epsilon_node
+      end
+    end
+    
+    class AndPredicate < Predicate
+      def when_success
+        assign_success
+      end
+
+      def when_failure
+        assign_failure
+      end
+    end
+    
+    class NotPredicate < Predicate
+      def when_success
+        assign_failure
+      end
+      
+      def when_failure
+        assign_success
+      end
+    end
+  end
+end

data/lib/gems/treetop-1.2.4/lib/treetop/compiler/node_classes/repetition.rb

@@ -0,0 +1,55 @@
+module Treetop
+  module Compiler
+    class Repetition < ParsingExpression
+      def compile(address, builder, parent_expression)
+        super
+        repeated_expression = parent_expression.atomic
+        begin_comment(parent_expression)
+        use_vars :result, :accumulator, :start_index
+
+        builder.loop do
+          obtain_new_subexpression_address
+          repeated_expression.compile(subexpression_address, builder)
+          builder.if__ subexpression_success? do
+            accumulate_subexpression_result
+          end
+          builder.else_ do
+            builder.break
+          end
+        end
+      end
+      
+      def inline_module_name
+        parent_expression.inline_module_name
+      end
+      
+      def assign_and_extend_result
+        assign_result "#{node_class_name}.new(input, #{start_index_var}...index, #{accumulator_var})"
+        extend_result_with_inline_module
+      end
+    end
+
+  
+    class ZeroOrMore < Repetition
+      def compile(address, builder, parent_expression)
+        super
+        assign_and_extend_result
+        end_comment(parent_expression)
+      end
+    end
+  
+    class OneOrMore < Repetition
+      def compile(address, builder, parent_expression)
+        super
+        builder.if__ "#{accumulator_var}.empty?" do
+          reset_index
+          assign_failure start_index_var
+        end
+        builder.else_ do
+          assign_and_extend_result
+        end
+        end_comment(parent_expression)
+      end
+    end
+  end
+end