Fraction class prototype and test (not to be committed).

runtime/vm/object.cc

 // Copyright (c) 2012, 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 "vm/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/become.h"
@@ skipping 685 matching lines @@
   cls = Class::NewStringClass(kOneByteStringCid);
   isolate->object_store()->set_one_byte_string_class(cls);
   cls = Class::NewStringClass(kTwoByteStringCid);
   isolate->object_store()->set_two_byte_string_class(cls);
   cls = Class::New<Mint>();
   isolate->object_store()->set_mint_class(cls);
   cls = Class::New<Bigint>();
   isolate->object_store()->set_bigint_class(cls);
   cls = Class::New<Double>();
   isolate->object_store()->set_double_class(cls);
+  cls = Class::New<Fraction>();
+  // TODO(regis): Remove once native getters are implemented for _Fraction.
+  cls.SetRefinalizeAfterPatch();  // Fields are defined both in C++ and in Dart.
+  isolate->object_store()->set_fraction_class(cls);
 
   // Ensure that class kExternalTypedDataUint8ArrayCid is registered as we
   // need it when reading in the token stream of bootstrap classes in the VM
   // isolate.
   Class::NewExternalTypedDataClass(kExternalTypedDataUint8ArrayCid);
 
   // Needed for object pools of VM isolate stubs.
   Class::NewTypedDataClass(kTypedDataInt8ArrayCid);
 
   // Allocate and initialize the empty_array instance.
@@ skipping 655 matching lines @@
   cls = Class::New<Bigint>();
   object_store->set_bigint_class(cls);
   RegisterPrivateClass(cls, Symbols::_Bigint(), core_lib);
   pending_classes.Add(cls);
 
   cls = Class::New<Double>();
   object_store->set_double_class(cls);
   RegisterPrivateClass(cls, Symbols::_Double(), core_lib);
   pending_classes.Add(cls);
 
+  cls = Class::New<Fraction>();
+  object_store->set_fraction_class(cls);
+  // TODO(regis): Remove once native getters are implemented for _Fraction.
+  cls.SetRefinalizeAfterPatch();  // Fields are defined both in C++ and in Dart.
+  RegisterPrivateClass(cls, Symbols::_Fraction(), core_lib);
+  pending_classes.Add(cls);
+
   // Class that represents the Dart class _Closure and C++ class Closure.
   cls = Class::New<Closure>();
   cls.set_type_arguments_field_offset(Closure::type_arguments_offset());
   cls.set_num_type_arguments(0);  // Although a closure has type_arguments_.
   cls.set_num_own_type_arguments(0);
   RegisterPrivateClass(cls, Symbols::_Closure(), core_lib);
   pending_classes.Add(cls);
   object_store->set_closure_class(cls);
 
   cls = Class::New<WeakProperty>();
