dhaka 2.0.0 → 2.0.1

data/lib/dhaka.rb

@@ -21,26 +21,28 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #++
 
-module Dhaka
-end
+require 'set'
+require 'logger'
+require 'delegate'
 
-require File.dirname(__FILE__)+'/grammar/grammar_symbol'
-require File.dirname(__FILE__)+'/grammar/production'
-require File.dirname(__FILE__)+'/grammar/closure_hash'
-require File.dirname(__FILE__)+'/grammar/grammar'
-require File.dirname(__FILE__)+'/grammar/precedence'
-
-require File.dirname(__FILE__)+'/parser/parse_result'
-require File.dirname(__FILE__)+'/parser/item'
-require File.dirname(__FILE__)+'/parser/channel'
-require File.dirname(__FILE__)+'/parser/parser_methods'
-require File.dirname(__FILE__)+'/parser/parse_tree'
-require File.dirname(__FILE__)+'/parser/parser_state'
-require File.dirname(__FILE__)+'/parser/token'
-require File.dirname(__FILE__)+'/parser/action'
-require File.dirname(__FILE__)+'/parser/parser_run'
-require File.dirname(__FILE__)+'/parser/parser'
-require File.dirname(__FILE__)+'/parser/compiled_parser'
-
-require File.dirname(__FILE__)+'/tokenizer/tokenizer'
-require File.dirname(__FILE__)+'/evaluator/evaluator'
+%w[
+grammar/grammar_symbol
+grammar/production
+grammar/closure_hash
+grammar/grammar
+grammar/precedence
+parser/parse_tree
+parser/parse_result
+parser/item
+parser/channel
+parser/parser_methods
+parser/parser_state
+parser/conflict
+parser/token
+parser/action
+parser/parser_run
+parser/parser
+parser/compiled_parser
+tokenizer/tokenizer
+evaluator/evaluator
+].each {|path| require File.join(File.dirname(__FILE__), path)}

data/lib/evaluator/evaluator.rb

@@ -1,5 +1,4 @@
 module Dhaka
-
   # This is the abstract base evaluator class. It is not directly instantiated.
   # When defining an evaluator for a specific grammar, we subclass it. e.g. for FooGrammar
   # we create a FooEvaluator that subclasses Evaluator. Note that FooEvaluator may not
@@ -55,61 +54,60 @@ module Dhaka
   #      end
   #
   #    end
-      
-  
   class Evaluator
+    class << self
+      def inherited(evaluator)
+        class << evaluator
+          attr_accessor :grammar, :actions
+        end
+      end
+    
+      def method_missing(method_name, *args, &blk)
+        name = method_name.to_s
+        if name =~ /^for_(.+)$/
+          rule_name = $1
+          actions   << rule_name
+          send(:define_method, rule_name, &blk)
+        else
+          super
+        end
+      end
+      
+      # Evaluation rules are defined within a block passed to this method.
+      def define_evaluation_rules
+        self.actions = []
+        yield
+        check_definitions
+      end
+      
+      private
 
-    # Instantiates a new evaluator with the syntax tree of a parsed expression. Only subclasses
-    # of Evaluator are directly instantiated.
+      def check_definitions
+        filter = lambda {|productions| productions.map {|production| production.name} - actions}
+        pass_through_productions_without_rules = filter[grammar.productions.select {|production| production.expansion.size == 1}]
+        pass_through_productions_without_rules.each do |rule_name|
+          send(:define_method, rule_name) do
+            evaluate(child_nodes.first)
+          end
+        end
+        non_trivial_productions_with_rules_undefined = filter[grammar.productions.select {|production| production.expansion.size != 1}]
+        raise EvaluatorDefinitionError.new(non_trivial_productions_with_rules_undefined) unless non_trivial_productions_with_rules_undefined.empty?
+      end
+    end
 
     # Evaluate a syntax tree node.
     def evaluate node
       @node_stack ||= []
       @node_stack << node.child_nodes
-      result = self.send(node.production.name)
+      result      = send(node.production.name)
       @node_stack.pop
       result
     end
 
