treetop 0.1.0

data/lib/treetop.rb

@@ -0,0 +1,6 @@
+require "treetop/grammar"
+require "treetop/protometagrammar"
+require "treetop/parser"
+require "treetop/ruby_extension"
+require "treetop/metagrammar"
+require "treetop/api"

data/lib/treetop/api.rb

@@ -0,0 +1,3 @@
+dir = File.dirname(__FILE__)
+require "#{dir}/api/load_grammar"
+require "#{dir}/api/malformed_grammar_exception"

data/lib/treetop/api/load_grammar.rb

@@ -0,0 +1,16 @@
+class Object
+  def load_grammar(treetop_file_path)
+    treetop_file_path += ".treetop" unless treetop_file_path =~ /\.treetop$/
+    
+    File.open("#{treetop_file_path}", 'r') do |grammar_file|
+      result = Metagrammar.new_parser.parse(grammar_file.read)
+      
+      if result.success?
+        grammar = result.value
+        Object.instance_eval { const_set(grammar.name, grammar) }
+      else
+        raise MalformedGrammarException.new(result.nested_failures)
+      end
+    end
+  end
+end

data/lib/treetop/api/malformed_grammar_exception.rb

@@ -0,0 +1,9 @@
+class MalformedGrammarException < Exception
+  attr_reader :errors
+  
+  def initialize(errors)
+    @errors = errors
+    expected_expressions = errors.collect(&:expression)
+    super("String matching #{expected_expressions.join(' or ')} expected at position #{errors.first.index}.")
+  end
+end

data/lib/treetop/grammar.rb

@@ -0,0 +1,7 @@
+dir = File.dirname(__FILE__)
+require "#{dir}/grammar/grammar"
+require "#{dir}/grammar/parsing_expression_builder_helper"
+require "#{dir}/grammar/grammar_builder"
+require "#{dir}/grammar/parsing_expression_builder"
+require "#{dir}/grammar/parsing_expressions"
+require "#{dir}/grammar/parsing_rule"

data/lib/treetop/grammar/grammar.rb

@@ -0,0 +1,48 @@
+module Treetop
+  class Grammar
+    attr_accessor :root, :builder, :name
+    
+    def initialize(name = nil, &block)
+      @name = name
+      @parsing_rules = Hash.new
+      @nonterminal_symbols = Hash.new
+      self.builder = GrammarBuilder.new(self)
+      build &block if block
+    end
+
+    def new_parser
+      Parser.new(self)
+    end
+    
+    def nonterminal_symbol(ruby_sym)
+      @nonterminal_symbols[ruby_sym] ||= NonterminalSymbol.new(ruby_sym, self)
+    end
+    
+    def add_parsing_rule(parsing_rule_or_nonterminal, expression = nil)
+      rule = make_parsing_rule(parsing_rule_or_nonterminal, expression)
+      @parsing_rules[rule.nonterminal_symbol.name] = rule
+      self.root ||= rule.nonterminal_symbol
+    end
+    
+    def get_parsing_expression(nonterminal_symbol)
+      if @parsing_rules[nonterminal_symbol.name]
+        @parsing_rules[nonterminal_symbol.name].parsing_expression
+      else
+        raise "No parsing rule found named #{nonterminal_symbol}."
+      end
+    end
+    
+    def build(&block)
+      builder.build &block
+    end
+    
+    private
+    def make_parsing_rule(rule_or_nonterminal, expression)
+      if rule_or_nonterminal.is_a? NonterminalSymbol
+        return ParsingRule.new(rule_or_nonterminal, expression)
+      else
+        return rule_or_nonterminal
+      end
+    end
+  end
+end

data/lib/treetop/grammar/grammar_builder.rb

@@ -0,0 +1,35 @@
+module Treetop
+  class GrammarBuilder
+    attr_accessor :grammar
+    include ParsingExpressionBuilderHelper
+  
+    def initialize(grammar)
+      self.grammar = grammar
+    end
+  
+    def build(&block)
+      instance_eval(&block)
+    end
+      
+    def root(sym)
+      grammar.root = grammar.nonterminal_symbol(sym)
+    end
+  
+    def rule(nonterminal_name, expression_or_expression_builder)
+      nonterminal_symbol = grammar.nonterminal_symbol(nonterminal_name)
+      parsing_expression = parsing_expression_for(expression_or_expression_builder)
+
+      grammar.add_parsing_rule(nonterminal_symbol, parsing_expression)
+    end
+  
+    def parsing_expression_for(expression_or_expression_builder)
+      case expression_or_expression_builder
+      when ParsingExpression
+        return expression_or_expression_builder
+      when ParsingExpressionBuilder
+        expression_or_expression_builder.grammar = grammar
+        return expression_or_expression_builder.build
+      end
+    end
+  end
+end

