cast 0.0.1 → 0.1.0

data/lib/{c_nodes.rb → cast/c_nodes.rb}

@@ -401,13 +401,6 @@ module C
     initializer :cond, :then, :else
   end
   ###
-  ### Sizeof
-  ###
-  class Sizeof
-    child :expr
-    initializer :expr
-  end
-  ###
   ### Variable
   ###
   class Variable
@@ -444,6 +437,13 @@ module C
     initializer :expr
   end
   ###
+  ### Sizeof
+  ###
+  class Sizeof
+    child :expr
+    initializer :expr
+  end
+  ###
   ### Positive
   ###
   class Positive
@@ -849,6 +849,7 @@ module C
   ###
   class StringLiteral
     field :val
+    field :wide?
     initializer :val
   end
   ###
@@ -856,6 +857,7 @@ module C
   ###
   class CharLiteral
     field :val
+    field :wide?
     initializer :val
   end
   ###
@@ -872,6 +874,7 @@ module C
   class IntLiteral
     field :val
     field :format, :dec
+    field :suffix
     initializer :val
     def dec?
       format.equal? :dec
@@ -888,6 +891,8 @@ module C
   ###
   class FloatLiteral
     field :val
+    field :format, :dec
+    field :suffix
     initializer :val
   end
 

data/lib/{to_debug.rb → cast/inspect.rb}

@@ -1,33 +1,33 @@
 ###
 ### ##################################################################
 ###
-### Node#to_debug.
+### Node#inspect.
 ###
 ### ##################################################################
 ###
 
 module C
   class Node
-    TO_DEBUG_TAB = '    '
-    def to_debug
-      return Node.to_debug1(self)
+    INSPECT_TAB = '    '
+    def inspect
+      return Node.inspect1(self)
     end
 
-    def Node.to_debug1 x, prefix='', indent=0, is_child=true
+    def Node.inspect1 x, prefix='', indent=0, is_child=true
       case x
       when NodeList
         if x.empty?
-          return "#{TO_DEBUG_TAB*indent}#{prefix}[]\n"
+          return "#{INSPECT_TAB*indent}#{prefix}[]\n"
         else
-          str = "#{TO_DEBUG_TAB*indent}#{prefix}\n"
+          str = "#{INSPECT_TAB*indent}#{prefix}\n"
           x.each do |el|
-            str << to_debug1(el, "- ", indent+1)
+            str << inspect1(el, "- ", indent+1)
           end
           return str
         end
       when Node
         classname = x.class.name.gsub(/^C::/, '')
-        str = "#{TO_DEBUG_TAB*indent}#{prefix}#{classname}"
+        str = "#{INSPECT_TAB*indent}#{prefix}#{classname}"
 
         fields = x.fields
         bools, others = fields.partition{|field| field.reader.to_s[-1] == ??}
@@ -45,13 +45,13 @@ module C
             ## don't bother with non-child Nodes, since they may cause
             ## loops in the tree
             (val.is_a?(Node) && !field.child?)
-          str << to_debug1(val, "#{field.reader}: ", indent+1, field.child?)
+          str << inspect1(val, "#{field.reader}: ", indent+1, field.child?)
         end
         return str
       when Symbol
-        return "#{TO_DEBUG_TAB*indent}#{prefix}#{x}\n"
+        return "#{INSPECT_TAB*indent}#{prefix}#{x}\n"
       else
-        return "#{TO_DEBUG_TAB*indent}#{prefix}#{x.inspect}\n"
+        return "#{INSPECT_TAB*indent}#{prefix}#{x.inspect}\n"
       end
       return s.string
     end

data/lib/{node_list.rb → cast/node_list.rb}

@@ -451,7 +451,11 @@ module C
         removed_(ret)
         return ret
       else
-        ret = @array.pop(*args)
+        args.length == 1 or
+          raise ArgumentError, "wrong number of arguments (#{args.length} for 0..1)"
+        arg = args[0]
+        arg = @array.length if @array.length < arg
+        ret = @array.slice!(-arg, arg)
         removed_ *ret
         return ret
       end
@@ -461,7 +465,11 @@ module C
         ret = @array.shift
         removed_ ret
       else
-        ret = @array.shift(*args)
+        args.length == 1 or
+          raise ArgumentError, "wrong number of arguments (#{args.length} for 0..1)"
+        arg = args[0]
+        arg = @array.length if @array.length < arg
+        ret = @array.slice!(0, arg)
         removed_ *ret
       end
       adjust_indices_(0)

data/lib/{to_s.rb → cast/to_s.rb}

@@ -301,7 +301,12 @@ module C
       else
         rvalstr = "#{rval}"
       end