@@ skipping 300 matching lines @@
   cls = Class::NewTypedDataViewClass(kTypedData##clazz##ViewCid);
   CLASS_LIST_TYPED_DATA(REGISTER_TYPED_DATA_VIEW_CLASS);
 #undef REGISTER_TYPED_DATA_VIEW_CLASS
   cls = Class::NewTypedDataViewClass(kByteDataViewCid);
 #define REGISTER_EXT_TYPED_DATA_CLASS(clazz)                                   \
   cls = Class::NewExternalTypedDataClass(kExternalTypedData##clazz##Cid);
   CLASS_LIST_TYPED_DATA(REGISTER_EXT_TYPED_DATA_CLASS);
 #undef REGISTER_EXT_TYPED_DATA_CLASS
 
   cls = Class::New<Instance>(kByteBufferCid);
+  object_store->set_byte_buffer_class(cls);
 
   cls = Class::New<Integer>();
   object_store->set_integer_implementation_class(cls);
 
   cls = Class::New<Smi>();
   object_store->set_smi_class(cls);
 
   cls = Class::New<Mint>();
   object_store->set_mint_class(cls);
 
   cls = Class::New<Double>();
   object_store->set_double_class(cls);
 
+  cls = Class::New<Fraction>();
+  // TODO(regis): Remove once native getters are implemented for _Fraction.
+  cls.SetRefinalizeAfterPatch();  // Fields are defined both in C++ and in Dart.
+  object_store->set_fraction_class(cls);
+
   cls = Class::New<Closure>();
   object_store->set_closure_class(cls);
 
   cls = Class::New<Bigint>();
   object_store->set_bigint_class(cls);
 
   cls = Class::NewStringClass(kOneByteStringCid);
   object_store->set_one_byte_string_class(cls);
 
   cls = Class::NewStringClass(kTwoByteStringCid);
@@ skipping 1841 matching lines @@
 
 
 void Class::set_is_finalized() const {
   ASSERT(!is_finalized());
   set_state_bits(ClassFinalizedBits::update(RawClass::kFinalized,
                                             raw_ptr()->state_bits_));
 }
 
 
 void Class::SetRefinalizeAfterPatch() const {
-  ASSERT(!IsTopLevel());
+  ASSERT((raw_ptr()->name_ == String::null()) || !IsTopLevel());
   set_state_bits(ClassFinalizedBits::update(RawClass::kRefinalizeAfterPatch,
                                             raw_ptr()->state_bits_));
   set_state_bits(TypeFinalizedBit::update(false, raw_ptr()->state_bits_));
 }
 
 
 void Class::ResetFinalization() const {
   ASSERT(IsTopLevel());
   set_state_bits(ClassFinalizedBits::update(RawClass::kAllocated,
                                             raw_ptr()->state_bits_));
@@ skipping 745 matching lines @@
     if (canonical_value.Equals(value)) {
       ASSERT(canonical_value.IsCanonical());
       return canonical_value.raw();
     }
     *index = *index + 1;
   }
   return Bigint::null();
 }
 
 
+RawFraction* Class::LookupCanonicalFraction(Zone* zone,
+                                            const Fraction& value,
+                                            intptr_t* index) const {
+  ASSERT(this->raw() == Isolate::Current()->object_store()->fraction_class());
+  const Array& constants = Array::Handle(zone, this->constants());
+  const intptr_t constants_len = constants.Length();
+  // Linear search to see whether this value is already present in the
+  // list of canonicalized constants.
+  Fraction& canonical_value = Fraction::Handle(zone);
+  while (*index < constants_len) {
+    canonical_value ^= constants.At(*index);
+    if (canonical_value.IsNull()) {
+      break;
+    }
+    if (canonical_value.CanonicalizeEquals(value)) {
+      ASSERT(canonical_value.IsCanonical());
+      return canonical_value.raw();
+    }
+    *index = *index + 1;
+  }
+  return Fraction::null();
+}
+
+
 class CanonicalInstanceKey {
  public:
   explicit CanonicalInstanceKey(const Instance& key) : key_(key) {
     ASSERT(!(key.IsString() || key.IsInteger() || key.IsAbstractType()));
   }
   bool Matches(const Instance& obj) const {
     ASSERT(!(obj.IsString() || obj.IsInteger() || obj.IsAbstractType()));
     if (key_.CanonicalizeEquals(obj)) {
       ASSERT(obj.IsCanonical());
       return true;
@@ skipping 3659 matching lines @@
 
 
 RawLiteralToken* LiteralToken::New(Token::Kind kind, const String& literal) {
   const LiteralToken& result = LiteralToken::Handle(LiteralToken::New());
   result.set_kind(kind);
   result.set_literal(literal);
   if (kind == Token::kINTEGER) {
     const Integer& value = Integer::Handle(Integer::NewCanonical(literal));
     ASSERT(value.IsSmi() || value.IsOld());
     result.set_value(value);
+  } else if (kind == Token::kRATIONAL) {
+    const Fraction& value = Fraction::Handle(Fraction::NewCanonical(literal));
+    result.set_value(value);
   } else if (kind == Token::kDOUBLE) {
     const Double& value = Double::Handle(Double::NewCanonical(literal));
     result.set_value(value);
   } else {
     ASSERT(Token::NeedsLiteralToken(kind));
     result.set_value(literal);
   }
   return result.raw();
 }
 
@@ skipping 10024 matching lines @@
         if (result.IsNew()) {
           // Create a canonical object in old space.
           result ^= Object::Clone(result, Heap::kOld);
         }
         ASSERT(result.IsOld());
         result.SetCanonical();
         cls.InsertCanonicalNumber(zone, index, result);
         return result.raw();
       }
     }
+    case kFractionCid: {
+      return Fraction::NewCanonical(Fraction::Cast(*this));
+    }
     default:
       UNREACHABLE();
   }
   return Instance::null();
 }
 
 
 const char* Number::ToCString() const {
   // Number is an interface. No instances of Number should exist.
   UNREACHABLE();
@@ skipping 878 matching lines @@
   }
   {
     SafepointMutexLocker ml(isolate->constant_canonicalization_mutex());
     // Retry lookup.
     {
       canonical_value ^= cls.LookupCanonicalBigint(zone, value, &index);
       if (!canonical_value.IsNull()) {
         return canonical_value.raw();
       }
     }
+    ASSERT(value.IsOld());
     value.SetCanonical();
     // The value needs to be added to the constants list. Grow the list if
     // it is full.
     cls.InsertCanonicalNumber(zone, index, value);
     return value.raw();
   }
 }
 
 
 RawTypedData* Bigint::NewDigitsFromHexCString(const char* str, intptr_t* used,
@@ skipping 472 matching lines @@
   Zone* zone = Thread::Current()->zone();
   return zone->AllocUnsafe(size);
 }
 
 
 const char* Bigint::ToCString() const {
   return ToDecCString(&BigintAllocator);
 }
 
 
