treetop 0.1.0

data/lib/treetop/parser.rb

@@ -0,0 +1,11 @@
+dir = File.dirname(__FILE__)
+require "#{dir}/parser/parser"
+require "#{dir}/parser/parse_result"
+require "#{dir}/parser/syntax_node"
+require "#{dir}/parser/terminal_syntax_node"
+require "#{dir}/parser/sequence_syntax_node"
+require "#{dir}/parser/parse_failure"
+require "#{dir}/parser/node_cache"
+require "#{dir}/parser/parse_cache"
+require "#{dir}/parser/parse_failure"
+require "#{dir}/parser/terminal_parse_failure"

data/lib/treetop/parser/node_cache.rb

@@ -0,0 +1,25 @@
+module Treetop
+  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

data/lib/treetop/parser/parse_cache.rb

@@ -0,0 +1,17 @@
+module Treetop
+  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

data/lib/treetop/parser/parse_failure.rb

@@ -0,0 +1,22 @@
+module Treetop
+  class ParseFailure < ParseResult
+    attr_reader :index
+    
+    def initialize(index, nested_failures = [])
+      super(nested_failures)
+      @index = index
+    end
+    
+    def success?
+      false
+    end
+    
+    def failure?
+      true
+    end
+    
+    def interval      
+      @interval ||= (index...index)
+    end    
+  end
+end

data/lib/treetop/parser/parse_result.rb

@@ -0,0 +1,26 @@
+module Treetop
+  class ParseResult
+    attr_reader :nested_failures
+    
+    def initialize(nested_failures = [])
+      @nested_failures = select_failures_at_maximum_index(nested_failures)
+    end
+    
+    protected
+    def select_failures_at_maximum_index(failures)
+      maximum_index = 0
+      failures_at_maximum_index = []
+      
+      failures.each do |failure|
+        if failure.index > maximum_index
+          failures_at_maximum_index = [failure]
+          maximum_index = failure.index
+        elsif failure.index == maximum_index
+          failures_at_maximum_index << failure
+        end
+      end
+      
+      return failures_at_maximum_index
+    end
+  end
+end

data/lib/treetop/parser/parser.rb

@@ -0,0 +1,24 @@
+module Treetop
+  class Parser
+    attr_reader :grammar, :parse_cache
+    
+    def initialize(grammar)
+      @grammar = grammar
+      @parse_cache = ParseCache.new      
+    end
+
+    def parse(input)
+      @parse_cache = ParseCache.new
+      result = grammar.root.parse_at(input, 0, self)
+      if result.success? and result.interval.end == input.size
+        return result
+      else        
+        return ParseFailure.new(result.interval.end, result.nested_failures)
+      end
+    end
+    
+    def node_cache_for(parsing_expression)
+      parse_cache[parsing_expression]
+    end
+  end
+end

data/lib/treetop/parser/sequence_syntax_node.rb

@@ -0,0 +1,14 @@
+module Treetop
+  class SequenceSyntaxNode < SyntaxNode
+    attr_reader :elements
+    
+    def initialize(input, interval, elements, nested_failures = [])
+      super(input, interval, nested_failures)
+      @elements = elements
+    end
+    
+    def empty?
+      elements.empty?
+    end
+  end
+end

data/lib/treetop/parser/syntax_node.rb

@@ -0,0 +1,31 @@
+module Treetop
+  class SyntaxNode < ParseResult
+    attr_reader :input, :interval
+    
+    def initialize(input, interval, nested_failures = [])
+      super(nested_failures)
+      @input = input
+      @interval = interval
+    end
+    
+    def update_nested_failures(failures)      
+      @nested_failures = select_failures_at_maximum_index(nested_failures + failures)
+    end
+        
+    def text_value
+      input[interval]
+    end
+    
+    def success?
+      true
+    end
+    
+    def failure?
+      false
+    end
+    
+    def epsilon?
+      false
+    end
+  end
+end

data/lib/treetop/parser/terminal_parse_failure.rb

