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

runtime/vm/raw_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_RAW_OBJECT_H_
 #define VM_RAW_OBJECT_H_
 
 #include "platform/assert.h"
 #include "vm/atomic.h"
 #include "vm/globals.h"
@@ skipping 43 matching lines @@
       V(TypeRef)                                                               \
       V(TypeParameter)                                                         \
       V(BoundedType)                                                           \
       V(MixinAppType)                                                          \
     V(Closure)                                                                 \
     V(Number)                                                                  \
       V(Integer)                                                               \
         V(Smi)                                                                 \
         V(Mint)                                                                \
         V(Bigint)                                                              \
+      V(Fraction)                                                              \
       V(Double)                                                                \
     V(Bool)                                                                    \
     V(GrowableObjectArray)                                                     \
     V(Float32x4)                                                               \
     V(Int32x4)                                                                 \
     V(Float64x2)                                                               \
     V(TypedData)                                                               \
     V(ExternalTypedData)                                                       \
     V(Capability)                                                              \
     V(ReceivePort)                                                             \
@@ skipping 1724 matching lines @@
   RAW_HEAP_OBJECT_IMPLEMENTATION(Bigint);
 
   RawObject** from() { return reinterpret_cast<RawObject**>(&ptr()->neg_); }
   RawBool* neg_;
   RawSmi* used_;
   RawTypedData* digits_;
   RawObject** to() { return reinterpret_cast<RawObject**>(&ptr()->digits_); }
 };
 
 
+class RawFraction : public RawNumber {
+  RAW_HEAP_OBJECT_IMPLEMENTATION(Fraction);
+
+  RawObject** from() {
+    return reinterpret_cast<RawObject**>(&ptr()->numerator_);
+  }
+  RawInteger* numerator_;
+  RawInteger* denominator_;
+  RawObject** to() {
+    return reinterpret_cast<RawObject**>(&ptr()->denominator_);
+  }
+};
+
+
 class RawDouble : public RawNumber {
   RAW_HEAP_OBJECT_IMPLEMENTATION(Double);
 
   ALIGN8 double value_;
 
   friend class Api;
   friend class SnapshotReader;
 };
 COMPILE_ASSERT(sizeof(RawDouble) == 16);
 
@@ skipping 412 matching lines @@
   return (index >= kErrorCid && index < kInstanceCid);
 }
 
 
 inline bool RawObject::IsNumberClassId(intptr_t index) {
   // Make sure this function is updated when new Number types are added.
   COMPILE_ASSERT(kIntegerCid == kNumberCid + 1 &&
                  kSmiCid == kNumberCid + 2 &&
                  kMintCid == kNumberCid + 3 &&
                  kBigintCid == kNumberCid + 4 &&
-                 kDoubleCid == kNumberCid + 5);
+                 kFractionCid == kNumberCid + 5 &&
+                 kDoubleCid == kNumberCid + 6);
   return (index >= kNumberCid && index < kBoolCid);
 }
 
 
 inline bool RawObject::IsIntegerClassId(intptr_t index) {
   // Make sure this function is updated when new Integer types are added.
   COMPILE_ASSERT(kSmiCid == kIntegerCid + 1 &&
                  kMintCid == kIntegerCid + 2 &&
                  kBigintCid == kIntegerCid + 3 &&
-                 kDoubleCid == kIntegerCid + 4);
-  return (index >= kIntegerCid && index < kDoubleCid);
+                 kFractionCid == kIntegerCid + 4);
+  return (index >= kIntegerCid && index < kFractionCid);
 }
 
 
 inline bool RawObject::IsStringClassId(intptr_t index) {
   // Make sure this function is updated when new StringCid types are added.
   COMPILE_ASSERT(kOneByteStringCid == kStringCid + 1 &&
                  kTwoByteStringCid == kStringCid + 2 &&
                  kExternalOneByteStringCid == kStringCid + 3 &&
                  kExternalTwoByteStringCid == kStringCid + 4);
   return (index >= kStringCid && index <= kExternalTwoByteStringCid);
@@ skipping 147 matching lines @@
          (index == kContextScopeCid) ||
          (index == kInstanceCid) ||
          (index == kRegExpCid);
 }
 
 
 // This is a set of classes that are not Dart classes whose representation
 // is defined by the VM but are used in the VM code by computing the
 // implicit field offsets of the various fields in the dart object.
 inline bool RawObject::IsImplicitFieldClassId(intptr_t index) {
-  return (IsTypedDataViewClassId(index) || index == kByteBufferCid);
+  return (IsTypedDataViewClassId(index) || (index == kByteBufferCid));
 }
 
 
 inline intptr_t RawObject::NumberOfTypedDataClasses() {
   // Make sure this is updated when new TypedData types are added.
   COMPILE_ASSERT(kTypedDataInt8ArrayViewCid == kTypedDataInt8ArrayCid + 14);
   COMPILE_ASSERT(kExternalTypedDataInt8ArrayCid ==
                  kTypedDataInt8ArrayViewCid + 15);
   COMPILE_ASSERT(kByteBufferCid == kExternalTypedDataInt8ArrayCid + 14);
   COMPILE_ASSERT(kNullCid == kByteBufferCid + 1);
   return (kNullCid - kTypedDataInt8ArrayCid);
 }
 
 }  // namespace dart
 
 #endif  // VM_RAW_OBJECT_H_