less 1.1.13 → 1.2.9

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

@@ -1,24 +0,0 @@
-module Treetop
-  module Compiler    
-    class CharacterClass < AtomicExpression
-      def compile(address, builder, parent_expression = nil)
-        super
-        
-        builder.if__ "has_terminal?(#{grounded_regexp(text_value)}, true, index)" do
-          assign_result "instantiate_node(#{node_class_name},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
-
-      def grounded_regexp(string)
-        # Double any backslashes, then backslash any single-quotes:
-        "'\\G#{string.gsub(/\\/) { '\\\\' }.gsub(/'/) { "\\'"}}'"
-      end
-    end
-  end
-end

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

@@ -1,31 +0,0 @@
-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/vendor/treetop/lib/treetop/compiler/node_classes/declaration_sequence.rb

@@ -1,24 +0,0 @@
-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/vendor/treetop/lib/treetop/compiler/node_classes/grammar.rb

@@ -1,28 +0,0 @@
-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/vendor/treetop/lib/treetop/compiler/node_classes/inline_module.rb

@@ -1,27 +0,0 @@
-module Treetop
-  module Compiler
-    module InlineModuleMixin
-      attr_reader :module_name
-      
-      def compile(index, builder, rule)
-        @module_name = "#{rule.name.treetop_camelize}#{index}"
-      end
-    end
-    
-    class InlineModule < Runtime::SyntaxNode
-
-      include InlineModuleMixin
-      
-      def compile(index, builder, rule)
-        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/vendor/treetop/lib/treetop/compiler/node_classes/nonterminal.rb

@@ -1,13 +0,0 @@
-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/vendor/treetop/lib/treetop/compiler/node_classes/optional.rb

@@ -1,19 +0,0 @@
-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/vendor/treetop/lib/treetop/compiler/node_classes/parenthesized_expression.rb

@@ -1,9 +0,0 @@
-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/vendor/treetop/lib/treetop/compiler/node_classes/parsing_expression.rb

@@ -1,138 +0,0 @@
-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 '@index', start_index_var
-      end
-      
-      def epsilon_node
-        "instantiate_node(SyntaxNode,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/vendor/treetop/lib/treetop/compiler/node_classes/parsing_rule.rb

@@ -1,55 +0,0 @@
-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, builder, self)
-          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 << 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/vendor/treetop/lib/treetop/compiler/node_classes/predicate.rb

@@ -1,45 +0,0 @@
-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/vendor/treetop/lib/treetop/compiler/node_classes/repetition.rb

@@ -1,55 +0,0 @@
-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 "instantiate_node(#{node_class_name},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