treetop 0.1.0 → 1.0.0

data/lib/treetop/compiler/node_classes/terminal.rb

@@ -0,0 +1,10 @@
+module Treetop
+  module Compiler    
+    class Terminal < AtomicExpression
+      def compile(address, builder, parent_expression = nil)
+        super
+        assign_result "parse_terminal(#{text_value}, #{node_class}#{optional_arg(inline_module_name)})"
+      end
+    end
+ end
+end

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

@@ -0,0 +1,109 @@
+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 << indent << "\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 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
+      
+      protected
+      
+      def indent
+        " " * level
+      end
+    end
+  end
+end

data/lib/treetop/ruby_extensions.rb

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

data/lib/treetop/ruby_extensions/string.rb

@@ -0,0 +1,19 @@
+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
+  
+  def blank?
+    self == ""
+  end
+end

data/lib/treetop/runtime.rb

@@ -0,0 +1,9 @@
+dir = File.dirname(__FILE__)
+require "#{dir}/runtime/compiled_parser"
+require "#{dir}/runtime/parse_result"
+require "#{dir}/runtime/syntax_node"
+require "#{dir}/runtime/parse_failure"
+require "#{dir}/runtime/node_cache"
+require "#{dir}/runtime/parse_cache"
+require "#{dir}/runtime/parse_failure"
+require "#{dir}/runtime/terminal_parse_failure"

data/lib/treetop/runtime/compiled_parser.rb

@@ -0,0 +1,66 @@
+module Treetop
+  module Runtime
+    class CompiledParser
+      include Treetop::Runtime
+      
+      attr_reader :input, :index
+
+      def parse(input)
+        prepare_to_parse(input)
+        return root
+      end
+      
+      protected
+      
+      attr_reader :node_cache
+      attr_writer :index
+              
+      def prepare_to_parse(input)
+        @input = input
+        reset_index
+        @node_cache = Hash.new {|hash, key| hash[key] = Hash.new}
+      end
+      
+      def reset_index
+        @index = 0
+      end
+      
+      def parse_char_class(char_class_re, char_class_string, node_class = SyntaxNode, inline_module = nil)
+        if input.index(char_class_re, index) == index
+          result = node_class.new(input, index...(index + 1))
+          result.extend(inline_module) if inline_module
+          @index += 1
+          result
+        else
+          terminal_parse_failure("[#{char_class_string}]")
+        end
+      end
+    
+      def parse_terminal(terminal_string, node_class = SyntaxNode, inline_module = nil)
+        if input.index(terminal_string, index) == index
+          result = node_class.new(input, index...(index + terminal_string.length))
+          result.extend(inline_module) if inline_module
+          @index += terminal_string.length
+          result
+        else
+          terminal_parse_failure(terminal_string)
+        end
+      end
+    
+      def parse_anything(node_class = SyntaxNode, inline_module = nil)
+        if index < input.length
+          result = node_class.new(input, index...(index + 1))
+          result.extend(inline_module) if inline_module
+          @index += 1
+          result
+        else
+          terminal_parse_failure("any character")
+        end
+      end
+    
+      def terminal_parse_failure(expected_string)
+        TerminalParseFailure.new(input, index, expected_string)
+      end
+    end
+  end
+end

data/lib/treetop/runtime/node_cache.rb

@@ -0,0 +1,27 @@
+module Treetop
+  module Runtime
+    class NodeCache
+      attr_reader :parse_results
+    
+      def initialize
+        @parse_results = {}
+      end
+  
+      def empty?
+        parse_results.empty?
+      end
+  
+      def store(parse_result)
+        if parse_result.failure?
+          parse_results[parse_result.index] = parse_result
+        else
+          parse_results[parse_result.interval.begin] = parse_result
+        end
+      end
+  
+      def [](start_index)
+        parse_results[start_index]
+      end
+    end
+  end
+end

data/lib/treetop/runtime/parse_cache.rb

@@ -0,0 +1,19 @@
+module Treetop
+  module Runtime
+    class ParseCache
+      attr_reader :node_caches
+    
+      def initialize
+        @node_caches = {}
+      end
+    
+      def [](parsing_expression)
+        node_caches[parsing_expression] ||= NodeCache.new
+      end
+    
+      def empty?
+        node_caches.empty?
+      end
+    end
+  end
+end

