depengine 0.0.1

data/etc/isolate/jruby-1.8/gems/treetop-1.4.8/lib/treetop/runtime/compiled_parser.rb

@@ -0,0 +1,114 @@
+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 SyntaxNode.new(input, index...(index + 1)) if result == true
+        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
+        if @terminal_failures.empty? || @terminal_failures[0].is_a?(TerminalParseFailure)
+          @terminal_failures
+        else
+          @terminal_failures.map! {|tf_ary| TerminalParseFailure.new(*tf_ary) }
+        end
+      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 << [index, expected_string]
+        return nil
+      end
+    end
+  end
+end

data/etc/isolate/jruby-1.8/gems/treetop-1.4.8/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/etc/isolate/jruby-1.8/gems/treetop-1.4.8/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

data/etc/isolate/jruby-1.8/gems/treetop-1.4.8/lib/treetop/runtime/interval_skip_list/node.rb

@@ -0,0 +1,164 @@
+class IntervalSkipList
+  class Node < HeadNode
+    attr_accessor :key
+    attr_reader :markers, :endpoint_of
+
+    def initialize(key, height, path)
+      super(height)
+      @key = key
+      @markers = []
+      @endpoint_of = []
+      update_forward_pointers(path)
+      promote_markers(path)
+    end
+
+    def all_forward_markers
+      markers.flatten
+    end
+
+    def delete(path)
+      0.upto(top_level) do |i|
+        path[i].forward[i] = forward[i]
+      end
+      demote_markers(path)
+    end
+
+    def propagate_length_change(length_change)
+      cur_node = self
+      while cur_node do
+        cur_node.key += length_change
+        cur_node = cur_node.forward[0]
+      end
+    end
+
+    protected
+
+    def update_forward_pointers(path)
+      0.upto(top_level) do |i|
+        forward[i] = path[i].forward[i]
+        path[i].forward[i] = self
+      end
+    end
+
+    def promote_markers(path)
+      promoted = []
+      new_promoted = []
+      0.upto(top_level) do |i|
+        incoming_markers = path[i].forward_markers[i]
+        markers.concat(incoming_markers)
+
+        incoming_markers.each do |marker|
+          if can_be_promoted_higher?(marker, i)
+            new_promoted.push(marker)
+            forward[i].delete_marker_from_path(marker, i, forward[i+1])
+          else
+            forward_markers[i].push(marker)
+          end
+        end
+
+        promoted.each do |marker|
+          if can_be_promoted_higher?(marker, i)
+            new_promoted.push(marker)
+            forward[i].delete_marker_from_path(marker, i, forward[i+1])
+          else
+            forward_markers[i].push(marker)
+          end
+        end
+
+        promoted = new_promoted
+        new_promoted = []
+      end
+    end
+
+
+    def can_be_promoted_higher?(marker, level)
+      level < top_level && forward[level + 1] && forward[level + 1].markers.include?(marker)
+    end
+
+    def delete_marker_from_path(marker, level, terminus)
+      cur_node = self
+      until cur_node == terminus
+        cur_node.forward_markers[level].delete(marker)
+        cur_node.markers.delete(marker)
+        cur_node = cur_node.forward[level]
+      end
+    end
+
+    def demote_markers(path)
+      demote_inbound_markers(path)
+      demote_outbound_markers(path)
+    end
+
+    def demote_inbound_markers(path)
+      demoted = []
+      new_demoted = []
+
+      top_level.downto(0) do |i|
+        incoming_markers = path[i].forward_markers[i].dup
+        incoming_markers.each do |marker|
+          unless forward_node_with_marker_at_or_above_level?(marker, i)
+            path[i].forward_markers[i].delete(marker)
+            new_demoted.push(marker)
+          end
+        end
+
+        demoted.each do |marker|
+          path[i + 1].place_marker_on_inbound_path(marker, i, path[i])
+
+          if forward[i].markers.include?(marker)
+            path[i].forward_markers[i].push(marker)
+          else
+            new_demoted.push(marker)
+          end
+        end
+
+        demoted = new_demoted
+        new_demoted = []
+      end
+    end
+
+    def demote_outbound_markers(path)
+      demoted = []
+      new_demoted = []
+
+      top_level.downto(0) do |i|
+        forward_markers[i].each do |marker|
+          new_demoted.push(marker) unless path[i].forward_markers[i].include?(marker)
+        end
+
+        demoted.each do |marker|
+          forward[i].place_marker_on_outbound_path(marker, i, forward[i + 1])
+          new_demoted.push(marker) unless path[i].forward_markers[i].include?(marker)
+        end
+
+        demoted = new_demoted
+        new_demoted = []
+      end
+    end
+
+    def forward_node_with_marker_at_or_above_level?(marker, level)
+      level.upto(top_level) do |i|
+        return true if forward[i].markers.include?(marker)
+      end
+      false
+    end
+
+    def place_marker_on_outbound_path(marker, level, terminus)
+      cur_node = self
+      until cur_node == terminus
+        cur_node.forward_markers[level].push(marker)
+        cur_node.markers.push(marker)
+        cur_node = cur_node.forward[level]
+      end
+    end
+
+    def place_marker_on_inbound_path(marker, level, terminus)
+      cur_node = self
+      until cur_node == terminus
+        cur_node.forward_markers[level].push(marker)
+        cur_node = cur_node.forward[level]
+        cur_node.markers.push(marker)
+      end
+    end
+  end
+end