-    # Performs the pass-through calculations for nodes with only one child_node for which an
-    # evaluation rule is not explicitly defined. Will probably be deprecated in future versions.
-    def method_missing(method_name)
-      evaluate(child_nodes[0])
-    end
-
     # Returns the array of child nodes of the node being currently evaluated. 
     def child_nodes
-      @node_stack[-1]
+      @node_stack.last
     end
-
-    # Evaluation rules are defined within a block passed to this method.
-    def self.define_evaluation_rules
-      self.actions = []
-      yield
-      check_definitions
-    end
-  
-    private
-  
-    def self.inherited(evaluator)
-      class << evaluator
-        attr_accessor :grammar, :actions
-      end
-    end
-  
-    def self.method_missing(method_name, &blk)
-      if method_name.to_s =~ /^for_*/
-        rule_name = method_name.to_s[4..-1]
-        self.actions << rule_name
-        self.send(:define_method, rule_name, &blk)
-      end 
-    end
-
-    def self.check_definitions
-      non_trivial_productions_with_rules_undefined = self.grammar.productions.select {|production| production.expansion.size != 1}.collect {|production| production.name} - self.actions
-      raise EvaluatorDefinitionError.new(non_trivial_productions_with_rules_undefined) unless non_trivial_productions_with_rules_undefined.empty?
-    end
-  
   end
 
   class EvaluatorDefinitionError < StandardError #:nodoc:
@@ -118,8 +116,8 @@ module Dhaka
     end
   
     def to_s
-        result = "The following non-trivial productions do not have any evaluation rules defined:\n" 
-        result << (@non_trivial_productions_with_rules_undefined).join("\n")
+      result = "The following non-trivial productions do not have any evaluation rules defined:\n" 
+      result << @non_trivial_productions_with_rules_undefined.join("\n")
     end
   end
 end

data/lib/grammar/closure_hash.rb

@@ -1,12 +1,13 @@
-#!/usr/bin/env ruby
 module Dhaka
   # A subclass of Hash with a dirty flag
   class ClosureHash < Hash #:nodoc:
     attr_accessor :dirty
-    def initialize(&block)
-      super(&block)
+
+    def initialize
+      super
       @dirty = false
     end
+
     def load_set(set)
       set.each {|item| self[item] = item}
     end

data/lib/grammar/grammar.rb

@@ -1,10 +1,8 @@
-#!/usr/bin/env ruby
-require 'set'
 module Dhaka
   
   # Reserved name for the start symbol for all grammars. 
   START_SYMBOL_NAME = "_Start_"
-  END_SYMBOL_NAME = "_End_" #:nodoc:
+  END_SYMBOL_NAME   = "_End_" #:nodoc:
   
   # Productions for specific grammar symbols are defined in the context of this class.
   class ProductionBuilder
@@ -12,7 +10,7 @@ module Dhaka
     # +symbol+ is the grammar symbol that productions are being defined for.
     def initialize(grammar, symbol)
       @grammar = grammar
-      @symbol = symbol
+      @symbol  = symbol
     end
   
     # Creates a new production for +symbol+ with an expansion of +expansion+. The options hash can include
@@ -22,11 +20,13 @@ module Dhaka
     # See the arithmetic precedence grammar in the test suites for an example.
     def method_missing(production_name, expansion, options = {})
       expansion_symbols = expansion.collect {|name| @grammar.symbols[name]}
+      production_args   = [@symbol, expansion_symbols, production_name.to_s]
       if precedence_symbol_name = options[:prec] 
-        production = Production.new(@symbol, expansion_symbols, production_name.to_s, @grammar.symbol_for_name(precedence_symbol_name).precedence)
-      else
-        production = Production.new(@symbol, expansion_symbols, production_name.to_s)
+        production_args << @grammar.symbol_for_name(precedence_symbol_name).precedence
       end
+      
+      production = Production.new(*production_args)
+      
       @symbol.nullable = true if expansion_symbols.empty?
       @grammar.productions_by_symbol[production.symbol] << production
       raise "Duplicate production named #{production.name}" if @grammar.productions_by_name[production.name]
