Improve the casing of Stackmap and Stacktrace.

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 RUNTIME_VM_OBJECT_H_
 #define RUNTIME_VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 739 matching lines @@
   static RawClass* literal_token_class_;     // Class of LiteralToken vm object.
   static RawClass* token_stream_class_;  // Class of the TokenStream vm object.
   static RawClass* script_class_;        // Class of the Script vm object.
   static RawClass* library_class_;       // Class of the Library vm object.
   static RawClass* namespace_class_;     // Class of Namespace vm object.
   static RawClass* code_class_;          // Class of the Code vm object.
   static RawClass* instructions_class_;  // Class of the Instructions vm object.
   static RawClass* object_pool_class_;   // Class of the ObjectPool vm object.
   static RawClass* pc_descriptors_class_;   // Class of PcDescriptors vm object.
   static RawClass* code_source_map_class_;  // Class of CodeSourceMap vm object.
-  static RawClass* stackmap_class_;         // Class of Stackmap vm object.
+  static RawClass* stackmap_class_;         // Class of StackMap vm object.
   static RawClass* var_descriptors_class_;  // Class of LocalVarDescriptors.
   static RawClass* exception_handlers_class_;  // Class of ExceptionHandlers.
   static RawClass* deopt_info_class_;          // Class of DeoptInfo.
   static RawClass* context_class_;        // Class of the Context vm object.
   static RawClass* context_scope_class_;  // Class of ContextScope vm object.
   static RawClass* singletargetcache_class_;    // Class of SingleTargetCache.
   static RawClass* unlinkedcall_class_;         // Class of UnlinkedCall.
   static RawClass* icdata_class_;               // Class of ICData.
   static RawClass* megamorphic_cache_class_;    // Class of MegamorphiCache.
   static RawClass* subtypetestcache_class_;     // Class of SubtypeTestCache.
@@ skipping 3625 matching lines @@
   intptr_t Length() const;
   void SetLength(intptr_t value) const;
   void CopyData(GrowableArray<uint8_t>* data);
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(CodeSourceMap, Object);
   friend class Class;
   friend class Object;
 };
 
 
