Don't allocate on the Dart heap during Bigint::ToCString().

runtime/vm/bigint_test.cc

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "platform/assert.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/unit_test.h"
 
 namespace dart {
 
-static uword ZoneAllocator(intptr_t size) {
-  Zone* zone = Thread::Current()->zone();
-  return zone->AllocUnsafe(size);
-}
-
-
 TEST_CASE(BigintSmi) {
   {
     const Smi& smi = Smi::Handle(Smi::New(5));
     const Bigint& bigint = Bigint::Handle(Bigint::NewFromInt64(smi.Value()));
     EXPECT_EQ(5, bigint.AsInt64Value());
     EXPECT(bigint.FitsIntoSmi());
     Smi& smi_back = Smi::Handle();
     smi_back ^= bigint.AsValidInteger();
     EXPECT_EQ(5, smi_back.Value());
   }
@@ skipping 200 matching lines @@
       "1844674407370955161600000000000000000000000");
   EXPECT_EQ(1.844674407370955e+42, bigint.AsDoubleValue());
 
   bigint = Bigint::NewFromCString(
       "1844674407370955161600000000000000000000001");
   EXPECT_EQ(1.8446744073709553e+42, bigint.AsDoubleValue());
 }
 
 
 TEST_CASE(BigintHexStrings) {
+  Zone* zone = Thread::Current()->zone();
   {
     const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("0x0"));
     EXPECT(bigint.FitsIntoSmi());
     EXPECT_EQ(0, bigint.AsInt64Value());
   }
 
   {
     const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("0x1"));
     EXPECT(bigint.FitsIntoSmi());
     EXPECT_EQ(1, bigint.AsInt64Value());
   }
 
   {
     const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("0x123"));
     EXPECT(bigint.FitsIntoSmi());
     EXPECT_EQ(0x123, bigint.AsInt64Value());
   }
 
   {
     const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("0x123"));
-    const char* str = bigint.ToHexCString(&ZoneAllocator);
+    const char* str = bigint.ToHexCString(zone);
     EXPECT_STREQ("0x123", str);
   }
 
   {
     const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("0xaBcEf"));
-    const char* str = bigint.ToHexCString(&ZoneAllocator);
+    const char* str = bigint.ToHexCString(zone);
     EXPECT_STREQ("0xABCEF", str);
   }
 
   {
     const char* in = "0x123456789";
     const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString(in));
-    const char* str = bigint.ToHexCString(&ZoneAllocator);
+    const char* str = bigint.ToHexCString(zone);
     EXPECT_STREQ(in, str);
   }
 
   {
     const char* in = "0xFFFFFFF";
     const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString(in));
-    const char* str = bigint.ToHexCString(&ZoneAllocator);
+    const char* str = bigint.ToHexCString(zone);
     EXPECT_STREQ(in, str);
   }
 
   {
     const char* in = "0x10000000";
     const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString(in));
-    const char* str = bigint.ToHexCString(&ZoneAllocator);
+    const char* str = bigint.ToHexCString(zone);
     EXPECT_STREQ(in, str);
   }
 
   {
     const char* in = "0x123456789ABCDEF01234567890ABCDEF0123456789ABCDEF0";
     const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString(in));
-    const char* str = bigint.ToHexCString(&ZoneAllocator);
+    const char* str = bigint.ToHexCString(zone);
     EXPECT_STREQ(in, str);
   }
 
   {
     const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("-0x123"));
     EXPECT(bigint.FitsIntoSmi());
     EXPECT_EQ(-0x123, bigint.AsInt64Value());
   }
 
   {
     const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("-0x123"));
-    const char* str = bigint.ToHexCString(&ZoneAllocator);
+    const char* str = bigint.ToHexCString(zone);
     EXPECT_STREQ("-0x123", str);
   }
 
   {
     const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("-0xaBcEf"));
-    const char* str = bigint.ToHexCString(&ZoneAllocator);
+    const char* str = bigint.ToHexCString(zone);
     EXPECT_STREQ("-0xABCEF", str);
   }
 
   {
     const char* in = "-0x123456789";
     const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString(in));
-    const char* str = bigint.ToHexCString(&ZoneAllocator);
+    const char* str = bigint.ToHexCString(zone);
     EXPECT_STREQ(in, str);
   }
 
   {
     const char* in = "-0x123456789ABCDEF01234567890ABCDEF0123456789ABCDEF0";
     const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString(in));
-    const char* str = bigint.ToHexCString(&ZoneAllocator);
+    const char* str = bigint.ToHexCString(zone);
     EXPECT_STREQ(in, str);
   }
 
   {
     const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("0x00000123"));
     EXPECT(bigint.FitsIntoSmi());
     EXPECT_EQ(0x123, bigint.AsInt64Value());
   }
 
   {
     const Bigint& bigint = Bigint::Handle(
         Bigint::NewFromCString("0x000000123"));
-    const char* str = bigint.ToHexCString(&ZoneAllocator);
+    const char* str = bigint.ToHexCString(zone);
     EXPECT_STREQ("0x123", str);
   }
 
   {
     const Bigint& bigint = Bigint::Handle(
         Bigint::NewFromCString("0x0000aBcEf"));
-    const char* str = bigint.ToHexCString(&ZoneAllocator);
+    const char* str = bigint.ToHexCString(zone);
     EXPECT_STREQ("0xABCEF", str);
   }
 
   {
     const char* in = "0x00000000000000000000000000000000000000000000123456789";
     const char* out =                                            "0x123456789";
     const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString(in));
-    const char* str = bigint.ToHexCString(&ZoneAllocator);
+    const char* str = bigint.ToHexCString(zone);
     EXPECT_STREQ(out, str);
   }
 
   {
     const char* in = "0x00000123456789ABCDEF01234567890ABCDEF0123456789ABCDEF0";
     const char* out =     "0x123456789ABCDEF01234567890ABCDEF0123456789ABCDEF0";
     const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString(in));
-    const char* str = bigint.ToHexCString(&ZoneAllocator);
+    const char* str = bigint.ToHexCString(zone);
     EXPECT_STREQ(out, str);
   }
 
   {
     const Bigint& bigint = Bigint::Handle(
         Bigint::NewFromCString("-0x00000123"));
     EXPECT(bigint.FitsIntoSmi());
     EXPECT_EQ(-0x123, bigint.AsInt64Value());
   }
 
   {
     const Bigint& bigint = Bigint::Handle(
         Bigint::NewFromCString("-0x00000123"));
-    const char* str = bigint.ToHexCString(&ZoneAllocator);
+    const char* str = bigint.ToHexCString(zone);
     EXPECT_STREQ("-0x123", str);
   }
 
   {
     const Bigint& bigint = Bigint::Handle(
         Bigint::NewFromCString("-0x000aBcEf"));
-    const char* str = bigint.ToHexCString(&ZoneAllocator);
+    const char* str = bigint.ToHexCString(zone);
     EXPECT_STREQ("-0xABCEF", str);
   }
 
   {
     const char* in = "-0x00000000000000000000000000000000000000000000123456789";
     const char* out =                                            "-0x123456789";
     const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString(in));
-    const char* str = bigint.ToHexCString(&ZoneAllocator);
+    const char* str = bigint.ToHexCString(zone);
     EXPECT_STREQ(out, str);
   }
 
   {
     const char* in = "-0x0000123456789ABCDEF01234567890ABCDEF0123456789ABCDEF0";
     const char* out =    "-0x123456789ABCDEF01234567890ABCDEF0123456789ABCDEF0";
     const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString(in));