data/lib/treetop/grammar/parsing_expression_builder.rb

@@ -0,0 +1,5 @@
+module Treetop
+  class ParsingExpressionBuilder
+    include ParsingExpressionBuilderHelper
+  end
+end

data/lib/treetop/grammar/parsing_expression_builder_helper.rb

@@ -0,0 +1,121 @@
+module Treetop
+  module ParsingExpressionBuilderHelper
+    attr_accessor :grammar
+  
+    def nonterm(symbol)
+      grammar.nonterminal_symbol(symbol)
+    end
+  
+    def term(string)
+      TerminalSymbol.new(string)
+    end
+
+    def exp(object, &block)
+      exp = case object
+            when String
+              term(object)
+            when Symbol
+              nonterm(object)
+            when ParsingExpression
+              object
+            when Array
+              object.map { |elt| exp(elt) }
+            else raise "Argument must be an instance of String, Symbol, or ParsingExpression"
+            end
+      exp.node_class_eval &block if block
+      exp
+    end
+  
+    def any
+      AnythingSymbol.new
+    end
+  
+    def char_class(char_class_string)
+      CharacterClass.new(char_class_string)
+    end
+  
+    def andp(expression)
+      exp(expression).and_predicate
+    end
+  
+    def notp(expression)
+      exp(expression).not_predicate
+    end
+  
+    def optional(expression)
+      exp(expression).optional
+    end
+  
+    def seq(*expressions, &block)
+      sequence = Sequence.new(exp(expressions))
+      sequence.node_class_eval &block if block
+      return sequence
+    end
+  
+    def choice(*expressions)
+      OrderedChoice.new(exp(expressions))
+    end
+  
+    def zero_or_more(expression)
+      exp(expression).zero_or_more
+    end
+
+    def one_or_more(expression)
+      exp(expression).one_or_more
+    end
+  
+    def escaped(character)
+      seq('\\', character)
+    end
+  
+    def zero_or_more_delimited(expression, delimiter, &block)
+      n_or_more_delimited(0, expression, delimiter, &block)
+    end
+  
+    def two_or_more_delimited(expression, delimiter, &block)
+      n_or_more_delimited(2, expression, delimiter, &block)    
+    end
+
+    def n_or_more_delimited(n, expression, delimiter, &block)
+      expression = exp(expression)
+      delimiter = exp(delimiter)
+        
+      delimited_sequence = seq(delimited_sequence_head(n, expression), 
+                               delimited_sequence_tail(n, expression, delimiter)) do
+        def elements
+          return [] if super[0].epsilon?
+          [super[0]] + super[1].elements
+        end
+      end  
+      delimited_sequence.node_class_eval(&block) if block
+
+      return delimited_sequence
+    end
+  
+    def delimited_sequence_head(n, expression)
+      n == 0 ? optional(expression) : expression
+    end
+    
+    def delimited_sequence_tail(n, expression, delimiter)
+      if n > 1
+        tail_elements = one_or_more(delimited_sequence_tail_element(n, expression, delimiter))
+      else
+        tail_elements = zero_or_more(delimited_sequence_tail_element(n, expression, delimiter))
+      end
+      tail_elements.node_class_eval do
+        def elements
+          super.map {|elt| elt.element}
+        end
+      end
+      return tail_elements
+    end
+
+    def delimited_sequence_tail_element(n, expression, delimiter)
+      seq(delimiter, expression) do
+        def element
+          elements[1]
+        end
+      end
+    end
+  end
+end

data/lib/treetop/grammar/parsing_expressions.rb

@@ -0,0 +1,18 @@
+dir = File.dirname(__FILE__)
+require "#{dir}/parsing_expressions/parsing_expression"
+require "#{dir}/parsing_expressions/node_instantiating_parsing_expression"
+require "#{dir}/parsing_expressions/node_propagating_parsing_expression"
+require "#{dir}/parsing_expressions/terminal_parsing_expression"
+require "#{dir}/parsing_expressions/terminal_symbol"
+require "#{dir}/parsing_expressions/anything_symbol"
+require "#{dir}/parsing_expressions/character_class"
+require "#{dir}/parsing_expressions/nonterminal_symbol"
+require "#{dir}/parsing_expressions/sequence"
+require "#{dir}/parsing_expressions/ordered_choice"
+require "#{dir}/parsing_expressions/repeating_parsing_expression"
+require "#{dir}/parsing_expressions/zero_or_more"
+require "#{dir}/parsing_expressions/one_or_more"
+require "#{dir}/parsing_expressions/optional"
+require "#{dir}/parsing_expressions/predicate"
+require "#{dir}/parsing_expressions/and_predicate"
+require "#{dir}/parsing_expressions/not_predicate"

