DXR is a code search and navigation tool aimed at making sense of large projects. It supports full-text and regex searches as well as structural queries.

Mercurial (b6d82b1a6b02)

VCS Links

Line Code
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 * vim: set ts=8 sts=2 et sw=2 tw=80:
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef vm_JSAtom_inl_h
#define vm_JSAtom_inl_h

#include "vm/JSAtom.h"

#include "mozilla/FloatingPoint.h"
#include "mozilla/RangedPtr.h"

#include "jsnum.h"

#include "vm/Runtime.h"
#include "vm/StringType.h"

namespace js {

inline jsid AtomToId(JSAtom* atom) {
  JS_STATIC_ASSERT(JSID_INT_MIN == 0);

  uint32_t index;
  if (atom->isIndex(&index) && index <= JSID_INT_MAX) {
    return INT_TO_JSID(int32_t(index));
  }

  return JSID_FROM_BITS(size_t(atom) | JSID_TYPE_STRING);
}

// Use the NameToId method instead!
inline jsid AtomToId(PropertyName* name) = delete;

MOZ_ALWAYS_INLINE bool ValueToIntId(const Value& v, jsid* id) {
  int32_t i;
  if (v.isInt32()) {
    i = v.toInt32();
  } else if (!v.isDouble() || !mozilla::NumberEqualsInt32(v.toDouble(), &i)) {
    return false;
  }

  if (!INT_FITS_IN_JSID(i)) {
    return false;
  }

  *id = INT_TO_JSID(i);
  return true;
}

inline bool ValueToIdPure(const Value& v, jsid* id) {
  if (v.isString()) {
    if (v.toString()->isAtom()) {
      *id = AtomToId(&v.toString()->asAtom());
      return true;
    }
    return false;
  }

  if (ValueToIntId(v, id)) {
    return true;
  }

  if (v.isSymbol()) {
    *id = SYMBOL_TO_JSID(v.toSymbol());
    return true;
  }

  return false;
}

template <AllowGC allowGC>
inline bool ValueToId(
    JSContext* cx, typename MaybeRooted<Value, allowGC>::HandleType v,
    typename MaybeRooted<jsid, allowGC>::MutableHandleType idp) {
  if (v.isString()) {
    if (v.toString()->isAtom()) {
      idp.set(AtomToId(&v.toString()->asAtom()));
      return true;
    }
  } else {
    if (ValueToIntId(v, idp.address())) {
      return true;
    }

    if (v.isSymbol()) {
      idp.set(SYMBOL_TO_JSID(v.toSymbol()));
      return true;
    }
  }

  JSAtom* atom = ToAtom<allowGC>(cx, v);
  if (!atom) {
    return false;
  }

  idp.set(AtomToId(atom));
  return true;
}

/*
 * Write out character representing |index| to the memory just before |end|.
 * Thus |*end| is not touched, but |end[-1]| and earlier are modified as
 * appropriate.  There must be at least js::UINT32_CHAR_BUFFER_LENGTH elements
 * before |end| to avoid buffer underflow.  The start of the characters written
 * is returned and is necessarily before |end|.
 */
template <typename T>
inline mozilla::RangedPtr<T> BackfillIndexInCharBuffer(
    uint32_t index, mozilla::RangedPtr<T> end) {
#ifdef DEBUG
  /*
   * Assert that the buffer we're filling will hold as many characters as we
   * could write out, by dereferencing the index that would hold the most
   * significant digit.
   */
  (void)*(end - UINT32_CHAR_BUFFER_LENGTH);
#endif

  do {
    uint32_t next = index / 10, digit = index % 10;
    *--end = '0' + digit;
    index = next;
  } while (index > 0);

  return end;
}

bool IndexToIdSlow(JSContext* cx, uint32_t index, MutableHandleId idp);

inline bool IndexToId(JSContext* cx, uint32_t index, MutableHandleId idp) {
  if (index <= JSID_INT_MAX) {
    idp.set(INT_TO_JSID(index));
    return true;
  }

  return IndexToIdSlow(cx, index, idp);
}

static MOZ_ALWAYS_INLINE JSFlatString* IdToString(JSContext* cx, jsid id) {
  if (JSID_IS_STRING(id)) {
    return JSID_TO_ATOM(id);
  }

  if (MOZ_LIKELY(JSID_IS_INT(id))) {
    return Int32ToString<CanGC>(cx, JSID_TO_INT(id));
  }

  RootedValue idv(cx, IdToValue(id));
  JSString* str = ToStringSlow<CanGC>(cx, idv);
  if (!str) {
    return nullptr;
  }

  return str->ensureFlat(cx);
}

inline Handle<PropertyName*> TypeName(JSType type, const JSAtomState& names) {
  MOZ_ASSERT(type < JSTYPE_LIMIT);
  JS_STATIC_ASSERT(offsetof(JSAtomState, undefined) +
                       JSTYPE_LIMIT * sizeof(ImmutablePropertyNamePtr) <=
                   sizeof(JSAtomState));
  JS_STATIC_ASSERT(JSTYPE_UNDEFINED == 0);
  return (&names.undefined)[type];
}

inline Handle<PropertyName*> ClassName(JSProtoKey key, JSAtomState& atomState) {
  MOZ_ASSERT(key < JSProto_LIMIT);
  JS_STATIC_ASSERT(offsetof(JSAtomState, Null) +
                       JSProto_LIMIT * sizeof(ImmutablePropertyNamePtr) <=
                   sizeof(JSAtomState));
  JS_STATIC_ASSERT(JSProto_Null == 0);
  return (&atomState.Null)[key];
}

}  // namespace js

#endif /* vm_JSAtom_inl_h */