data/lib/treetop/runtime/parse_failure.rb

@@ -0,0 +1,32 @@
+module Treetop
+  module Runtime
+    class ParseFailure < ParseResult
+      attr_reader :index
+    
+      def initialize(input, index, nested_results = [])
+        super(input, nested_results)
+        @index = index
+      end
+      
+      def line
+        input.line_of(index)
+      end
+      
+      def column
+        input.column_of(index)
+      end
+    
+      def success?
+        false
+      end
+    
+      def failure?
+        true
+      end
+    
+      def interval      
+        @interval ||= (index...index)
+      end    
+    end
+  end
+end

data/lib/treetop/runtime/parse_result.rb

@@ -0,0 +1,30 @@
+module Treetop
+  module Runtime
+    class ParseResult
+      attr_reader :input, :nested_failures
+    
+      def initialize(input, nested_results = [])
+        @input = input
+        @nested_failures = collect_nested_failures_at_maximum_index(nested_results)
+      end
+    
+      def collect_nested_failures_at_maximum_index(results)
+        maximum_index = 0
+        nested_failures = []
+    
+        results.each do |result|
+          next if result.nested_failures.empty?
+          index_of_nested_failures = result.nested_failures.first.index
+          if index_of_nested_failures > maximum_index
+            maximum_index = index_of_nested_failures
+            nested_failures = result.nested_failures
+          elsif index_of_nested_failures == maximum_index
+            nested_failures += result.nested_failures
+          end
+        end
+      
+        return nested_failures.uniq
+      end
+    end
+  end
+end

data/lib/treetop/runtime/syntax_node.rb

@@ -0,0 +1,53 @@
+module Treetop
+  module Runtime
+    class SyntaxNode < ParseResult
+      attr_reader :input, :interval
+      
+      def initialize(input, interval, elements = nil, nested_results = elements)
+        super(input, nested_results || [])
+        @interval = interval
+        @elements = elements
+      end
+      
+      def success?
+        true
+      end
+    
+      def failure?
+        false
+      end
+
+      def terminal?
+        @elements.nil?
+      end
+      
+      def nonterminal?
+        !terminal?
+      end
+      
+      def elements
+        @elements || [self]
+      end
+      
+      def text_value
+        input[interval]
+      end
+      
+      def update_nested_results(nested_results)
+        new_nested_failures = collect_nested_failures_at_maximum_index(nested_results)
+      
+        return if new_nested_failures.empty?
+        @nested_failures = new_nested_failures and return if nested_failures.empty?
+      
+        current_nested_failure_index = nested_failures.first.index
+        new_nested_failure_index = new_nested_failures.first.index
+      
+        if new_nested_failure_index > current_nested_failure_index
+          @nested_failures = new_nested_failures
+        elsif new_nested_failure_index == current_nested_failure_index
+          @nested_failures += new_nested_failures
+        end
+      end
+    end
+  end
+end

data/lib/treetop/runtime/terminal_parse_failure.rb

@@ -0,0 +1,33 @@
+module Treetop
+  module Runtime
+    class TerminalParseFailure < ParseFailure
+      attr_reader :expected_string
+
+      def initialize(input, index, expected_string)
+        super(input, index)
+        @expected_string = expected_string      
+      end
+
+      def nested_failures
+        [self]
+      end
+      
+      def to_s
+        "String matching #{expected_string} expected at line #{line}, column #{column} (index #{index})."
+      end
+    
+      def ==(other_failure)
+        eql?(other_failure)
+      end
+    
+      def eql?(other_failure)
+        return false unless other_failure.instance_of?(TerminalParseFailure)
+        expected_string.eql?(other_failure.expected_string) && index.eql?(other_failure.index)
+      end
+    
+      def hash
+        [index, expected_string].hash
+      end
+    end
+  end
+end

data/lib/treetop/runtime/terminal_syntax_node.rb

@@ -0,0 +1,12 @@
+module Treetop
+  module Runtime
+    class TerminalSyntaxNode < SyntaxNode
+
+      def initialize(input, interval)
+        super(input, interval, [])
+      end
+
+      
+    end
+  end
+end