@@ -0,0 +1,18 @@
+module Treetop
+  class TerminalParseFailure < ParseFailure
+    attr_reader :expression
+
+    def initialize(index, expression)
+      super(index)
+      @expression = expression      
+    end
+    
+    def nested_failures
+      [self]
+    end
+    
+    def to_s
+      "String matching #{expression} expected at position #{index}."
+    end
+  end
+end

data/lib/treetop/parser/terminal_syntax_node.rb

@@ -0,0 +1,7 @@
+module Treetop
+  class TerminalSyntaxNode < SyntaxNode    
+    def epsilon?
+      text_value.eql? ""
+    end
+  end
+end

data/lib/treetop/protometagrammar.rb

@@ -0,0 +1,16 @@
+dir = File.dirname(__FILE__)
+require "#{dir}/protometagrammar/protometagrammar"
+require "#{dir}/protometagrammar/grammar_expression_builder"
+require "#{dir}/protometagrammar/parsing_rule_sequence_expression_builder"
+require "#{dir}/protometagrammar/parsing_rule_expression_builder"
+require "#{dir}/protometagrammar/primary_expression_builder"
+require "#{dir}/protometagrammar/nonterminal_symbol_expression_builder"
+require "#{dir}/protometagrammar/terminal_symbol_expression_builder"
+require "#{dir}/protometagrammar/character_class_expression_builder"
+require "#{dir}/protometagrammar/anything_symbol_expression_builder"
+require "#{dir}/protometagrammar/sequence_expression_builder"
+require "#{dir}/protometagrammar/suffix_expression_builder"
+require "#{dir}/protometagrammar/prefix_expression_builder"
+require "#{dir}/protometagrammar/ordered_choice_expression_builder"
+require "#{dir}/protometagrammar/block_expression_builder"
+require "#{dir}/protometagrammar/trailing_block_expression_builder"

data/lib/treetop/protometagrammar/anything_symbol_expression_builder.rb

@@ -0,0 +1,13 @@
+module Treetop
+  class Protometagrammar
+    class AnythingSymbolExpressionBuilder < ParsingExpressionBuilder
+      def build
+        exp(".") do
+          def value(grammar = nil)
+            AnythingSymbol.new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/treetop/protometagrammar/block_expression_builder.rb

@@ -0,0 +1,17 @@
+module Treetop
+  class Protometagrammar
+    class BlockExpressionBuilder < ParsingExpressionBuilder
+      def build
+        seq('{', zero_or_more(choice(:block, anything_but_a_brace)), '}') do
+          def value
+            elements[1].text_value
+          end
+        end
+      end
+    
+      def anything_but_a_brace
+        seq(notp(choice('{', '}')), any)
+      end
+    end
+  end
+end

data/lib/treetop/protometagrammar/character_class_expression_builder.rb

@@ -0,0 +1,25 @@
+module Treetop
+  class Protometagrammar
+    class CharacterClassExpressionBuilder < ParsingExpressionBuilder
+      def build
+        character_class
+      end
+  
+      def character_class
+        seq('[', one_or_more(char_class_char), ']')  do
+          def value(grammar = nil)
+            CharacterClass.new(characters)
+          end
+      
+          def characters
+            elements[1].text_value
+          end
+        end
+      end
+  
+      def char_class_char
+        seq(notp(']'), choice(escaped(']'), any))
+      end
+    end
+  end
+end

data/lib/treetop/protometagrammar/grammar_expression_builder.rb

