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

runtime/vm/object.h

 // 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.
 
 #ifndef VM_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 1192 matching lines @@
   // Returns an instance of Double or Double::null().
   // 'index' points to either:
   // - constants_list_ position of found element, or
   // - constants_list_ position where new canonical can be inserted.
   RawDouble* LookupCanonicalDouble(Zone* zone,
                                    double value, intptr_t* index) const;
   RawMint* LookupCanonicalMint(Zone* zone,
                                int64_t value, intptr_t* index) const;
   RawBigint* LookupCanonicalBigint(Zone* zone,
                                    const Bigint& value, intptr_t* index) const;
+  RawFraction* LookupCanonicalFraction(Zone* zone,
+                                       const Fraction& value,
+                                       intptr_t* index) const;
   // The methods above are more efficient than this generic one.
   RawInstance* LookupCanonicalInstance(Zone* zone,
                                        const Instance& value) const;
 
   RawInstance* InsertCanonicalConstant(Zone* zone,
                                        const Instance& constant) const;
   void InsertCanonicalNumber(Zone* zone,
                              intptr_t index,
                              const Number& constant) const;
 
@@ skipping 5114 matching lines @@
   static RawTypedData* NewDigitsFromDecCString(const char* str, intptr_t* used,
                                                Heap::Space space = Heap::kNew);
 
   static RawBigint* Allocate(intptr_t length, Heap::Space space = Heap::kNew);
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Bigint, Integer);
   friend class Class;
 };
 
 
-// Class Double represents class Double in corelib_impl, which implements
+class Fraction : public Number {
+ public:
+  RawInteger* numerator() const {
+    return raw_ptr()->numerator_;
+  }
+  RawInteger* denominator() const {
+    return raw_ptr()->denominator_;
+  }
+  virtual bool CanonicalizeEquals(const Instance& other) const;
+
+  static RawFraction* New(Heap::Space space = Heap::kNew);  // For snapshots.
+
+  static RawFraction* New(uint64_t numerator,
+                          uint64_t denominator,
+                          Heap::Space space = Heap::kNew);
+
+  // Returns a canonical Fraction object allocated in the old gen space.
+  static RawFraction* NewCanonical(const Fraction& value);
+
+  // Returns a canonical Fraction object (allocated in the old gen space) or
+  // Fraction::null() if str points to a string that does not convert to a
+  // Fraction value.
+  static RawFraction* NewCanonical(const String& str);
+
+  static intptr_t InstanceSize() {
+    return RoundedAllocationSize(sizeof(RawFraction));
+  }
+
+  static intptr_t numerator_offset() {
+    return OFFSET_OF(RawFraction, numerator_);
+  }
+  static intptr_t denominator_offset() {
+    return OFFSET_OF(RawFraction, denominator_);
+  }
+
+ private:
+  void set_numerator(const Integer& value) const;
+  void set_denominator(const Integer& value) const;
+
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(Fraction, Number);
+  friend class Class;
+  friend class Number;
+};
+
+
+// Class Double represents Dart class _Double in runtime/lib, which implements
 // abstract class double in corelib.
 class Double : public Number {
  public:
   double value() const {
     return raw_ptr()->value_;
   }
 
   bool BitwiseEqualsToDouble(double value) const;
   virtual bool OperatorEquals(const Instance& other) const;
   virtual bool CanonicalizeEquals(const Instance& other) const;
@@ skipping 2297 matching lines @@
 
 inline void TypeArguments::SetHash(intptr_t value) const {
   // This is only safe because we create a new Smi, which does not cause
   // heap allocation.
   StoreSmi(&raw_ptr()->hash_, Smi::New(value));
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_