-      "#{lval} #{op}= #{rvalstr}"
+      if lval.to_s_precedence < self.to_s_precedence
+        lvalstr = "(#{lval})"
+      else
+        lvalstr = "#{lval}"
+      end
+      "#{lvalstr} #{op}= #{rvalstr}"
     end
   end
   ## Other Expressions
@@ -470,7 +475,11 @@ module C
   class Parameter
     def to_s
       str = register? ? 'register ' : ''
-      str << type.to_s(name)
+      if type
+        str << type.to_s(name)
+      else
+        str << name.to_s
+      end
     end
   end
 
@@ -490,7 +499,7 @@ module C
       str = ''
       type and
         str << "(#{type}) "
-      str << "{\n" << indent(inits.join(",\n")) << "\n}"
+      str << "{\n" << indent(member_inits.join(",\n")) << "\n}"
     end
   end
   class MemberInit

data/test/run.rb

@@ -1,5 +1,207 @@
 #!/usr/bin/env ruby
 
-Dir.new(Dir.pwd).grep(/^test_/) do |filename|
-  require "#{Dir.pwd}/#{filename}"
+require 'test/unit'
+require 'stringio'
+
+# require cast
+CAST_ROOT = File.expand_path('..', File.dirname(__FILE__))
+ENV['CAST_EXTDIR'] = "#{CAST_ROOT}/ext"
+ENV['CAST_LIBDIR'] = "#{CAST_ROOT}/lib/cast"
+require "#{CAST_ROOT}/lib/cast.rb"
+
+###
+### ------------------------------------------------------------------
+###                        Helpers for testing
+### ------------------------------------------------------------------
+###
+
+class Array
+  def same_list? other
+    self.length == other.length or
+      return false
+    self.zip(other).all? do |mine, yours|
+      mine.equal? yours or
+        return false
+    end
+  end
+end
+
+class Integer
+  ###
+  ### Return a `self'-element array containing the result of the given
+  ### block.
+  ###
+  def of &blk
+    Array.new(self, &blk)
+  end
+end
+
+module Test::Unit::Assertions
+  INDENT = '    '
+  ###
+  ### Assert that the given string is parsed as expected.  The given
+  ### string is of the format:
+  ###
+  ### <program>
+  ### ----
+  ### <expected inspect string>
+  ###
+  ### The <program> part is yielded to obtain the AST.
+  ###
+  def check_ast test_data
+    inp, exp = test_data.split(/^----+\n/)
+    ast = yield(inp)
+    assert_tree(ast)
+    assert(ast.is_a?(C::Node))
+    assert_equal_inspect_strs(exp, ast.inspect)
+  end
+  ###
+  ### Assert that the given Node#inspect strings are equal.
+  ###
+  def assert_equal_inspect_strs exp, out
+    ## remove EOL space
+    out = out.gsub(/ *$/, '')
+    exp = exp.gsub(/ *$/, '')
+
+    ## normalize BOL space
+    exp.gsub!(%r'^#{INDENT}*') do |s|
+      levels = s.length / INDENT.length
+      C::Node::INSPECT_TAB*levels
+    end
+
+    ## compare
+    msg = "Debug strings unequal:\n#{juxtapose('Expected', exp, 'Output', out)}"
+    assert_block(msg){out == exp}
+  end
+  ###
+  ### Return a string of `s1' and `s2' side by side with a dividing
+  ### line in between indicating differences.  `h1' and `h2' are the
+  ### column headings.
+  ###
+  def juxtapose h1, s1, h2, s2
+    s1 = s1.map{|line| line.chomp}
+    s2 = s2.map{|line| line.chomp}
+    rows = [s1.length, s2.length].max
+    wl = s1.map{|line| line.length}.max
+    wr = s2.map{|line| line.length}.max
+    ret = ''
+    ret << "#{('-'*wl)}----#{'-'*wr}\n"
+    ret << "#{h1.ljust(wl)} || #{h2}\n"
+    ret << "#{('-'*wl)}-++-#{'-'*wr}\n"
+    (0...rows).each do |i|
+      if i >= s1.length
+        ret << "#{' '*wl}  > #{s2[i]}\n"
+      elsif i >= s2.length
+        ret << "#{s1[i].ljust(wl)} <\n"
+      elsif s1[i] == s2[i]
+        ret << "#{s1[i].ljust(wl)} || #{s2[i]}\n"
+      else
+        ret << "#{s1[i].ljust(wl)} <> #{s2[i]}\n"
+      end
+    end
+    ret << "#{('-'*wl)}----#{'-'*wr}\n"
+    return ret
+  end
+  ###
+  ### Assert that an exception of the given class is raised, and that
+  ### the message matches the given regex.
+  ###
+  def assert_error klass, re
+    ex = nil
+    assert_raise(klass) do
+      begin
+        yield
+      rescue Exception => ex
+        raise
+      end
+    end
+    assert_match(re, ex.message)
+  end
+  ###
+  ### Assert that the given ast's nodes' parents are correct, and
+  ### there aren't non-Nodes where there shouldn't be.
+  ###
+  def assert_tree ast
+    meth = 'unknown method'
+    caller.each do |line|
+      if line =~ /in `(test_.*?)'/  #`
+        meth = $1
+        break
+      end
+    end
+    filename = "#{self.class}_#{meth}.out"
+    begin
+      assert_tree1(ast, nil)
+      assert(true)
+    rescue BadTreeError => e
+      require 'pp'
+      open("#{filename}", 'w'){|f| PP.pp(ast, f)}
+      flunk("#{e.message}.  Output dumped to `#{filename}'.")
+    end
+  end
+  ###
+  def assert_tree1 x, parent
+    if x.is_a? C::Node
+      parent.equal? x.parent or
+        raise BadTreeError, "#{x.class}:0x#{(x.id << 1).to_s(16)} has #{x.parent ? 'wrong' : 'no'} parent"
+      x.fields.each do |field|
+        next if !field.child?
+        val = x.send(field.reader)
+        next if val.nil?
+        val.is_a? C::Node or
+          raise BadTreeError, "#{x.class}:0x#{(x.id << 1).to_s(16)} is a non-Node child"
+        assert_tree1(val, x)
+      end
+    end
+  end
+  class BadTreeError < StandardError; end
+  ###
+  ### Assert that `arg' is a C::NodeList.
+  ###
+  def assert_list arg
+    assert_kind_of(C::NodeList, arg)
+  end
+  ###
+  ### Assert that `arg' is an empty C::NodeList.
+  ###
+  def assert_empty_list arg
+    assert_list arg
+    assert(arg.empty?)
+  end
+  ###
+  ### Assert that the elements of exp are the same as those of out,
+  ### and are in the same order.
+  ###
+  def assert_same_list exp, out
+    assert_equal(exp.length, out.length, "Checking length")
+    (0...exp.length).each do |i|
+      assert_same(exp[i], out[i], "At index #{i} (of 0...#{exp.length})")
+    end
+  end
+  ###
+  ### Assert that out is ==, but not the same as exp (i.e., it is a
+  ### copy).
+  ###
+  def assert_copy exp, out
+    assert_not_same exp, out
+    assert_equal exp, out
+  end
+  ###
+  ### Assert the invariants of `node'.
+  ###
+  def assert_invariants node
+    node.assert_invariants(self)
+  end
+end
+
+###
+### ------------------------------------------------------------------
+###                                Main
+### ------------------------------------------------------------------
+###
+
+if $0 == __FILE__
+  Dir.new(Dir.pwd).grep(/^test_/) do |filename|
+    require "#{Dir.pwd}/#{filename}"
+  end
 end