+bool Fraction::CanonicalizeEquals(const Instance& other) const {
+  if (this->raw() == other.raw()) {
+    return true;  // "===".
+  }
+  if (other.IsNull() || !other.IsFraction()) {
+    return false;
+  }
+  return (numerator() == Fraction::Cast(other).numerator()) &&
+         (denominator() == Fraction::Cast(other).denominator());
+}
+
+
+RawFraction* Fraction::New(Heap::Space space) {
+  return Fraction::New(0, 0, space);
+}
+
+
+RawFraction* Fraction::New(uint64_t numerator,
+                           uint64_t denominator,
+                           Heap::Space space) {
+  Thread* thread = Thread::Current();
+  Zone* zone = thread->zone();
+  Isolate* isolate = thread->isolate();
+  ASSERT(isolate->object_store()->fraction_class() != Class::null());
+  Fraction& result = Fraction::Handle(zone);
+  {
+    RawObject* raw = Object::Allocate(Fraction::kClassId,
+                                      Fraction::InstanceSize(),
+                                      space);
+    NoSafepointScope no_safepoint;
+    result ^= raw;
+  }
+  result.set_numerator(Integer::Handle(
+      Integer::NewFromUint64(numerator, space)));
+  result.set_denominator(Integer::Handle(
+      Integer::NewFromUint64(denominator, space)));
+  return result.raw();
+}
+
+
+void Fraction::set_numerator(const Integer& value) const {
+  StorePointer(&raw_ptr()->numerator_, value.raw());
+}
+
+
+static bool CStringToFraction(const char* str,
+                              intptr_t length,
+                              uint64_t* numerator,
+                              uint64_t* denominator) {
+  ASSERT(str != NULL);
+  ASSERT(length > 0);
+  const uint64_t max_accum = (1ULL << 63) / 10;
+  uint64_t num = 0ULL;
+  uint64_t denom = 1ULL;
+  bool seen_decimal_point = false;
+  for (intptr_t i = 0; i < length; i++) {
+    char c = str[i];
+    if (!seen_decimal_point && (c == '.')) {
+      seen_decimal_point = true;
+    } else if (('0' <= c) && (c <= '9')) {
+      // Bail if numerator or denominator get close to Bigint.
+      if ((num > max_accum) || (denom > max_accum)) {
+        return false;
+      }
+      num = num*10 + (c - '0');
+      if (seen_decimal_point) denom *= 10;
+    } else {
+      if ((str[i] != 'r') && (str[i] != 'R')) {
+        return false;
+      }
+      break;
+    }
+  }
+  // Reduce somewhat. Do not reduce if denominator is 100.
+  while ((denom != 100ULL) && ((num & 1) == 0) && ((denom & 1) == 0)) {
+    num >>= 1;
+    denom >>= 1;
+  }
+  // TODO(regis): Reduce further using gcd.
+  *numerator = num;
+  *denominator = denom;
+  return true;
+}
+
+
+RawFraction* Fraction::NewCanonical(const String& str) {
+  uint64_t nominator;
+  uint64_t denominator;
+  if (!CStringToFraction(str.ToCString(), str.Length(),
+                         &nominator, &denominator)) {
+    // Call the Dart version, which supports Bigint.
+    // Not supported when called early from core lib itself.
+    const Library& core_lib = Library::Handle(Library::CoreLibrary());
+    ASSERT(!core_lib.IsNull());
+    const String& fraction_class_name = Symbols::_Fraction();
+    const String& constructor_name = Symbols::DotFromRationalLiteral();
+    const Array& constructor_args = Array::Handle(Array::New(1));
+    constructor_args.SetAt(0, str);
+    Object& value = Object::Handle(
+        DartLibraryCalls::InstanceCreate(core_lib,
+                                         fraction_class_name,
+                                         constructor_name,
+                                         true,  // A factory.
+                                         constructor_args));
+    ASSERT(!value.IsError());
+    return Fraction::NewCanonical(Fraction::Cast(value));
+  }
+  return Fraction::NewCanonical(Fraction::Handle(
+      Fraction::New(nominator, denominator, Heap::kOld)));
+}
+
+
+RawFraction* Fraction::NewCanonical(const Fraction& value) {
+  // TODO(regis): Canonicalize fields.
+  Thread* thread = Thread::Current();
+  Zone* zone = thread->zone();
+  Isolate* isolate = thread->isolate();
+  const Class& cls =
+      Class::Handle(zone, isolate->object_store()->fraction_class());
+  intptr_t index = 0;
+  Fraction& canonical_value = Fraction::Handle(zone);
+  canonical_value ^= cls.LookupCanonicalFraction(zone, value, &index);
+  if (!canonical_value.IsNull()) {
+    return canonical_value.raw();
+  }
+  {
+    SafepointMutexLocker ml(isolate->constant_canonicalization_mutex());
+    // Retry lookup.
+    {
+      canonical_value ^= cls.LookupCanonicalFraction(zone, value, &index);
+      if (!canonical_value.IsNull()) {
+        return canonical_value.raw();
+      }
+    }
+    Fraction& result = Fraction::Handle(zone, value.raw());
+    if (result.IsNew()) {
+      // Create a canonical object in old space.
+      result ^= Object::Clone(result, Heap::kOld);
+    }
+    ASSERT(result.IsOld());
+    result.SetCanonical();
+    // The value needs to be added to the constants list. Grow the list if
+    // it is full.
+    cls.InsertCanonicalNumber(zone, index, result);
+    return result.raw();
+  }
+}
+
+
+void Fraction::set_denominator(const Integer& value) const {
+  StorePointer(&raw_ptr()->denominator_, value.raw());
+}
+
+
+const char* Fraction::ToCString() const {
+  if (IsNull()) {
+    return "_Fraction NULL";
+  }
+  return OS::SCreate(Thread::Current()->zone(), "_Fraction %s/%s",
+                     Integer::Handle(numerator()).ToCString(),
+                     Integer::Handle(denominator()).ToCString());
+}
+
+
 // Synchronize with implementation in compiler (intrinsifier).
 class StringHasher : ValueObject {
  public:
   StringHasher() : hash_(0) {}
   void Add(int32_t ch) {
     hash_ = CombineHashes(hash_, ch);
   }
   void Add(const String& str, intptr_t begin_index, intptr_t len);
 
   // Return a non-zero hash of at most 'bits' bits.
@@ skipping 3131 matching lines @@
   return UserTag::null();
 }
 
 
 const char* UserTag::ToCString() const {
   const String& tag_label = String::Handle(label());
   return tag_label.ToCString();
 }
 
 }  // namespace dart