- Rename class index to class id.

runtime/vm/dart_api_impl.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 "include/dart_api.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/dart.h"
@@ skipping 241 matching lines @@
   ASSERT(api_native_key_ == Thread::kUnsetThreadLocalKey);
   api_native_key_ = Thread::CreateThreadLocal();
   ASSERT(api_native_key_ != Thread::kUnsetThreadLocalKey);
 }
 
 
 // --- Handles ---
 
 
 DART_EXPORT bool Dart_IsError(Dart_Handle handle) {
-  return RawObject::IsErrorClassIndex(Api::ClassIndex(handle));
+  return RawObject::IsErrorClassId(Api::ClassId(handle));
 }
 
 
 DART_EXPORT const char* Dart_GetError(Dart_Handle handle) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(handle));
   if (obj.IsError()) {
     Error& error = Error::Handle(isolate);
     error ^= obj.raw();
@@ skipping 767 matching lines @@
 
 
 DART_EXPORT Dart_Handle Dart_Null() {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE_SCOPE(isolate);
   return Api::Null(isolate);
 }
 
 
 DART_EXPORT bool Dart_IsNull(Dart_Handle object) {
-  return Api::ClassIndex(object) == kNullClassIndex;
+  return Api::ClassId(object) == kNullClassId;
 }
 
 
 DART_EXPORT Dart_Handle Dart_ObjectEquals(Dart_Handle obj1, Dart_Handle obj2,
                                           bool* value) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Instance& expected =
       Instance::CheckedHandle(isolate, Api::UnwrapHandle(obj1));
   const Instance& actual =
@@ skipping 49 matching lines @@
   ASSERT(malformed_type_error.IsNull());  // Type was created here from a class.
   return Api::Success(isolate);
 }
 
 
 // --- Numbers ----
 
 
 // TODO(iposva): The argument should be an instance.
 DART_EXPORT bool Dart_IsNumber(Dart_Handle object) {
-  return RawObject::IsNumberClassIndex(Api::ClassIndex(object));
+  return RawObject::IsNumberClassId(Api::ClassId(object));
 }
 
 
 // --- Integers ----
 
 
 DART_EXPORT bool Dart_IsInteger(Dart_Handle object) {
-  return RawObject::IsIntegerClassIndex(Api::ClassIndex(object));
+  return RawObject::IsIntegerClassId(Api::ClassId(object));
 }
 
 
 DART_EXPORT Dart_Handle Dart_IntegerFitsIntoInt64(Dart_Handle integer,
                                                   bool* fits) {
   // Fast path for Smis and Mints.
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
-  intptr_t class_index = Api::ClassIndex(integer);
+  intptr_t class_index = Api::ClassId(integer);
   if (class_index == kSmi || class_index == kMint) {
     *fits = true;
     return Api::Success(isolate);
   }
 
   DARTSCOPE_NOCHECKS(isolate);
   const Integer& int_obj = Api::UnwrapIntegerHandle(isolate, integer);
   if (int_obj.IsNull()) {
     RETURN_TYPE_ERROR(isolate, integer, Integer);
   }
@@ skipping 163 matching lines @@
 
 
 DART_EXPORT Dart_Handle Dart_False() {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE_SCOPE(isolate);
   return Api::False(isolate);
 }
 
 
 DART_EXPORT bool Dart_IsBoolean(Dart_Handle object) {
-  return Api::ClassIndex(object) == kBool;
+  return Api::ClassId(object) == kBool;
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewBoolean(bool value) {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE_SCOPE(isolate);
   return value ? Api::True(isolate) : Api::False(isolate);
 }
 
 
 DART_EXPORT Dart_Handle Dart_BooleanValue(Dart_Handle boolean_obj,
                                           bool* value) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Bool& obj = Api::UnwrapBoolHandle(isolate, boolean_obj);
   if (obj.IsNull()) {
     RETURN_TYPE_ERROR(isolate, boolean_obj, Bool);
   }
   *value = obj.value();
   return Api::Success(isolate);
 }
 
 
 // --- Doubles ---
 
 
 DART_EXPORT bool Dart_IsDouble(Dart_Handle object) {
-  return Api::ClassIndex(object) == kDouble;
+  return Api::ClassId(object) == kDouble;
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewDouble(double value) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   return Api::NewHandle(isolate, Double::New(value));
 }
 
 
 DART_EXPORT Dart_Handle Dart_DoubleValue(Dart_Handle double_obj,
                                          double* value) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Double& obj = Api::UnwrapDoubleHandle(isolate, double_obj);
   if (obj.IsNull()) {
     RETURN_TYPE_ERROR(isolate, double_obj, Double);
   }
   *value = obj.value();
   return Api::Success(isolate);
 }
 
 
 // --- Strings ---
 
 
 DART_EXPORT bool Dart_IsString(Dart_Handle object) {
-  return RawObject::IsStringClassIndex(Api::ClassIndex(object));
+  return RawObject::IsStringClassId(Api::ClassId(object));
 }
 
 
 DART_EXPORT bool Dart_IsString8(Dart_Handle object) {
-  return RawObject::IsOneByteStringClassIndex(Api::ClassIndex(object));
+  return RawObject::IsOneByteStringClassId(Api::ClassId(object));
 }
 
 
 DART_EXPORT bool Dart_IsString16(Dart_Handle object) {
-  return RawObject::IsTwoByteStringClassIndex(Api::ClassIndex(object));
+  return RawObject::IsTwoByteStringClassId(Api::ClassId(object));
 }
 
 
 DART_EXPORT Dart_Handle Dart_StringLength(Dart_Handle str, intptr_t* len) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const String& str_obj = Api::UnwrapStringHandle(isolate, str);
   if (str_obj.IsNull()) {
     RETURN_TYPE_ERROR(isolate, str, String);
   }
