less 0.8.13 → 1.0.4

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

@@ -0,0 +1,68 @@
+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
+          sequence_elements.each_with_index do |element, index|
+            if element.label_name
+              builder.method_declaration(element.label_name) do
+                builder << "elements[#{index}]"
+              end
+              builder.newline unless index == sequence_elements.size - 1
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vendor/treetop/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/lib/vendor/treetop/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/lib/vendor/treetop/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/lib/vendor/treetop/lib/treetop/compiler/ruby_builder.rb

@@ -0,0 +1,113 @@
+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/lib/vendor/treetop/lib/treetop/ruby_extensions.rb

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

data/lib/vendor/treetop/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/lib/vendor/treetop/lib/treetop/runtime.rb

@@ -0,0 +1,5 @@
+dir = File.dirname(__FILE__)
+require "#{dir}/runtime/compiled_parser"
+require "#{dir}/runtime/syntax_node"
+require "#{dir}/runtime/terminal_parse_failure"
+require "#{dir}/runtime/interval_skip_list"

data/lib/vendor/treetop/lib/treetop/runtime/compiled_parser.rb

@@ -0,0 +1,109 @@
+module Treetop
+  module Runtime
+    class CompiledParser
+      include Treetop::Runtime
+      
+      attr_reader :input, :index, :max_terminal_failure_index
+      attr_writer :root
+      attr_accessor :consume_all_input
+      alias :consume_all_input? :consume_all_input
+      
+      def initialize
+        self.consume_all_input = true
+      end
+
+      def parse(input, options = {})
+        prepare_to_parse(input)
+        @index = options[:index] if options[:index]
+        result = send("_nt_#{root}")
+        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
+      
+      def terminal_failures
+        @terminal_failures.map! {|tf_ary| TerminalParseFailure.new(*tf_ary) }
+      end
+
+
+      protected
+      
+      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}
+        @regexps = {}
+        @terminal_failures = []
+        @max_terminal_failure_index = 0
+      end
+      
+      def reset_index
+        @index = 0
+      end
+      
+      def parse_anything(node_class = SyntaxNode, inline_module = nil)
+        if index < input.length
+          result = instantiate_node(node_class,input, index...(index + 1))
+          result.extend(inline_module) if inline_module
+          @index += 1
+          result
+        else
+          terminal_parse_failure("any character")
+        end
+      end
+    
+      def instantiate_node(node_type,*args)
+        if node_type.respond_to? :new 
+          node_type.new(*args)
+        else
+          SyntaxNode.new(*args).extend(node_type)
+        end
+      end
+    
+      def has_terminal?(terminal, regex, index)
+        if regex
+          rx = @regexps[terminal] ||= Regexp.new(terminal)
+          input.index(rx, index) == index
+        else
+          input[index] == terminal[0] && input.index(terminal, index) == index
+        end
+      end
+    
+      def terminal_parse_failure(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 << [index, expected_string]
+        return nil
+      end
+    end
+  end
+end

data/lib/vendor/treetop/lib/treetop/runtime/interval_skip_list.rb

@@ -0,0 +1,4 @@
+dir = File.dirname(__FILE__)
+require "#{dir}/interval_skip_list/interval_skip_list.rb"
+require "#{dir}/interval_skip_list/head_node.rb"
+require "#{dir}/interval_skip_list/node.rb"

data/lib/vendor/treetop/lib/treetop/runtime/interval_skip_list/head_node.rb

@@ -0,0 +1,15 @@
+class IntervalSkipList
+  class HeadNode
+    attr_reader :height, :forward, :forward_markers
+
+    def initialize(height)
+      @height = height
+      @forward = Array.new(height, nil)
+      @forward_markers = Array.new(height) {|i| []}
+    end
+
+    def top_level
+      height - 1
+    end
+  end
+end

data/lib/vendor/treetop/lib/treetop/runtime/interval_skip_list/interval_skip_list.rb

@@ -0,0 +1,200 @@
+class IntervalSkipList
+  attr_reader :probability
+
+  def initialize
+    @head = HeadNode.new(max_height)
+    @ranges = {}
+    @probability = 0.5
+  end
+
+  def max_height
+    3
+  end
+
+  def empty?
+    head.forward[0].nil?
+  end
+
+  def expire(range, length_change)
+    expired_markers, first_node_after_range = overlapping(range)
+    expired_markers.each { |marker| delete(marker) }
+    first_node_after_range.propagate_length_change(length_change)    
+  end
+
+  def overlapping(range)
+    markers, first_node = containing_with_node(range.first)
+
+    cur_node = first_node
+    begin
+      markers.concat(cur_node.forward_markers.flatten)
+      cur_node = cur_node.forward[0]
+    end while cur_node.key < range.last
+
+    return markers.uniq, cur_node
+  end
+
+  def containing(n)
+    containing_with_node(n).first
+  end
+
+  def insert(range, marker)
+    ranges[marker] = range
+    first_node = insert_node(range.first)
+    first_node.endpoint_of.push(marker)
+    last_node = insert_node(range.last)
+    last_node.endpoint_of.push(marker)
+
+    cur_node = first_node
+    cur_level = first_node.top_level
+    while next_node_at_level_inside_range?(cur_node, cur_level, range)
+      while can_ascend_from?(cur_node, cur_level) && next_node_at_level_inside_range?(cur_node, cur_level + 1, range)
+        cur_level += 1
+      end
+      cur_node = mark_forward_path_at_level(cur_node, cur_level, marker)
+    end
+
+    while node_inside_range?(cur_node, range)
+      while can_descend_from?(cur_level) && next_node_at_level_outside_range?(cur_node, cur_level, range)
+        cur_level -= 1 
+      end
+      cur_node = mark_forward_path_at_level(cur_node, cur_level, marker)
+    end
+  end
+
+  def delete(marker)
+    range = ranges[marker]
+    path_to_first_node = make_path
+    first_node = find(range.first, path_to_first_node)
+
+    cur_node = first_node
+    cur_level = first_node.top_level
+    while next_node_at_level_inside_range?(cur_node, cur_level, range)
+      while can_ascend_from?(cur_node, cur_level) && next_node_at_level_inside_range?(cur_node, cur_level + 1, range)
+        cur_level += 1
+      end
+      cur_node = unmark_forward_path_at_level(cur_node, cur_level, marker)
+    end
+
+    while node_inside_range?(cur_node, range)
+      while can_descend_from?(cur_level) && next_node_at_level_outside_range?(cur_node, cur_level, range)
+        cur_level -= 1
+      end
+      cur_node = unmark_forward_path_at_level(cur_node, cur_level, marker)
+    end
+    last_node = cur_node
+
+    first_node.endpoint_of.delete(marker)
+    if first_node.endpoint_of.empty?
+      first_node.delete(path_to_first_node)
+    end
+
+    last_node.endpoint_of.delete(marker)
+    if last_node.endpoint_of.empty?
+      path_to_last_node = make_path
+      find(range.last, path_to_last_node)
+      last_node.delete(path_to_last_node)
+    end
+  end
+
+  protected
+  attr_reader :head, :ranges
+
+  def insert_node(key)
+    path = make_path
+    found_node = find(key, path)
+    if found_node && found_node.key == key
+      return found_node
+    else
+      return Node.new(key, next_node_height, path)
+    end
+  end  
+
+  def containing_with_node(n)
+    containing = []
+    cur_node = head
+    (max_height - 1).downto(0) do |cur_level|
+      while (next_node = cur_node.forward[cur_level]) && next_node.key <= n
+        cur_node = next_node
+        if cur_node.key == n
+          return containing + (cur_node.markers - cur_node.endpoint_of), cur_node
+        end
+      end
+      containing.concat(cur_node.forward_markers[cur_level])
+    end
+
+    return containing, cur_node
+  end
+
+  def delete_node(key)
+    path = make_path
+    found_node = find(key, path)
+    found_node.delete(path) if found_node.key == key
+  end
+  
+  def find(key, path)
+    cur_node = head
+    (max_height - 1).downto(0) do |cur_level|
+      while (next_node = cur_node.forward[cur_level]) && next_node.key < key
+        cur_node = next_node
+      end
+      path[cur_level] = cur_node
+    end
+    cur_node.forward[0]
+  end
+
+  def make_path
+    Array.new(max_height, nil)
+  end
+
+  def next_node_height
+    height = 1
+    while rand < probability && height < max_height
+      height += 1
+    end
+    height
+  end
+
+  def can_ascend_from?(node, level)
+    level < node.top_level
+  end
+
+  def can_descend_from?(level)
+    level > 0
+  end
+
+  def node_inside_range?(node, range)
+    node.key < range.last
+  end
+
+  def next_node_at_level_inside_range?(node, level, range)
+    node.forward[level] && node.forward[level].key <= range.last
+  end
+
+  def next_node_at_level_outside_range?(node, level, range)
+    (node.forward[level].nil? || node.forward[level].key > range.last)
+  end
+
+  def mark_forward_path_at_level(node, level, marker)
+    node.forward_markers[level].push(marker)
+    next_node = node.forward[level]
+    next_node.markers.push(marker)
+    node = next_node
+  end
+
+  def unmark_forward_path_at_level(node, level, marker)
+    node.forward_markers[level].delete(marker)
+    next_node = node.forward[level]
+    next_node.markers.delete(marker)
+    node = next_node
+  end
+
+  def nodes
+    nodes = []
+    cur_node = head.forward[0]
+    until cur_node.nil?
+      nodes << cur_node
+      cur_node = cur_node.forward[0]
+    end
+    nodes
+  end 
+end