[objects] Rename macros from DECLARE_ to DECL_ for consistency.

src/objects/string.h

 // Copyright 2017 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_OBJECTS_STRING_H_
 #define V8_OBJECTS_STRING_H_
 
 #include "src/objects/name.h"
 
 // Has to be the last include (doesn't have include guards):
@@ skipping 296 matching lines @@
   bool MakeExternal(v8::String::ExternalOneByteStringResource* resource);
 
   // Conversion.
   inline bool AsArrayIndex(uint32_t* index);
   uint32_t inline ToValidIndex(Object* number);
 
   // Trimming.
   enum TrimMode { kTrim, kTrimLeft, kTrimRight };
   static Handle<String> Trim(Handle<String> string, TrimMode mode);
 
-  DECLARE_CAST(String)
+  DECL_CAST(String)
 
   void PrintOn(FILE* out);
 
   // For use during stack traces.  Performs rudimentary sanity check.
   bool LooksValid();
 
   // Dispatched behavior.
   void StringShortPrint(StringStream* accumulator, bool show_details = true);
   void PrintUC16(std::ostream& os, int start = 0, int end = -1);  // NOLINT
 #if defined(DEBUG) || defined(OBJECT_PRINT)
   char* ToAsciiArray();
 #endif
-  DECLARE_PRINTER(String)
-  DECLARE_VERIFIER(String)
+  DECL_PRINTER(String)
+  DECL_VERIFIER(String)
 
   inline bool IsFlat();
 
   // Layout description.
   static const int kLengthOffset = Name::kSize;
   static const int kSize = kLengthOffset + kPointerSize;
 
   // Max char codes.
   static const int32_t kMaxOneByteCharCode = unibrow::Latin1::kMaxChar;
   static const uint32_t kMaxOneByteCharCodeU = unibrow::Latin1::kMaxChar;
