rockit 0.7.1

data/lib/rockit/tree/base.rb

@@ -0,0 +1,223 @@
+require 'pp'
+
+# Make sure Rockit module exists if we are loaded separetely from rest
+# of Rockit
+module Rockit; end 
+
+# Rockit::Tree defines a superclass for syntax trees. The trees has methods
+# for easily creating and pattern matching trees.
+module Rockit::Tree
+  class Base
+    include Enumerable
+    
+    def self.new_tree_class(name, children_names = [])
+      name_as_str = name.to_s
+      unless name_as_str =~ /^[A-Z]/
+	raise NameError, "identifier #{name} needs to be constant"
+      end
+      unless constants.include?(name_as_str)
+	s = <<-EOC
+        class #{name_as_str} < #{self.inspect}
+	    #{child_accessor_codes(children_names)}
+	end
+	EOC
+	class_eval s
+      end
+      class_eval "#{name_as_str}"
+    end
+
+    def self.child_accessor_codes(children_names)
+      i, s = 0, ""
+      while i < children_names.length
+	s += child_accessor_code(children_names[i], i)
+	i += 1
+      end
+      s
+    end
+
+    def self.child_accessor_code(children_name, index)
+      name = children_name.to_s
+      s = <<-EOC
+        def #{name}
+          @children[#{index}]
+        end
+	def #{name}=(newValue)
+	  @children[#{index}] = newValue
+        end
+      EOC
+    end
+
+    def self.[](*children)
+      new(*children)
+    end
+
+    attr_reader :children
+
+    def initialize(*children)
+      @children = children
+    end
+
+    def [](index)
+      self.children[index]
+    end
+
+    def num_children
+      self.children.length
+    end
+
+    def ==(other)
+      self.class == other.class && self.children == other.children
+    end
+
+    def inspect
+      class_name + "[" +
+        self.children.map {|c| c.inspect}.join(", ") + 
+        "]"
+    end
+
+    def class_name
+      self.class.inspect.split("::").last
+    end
+
+    def each_child
+      children.each {|c| yield(c)}
+    end
+
+    alias each each_child
+
+    # Depth-first traversal of (sub)trees in tree
+    def each_tree(&block)
+      block.call(self)
+      self.children.each do |c|
+	if Base === c
+	  c.each_tree(&block)
+	else
+	  block.call(c)
+	end
+      end
+    end
+
+    # Assuming klass is a subclass of Base
+    def each_tree_of_class(klass, recursive = false, &block)
+      cs = self.children
+      if self.kind_of?(klass)
+	block.call(self)
+	cs = [] unless recursive
+      end
+      cs.each do |c|
+	if Base === c
+	  c.each_tree_of_class(klass, recursive, &block)
+	elsif Array === c
+	  c.each {|ac| 
+	    ac.each_tree_of_class(klass, recursive, &block) if Base === ac
+	  }
+	end
+      end
+    end
+
+    def match_tree(tree, matches = Hash.new)
+      if self.class == tree.class && 
+	  self.num_children == tree.num_children
+        self.each_with_index do |child, i|
+	  unless child.match_tree(tree[i], matches)
+	    matches = nil
+	    break
+	  end
+        end
+	matches
+      else
+        nil
+      end
+    end
+
+    def =~(patternTree)
+      pattern = patternTree.upcase_symbols_to_pattern_vars
+      pattern.match_tree(self)
+    end
+
+    def select_trees_of_class(klass, recursive = false)
+      ary = []
+      each_tree_of_class(klass, recursive) {|t| ary << t}
+      ary
+    end
+
+    # Return all subtrees in tree which match the pattern self.
+    def all_matching_trees(tree)
+      # Only the subtrees with a root node of the right type are candidates
+      candidates = tree.select_trees_of_class(self.class, true)
+      pattern = self.upcase_symbols_to_pattern_vars
+      candidates.map do |t| 
+	res = pattern.match_tree(t)
+	res ? [res, t] : nil
+      end.compact
+    end
+  
+    # Representing a variable in a patternTree
+    class PatternVar
+      attr_reader :name
+
+      def initialize(name)
+	@name = name
+      end
+
+      # A variable match anything and the binding is noted in the matches
+      # hash.
+      def match_tree(tree, matches = Hash.new)
+	matches[@name] = tree
+	matches
+      end
+
+      def inspect
+	"Var_" + @name.to_s
+      end
+
+      # No need to def upcase_symbols_to_pattern_vars here since it
+      # inherits the one defined for Object below
+    end
+
+    # Convert upper case symbols to pattern variables 
+    def upcase_symbols_to_pattern_vars    
+      new_children = Array.new
+      self.each {|child| new_children << child.upcase_symbols_to_pattern_vars}
+      self.class.new(*new_children)
+    end
+
+    def pretty_print(pp)
+      pp.text class_name
+      pp.group(1, '[', ']') do 
+	pp.breakable ""
+	pp.seplist(self.children) {|c| pp.pp c}
+      end
+    end
+
+    # The nodes in a tree are not linked upwards by default but by calling
+    # the set_parents method on the root the parent attribute on each subtree
+    # is set and can then be accessed.
+    attr_accessor :parent
+
+    def set_parents(parent = nil)
+      self.parent = parent
+      each_child {|c| c.set_parents(self) if c.kind_of?(Base)}
+    end
+  end
+end
+
+class Object
+  def match_tree(tree, matches = Hash.new)
+    self == tree
+  end
+  
+  def upcase_symbols_to_pattern_vars
+    self
+  end
+end
+
+class Symbol
+  def upcase_symbols_to_pattern_vars
+    if self.to_s =~ /^[A-Z]/
+      Rockit::Tree::Base::PatternVar.new(self)
+    else
+      self
+    end
+  end
+end

data/lib/rockit/tree/enter_leave_visitor.rb

@@ -0,0 +1,12 @@
+require 'util/enter_leave_visitor'
+require 'rockit/tree/base'
+
+module Rockit::Tree
+  class Base
+    include EnterLeaveVisitable
+    
+    def accept_visitor(visitor)
+      visitor.visit_me_then_children(self, self.children)
+    end
+  end
+end

data/lib/rockit/tree/graphviz.rb

@@ -0,0 +1,69 @@
+require 'rockit/tree/base'
+
+class Object
+  def to_graphviz_node_label; inspect; end
+  def to_graphviz_printer(printer); printer; end
+end
+
+class Array
+  def to_graphviz_node_label; "[]"; end
+  def to_graphviz_printer(printer)
+    label = printer.unique(self)
+    each do |child|
+      printer.add(label, child)
+      child.to_graphviz_printer(printer)
+    end
+    printer
+  end
+end
+
+class DotPrinter
+  def initialize
+    @links = []
+    @counts = Hash.new(0)
+  end
+
+  def unique(obj)
+    num = (@counts[obj.class] += 1)
+    obj.to_graphviz_node_label + " (#{num})"
+  end
+
+  def add(from, to)
+    @links << [from.to_graphviz_node_label, to.to_graphviz_node_label]
+  end
+
+  def to_dot_file
+    "digraph {" +
+      @links.uniq.map {|from, to| "#{from.inspect} -> #{to.inspect};"}.join("\n") +
+      "}"
+  end
+
+  def write_to_file(filename, format = "ps")
+    tmpfilename = "temp" + Time.now.strftime("%M%S_") + rand(1e10).inspect
+    File.open(tmpfilename, "w") do |fh|
+      fh.write self.to_dot_file
+      system "dot -T#{format} #{tmpfilename} > #{filename}"
+    end
+    # File.delete(tmpfilename)
+  end
+end
+
+module Rockit::Tree
+  class Base
+    def to_graphviz_printer(printer = DotPrinter.new)
+      children.each do |child|
+	printer.add(self, child)
+	child.to_graphviz_printer(printer)
+      end
+      printer
+    end
+
+    def to_graphviz_node_label
+      class_name_as_string
+    end
+
+    def class_name_as_string
+      self.class.inspect.split("::").last
+    end
+  end
+end

data/lib/rockit/tree/visitor.rb

@@ -0,0 +1,12 @@
+require 'util/visitor'
+require 'rockit/tree/base'
+
+module Rockit::Tree
+  class Base
+    include Visitable
+    
+    def accept_visitor(visitor)
+      visitor.visit_me_and_my_children(self, self.children)
+    end
+  end
+end

data/lib/util/array_alternatives.rb

@@ -0,0 +1,20 @@
+# Collect alternatives to an array by pushing them onto an internal
+# instance variable @__alternatives. We can then assemble all the alternatives
+# (including self) into an Array. This is used for specifying alternative
+# RightHandSides in a Rule in a Grammar.
+class Array
+  def __alternatives
+    @__alternatives ||= Array.new
+  end
+
+  def /(other)
+    self.__alternatives << other
+    self
+  end
+
+  def assemble_alternatives
+    alternatives = self.__alternatives
+    alternatives.unshift self
+    alternatives
+  end
+end

data/lib/util/enter_leave_visitor.rb

@@ -0,0 +1,69 @@
+require 'util/visitor'
+
+# An EnterLeaveVisitor is a Visitor that visits objects both on the way down
+# and on the way up when traversing an object structure/hierarchy.
+# It will first call enter_X(x) if available, then visit_X(x) if avilable
+# then traverse down into children objects and then call leave_X(x) if
+# available.
+# Objects use visit_all to indicate structure. The first argument to visit_all
+# is a parent object and the rest are children objects.
+# NOTE! If they simply call visit the leave method will never be called but
+# the enter and visit methods will.
+module EnterLeaveVisitor
+  include Visitor
+
+  def visit(obj)
+    visit_me_then_children(obj)
+  end
+
+  def enter(obj)
+    method = _enter_method(obj)
+    self.send(method, obj) if method
+  end
+
+  def leave(obj)
+    method = _leave_method(obj)
+    self.send(method, obj) if method
+  end
+
+  # Each children should be an array with children
+  def visit_me_then_children(parent, *children)
+    enter_method, visit_method, leave_method = _evl_methods(parent)
+    self.send(enter_method, parent) if enter_method
+    self.send(visit_method, parent) if visit_method
+    children.each {|cs| cs.each {|c| c.accept_visitor(self)}}
+    self.send(leave_method, parent) if leave_method
+  end
+
+  def _evl_methods(obj)
+    obj.class.ancestors.map {|c| _evl_methods_for_class(c)}.compact.first
+  end
+
+  def _evl_methods_for_class(klass)
+    # Memoized so not dynamic, maybe we should clear cache when a method is
+    # added?
+    (@_memoized_methods ||= Hash.new)[klass] ||= _methodnames_from_class(klass)
+  end
+
+  def _methodname_from_classname(klassName, prefix)
+    name = prefix + klassName
+    self.class.instance_methods.include?(name) ? name : nil
+  end
+
+  def _methodnames_from_class(klass)
+    class_name = klass.inspect.split("::").last
+    l = ["enter_", "visit_", "leave_"].map do |prefix| 
+      _methodname_from_classname(class_name, prefix)
+    end
+    # Return nil unless we found at least one method to visit
+    (l.compact.length > 0) ? l : nil
+  end
+end
+
+module EnterLeaveVisitable
+  include Visitable
+end
+
+class Object
+  include EnterLeaveVisitable
+end

data/lib/util/graphviz_dot.rb

@@ -0,0 +1,182 @@
+class DotGraphPrinter
+  attr_accessor :orientation, :size, :color
+
+  # The following can be set to blocks of code that gives a default
+  # value for the node shapes, node labels and link labels, respectively.
+  attr_accessor :node_shaper, :node_labeler, :link_labeler
+
+  # A node shaper maps each node to a string describing its shape.
+  # Valid shapes are: 
+  #   "ellipse"   (default)
+  #   "box"
+  #   "circle"
+  #   "plaintext" (no outline)
+  #   "doublecircle"
+  #   "diamond"
+  # Not yet supported or untested once are:
+  #   "polygon", "record", "epsf"
+  @@default_node_shaper = proc{|n| "box"}
+
+  @@default_node_labeler = proc{|n| 
+    if Symbol===n
+      n.id2name 
+    elsif String===n
+      n
+    else
+      n.inspect
+    end
+  }
+
+  @@default_link_labeler = proc{|info| info ? info.inspect : nil}
+
+  # links is either array of 
+  #                   arrays [fromNode, toNode [, infoOnLink]], or
+  #                   objects with attributes :from, :to, :info
+  # nodes is array of node objects
+  # All nodes used in the links are used as nodes even if they are not 
+  # in the "nodes" parameters.
+  def initialize(links = [], nodes = [])
+    @links, @nodes = links, add_nodes_in_links(links, nodes)
+    @node_attributes, @edge_attributes = Hash.new, Hash.new
+    set_default_values
+  end
+
+  def set_default_values
+    @color = "black"
+    @size = "9,11"
+    @orientation = "portrait"
+    @node_shaper = @@default_node_shaper
+    @node_labeler = @@default_node_labeler
+    @link_labeler = @@default_link_labeler
+  end
+
+  def write_to_file(filename, fileType = "ps")
+    dotfile = temp_filename(filename)
+    File.open(dotfile, "w") {|f| f.write to_dot_specification}
+    system "dot -T#{fileType} -o #{filename} #{dotfile}"
+    File.delete(dotfile)
+  end
+
+  def set_edge_attributes(anEdge, aHash)
+    # TODO check if attributes are valid dot edge attributes
+    edge = find_edge(anEdge)
+    set_attributes(edge, @edge_attributes, true, aHash)
+  end
+
+  def set_node_attributes(aNode, aHash)
+    # TODO check if attributes are valid dot node attributes
+    set_attributes(aNode, @node_attributes, true, aHash)
+  end
+
+  def to_dot_specification
+    set_edge_labels(@links)
+    set_node_labels_and_shape(@nodes)
+    "digraph G {\n" +
+      graph_parameters_to_dot_specification +
+      @nodes.uniq.map {|n| format_node(n)}.join(";\n") + ";\n" +
+      @links.uniq.map {|l| format_link(l)}.join(";\n") + ";\n" +
+      "}"
+  end
+
+  protected
+
+  def find_edge(anEdge)
+    @links.each do |link|
+      return link if source_and_dest(link) == source_and_dest(anEdge)
+    end
+  end
+
+  def set_attributes(key, hash, override, newAttributeHash)
+    h = hash[key] || Hash.new
+    newAttributeHash = all_keys_to_s(newAttributeHash) 
+    newAttributeHash.each do |k, value|
+      h[k] = value unless h[k] and !override
+    end
+    hash[key] = h
+  end
+
+  def graph_parameters_to_dot_specification
+    "graph [\n" + 
+      (self.size ? "  size = #{@size.inspect},\n" : "") +
+      (self.orientation ? "  orientation = #{@orientation},\n" : "") +
+      (self.color ? "  color = #{@color}\n" : "") +
+      "]\n"
+  end
+
+  def each_node_in_links(links)
+    links.each do |l|
+      src, dest = source_and_dest(l)
+      yield src
+      yield dest
+    end
+  end
+
+  def add_nodes_in_links(links, nodes)
+    new_nodes = []
+    each_node_in_links(links) {|node| new_nodes.push node}
+    (nodes + new_nodes).uniq
+  end
+
+  def all_keys_to_s(aHash)
+    # MAYBE reuse existing hash?
+    Hash[*(aHash.map{|p| p[0] = p[0].to_s; p}.flatten)]
+  end
+
+  def set_edge_labels(edges)
+    edges.each do |edge|
+      src, dest, info = get_link_data(edge)
+      if info
+	label = @link_labeler.call(info)
+	set_attributes(edge, @edge_attributes, false, :label =>label) if label 
+      end
+    end
+  end
+
+  def set_node_labels_and_shape(nodes)
+    nodes.each do |node|
+      set_attributes(node, @node_attributes, false,
+		     :label => @node_labeler.call(node).inspect,
+		     :shape => @node_shaper.call(node).inspect)
+    end
+  end
+
+  def get_link_data(link)
+    begin
+      return link.from, link.to, link.info
+    rescue Exception
+      return link[0], link[1], link[2]
+    end
+  end
+  
+  def source_and_dest(link)
+    get_link_data(link)[0,2]
+  end
+
+  def format_attributes(attributes)
+    return "" unless attributes
+    strings = attributes.map {|a, v| "#{a}=#{v}"}
+    strings.length > 0 ? (" [" + strings.join(", ") + "]") : ("")
+  end
+
+  def mangle_node_name(node)
+    "n" + node.hash.abs.inspect
+  end
+
+  def format_link(link)
+    from, to, info = get_link_data(link)
+    mangle_node_name(from) + " -> " + mangle_node_name(to) + 
+      format_attributes(@edge_attributes[link])
+  end
+
+  def format_node(node)
+    mangle_node_name(node) + format_attributes(@node_attributes[node])
+  end
+
+  def temp_filename(base = "tmp")
+    tmpfile = base + rand(100000).inspect
+    while test(?f, tmpfile)
+      tmpfile = base + rand(100000).inspect
+    end
+    tmpfile
+  end
+end

data/lib/util/string_location.rb

@@ -0,0 +1,42 @@
+# A class for calculating locations (line, column) in a string based
+# on an offset.
+class StringLocations
+  def initialize(string)
+    @string, @string_length = string, string.length
+    @line_lengths = @string.split(/\n/).map {|l| l.length}
+    @start_pos_of_line = [0]
+    @line_lengths.each do |l|
+      @start_pos_of_line << @start_pos_of_line.last + l + 1
+    end
+  end
+
+  def location(offset)
+    l = line(offset)
+    return l, column(offset, l)
+  end
+
+  def column(offset, l = nil)
+    l ||= line(offset)
+    offset - @start_pos_of_line[l-1]
+  end
+
+  def line(offset)
+    if offset >= @string_length
+      raise "#{offset} is larger than the string size #{@string_length}"
+    end
+    line_index(offset) + 1
+  end
+
+  # Find the index to the line where the given offset can be found. Assumes
+  # the start_pos_of_line array has been extended so that offset is covered.
+  def line_index(offset)
+    index = nil
+    for index in (0...(@start_pos_of_line.length))
+      if @start_pos_of_line[index] <= offset && 
+	  @start_pos_of_line[index+1] > offset
+	break
+      end
+    end
+    index
+  end
+end

data/lib/util/visitor.rb

@@ -0,0 +1,49 @@
+module Visitor
+  def visit(obj)
+    method = _visitor_method(obj)
+    self.send(method, obj) if method
+  end
+
+  def visit_me_and_my_children(me, children)
+    visit(me)
+    children.each {|c| c.accept_visitor(self)}
+  end
+
+  def visit_me_then_children(obj, *children)
+    visit(obj)
+    children.each {|cs| cs.each {|c| c.accept_visitor(self)}}
+  end
+
+  # Find the visit_X method to use based on the inheritance tree. First try
+  # the class name then traverse the ancestors list.
+  def _visitor_method(obj)
+    obj.class.ancestors.map {|c| _visitor_method_for_class(c)}.compact.first
+  end
+
+  def _visitor_method_for_class(klass)
+    _visitor_methods[klass] ||= _methodname_from_class(klass)
+  end
+  
+  def _visitor_methods
+    @_visitor_methods ||= Hash.new
+  end
+
+  def _methodname_from_class(klass)
+    name = "visit_" + klass.inspect.split("::").last
+    self.class.instance_methods.include?(name) ? name : nil
+  end
+
+  def visit_each(ary)
+    ary.each {|e| e.accept_visitor(self)}
+  end
+end
+
+module Visitable
+  def accept_visitor(visitor)
+    visitor.visit(self)
+  end
+end
+
+class Object
+  include Visitable
+end

data/lib/util/visitor_combinators.rb

@@ -0,0 +1,14 @@
+require 'util/visitor'
+
+# Sequentially apply visitors
+class SequenceVisitor
+  include Visitor
+
+  def initialize(*visitors)
+    @visitors = visitors
+  end
+
+  def visit(obj)
+    @visitors.each {|v| obj.accept_visitor(v)}
+  end
+end