-    const char* str = bigint.ToHexCString(&ZoneAllocator);
+    const char* str = bigint.ToHexCString(zone);
     EXPECT_STREQ(out, str);
   }
   {
     const char* test = "12345678901234567890";
     const char* out = "0xAB54A98CEB1F0AD2";
     const Bigint& bigint = Bigint::Handle(
         Bigint::NewFromCString(test));
-    const char* str = bigint.ToHexCString(&ZoneAllocator);
+    const char* str = bigint.ToHexCString(zone);
     EXPECT_STREQ(out, str);
   }
   {
     const char* test = "-12345678901234567890";
     const char* out = "-0xAB54A98CEB1F0AD2";
     const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString(test));
-    const char* str = bigint.ToHexCString(&ZoneAllocator);
+    const char* str = bigint.ToHexCString(zone);
     EXPECT_STREQ(out, str);
   }
 }
 
 
 TEST_CASE(BigintDecStrings) {
+  Zone* zone = Thread::Current()->zone();
   {
     const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("0x0"));
-    const char* str = bigint.ToDecCString(&ZoneAllocator);
+    const char* str = bigint.ToDecCString(zone);
     EXPECT_STREQ("0", str);
   }
 
   {
     const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("0x123"));
-    const char* str = bigint.ToDecCString(&ZoneAllocator);
+    const char* str = bigint.ToDecCString(zone);
     EXPECT_STREQ("291", str);
   }
 
   {
     const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("0xaBcEf"));
-    const char* str = bigint.ToDecCString(&ZoneAllocator);
+    const char* str = bigint.ToDecCString(zone);
     EXPECT_STREQ("703727", str);
   }
 
   {
     const char* in = "0x123456789";
     const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString(in));
-    const char* str = bigint.ToDecCString(&ZoneAllocator);
+    const char* str = bigint.ToDecCString(zone);
     EXPECT_STREQ("4886718345", str);
   }
 
   {
     const char* in = "0xFFFFFFF";
     const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString(in));
-    const char* str = bigint.ToDecCString(&ZoneAllocator);
+    const char* str = bigint.ToDecCString(zone);
     EXPECT_STREQ("268435455", str);
   }
 
   {
     const char* in = "0x10000000";
     const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString(in));
-    const char* str = bigint.ToDecCString(&ZoneAllocator);
+    const char* str = bigint.ToDecCString(zone);
     EXPECT_STREQ("268435456", str);
   }
 
   {
     const char* in = "0x123456789ABCDEF01234567890ABCDEF0123456789ABCDEF0";
     const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString(in));
-    const char* str = bigint.ToDecCString(&ZoneAllocator);
+    const char* str = bigint.ToDecCString(zone);
     EXPECT_STREQ("7141946863373290020600059860922167424469804758405880798960",
         str);
   }
 
   {
     const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("-0x123"));
     EXPECT(bigint.FitsIntoSmi());
     EXPECT_EQ(-291, bigint.AsInt64Value());
   }
 
   {
     const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("-0x123"));
-    const char* str = bigint.ToDecCString(&ZoneAllocator);
+    const char* str = bigint.ToDecCString(zone);
     EXPECT_STREQ("-291", str);
   }
 
   {
     const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("-0xaBcEf"));
-    const char* str = bigint.ToDecCString(&ZoneAllocator);
+    const char* str = bigint.ToDecCString(zone);
     EXPECT_STREQ("-703727", str);
   }
 
   {
     const char* in = "-0x123456789";
     const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString(in));
-    const char* str = bigint.ToDecCString(&ZoneAllocator);
+    const char* str = bigint.ToDecCString(zone);
     EXPECT_STREQ("-4886718345", str);
   }
 
   {
     const char* in = "-0x123456789ABCDEF01234567890ABCDEF0123456789ABCDEF0";
     const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString(in));
