Pixels 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<Pixels>();
+  // TODO(regis): Remove once native getters are implemented for _Pixels.
+  cls.SetRefinalizeAfterPatch();  // Fields are defined both in C++ and in Dart.
+  isolate->object_store()->set_pixels_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<Pixels>();
+  object_store->set_pixels_class(cls);
+  // TODO(regis): Remove once native getters are implemented for _Pixels.
+  cls.SetRefinalizeAfterPatch();  // Fields are defined both in C++ and in Dart.
+  RegisterPrivateClass(cls, Symbols::_Pixels(), 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<Pixels>();
+  // TODO(regis): Remove once native getters are implemented for _Pixels.
+  cls.SetRefinalizeAfterPatch();  // Fields are defined both in C++ and in Dart.
+  object_store->set_pixels_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();
 }
 
 
+RawPixels* Class::LookupCanonicalPixels(Zone* zone,
+                                        intptr_t value,
+                                        intptr_t* index) const {
+  ASSERT(this->raw() == Isolate::Current()->object_store()->pixels_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.
+  Pixels& canonical_value = Pixels::Handle(zone);
+  while (*index < constants_len) {
+    canonical_value ^= constants.At(*index);
+    if (canonical_value.IsNull()) {
+      break;
+    }
+    if (canonical_value.Value() == value) {
+      ASSERT(canonical_value.IsCanonical());
+      return canonical_value.raw();
+    }
+    *index = *index + 1;
+  }
+  return Pixels::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::kPIXELS) {
+    const Pixels& value = Pixels::Handle(Pixels::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 kPixelsCid: {
+      return Pixels::NewCanonical(Pixels::Cast(*this).Value());
+    }
     default:
       UNREACHABLE();
   }
   return Instance::null();
 }
 
 
 const char* Number::ToCString() const {
   // Number is an interface. No instances of Number should exist.
   UNREACHABLE();
@@ skipping 1370 matching lines @@
   Zone* zone = Thread::Current()->zone();
   return zone->AllocUnsafe(size);
 }
 
 
 const char* Bigint::ToCString() const {
   return ToDecCString(&BigintAllocator);
 }
 
 
+bool Pixels::CanonicalizeEquals(const Instance& other) const {
+  if (this->raw() == other.raw()) {
+    return true;  // "===".
+  }
+  if (other.IsNull() || !other.IsPixels()) {
+    return false;
+  }
+  return Value() == Pixels::Cast(other).Value();
+}
+
+
+RawPixels*  Pixels::New(intptr_t value, Heap::Space space) {
+  Thread* thread = Thread::Current();
+  Zone* zone = thread->zone();
+  Isolate* isolate = thread->isolate();
+  ASSERT(isolate->object_store()->pixels_class() != Class::null());
+  Pixels& result = Pixels::Handle(zone);
+  {
+    RawObject* raw = Object::Allocate(Pixels::kClassId,
+                                      Pixels::InstanceSize(),
+                                      space);
+    NoSafepointScope no_safepoint;
+    result ^= raw;
+  }
+  result.set_value(value);
+  return result.raw();
+}
+
+
+static bool CStringToPixels(const char* str,
+                            intptr_t length,
+                            intptr_t* result) {
+  ASSERT(str != NULL);
+  ASSERT(length > 0);
+  const uint64_t max_accum = (1LL << (63 - Pixels::kFractionalBits)) / 10;
+  uint64_t numerator = 0LL;
+  uint64_t denominator = 1LL;
+  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')) {
+      // Ignore extra digits not contributing to the result.
+      if ((numerator < max_accum) && (denominator < max_accum)) {
+        numerator = numerator*10 + (c - '0');
+        if (seen_decimal_point) denominator *= 10;
+      }
+    } else {
+      if ((strcmp(str + i, "px") != 0) && (strcmp(str + i, "PX") != 0)) {
+        return false;
+      }
+      break;
+    }
+  }
+  uint64_t value = (numerator << Pixels::kFractionalBits) / denominator;
+  if (value > Pixels::kPlusInfinity) value = Pixels::kPlusInfinity;
+  *result = static_cast<intptr_t>(value);
+  return true;
+}
+
+
+RawPixels* Pixels::NewCanonical(const String& str) {
+  intptr_t value;
+  if (!CStringToPixels(str.ToCString(), str.Length(), &value)) {
+    return Pixels::null();
+  }
+  return Pixels::NewCanonical(value);
+}
+
+RawPixels* Pixels::NewCanonical(intptr_t value) {
+  Thread* thread = Thread::Current();
+  Zone* zone = thread->zone();
+  Isolate* isolate = thread->isolate();
+  const Class& cls =
+      Class::Handle(zone, isolate->object_store()->pixels_class());
+  intptr_t index = 0;
+  Pixels& canonical_value = Pixels::Handle(zone);
+  canonical_value ^= cls.LookupCanonicalPixels(zone, value, &index);
+  if (!canonical_value.IsNull()) {
+    return canonical_value.raw();
+  }
+  {
+    SafepointMutexLocker ml(isolate->constant_canonicalization_mutex());
+    // Retry lookup.
+    {
+      canonical_value ^= cls.LookupCanonicalPixels(zone, value, &index);
+      if (!canonical_value.IsNull()) {
+        return canonical_value.raw();
+      }
+    }
+    canonical_value = Pixels::New(value, Heap::kOld);
+    canonical_value.SetCanonical();
+    // The value needs to be added to the constants list. Grow the list if
+    // it is full.
+    cls.InsertCanonicalNumber(zone, index, canonical_value);
+    return canonical_value.raw();
+  }
+}
+
+
+void Pixels::set_value(intptr_t value) const {
+  ASSERT((kMinusInfinity <= value) && (value <= kPlusInfinity));
+  StoreSmi(&raw_ptr()->value_, Smi::New(value));
+}
+
+
+const char* Pixels::ToCString() const {
+  if (IsNull()) {
+    return "_Pixels NULL";
+  }
+  // TODO(regis): Handle non finite values.
+  return OS::SCreate(Thread::Current()->zone(), "_Pixels %f",
+                     static_cast<double>(Value()) / Pixels::kScaling);
+}
+
+
 // 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