rubyjs 0.7.1 → 0.8.0

data/vendor/ParseTree-1.7.1/lib/sexp.rb

@@ -1,235 +0,0 @@
-##
-# Sexps are the basic storage mechanism of SexpProcessor.  Sexps have
-# a +type+ (to be renamed +node_type+) which is the first element of
-# the Sexp. The type is used by SexpProcessor to determine whom to
-# dispatch the Sexp to for processing.
-
-$TESTING ||= false # unless defined $TESTING
-
-class Sexp < Array # ZenTest FULL
-
-  @@array_types = [ :array, :args, ]
-
-  ##
-  # Create a new Sexp containing +args+.
-
-  def initialize(*args)
-    super(args)
-  end
-
-  def self.from_array(a)
-    ary = Array === a ? a : [a]
-
-    result = self.new
-
-    ary.each do |x|
-      case x
-      when Sexp
-        result << x
-      when Array
-        result << self.from_array(x)
-      else
-        result << x
-      end
-    end
-
-    result
-  end
-
-  def ==(obj) # :nodoc:
-    if obj.class == self.class then
-      super
-    else
-      false
-    end
-  end
-
-  def ===(sexp)
-    return nil unless Sexp === sexp
-    pattern = self # this is just for my brain
-
-    return true if pattern == sexp
-
-    sexp.each do |subset|
-      return true if pattern === subset
-    end
-
-    return nil
-  end
-
-  def =~(pattern)
-    return pattern === self
-  end
-
-  ##
-  # Returns true if the node_type is +array+ or +args+.
-  #
-  # REFACTOR: to TypedSexp - we only care when we have units.
-
-  def array_type?
-    type = self.first
-    @@array_types.include? type
-  end
-
-  ##
-  # Enumeratates the sexp yielding to +b+ when the node_type == +t+.
-
-  def each_of_type(t, &b)
-    each do | elem |
-      if Sexp === elem then
-        elem.each_of_type(t, &b)
-        b.call(elem) if elem.first == t
-      end
-    end
-  end
-
-  ##
-  # Replaces all elements whose node_type is +from+ with +to+. Used
-  # only for the most trivial of rewrites.
-
-  def find_and_replace_all(from, to)
-    each_with_index do | elem, index |
-      if Sexp === elem then
-        elem.find_and_replace_all(from, to)
-      else
-        self[index] = to if elem == from
-      end
-    end
-  end
-
-  def gsub(pattern, repl)
-    return repl if pattern == self
-
-    new = self.map do |subset|
-      case subset
-      when Sexp then
-        subset.gsub(pattern, repl)
-      else
-        subset
-      end
-    end
-
-    return Sexp.from_array(new)
-  end
-
-  def inspect # :nodoc:
-    sexp_str = self.map {|x|x.inspect}.join(', ')
-    return "s(#{sexp_str})"
-  end
-
-  def method_missing(meth, delete=false)
-    matches = find_all { | sexp | Sexp === sexp and sexp.first == meth }
-
-    case matches.size
-    when 0 then
-      nil
-    when 1 then
-      match = matches.first
-      delete match if delete
-      match
-    else
-      raise NoMethodError, "multiple nodes for #{meth} were found in #{inspect}"
-    end
-  end
-
-  def pretty_print(q) # :nodoc:
-    q.group(1, 's(', ')') do
-      q.seplist(self) {|v| q.pp v }
-    end
-  end
-
-  ##
-  # Returns the Sexp without the node_type.
-
-  def sexp_body
-    self[1..-1]
-  end
-
-  ##
-  # If run with debug, Sexp will raise if you shift on an empty
-  # Sexp. Helps with debugging.
-
-  def shift
-    raise "I'm empty" if self.empty?
-    super
-  end if $DEBUG or $TESTING
-
-  ##
-  # Returnes the bare bones structure of the sexp.
-  # s(:a, :b, s(:c, :d), :e) => s(:a, s(:c))
-
-  def structure
-    result = self.class.new
-    if Array === self.first then
-      result = self.first.structure
-    else
-      result << self.shift
-      self.grep(Array).each do |subexp|
-        result << subexp.structure
-      end
-    end
-    result
-  end
-
-  def sub(pattern, repl)
-    return repl.dup if pattern == self
-
-    done = false
-
-    new = self.map do |subset|
-      if done then
-        subset
-      else
-        case subset
-        when Sexp then
-          if pattern == subset then
-            done = true
-            repl.dup
-          elsif pattern === subset then
-            done = true
-            subset.sub pattern, repl
-          else
-            subset
-          end
-        else
-          subset
-        end
-      end
-    end
-
-    return Sexp.from_array(new)
-  end
-
-  def to_a # :nodoc:
-    self.map { |o| Sexp === o ? o.to_a : o }
-  end
-
-  def to_s # :nodoc:
-    inspect
-  end
-
-end
-
-class SexpMatchSpecial < Sexp; end
-
-class SexpAny < SexpMatchSpecial
-  def ===(o)
-    return Sexp === o
-  end
-
-  def inspect
-    "ANY"
-  end
-end
-
-module SexpMatchSpecials
-  def ANY(); return SexpAny.new; end
-end
-
-##
-# This is just a stupid shortcut to make indentation much cleaner.
-
-def s(*args)
-  Sexp.new(*args)
-end
-

