cast 0.2.1 → 0.3.0

data/lib/cast/c_nodes.rb

@@ -724,6 +724,7 @@ module C
   class FloatLiteral
     field :format, :dec
     field :val
+    field :exponent
     field :suffix
     initializer :val
   end

data/lib/cast/node_list.rb

@@ -238,7 +238,7 @@ module C
     def node_after(node)
       node.parent.equal? self or
         raise ArgumentError, "node is not a child"
-      @array[index = node.instance_variable_get(:@parent_index)+1]
+      @array[node.instance_variable_get(:@parent_index) + 1]
     end
 
     def node_before(node)
@@ -248,7 +248,7 @@ module C
       if index.zero?
         return nil
       else
-        return @array[index-1]
+        return @array[index - 1]
       end
     end
 
@@ -256,7 +256,7 @@ module C
       node.parent.equal? self or
         raise ArgumentError, "node is not a child"
       index = node.instance_variable_get(:@parent_index)
-      index.instance_variable_set(:@parent_index, nil)
+      node.instance_variable_set(:@parent_index, nil)
       removed_(@array[index])
       @array.delete_at(index)
       adjust_indices_(index)
@@ -435,8 +435,8 @@ module C
     end
     def pop(*args)
       if args.empty?
-        ret = @array.pop
-        removed_(ret)
+        ret = @array.pop and
+          removed_(ret)
         return ret
       else
         args.length == 1 or
@@ -450,8 +450,8 @@ module C
     end
     def shift(*args)
       if args.empty?
-        ret = @array.shift
-        removed_ ret
+        ret = @array.shift and
+          removed_ ret
       else
         args.length == 1 or
           raise ArgumentError, "wrong number of arguments (#{args.length} for 0..1)"
@@ -460,7 +460,7 @@ module C
         ret = @array.slice!(0, arg)
         removed_(*ret)
       end
-      adjust_indices_(0)
+      adjust_indices_(0) unless ret.nil?
       return ret
     end
     def insert(i, *newnodes)
@@ -786,7 +786,7 @@ module C
         else
           b.instance_variable_set(:@prev, last)
         end
-      
+
         # connect `nodes'
         if nodes.length == 1
           node = nodes[0]

data/lib/cast/preprocessor.rb

@@ -1,4 +1,5 @@
 require 'rbconfig'
+require 'shellwords'
 
 ######################################################################
 #
@@ -21,9 +22,10 @@ module C
 
     attr_accessor :pwd, :include_path, :macros
 
-    def initialize
+    def initialize(quiet: false)
       @include_path = []
       @macros = {}
+      @quiet = quiet
     end
     def preprocess(text)
       filename = nil
@@ -31,7 +33,7 @@ module C
         filename = file.path
         file.puts text
       end
-      output = `#{full_command(filename)} 2>&1`
+      output = `#{full_command(filename)} #{'2> /dev/null' if @quiet}`
       if $? == 0
         return output
       else
@@ -48,25 +50,10 @@ module C
 
     private  # -------------------------------------------------------
 