-class Stackmap : public Object {
+class StackMap : public Object {
  public:
   static const intptr_t kNoMaximum = -1;
   static const intptr_t kNoMinimum = -1;
 
   bool IsObject(intptr_t index) const {
     ASSERT(InRange(index));
     return GetBit(index);
   }
 
   intptr_t Length() const { return raw_ptr()->length_; }
 
   uint32_t PcOffset() const { return raw_ptr()->pc_offset_; }
   void SetPcOffset(uint32_t value) const {
     ASSERT(value <= kMaxUint32);
     StoreNonPointer(&raw_ptr()->pc_offset_, value);
   }
 
   intptr_t SlowPathBitCount() const { return raw_ptr()->slow_path_bit_count_; }
   void SetSlowPathBitCount(intptr_t bit_count) const {
     ASSERT(bit_count < kMaxInt32);
     StoreNonPointer(&raw_ptr()->slow_path_bit_count_, bit_count);
   }
 
-  bool Equals(const Stackmap& other) const {
+  bool Equals(const StackMap& other) const {
     if (Length() != other.Length()) {
       return false;
     }
     NoSafepointScope no_safepoint;
     return memcmp(raw_ptr(), other.raw_ptr(), InstanceSize(Length())) == 0;
   }
 
   static const intptr_t kMaxLengthInBytes = kSmiMax;
 
   static intptr_t InstanceSize() {
-    ASSERT(sizeof(RawStackmap) == OFFSET_OF_RETURNED_VALUE(RawStackmap, data));
+    ASSERT(sizeof(RawStackMap) == OFFSET_OF_RETURNED_VALUE(RawStackMap, data));
     return 0;
   }
   static intptr_t InstanceSize(intptr_t length) {
     ASSERT(length >= 0);
     // The stackmap payload is in an array of bytes.
     intptr_t payload_size = Utils::RoundUp(length, kBitsPerByte) / kBitsPerByte;
-    return RoundedAllocationSize(sizeof(RawStackmap) + payload_size);
+    return RoundedAllocationSize(sizeof(RawStackMap) + payload_size);
   }
-  static RawStackmap* New(intptr_t pc_offset,
+  static RawStackMap* New(intptr_t pc_offset,
                           BitmapBuilder* bmap,
                           intptr_t register_bit_count);
 
-  static RawStackmap* New(intptr_t length,
+  static RawStackMap* New(intptr_t length,
                           intptr_t register_bit_count,
                           intptr_t pc_offset);
 
  private:
   void SetLength(intptr_t length) const {
     StoreNonPointer(&raw_ptr()->length_, length);
   }
 
   bool InRange(intptr_t index) const { return index < Length(); }
 
   bool GetBit(intptr_t bit_index) const;
   void SetBit(intptr_t bit_index, bool value) const;
 
-  FINAL_HEAP_OBJECT_IMPLEMENTATION(Stackmap, Object);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(StackMap, Object);
   friend class BitmapBuilder;
   friend class Class;
 };
 
 
 class ExceptionHandlers : public Object {
  public:
   static const intptr_t kInvalidPcOffset = 0;
 
   intptr_t num_entries() const;
 
   void GetHandlerInfo(intptr_t try_index,
                       RawExceptionHandlers::HandlerInfo* info) const;
 
   uword HandlerPCOffset(intptr_t try_index) const;
   intptr_t OuterTryIndex(intptr_t try_index) const;
-  bool NeedsStacktrace(intptr_t try_index) const;
+  bool NeedsStackTrace(intptr_t try_index) const;
 
   void SetHandlerInfo(intptr_t try_index,
                       intptr_t outer_try_index,
                       uword handler_pc_offset,
                       bool needs_stacktrace,
                       bool has_catch_all) const;
 
   RawArray* GetHandledTypes(intptr_t try_index) const;
   void SetHandledTypes(intptr_t try_index, const Array& handled_types) const;
   bool HasCatchAll(intptr_t try_index) const;
@@ skipping 177 matching lines @@
     UNREACHABLE();
     return NULL;
 #else
     return raw_ptr()->deopt_info_array_;
 #endif
   }
   void set_deopt_info_array(const Array& array) const;
 
   RawArray* stackmaps() const { return raw_ptr()->stackmaps_; }
   void set_stackmaps(const Array& maps) const;
-  RawStackmap* GetStackmap(uint32_t pc_offset,
+  RawStackMap* GetStackMap(uint32_t pc_offset,
                            Array* stackmaps,
-                           Stackmap* map) const;
+                           StackMap* map) const;
 
   enum {
     kSCallTableOffsetEntry = 0,
     kSCallTableFunctionEntry = 1,
     kSCallTableCodeEntry = 2,
     kSCallTableEntryLength = 3,
   };
 
   void set_static_calls_target_table(const Array& value) const;
   RawArray* static_calls_target_table() const {
@@ skipping 3672 matching lines @@
                           Dart_Port origin_id,
                           Heap::Space space = Heap::kNew);
 
  private:
   FINAL_HEAP_OBJECT_IMPLEMENTATION(SendPort, Instance);
   friend class Class;
 };
 
 
 // Internal stacktrace object used in exceptions for printing stack traces.
-class Stacktrace : public Instance {
+class StackTrace : public Instance {
  public:
   static const int kPreallocatedStackdepth = 30;
 
   intptr_t Length() const;
 
   RawFunction* FunctionAtFrame(intptr_t frame_index) const;
 
   RawCode* CodeAtFrame(intptr_t frame_index) const;
   void SetCodeAtFrame(intptr_t frame_index, const Code& code) const;
 
   RawSmi* PcOffsetAtFrame(intptr_t frame_index) const;
   void SetPcOffsetAtFrame(intptr_t frame_index, const Smi& pc_offset) const;
   void set_expand_inlined(bool value) const;
 
   static intptr_t InstanceSize() {
-    return RoundedAllocationSize(sizeof(RawStacktrace));
+    return RoundedAllocationSize(sizeof(RawStackTrace));
   }
-  static RawStacktrace* New(const Array& code_array,
+  static RawStackTrace* New(const Array& code_array,
                             const Array& pc_offset_array,
                             Heap::Space space = Heap::kNew);
 
   // The argument 'max_frames' limits the number of printed frames.
   const char* ToCStringInternal(intptr_t* frame_index,
                                 intptr_t max_frames = kMaxInt32) const;
 
  private:
   void set_code_array(const Array& code_array) const;
   void set_pc_offset_array(const Array& pc_offset_array) const;
   bool expand_inlined() const;
 
-  FINAL_HEAP_OBJECT_IMPLEMENTATION(Stacktrace, Instance);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(StackTrace, Instance);
   friend class Class;
   friend class Debugger;
 };
 
 
 // Internal JavaScript regular expression object.
 class RegExp : public Instance {
  public:
   // Meaning of RegExType:
   // kUninitialized: the type of th regexp has not been initialized yet.
@@ skipping 466 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  // RUNTIME_VM_OBJECT_H_