@@ -40,9 +40,10 @@ module Dhaka
   # See the arithmetic precedence grammar in the test suites for an example.
   class PrecedenceBuilder
     def initialize(grammar) #:nodoc:
-      @grammar = grammar
+      @grammar          = grammar
       @precedence_level = 0
     end
+    
     [:left, :right, :nonassoc].each do |associativity| 
       define_method(associativity) do |symbols|
         assign_precedences associativity, symbols
@@ -52,7 +53,7 @@ module Dhaka
     private
     def assign_precedences(associativity, symbol_names)
       symbol_names.each do |symbol_name|
-        symbol = @grammar.symbols[symbol_name]
+        symbol            = @grammar.symbols[symbol_name]
         symbol.precedence = Precedence.new(@precedence_level, associativity)
       end
       @precedence_level += 1
@@ -91,119 +92,121 @@ module Dhaka
   #  end
   #
   class Grammar
-
-    # Used for defining the productions for the symbol with name +symbol+. The block +blk+ is 
-    # evaluated in the context of a ProductionBuilder.
-    def self.for_symbol symbol, &blk
-      symbol = symbols[symbol]
-      symbol.non_terminal = true
-      ProductionBuilder.new(self, symbol).instance_eval(&blk)
-    end
-
-    # Used for defining the precedences and associativities of symbols. The block +blk+ is
-    # evaluated in the context of a PrecedenceBuilder.
-    def self.precedences &blk
-      PrecedenceBuilder.new(self).instance_eval(&blk)
-    end
-
-    # Returns the grammar symbol identified by +name+
-    def self.symbol_for_name(name)
-      if symbols.has_key? name
-        symbols[name]
-      else
-        raise "No symbol with name #{name} found"
+    class << self
+      # Used for defining the productions for the symbol with name +symbol+. The block +blk+ is 
+      # evaluated in the context of a ProductionBuilder.
+      def for_symbol symbol, &blk
+        symbol              = symbols[symbol]
+        symbol.non_terminal = true
+        ProductionBuilder.new(self, symbol).instance_eval(&blk)
       end
-    end
 
-    private
-    
-    def self.inherited(grammar)
-      class << grammar
-        attr_accessor :symbols, :productions_by_symbol, :productions_by_name, :start_symbol, :end_symbol, :__first_cache
+      # Used for defining the precedences and associativities of symbols. The block +blk+ is
+      # evaluated in the context of a PrecedenceBuilder.
+      def precedences &blk
+        PrecedenceBuilder.new(self).instance_eval(&blk)
       end
-      grammar.symbols = Hash.new {|hash, name| hash[name] = GrammarSymbol.new(name)}
-      grammar.productions_by_symbol = Hash.new {|hash, name| hash[name] = Set.new([])}
-      grammar.productions_by_name = {}
-      grammar.end_symbol = grammar.symbols[END_SYMBOL_NAME]
-      grammar.start_symbol = grammar.symbols[START_SYMBOL_NAME]
-      grammar.__first_cache = {}
-    end
-
-    def self.productions_for_symbol(symbol)
-      productions_by_symbol[symbol]
-    end
-
-    def self.productions
-      productions_by_name.values
-    end
-
-    def self.production_named(name)
-      productions_by_name[name]
-    end
-
-
-    def self.terminal_symbols
-      symbols.values.select {|symbol| symbol.terminal}
-    end
-
-    def self.non_terminal_symbols
-      symbols.values.select {|symbol| symbol.non_terminal}
-    end
-
-    def self.closure(kernel)
-      channels = Set.new
 
-      result = compute_closure(kernel) do |hash, item|    
-        if item.next_symbol and item.next_symbol.non_terminal
-          productions_by_symbol[item.next_symbol].each do |production|
-            channels << spontaneous_channel(item, hash[Item.new(production, 0)])
-          end
+      # Returns the grammar symbol identified by +name+
+      def symbol_for_name(name)
+        if symbols.has_key? name
+          symbols[name]
+        else
+          raise "No symbol with name #{name} found"
         end
       end
