treetop 0.1.0

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

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

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

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

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

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

@@ -0,0 +1,29 @@
+module Treetop
+  class RepeatingParsingExpression < Sequence
+    attr_reader :repeated_expression
+    
+    def initialize(repeated_expression)
+      super
+      @repeated_expression = repeated_expression
+    end
+
+    def parse_at(input, start_index, parser)
+      results = []
+      next_index = start_index
+      
+      while true
+        result = repeated_expression.parse_at(input, next_index, parser)
+        break if result.failure?
+        results << result
+        next_index = result.interval.end
+      end
+            
+      if enough? results
+        interval = start_index...next_index
+        return success(input, interval, results, results + [result])
+      else
+        return failure_at(start_index, results + [result])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module Treetop
+  class Sequence < NodeInstantiatingParsingExpression
+    attr_reader :elements, :node_class
+    
+    def initialize(elements)
+      super()
+      @elements = elements
+    end
+    
+    def node_superclass
+      SequenceSyntaxNode
+    end
+        
+    def to_s
+      parenthesize((@elements.collect {|elt| elt.to_s}).join(" "))
+    end
+
+    def parse_at(input, start_index, parser)
+      results = []
+      next_index = start_index
+      
+      for elt in elements
+        result = elt.parse_at(input, next_index, parser)
+        results << result
+        return failure_at(start_index, results) if result.failure?
+        next_index = result.interval.end
+      end
+      
+      success(input, start_index...next_index, results, results)
+    end
+    
+    protected
+
+    def success(input, interval, results, encountered_child_results)
+      return node_class.new(input,
+                            interval,
+                            results,
+                            collect_nested_failures(encountered_child_results))
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module Treetop
+  class TerminalParsingExpression < NodeInstantiatingParsingExpression
+    def initialize
+      super
+    end
+      
+    def node_superclass
+      TerminalSyntaxNode
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module Treetop
+  class TerminalSymbol < TerminalParsingExpression
+    attr_accessor :prefix
+    
+    def self.epsilon
+      @epsilon ||= self.new("")
+    end
+    
+    def initialize(prefix)
+      super()
+      self.prefix = prefix
+    end
+    
+    def epsilon?
+      prefix.blank?
+    end
+            
+    def to_s
+      "\"#{prefix}\""
+    end
+    
+    def parse_at(input, start_index, parser)
+      
+      if input.index(prefix, start_index) == start_index
+        return node_class.new(input, start_index...(prefix.length + start_index))
+      else
+        TerminalParseFailure.new(start_index, self)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module Treetop
+  class ZeroOrMore < RepeatingParsingExpression
+    def enough?(results)
+      true
+    end
+    
+    def to_s
+      "(#{repeated_expression.to_s})*"
+    end
+  end
+end

data/lib/treetop/grammar/parsing_rule.rb

@@ -0,0 +1,10 @@
+module Treetop
+  class ParsingRule
+    attr_reader :nonterminal_symbol, :parsing_expression
+    
+    def initialize(nonterminal_symbol, parsing_expression)
+      @nonterminal_symbol = nonterminal_symbol
+      @parsing_expression = parsing_expression
+    end
+  end
+end

data/lib/treetop/metagrammar.rb

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

data/lib/treetop/metagrammar/metagrammar.rb

@@ -0,0 +1,14 @@
+module Treetop
+  metagrammar_parser = Protometagrammar.new.new_parser
+  
+  File.open(File.expand_path('metagrammar.treetop', File.dirname(__FILE__)), 'r') do |file|
+    metagrammar_text = file.read
+    result = metagrammar_parser.parse(metagrammar_text)
+    
+    unless result.success?
+      raise 'unable to parse metagrammar'
+    end
+    
+    Metagrammar = result.value
+  end
+end

data/lib/treetop/metagrammar/metagrammar.treetop