@@ skipping 27 matching lines @@
 
 DART_EXPORT Dart_Handle Dart_NewString32(const uint32_t* codepoints,
                                          intptr_t length) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   return Api::NewHandle(isolate, String::New(codepoints, length));
 }
 
 
 DART_EXPORT bool Dart_IsExternalString(Dart_Handle object) {
-  return RawObject::IsExternalStringClassIndex(Api::ClassIndex(object));
+  return RawObject::IsExternalStringClassId(Api::ClassId(object));
 }
 
 
 DART_EXPORT Dart_Handle Dart_ExternalStringGetPeer(Dart_Handle object,
                                                    void** peer) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const String& str = Api::UnwrapStringHandle(isolate, object);
   if (str.IsNull()) {
     RETURN_TYPE_ERROR(isolate, object, String);
@@ skipping 195 matching lines @@
                               &malformed_type_error)) {
       ASSERT(malformed_type_error.IsNull());  // Type is a raw List.
       return instance.raw();
     }
   }
   return Instance::null();
 }
 
 
 DART_EXPORT bool Dart_IsList(Dart_Handle object) {
-  if (RawObject::IsBuiltinListClassIndex(Api::ClassIndex(object))) {
+  if (RawObject::IsBuiltinListClassId(Api::ClassId(object))) {
     return true;
   }
 
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(object));
   return GetListInstance(isolate, obj) != Instance::null();
 }
 
 
@@ skipping 331 matching lines @@
     }
   }
   return Api::NewError("Object does not implement the 'List' interface");
 }
 
 
 // --- Byte Arrays ---
 
 
 DART_EXPORT bool Dart_IsByteArray(Dart_Handle object) {
-  return RawObject::IsByteArrayClassIndex(Api::ClassIndex(object));
+  return RawObject::IsByteArrayClassId(Api::ClassId(object));
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewByteArray(intptr_t length) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   return Api::NewHandle(isolate, Uint8Array::New(length));
 }
 
 
@@ skipping 1172 matching lines @@
   const char* msg = CheckIsolateState(isolate);
   if (msg != NULL) {
     return Api::NewError(msg);
   }
   CompileAll(isolate, &result);
   return result;
 }
 
 
 DART_EXPORT bool Dart_IsLibrary(Dart_Handle object) {
-  return Api::ClassIndex(object) == kLibrary;
+  return Api::ClassId(object) == kLibrary;
 }
 
 
 DART_EXPORT Dart_Handle Dart_GetClass(Dart_Handle library,
                                       Dart_Handle class_name) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Library& lib = Api::UnwrapLibraryHandle(isolate, library);
   if (lib.IsNull()) {
     RETURN_TYPE_ERROR(isolate, library, Library);
@@ skipping 185 matching lines @@
       *buffer = NULL;
     }
     delete debug_region;
   } else {
     *buffer = NULL;
     *buffer_size = 0;
   }
 }
 
 }  // namespace dart