classiccms 0.2.4.pre → 0.3.0

data/vendor/bundle/gems/treetop-1.4.10/lib/treetop/compiler/node_classes/parsing_expression.rb

@@ -0,0 +1,146 @@
+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 decorated?
+        parent_expression && (parent_expression.node_class_name || parent_expression.node_class_name || 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 assign_lazily_instantiated_node
+        assign_result("true")
+      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/vendor/bundle/gems/treetop-1.4.10/lib/treetop/compiler/node_classes/parsing_rule.rb

@@ -0,0 +1,58 @@
+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.if_ "cached" do
+            builder << 'cached = SyntaxNode.new(input, index...(index + 1)) if cached == true'
+            builder << '@index = cached.interval.end'
+          end
+          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/vendor/bundle/gems/treetop-1.4.10/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/vendor/bundle/gems/treetop-1.4.10/lib/treetop/compiler/node_classes/predicate_block.rb

@@ -0,0 +1,16 @@
+module Treetop
+  module Compiler
+    class PredicateBlock < ParsingExpression
+      def compile(index, builder, parent_expression = nil)
+        super
+        # REVISIT: This is distinctly dodgey, but since we can only be called from
+        # two contexts, and it works in both those, I'm going with it for now, as
+        # opposed to doing the major refactor of providing a proper way of accessing
+        # the parent's accumulator variable.
+        p = parent
+        p = p.parent while p && !p.respond_to?(:accumulator_var)
+        assign_result "lambda #{text_value}.call(#{p ? p.accumulator_var : ""})"
+      end
+    end
+  end
+end

data/vendor/bundle/gems/treetop-1.4.10/lib/treetop/compiler/node_classes/repetition.rb

@@ -0,0 +1,89 @@
+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
+          if max && !max.empty?
+            builder.if_ "#{accumulator_var}.size == #{max.text_value}" do
+              builder.break
+            end
+          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
+
+      def max
+        nil
+      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
+
+      def max
+        nil
+      end
+    end
+
+    class OccurrenceRange < Repetition
+      def compile(address, builder, parent_expression)
+        super
+
+        if min.empty? || min.text_value.to_i == 0
+          assign_and_extend_result
+        else
+          # We got some, but fewer than we wanted. There'll be a failure reported already
+          builder.if__ "#{accumulator_var}.size < #{min.text_value}" do
+            reset_index
+            assign_failure start_index_var
+          end
+          builder.else_ do
+            assign_and_extend_result
+          end
+        end
+        end_comment(parent_expression)
+      end
+    end
+
+  end
+end

data/vendor/bundle/gems/treetop-1.4.10/lib/treetop/compiler/node_classes/sequence.rb

@@ -0,0 +1,71 @@
+module Treetop
+  module Compiler    
+    class Sequence < ParsingExpression
+      def compile(address, builder, parent_expression = nil)
+        super
+        begin_comment(self)
+        use_vars :result, :start_index, :accumulator
+        compile_sequence_elements(sequence_elements)
+        builder.if__ "#{accumulator_var}.last" do
+          assign_result "instantiate_node(#{node_class_name},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
+        end
+        end_comment(self)
+      end
+      
+      def node_class_name
+        node_class_declarations.node_class_name || 'SyntaxNode'
+      end
+      
+      def compile_sequence_elements(elements)
+        obtain_new_subexpression_address
+        elements.first.compile(subexpression_address, builder)
+        accumulate_subexpression_result
+        if elements.size > 1
+          builder.if_ subexpression_success? do
+            compile_sequence_elements(elements[1..-1])
+          end
+        end
+      end
+      
+      def sequence_element_accessor_module
+        @sequence_element_accessor_module ||= SequenceElementAccessorModule.new(sequence_elements)
+      end
+      
+      def sequence_element_accessor_module_name
+        sequence_element_accessor_module.module_name
+      end
+    end
+    
+    class SequenceElementAccessorModule
+      include InlineModuleMixin   
+      attr_reader :sequence_elements
+      
+      def initialize(sequence_elements)
+        @sequence_elements = sequence_elements
+      end
+      
+      def compile(index, builder, rule)
+        super
+        builder.module_declaration(module_name) do
+          elements_by_name = sequence_elements.inject({}){|h,e| (h[e.label_name.to_s] ||= []) << e; h}
+          sequence_elements.each_with_index do |element, index|
+            if element.label_name
+              repetitions = elements_by_name[element.label_name.to_s]
+              label_name = element.label_name + (repetitions.size > 1 ? (repetitions.index(element)+1).to_s : "")
+              builder.method_declaration(label_name) do
+                builder << "elements[#{index}]"
+              end
+              builder.newline unless index == sequence_elements.size - 1
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/gems/treetop-1.4.10/lib/treetop/compiler/node_classes/terminal.rb

@@ -0,0 +1,20 @@
+module Treetop
+  module Compiler    
+    class Terminal < AtomicExpression
+      def compile(address, builder, parent_expression = nil)
+        super
+        string_length = eval(text_value).length
+        
+        builder.if__ "has_terminal?(#{text_value}, false, index)" do
+          assign_result "instantiate_node(#{node_class_name},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
+end

data/vendor/bundle/gems/treetop-1.4.10/lib/treetop/compiler/node_classes/transient_prefix.rb

@@ -0,0 +1,9 @@
+module Treetop
+  module Compiler
+    class TransientPrefix < ParsingExpression
+      def compile(address, builder, parent_expression)
+        parent_expression.prefixed_expression.compile(address, builder)
+      end
+    end
+  end
+end

data/vendor/bundle/gems/treetop-1.4.10/lib/treetop/compiler/node_classes/treetop_file.rb

@@ -0,0 +1,9 @@
+module Treetop
+  module Compiler
+    class TreetopFile < Runtime::SyntaxNode
+      def compile
+        (elements.map {|elt| elt.compile}).join
+      end
+    end
+  end
+end

data/vendor/bundle/gems/treetop-1.4.10/lib/treetop/compiler/node_classes.rb

@@ -0,0 +1,19 @@
+require 'treetop/compiler/node_classes/parsing_expression'
+require 'treetop/compiler/node_classes/atomic_expression'
+require 'treetop/compiler/node_classes/inline_module'
+require 'treetop/compiler/node_classes/predicate_block'
+require 'treetop/compiler/node_classes/treetop_file'
+require 'treetop/compiler/node_classes/grammar'
+require 'treetop/compiler/node_classes/declaration_sequence'
+require 'treetop/compiler/node_classes/parsing_rule'
+require 'treetop/compiler/node_classes/parenthesized_expression'
+require 'treetop/compiler/node_classes/nonterminal'
+require 'treetop/compiler/node_classes/terminal'
+require 'treetop/compiler/node_classes/anything_symbol'
+require 'treetop/compiler/node_classes/character_class'
+require 'treetop/compiler/node_classes/sequence'
+require 'treetop/compiler/node_classes/choice'
+require 'treetop/compiler/node_classes/repetition'
+require 'treetop/compiler/node_classes/optional'
+require 'treetop/compiler/node_classes/predicate'
+require 'treetop/compiler/node_classes/transient_prefix'

data/vendor/bundle/gems/treetop-1.4.10/lib/treetop/compiler/ruby_builder.rb

@@ -0,0 +1,115 @@
+require 'treetop/ruby_extensions/string'
+
+module Treetop
+  module Compiler
+    class RubyBuilder
+      
+      attr_reader :level, :address_space, :ruby
+      
+      def initialize
+        @level = 0
+        @address_space = LexicalAddressSpace.new
+        @ruby = ""
+      end
+      
+      def <<(ruby_line)              
+        return if ruby_line.blank?
+        ruby << ruby_line.tabto(level) << "\n"
+      end
+
+      def newline
+        ruby << "\n"
+      end
+      
+      def indented(depth = 2)
+        self.in(depth)
+        yield
+        self.out(depth)
+      end
+            
+      def class_declaration(name, &block)
+        self << "class #{name}"
+        indented(&block)
+        self << "end"
+      end
+      
+      def module_declaration(name, &block)
+        self << "module #{name}"
+        indented(&block)
+        self << "end"
+      end
+      
+      def method_declaration(name, &block)
+        self << "def #{name}"
+        indented(&block)
+        self << "end"
+      end
+      
+      def assign(left, right)
+        if left.instance_of? Array
+          self << "#{left.join(', ')} = #{right.join(', ')}"
+        else
+          self << "#{left} = #{right}"
+        end
+      end
+      
+      def extend(var, module_name)
+        self << "#{var}.extend(#{module_name})"
+      end
+      
+      def accumulate(left, right)
+        self << "#{left} << #{right}"
+      end
+      
+      def if__(condition, &block)
+        self << "if #{condition}"
+        indented(&block)
+      end
+      
+      def if_(condition, &block)
+        if__(condition, &block)
+        self << 'end'
+      end
+      
+      def else_(&block)
+        self << 'else'
+        indented(&block)
+        self << 'end'
+      end
+      
+      def loop(&block)
+        self << 'loop do'
+        indented(&block)
+        self << 'end'
+      end
+      
+      def break
+        self << 'break'
+      end
+      
+      def in(depth = 2)
+        @level += depth
+        self
+      end
+      
+      def out(depth = 2)
+        @level -= depth
+        self
+      end
+      
+      def next_address
+        address_space.next_address
+      end
+      
+      def reset_addresses
+        address_space.reset_addresses
+      end
+      
+      private
+      
+      def indent
+        " " * level
+      end
+    end
+  end
+end

data/vendor/bundle/gems/treetop-1.4.10/lib/treetop/compiler.rb

@@ -0,0 +1,7 @@
+require 'treetop/ruby_extensions'
+
+require 'treetop/compiler/lexical_address_space'
+require 'treetop/compiler/ruby_builder'
+require 'treetop/compiler/node_classes'
+require 'treetop/compiler/metagrammar' unless defined?($exclude_metagrammar)
+require 'treetop/compiler/grammar_compiler'

data/vendor/bundle/gems/treetop-1.4.10/lib/treetop/polyglot.rb

@@ -0,0 +1,9 @@
+module Treetop
+  module Polyglot
+    VALID_GRAMMAR_EXT = ['treetop', 'tt']
+    VALID_GRAMMAR_EXT_REGEXP = /\.(#{VALID_GRAMMAR_EXT.join('|')})\Z/o
+  end
+end
+
+require 'polyglot'
+Polyglot.register(Treetop::Polyglot::VALID_GRAMMAR_EXT, Treetop)

data/vendor/bundle/gems/treetop-1.4.10/lib/treetop/ruby_extensions/string.rb

@@ -0,0 +1,42 @@
+class String
+  def column_of(index)
+    return 1 if index == 0
+    newline_index = rindex("\n", index - 1)
+    if newline_index
+      index - newline_index
+    else
+      index + 1
+    end
+  end
+  
+  def line_of(index)
+    self[0...index].count("\n") + 1
+  end
+
+  unless method_defined?(:blank?)
+    def blank?
+      self == ""
+    end
+  end
+
+  # The following methods are lifted from Facets 2.0.2
+  def tabto(n)
+    if self =~ /^( *)\S/
+      indent(n - $1.length)
+    else
+      self
+    end
+  end
+
+  def indent(n)
+    if n >= 0
+      gsub(/^/, ' ' * n)
+    else
+      gsub(/^ {0,#{-n}}/, "")
+    end
+  end
+
+  def treetop_camelize
+    to_s.gsub(/\/(.?)/){ "::" + $1.upcase }.gsub(/(^|_)(.)/){ $2.upcase }
+  end
+end

data/vendor/bundle/gems/treetop-1.4.10/lib/treetop/ruby_extensions.rb

@@ -0,0 +1 @@
+require 'treetop/ruby_extensions/string'