data/test/test_c_nodes.rb

@@ -1,5 +1,3 @@
-require 'common'
-
 ###
 ### ##################################################################
 ###
@@ -9,8 +7,6 @@ require 'common'
 ### ##################################################################
 ###
 class MiscTests < Test::Unit::TestCase
-  include CheckAst
-
   ###
   ### ----------------------------------------------------------------
   ###                           Declarator#
@@ -42,22 +38,22 @@ class MiscTests < Test::Unit::TestCase
     arr = C::Array.new(C::Pointer.new, C::IntLiteral.new(10))
     decl.declarators << C::Declarator.new(arr, 'm')
 
-    assert_equal_debug_strs(decl.declarators[0].type.to_debug, <<EOS)
+    assert_equal_inspect_strs(decl.declarators[0].type.inspect, <<EOS)
 Int
 EOS
-    assert_equal_debug_strs(decl.declarators[1].type.to_debug, <<EOS)
+    assert_equal_inspect_strs(decl.declarators[1].type.inspect, <<EOS)
 Pointer
     type: Int
 EOS
-    assert_equal_debug_strs(decl.declarators[2].type.to_debug, <<EOS)
+    assert_equal_inspect_strs(decl.declarators[2].type.inspect, <<EOS)
 Array
     type: Int
 EOS
-    assert_equal_debug_strs(decl.declarators[3].type.to_debug, <<EOS)
+    assert_equal_inspect_strs(decl.declarators[3].type.inspect, <<EOS)
 Function
     type: Int
 EOS
-    assert_equal_debug_strs(decl.declarators[4].type.to_debug, <<EOS)
+    assert_equal_inspect_strs(decl.declarators[4].type.inspect, <<EOS)
 Array
     type: Pointer
         type: Int

data/test/test_node.rb

@@ -6,16 +6,6 @@
 ### ##################################################################
 ###
 
-require 'common'
-require 'stringio'
-
-require 'pp'
-class C::Node
-  def pretty_print q
-    q.text self.to_debug
-  end
-end
-
 Chain = C::NodeChain
 
 ###