data/etc/isolate/jruby-1.8/gems/treetop-1.4.8/lib/treetop/runtime/interval_skip_list.rb

@@ -0,0 +1,3 @@
+require 'treetop/runtime/interval_skip_list/interval_skip_list'
+require 'treetop/runtime/interval_skip_list/head_node'
+require 'treetop/runtime/interval_skip_list/node'

data/etc/isolate/jruby-1.8/gems/treetop-1.4.8/lib/treetop/runtime/syntax_node.rb

@@ -0,0 +1,114 @@
+module Treetop
+  module Runtime
+    class SyntaxNode
+      attr_reader :input, :interval
+      attr_accessor :parent
+
+      def initialize(input, interval, elements = nil)
+        @input = input
+        @interval = interval
+        @elements = elements
+      end
+
+      def elements
+        return @elements if terminal?
+        # replace the character class placeholders in the sequence (lazy instantiation)
+        last_element = nil
+        @comprehensive_elements ||= @elements.map do |element|
+          if element == true
+            index = last_element ? last_element.interval.last : interval.first
+            element = SyntaxNode.new(input, index...(index + 1))
+          end
+          element.parent = self
+          last_element = element
+        end
+
+        @comprehensive_elements
+      end
+
+      def terminal?
+        @elements.nil?
+      end
+
+      def nonterminal?
+        !terminal?
+      end
+
+      def text_value
+        input[interval]
+      end
+
+      def empty?
+        interval.first == interval.last && interval.exclude_end?
+      end
+      
+      def <=>(other)
+        self.interval.first <=> other.interval.first
+      end
+
+      def extension_modules
+        local_extensions =
+          class <<self
+            included_modules-Object.included_modules
+          end
+        if local_extensions.size > 0
+          local_extensions
+        else
+          []    # There weren't any; must be a literal node
+        end
+      end
+
+      def inspect(indent="")
+        em = extension_modules
+        interesting_methods = methods-[em.last ? em.last.methods : nil]-self.class.instance_methods
+        im = interesting_methods.size > 0 ? " (#{interesting_methods.join(",")})" : ""
+        tv = text_value
+        tv = "...#{tv[-20..-1]}" if tv.size > 20
+
+        indent +
+        self.class.to_s.sub(/.*:/,'') +
+          em.map{|m| "+"+m.to_s.sub(/.*:/,'')}*"" +
+          " offset=#{interval.first}" +
+          ", #{tv.inspect}" +
+          im +
+          (elements && elements.size > 0 ?
+            ":" +
+              (elements||[]).map{|e|
+          begin
+            "\n"+e.inspect(indent+"  ")
+          rescue  # Defend against inspect not taking a parameter
+            "\n"+indent+" "+e.inspect
+          end
+              }.join("") :
+            ""
+          )
+      end
+
+      @@dot_id_counter = 0
+
+      def dot_id
+        @dot_id ||= @@dot_id_counter += 1
+      end
+
+      def write_dot(io)
+        io.puts "node#{dot_id} [label=\"'#{text_value}'\"];"
+        if nonterminal? then
+          elements.each do
+            |x|
+            io.puts "node#{dot_id} -> node#{x.dot_id};"
+            x.write_dot(io)
+          end
+        end
+      end
+
+      def write_dot_file(fname)
+        File.open(fname + ".dot","w") do
+          |file|
+          file.puts "digraph G {"
+          write_dot(file)
+          file.puts "}"
+        end
+      end
+    end
+  end
+end

