treetop 0.1.0 → 1.0.0

data/lib/treetop/grammar/grammar_builder.rb

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

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

data/lib/treetop/grammar/parsing_expression_builder_helper.rb

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,14 +0,0 @@
-module Treetop
-  class Optional < OrderedChoice
-    attr_reader :expression
-    
-    def initialize(optional_expression)
-      super([optional_expression, TerminalSymbol.epsilon])
-      @expression = optional_expression
-    end
-    
-    def to_s
-      "(#{expression.to_s})?"
-    end    
-  end
-end

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

@@ -1,27 +0,0 @@
-module Treetop
-  class OrderedChoice < NodePropagatingParsingExpression
-    attr_reader :alternatives
-    
-    def initialize(alternatives)
-      @alternatives = alternatives
-    end
-    
-    def to_s
-      parenthesize((alternatives.collect {|alt| alt.to_s}).join(" / "))
-    end
-    
-    def parse_at(input, start_index, parser)
-      failures = []
-      for alt in alternatives
-        result = alt.parse_at(input, start_index, parser)
-        if result.success?
-          result.update_nested_failures(collect_nested_failures(failures))
-          return result
-        else
-          failures << result
-        end
-      end
-      return failure_at(start_index, failures)
-    end
-  end
-end

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

@@ -1,36 +0,0 @@
-module Treetop
-  class ParsingExpression
-    def zero_or_more
-      ZeroOrMore.new(self)
-    end
-    
-    def one_or_more
-      OneOrMore.new(self)
-    end
-    
-    def optional
-      Optional.new(self)
-    end
-    
-    def and_predicate
-      AndPredicate.new(self)
-    end
-    
-    def not_predicate
-      NotPredicate.new(self)
-    end
-    
-    def parenthesize(string)
-      "(#{string})"
-    end
-    
-    protected
-    def failure_at(index, nested_results = [])
-      ParseFailure.new(index, collect_nested_failures(nested_results))
-    end
-    
-    def collect_nested_failures(results)
-      (results.collect {|result| result.nested_failures}).flatten
-    end
-  end
-end

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

@@ -1,25 +0,0 @@
-module Treetop
-  class Predicate < NodePropagatingParsingExpression
-    attr_reader :expression
-    
-    def initialize(expression)
-      @expression = expression
-    end
-        
-    def parse_at(input, start_index, parser)
-      result = expression.parse_at(input, start_index, parser)
-      
-      if result.success?
-        return child_expression_success(start_index, input, result)
-      else
-        return child_expression_failure(start_index, input, result)
-      end        
-    end
-    
-    protected
-    
-    def success_at(index, input, nested_results)
-      SyntaxNode.new(input, index...index, collect_nested_failures(nested_results))
-    end
-  end
-end