-    def shellquote(arg)
-      if arg !~ /[\"\'\\$&<>|\s]/
-        return arg
-      elsif arg !~ /\'/
-        return "'#{arg}'"
-      else
-        arg.gsub!(/([\"\\$&<>|])/, '\\\\\\1')
-        return "\"#{arg}\""
-      end
-    end
     def full_command(filename)
-      include_args = include_path.map do |path|
-        "#{shellquote('-I'+path)}"
-      end.join(' ')
-      macro_args   = macros.sort.map do |key, val|
-        shellquote("-D#{key}" + (val ? "=#{val}" : ''))
-      end.join(' ')
-      filename = shellquote(filename)
-      "#{Preprocessor.command} #{include_args} #{macro_args} #{filename}"
+      include_args = include_path.map { |path| "-I#{path}" }
+      macro_args = macros.sort.map { |key, val| "-D#{key}" + (val ? "=#{val}" : '') }
+      [*Preprocessor.command.shellsplit, *include_args, *macro_args, filename].shelljoin
     end
   end
 end

data/lib/cast/to_s.rb

@@ -527,12 +527,48 @@ module C
   end
   class IntLiteral
     def to_s
-      val.to_s
+      case format
+      when :dec
+        "#{val.to_s}#{suffix}"
+      when :hex
+        "0x#{val.to_s(16)}#{suffix}"
+      when :oct
+        "0#{val.to_s(8)}#{suffix}"
+      else
+        raise "invalid C::IntLiteral format: #{format}"
+      end
     end
   end
   class FloatLiteral
     def to_s
-      val.to_s
+      case format
+      when :dec
+        if exponent
+          "#{val / 10**exponent}e#{exponent}#{suffix}"
+        else
+          "#{val}#{suffix}"
+        end
+      when :hex
+        "0x#{float_hex(val / 2**exponent)}p#{exponent || 0}#{suffix}"
+      else
+        raise "invalid C::FloatLiteral format: #{format}"
+      end
+    end
+
+    private
+
+    HEX_DIGITS = %w[0 1 2 3 4 5 6 7 8 9 a b c d e f]
+
+    def float_hex(value)
+      int, frac = value.divmod(1)
+      string = "#{int.to_s(16)}."
+      # 64-bit floats have 53 bits of significand ~ 14 hex digits.
+      14.times do
+        break if frac < 1e-17
+        int, frac = (frac * 16).divmod(1)
+        string << HEX_DIGITS[int]
+      end
+      string
     end
   end
   class Variable

data/lib/cast/version.rb

@@ -1,5 +1,5 @@
 module C
-  VERSION = [0, 2, 1]
+  VERSION = [0, 3, 0]
 
   class << VERSION
     include Comparable

data/test/c_nodes_test.rb

@@ -6,7 +6,7 @@
 
 require 'test_helper'
 
-class MiscTests < Test::Unit::TestCase
+class MiscTests < Minitest::Test
 
   # ------------------------------------------------------------------
   #                    Declarator#declaration type
@@ -164,7 +164,7 @@ EOS
 
     t = C::Int.new
     x = C::Void.new
-    assert_raise(NoMethodError){t.direct_type = x}
+    assert_raises(NoMethodError){t.direct_type = x}
   end
 
   # ------------------------------------------------------------------

data/test/lexer_test.rb

@@ -8,7 +8,7 @@
 
 require 'test_helper'
 
-class LexerTest < Test::Unit::TestCase
+class LexerTest < Minitest::Test
   def check(s)
     check_ast(s){|inp| C::Parser.new.parse(inp)}
   end
@@ -136,10 +136,10 @@ TranslationUnit
                                     val: 4660
                                     suffix: "ULL"
 EOS
-    assert_raise(C::ParseError){C::Parser.new.parse('void f() {12lll;}')}
-    assert_raise(C::ParseError){C::Parser.new.parse('void f() {12ulL;}')}
-    assert_raise(C::ParseError){C::Parser.new.parse('void f() {12lul;}')}
-    assert_raise(C::ParseError){C::Parser.new.parse('void f() {123_4;}')}
+    assert_raises(C::ParseError){C::Parser.new.parse('void f() {12lll;}')}
+    assert_raises(C::ParseError){C::Parser.new.parse('void f() {12ulL;}')}
+    assert_raises(C::ParseError){C::Parser.new.parse('void f() {12lul;}')}
+    assert_raises(C::ParseError){C::Parser.new.parse('void f() {123_4;}')}
   end
   def test_float_literal
     check <<EOS
@@ -166,51 +166,63 @@ TranslationUnit
                             exprs:
                                 - FloatLiteral
                                     val: 1230000.0
+                                    exponent: 4
                                 - FloatLiteral
                                     val: 0.0123
+                                    exponent: -4
                     - ExpressionStatement
                         expr: Comma
                             exprs:
                                 - FloatLiteral
                                     val: 1234000000000.0
+                                    exponent: 10
                                 - FloatLiteral
                                     val: 1.23e-05
+                                    exponent: -4
                     - ExpressionStatement
                         expr: Comma
                             exprs:
                                 - FloatLiteral
                                     val: 12340000.0
+                                    exponent: 5
                                 - FloatLiteral
                                     val: 1.23e-08
+                                    exponent: -10
                     - ExpressionStatement
                         expr: Comma
                             exprs:
                                 - FloatLiteral
                                     format: hex
                                     val: 684.0
+                                    exponent: 2
                                 - FloatLiteral
                                     format: hex
                                     val: 2.68359375
+                                    exponent: -10
                     - ExpressionStatement
                         expr: Comma
                             exprs:
                                 - FloatLiteral
                                     format: hex
                                     val: 21990.5
+                                    exponent: 3
                                 - FloatLiteral
                                     format: hex
                                     val: 1.341796875
+                                    exponent: -11
                     - ExpressionStatement
                         expr: Comma
                             exprs:
                                 - FloatLiteral
                                     format: hex
                                     val: 43981.0
+                                    exponent: 4
                                 - FloatLiteral
                                     format: hex
                                     val: 0.6708984375
+                                    exponent: -12
 EOS
-    assert_raise(C::ParseError){C::Parser.new.parse('void f() {0x123.4pa;}')}
+    assert_raises(C::ParseError){C::Parser.new.parse('void f() {0x123.4pa;}')}
   end
   def test_string_literal
     check <<EOS
@@ -269,7 +281,7 @@ TranslationUnit
                                     prefix: "L"
                                     val: "a\\nb"
 EOS
-    assert_raise(C::ParseError){C::Parser.new.parse('void f() {xy"ab";}')}
+    assert_raises(C::ParseError){C::Parser.new.parse('void f() {xy"ab";}')}
   end
   def test_char_literal
     check <<EOS
@@ -318,6 +330,6 @@ TranslationUnit
                                     prefix: "L"
                                     val: "\\n"
 EOS
-    assert_raise(C::ParseError){C::Parser.new.parse("void f() {xy'ab';}")}
+    assert_raises(C::ParseError){C::Parser.new.parse("void f() {xy'ab';}")}
   end
 end

data/test/node_list_test.rb

@@ -243,7 +243,7 @@ module NodeListEqualTest
     assert(a.eql?(b))
     assert(a.hash == b.hash)
   end
-  def assert_not_eq(a, b)
+  def refute_eq(a, b)
     assert(!(a == b))
     assert(!a.eql?(b))
   end
@@ -256,12 +256,12 @@ module NodeListEqualTest
     assert_eq(two_by_four, two_by_four)
     assert_eq(big, big)
 
-    assert_not_eq(empty, one)
-    assert_not_eq(one, empty)
-    assert_not_eq(one, two)
-    assert_not_eq(two, one)
-    assert_not_eq(two, three)
-    assert_not_eq(three, two)
+    refute_eq(empty, one)
+    refute_eq(one, empty)
+    refute_eq(one, two)
+    refute_eq(two, one)
+    refute_eq(two, three)
+    refute_eq(three, two)
 
     # []
     empty2 = _List[]
@@ -453,12 +453,12 @@ module NodeListChildManagementTests
   include NodeListTest
   def check_not_child(list, node)
     n = C::Int.new
-    assert_raise(ArgumentError, list.node_before(node))
-    assert_raise(ArgumentError, list.node_after(node))
-    assert_raise(ArgumentError, list.remove_node(node))
-    assert_raise(ArgumentError, list.insert_after(node, n))
-    assert_raise(ArgumentError, list.insert_before(node, n))
-    assert_raise(ArgumentError, list.replace_node(node, n))
+    assert_raises(ArgumentError, list.node_before(node))
+    assert_raises(ArgumentError, list.node_after(node))
+    assert_raises(ArgumentError, list.remove_node(node))
+    assert_raises(ArgumentError, list.insert_after(node, n))
+    assert_raises(ArgumentError, list.insert_before(node, n))
+    assert_raises(ArgumentError, list.replace_node(node, n))
   end
 
   def check_list(list, *nodes)
@@ -1151,7 +1151,7 @@ module NodeListArrayQueryTests
     assert_same_list([a1, a2, a3], a.first(4))
 
     # negative array size
-    assert_raise(ArgumentError){a.first(-1)}
+    assert_raises(ArgumentError){a.first(-1)}
   end
 
   def test_last
@@ -1188,7 +1188,7 @@ module NodeListArrayQueryTests
     assert_same_list([a1, a2, a3], a.last(4))
 
     # negative array size
-    assert_raise(ArgumentError){a.last(-1)}
+    assert_raises(ArgumentError){a.last(-1)}
   end
 
   # ------------------------------------------------------------------
@@ -1792,7 +1792,7 @@ module NodeListModifierTests
     # too many args
     a, b = 2.of{C::Int.new}
     list = _List[a, b]
-    assert_raise(ArgumentError){list.pop(1, 2)}
+    assert_raises(ArgumentError){list.pop(1, 2)}
     assert_same_list([a, b], list)
     assert_same(list, a.parent)
     assert_same(list, b.parent)
@@ -1929,7 +1929,7 @@ module NodeListModifierTests
     # too many args
     a, b = 2.of{C::Int.new}
     list = _List[a, b]
-    assert_raise(ArgumentError){list.shift(1, 2)}
+    assert_raises(ArgumentError){list.shift(1, 2)}
     assert_same_list([a, b], list)
     assert_same(list, a.parent)
     assert_same(list, b.parent)
@@ -2462,7 +2462,7 @@ NodeListTest.submodules.each do |test_module|
   %w[NodeArray NodeChain].each do |list_class|
     test_class = test_module.name.sub(/^NodeList/, list_class)
     eval "
-      class #{test_class} < Test::Unit::TestCase
+      class #{test_class} < Minitest::Test
         def _List
           C::#{list_class}
         end

data/test/node_test.rb

@@ -38,7 +38,7 @@ class V < C::Node
   initializer :a
 end
 
-class NodeInitializeTest < Test::Unit::TestCase
+class NodeInitializeTest < Minitest::Test
 
   # ------------------------------------------------------------------
   #                             initialize
@@ -94,7 +94,7 @@ class NodeInitializeTest < Test::Unit::TestCase
   end
 end
 
-class NodeEqualTest < Test::Unit::TestCase
+class NodeEqualTest < Minitest::Test
   def str
     "(struct s){.a = 1, [2] = {3, 4}, .b [5] = 6, 7}"
   end
@@ -108,7 +108,7 @@ class NodeEqualTest < Test::Unit::TestCase
     five  = C::IntLiteral.new(5)
     six   = C::IntLiteral.new(6)
     seven = C::IntLiteral.new(7)
-    
+
     mi0 = C::MemberInit.new(Chain[ma], one)
     mi10 = C::MemberInit.new(nil, three)
     mi11 = C::MemberInit.new(nil, four)
@@ -134,42 +134,42 @@ class NodeEqualTest < Test::Unit::TestCase
     # change any one field and it should be not_equal
     n = node
     n.type = nil
-    assert_not_equal(node, n)
+    refute_equal(node, n)
     assert(!node.eql?(n))
 
     n = node
     n.member_inits[0].member[0] = C::Member.new('c')
-    assert_not_equal(node, n)
+    refute_equal(node, n)
     assert(!node.eql?(n))
     copy = node.dup
 
     n = node
     n.member_inits[2].member[1] = C::IntLiteral.new(8)
-    assert_not_equal(node, n)
+    refute_equal(node, n)
     assert(!node.eql?(n))
 
     # add a member's init and it should be not_equal
     n = node
     n.member_inits[3].init = C::IntLiteral.new(9)
-    assert_not_equal(node, n)
+    refute_equal(node, n)
     assert(!node.eql?(n))
 
     # change a member's init and it should be not_equal
     n = node
     n.member_inits[0].init = C::IntLiteral.new(10)
-    assert_not_equal(node, n)
+    refute_equal(node, n)
     assert(!node.eql?(n))
 
     # add a member specifier and it should be not_equal
     n = node
     n.member_inits[3].member = Chain[C::Member.new('d')]
-    assert_not_equal(node, n)
+    refute_equal(node, n)
     assert(!node.eql?(n))
 
     # pop a member and it should be not_equal
     n = node
     n.member_inits.pop
-    assert_not_equal(node, n)
+    refute_equal(node, n)
     assert(!node.eql?(n))
 
     # assign a field a copy of what's there and it should still be
@@ -205,7 +205,7 @@ class NodeEqualTest < Test::Unit::TestCase
   end
 end
 
-class NodeCopyTest < Test::Unit::TestCase
+class NodeCopyTest < Minitest::Test
   def setup
     # (struct s){.a = 1, [2] = {3, 4}, .b [5] = 6, 7}
 
@@ -273,12 +273,12 @@ class NodeCopyTest < Test::Unit::TestCase
       assert_same(value, dres)
       assert_same(value, eres)
     end
-    assert_raise(NoMethodError){dres.new_method}
+    assert_raises(NoMethodError){dres.new_method}
     case value.object_id
     when @c.object_id, @c_mis1_i_mis0.object_id
       assert_same(100, eres.new_method)
     else
-      assert_raise(NoMethodError){eres.new_method}
+      assert_raises(NoMethodError){eres.new_method}
     end
   end
 
@@ -331,7 +331,7 @@ class NodeCopyTest < Test::Unit::TestCase
   end
 end
 
-class NodeWalkTest < Test::Unit::TestCase
+class NodeWalkTest < Minitest::Test
   #
   # Collect and return the args yielded to `node.send(method)' as an
   # Array, each element of which is an array of args yielded.
@@ -800,8 +800,8 @@ class NodeWalkTest < Test::Unit::TestCase
 
     # no parent
     i = C::Int.new
-    assert_raise(C::Node::NoParent){i.next}
-    assert_raise(C::Node::NoParent){i.prev}
+    assert_raises(C::Node::NoParent){i.next}
+    assert_raises(C::Node::NoParent){i.prev}
   end
 
   def test_list_next_prev
@@ -818,19 +818,19 @@ class NodeWalkTest < Test::Unit::TestCase
     i1 = C::IntLiteral.new(1)
     i2 = C::IntLiteral.new(2)
     a = C::Add.new(i1, i2)
-    assert_raise(C::Node::BadParent){i1.list_next}
-    assert_raise(C::Node::BadParent){i2.list_next}
-    assert_raise(C::Node::BadParent){i1.list_prev}
-    assert_raise(C::Node::BadParent){i2.list_prev}
+    assert_raises(C::Node::BadParent){i1.list_next}
+    assert_raises(C::Node::BadParent){i2.list_next}
+    assert_raises(C::Node::BadParent){i1.list_prev}
+    assert_raises(C::Node::BadParent){i2.list_prev}
 
     # no parent
     i = C::Int.new
-    assert_raise(C::Node::NoParent){i.list_next}
-    assert_raise(C::Node::NoParent){i.list_prev}
+    assert_raises(C::Node::NoParent){i.list_next}
+    assert_raises(C::Node::NoParent){i.list_prev}
   end
 end
 
-class NodeTreeTest < Test::Unit::TestCase
+class NodeTreeTest < Minitest::Test
   def setup
     # @c = "(int){[1] = 10,
     #             .x = 20,
@@ -953,10 +953,10 @@ class NodeTreeTest < Test::Unit::TestCase
     assert_tree(mi)
     assert_same_list([mi1, mi2, mis[1], mis[2]], c.member_inits)
 
-    assert_raise(C::Node::NoParent){mi.replace_with(nil)}
+    assert_raises(C::Node::NoParent){mi.replace_with(nil)}
     i1 = C::Int.new
     i2 = C::Int.new
-    assert_raise(ArgumentError){c.type.replace_with(i1, i2)}
+    assert_raises(ArgumentError){c.type.replace_with(i1, i2)}
   end
 
   def test_node_swap_with
@@ -1015,9 +1015,9 @@ class NodeTreeTest < Test::Unit::TestCase
 
   def test_node_insert_next_detached
     x1, x2 = 2.of{X.new}
-    assert_raise(C::Node::NoParent){x1.insert_next}
+    assert_raises(C::Node::NoParent){x1.insert_next}
     assert_nil(x1.parent)
-    assert_raise(C::Node::NoParent){x1.insert_next(x2)}
+    assert_raises(C::Node::NoParent){x1.insert_next(x2)}
     assert_nil(x1.parent)
     assert_nil(x2.parent)
   end
@@ -1025,9 +1025,9 @@ class NodeTreeTest < Test::Unit::TestCase
     parent = X.new
     x1, x2 = 2.of{X.new}
     parent.a = x1
-    assert_raise(C::Node::BadParent){x1.insert_next}
+    assert_raises(C::Node::BadParent){x1.insert_next}
     assert_same(parent, x1.parent)
-    assert_raise(C::Node::BadParent){x1.insert_next(x2)}
+    assert_raises(C::Node::BadParent){x1.insert_next(x2)}
     assert_same(parent, x1.parent)
     assert_nil(x2.parent)
   end
@@ -1046,9 +1046,9 @@ class NodeTreeTest < Test::Unit::TestCase
 
   def test_node_insert_prev_detached
     a1, a2 = 2.of{X.new}
-    assert_raise(C::Node::NoParent){a1.insert_prev}
+    assert_raises(C::Node::NoParent){a1.insert_prev}
     assert_nil(a1.parent)
-    assert_raise(C::Node::NoParent){a1.insert_prev(a2)}
+    assert_raises(C::Node::NoParent){a1.insert_prev(a2)}
     assert_nil(a1.parent)
     assert_nil(a2.parent)
   end
@@ -1056,9 +1056,9 @@ class NodeTreeTest < Test::Unit::TestCase
     parent = X.new
     x1, x2 = 2.of{X.new}
     parent.a = x1
-    assert_raise(C::Node::BadParent){x1.insert_prev}
+    assert_raises(C::Node::BadParent){x1.insert_prev}
     assert_same(parent, x1.parent)
-    assert_raise(C::Node::BadParent){x1.insert_prev(x2)}
+    assert_raises(C::Node::BadParent){x1.insert_prev(x2)}
     assert_same(parent, x1.parent)
     assert_nil(x2.parent)
   end
@@ -1083,15 +1083,15 @@ class NodeTreeTest < Test::Unit::TestCase
     # node not a child
     x1, x2 = 2.of{X.new}
     parent = X.new(x1)
-    assert_raise(ArgumentError){parent.node_after(x2)}
-    assert_raise(ArgumentError){parent.node_before(x2)}
+    assert_raises(ArgumentError){parent.node_after(x2)}
+    assert_raises(ArgumentError){parent.node_before(x2)}
 
     x1, x2 = 2.of{X.new}
     parent = Z.new(nil, x1, nil, x2, nil)
-    assert_raise(ArgumentError){parent.node_after(x1)}
-    assert_raise(ArgumentError){parent.node_after(x2)}
-    assert_raise(ArgumentError){parent.node_before(x1)}
-    assert_raise(ArgumentError){parent.node_before(x2)}
+    assert_raises(ArgumentError){parent.node_after(x1)}
+    assert_raises(ArgumentError){parent.node_after(x2)}
+    assert_raises(ArgumentError){parent.node_before(x1)}
+    assert_raises(ArgumentError){parent.node_before(x2)}
 
     # one child
     x = X.new
@@ -1127,8 +1127,8 @@ class NodeTreeTest < Test::Unit::TestCase
     # node not a child
     x1, x2, x3 = 3.of{X.new}
     parent = Z.new(x1, x2)
-    assert_raise(ArgumentError){parent.remove_node(x2)}
-    assert_raise(ArgumentError){parent.remove_node(x3)}
+    assert_raises(ArgumentError){parent.remove_node(x2)}
+    assert_raises(ArgumentError){parent.remove_node(x3)}
 
     # one child
     x = X.new
@@ -1151,8 +1151,8 @@ class NodeTreeTest < Test::Unit::TestCase
     # node not a child
     x1, x2, x3, x4 = 3.of{X.new}
     parent = Z.new(x1, x2)
-    assert_raise(ArgumentError){parent.replace_node(x2, x4)}
-    assert_raise(ArgumentError){parent.replace_node(x3, x4)}
+    assert_raises(ArgumentError){parent.replace_node(x2, x4)}
+    assert_raises(ArgumentError){parent.replace_node(x3, x4)}
 
     # no newnode
     x = X.new
@@ -1165,7 +1165,7 @@ class NodeTreeTest < Test::Unit::TestCase
     # >1 newnode
     x1, x2, x3 = 3.of{X.new}
     parent = X.new(x1)
-    assert_raise(ArgumentError){parent.replace_node(x1, x2, x3)}
+    assert_raises(ArgumentError){parent.replace_node(x1, x2, x3)}
 
     # one child
     x1, x2 = 2.of{X.new}