+      
+      def productions
+        productions_by_name.values
+      end
+      
+      def productions_for_symbol(symbol)
+        productions_by_symbol[symbol]
+      end
+      
+      def closure(kernel)
+        channels = Set.new
+
+        result = compute_closure(kernel) do |hash, item|    
+          if item.next_symbol and item.next_symbol.non_terminal
+            productions_by_symbol[item.next_symbol].each do |production|
+              channels << spontaneous_channel(item, hash[Item.new(production, 0)])
+            end
+          end
+        end
 
-      return channels, result
-    end
+        [channels, result]
+      end
+      
+      def passive_channel(start_item, end_item)
+        PassiveChannel.new(self, start_item, end_item)
+      end
+      
+      def first(given_symbol)
+        cached_result = __first_cache[given_symbol] 
+        return cached_result if cached_result
+        result = compute_closure([given_symbol]) do |hash, symbol|
+              productions_by_symbol[symbol].each do |production| 
+                symbol_index = 0
+                while next_symbol = production.expansion[symbol_index]
+                  hash[next_symbol]
+                  break unless next_symbol.nullable
+                  symbol_index += 1
+                end
+              end if symbol.non_terminal
+          end.values.select {|symbol| symbol.terminal}.to_set
+        __first_cache[given_symbol] = result
+        result
+      end
+      
+      def production_named(name)
+        productions_by_name[name]
+      end
+      
+      def terminal_symbols
+        symbols.values.select {|symbol| symbol.terminal}
+      end
 
-    def self.first(given_symbol)
-      cached_result = self.__first_cache[given_symbol] 
-      return cached_result if cached_result
-      result = compute_closure([given_symbol]) do |hash, symbol|
-            productions_by_symbol[symbol].each do |production| 
-              symbol_index = 0
-              while next_symbol = production.expansion[symbol_index]
-                hash[next_symbol]
-                break if !next_symbol.nullable
-                symbol_index += 1
-              end
-            end if symbol.non_terminal
-        end.values.select {|symbol| symbol.terminal}.to_set
-      self.__first_cache[given_symbol] = result
-      result
-    end
+      def non_terminal_symbols
+        symbols.values.select {|symbol| symbol.non_terminal}
+      end
+      
+      private 
+      
+        def inherited(grammar)
+          class << grammar
+            attr_accessor :symbols, :productions_by_symbol, :productions_by_name, :start_symbol, :end_symbol, :__first_cache
+          end
+          grammar.symbols               = Hash.new {|hash, name| hash[name] = GrammarSymbol.new(name)}
+          grammar.productions_by_symbol = Hash.new {|hash, name| hash[name] = Set.new([])}
+          grammar.productions_by_name   = {}
+          grammar.end_symbol            = grammar.symbols[END_SYMBOL_NAME]
+          grammar.start_symbol          = grammar.symbols[START_SYMBOL_NAME]
+          grammar.__first_cache         = {}
+        end
   
-    def self.spontaneous_channel(start_item, end_item)
-      SpontaneousChannel.new(self, start_item, end_item)
-    end
-
-    def self.passive_channel(start_item, end_item)
-      PassiveChannel.new(self, start_item, end_item)
-    end
+        def spontaneous_channel(start_item, end_item)
+          SpontaneousChannel.new(self, start_item, end_item)
+        end
 
-    def self.compute_closure(initial)
-      closure_hash = ClosureHash.new do |hash, item|
-        hash.dirty = true
-        hash[item] = item
-      end
-      closure_hash.load_set(initial)
-      while true
-        closure_hash.keys.each do |element|
-          yield closure_hash, element
+        def compute_closure(initial)
+          closure_hash = ClosureHash.new do |hash, item|
+            hash.dirty = true
+            hash[item] = item
+          end
+          
+          closure_hash.load_set(initial)
+          
+          loop do
+            closure_hash.keys.each do |element|
+              yield closure_hash, element
+            end
+            break unless closure_hash.dirty
+            closure_hash.dirty = false
+          end
+          closure_hash
         end
-        break if !closure_hash.dirty
-        closure_hash.dirty = false
       end
-      return closure_hash
-    end
   end
 
 end