data/etc/isolate/jruby-1.8/gems/treetop-1.4.8/lib/treetop/runtime/terminal_parse_failure.rb

@@ -0,0 +1,16 @@
+module Treetop
+  module Runtime
+    class TerminalParseFailure
+      attr_reader :index, :expected_string
+
+      def initialize(index, expected_string)
+        @index = index
+        @expected_string = expected_string
+      end
+
+      def to_s
+        "String matching #{expected_string} expected."
+      end
+    end
+  end
+end

data/etc/isolate/jruby-1.8/gems/treetop-1.4.8/lib/treetop/runtime/terminal_parse_failure_debug.rb

@@ -0,0 +1,21 @@
+module Treetop
+  module Runtime
+    class TerminalParseFailure
+      attr_reader :index
+
+      def initialize(index, expected_string)
+        @index = index
+        @caller = caller
+        @expected_string = expected_string
+      end
+
+      def expected_string
+        "#{@expected_string} from #{@caller.map{|s| s.sub(/\A.*:([0-9]+):in `([^']*)'.*/,'\2:\1')}*" from "}\n\t"
+      end
+
+      def to_s
+        "String matching #{expected_string} expected."
+      end
+    end
+  end
+end

data/etc/isolate/jruby-1.8/gems/treetop-1.4.8/lib/treetop/runtime/terminal_syntax_node.rb

@@ -0,0 +1,17 @@
+module Treetop
+  module Runtime
+    class TerminalSyntaxNode < SyntaxNode
+
+      def initialize(input, interval)
+        super(input, interval, [])
+      end
+
+      def inspect(indent="")
+	indent+
+	  self.class.to_s.sub(/.*:/,'') +
+	  " offset=#{interval.first}" +
+	  " #{text_value.inspect}"
+      end
+    end
+  end
+end

data/etc/isolate/jruby-1.8/gems/treetop-1.4.8/lib/treetop/runtime.rb

@@ -0,0 +1,6 @@
+require 'treetop/ruby_extensions'
+
+require 'treetop/runtime/compiled_parser'
+require 'treetop/runtime/syntax_node'
+require 'treetop/runtime/terminal_parse_failure'
+require 'treetop/runtime/interval_skip_list'

data/etc/isolate/jruby-1.8/gems/treetop-1.4.8/lib/treetop/version.rb

@@ -0,0 +1,9 @@
+module Treetop #:nodoc:
+  module VERSION #:nodoc:
+    MAJOR = 1
+    MINOR = 4
+    TINY  = 8
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/etc/isolate/jruby-1.8/gems/treetop-1.4.8/lib/treetop.rb

@@ -0,0 +1,3 @@
+require 'treetop/runtime'
+require 'treetop/compiler'
+require 'treetop/polyglot'