dhaka 0.0.1

data/lib/dhaka.rb

@@ -0,0 +1,44 @@
+#--
+# Copyright (c) 2006 Mushfeq Khan
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+require 'grammar/grammar_symbol'
+require 'grammar/production'
+require 'grammar/closure_hash'
+require 'grammar/grammar'
+
+require 'parser/parse_result'
+require 'parser/item'
+require 'parser/channel'
+require 'parser/parser_methods'
+require 'parser/parse_tree'
+require 'parser/parser_state'
+require 'parser/token'
+require 'parser/action'
+require 'parser/parser_run'
+require 'parser/parser'
+require 'parser/compiled_parser'
+
+require 'tokenizer/tokenizer'
+require 'evaluator/evaluator'
+
+

data/lib/evaluator/evaluator.rb

@@ -0,0 +1,70 @@
+module Dhaka
+  class Evaluator
+
+    def initialize(syntax_tree)
+      @syntax_tree = syntax_tree
+      @node_stack = []
+    end
+
+    def result
+      evaluate(@syntax_tree)
+    end
+
+    def child_nodes
+      current_node = @node_stack[-1]
+      Array.new(current_node.child_nodes.size) {|i| evaluate(current_node.child_nodes[i])}
+    end
+
+    private
+  
+    def self.inherited(evaluator)
+      class << evaluator
+        attr_accessor :grammar, :actions
+      end
+    end
+  
+    def self.define_evaluation_rules
+      default_action = Proc.new { child_nodes[0] }
+      self.actions = Hash.new { |hash, key| default_action }
+      yield
+      check_definitions
+    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.keys
+      raise EvaluatorDefinitionError.new(non_trivial_productions_with_rules_undefined) unless non_trivial_productions_with_rules_undefined.empty?
+    end
+  
+    def evaluate node
+      return node if (ParseTreeLeafNode === node)
+      @node_stack << node
+      proc = self.class.actions[node.production.name]
+      result = self.instance_eval(&proc)
+      @node_stack.pop
+      result
+    end
+
+    def self.for_rule_named(name, &blk)
+      self.actions[name] = blk
+    end
+  
+    def self.method_missing(method_name, &blk)
+      if method_name.to_s =~ /^for_*/
+        rule_name = method_name.to_s[4..-1]
+        self.for_rule_named(rule_name, &blk)
+      end 
+    end
+    
+  end
+
+  class EvaluatorDefinitionError < StandardError
+    def initialize(non_trivial_productions_with_rules_undefined)
+      @non_trivial_productions_with_rules_undefined = non_trivial_productions_with_rules_undefined
+    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")
+    end
+  end
+end

data/lib/grammar/closure_hash.rb

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

data/lib/grammar/grammar.rb

@@ -0,0 +1,129 @@
+#!/usr/bin/env ruby
+require 'set'
+module Dhaka
+  
+  START_SYMBOL_NAME = "_Start_"
+  END_SYMBOL_NAME = "_End_"
+  
+  class ProductionBuilder
+    def initialize(grammar, symbol)
+      @grammar = grammar
+      @symbol = symbol
+    end
+  
+    def method_missing(production_name, expansion)
+      expansion_symbols = expansion.collect {|name| @grammar.symbols[name]}
+      production = Production.new(@symbol, expansion_symbols, production_name.to_s)
+      @symbol.nullable = true if expansion_symbols.empty?
+      @grammar.productions_by_symbol[production.symbol] << production
+      @grammar.productions_by_name[production.name] = production
+    end
+  end
+
+  class Grammar
+
+    def self.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.for_symbol symbol, &blk
+      symbol = symbols[symbol]
+      symbol.non_terminal = true
+      ProductionBuilder.new(self, symbol).instance_eval(&blk)
+    end
+
+
+    def self.productions
+      productions_by_name.values
+    end
+
+    def self.production_named(name)
+      productions_by_name[name]
+    end
+
+    def self.productions_for_symbol(symbol)
+      productions_by_symbol[symbol]
+    end
+
+    def self.symbol_for_name(name)
+      if symbols.has_key? name
+        symbols[name]
+      else
+        raise "No symbol with name #{name} found"
+      end
+    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
+        end
+      end
+
+      return channels, result
+    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 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 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
+        end
+        break if !closure_hash.dirty
+        closure_hash.dirty = false
+      end
+      return closure_hash
+    end
+
+  
+  end
+end

data/lib/grammar/grammar_symbol.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+module Dhaka
+  class GrammarSymbol
+    attr_reader :name
+    attr_accessor :non_terminal, :nullable
+    def initialize(name)
+      @name = name
+    end
+    def terminal
+      !non_terminal
+    end
+    def to_s
+      name
+    end
+    def <=> other
+      self.name <=> other.name
+    end
+  end
+end

data/lib/grammar/production.rb

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+module Dhaka
+  class Production
+    attr_reader :symbol, :expansion, :name
+    def initialize(symbol, expansion, name)
+      @symbol = symbol
+      @expansion = expansion
+      @name = name
+    end
+    def to_s
+      "#{@name} #{@symbol} ::= #{@expansion.join(' ')}"
+    end
+  end
+end

