libraries/source/spidermonkey/include-win32-debug/js/shadow/String.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
   2  * vim: set ts=8 sts=2 et sw=2 tw=80:
   3  * This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 /* Shadow definition of |JSString| innards.  Don't use this directly! */
   8
   9 #ifndef js_shadow_String_h
  10 #define js_shadow_String_h
  11
  12 #include <stdint.h>  // uint32_t, uintptr_t
  13
  14 #include "jstypes.h"  // JS_PUBLIC_API, js::Bit, js::BitMask, JS_BITS_PER_WORD
  15
  16 #include "js/TypeDecls.h"  // JS::Latin1Char
  17
  18 class JS_PUBLIC_API JSAtom;
  19 struct JSExternalStringCallbacks;
  20 class JSLinearString;
  21 class JS_PUBLIC_API JSString;
  22
  23 namespace js {
  24 namespace gc {
  25 struct Cell;
  26 }  // namespace gc
  27 }  // namespace js
  28
  29 namespace JS {
  30
  31 namespace shadow {
  32
  33 struct String {
  34   static constexpr uint32_t ATOM_BIT = js::Bit(3);
  35   static constexpr uint32_t LINEAR_BIT = js::Bit(4);
  36   static constexpr uint32_t INLINE_CHARS_BIT = js::Bit(6);
  37   static constexpr uint32_t LATIN1_CHARS_BIT = js::Bit(9);
  38   static constexpr uint32_t EXTERNAL_FLAGS = LINEAR_BIT | js::Bit(8);
  39   static constexpr uint32_t TYPE_FLAGS_MASK = js::BitMask(9) - js::BitMask(3);
  40   static constexpr uint32_t PERMANENT_ATOM_MASK = ATOM_BIT | js::Bit(8);
  41
  42   uintptr_t flags_;
  43 #if JS_BITS_PER_WORD == 32
  44   uint32_t length_;
  45 #endif
  46
  47   union {
  48     const JS::Latin1Char* nonInlineCharsLatin1;
  49     const char16_t* nonInlineCharsTwoByte;
  50     JS::Latin1Char inlineStorageLatin1[1];
  51     char16_t inlineStorageTwoByte[1];
  52   };
  53   const JSExternalStringCallbacks* externalCallbacks;
  54
  55   uint32_t flags() const { return static_cast<uint32_t>(flags_); }
  56   uint32_t length() const {
  57 #if JS_BITS_PER_WORD == 32
  58     return length_;
  59 #else
  60     return static_cast<uint32_t>(flags_ >> 32);
  61 #endif
  62   }
  63
  64   static bool isPermanentAtom(const js::gc::Cell* cell) {
  65     uint32_t flags = reinterpret_cast<const String*>(cell)->flags();
  66     return (flags & PERMANENT_ATOM_MASK) == PERMANENT_ATOM_MASK;
  67   }
  68
  69   bool isLinear() const { return flags() & LINEAR_BIT; }
  70   bool hasLatin1Chars() const { return flags() & LATIN1_CHARS_BIT; }
  71
  72   // For hot code, prefer other type queries.
  73   bool isExternal() const {
  74     return (flags() & TYPE_FLAGS_MASK) == EXTERNAL_FLAGS;
  75   }
  76
  77   const JS::Latin1Char* latin1LinearChars() const {
  78     MOZ_ASSERT(isLinear());
  79     MOZ_ASSERT(hasLatin1Chars());
  80     return (flags() & String::INLINE_CHARS_BIT) ? inlineStorageLatin1
  81                                                 : nonInlineCharsLatin1;
  82   }
  83
  84   const char16_t* twoByteLinearChars() const {
  85     MOZ_ASSERT(isLinear());
  86     MOZ_ASSERT(!hasLatin1Chars());
  87     return (flags() & String::INLINE_CHARS_BIT) ? inlineStorageTwoByte
  88                                                 : nonInlineCharsTwoByte;
  89   }
  90 };
  91
  92 inline const String* AsShadowString(const JSString* str) {
  93   return reinterpret_cast<const String*>(str);
  94 }
  95
  96 inline String* AsShadowString(JSString* str) {
  97   return reinterpret_cast<String*>(str);
  98 }
  99
 100 inline const String* AsShadowString(const JSLinearString* str) {
 101   return reinterpret_cast<const String*>(str);
 102 }
 103
 104 inline String* AsShadowString(JSLinearString* str) {
 105   return reinterpret_cast<String*>(str);
 106 }
 107
 108 inline const String* AsShadowString(const JSAtom* str) {
 109   return reinterpret_cast<const String*>(str);
 110 }
 111
 112 inline String* AsShadowString(JSAtom* str) {
 113   return reinterpret_cast<String*>(str);
 114 }
 115
 116 }  // namespace shadow
 117
 118 }  // namespace JS
 119
 120 #endif  // js_shadow_String_h