less 1.1.13 → 1.2.9

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

@@ -1,68 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,113 +0,0 @@
-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

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

data/lib/vendor/treetop/lib/treetop/ruby_extensions/string.rb

@@ -1,42 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,105 +0,0 @@
-module Treetop
-  module Runtime
-    class CompiledParser
-      include Treetop::Runtime
-      
-      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
-      
-      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
-
-
-      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.size] == terminal
-        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 << TerminalParseFailure.new(index, expected_string)
-        return nil
-      end
-    end
-  end
-end

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

@@ -1,4 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,200 +0,0 @@
-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