@@ -0,0 +1,38 @@
+module Treetop
+  class Protometagrammar
+    class GrammarExpressionBuilder < ParsingExpressionBuilder
+      def build
+        seq('grammar', :space, grammar_name, :parsing_rule_sequence, optional(:space), 'end') do
+          def value
+            grammar = Grammar.new(grammar_name)
+            parsing_rules(grammar).each do |parsing_rule|
+              grammar.add_parsing_rule(parsing_rule)
+            end
+            return grammar
+          end
+          
+          def grammar_name
+            name_string = elements[2].text_value.chop
+
+            if name_string.empty?
+              nil
+            else
+              name_string.to_sym
+            end
+          end
+        
+          def parsing_rules(grammar)
+            elements[3].value(grammar)
+          end
+        end
+      end
+    
+      def grammar_name
+        optional(
+          seq(char_class('A-Z'),
+              zero_or_more(char_class('a-z0-9_')),
+              :space))
+      end
+    end
+  end
+end

data/lib/treetop/protometagrammar/nonterminal_symbol_expression_builder.rb

@@ -0,0 +1,45 @@
+module Treetop
+  class Protometagrammar
+    class NonterminalSymbolExpressionBuilder < ParsingExpressionBuilder
+      def build
+        seq(notp(naked_keyword), nonterminal_symbol) do
+          def value(grammar)
+            nonterminal_symbol.value(grammar)
+          end
+        
+          def nonterminal_symbol
+            elements[1]
+          end
+        end
+      end
+
+      def naked_keyword
+        seq(:keyword, notp(alphanumeric_char))
+      end
+
+      def nonterminal_symbol
+        seq(alpha_char, zero_or_more(alphanumeric_char)) do
+          def value(grammar)
+            grammar.nonterminal_symbol(name)
+          end
+
+          def name
+            text_value.to_sym
+          end
+        end
+      end
+
+      def alpha_char
+        char_class('A-Za-z_')
+      end
+
+      def numeric_char
+        char_class('0-9')
+      end
+
+      def alphanumeric_char
+        choice(alpha_char, numeric_char)
+      end
+    end
+  end
+end

data/lib/treetop/protometagrammar/ordered_choice_expression_builder.rb

@@ -0,0 +1,21 @@
+module Treetop
+  class Protometagrammar  
+    class OrderedChoiceExpressionBuilder < ParsingExpressionBuilder
+      def build
+        choice(ordered_choice, :sequence)
+      end
+    
+      def ordered_choice
+        two_or_more_delimited(:sequence, seq(optional(:space), "/", optional(:space))) do
+          def value(grammar)
+            OrderedChoice.new(element_values(grammar))
+          end
+        
+          def element_values(grammar)
+            elements.collect { |element| element.value(grammar) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/treetop/protometagrammar/parsing_rule_expression_builder.rb

@@ -0,0 +1,23 @@
+module Treetop
+  class Protometagrammar
+    class ParsingRuleExpressionBuilder < ParsingExpressionBuilder
+      def build
+        seq('rule', :space, :nonterminal_symbol, :space, :ordered_choice, :space, 'end') do
+          def value(grammar)
+            ParsingRule.new(nonterminal_symbol.value(grammar),
+                            parsing_expression.value(grammar))
+          end
+        
+          def nonterminal_symbol
+            elements[2]
+          end
+        
+          def parsing_expression
+            elements[4]
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/treetop/protometagrammar/parsing_rule_sequence_expression_builder.rb

@@ -0,0 +1,14 @@
+module Treetop
+  class Protometagrammar
+    class ParsingRuleSequenceExpressionBuilder < ParsingExpressionBuilder
+      def build
+        zero_or_more_delimited(:parsing_rule, :space) do
+          def value(grammar)
+            elements.collect {|element| element.value(grammar) }
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/treetop/protometagrammar/prefix_expression_builder.rb

@@ -0,0 +1,25 @@
+module Treetop
+  class Protometagrammar
+    class PrefixExpressionBuilder < ParsingExpressionBuilder    
+      def build
+        choice(and_predicate, not_predicate)
+      end
+    
+      def and_predicate
+        exp('&') do
+          def value(parsing_expression)
+            parsing_expression.and_predicate
+          end
+        end
+      end
+
+      def not_predicate
+        exp('!') do
+          def value(parsing_expression)
+            parsing_expression.not_predicate
+          end
+        end
+      end
+    end
+  end
+end