data/lib/treetop/grammar/parsing_expressions/and_predicate.rb

@@ -0,0 +1,17 @@
+module Treetop
+  class AndPredicate < Predicate    
+    def to_s
+      "&(#{expression.to_s})"
+    end
+    
+    protected
+    
+    def child_expression_success(index, input, result)
+      return success_at(index, input, [result])
+    end
+    
+    def child_expression_failure(index, input, result)
+      return failure_at(index, [result])
+    end
+  end
+end

data/lib/treetop/grammar/parsing_expressions/anything_symbol.rb

@@ -0,0 +1,20 @@
+module Treetop
+  class AnythingSymbol < TerminalParsingExpression
+    def initialize
+      super
+    end
+    
+    def parse_at(input, start_index, parser)
+      if start_index < input.length
+        interval = (start_index...(start_index + 1))
+        return node_class.new(input, interval)
+      else
+        TerminalParseFailure.new(start_index, self)
+      end
+    end
+    
+    def to_s
+      '.'
+    end
+  end
+end

data/lib/treetop/grammar/parsing_expressions/character_class.rb

@@ -0,0 +1,24 @@
+module Treetop
+  class CharacterClass < TerminalParsingExpression
+
+    attr_reader :char_class_string, :prefix_regex
+    
+    def initialize(char_class_string)
+      super()
+      @char_class_string = char_class_string
+      @prefix_regex = Regexp.new("[#{char_class_string}]")
+    end
+    
+    def parse_at(input, start_index, parser)
+      if input.index(prefix_regex, start_index) == start_index
+        return node_class.new(input, start_index...(start_index + 1))
+      else
+        TerminalParseFailure.new(start_index, self)
+      end
+    end
+    
+    def to_s
+      return "[#{char_class_string}]"
+    end 
+  end
+end

data/lib/treetop/grammar/parsing_expressions/node_instantiating_parsing_expression.rb

@@ -0,0 +1,14 @@
+module Treetop
+  class NodeInstantiatingParsingExpression < ParsingExpression
+    attr_reader :node_class
+    
+    def initialize
+      @node_class = Class.new(node_superclass)
+    end
+    
+    def node_class_eval(string = nil, &block)      
+      node_class.class_eval(string) if string
+      node_class.class_eval(&block) if block
+    end
+  end
+end

data/lib/treetop/grammar/parsing_expressions/node_propagating_parsing_expression.rb

@@ -0,0 +1,4 @@
+module Treetop
+  class NodePropagatingParsingExpression < ParsingExpression
+  end
+end

data/lib/treetop/grammar/parsing_expressions/nonterminal_symbol.rb

@@ -0,0 +1,42 @@
+module Treetop
+  class NonterminalSymbol < NodePropagatingParsingExpression
+    attr_reader :name, :grammar
+    
+    def initialize(name, grammar)
+      @name = name
+      @grammar = grammar
+    end
+        
+    def parsing_expression
+      grammar.get_parsing_expression(self)
+    end
+    
+    def to_s
+      name.to_s
+    end
+
+    def parse_at(input, start_index, parser)
+      node_cache = parser.node_cache_for(self)
+      if cached_result = node_cache[start_index]
+        return cached_result
+      else
+        return node_cache.store(parse_at_without_caching(input, start_index, parser))
+      end
+    end
+    
+    protected
+    def parse_at_without_caching(input, start_index, parser)
+      result = parsing_expression.parse_at(input, start_index, parser)
+      
+      if result.success?
+        result
+      else
+        return failure_at(start_index, result.nested_failures)
+      end
+    end
+    
+    def node_cache(parser)
+      parser.node_cache_for(self)
+    end
+  end
+end

data/lib/treetop/grammar/parsing_expressions/not_predicate.rb

@@ -0,0 +1,18 @@
+module Treetop
+  class NotPredicate < Predicate
+    def to_s
+      "!(#{expression.to_s})"
+    end
+    
+    protected
+    
+    def child_expression_success(index, input, result)
+      return failure_at(index, [result])
+    end
+    
+    def child_expression_failure(index, input, result)
+      return success_at(index, input, [result])
+    end
+    
+  end
+end

data/lib/treetop/grammar/parsing_expressions/one_or_more.rb

@@ -0,0 +1,12 @@
+module Treetop
+  class OneOrMore < RepeatingParsingExpression
+    
+    def enough?(results)
+      !results.empty?
+    end
+    
+    def to_s
+      "(#{repeated_expression.to_s})+"
+    end
+  end
+end