data/lib/parser/action.rb

@@ -0,0 +1,51 @@
+module Dhaka
+  class Action
+    attr_reader :action_code
+  end
+
+  class ShiftAction < Action
+    attr_reader :destination_state
+    def initialize destination_state
+      @destination_state = destination_state
+      @action_code = Proc.new do
+        state_stack << destination_state
+        []
+      end
+    end
+    def compile_to_ruby_source
+      "shift_to #{@destination_state.id}"
+    end
+    def to_s
+      "Shift to #{@destination_state}"
+    end
+  end
+
+  class ReduceAction < Action
+    attr_reader :production
+    def initialize(production)
+      @production = production
+      @action_code = Proc.new do
+        composite_node = ParseTreeCompositeNode.new(production)
+
+        production.expansion.each { |symbol| 
+            state_stack.pop
+            composite_node.child_nodes.unshift(node_stack.pop)
+           }
+
+        node_stack << composite_node
+
+        unless composite_node.head_node?
+          [production.symbol.name, current_token.grammar_symbol.name]
+        else
+          []
+        end
+      end
+    end
+    def compile_to_ruby_source
+      "reduce_with '#{@production.name}'"
+    end
+    def to_s
+      "Reduce with #{production}"
+    end
+  end
+end

data/lib/parser/channel.rb

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+module Dhaka
+  class Channel
+    attr_reader :start_item, :end_item
+    def initialize(grammar, start_item, end_item)
+      @grammar = grammar
+      @start_item = start_item
+      @end_item = end_item
+    end
+    def propagate cargo
+      diff = cargo - @end_item.lookaheadset
+      @end_item.lookaheadset.merge(diff)
+      !diff.empty?
+    end
+    def to_s
+      "Channel from #{@start_item} to #{@end_item}"
+    end
+    def eql? other
+      @start_item.eql?(other.start_item) and @end_item.eql?(other.end_item)
+    end
+    def hash
+      @start_item.hash ^ @end_item.hash
+    end
+  end
+
+  class SpontaneousChannel < Channel
+    def to_s
+      "Spontaneous " + super.to_s
+    end
+    def pump
+      follow_index = @start_item.next_item_index + 1
+      cargo = Set.new
+      while follow_symbol = @start_item.production.expansion[follow_index]
+        cargo += @grammar.first(follow_symbol)
+        return propagate(cargo) unless follow_symbol.nullable
+        follow_index += 1
+      end
+      cargo += @start_item.lookaheadset
+      propagate cargo
+    end
+  end
+
+  class PassiveChannel < Channel
+    def to_s
+      "Passive " + super.to_s
+    end
+    def pump
+      propagate @start_item.lookaheadset
+    end
+  end
+end

data/lib/parser/compiled_parser.rb

@@ -0,0 +1,35 @@
+module Dhaka
+  class CompiledParser
+
+    def self.inherited(compiled_parser)
+      class << compiled_parser
+        attr_accessor :states, :grammar, :start_state_id
+      end
+      compiled_parser.states = Hash.new {|hash, state_id| hash[state_id] = ParserState.new(compiled_parser, {}, state_id)}
+    end
+
+    def self.at_state x, &blk
+      self.states[x].instance_eval(&blk)
+    end
+  
+    def self.start_state
+      states[start_state_id]
+    end
+  
+    def self.start_with start_state_id
+      self.start_state_id = start_state_id
+    end
+  
+    def self.reduce_with production_name
+      ReduceAction.new(grammar.production_named(production_name))
+    end
+  
+    def self.shift_to state_id
+      ShiftAction.new(states[state_id])
+    end
+  
+    self.extend(ParserMethods)
+  
+  end
+
+end

data/lib/parser/item.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+module Dhaka
+  class Item
+    attr_reader :production, :next_item_index, :lookaheadset
+    def initialize(production, next_item_index)
+      @production = production
+      @next_item_index = next_item_index
+      @lookaheadset = Set.new
+    end
+    def next_symbol
+      if @next_item_index < @production.expansion.size
+        @production.expansion[@next_item_index]
+      else
+        nil
+      end
+    end
+    def next_item
+      Item.new(@production, @next_item_index+1)
+    end
+    def to_s
+      expansion_symbols = @production.expansion.collect {|symbol| symbol.name}
+      if @next_item_index < expansion_symbols.size
+        expansion_symbols.insert(@next_item_index, '->')
+      else
+        expansion_symbols << '->'
+      end
+      expansion_repr = expansion_symbols.join(' ')
+      "#{@production.symbol} ::= #{expansion_repr} [#{@lookaheadset.collect.sort}]"
+    end
+    def eql?(other)
+      @production == other.production && @next_item_index==other.next_item_index
+    end
+    def hash
+      @production.hash ^ @next_item_index.hash
+    end
+  end
+end