Rename dart:typeddata to dart:typed_data.

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/cpu.h"
@@ skipping 871 matching lines @@
 
   cls = Class::New<WeakProperty>();
   object_store->set_weak_property_class(cls);
   RegisterPrivateClass(cls, Symbols::_WeakProperty(), core_lib);
 
   // Setup some default native field classes which can be extended for
   // specifying native fields in dart classes.
   Library::InitNativeWrappersLibrary(isolate);
   ASSERT(isolate->object_store()->native_wrappers_library() != Library::null());
 
-  // Pre-register the typeddata library so the native class implementations
+  // Pre-register the typed_data library so the native class implementations
   // can be hooked up before compiling it.
-  LOAD_LIBRARY(TypedData, typeddata);
+  LOAD_LIBRARY(TypedData, typed_data);
   ASSERT(!lib.IsNull());
   ASSERT(lib.raw() == Library::TypedDataLibrary());
-  const intptr_t typeddata_class_array_length =
+  const intptr_t typed_data_class_array_length =
       RawObject::NumberOfTypedDataClasses();
-  Array& typeddata_classes =
-      Array::Handle(Array::New(typeddata_class_array_length));
+  Array& typed_data_classes =
+      Array::Handle(Array::New(typed_data_class_array_length));
   int index = 0;
 #define REGISTER_TYPED_DATA_CLASS(clazz)                                       \
   cls = Class::NewTypedDataClass(kTypedData##clazz##Cid);                      \
   index = kTypedData##clazz##Cid - kTypedDataInt8ArrayCid;                     \
-  typeddata_classes.SetAt(index, cls);                                         \
+  typed_data_classes.SetAt(index, cls);                                        \
   RegisterPrivateClass(cls, Symbols::_##clazz(), lib);                         \
 
   CLASS_LIST_TYPED_DATA(REGISTER_TYPED_DATA_CLASS);
 #undef REGISTER_TYPED_DATA_CLASS
 #define REGISTER_TYPED_DATA_VIEW_CLASS(clazz)                                  \
   cls = Class::NewTypedDataViewClass(kTypedData##clazz##ViewCid);              \
   index = kTypedData##clazz##ViewCid - kTypedDataInt8ArrayCid;                 \
-  typeddata_classes.SetAt(index, cls);                                         \
+  typed_data_classes.SetAt(index, cls);                                        \
   RegisterPrivateClass(cls, Symbols::_##clazz##View(), lib);                   \
   pending_classes.Add(cls, Heap::kOld);                                        \
 
   CLASS_LIST_TYPED_DATA(REGISTER_TYPED_DATA_VIEW_CLASS);
   cls = Class::NewTypedDataViewClass(kByteDataViewCid);
   index = kByteDataViewCid - kTypedDataInt8ArrayCid;
-  typeddata_classes.SetAt(index, cls);
+  typed_data_classes.SetAt(index, cls);
   RegisterPrivateClass(cls, Symbols::_ByteDataView(), lib);
   pending_classes.Add(cls, Heap::kOld);
 #undef REGISTER_TYPED_DATA_VIEW_CLASS
 #define REGISTER_EXT_TYPED_DATA_CLASS(clazz)                                   \
   cls = Class::NewExternalTypedDataClass(kExternalTypedData##clazz##Cid);      \
   index = kExternalTypedData##clazz##Cid - kTypedDataInt8ArrayCid;             \
-  typeddata_classes.SetAt(index, cls);                                         \
+  typed_data_classes.SetAt(index, cls);                                        \
   RegisterPrivateClass(cls, Symbols::_External##clazz(), lib);                 \
 
   CLASS_LIST_TYPED_DATA(REGISTER_EXT_TYPED_DATA_CLASS);
 #undef REGISTER_EXT_TYPED_DATA_CLASS
   // Register Float32x4 and Uint32x4 in the object store.
   cls = Class::New<Float32x4>();
   object_store->set_float32x4_class(cls);
   RegisterPrivateClass(cls, Symbols::_Float32x4(), lib);
   cls = Class::New<Uint32x4>();
   object_store->set_uint32x4_class(cls);
   RegisterPrivateClass(cls, Symbols::_Uint32x4(), lib);
 
   cls = Class::New<Instance>(Symbols::Float32x4(), script,
                              Scanner::kDummyTokenIndex);
   RegisterClass(cls, Symbols::Float32x4(), lib);
   pending_classes.Add(cls, Heap::kOld);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_float32x4_type(type);
 
   cls = Class::New<Instance>(Symbols::Uint32x4(), script,
                              Scanner::kDummyTokenIndex);
   pending_classes.Add(cls, Heap::kOld);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_uint32x4_type(type);
 
-  object_store->set_typeddata_classes(typeddata_classes);
+  object_store->set_typed_data_classes(typed_data_classes);
 
   // Set the super type of class Stacktrace to Object type so that the
   // 'toString' method is implemented.
   cls = object_store->stacktrace_class();
   cls.set_super_type(type);
 
   // Note: The abstract class Function is represented by VM class
   // DartFunction, not VM class Function.
   cls = Class::New<DartFunction>();
   RegisterClass(cls, Symbols::Function(), core_lib);
@@ skipping 72 matching lines @@
   INIT_LIBRARY(Core, core, true);
 
   INIT_LIBRARY(Async, async, true);
   INIT_LIBRARY(Collection, collection, true);
   INIT_LIBRARY(CollectionDev, collection_dev, true);
   INIT_LIBRARY(Crypto, crypto, false);
   INIT_LIBRARY(Isolate, isolate, true);
   INIT_LIBRARY(Json, json, true);
   INIT_LIBRARY(Math, math, true);
   INIT_LIBRARY(Mirrors, mirrors, true);
-  INIT_LIBRARY(TypedData, typeddata, true);
+  INIT_LIBRARY(TypedData, typed_data, true);
   INIT_LIBRARY(Utf, utf, false);
   INIT_LIBRARY(Uri, uri, false);
 
   Bootstrap::SetupNativeResolver();
 
   // Remove the Object superclass cycle by setting the super type to null (not
   // to the type of null).
   cls = object_store->object_class();
   cls.set_super_type(Type::Handle());
 
@@ skipping 5553 matching lines @@
   return Isolate::Current()->object_store()->mirrors_library();
 }
 
 
 RawLibrary* Library::NativeWrappersLibrary() {
   return Isolate::Current()->object_store()->native_wrappers_library();
 }
 
 
 RawLibrary* Library::TypedDataLibrary() {
-  return Isolate::Current()->object_store()->typeddata_library();
+  return Isolate::Current()->object_store()->typed_data_library();
 }
 
 
 RawLibrary* Library::UriLibrary() {
   return Isolate::Current()->object_store()->uri_library();
 }
 
 
 RawLibrary* Library::UtfLibrary() {
   return Isolate::Current()->object_store()->utf_library();
@@ skipping 269 matching lines @@
 
   lib = Library::CoreLibrary();
   CORE_LIB_INTRINSIC_LIST(CHECK_FINGERPRINTS);
 
   RECOGNIZED_LIST(CHECK_FINGERPRINTS);
 
   lib = Library::MathLibrary();
   MATH_LIB_INTRINSIC_LIST(CHECK_FINGERPRINTS);
 
   lib = Library::TypedDataLibrary();
-  TYPEDDATA_LIB_INTRINSIC_LIST(CHECK_FINGERPRINTS);
+  TYPED_DATA_LIB_INTRINSIC_LIST(CHECK_FINGERPRINTS);
 
 #undef CHECK_FINGERPRINTS
   if (has_errors) {
     for (intptr_t i = 0; i < collected_fp_diffs.length(); i++) {
       OS::Print("s/%d/%d/\n",
           collected_fp_diffs[i].old_fp, collected_fp_diffs[i].new_fp);
     }
     OS::Print("\n");
     FATAL("Fingerprint mismatch.");
   }
@@ skipping 6212 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart