ruby2c 1.0.0.9 → 1.1.1

data/lib/typed_sexp.rb

@@ -1,77 +1,101 @@
-
 begin require 'rubygems'; rescue LoadError; end
 require 'sexp'
 require 'type'
 
 $TESTING = false unless defined? $TESTING
 
-class TypedSexp < Sexp
+class Sexp
+  @@array_types = [ :array, :args ]
+
+  alias array_type? array_type? # shuts up duplicate method warning
 
+  ##
+  # Returns true if the node_type is +array+ or +args+.
+
+  def array_type?
+    type = self.sexp_type
+    @@array_types.include? type
+  end
+end
+
+class TypedSexp < Sexp
   def ==(obj)
     case obj
     when TypedSexp
-      super && sexp_type == obj.sexp_type
+      super && c_type == obj.c_type
     else
       false
     end
   end
 
-  def _set_sexp_type(o)
-    @sexp_type = o
+  def new(*stuff)
+    r = super
+    r.c_type = self.c_type if self.c_type
+    r
+  end
+
+  def _set_c_type(o)
+    @c_type = o
   end
 
   def initialize(*args)
-    # TODO: should probably be Type.unknown
-    @sexp_type = Type === args.last ? args.pop : nil
+    # TODO: should probably be CType.unknown
+    @c_type = CType === args.last ? args.pop : nil
     super(*args)
   end
 
   def inspect
     sexp_str = self.map {|x|x.inspect}.join(', ')
-    sexp_type_str = (sexp_str.empty? ? "" : ", ") + "#{array_type? ? sexp_types.inspect : sexp_type}" unless sexp_type.nil?
-    return "t(#{sexp_str}#{sexp_type_str})"
+    c_type_str = (sexp_str.empty? ? "" : ", ") + "#{array_type? ? c_types.inspect : c_type}" unless c_type.nil?
+    nnd = ")"
+    nnd << ".line(#{line})" if line && ENV["VERBOSE"]
+    "t(#{sexp_str}#{c_type_str}#{nnd}"
   end
 
   def pretty_print(q)
-    q.group(1, 't(', ')') do
+    nnd = ")"
+    nnd << ".line(#{line})" if line && ENV["VERBOSE"]
+
+    q.group(1, 't(', nnd) do
       q.seplist(self) {|v| q.pp v }
-      unless @sexp_type.nil? then
+      unless @c_type.nil? then
         q.text ", " unless self.empty?
-        q.pp @sexp_type
+        q.pp @c_type
       end
     end
   end
 
-  def sexp_type
+  def c_type
     unless array_type? then
-      @sexp_type
+      defined?(@c_type) && @c_type
     else
-      types = self.sexp_types.flatten.uniq
+      types = self.c_types.flatten.uniq
 
       if types.size > 1 then
-        Type.hetero
+        CType.hetero
       else
-        Type.homo
+        CType.homo
       end
     end
   end
 
-  def sexp_type=(o)
-    raise "You shouldn't call this on an #{first}" if array_type?
+  def c_type=(o)
+    # HACK raise "You shouldn't call this on an #{first}" if array_type?
+    # c_type is different in ruby2c than from sexp_processor. need renames
     raise "You shouldn't call this a second time, ever" unless
-      @sexp_type.nil? or @sexp_type == Type.unknown
-    _set_sexp_type(o)
+      @c_type.nil? or @c_type == CType.unknown
+    _set_c_type(o)
   end
 
-  def sexp_types
+  def c_types
     raise "You shouldn't call this if not an #{@@array_types.join(' or ')}, was #{first} (#{self.inspect})" unless array_type?
-    self.grep(Sexp).map { |x| x.sexp_type }
+    self.grep(Sexp).map { |x| x.c_type }
   end
 
   def to_a
     result = super
-    if defined?(@sexp_type) and not @sexp_type.nil? then
-      result += [ @sexp_type ]
+    if defined?(@c_type) and not @c_type.nil? then
+      result += [ @c_type ]
     end
     result
   end