treetop 0.1.0 → 1.0.0

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

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

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

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

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

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

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

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

data/lib/treetop/metagrammar/metagrammar.rb

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

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