-    const char* str = bigint.ToDecCString(&ZoneAllocator);
+    const char* str = bigint.ToDecCString(zone);
     EXPECT_STREQ("-7141946863373290020600059860922167424469804758405880798960",
         str);
   }
 
   {
     const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("0x00000123"));
     EXPECT(bigint.FitsIntoSmi());
     EXPECT_EQ(0x123, bigint.AsInt64Value());
   }
 
   {
     const Bigint& bigint = Bigint::Handle(
         Bigint::NewFromCString("0x000000123"));
-    const char* str = bigint.ToDecCString(&ZoneAllocator);
+    const char* str = bigint.ToDecCString(zone);
     EXPECT_STREQ("291", str);
   }
 
   {
     const Bigint& bigint = Bigint::Handle(
         Bigint::NewFromCString("100000000000000000000000000000000"));
-    const char* str = bigint.ToDecCString(&ZoneAllocator);
+    const char* str = bigint.ToDecCString(zone);
     EXPECT_STREQ("100000000000000000000000000000000", str);
   }
 }
 
 
 static void TestBigintCompare(const char* a, const char* b, int compare) {
   const Bigint& bigint_a = Bigint::Handle(Bigint::NewFromCString(a));
   const Bigint& bigint_b = Bigint::Handle(Bigint::NewFromCString(b));
   const Integer& int_a = Integer::Handle(bigint_a.AsValidInteger());
   const Integer& int_b = Integer::Handle(bigint_b.AsValidInteger());
@@ skipping 57 matching lines @@
   TestBigintCompare("-0x100000000", "0xFFFFFFFF", -1);
   TestBigintCompare("-0x100000000", "0xFFFFFFFF", -1);
   TestBigintCompare("-0x10000000000000000", "0xFFFFFFFFFFFFFFFF", -1);
   TestBigintCompare("-0x10000000000000000", "0xFFFFFFFFFFFFFFFF", -1);
   TestBigintCompare("-0x10000000000000000", "0x0", -1);
   TestBigintCompare("-0x10000000000000000", "0x0", -1);
 }
 
 
 TEST_CASE(BigintDecimalStrings) {
+  Zone* zone = Thread::Current()->zone();
   {
     const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("0"));
     EXPECT(bigint.FitsIntoSmi());
     EXPECT_EQ(0, bigint.AsInt64Value());
   }
 
   {
     const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("1"));
     EXPECT(bigint.FitsIntoSmi());
     EXPECT_EQ(1, bigint.AsInt64Value());
   }
 
   {
     const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("703710"));
-    const char* str = bigint.ToHexCString(&ZoneAllocator);
+    const char* str = bigint.ToHexCString(zone);
     EXPECT_STREQ("0xABCDE", str);
   }
 
   {
     const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("11259375"));
-    const char* str = bigint.ToHexCString(&ZoneAllocator);
+    const char* str = bigint.ToHexCString(zone);
     EXPECT_STREQ("0xABCDEF", str);
   }
 
   {
     const Bigint& bigint =
         Bigint::Handle(Bigint::NewFromCString("1311768467463790320"));
-    const char* str = bigint.ToHexCString(&ZoneAllocator);
+    const char* str = bigint.ToHexCString(zone);
     EXPECT_STREQ("0x123456789ABCDEF0", str);
   }
 
   {
     const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("-0"));
     EXPECT(bigint.FitsIntoSmi());
     EXPECT_EQ(0, bigint.AsInt64Value());
   }
 
   {
     const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("-1"));
     EXPECT(bigint.FitsIntoSmi());
     EXPECT_EQ(-1, bigint.AsInt64Value());
   }
 
   {
     const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("-703710"));
-    const char* str = bigint.ToHexCString(&ZoneAllocator);
+    const char* str = bigint.ToHexCString(zone);
     EXPECT_STREQ("-0xABCDE", str);
   }
 
   {
     const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("-11259375"));
-    const char* str = bigint.ToHexCString(&ZoneAllocator);
+    const char* str = bigint.ToHexCString(zone);
     EXPECT_STREQ("-0xABCDEF", str);
   }
 
   {
     const Bigint& bigint = Bigint::Handle(
         Bigint::NewFromCString("-1311768467463790320"));
-    const char* str = bigint.ToHexCString(&ZoneAllocator);
+    const char* str = bigint.ToHexCString(zone);
     EXPECT_STREQ("-0x123456789ABCDEF0", str);
   }
 }
 
 }  // namespace dart