@@ -0,0 +1,320 @@
+grammar Metagrammar
+  rule grammar
+    ('grammar' space grammar_name? parsing_rule_sequence space? 'end') {
+      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
+				if elements[2].epsilon?
+					nil
+				else
+					elements[2].value
+				end
+			end
+
+      def parsing_rules(grammar)
+        elements[3].value(grammar)
+      end
+    }
+  end
+
+  rule grammar_name
+    ([A-Z] alphanumeric_char*) space {    
+      def value
+        elements[0].text_value.to_sym
+      end
+    }
+  end
+
+	rule parsing_rule_sequence
+		(parsing_rule (space parsing_rule)*) {
+			def value(grammar)
+				[head.value(grammar)] + tail_values(grammar)
+			end
+		
+			def head
+				elements[0]
+			end
+					
+			def tail_elements
+				elements[1].elements
+			end
+		
+			def tail_values(grammar)
+				tail_elements.collect {|tail_element| tail_element.elements[1].value(grammar)}
+			end
+		}
+		/
+		'' {
+		  def value(grammar)
+		    []
+		  end
+		}
+	end
+
+	rule parsing_rule
+		('rule' space nonterminal_symbol space ordered_choice space 'end') {
+			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
+
+	rule ordered_choice
+		(sequence (space? '/' space? sequence)+) {
+			def value(grammar)
+				OrderedChoice.new(alternatives(grammar))
+			end
+		
+			def alternatives(grammar)
+				[head.value(grammar)] + tail_values(grammar)
+			end
+		
+			def head
+				elements[0]
+			end
+		
+			def tail_elements
+				elements[1].elements
+			end
+		
+			def tail_values(grammar)
+				tail_elements.map {|tail_element| tail_element.elements[3].value(grammar)}
+			end
+		}
+		/
+		sequence
+	end
+
+	rule sequence
+		(primary (space primary)+ trailing_block)	{
+			def value(grammar)
+				trailing_block.value(Sequence.new(sequence_elements(grammar)))
+			end
+		
+			def trailing_block
+				elements[2]
+			end
+	
+			def sequence_elements(grammar)
+				[head.value(grammar)] + tail_values(grammar)
+			end
+	
+			def head
+				elements[0]
+			end
+	
+			def tail_elements
+				elements[1].elements
+			end
+	
+			def tail_values(grammar)
+				tail_elements.map {|tail_element| tail_element.elements[1].value(grammar)}
+			end
+		}
+		/
+		primary
+	end
+
+	rule parenthesized_ordered_choice
+		'(' space? ordered_choice space? ')' trailing_block {
+			def value(grammar)
+	       nested_value = nested_expression.value(grammar)
+	       unless trailing_block.epsilon? || nested_value.kind_of?(NodeInstantiatingParsingExpression)
+	         raise "Blocks can only follow node-instantiating parsing expressions such as sequences and terminal symbols."
+	       end
+	       return trailing_block.value(nested_expression.value(grammar))
+	     end
+     
+			def nested_expression
+	      elements[2]
+	    end
+ 
+	    def trailing_block
+	      elements[5]
+	    end
+		}
+	end
+
+	rule primary
+		(prefix? ((parenthesized_ordered_choice / terminal_symbol / nonterminal_symbol) suffix?)) {
+			def value(grammar)
+				value = primary_expression.value(grammar)
+				value = suffix.value(value) unless suffix.epsilon?
+				value = prefix.value(value) unless prefix.epsilon?
+				value
+			end
+	
+			def prefix
+				elements[0]
+			end
+		
+			def primary_expression
+				elements[1].elements[0]
+			end
+		
+			def suffix
+				elements[1].elements[1]
+			end
+		}
+	end	
+	
+	rule prefix
+		'&' {
+			def value(parsing_expression)
+				parsing_expression.and_predicate
+			end
+		}
+		/
+		'!' {
+			def value(parsing_expression)
+				parsing_expression.not_predicate
+			end
+		}
+	end
+
+	rule suffix
+		'*' {
+			def value(parsing_expression)
+				parsing_expression.zero_or_more
+			end
+		}
+		/
+		'+' {
+			def value(parsing_expression)
+				parsing_expression.one_or_more
+			end
+		}
+		/
+		'?' {
+			def value(parsing_expression)
+				parsing_expression.optional
+			end
+		}
+	end
+	
+	rule nonterminal_symbol
+		(!(keyword !alphanumeric_char) (alpha_char alphanumeric_char*)) {
+			def value(grammar)
+				grammar.nonterminal_symbol(name)
+			end
+		
+			def name
+				elements[1].text_value.to_sym
+			end
+		}
+	end
+
+	rule alpha_char
+		[A-Za-z_]
+	end
+
+	rule alphanumeric_char
+		alpha_char / [0-9]
+	end
+
+	rule terminal_symbol
+		terminal_symbol_prefix trailing_block {
+			def value(grammar = nil)
+	     	trailing_block.value(terminal_symbol.value)
+	     end
+     
+	     def terminal_symbol
+	       elements[0]
+	     end
+     
+	     def trailing_block
+	       elements[1]
+	   	end
+		}
+	end
+
+	rule terminal_symbol_prefix
+		single_quoted_string / double_quoted_string / character_class / anything_symbol
+	end
+
+	rule double_quoted_string
+		('"' (!'"' ('\"' / .))* '"') {
+			def value
+				TerminalSymbol.new(elements[1].text_value)
+			end
+		}
+	end
+
+	rule single_quoted_string
+		("'" (!"'" ("\'" / .))* "'") {
+			def value
+				TerminalSymbol.new(elements[1].text_value)
+			end
+		}
+	end
+
+  rule trailing_block
+    space block {
+      def value(parsing_expression)
+        parsing_expression.node_class_eval(block.value)
+        return parsing_expression
+      end
+
+      def block
+        elements[1]
+      end
+    }
+    /
+    '' {
+      def value(parsing_expression)
+        parsing_expression
+      end
+    }
+  end
+  
+  rule block
+    ('{' (block / ![{}] .)* '}') {
+      def value
+        elements[1].text_value
+      end
+    }
+  end
+
+  rule character_class
+    ('[' (!']' ('\]'/.))+ ']') {      
+      def value(grammar = nil)
+        CharacterClass.new(characters)
+      end
+
+      def characters
+        elements[1].text_value
+      end    
+    }
+  end
+  
+  rule keyword
+    'rule' / 'end'
+  end
+
+  rule anything_symbol
+    '.' {
+      def value(grammar = nil)
+        AnythingSymbol.new
+      end
+    }
+  end
+  
+  rule space
+    [ \t\n\r]+
+  end
+end