data/vendor/ParseTree-1.7.1/lib/sexp_processor.rb

@@ -1,330 +0,0 @@
-
-$TESTING = false unless defined? $TESTING
-
-require 'sexp'
-
-class Object
-
-  ##
-  # deep_clone is the usual Marshalling hack to make a deep copy.
-  # It is rather slow, so use it sparingly. Helps with debugging
-  # SexpProcessors since you usually shift off sexps.
-
-  def deep_clone
-    Marshal.load(Marshal.dump(self))
-  end
-end
-
-##
-# SexpProcessor base exception class.
-
-class SexpProcessorError < StandardError; end
-
-##
-# Raised by SexpProcessor if it sees a node type listed in its
-# unsupported list.
-
-class UnsupportedNodeError < SexpProcessorError; end
-
-##
-# Raised by SexpProcessor if it is in strict mode and sees a node for
-# which there is no processor available.
-
-class UnknownNodeError < SexpProcessorError; end
-
-##
-# Raised by SexpProcessor if a processor did not process every node in
-# a sexp and @require_empty is true.
-
-class NotEmptyError < SexpProcessorError; end
-
-##
-# Raised if assert_type encounters an unexpected sexp type.
-
-class SexpTypeError < SexpProcessorError; end
-
-##
-# SexpProcessor provides a uniform interface to process Sexps.
-#
-# In order to create your own SexpProcessor subclass you'll need
-# to call super in the initialize method, then set any of the
-# Sexp flags you want to be different from the defaults.
-#
-# SexpProcessor uses a Sexp's type to determine which process method
-# to call in the subclass.  For Sexp <code>s(:lit, 1)</code>
-# SexpProcessor will call #process_lit, if it is defined.
-#
-# You can also specify a default method to call for any Sexp types
-# without a process_<type> method or use the default processor provided to
-# skip over them.
-#
-# Here is a simple example:
-#
-#   class MyProcessor < SexpProcessor
-#     def initialize
-#       super
-#       self.strict = false
-#     end
-#
-#     def process_lit(exp)
-#       val = exp.shift
-#       return val
-#     end
-#   end
-
-class SexpProcessor
-
-  ##
-  # A default method to call if a process_<type> method is not found
-  # for the Sexp type.
-
-  attr_accessor :default_method
-
-  ##
-  # Emit a warning when the method in #default_method is called.
-
-  attr_accessor :warn_on_default
-
-  ##
-  # Automatically shifts off the Sexp type before handing the
-  # Sexp to process_<type>
-
-  attr_accessor :auto_shift_type
-
-  ##
-  # An array that specifies node types that are unsupported by this
-  # processor. SexpProcessor will raise UnsupportedNodeError if you try
-  # to process one of those node types.
-
-  attr_accessor :unsupported
-
-  ##
-  # Raise an exception if no process_<type> method is found for a Sexp.
-
-  attr_accessor :strict
-
-  ##
-  # A Hash of Sexp types and Regexp.
-  #
-  # Print a debug message if the Sexp type matches the Hash key
-  # and the Sexp's #inspect output matches the Regexp.
-
-  attr_accessor :debug
-
-  ##
-  # Expected result class
-
-  attr_accessor :expected
-
-  ##
-  # Raise an exception if the Sexp is not empty after processing
-
-  attr_accessor :require_empty
-
-  ##
-  # Creates a new SexpProcessor.  Use super to invoke this
-  # initializer from SexpProcessor subclasses, then use the
-  # attributes above to customize the functionality of the
-  # SexpProcessor
-
-  def initialize
-    @default_method = nil
-    @warn_on_default = true
-    @auto_shift_type = false
-    @strict = false
-    @unsupported = [:alloca, :cfunc, :cref, :evstr, :ifunc, :last, :memo, :newline, :opt_n, :method] # internal nodes that you can't get to
-    @unsupported_checked = false
-    @debug = {}
-    @expected = Sexp
-    @require_empty = true
-    @exceptions = {}
-    @process_level = 0
-
-    # we do this on an instance basis so we can subclass it for
-    # different processors.
-    @processors = {}
-    @rewriters  = {}
-
-    public_methods.each do |name|
-      case name
-      when /^process_(.*)/ then
-        @processors[$1.intern] = name.intern
-      when /^rewrite_(.*)/ then
-        @rewriters[$1.intern]  = name.intern
-      end
-    end
-  end
-
-  def assert_empty(meth, exp, exp_orig)
-    unless exp.empty? then
-      msg = "exp not empty after #{self.class}.#{meth} on #{exp.inspect}"
-      msg += " from #{exp_orig.inspect}" if $DEBUG
-      raise NotEmptyError, msg
-    end
-  end
-
-  def rewrite(exp)
-    meth = @rewriters[exp.first]
-    if meth then
-      r = self.send(meth, exp)
-      self.assert_empty(meth, exp, nil) if @require_empty
-      r
-    else
-      result = exp.class.new
-      until exp.empty? do
-        sub_exp = exp.shift
-        sub_result = nil
-
-        if Array === sub_exp then
-          result << rewrite(sub_exp)
-        else
-          result << sub_exp
-        end
-      end
-      result
-    end
-  end
-
-  ##
-  # Default Sexp processor.  Invokes process_<type> methods matching
-  # the Sexp type given.  Performs additional checks as specified by
-  # the initializer.
-
-  def process(exp)
-    return nil if exp.nil?
-
-    @process_level += 1
-
-    unless @unsupported_checked then
-      m = public_methods.grep(/^process_/) { |o| o.sub(/^process_/, '').intern }
-      supported = m - (m - @unsupported)
-
-      raise UnsupportedNodeError, "#{supported.inspect} shouldn't be in @unsupported" unless supported.empty?
-
-      @unsupported_checked = true
-    end
-
-    result = self.expected.new
-
-    type = exp.first
-
-    if @debug.has_key? type then
-      str = exp.inspect
-      puts "// DEBUG: #{str}" if str =~ @debug[type]
-    end
-
-    exp_orig = nil
-    exp_orig = exp.deep_clone if $DEBUG or
-      @debug.has_key? type or @exceptions.has_key?(type)
-
-    raise UnsupportedNodeError, "'#{type}' is not a supported node type" if @unsupported.include? type
-
-    exp = self.rewrite(exp) if @process_level == 1
-
-    # now do a pass with the real processor (or generic)
-    meth = @processors[type] || @default_method
-    if meth then
-
-      if @warn_on_default and meth == @default_method then
-        $stderr.puts "WARNING: Using default method #{meth} for #{type}"
-      end
-
-      exp.shift if @auto_shift_type and meth != @default_method
-
-      result = error_handler(type, exp_orig) do
-        self.send(meth, exp)
-      end
-
-      raise SexpTypeError, "Result must be a #{@expected}, was #{result.class}:#{result.inspect}" unless @expected === result
-
-      self.assert_empty(meth, exp, exp_orig) if @require_empty
-    else
-      unless @strict then
-        until exp.empty? do
-          sub_exp = exp.shift
-          sub_result = nil
-          if Array === sub_exp then
-            sub_result = error_handler(type, exp_orig) do
-              process(sub_exp)
-            end
-            raise "Result is a bad type" unless Array === sub_exp
-            raise "Result does not have a type in front: #{sub_exp.inspect}" unless Symbol === sub_exp.first unless sub_exp.empty?
-          else
-            sub_result = sub_exp
-          end
-          result << sub_result
-        end
-
-        # NOTE: this is costly, but we are in the generic processor
-        # so we shouldn't hit it too much with RubyToC stuff at least.
-        #if Sexp === exp and not exp.sexp_type.nil? then
-        begin
-          result.sexp_type = exp.sexp_type
-        rescue Exception
-          # nothing to do, on purpose
-        end
-      else
-        msg = "Bug! Unknown node-type #{type.inspect} to #{self.class}"
-        msg += " in #{exp_orig.inspect} from #{caller.inspect}" if $DEBUG
-        raise UnknownNodeError, msg
-      end
-    end
-
-    @process_level -= 1
-
-    result
-  end
-
-  def generate # :nodoc:
-    raise NotImplementedError, "not implemented yet"
-  end
-
-  ##
-  # Raises unless the Sexp type for +list+ matches +typ+
-
-  def assert_type(list, typ)
-    raise SexpTypeError, "Expected type #{typ.inspect} in #{list.inspect}" if
-      list.first != typ
-  end
-
-  def error_handler(type, exp=nil) # :nodoc:
-    begin
-      return yield
-    rescue StandardError => err
-      if @exceptions.has_key? type then
-        return @exceptions[type].call(self, exp, err)
-      else
-        $stderr.puts "#{err.class} Exception thrown while processing #{type} for sexp #{exp.inspect} #{caller.inspect}" if $DEBUG
-        raise
-      end
-    end
-  end
-  private :error_handler
-
-  ##
-  # Registers an error handler for +node+
-
-  def on_error_in(node_type, &block)
-    @exceptions[node_type] = block
-  end
-
-  ##
-  # A fairly generic processor for a dummy node. Dummy nodes are used
-  # when your processor is doing a complicated rewrite that replaces
-  # the current sexp with multiple sexps.
-  #
-  # Bogus Example:
-  #
-  #   def process_something(exp)
-  #     return s(:dummy, process(exp), s(:extra, 42))
-  #   end
-
-  def process_dummy(exp)
-    result = @expected.new(:dummy) rescue @expected.new
-    until exp.empty? do
-      result << self.process(exp.shift)
-    end
-    result
-  end
-end
-