@@ skipping 109 matching lines @@
 
   // Compute and set the hash code.
   uint32_t ComputeAndSetHash();
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(String);
 };
 
 // The SeqString abstract class captures sequential string values.
 class SeqString : public String {
  public:
-  DECLARE_CAST(SeqString)
+  DECL_CAST(SeqString)
 
   // Layout description.
   static const int kHeaderSize = String::kSize;
 
   // Truncate the string in-place if possible and return the result.
   // In case of new_length == 0, the empty string is returned without
   // truncating the original string.
   MUST_USE_RESULT static Handle<String> Truncate(Handle<SeqString> string,
                                                  int new_length);
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(SeqString);
 };
 
 // The OneByteString class captures sequential one-byte string objects.
 // Each character in the OneByteString is an one-byte character.
 class SeqOneByteString : public SeqString {
  public:
   static const bool kHasOneByteEncoding = true;
 
   // Dispatched behavior.
   inline uint16_t SeqOneByteStringGet(int index);
   inline void SeqOneByteStringSet(int index, uint16_t value);
 
   // Get the address of the characters in this string.
   inline Address GetCharsAddress();
 
   inline uint8_t* GetChars();
 
-  DECLARE_CAST(SeqOneByteString)
+  DECL_CAST(SeqOneByteString)
 
   // Garbage collection support.  This method is called by the
   // garbage collector to compute the actual size of an OneByteString
   // instance.
   inline int SeqOneByteStringSize(InstanceType instance_type);
 
   // Computes the size for an OneByteString instance of a given length.
   static int SizeFor(int length) {
     return OBJECT_POINTER_ALIGN(kHeaderSize + length * kCharSize);
   }
@@ skipping 21 matching lines @@
   inline void SeqTwoByteStringSet(int index, uint16_t value);
 
   // Get the address of the characters in this string.
   inline Address GetCharsAddress();
 
   inline uc16* GetChars();
 
   // For regexp code.
   const uint16_t* SeqTwoByteStringGetData(unsigned start);
 
-  DECLARE_CAST(SeqTwoByteString)
+  DECL_CAST(SeqTwoByteString)
 
   // Garbage collection support.  This method is called by the
   // garbage collector to compute the actual size of a TwoByteString
   // instance.
   inline int SeqTwoByteStringSize(InstanceType instance_type);
 
   // Computes the size for a TwoByteString instance of a given length.
   static int SizeFor(int length) {
     return OBJECT_POINTER_ALIGN(kHeaderSize + length * kShortSize);
   }
@@ skipping 33 matching lines @@
   inline String* second();
   // Doesn't check that the result is a string, even in debug mode.  This is
   // useful during GC where the mark bits confuse the checks.
   inline Object* unchecked_second();
   inline void set_second(String* second,
                          WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
 
   // Dispatched behavior.
   V8_EXPORT_PRIVATE uint16_t ConsStringGet(int index);
 
-  DECLARE_CAST(ConsString)
+  DECL_CAST(ConsString)
 
   // Layout description.
   static const int kFirstOffset = POINTER_SIZE_ALIGN(String::kSize);
   static const int kSecondOffset = kFirstOffset + kPointerSize;
   static const int kSize = kSecondOffset + kPointerSize;
 
   // Minimum length for a cons string.
   static const int kMinLength = 13;
 
   typedef FixedBodyDescriptor<kFirstOffset, kSecondOffset + kPointerSize, kSize>
       BodyDescriptor;
   // No weak fields.
   typedef BodyDescriptor BodyDescriptorWeak;
 
-  DECLARE_VERIFIER(ConsString)
+  DECL_VERIFIER(ConsString)
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(ConsString);
 };
 
 // The ThinString class describes string objects that are just references
 // to another string object. They are used for in-place internalization when
 // the original string cannot actually be internalized in-place: in these
 // cases, the original string is converted to a ThinString pointing at its
 // internalized version (which is allocated as a new object).
 // In terms of memory layout and most algorithms operating on strings,
 // ThinStrings can be thought of as "one-part cons strings".
 class ThinString : public String {
  public:
   // Actual string that this ThinString refers to.
   inline String* actual() const;
   inline void set_actual(String* s,
                          WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
 
   V8_EXPORT_PRIVATE uint16_t ThinStringGet(int index);
 
-  DECLARE_CAST(ThinString)
-  DECLARE_VERIFIER(ThinString)
+  DECL_CAST(ThinString)
+  DECL_VERIFIER(ThinString)
 
   // Layout description.
   static const int kActualOffset = String::kSize;
   static const int kSize = kActualOffset + kPointerSize;
 
   typedef FixedBodyDescriptor<kActualOffset, kSize, kSize> BodyDescriptor;
   // No weak fields.
   typedef BodyDescriptor BodyDescriptorWeak;
 
  private:
@@ skipping 16 matching lines @@
  public:
   inline String* parent();
   inline void set_parent(String* parent,
                          WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
   inline int offset() const;
   inline void set_offset(int offset);
 
   // Dispatched behavior.
   V8_EXPORT_PRIVATE uint16_t SlicedStringGet(int index);
 
-  DECLARE_CAST(SlicedString)
+  DECL_CAST(SlicedString)
 
   // Layout description.
   static const int kParentOffset = POINTER_SIZE_ALIGN(String::kSize);
   static const int kOffsetOffset = kParentOffset + kPointerSize;
   static const int kSize = kOffsetOffset + kPointerSize;
 
   // Minimum length for a sliced string.
   static const int kMinLength = 13;
 
   typedef FixedBodyDescriptor<kParentOffset, kOffsetOffset + kPointerSize,
                               kSize>
       BodyDescriptor;
   // No weak fields.
   typedef BodyDescriptor BodyDescriptorWeak;
 
-  DECLARE_VERIFIER(SlicedString)
+  DECL_VERIFIER(SlicedString)
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(SlicedString);
 };
 
 // The ExternalString class describes string values that are backed by
 // a string resource that lies outside the V8 heap.  ExternalStrings
 // consist of the length field common to all strings, a pointer to the
 // external resource.  It is important to ensure (externally) that the
 // resource is not deallocated while the ExternalString is live in the
 // V8 heap.
 //
 // The API expects that all ExternalStrings are created through the
 // API.  Therefore, ExternalStrings should not be used internally.
 class ExternalString : public String {
  public:
-  DECLARE_CAST(ExternalString)
+  DECL_CAST(ExternalString)
 
   // Layout description.
   static const int kResourceOffset = POINTER_SIZE_ALIGN(String::kSize);
   static const int kShortSize = kResourceOffset + kPointerSize;
   static const int kResourceDataOffset = kResourceOffset + kPointerSize;
   static const int kSize = kResourceDataOffset + kPointerSize;
 
   // Return whether external string is short (data pointer is not cached).
   inline bool is_short();
 
@@ skipping 19 matching lines @@
   // The cached pointer is always valid, as the external character array does =
   // not move during lifetime.  Deserialization is the only exception, after
   // which the pointer cache has to be refreshed.
   inline void update_data_cache();
 
   inline const uint8_t* GetChars();
 
   // Dispatched behavior.
   inline uint16_t ExternalOneByteStringGet(int index);
 
-  DECLARE_CAST(ExternalOneByteString)
+  DECL_CAST(ExternalOneByteString)
 
   class BodyDescriptor;
   // No weak fields.
   typedef BodyDescriptor BodyDescriptorWeak;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(ExternalOneByteString);
 };
 
 // The ExternalTwoByteString class is an external string backed by a UTF-16
@@ skipping 15 matching lines @@
   inline void update_data_cache();
 
   inline const uint16_t* GetChars();
 
   // Dispatched behavior.
   inline uint16_t ExternalTwoByteStringGet(int index);
 
   // For regexp code.
   inline const uint16_t* ExternalTwoByteStringGetData(unsigned start);
 
-  DECLARE_CAST(ExternalTwoByteString)
+  DECL_CAST(ExternalTwoByteString)
 
   class BodyDescriptor;
   // No weak fields.
   typedef BodyDescriptor BodyDescriptorWeak;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(ExternalTwoByteString);
 };
 
 // A flat string reader provides random access to the contents of a
@@ skipping 84 matching lines @@
   const uint8_t* end_;
   DISALLOW_COPY_AND_ASSIGN(StringCharacterStream);
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #include "src/objects/object-macros-undef.h"
 
 #endif  // V8_OBJECTS_STRING_H_