/home/maurizio/node-v18.6.0/out/Release/obj/gen/src/node/inspector/protocol/Protocol.h

Bug Summary

File:	out/Release/obj/gen/src/node/inspector/protocol/Protocol.h
Warning:	line 235, column 16 Potential leak of memory pointed to by 'value._M_t._M_t._M_head_impl'

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name Protocol.cpp -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -pic-is-pie -mframe-pointer=all -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/home/maurizio/node-v18.6.0/out -resource-dir /usr/local/lib/clang/16.0.0 -D V8_DEPRECATION_WARNINGS -D V8_IMMINENT_DEPRECATION_WARNINGS -D _GLIBCXX_USE_CXX11_ABI=1 -D NODE_OPENSSL_CONF_NAME=nodejs_conf -D NODE_OPENSSL_HAS_QUIC -D __STDC_FORMAT_MACROS -D OPENSSL_NO_PINSHARED -D OPENSSL_THREADS -D NODE_ARCH="x64" -D NODE_PLATFORM="linux" -D NODE_WANT_INTERNALS=1 -D V8_DEPRECATION_WARNINGS=1 -D NODE_OPENSSL_SYSTEM_CERT_PATH="" -D NODE_USE_NODE_CODE_CACHE=1 -D HAVE_INSPECTOR=1 -D NODE_ENABLE_LARGE_CODE_PAGES=1 -D __POSIX__ -D NODE_USE_V8_PLATFORM=1 -D NODE_HAVE_I18N_SUPPORT=1 -D HAVE_OPENSSL=1 -D OPENSSL_API_COMPAT=0x10100000L -D UCONFIG_NO_SERVICE=1 -D U_ENABLE_DYLOAD=0 -D U_STATIC_IMPLEMENTATION=1 -D U_HAVE_STD_STRING=1 -D UCONFIG_NO_BREAK_ITERATION=0 -D _LARGEFILE_SOURCE -D _FILE_OFFSET_BITS=64 -D _POSIX_C_SOURCE=200112 -D NGHTTP2_STATICLIB -D NDEBUG -D OPENSSL_USE_NODELETE -D L_ENDIAN -D OPENSSL_BUILDING_OPENSSL -D AES_ASM -D BSAES_ASM -D CMLL_ASM -D ECP_NISTZ256_ASM -D GHASH_ASM -D KECCAK1600_ASM -D MD5_ASM -D OPENSSL_BN_ASM_GF2m -D OPENSSL_BN_ASM_MONT -D OPENSSL_BN_ASM_MONT5 -D OPENSSL_CPUID_OBJ -D OPENSSL_IA32_SSE2 -D PADLOCK_ASM -D POLY1305_ASM -D SHA1_ASM -D SHA256_ASM -D SHA512_ASM -D VPAES_ASM -D WHIRLPOOL_ASM -D X25519_ASM -D OPENSSL_PIC -D NGTCP2_STATICLIB -D NGHTTP3_STATICLIB -I ../src -I /home/maurizio/node-v18.6.0/out/Release/obj/gen -I /home/maurizio/node-v18.6.0/out/Release/obj/gen/include -I /home/maurizio/node-v18.6.0/out/Release/obj/gen/src -I ../deps/googletest/include -I ../deps/histogram/src -I ../deps/uvwasi/include -I ../deps/v8/include -I ../deps/icu-small/source/i18n -I ../deps/icu-small/source/common -I ../deps/zlib -I ../deps/llhttp/include -I ../deps/cares/include -I ../deps/uv/include -I ../deps/nghttp2/lib/includes -I ../deps/brotli/c/include -I ../deps/openssl/openssl/include -I ../deps/openssl/openssl/crypto/include -I ../deps/openssl/config/archs/linux-x86_64/asm/include -I ../deps/openssl/config/archs/linux-x86_64/asm -I ../deps/ngtcp2 -I ../deps/ngtcp2/ngtcp2/lib/includes -I ../deps/ngtcp2/ngtcp2/crypto/includes -I ../deps/ngtcp2/nghttp3/lib/includes -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8 -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/x86_64-redhat-linux -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/backward -internal-isystem /usr/local/lib/clang/16.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../x86_64-redhat-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O3 -Wno-unused-parameter -Wno-unused-parameter -std=gnu++17 -fdeprecated-macro -fdebug-compilation-dir=/home/maurizio/node-v18.6.0/out -ferror-limit 19 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2022-08-22-142216-507842-1 -x c++ /home/maurizio/node-v18.6.0/out/Release/obj/gen/src/node/inspector/protocol/Protocol.cpp

/home/maurizio/node-v18.6.0/out/Release/obj/gen/src/node/inspector/protocol/Protocol.cpp

→

1// This file is generated by Protocol_cpp.template.

3// Copyright 2016 The Chromium Authors. All rights reserved.
4// Use of this source code is governed by a BSD-style license that can be
5// found in the LICENSE file.

7#include "src/node/inspector/protocol/Protocol.h"

9#include <algorithm>
10#include <climits>
11#include <cmath>
12#include <cstring>


15// This file is generated by ErrorSupport_cpp.template.

17// Copyright 2016 The Chromium Authors. All rights reserved.
18// Use of this source code is governed by a BSD-style license that can be
19// found in the LICENSE file.

21//#include "ErrorSupport.h"

23namespace node {
24namespace inspector {
25namespace protocol {

27ErrorSupport::ErrorSupport() { }
28ErrorSupport::~ErrorSupport() { }

30void ErrorSupport::setName(const char* name)
31{
  setName(String(name));
33}

35void ErrorSupport::setName(const String& name)
36{
  DCHECK(m_path.size());
  m_path[m_path.size() - 1] = name;
39}

41void ErrorSupport::push()
42{
  m_path.push_back(String());
44}

46void ErrorSupport::pop()
47{
  m_path.pop_back();
49}

51void ErrorSupport::addError(const char* error)
52{
  addError(String(error));
54}

56void ErrorSupport::addError(const String& error)
57{
  StringBuilder builder;
  for (size_t i = 0; i < m_path.size(); ++i) {
      if (i)
          StringUtil::builderAppend(builder, '.');
      StringUtil::builderAppend(builder, m_path[i]);
  }
  StringUtil::builderAppend(builder, ": ");
  StringUtil::builderAppend(builder, error);
  m_errors.push_back(StringUtil::builderToString(builder));
67}

69bool ErrorSupport::hasErrors()
70{
  return !!m_errors.size();
72}

74String ErrorSupport::errors()
75{
  StringBuilder builder;
  for (size_t i = 0; i < m_errors.size(); ++i) {
      if (i)
          StringUtil::builderAppend(builder, "; ");
      StringUtil::builderAppend(builder, m_errors[i]);
  }
  return StringUtil::builderToString(builder);
83}

85} // namespace node
86} // namespace inspector
87} // namespace protocol


90// This file is generated by Values_cpp.template.

92// Copyright 2016 The Chromium Authors. All rights reserved.
93// Use of this source code is governed by a BSD-style license that can be
94// found in the LICENSE file.

96//#include "Values.h"


99namespace node {
100namespace inspector {
101namespace protocol {

103namespace {

105const char* const nullValueString = "null";
106const char* const trueValueString = "true";
107const char* const falseValueString = "false";

109inline bool escapeChar(uint16_t c, StringBuilder* dst)
110{
  switch (c) {
  case '\b': StringUtil::builderAppend(*dst, "\\b"); break;
  case '\f': StringUtil::builderAppend(*dst, "\\f"); break;
  case '\n': StringUtil::builderAppend(*dst, "\\n"); break;
  case '\r': StringUtil::builderAppend(*dst, "\\r"); break;
  case '\t': StringUtil::builderAppend(*dst, "\\t"); break;
  case '\\': StringUtil::builderAppend(*dst, "\\\\"); break;
  case '"': StringUtil::builderAppend(*dst, "\\\""); break;
  default:
      return false;
  }
  return true;
123}

125const char hexDigits[17] = "0123456789ABCDEF";

127void appendUnsignedAsHex(uint16_t number, StringBuilder* dst)
128{
  StringUtil::builderAppend(*dst, "\\u");
  for (size_t i = 0; i < 4; ++i) {
      uint16_t c = hexDigits[(number & 0xF000) >> 12];
      StringUtil::builderAppend(*dst, c);
      number <<= 4;
  }
135}

137template <typename Char>
138void escapeStringForJSONInternal(const Char* str, unsigned len,
                               StringBuilder* dst)
140{
  for (unsigned i = 0; i < len; ++i) {
      Char c = str[i];
      if (escapeChar(c, dst))
          continue;
      if (c < 32 || c > 126) {
          appendUnsignedAsHex(c, dst);
      } else {
          StringUtil::builderAppend(*dst, c);
      }
  }
151}

153// When parsing CBOR, we limit recursion depth for objects and arrays
154// to this constant.
155static constexpr int kStackLimitValues = 1000;


158// Below are three parsing routines for CBOR, which cover enough
159// to roundtrip JSON messages.
160std::unique_ptr<DictionaryValue> parseMap(int32_t stack_depth, cbor::CBORTokenizer* tokenizer);
161std::unique_ptr<ListValue> parseArray(int32_t stack_depth, cbor::CBORTokenizer* tokenizer);
162std::unique_ptr<Value> parseValue(int32_t stack_depth, cbor::CBORTokenizer* tokenizer);

164// |bytes| must start with the indefinite length array byte, so basically,
165// ParseArray may only be called after an indefinite length array has been
166// detected.
167std::unique_ptr<ListValue> parseArray(int32_t stack_depth, cbor::CBORTokenizer* tokenizer) {
DCHECK(tokenizer->TokenTag() == cbor::CBORTokenTag::ARRAY_START);
tokenizer->Next();
auto list = ListValue::create();
while (tokenizer->TokenTag() != cbor::CBORTokenTag::STOP) {
  // Error::CBOR_UNEXPECTED_EOF_IN_ARRAY
  if (tokenizer->TokenTag() == cbor::CBORTokenTag::DONE) return nullptr;
  if (tokenizer->TokenTag() == cbor::CBORTokenTag::ERROR_VALUE) return nullptr;
  // Parse value.
  auto value = parseValue(stack_depth, tokenizer);
  if (!value) return nullptr;
  list->pushValue(std::move(value));
}
tokenizer->Next();
return list;
182}

184std::unique_ptr<Value> parseValue(
  int32_t stack_depth, cbor::CBORTokenizer* tokenizer) {
// Error::CBOR_STACK_LIMIT_EXCEEDED
if (stack_depth > kStackLimitValues) return nullptr;
// Skip past the envelope to get to what's inside.
if (tokenizer->TokenTag() == cbor::CBORTokenTag::ENVELOPE)
  tokenizer->EnterEnvelope();
switch (tokenizer->TokenTag()) {
  case cbor::CBORTokenTag::ERROR_VALUE:
    return nullptr;
  case cbor::CBORTokenTag::DONE:
    // Error::CBOR_UNEXPECTED_EOF_EXPECTED_VALUE
    return nullptr;
  case cbor::CBORTokenTag::TRUE_VALUE: {
    std::unique_ptr<Value> value = FundamentalValue::create(true);
    tokenizer->Next();
    return value;
  }
  case cbor::CBORTokenTag::FALSE_VALUE: {
    std::unique_ptr<Value> value = FundamentalValue::create(false);
    tokenizer->Next();
    return value;
  }
  case cbor::CBORTokenTag::NULL_VALUE: {
    std::unique_ptr<Value> value = FundamentalValue::null();
    tokenizer->Next();
    return value;
  }
  case cbor::CBORTokenTag::INT32: {
    std::unique_ptr<Value> value = FundamentalValue::create(tokenizer->GetInt32());
    tokenizer->Next();
    return value;
  }
  case cbor::CBORTokenTag::DOUBLE: {
    std::unique_ptr<Value> value = FundamentalValue::create(tokenizer->GetDouble());
    tokenizer->Next();
    return value;
  }
  case cbor::CBORTokenTag::STRING8: {
    span<uint8_t> str = tokenizer->GetString8();
    std::unique_ptr<Value> value =
        StringValue::create(StringUtil::fromUTF8(str.data(), str.size()));
    tokenizer->Next();
    return value;
  }
  case cbor::CBORTokenTag::STRING16: {
    span<uint8_t> wire = tokenizer->GetString16WireRep();
    DCHECK_EQ(wire.size() & 1, 0u);
    std::unique_ptr<Value> value = StringValue::create(StringUtil::fromUTF16(
        reinterpret_cast<const uint16_t*>(wire.data()), wire.size() / 2));
    tokenizer->Next();
    return value;
  }
  case cbor::CBORTokenTag::BINARY: {
    span<uint8_t> payload = tokenizer->GetBinary();
    tokenizer->Next();
    return BinaryValue::create(Binary::fromSpan(payload.data(), payload.size()));
  }
  case cbor::CBORTokenTag::MAP_START:
    return parseMap(stack_depth + 1, tokenizer);
  case cbor::CBORTokenTag::ARRAY_START:
    return parseArray(stack_depth + 1, tokenizer);
  default:
    // Error::CBOR_UNSUPPORTED_VALUE
    return nullptr;
}
250}

252// |bytes| must start with the indefinite length array byte, so basically,
253// ParseArray may only be called after an indefinite length array has been
254// detected.
255std::unique_ptr<DictionaryValue> parseMap(
  int32_t stack_depth, cbor::CBORTokenizer* tokenizer) {
auto dict = DictionaryValue::create();
tokenizer->Next();
while (tokenizer->TokenTag() != cbor::CBORTokenTag::STOP) {
  if (tokenizer->TokenTag() == cbor::CBORTokenTag::DONE) {
    // Error::CBOR_UNEXPECTED_EOF_IN_MAP
    return nullptr;
  }
  if (tokenizer->TokenTag() == cbor::CBORTokenTag::ERROR_VALUE) return nullptr;
  // Parse key.
  String key;
  if (tokenizer->TokenTag() == cbor::CBORTokenTag::STRING8) {
    span<uint8_t> key_span = tokenizer->GetString8();
    key = StringUtil::fromUTF8(key_span.data(), key_span.size());
    tokenizer->Next();
  } else if (tokenizer->TokenTag() == cbor::CBORTokenTag::STRING16) {
    span<uint8_t> key_span = tokenizer->GetString16WireRep();
    if (key_span.size() & 1) return nullptr;  // UTF16 is 2 byte multiple.
    key = StringUtil::fromUTF16(
        reinterpret_cast<const uint16_t*>(key_span.data()),
        key_span.size() / 2);
    tokenizer->Next();
  } else {
    // Error::CBOR_INVALID_MAP_KEY
    return nullptr;
  }
  // Parse value.
  auto value = parseValue(stack_depth, tokenizer);
  if (!value) return nullptr;
  dict->setValue(key, std::move(value));
}
tokenizer->Next();
return dict;
289}

291} // anonymous namespace

293// static
294std::unique_ptr<Value> Value::parseBinary(const uint8_t* data, size_t size) {
span<uint8_t> bytes(data, size);

// Error::CBOR_NO_INPUT
if (bytes.empty()) return nullptr;

// Error::CBOR_INVALID_START_BYTE
if (bytes[0] != cbor::InitialByteForEnvelope()) return nullptr;

cbor::CBORTokenizer tokenizer(bytes);
if (tokenizer.TokenTag() == cbor::CBORTokenTag::ERROR_VALUE) return nullptr;

// We checked for the envelope start byte above, so the tokenizer
// must agree here, since it's not an error.
DCHECK(tokenizer.TokenTag() == cbor::CBORTokenTag::ENVELOPE);
tokenizer.EnterEnvelope();
// Error::MAP_START_EXPECTED
if (tokenizer.TokenTag() != cbor::CBORTokenTag::MAP_START) return nullptr;
std::unique_ptr<Value> result = parseMap(/*stack_depth=*/1, &tokenizer);
if (!result) return nullptr;
if (tokenizer.TokenTag() == cbor::CBORTokenTag::DONE) return result;
if (tokenizer.TokenTag() == cbor::CBORTokenTag::ERROR_VALUE) return nullptr;
// Error::CBOR_TRAILING_JUNK
return nullptr;
318}

320bool Value::asBoolean(bool*) const
321{
  return false;
323}

325bool Value::asDouble(double*) const
326{
  return false;
328}

330bool Value::asInteger(int*) const
331{
  return false;
333}

335bool Value::asString(String*) const
336{
  return false;
338}

340bool Value::asBinary(Binary*) const
341{
  return false;
343}

345void Value::writeJSON(StringBuilder* output) const
346{
  DCHECK(m_type == TypeNull);
  StringUtil::builderAppend(*output, nullValueString, 4);
349}

351void Value::writeBinary(std::vector<uint8_t>* bytes) const {
  DCHECK(m_type == TypeNull);
  bytes->push_back(cbor::EncodeNull());
354}

356std::unique_ptr<Value> Value::clone() const
357{
  return Value::null();
359}

361String Value::toJSONString() const
362{
  StringBuilder result;
  StringUtil::builderReserve(result, 512);
  writeJSON(&result);
  return StringUtil::builderToString(result);
367}

369String Value::serializeToJSON() {
  return toJSONString();
371}

373std::vector<uint8_t> Value::serializeToBinary() {
  std::vector<uint8_t> bytes;
  writeBinary(&bytes);
  return bytes;
377}

379bool FundamentalValue::asBoolean(bool* output) const
380{
  if (type() != TypeBoolean)
      return false;
  *output = m_boolValue;
  return true;
385}

387bool FundamentalValue::asDouble(double* output) const
388{
  if (type() == TypeDouble) {
      *output = m_doubleValue;
      return true;
  }
  if (type() == TypeInteger) {
      *output = m_integerValue;
      return true;
  }
  return false;
398}

400bool FundamentalValue::asInteger(int* output) const
401{
  if (type() != TypeInteger)
      return false;
  *output = m_integerValue;
  return true;
406}

408void FundamentalValue::writeJSON(StringBuilder* output) const
409{
  DCHECK(type() == TypeBoolean || type() == TypeInteger || type() == TypeDouble);
  if (type() == TypeBoolean) {
      if (m_boolValue)
          StringUtil::builderAppend(*output, trueValueString, 4);
      else
          StringUtil::builderAppend(*output, falseValueString, 5);
  } else if (type() == TypeDouble) {
      if (!std::isfinite(m_doubleValue)) {
          StringUtil::builderAppend(*output, nullValueString, 4);
          return;
      }
      StringUtil::builderAppend(*output, StringUtil::fromDouble(m_doubleValue));
  } else if (type() == TypeInteger) {
      StringUtil::builderAppend(*output, StringUtil::fromInteger(m_integerValue));
  }
425}

427void FundamentalValue::writeBinary(std::vector<uint8_t>* bytes) const {
  switch (type()) {
  case TypeDouble:
      cbor::EncodeDouble(m_doubleValue, bytes);
      return;
  case TypeInteger:
      cbor::EncodeInt32(m_integerValue, bytes);
      return;
  case TypeBoolean:
      bytes->push_back(m_boolValue ? cbor::EncodeTrue() : cbor::EncodeFalse());
      return;
  default:
      DCHECK(false);
  }
441}

443std::unique_ptr<Value> FundamentalValue::clone() const
444{
  switch (type()) {
  case TypeDouble: return FundamentalValue::create(m_doubleValue);
  case TypeInteger: return FundamentalValue::create(m_integerValue);
  case TypeBoolean: return FundamentalValue::create(m_boolValue);
  default:
      DCHECK(false);
  }
  return nullptr;
453}

455bool StringValue::asString(String* output) const
456{
  *output = m_stringValue;
  return true;
459}

461void StringValue::writeJSON(StringBuilder* output) const
462{
  DCHECK(type() == TypeString);
  StringUtil::builderAppendQuotedString(*output, m_stringValue);
465}

467namespace {
468// This routine distinguishes between the current encoding for a given
469// string |s|, and calls encoding routines that will
470// - Ensure that all ASCII strings end up being encoded as UTF8 in
471//   the wire format - e.g., EncodeFromUTF16 will detect ASCII and
472//   do the (trivial) transcode to STRING8 on the wire, but if it's
473//   not ASCII it'll do STRING16.
474// - Select a format that's cheap to convert to. E.g., we don't
475//   have LATIN1 on the wire, so we call EncodeFromLatin1 which
476//   transcodes to UTF8 if needed.
477void EncodeString(const String& s, std::vector<uint8_t>* out) {
if (StringUtil::CharacterCount(s) == 0) {
  cbor::EncodeString8(span<uint8_t>(nullptr, 0), out);  // Empty string.
} else if (StringUtil::CharactersLatin1(s)) {
  cbor::EncodeFromLatin1(span<uint8_t>(StringUtil::CharactersLatin1(s),
                         StringUtil::CharacterCount(s)),
                         out);
} else if (StringUtil::CharactersUTF16(s)) {
  cbor::EncodeFromUTF16(span<uint16_t>(StringUtil::CharactersUTF16(s),
                                       StringUtil::CharacterCount(s)),
                        out);
} else if (StringUtil::CharactersUTF8(s)) {
  cbor::EncodeString8(span<uint8_t>(StringUtil::CharactersUTF8(s),
                                    StringUtil::CharacterCount(s)),
                      out);
}
493}
494}  // namespace

496void StringValue::writeBinary(std::vector<uint8_t>* bytes) const {
EncodeString(m_stringValue, bytes);
498}

500std::unique_ptr<Value> StringValue::clone() const
501{
  return StringValue::create(m_stringValue);
503}

505bool BinaryValue::asBinary(Binary* output) const
506{
  *output = m_binaryValue;
  return true;
509}

511void BinaryValue::writeJSON(StringBuilder* output) const
512{
  DCHECK(type() == TypeBinary);
  StringUtil::builderAppendQuotedString(*output, m_binaryValue.toBase64());
515}

517void BinaryValue::writeBinary(std::vector<uint8_t>* bytes) const {
  cbor::EncodeBinary(span<uint8_t>(m_binaryValue.data(),
                                   m_binaryValue.size()), bytes);
520}

522std::unique_ptr<Value> BinaryValue::clone() const
523{
  return BinaryValue::create(m_binaryValue);
525}

527void SerializedValue::writeJSON(StringBuilder* output) const
528{
  DCHECK(type() == TypeSerialized);
  StringUtil::builderAppend(*output, m_serializedJSON);
531}

533void SerializedValue::writeBinary(std::vector<uint8_t>* output) const
534{
  DCHECK(type() == TypeSerialized);
  output->insert(output->end(), m_serializedBinary.begin(), m_serializedBinary.end());
537}

539std::unique_ptr<Value> SerializedValue::clone() const
540{
  return std::unique_ptr<SerializedValue>(new SerializedValue(m_serializedJSON, m_serializedBinary));
542}

544DictionaryValue::~DictionaryValue()
545{
546}

548void DictionaryValue::setBoolean(const String& name, bool value)
549{
  setValue(name, FundamentalValue::create(value));
551}

553void DictionaryValue::setInteger(const String& name, int value)
554{
  setValue(name, FundamentalValue::create(value));
556}

558void DictionaryValue::setDouble(const String& name, double value)
559{
  setValue(name, FundamentalValue::create(value));
561}

563void DictionaryValue::setString(const String& name, const String& value)
564{
  setValue(name, StringValue::create(value));
566}

568void DictionaryValue::setValue(const String& name, std::unique_ptr<Value> value)
569{
  set(name, value);
571}

573void DictionaryValue::setObject(const String& name, std::unique_ptr<DictionaryValue> value)
574{
  set(name, value);
576}

578void DictionaryValue::setArray(const String& name, std::unique_ptr<ListValue> value)
579{
  set(name, value);
581}

583bool DictionaryValue::getBoolean(const String& name, bool* output) const
584{
  protocol::Value* value = get(name);
  if (!value)
      return false;
  return value->asBoolean(output);
589}

591bool DictionaryValue::getInteger(const String& name, int* output) const
592{
  Value* value = get(name);
  if (!value)
      return false;
  return value->asInteger(output);
597}

599bool DictionaryValue::getDouble(const String& name, double* output) const
600{
  Value* value = get(name);
  if (!value)
      return false;
  return value->asDouble(output);
605}

607bool DictionaryValue::getString(const String& name, String* output) const
608{
  protocol::Value* value = get(name);
  if (!value)
      return false;
  return value->asString(output);
613}

615DictionaryValue* DictionaryValue::getObject(const String& name) const
616{
  return DictionaryValue::cast(get(name));
618}

620protocol::ListValue* DictionaryValue::getArray(const String& name) const
621{
  return ListValue::cast(get(name));
623}

625protocol::Value* DictionaryValue::get(const String& name) const
626{
  Dictionary::const_iterator it = m_data.find(name);
  if (it == m_data.end())
      return nullptr;
  return it->second.get();
631}

633DictionaryValue::Entry DictionaryValue::at(size_t index) const
634{
  const String key = m_order[index];
  return std::make_pair(key, m_data.find(key)->second.get());
637}

639bool DictionaryValue::booleanProperty(const String& name, bool defaultValue) const
640{
  bool result = defaultValue;
  getBoolean(name, &result);
  return result;
644}

646int DictionaryValue::integerProperty(const String& name, int defaultValue) const
647{
  int result = defaultValue;
  getInteger(name, &result);
  return result;
651}

653double DictionaryValue::doubleProperty(const String& name, double defaultValue) const
654{
  double result = defaultValue;
  getDouble(name, &result);
  return result;
658}

660void DictionaryValue::remove(const String& name)
661{
  m_data.erase(name);
  m_order.erase(std::remove(m_order.begin(), m_order.end(), name), m_order.end());
664}

666void DictionaryValue::writeJSON(StringBuilder* output) const
667{
  StringUtil::builderAppend(*output, '{');
  for (size_t i = 0; i < m_order.size(); ++i) {
      Dictionary::const_iterator it = m_data.find(m_order[i]);
      CHECK(it != m_data.end())do { if (__builtin_expect(!!(!(it != m_data.end())), 0)) { do
 { static const node::AssertionInfo args = { "/home/maurizio/node-v18.6.0/out/Release/obj/gen/src/node/inspector/protocol/Protocol.cpp"
 ":" "671", "it != m_data.end()", __PRETTY_FUNCTION__ }; node
::Assert(args); } while (0); } } while (0);
      if (i)
          StringUtil::builderAppend(*output, ',');
      StringUtil::builderAppendQuotedString(*output, it->first);
      StringUtil::builderAppend(*output, ':');
      it->second->writeJSON(output);
  }
  StringUtil::builderAppend(*output, '}');
679}

681void DictionaryValue::writeBinary(std::vector<uint8_t>* bytes) const {
  cbor::EnvelopeEncoder encoder;
  encoder.EncodeStart(bytes);
  bytes->push_back(cbor::EncodeIndefiniteLengthMapStart());
  for (size_t i = 0; i < m_order.size(); ++i) {
      const String& key = m_order[i];
      Dictionary::const_iterator value = m_data.find(key);
      DCHECK(value != m_data.cend() && value->second);
      EncodeString(key, bytes);
      value->second->writeBinary(bytes);
  }
  bytes->push_back(cbor::EncodeStop());
  encoder.EncodeStop(bytes);
694}

696std::unique_ptr<Value> DictionaryValue::clone() const
697{
  std::unique_ptr<DictionaryValue> result = DictionaryValue::create();
2
←
Calling 'DictionaryValue::create'→
4
←
Returned allocated memory→
  for (size_t i = 0; i < m_order.size(); ++i) {
5
←
Assuming the condition is false→
6
←
Loop condition is false. Execution continues on line 705→
      String key = m_order[i];
      Dictionary::const_iterator value = m_data.find(key);
      DCHECK(value != m_data.cend() && value->second);
      result->setValue(key, value->second->clone());
  }
  return result;
706}

708DictionaryValue::DictionaryValue()
  : Value(TypeObject)
710{
711}

713ListValue::~ListValue()
714{
715}

717void ListValue::writeJSON(StringBuilder* output) const
718{
  StringUtil::builderAppend(*output, '[');
  bool first = true;
  for (const std::unique_ptr<protocol::Value>& value : m_data) {
      if (!first)
          StringUtil::builderAppend(*output, ',');
      value->writeJSON(output);
      first = false;
  }
  StringUtil::builderAppend(*output, ']');
728}

730void ListValue::writeBinary(std::vector<uint8_t>* bytes) const {
  cbor::EnvelopeEncoder encoder;
  encoder.EncodeStart(bytes);
  bytes->push_back(cbor::EncodeIndefiniteLengthArrayStart());
  for (size_t i = 0; i < m_data.size(); ++i) {
      m_data[i]->writeBinary(bytes);
  }
  bytes->push_back(cbor::EncodeStop());
  encoder.EncodeStop(bytes);
739}

741std::unique_ptr<Value> ListValue::clone() const
742{
  std::unique_ptr<ListValue> result = ListValue::create();
  for (const std::unique_ptr<protocol::Value>& value : m_data)
      result->pushValue(value->clone());
  return result;
747}

749ListValue::ListValue()
  : Value(TypeArray)
751{
752}

754void ListValue::pushValue(std::unique_ptr<protocol::Value> value)
755{
  DCHECK(value);
  m_data.push_back(std::move(value));
758}

760protocol::Value* ListValue::at(size_t index)
761{
  DCHECK_LT(index, m_data.size());
  return m_data[index].get();
764}

766void escapeLatinStringForJSON(const uint8_t* str, unsigned len, StringBuilder* dst)
767{
  escapeStringForJSONInternal<uint8_t>(str, len, dst);
769}

771void escapeWideStringForJSON(const uint16_t* str, unsigned len, StringBuilder* dst)
772{
  escapeStringForJSONInternal<uint16_t>(str, len, dst);
774}

776} // namespace node
777} // namespace inspector
778} // namespace protocol


781// This file is generated by Object_cpp.template.

783// Copyright 2016 The Chromium Authors. All rights reserved.
784// Use of this source code is governed by a BSD-style license that can be
785// found in the LICENSE file.

787//#include "Object.h"

789namespace node {
790namespace inspector {
791namespace protocol {

793std::unique_ptr<Object> Object::fromValue(protocol::Value* value, ErrorSupport* errors)
794{
  protocol::DictionaryValue* dictionary = DictionaryValue::cast(value);
  if (!dictionary) {
      errors->addError("object expected");
      return nullptr;
  }
  dictionary = static_cast<protocol::DictionaryValue*>(dictionary->clone().release());
  return std::unique_ptr<Object>(new Object(std::unique_ptr<DictionaryValue>(dictionary)));
802}

804std::unique_ptr<protocol::DictionaryValue> Object::toValue() const
805{
  return DictionaryValue::cast(m_object->clone());
807}

809std::unique_ptr<Object> Object::clone() const
810{
  return std::unique_ptr<Object>(new Object(DictionaryValue::cast(m_object->clone())));
1
Calling 'DictionaryValue::clone'→
7
←
Returned allocated memory→
8
←
Calling 'DictionaryValue::cast'→
812}

814Object::Object(std::unique_ptr<protocol::DictionaryValue> object) : m_object(std::move(object)) { }

816Object::~Object() { }

818} // namespace node
819} // namespace inspector
820} // namespace protocol


823// This file is generated by DispatcherBase_cpp.template.

825// Copyright 2016 The Chromium Authors. All rights reserved.
826// Use of this source code is governed by a BSD-style license that can be
827// found in the LICENSE file.

829//#include "DispatcherBase.h"
830//#include "Parser.h"

832namespace node {
833namespace inspector {
834namespace protocol {

836// static
837DispatchResponse DispatchResponse::OK()
838{
  DispatchResponse result;
  result.m_status = kSuccess;
  result.m_errorCode = kParseError;
  return result;
843}

845// static
846DispatchResponse DispatchResponse::Error(const String& error)
847{
  DispatchResponse result;
  result.m_status = kError;
  result.m_errorCode = kServerError;
  result.m_errorMessage = error;
  return result;
853}

855// static
856DispatchResponse DispatchResponse::InternalError()
857{
  DispatchResponse result;
  result.m_status = kError;
  result.m_errorCode = kInternalError;
  result.m_errorMessage = "Internal error";
  return result;
863}

865// static
866DispatchResponse DispatchResponse::InvalidParams(const String& error)
867{
  DispatchResponse result;
  result.m_status = kError;
  result.m_errorCode = kInvalidParams;
  result.m_errorMessage = error;
  return result;
873}

875// static
876DispatchResponse DispatchResponse::FallThrough()
877{
  DispatchResponse result;
  result.m_status = kFallThrough;
  result.m_errorCode = kParseError;
  return result;
882}

884// static
885const char DispatcherBase::kInvalidParamsString[] = "Invalid parameters";

887DispatcherBase::WeakPtr::WeakPtr(DispatcherBase* dispatcher) : m_dispatcher(dispatcher) { }

889DispatcherBase::WeakPtr::~WeakPtr()
890{
  if (m_dispatcher)
      m_dispatcher->m_weakPtrs.erase(this);
893}

895DispatcherBase::Callback::Callback(std::unique_ptr<DispatcherBase::WeakPtr> backendImpl, int callId, const String& method, const ProtocolMessage& message)
  : m_backendImpl(std::move(backendImpl))
  , m_callId(callId)
  , m_method(method)
  , m_message(message) { }

901DispatcherBase::Callback::~Callback() = default;

903void DispatcherBase::Callback::dispose()
904{
  m_backendImpl = nullptr;
906}

908void DispatcherBase::Callback::sendIfActive(std::unique_ptr<protocol::DictionaryValue> partialMessage, const DispatchResponse& response)
909{
  if (!m_backendImpl || !m_backendImpl->get())
      return;
  m_backendImpl->get()->sendResponse(m_callId, response, std::move(partialMessage));
  m_backendImpl = nullptr;
914}

916void DispatcherBase::Callback::fallThroughIfActive()
917{
  if (!m_backendImpl || !m_backendImpl->get())
      return;
  m_backendImpl->get()->channel()->fallThrough(m_callId, m_method, m_message);
  m_backendImpl = nullptr;
922}

924DispatcherBase::DispatcherBase(FrontendChannel* frontendChannel)
  : m_frontendChannel(frontendChannel) { }

927DispatcherBase::~DispatcherBase()
928{
  clearFrontend();
930}

932void DispatcherBase::sendResponse(int callId, const DispatchResponse& response, std::unique_ptr<protocol::DictionaryValue> result)
933{
  if (!m_frontendChannel)
      return;
  if (response.status() == DispatchResponse::kError) {
      reportProtocolError(callId, response.errorCode(), response.errorMessage(), nullptr);
      return;
  }
  m_frontendChannel->sendProtocolResponse(callId, InternalResponse::createResponse(callId, std::move(result)));
941}

943void DispatcherBase::sendResponse(int callId, const DispatchResponse& response)
944{
  sendResponse(callId, response, DictionaryValue::create());
946}

948namespace {

950class ProtocolError : public Serializable {
951public:
  static std::unique_ptr<ProtocolError> createErrorResponse(int callId, DispatchResponse::ErrorCode code, const String& errorMessage, ErrorSupport* errors)
  {
      std::unique_ptr<ProtocolError> protocolError(new ProtocolError(code, errorMessage));
      protocolError->m_callId = callId;
      protocolError->m_hasCallId = true;
      if (errors && errors->hasErrors())
          protocolError->m_data = errors->errors();
      return protocolError;
  }

  static std::unique_ptr<ProtocolError> createErrorNotification(DispatchResponse::ErrorCode code, const String& errorMessage)
  {
      return std::unique_ptr<ProtocolError>(new ProtocolError(code, errorMessage));
  }

  String serializeToJSON() override
  {
      return serialize()->serializeToJSON();
  }

  std::vector<uint8_t> serializeToBinary() override
  {
      return serialize()->serializeToBinary();
  }

  ~ProtocolError() override {}

979private:
  ProtocolError(DispatchResponse::ErrorCode code, const String& errorMessage)
      : m_code(code)
      , m_errorMessage(errorMessage)
  {
  }

  std::unique_ptr<DictionaryValue> serialize() {
      std::unique_ptr<protocol::DictionaryValue> error = DictionaryValue::create();
      error->setInteger("code", m_code);
      error->setString("message", m_errorMessage);
      if (m_data.length())
          error->setString("data", m_data);
      std::unique_ptr<protocol::DictionaryValue> message = DictionaryValue::create();
      message->setObject("error", std::move(error));
      if (m_hasCallId)
          message->setInteger("id", m_callId);
      return message;
  }

  DispatchResponse::ErrorCode m_code;
  String m_errorMessage;
  String m_data;
  int m_callId = 0;
  bool m_hasCallId = false;
1004};

1006} // namespace

1008static void reportProtocolErrorTo(FrontendChannel* frontendChannel, int callId, DispatchResponse::ErrorCode code, const String& errorMessage, ErrorSupport* errors)
1009{
  if (frontendChannel)
      frontendChannel->sendProtocolResponse(callId, ProtocolError::createErrorResponse(callId, code, errorMessage, errors));
1012}

1014static void reportProtocolErrorTo(FrontendChannel* frontendChannel, DispatchResponse::ErrorCode code, const String& errorMessage)
1015{
  if (frontendChannel)
      frontendChannel->sendProtocolNotification(ProtocolError::createErrorNotification(code, errorMessage));
1018}

1020void DispatcherBase::reportProtocolError(int callId, DispatchResponse::ErrorCode code, const String& errorMessage, ErrorSupport* errors)
1021{
  reportProtocolErrorTo(m_frontendChannel, callId, code, errorMessage, errors);
1023}

1025void DispatcherBase::clearFrontend()
1026{
  m_frontendChannel = nullptr;
  for (auto& weak : m_weakPtrs)
      weak->dispose();
  m_weakPtrs.clear();
1031}

1033std::unique_ptr<DispatcherBase::WeakPtr> DispatcherBase::weakPtr()
1034{
  std::unique_ptr<DispatcherBase::WeakPtr> weak(new DispatcherBase::WeakPtr(this));
  m_weakPtrs.insert(weak.get());
  return weak;
1038}

1040UberDispatcher::UberDispatcher(FrontendChannel* frontendChannel)
  : m_frontendChannel(frontendChannel) { }

1043void UberDispatcher::registerBackend(const String& name, std::unique_ptr<protocol::DispatcherBase> dispatcher)
1044{
  m_dispatchers[name] = std::move(dispatcher);
1046}

1048void UberDispatcher::setupRedirects(const std::unordered_map<String, String>& redirects)
1049{
  for (const auto& pair : redirects)
      m_redirects[pair.first] = pair.second;
1052}

1054bool UberDispatcher::parseCommand(Value* parsedMessage, int* outCallId, String* outMethod) {
  if (!parsedMessage) {
      reportProtocolErrorTo(m_frontendChannel, DispatchResponse::kParseError, "Message must be a valid JSON");
      return false;
  }
  protocol::DictionaryValue* messageObject = DictionaryValue::cast(parsedMessage);
  if (!messageObject) {
      reportProtocolErrorTo(m_frontendChannel, DispatchResponse::kInvalidRequest, "Message must be an object");
      return false;
  }

  int callId = 0;
  protocol::Value* callIdValue = messageObject->get("id");
  bool success = callIdValue && callIdValue->asInteger(&callId);
  if (!success) {
      reportProtocolErrorTo(m_frontendChannel, DispatchResponse::kInvalidRequest, "Message must have integer 'id' property");
      return false;
  }
  if (outCallId)
    *outCallId = callId;

  protocol::Value* methodValue = messageObject->get("method");
  String method;
  success = methodValue && methodValue->asString(&method);
  if (!success) {
      reportProtocolErrorTo(m_frontendChannel, callId, DispatchResponse::kInvalidRequest, "Message must have string 'method' property", nullptr);
      return false;
  }
  if (outMethod)
    *outMethod = method;
  return true;
1085}

1087protocol::DispatcherBase* UberDispatcher::findDispatcher(const String& method) {
  size_t dotIndex = StringUtil::find(method, ".");
  if (dotIndex == StringUtil::kNotFound)
      return nullptr;
  String domain = StringUtil::substring(method, 0, dotIndex);
  auto it = m_dispatchers.find(domain);
  if (it == m_dispatchers.end())
      return nullptr;
  if (!it->second->canDispatch(method))
      return nullptr;
  return it->second.get();
1098}

1100bool UberDispatcher::canDispatch(const String& in_method)
1101{
  String method = in_method;
  auto redirectIt = m_redirects.find(method);
  if (redirectIt != m_redirects.end())
      method = redirectIt->second;
  return !!findDispatcher(method);
1107}

1109void UberDispatcher::dispatch(int callId, const String& in_method, std::unique_ptr<Value> parsedMessage, const ProtocolMessage& rawMessage)
1110{
  String method = in_method;
  auto redirectIt = m_redirects.find(method);
  if (redirectIt != m_redirects.end())
      method = redirectIt->second;
  protocol::DispatcherBase* dispatcher = findDispatcher(method);
  if (!dispatcher) {
      reportProtocolErrorTo(m_frontendChannel, callId, DispatchResponse::kMethodNotFound, "'" + method + "' wasn't found", nullptr);
      return;
  }
  std::unique_ptr<protocol::DictionaryValue> messageObject = DictionaryValue::cast(std::move(parsedMessage));
  dispatcher->dispatch(callId, method, rawMessage, std::move(messageObject));
1122}

1124UberDispatcher::~UberDispatcher() = default;

1126// static
1127std::unique_ptr<InternalResponse> InternalResponse::createResponse(int callId, std::unique_ptr<Serializable> params)
1128{
  return std::unique_ptr<InternalResponse>(new InternalResponse(callId, String(), std::move(params)));
1130}

1132// static
1133std::unique_ptr<InternalResponse> InternalResponse::createNotification(const String& notification, std::unique_ptr<Serializable> params)
1134{
  return std::unique_ptr<InternalResponse>(new InternalResponse(0, notification, std::move(params)));
1136}

1138String InternalResponse::serializeToJSON()
1139{
  std::unique_ptr<DictionaryValue> result = DictionaryValue::create();
  std::unique_ptr<Serializable> params(m_params ? std::move(m_params) : DictionaryValue::create());
  if (m_notification.length()) {
      result->setString("method", m_notification);
      result->setValue("params", SerializedValue::fromJSON(params->serializeToJSON()));
  } else {
      result->setInteger("id", m_callId);
      result->setValue("result", SerializedValue::fromJSON(params->serializeToJSON()));
  }
  return result->serializeToJSON();
1150}

1152std::vector<uint8_t> InternalResponse::serializeToBinary()
1153{
  std::unique_ptr<DictionaryValue> result = DictionaryValue::create();
  std::unique_ptr<Serializable> params(m_params ? std::move(m_params) : DictionaryValue::create());
  if (m_notification.length()) {
      result->setString("method", m_notification);
      result->setValue("params", SerializedValue::fromBinary(params->serializeToBinary()));
  } else {
      result->setInteger("id", m_callId);
      result->setValue("result", SerializedValue::fromBinary(params->serializeToBinary()));
  }
  return result->serializeToBinary();
1164}

1166InternalResponse::InternalResponse(int callId, const String& notification, std::unique_ptr<Serializable> params)
  : m_callId(callId)
  , m_notification(notification)
  , m_params(params ? std::move(params) : nullptr)
1170{
1171}

1173} // namespace node
1174} // namespace inspector
1175} // namespace protocol


1178// This file is generated by Parser_cpp.template.

1180// Copyright 2016 The Chromium Authors. All rights reserved.
1181// Use of this source code is governed by a BSD-style license that can be
1182// found in the LICENSE file.

1184namespace node {
1185namespace inspector {
1186namespace protocol {

1188namespace {

1190const int stackLimit = 1000;

1192enum Token {
  ObjectBegin,
  ObjectEnd,
  ArrayBegin,
  ArrayEnd,
  StringLiteral,
  Number,
  BoolTrue,
  BoolFalse,
  NullToken,
  ListSeparator,
  ObjectPairSeparator,
  InvalidToken,
1205};

1207const char* const nullString = "null";
1208const char* const trueString = "true";
1209const char* const falseString = "false";

1211bool isASCII(uint16_t c)
1212{
  return !(c & ~0x7F);
1214}

1216bool isSpaceOrNewLine(uint16_t c)
1217{
  return isASCII(c) && c <= ' ' && (c == ' ' || (c <= 0xD && c >= 0x9));
1219}

1221double charactersToDouble(const uint16_t* characters, size_t length, bool* ok)
1222{
  std::vector<char> buffer;
  buffer.reserve(length + 1);
  for (size_t i = 0; i < length; ++i) {
      if (!isASCII(characters[i])) {
          *ok = false;
          return 0;
      }
      buffer.push_back(static_cast<char>(characters[i]));
  }
  buffer.push_back('\0');
  return StringUtil::toDouble(buffer.data(), length, ok);
1234}

1236double charactersToDouble(const uint8_t* characters, size_t length, bool* ok)
1237{
  std::string buffer(reinterpret_cast<const char*>(characters), length);
  return StringUtil::toDouble(buffer.data(), length, ok);
1240}

1242template<typename Char>
1243bool parseConstToken(const Char* start, const Char* end, const Char** tokenEnd, const char* token)
1244{
  while (start < end && *token != '\0' && *start++ == *token++) { }
  if (*token != '\0')
      return false;
  *tokenEnd = start;
  return true;
1250}

1252template<typename Char>
1253bool readInt(const Char* start, const Char* end, const Char** tokenEnd, bool canHaveLeadingZeros)
1254{
  if (start == end)
      return false;
  bool haveLeadingZero = '0' == *start;
  int length = 0;
  while (start < end && '0' <= *start && *start <= '9') {
      ++start;
      ++length;
  }
  if (!length)
      return false;
  if (!canHaveLeadingZeros && length > 1 && haveLeadingZero)
      return false;
  *tokenEnd = start;
  return true;
1269}

1271template<typename Char>
1272bool parseNumberToken(const Char* start, const Char* end, const Char** tokenEnd)
1273{
  // We just grab the number here. We validate the size in DecodeNumber.
  // According to RFC4627, a valid number is: [minus] int [frac] [exp]
  if (start == end)
      return false;
  Char c = *start;
  if ('-' == c)
      ++start;

  if (!readInt(start, end, &start, false))
      return false;
  if (start == end) {
      *tokenEnd = start;
      return true;
  }

  // Optional fraction part
  c = *start;
  if ('.' == c) {
      ++start;
      if (!readInt(start, end, &start, true))
          return false;
      if (start == end) {
          *tokenEnd = start;
          return true;
      }
      c = *start;
  }

  // Optional exponent part
  if ('e' == c || 'E' == c) {
      ++start;
      if (start == end)
          return false;
      c = *start;
      if ('-' == c || '+' == c) {
          ++start;
          if (start == end)
              return false;
      }
      if (!readInt(start, end, &start, true))
          return false;
  }

  *tokenEnd = start;
  return true;
1319}

1321template<typename Char>
1322bool readHexDigits(const Char* start, const Char* end, const Char** tokenEnd, int digits)
1323{
  if (end - start < digits)
      return false;
  for (int i = 0; i < digits; ++i) {
      Char c = *start++;
      if (!(('0' <= c && c <= '9') || ('a' <= c && c <= 'f') || ('A' <= c && c <= 'F')))
          return false;
  }
  *tokenEnd = start;
  return true;
1333}

1335template<typename Char>
1336bool parseStringToken(const Char* start, const Char* end, const Char** tokenEnd)
1337{
  while (start < end) {
      Char c = *start++;
      if ('\\' == c) {
   if (start == end)
       return false;
          c = *start++;
          // Make sure the escaped char is valid.
          switch (c) {
          case 'x':
              if (!readHexDigits(start, end, &start, 2))
                  return false;
              break;
          case 'u':
              if (!readHexDigits(start, end, &start, 4))
                  return false;
              break;
          case '\\':
          case '/':
          case 'b':
          case 'f':
          case 'n':
          case 'r':
          case 't':
          case 'v':
          case '"':
              break;
          default:
              return false;
          }
      } else if ('"' == c) {
          *tokenEnd = start;
          return true;
      }
  }
  return false;
1373}

1375template<typename Char>
1376bool skipComment(const Char* start, const Char* end, const Char** commentEnd)
1377{
  if (start == end)
      return false;

  if (*start != '/' || start + 1 >= end)
      return false;
  ++start;

  if (*start == '/') {
      // Single line comment, read to newline.
      for (++start; start < end; ++start) {
          if (*start == '\n' || *start == '\r') {
              *commentEnd = start + 1;
              return true;
          }
      }
      *commentEnd = end;
      // Comment reaches end-of-input, which is fine.
      return true;
  }

  if (*start == '*') {
      Char previous = '\0';
      // Block comment, read until end marker.
      for (++start; start < end; previous = *start++) {
          if (previous == '*' && *start == '/') {
              *commentEnd = start + 1;
              return true;
          }
      }
      // Block comment must close before end-of-input.
      return false;
  }

  return false;
1412}

1414template<typename Char>
1415void skipWhitespaceAndComments(const Char* start, const Char* end, const Char** whitespaceEnd)
1416{
  while (start < end) {
      if (isSpaceOrNewLine(*start)) {
          ++start;
      } else if (*start == '/') {
          const Char* commentEnd;
          if (!skipComment(start, end, &commentEnd))
              break;
          start = commentEnd;
      } else {
          break;
      }
  }
  *whitespaceEnd = start;
1430}

1432template<typename Char>
1433Token parseToken(const Char* start, const Char* end, const Char** tokenStart, const Char** tokenEnd)
1434{
  skipWhitespaceAndComments(start, end, tokenStart);
  start = *tokenStart;

  if (start == end)
      return InvalidToken;

  switch (*start) {
  case 'n':
      if (parseConstToken(start, end, tokenEnd, nullString))
          return NullToken;
      break;
  case 't':
      if (parseConstToken(start, end, tokenEnd, trueString))
          return BoolTrue;
      break;
  case 'f':
      if (parseConstToken(start, end, tokenEnd, falseString))
          return BoolFalse;
      break;
  case '[':
      *tokenEnd = start + 1;
      return ArrayBegin;
  case ']':
      *tokenEnd = start + 1;
      return ArrayEnd;
  case ',':
      *tokenEnd = start + 1;
      return ListSeparator;
  case '{':
      *tokenEnd = start + 1;
      return ObjectBegin;
  case '}':
      *tokenEnd = start + 1;
      return ObjectEnd;
  case ':':
      *tokenEnd = start + 1;
      return ObjectPairSeparator;
  case '0':
  case '1':
  case '2':
  case '3':
  case '4':
  case '5':
  case '6':
  case '7':
  case '8':
  case '9':
  case '-':
      if (parseNumberToken(start, end, tokenEnd))
          return Number;
      break;
  case '"':
      if (parseStringToken(start + 1, end, tokenEnd))
          return StringLiteral;
      break;
  }
  return InvalidToken;
1492}

1494template<typename Char>
1495int hexToInt(Char c)
1496{
  if ('0' <= c && c <= '9')
      return c - '0';
  if ('A' <= c && c <= 'F')
      return c - 'A' + 10;
  if ('a' <= c && c <= 'f')
      return c - 'a' + 10;
  DCHECK(false);
  return 0;
1505}

1507template<typename Char>
1508bool decodeString(const Char* start, const Char* end, StringBuilder* output)
1509{
  while (start < end) {
      uint16_t c = *start++;
      if ('\\' != c) {
          StringUtil::builderAppend(*output, c);
          continue;
      }
if (start == end)
   return false;
      c = *start++;

      if (c == 'x') {
          // \x is not supported.
          return false;
      }

      switch (c) {
      case '"':
      case '/':
      case '\\':
          break;
      case 'b':
          c = '\b';
          break;
      case 'f':
          c = '\f';
          break;
      case 'n':
          c = '\n';
          break;
      case 'r':
          c = '\r';
          break;
      case 't':
          c = '\t';
          break;
      case 'v':
          c = '\v';
          break;
      case 'u':
          c = (hexToInt(*start) << 12) +
              (hexToInt(*(start + 1)) << 8) +
              (hexToInt(*(start + 2)) << 4) +
              hexToInt(*(start + 3));
          start += 4;
          break;
      default:
          return false;
      }
      StringUtil::builderAppend(*output, c);
  }
  return true;
1561}

1563template<typename Char>
1564bool decodeString(const Char* start, const Char* end, String* output)
1565{
  if (start == end) {
      *output = "";
      return true;
  }
  if (start > end)
      return false;
  StringBuilder buffer;
  StringUtil::builderReserve(buffer, end - start);
  if (!decodeString(start, end, &buffer))
      return false;
  *output = StringUtil::builderToString(buffer);
  return true;
1578}

1580template<typename Char>
1581std::unique_ptr<Value> buildValue(const Char* start, const Char* end, const Char** valueTokenEnd, int depth)
1582{
  if (depth > stackLimit)
      return nullptr;

  std::unique_ptr<Value> result;
  const Char* tokenStart;
  const Char* tokenEnd;
  Token token = parseToken(start, end, &tokenStart, &tokenEnd);
  switch (token) {
  case InvalidToken:
      return nullptr;
  case NullToken:
      result = Value::null();
      break;
  case BoolTrue:
      result = FundamentalValue::create(true);
      break;
  case BoolFalse:
      result = FundamentalValue::create(false);
      break;
  case Number: {
      bool ok;
      double value = charactersToDouble(tokenStart, tokenEnd - tokenStart, &ok);
      if (!ok)
          return nullptr;
      if (value >= INT_MIN(-2147483647 -1) && value <= INT_MAX2147483647 && static_cast<int>(value) == value)
          result = FundamentalValue::create(static_cast<int>(value));
      else
          result = FundamentalValue::create(value);
      break;
  }
  case StringLiteral: {
      String value;
      bool ok = decodeString(tokenStart + 1, tokenEnd - 1, &value);
      if (!ok)
          return nullptr;
      result = StringValue::create(value);
      break;
  }
  case ArrayBegin: {
      std::unique_ptr<ListValue> array = ListValue::create();
      start = tokenEnd;
      token = parseToken(start, end, &tokenStart, &tokenEnd);
      while (token != ArrayEnd) {
          std::unique_ptr<Value> arrayNode = buildValue(start, end, &tokenEnd, depth + 1);
          if (!arrayNode)
              return nullptr;
          array->pushValue(std::move(arrayNode));

          // After a list value, we expect a comma or the end of the list.
          start = tokenEnd;
          token = parseToken(start, end, &tokenStart, &tokenEnd);
          if (token == ListSeparator) {
              start = tokenEnd;
              token = parseToken(start, end, &tokenStart, &tokenEnd);
              if (token == ArrayEnd)
                  return nullptr;
          } else if (token != ArrayEnd) {
              // Unexpected value after list value. Bail out.
              return nullptr;
          }
      }
      if (token != ArrayEnd)
          return nullptr;
      result = std::move(array);
      break;
  }
  case ObjectBegin: {
      std::unique_ptr<DictionaryValue> object = DictionaryValue::create();
      start = tokenEnd;
      token = parseToken(start, end, &tokenStart, &tokenEnd);
      while (token != ObjectEnd) {
          if (token != StringLiteral)
              return nullptr;
          String key;
          if (!decodeString(tokenStart + 1, tokenEnd - 1, &key))
              return nullptr;
          start = tokenEnd;

          token = parseToken(start, end, &tokenStart, &tokenEnd);
          if (token != ObjectPairSeparator)
              return nullptr;
          start = tokenEnd;

          std::unique_ptr<Value> value = buildValue(start, end, &tokenEnd, depth + 1);
          if (!value)
              return nullptr;
          object->setValue(key, std::move(value));
          start = tokenEnd;

          // After a key/value pair, we expect a comma or the end of the
          // object.
          token = parseToken(start, end, &tokenStart, &tokenEnd);
          if (token == ListSeparator) {
              start = tokenEnd;
              token = parseToken(start, end, &tokenStart, &tokenEnd);
              if (token == ObjectEnd)
                  return nullptr;
          } else if (token != ObjectEnd) {
              // Unexpected value after last object value. Bail out.
              return nullptr;
          }
      }
      if (token != ObjectEnd)
          return nullptr;
      result = std::move(object);
      break;
  }

  default:
      // We got a token that's not a value.
      return nullptr;
  }

  skipWhitespaceAndComments(tokenEnd, end, valueTokenEnd);
  return result;
1698}

1700template<typename Char>
1701std::unique_ptr<Value> parseJSONInternal(const Char* start, unsigned length)
1702{
  const Char* end = start + length;
  const Char *tokenEnd;
  std::unique_ptr<Value> value = buildValue(start, end, &tokenEnd, 0);
  if (!value || tokenEnd != end)
      return nullptr;
  return value;
1709}

1711} // anonymous namespace

1713std::unique_ptr<Value> parseJSONCharacters(const uint16_t* characters, unsigned length)
1714{
  return parseJSONInternal<uint16_t>(characters, length);
1716}

1718std::unique_ptr<Value> parseJSONCharacters(const uint8_t* characters, unsigned length)
1719{
  return parseJSONInternal<uint8_t>(characters, length);
1721}

1723} // namespace node
1724} // namespace inspector
1725} // namespace protocol


1728// Generated by lib/encoding_cpp.template.

1730// Copyright 2019 The Chromium Authors. All rights reserved.
1731// Use of this source code is governed by a BSD-style license that can be
1732// found in the LICENSE file.


1735#include <algorithm>
1736#include <cassert>
1737#include <cmath>
1738#include <cstring>
1739#include <limits>
1740#include <stack>

1742namespace node {
1743namespace inspector {
1744namespace protocol {

1746// ===== encoding/encoding.cc =====

1748// =============================================================================
1749// Status and Error codes
1750// =============================================================================

1752std::string Status::ToASCIIString() const {
switch (error) {
  case Error::OK:
    return "OK";
  case Error::JSON_PARSER_UNPROCESSED_INPUT_REMAINS:
    return ToASCIIString("JSON: unprocessed input remains");
  case Error::JSON_PARSER_STACK_LIMIT_EXCEEDED:
    return ToASCIIString("JSON: stack limit exceeded");
  case Error::JSON_PARSER_NO_INPUT:
    return ToASCIIString("JSON: no input");
  case Error::JSON_PARSER_INVALID_TOKEN:
    return ToASCIIString("JSON: invalid token");
  case Error::JSON_PARSER_INVALID_NUMBER:
    return ToASCIIString("JSON: invalid number");
  case Error::JSON_PARSER_INVALID_STRING:
    return ToASCIIString("JSON: invalid string");
  case Error::JSON_PARSER_UNEXPECTED_ARRAY_END:
    return ToASCIIString("JSON: unexpected array end");
  case Error::JSON_PARSER_COMMA_OR_ARRAY_END_EXPECTED:
    return ToASCIIString("JSON: comma or array end expected");
  case Error::JSON_PARSER_STRING_LITERAL_EXPECTED:
    return ToASCIIString("JSON: string literal expected");
  case Error::JSON_PARSER_COLON_EXPECTED:
    return ToASCIIString("JSON: colon expected");
  case Error::JSON_PARSER_UNEXPECTED_MAP_END:
    return ToASCIIString("JSON: unexpected map end");
  case Error::JSON_PARSER_COMMA_OR_MAP_END_EXPECTED:
    return ToASCIIString("JSON: comma or map end expected");
  case Error::JSON_PARSER_VALUE_EXPECTED:
    return ToASCIIString("JSON: value expected");

  case Error::CBOR_INVALID_INT32:
    return ToASCIIString("CBOR: invalid int32");
  case Error::CBOR_INVALID_DOUBLE:
    return ToASCIIString("CBOR: invalid double");
  case Error::CBOR_INVALID_ENVELOPE:
    return ToASCIIString("CBOR: invalid envelope");
  case Error::CBOR_INVALID_STRING8:
    return ToASCIIString("CBOR: invalid string8");
  case Error::CBOR_INVALID_STRING16:
    return ToASCIIString("CBOR: invalid string16");
  case Error::CBOR_INVALID_BINARY:
    return ToASCIIString("CBOR: invalid binary");
  case Error::CBOR_UNSUPPORTED_VALUE:
    return ToASCIIString("CBOR: unsupported value");
  case Error::CBOR_NO_INPUT:
    return ToASCIIString("CBOR: no input");
  case Error::CBOR_INVALID_START_BYTE:
    return ToASCIIString("CBOR: invalid start byte");
  case Error::CBOR_UNEXPECTED_EOF_EXPECTED_VALUE:
    return ToASCIIString("CBOR: unexpected eof expected value");
  case Error::CBOR_UNEXPECTED_EOF_IN_ARRAY:
    return ToASCIIString("CBOR: unexpected eof in array");
  case Error::CBOR_UNEXPECTED_EOF_IN_MAP:
    return ToASCIIString("CBOR: unexpected eof in map");
  case Error::CBOR_INVALID_MAP_KEY:
    return ToASCIIString("CBOR: invalid map key");
  case Error::CBOR_STACK_LIMIT_EXCEEDED:
    return ToASCIIString("CBOR: stack limit exceeded");
  case Error::CBOR_TRAILING_JUNK:
    return ToASCIIString("CBOR: trailing junk");
  case Error::CBOR_MAP_START_EXPECTED:
    return ToASCIIString("CBOR: map start expected");
  case Error::CBOR_MAP_STOP_EXPECTED:
    return ToASCIIString("CBOR: map stop expected");
  case Error::CBOR_ENVELOPE_SIZE_LIMIT_EXCEEDED:
    return ToASCIIString("CBOR: envelope size limit exceeded");
}
// Some compilers can't figure out that we can't get here.
return "INVALID ERROR CODE";
1822}

1824std::string Status::ToASCIIString(const char* msg) const {
return std::string(msg) + " at position " + std::to_string(pos);
1826}

1828namespace cbor {
1829namespace {
1830// Indicates the number of bits the "initial byte" needs to be shifted to the
1831// right after applying |kMajorTypeMask| to produce the major type in the
1832// lowermost bits.
1833static constexpr uint8_t kMajorTypeBitShift = 5u;
1834// Mask selecting the low-order 5 bits of the "initial byte", which is where
1835// the additional information is encoded.
1836static constexpr uint8_t kAdditionalInformationMask = 0x1f;
1837// Mask selecting the high-order 3 bits of the "initial byte", which indicates
1838// the major type of the encoded value.
1839static constexpr uint8_t kMajorTypeMask = 0xe0;
1840// Indicates the integer is in the following byte.
1841static constexpr uint8_t kAdditionalInformation1Byte = 24u;
1842// Indicates the integer is in the next 2 bytes.
1843static constexpr uint8_t kAdditionalInformation2Bytes = 25u;
1844// Indicates the integer is in the next 4 bytes.
1845static constexpr uint8_t kAdditionalInformation4Bytes = 26u;
1846// Indicates the integer is in the next 8 bytes.
1847static constexpr uint8_t kAdditionalInformation8Bytes = 27u;

1849// Encodes the initial byte, consisting of the |type| in the first 3 bits
1850// followed by 5 bits of |additional_info|.
1851constexpr uint8_t EncodeInitialByte(MajorType type, uint8_t additional_info) {
return (static_cast<uint8_t>(type) << kMajorTypeBitShift) |
       (additional_info & kAdditionalInformationMask);
1854}

1856// TAG 24 indicates that what follows is a byte string which is
1857// encoded in CBOR format. We use this as a wrapper for
1858// maps and arrays, allowing us to skip them, because the
1859// byte string carries its size (byte length).
1860// https://tools.ietf.org/html/rfc7049#section-2.4.4.1
1861static constexpr uint8_t kInitialByteForEnvelope =
  EncodeInitialByte(MajorType::TAG, 24);
1863// The initial byte for a byte string with at most 2^32 bytes
1864// of payload. This is used for envelope encoding, even if
1865// the byte string is shorter.
1866static constexpr uint8_t kInitialByteFor32BitLengthByteString =
  EncodeInitialByte(MajorType::BYTE_STRING, 26);

1869// See RFC 7049 Section 2.2.1, indefinite length arrays / maps have additional
1870// info = 31.
1871static constexpr uint8_t kInitialByteIndefiniteLengthArray =
  EncodeInitialByte(MajorType::ARRAY, 31);
1873static constexpr uint8_t kInitialByteIndefiniteLengthMap =
  EncodeInitialByte(MajorType::MAP, 31);
1875// See RFC 7049 Section 2.3, Table 1; this is used for finishing indefinite
1876// length maps / arrays.
1877static constexpr uint8_t kStopByte =
  EncodeInitialByte(MajorType::SIMPLE_VALUE, 31);

1880// See RFC 7049 Section 2.3, Table 2.
1881static constexpr uint8_t kEncodedTrue =
  EncodeInitialByte(MajorType::SIMPLE_VALUE, 21);
1883static constexpr uint8_t kEncodedFalse =
  EncodeInitialByte(MajorType::SIMPLE_VALUE, 20);
1885static constexpr uint8_t kEncodedNull =
  EncodeInitialByte(MajorType::SIMPLE_VALUE, 22);
1887static constexpr uint8_t kInitialByteForDouble =
  EncodeInitialByte(MajorType::SIMPLE_VALUE, 27);

1890// See RFC 7049 Table 3 and Section 2.4.4.2. This is used as a prefix for
1891// arbitrary binary data encoded as BYTE_STRING.
1892static constexpr uint8_t kExpectedConversionToBase64Tag =
  EncodeInitialByte(MajorType::TAG, 22);

1895// Writes the bytes for |v| to |out|, starting with the most significant byte.
1896// See also: https://commandcenter.blogspot.com/2012/04/byte-order-fallacy.html
1897template <typename T, class C>
1898void WriteBytesMostSignificantByteFirst(T v, C* out) {
for (int shift_bytes = sizeof(T) - 1; shift_bytes >= 0; --shift_bytes)
  out->push_back(0xff & (v >> (shift_bytes * 8)));
1901}

1903// Extracts sizeof(T) bytes from |in| to extract a value of type T
1904// (e.g. uint64_t, uint32_t, ...), most significant byte first.
1905// See also: https://commandcenter.blogspot.com/2012/04/byte-order-fallacy.html
1906template <typename T>
1907T ReadBytesMostSignificantByteFirst(span<uint8_t> in) {
assert(in.size() >= sizeof(T))(static_cast<void> (0));
T result = 0;
for (size_t shift_bytes = 0; shift_bytes < sizeof(T); ++shift_bytes)
  result |= T(in[sizeof(T) - 1 - shift_bytes]) << (shift_bytes * 8);
return result;
1913}
1914}  // namespace

1916namespace internals {
1917// Reads the start of a token with definitive size from |bytes|.
1918// |type| is the major type as specified in RFC 7049 Section 2.1.
1919// |value| is the payload (e.g. for MajorType::UNSIGNED) or is the size
1920// (e.g. for BYTE_STRING).
1921// If successful, returns the number of bytes read. Otherwise returns 0.
1922size_t ReadTokenStart(span<uint8_t> bytes, MajorType* type, uint64_t* value) {
if (bytes.empty())
  return 0;
uint8_t initial_byte = bytes[0];
*type = MajorType((initial_byte & kMajorTypeMask) >> kMajorTypeBitShift);

uint8_t additional_information = initial_byte & kAdditionalInformationMask;
if (additional_information < 24) {
  // Values 0-23 are encoded directly into the additional info of the
  // initial byte.
  *value = additional_information;
  return 1;
}
if (additional_information == kAdditionalInformation1Byte) {
  // Values 24-255 are encoded with one initial byte, followed by the value.
  if (bytes.size() < 2)
    return 0;
  *value = ReadBytesMostSignificantByteFirst<uint8_t>(bytes.subspan(1));
  return 2;
}
if (additional_information == kAdditionalInformation2Bytes) {
  // Values 256-65535: 1 initial byte + 2 bytes payload.
  if (bytes.size() < 1 + sizeof(uint16_t))
    return 0;
  *value = ReadBytesMostSignificantByteFirst<uint16_t>(bytes.subspan(1));
  return 3;
}
if (additional_information == kAdditionalInformation4Bytes) {
  // 32 bit uint: 1 initial byte + 4 bytes payload.
  if (bytes.size() < 1 + sizeof(uint32_t))
    return 0;
  *value = ReadBytesMostSignificantByteFirst<uint32_t>(bytes.subspan(1));
  return 5;
}
if (additional_information == kAdditionalInformation8Bytes) {
  // 64 bit uint: 1 initial byte + 8 bytes payload.
  if (bytes.size() < 1 + sizeof(uint64_t))
    return 0;
  *value = ReadBytesMostSignificantByteFirst<uint64_t>(bytes.subspan(1));
  return 9;
}
return 0;
1964}

1966// Writes the start of a token with |type|. The |value| may indicate the size,
1967// or it may be the payload if the value is an unsigned integer.
1968template <typename C>
1969void WriteTokenStartTmpl(MajorType type, uint64_t value, C* encoded) {
if (value < 24) {
  // Values 0-23 are encoded directly into the additional info of the
  // initial byte.
  encoded->push_back(EncodeInitialByte(type, /*additional_info=*/value));
  return;
}
if (value <= std::numeric_limits<uint8_t>::max()) {
  // Values 24-255 are encoded with one initial byte, followed by the value.
  encoded->push_back(EncodeInitialByte(type, kAdditionalInformation1Byte));
  encoded->push_back(value);
  return;
}
if (value <= std::numeric_limits<uint16_t>::max()) {
  // Values 256-65535: 1 initial byte + 2 bytes payload.
  encoded->push_back(EncodeInitialByte(type, kAdditionalInformation2Bytes));
  WriteBytesMostSignificantByteFirst<uint16_t>(value, encoded);
  return;
}
if (value <= std::numeric_limits<uint32_t>::max()) {
  // 32 bit uint: 1 initial byte + 4 bytes payload.
  encoded->push_back(EncodeInitialByte(type, kAdditionalInformation4Bytes));
  WriteBytesMostSignificantByteFirst<uint32_t>(static_cast<uint32_t>(value),
                                               encoded);
  return;
}
// 64 bit uint: 1 initial byte + 8 bytes payload.
encoded->push_back(EncodeInitialByte(type, kAdditionalInformation8Bytes));
WriteBytesMostSignificantByteFirst<uint64_t>(value, encoded);
1998}
1999void WriteTokenStart(MajorType type,
                   uint64_t value,
                   std::vector<uint8_t>* encoded) {
WriteTokenStartTmpl(type, value, encoded);
2003}
2004void WriteTokenStart(MajorType type, uint64_t value, std::string* encoded) {
WriteTokenStartTmpl(type, value, encoded);
2006}
2007}  // namespace internals

2009// =============================================================================
2010// Detecting CBOR content
2011// =============================================================================

2013uint8_t InitialByteForEnvelope() {
return kInitialByteForEnvelope;
2015}
2016uint8_t InitialByteFor32BitLengthByteString() {
return kInitialByteFor32BitLengthByteString;
2018}
2019bool IsCBORMessage(span<uint8_t> msg) {
return msg.size() >= 6 && msg[0] == InitialByteForEnvelope() &&
       msg[1] == InitialByteFor32BitLengthByteString();
2022}

2024// =============================================================================
2025// Encoding invidiual CBOR items
2026// =============================================================================

2028uint8_t EncodeTrue() {
return kEncodedTrue;
2030}
2031uint8_t EncodeFalse() {
return kEncodedFalse;
2033}
2034uint8_t EncodeNull() {
return kEncodedNull;
2036}

2038uint8_t EncodeIndefiniteLengthArrayStart() {
return kInitialByteIndefiniteLengthArray;
2040}

2042uint8_t EncodeIndefiniteLengthMapStart() {
return kInitialByteIndefiniteLengthMap;
2044}

2046uint8_t EncodeStop() {
return kStopByte;
2048}

2050template <typename C>
2051void EncodeInt32Tmpl(int32_t value, C* out) {
if (value >= 0) {
  internals::WriteTokenStart(MajorType::UNSIGNED, value, out);
} else {
  uint64_t representation = static_cast<uint64_t>(-(value + 1));
  internals::WriteTokenStart(MajorType::NEGATIVE, representation, out);
}
2058}
2059void EncodeInt32(int32_t value, std::vector<uint8_t>* out) {
EncodeInt32Tmpl(value, out);
2061}
2062void EncodeInt32(int32_t value, std::string* out) {
EncodeInt32Tmpl(value, out);
2064}

2066template <typename C>
2067void EncodeString16Tmpl(span<uint16_t> in, C* out) {
uint64_t byte_length = static_cast<uint64_t>(in.size_bytes());
internals::WriteTokenStart(MajorType::BYTE_STRING, byte_length, out);
// When emitting UTF16 characters, we always write the least significant byte
// first; this is because it's the native representation for X86.
// TODO(johannes): Implement a more efficient thing here later, e.g.
// casting *iff* the machine has this byte order.
// The wire format for UTF16 chars will probably remain the same
// (least significant byte first) since this way we can have
// golden files, unittests, etc. that port easily and universally.
// See also:
// https://commandcenter.blogspot.com/2012/04/byte-order-fallacy.html
for (const uint16_t two_bytes : in) {
  out->push_back(two_bytes);
  out->push_back(two_bytes >> 8);
}
2083}
2084void EncodeString16(span<uint16_t> in, std::vector<uint8_t>* out) {
EncodeString16Tmpl(in, out);
2086}
2087void EncodeString16(span<uint16_t> in, std::string* out) {
EncodeString16Tmpl(in, out);
2089}

2091template <typename C>
2092void EncodeString8Tmpl(span<uint8_t> in, C* out) {
internals::WriteTokenStart(MajorType::STRING,
                           static_cast<uint64_t>(in.size_bytes()), out);
out->insert(out->end(), in.begin(), in.end());
2096}
2097void EncodeString8(span<uint8_t> in, std::vector<uint8_t>* out) {
EncodeString8Tmpl(in, out);
2099}
2100void EncodeString8(span<uint8_t> in, std::string* out) {
EncodeString8Tmpl(in, out);
2102}

2104template <typename C>
2105void EncodeFromLatin1Tmpl(span<uint8_t> latin1, C* out) {
for (size_t ii = 0; ii < latin1.size(); ++ii) {
  if (latin1[ii] <= 127)
    continue;
  // If there's at least one non-ASCII char, convert to UTF8.
  std::vector<uint8_t> utf8(latin1.begin(), latin1.begin() + ii);
  for (; ii < latin1.size(); ++ii) {
    if (latin1[ii] <= 127) {
      utf8.push_back(latin1[ii]);
    } else {
      // 0xC0 means it's a UTF8 sequence with 2 bytes.
      utf8.push_back((latin1[ii] >> 6) | 0xc0);
      utf8.push_back((latin1[ii] | 0x80) & 0xbf);
    }
  }
  EncodeString8(SpanFrom(utf8), out);
  return;
}
EncodeString8(latin1, out);
2124}
2125void EncodeFromLatin1(span<uint8_t> latin1, std::vector<uint8_t>* out) {
EncodeFromLatin1Tmpl(latin1, out);
2127}
2128void EncodeFromLatin1(span<uint8_t> latin1, std::string* out) {
EncodeFromLatin1Tmpl(latin1, out);
2130}

2132template <typename C>
2133void EncodeFromUTF16Tmpl(span<uint16_t> utf16, C* out) {
// If there's at least one non-ASCII char, encode as STRING16 (UTF16).
for (uint16_t ch : utf16) {
  if (ch <= 127)
    continue;
  EncodeString16(utf16, out);
  return;
}
// It's all US-ASCII, strip out every second byte and encode as UTF8.
internals::WriteTokenStart(MajorType::STRING,
                           static_cast<uint64_t>(utf16.size()), out);
out->insert(out->end(), utf16.begin(), utf16.end());
2145}
2146void EncodeFromUTF16(span<uint16_t> utf16, std::vector<uint8_t>* out) {
EncodeFromUTF16Tmpl(utf16, out);
2148}
2149void EncodeFromUTF16(span<uint16_t> utf16, std::string* out) {
EncodeFromUTF16Tmpl(utf16, out);
2151}

2153template <typename C>
2154void EncodeBinaryTmpl(span<uint8_t> in, C* out) {
out->push_back(kExpectedConversionToBase64Tag);
uint64_t byte_length = static_cast<uint64_t>(in.size_bytes());
internals::WriteTokenStart(MajorType::BYTE_STRING, byte_length, out);
out->insert(out->end(), in.begin(), in.end());
2159}
2160void EncodeBinary(span<uint8_t> in, std::vector<uint8_t>* out) {
EncodeBinaryTmpl(in, out);
2162}
2163void EncodeBinary(span<uint8_t> in, std::string* out) {
EncodeBinaryTmpl(in, out);
2165}

2167// A double is encoded with a specific initial byte
2168// (kInitialByteForDouble) plus the 64 bits of payload for its value.
2169constexpr size_t kEncodedDoubleSize = 1 + sizeof(uint64_t);

2171// An envelope is encoded with a specific initial byte
2172// (kInitialByteForEnvelope), plus the start byte for a BYTE_STRING with a 32
2173// bit wide length, plus a 32 bit length for that string.
2174constexpr size_t kEncodedEnvelopeHeaderSize = 1 + 1 + sizeof(uint32_t);

2176template <typename C>
2177void EncodeDoubleTmpl(double value, C* out) {
// The additional_info=27 indicates 64 bits for the double follow.
// See RFC 7049 Section 2.3, Table 1.
out->push_back(kInitialByteForDouble);
union {
  double from_double;
  uint64_t to_uint64;
} reinterpret;
reinterpret.from_double = value;
WriteBytesMostSignificantByteFirst<uint64_t>(reinterpret.to_uint64, out);
2187}
2188void EncodeDouble(double value, std::vector<uint8_t>* out) {
EncodeDoubleTmpl(value, out);
2190}
2191void EncodeDouble(double value, std::string* out) {
EncodeDoubleTmpl(value, out);
2193}

2195// =============================================================================
2196// cbor::EnvelopeEncoder - for wrapping submessages
2197// =============================================================================

2199template <typename C>
2200void EncodeStartTmpl(C* out, size_t* byte_size_pos) {
assert(*byte_size_pos == 0)(static_cast<void> (0));
out->push_back(kInitialByteForEnvelope);
out->push_back(kInitialByteFor32BitLengthByteString);
*byte_size_pos = out->size();
out->resize(out->size() + sizeof(uint32_t));
2206}

2208void EnvelopeEncoder::EncodeStart(std::vector<uint8_t>* out) {
EncodeStartTmpl<std::vector<uint8_t>>(out, &byte_size_pos_);
2210}

2212void EnvelopeEncoder::EncodeStart(std::string* out) {
EncodeStartTmpl<std::string>(out, &byte_size_pos_);
2214}

2216template <typename C>
2217bool EncodeStopTmpl(C* out, size_t* byte_size_pos) {
assert(*byte_size_pos != 0)(static_cast<void> (0));
// The byte size is the size of the payload, that is, all the
// bytes that were written past the byte size position itself.
uint64_t byte_size = out->size() - (*byte_size_pos + sizeof(uint32_t));
// We store exactly 4 bytes, so at most INT32MAX, with most significant
// byte first.
if (byte_size > std::numeric_limits<uint32_t>::max())
  return false;
for (int shift_bytes = sizeof(uint32_t) - 1; shift_bytes >= 0;
     --shift_bytes) {
  (*out)[(*byte_size_pos)++] = 0xff & (byte_size >> (shift_bytes * 8));
}
return true;
2231}

2233bool EnvelopeEncoder::EncodeStop(std::vector<uint8_t>* out) {
return EncodeStopTmpl(out, &byte_size_pos_);
2235}

2237bool EnvelopeEncoder::EncodeStop(std::string* out) {
return EncodeStopTmpl(out, &byte_size_pos_);
2239}

2241// =============================================================================
2242// cbor::NewCBOREncoder - for encoding from a streaming parser
2243// =============================================================================

2245namespace {
2246template <typename C>
2247class CBOREncoder : public StreamingParserHandler {
public:
CBOREncoder(C* out, Status* status) : out_(out), status_(status) {
  *status_ = Status();
}

void HandleMapBegin() override {
  if (!status_->ok())
    return;
  envelopes_.emplace_back();
  envelopes_.back().EncodeStart(out_);
  out_->push_back(kInitialByteIndefiniteLengthMap);
}

void HandleMapEnd() override {
  if (!status_->ok())
    return;
  out_->push_back(kStopByte);
  assert(!envelopes_.empty())(static_cast<void> (0));
  if (!envelopes_.back().EncodeStop(out_)) {
    HandleError(
        Status(Error::CBOR_ENVELOPE_SIZE_LIMIT_EXCEEDED, out_->size()));
    return;
  }
  envelopes_.pop_back();
}

void HandleArrayBegin() override {
  if (!status_->ok())
    return;
  envelopes_.emplace_back();
  envelopes_.back().EncodeStart(out_);
  out_->push_back(kInitialByteIndefiniteLengthArray);
}

void HandleArrayEnd() override {
  if (!status_->ok())
    return;
  out_->push_back(kStopByte);
  assert(!envelopes_.empty())(static_cast<void> (0));
  if (!envelopes_.back().EncodeStop(out_)) {
    HandleError(
        Status(Error::CBOR_ENVELOPE_SIZE_LIMIT_EXCEEDED, out_->size()));
    return;
  }
  envelopes_.pop_back();
}

void HandleString8(span<uint8_t> chars) override {
  if (!status_->ok())
    return;
  EncodeString8(chars, out_);
}

void HandleString16(span<uint16_t> chars) override {
  if (!status_->ok())
    return;
  EncodeFromUTF16(chars, out_);
}

void HandleBinary(span<uint8_t> bytes) override {
  if (!status_->ok())
    return;
  EncodeBinary(bytes, out_);
}

void HandleDouble(double value) override {
  if (!status_->ok())
    return;
  EncodeDouble(value, out_);
}

void HandleInt32(int32_t value) override {
  if (!status_->ok())
    return;
  EncodeInt32(value, out_);
}

void HandleBool(bool value) override {
  if (!status_->ok())
    return;
  // See RFC 7049 Section 2.3, Table 2.
  out_->push_back(value ? kEncodedTrue : kEncodedFalse);
}

void HandleNull() override {
  if (!status_->ok())
    return;
  // See RFC 7049 Section 2.3, Table 2.
  out_->push_back(kEncodedNull);
}

void HandleError(Status error) override {
  if (!status_->ok())
    return;
  *status_ = error;
  out_->clear();
}

private:
C* out_;
std::vector<EnvelopeEncoder> envelopes_;
Status* status_;
2350};
2351}  // namespace

2353std::unique_ptr<StreamingParserHandler> NewCBOREncoder(
  std::vector<uint8_t>* out,
  Status* status) {
return std::unique_ptr<StreamingParserHandler>(
    new CBOREncoder<std::vector<uint8_t>>(out, status));
2358}
2359std::unique_ptr<StreamingParserHandler> NewCBOREncoder(std::string* out,
                                                     Status* status) {
return std::unique_ptr<StreamingParserHandler>(
    new CBOREncoder<std::string>(out, status));
2363}

2365// =============================================================================
2366// cbor::CBORTokenizer - for parsing individual CBOR items
2367// =============================================================================

2369CBORTokenizer::CBORTokenizer(span<uint8_t> bytes) : bytes_(bytes) {
ReadNextToken(/*enter_envelope=*/false);
2371}
2372CBORTokenizer::~CBORTokenizer() {}

2374CBORTokenTag CBORTokenizer::TokenTag() const {
return token_tag_;
2376}

2378void CBORTokenizer::Next() {
if (token_tag_ == CBORTokenTag::ERROR_VALUE ||
    token_tag_ == CBORTokenTag::DONE)
  return;
ReadNextToken(/*enter_envelope=*/false);
2383}

2385void CBORTokenizer::EnterEnvelope() {
assert(token_tag_ == CBORTokenTag::ENVELOPE)(static_cast<void> (0));
ReadNextToken(/*enter_envelope=*/true);
2388}

2390Status CBORTokenizer::Status() const {
return status_;
2392}

2394// The following accessor functions ::GetInt32, ::GetDouble,
2395// ::GetString8, ::GetString16WireRep, ::GetBinary, ::GetEnvelopeContents
2396// assume that a particular token was recognized in ::ReadNextToken.
2397// That's where all the error checking is done. By design,
2398// the accessors (assuming the token was recognized) never produce
2399// an error.

2401int32_t CBORTokenizer::GetInt32() const {
assert(token_tag_ == CBORTokenTag::INT32)(static_cast<void> (0));
// The range checks happen in ::ReadNextToken().
return static_cast<int32_t>(
    token_start_type_ == MajorType::UNSIGNED
        ? token_start_internal_value_
        : -static_cast<int64_t>(token_start_internal_value_) - 1);
2408}

2410double CBORTokenizer::GetDouble() const {
assert(token_tag_ == CBORTokenTag::DOUBLE)(static_cast<void> (0));
union {
  uint64_t from_uint64;
  double to_double;
} reinterpret;
reinterpret.from_uint64 = ReadBytesMostSignificantByteFirst<uint64_t>(
    bytes_.subspan(status_.pos + 1));
return reinterpret.to_double;
2419}

2421span<uint8_t> CBORTokenizer::GetString8() const {
assert(token_tag_ == CBORTokenTag::STRING8)(static_cast<void> (0));
auto length = static_cast<size_t>(token_start_internal_value_);
return bytes_.subspan(status_.pos + (token_byte_length_ - length), length);
2425}

2427span<uint8_t> CBORTokenizer::GetString16WireRep() const {
assert(token_tag_ == CBORTokenTag::STRING16)(static_cast<void> (0));
auto length = static_cast<size_t>(token_start_internal_value_);
return bytes_.subspan(status_.pos + (token_byte_length_ - length), length);
2431}

2433span<uint8_t> CBORTokenizer::GetBinary() const {
assert(token_tag_ == CBORTokenTag::BINARY)(static_cast<void> (0));
auto length = static_cast<size_t>(token_start_internal_value_);
return bytes_.subspan(status_.pos + (token_byte_length_ - length), length);
2437}

2439span<uint8_t> CBORTokenizer::GetEnvelopeContents() const {
assert(token_tag_ == CBORTokenTag::ENVELOPE)(static_cast<void> (0));
auto length = static_cast<size_t>(token_start_internal_value_);
return bytes_.subspan(status_.pos + kEncodedEnvelopeHeaderSize, length);
2443}

2445// All error checking happens in ::ReadNextToken, so that the accessors
2446// can avoid having to carry an error return value.
2447//
2448// With respect to checking the encoded lengths of strings, arrays, etc:
2449// On the wire, CBOR uses 1,2,4, and 8 byte unsigned integers, so
2450// we initially read them as uint64_t, usually into token_start_internal_value_.
2451//
2452// However, since these containers have a representation on the machine,
2453// we need to do corresponding size computations on the input byte array,
2454// output span (e.g. the payload for a string), etc., and size_t is
2455// machine specific (in practice either 32 bit or 64 bit).
2456//
2457// Further, we must avoid overflowing size_t. Therefore, we use this
2458// kMaxValidLength constant to:
2459// - Reject values that are larger than the architecture specific
2460//   max size_t (differs between 32 bit and 64 bit arch).
2461// - Reserve at least one bit so that we can check against overflows
2462//   when adding lengths (array / string length / etc.); we do this by
2463//   ensuring that the inputs to an addition are <= kMaxValidLength,
2464//   and then checking whether the sum went past it.
2465//
2466// See also
2467// https://chromium.googlesource.com/chromium/src/+/HEAD/docs/security/integer-semantics.md
2468static const uint64_t kMaxValidLength =
  std::min<uint64_t>(std::numeric_limits<uint64_t>::max() >> 2,
                     std::numeric_limits<size_t>::max());

2472void CBORTokenizer::ReadNextToken(bool enter_envelope) {
if (enter_envelope) {
  status_.pos += kEncodedEnvelopeHeaderSize;
} else {
  status_.pos =
      status_.pos == Status::npos() ? 0 : status_.pos + token_byte_length_;
}
status_.error = Error::OK;
if (status_.pos >= bytes_.size()) {
  token_tag_ = CBORTokenTag::DONE;
  return;
}
const size_t remaining_bytes = bytes_.size() - status_.pos;
switch (bytes_[status_.pos]) {
  case kStopByte:
    SetToken(CBORTokenTag::STOP, 1);
    return;
  case kInitialByteIndefiniteLengthMap:
    SetToken(CBORTokenTag::MAP_START, 1);
    return;
  case kInitialByteIndefiniteLengthArray:
    SetToken(CBORTokenTag::ARRAY_START, 1);
    return;
  case kEncodedTrue:
    SetToken(CBORTokenTag::TRUE_VALUE, 1);
    return;
  case kEncodedFalse:
    SetToken(CBORTokenTag::FALSE_VALUE, 1);
    return;
  case kEncodedNull:
    SetToken(CBORTokenTag::NULL_VALUE, 1);
    return;
  case kExpectedConversionToBase64Tag: {  // BINARY
    const size_t bytes_read = internals::ReadTokenStart(
        bytes_.subspan(status_.pos + 1), &token_start_type_,
        &token_start_internal_value_);
    if (!bytes_read || token_start_type_ != MajorType::BYTE_STRING ||
        token_start_internal_value_ > kMaxValidLength) {
      SetError(Error::CBOR_INVALID_BINARY);
      return;
    }
    const uint64_t token_byte_length = token_start_internal_value_ +
                                       /* tag before token start: */ 1 +
                                       /* token start: */ bytes_read;
    if (token_byte_length > remaining_bytes) {
      SetError(Error::CBOR_INVALID_BINARY);
      return;
    }
    SetToken(CBORTokenTag::BINARY, static_cast<size_t>(token_byte_length));
    return;
  }
  case kInitialByteForDouble: {  // DOUBLE
    if (kEncodedDoubleSize > remaining_bytes) {
      SetError(Error::CBOR_INVALID_DOUBLE);
      return;
    }
    SetToken(CBORTokenTag::DOUBLE, kEncodedDoubleSize);
    return;
  }
  case kInitialByteForEnvelope: {  // ENVELOPE
    if (kEncodedEnvelopeHeaderSize > remaining_bytes) {
      SetError(Error::CBOR_INVALID_ENVELOPE);
      return;
    }
    // The envelope must be a byte string with 32 bit length.
    if (bytes_[status_.pos + 1] != kInitialByteFor32BitLengthByteString) {
      SetError(Error::CBOR_INVALID_ENVELOPE);
      return;
    }
    // Read the length of the byte string.
    token_start_internal_value_ = ReadBytesMostSignificantByteFirst<uint32_t>(
        bytes_.subspan(status_.pos + 2));
    if (token_start_internal_value_ > kMaxValidLength) {
      SetError(Error::CBOR_INVALID_ENVELOPE);
      return;
    }
    uint64_t token_byte_length =
        token_start_internal_value_ + kEncodedEnvelopeHeaderSize;
    if (token_byte_length > remaining_bytes) {
      SetError(Error::CBOR_INVALID_ENVELOPE);
      return;
    }
    SetToken(CBORTokenTag::ENVELOPE, static_cast<size_t>(token_byte_length));
    return;
  }
  default: {
    const size_t bytes_read = internals::ReadTokenStart(
        bytes_.subspan(status_.pos), &token_start_type_,
        &token_start_internal_value_);
    switch (token_start_type_) {
      case MajorType::UNSIGNED:  // INT32.
        // INT32 is a signed int32 (int32 makes sense for the
        // inspector_protocol, it's not a CBOR limitation), so we check
        // against the signed max, so that the allowable values are
        // 0, 1, 2, ... 2^31 - 1.
        if (!bytes_read ||
              static_cast<int64_t>(std::numeric_limits<int32_t>::max()) <
                static_cast<int64_t>(token_start_internal_value_)) {
          SetError(Error::CBOR_INVALID_INT32);
          return;
        }
        SetToken(CBORTokenTag::INT32, bytes_read);
        return;
      case MajorType::NEGATIVE: {  // INT32.
        // INT32 is a signed int32 (int32 makes sense for the
        // inspector_protocol, it's not a CBOR limitation); in CBOR, the
        // negative values for INT32 are represented as NEGATIVE, that is, -1
        // INT32 is represented as 1 << 5 | 0 (major type 1, additional info
        // value 0).
        // The represented allowed values range is -1 to -2^31.
        // They are mapped into the encoded range of 0 to 2^31-1.
        // We check the the payload in token_start_internal_value_ against
        // that range (2^31-1 is also known as
        // std::numeric_limits<int32_t>::max()).
        if (!bytes_read ||
       static_cast<int64_t>(token_start_internal_value_) >
                static_cast<int64_t>(std::numeric_limits<int32_t>::max())) {
          SetError(Error::CBOR_INVALID_INT32);
          return;
        }
        SetToken(CBORTokenTag::INT32, bytes_read);
        return;
      }
      case MajorType::STRING: {  // STRING8.
        if (!bytes_read || token_start_internal_value_ > kMaxValidLength) {
          SetError(Error::CBOR_INVALID_STRING8);
          return;
        }
        uint64_t token_byte_length = token_start_internal_value_ + bytes_read;
        if (token_byte_length > remaining_bytes) {
          SetError(Error::CBOR_INVALID_STRING8);
          return;
        }
        SetToken(CBORTokenTag::STRING8,
                 static_cast<size_t>(token_byte_length));
        return;
      }
      case MajorType::BYTE_STRING: {  // STRING16.
        // Length must be divisible by 2 since UTF16 is 2 bytes per
        // character, hence the &1 check.
        if (!bytes_read || token_start_internal_value_ > kMaxValidLength ||
            token_start_internal_value_ & 1) {
          SetError(Error::CBOR_INVALID_STRING16);
          return;
        }
        uint64_t token_byte_length = token_start_internal_value_ + bytes_read;
        if (token_byte_length > remaining_bytes) {
          SetError(Error::CBOR_INVALID_STRING16);
          return;
        }
        SetToken(CBORTokenTag::STRING16,
                 static_cast<size_t>(token_byte_length));
        return;
      }
      case MajorType::ARRAY:
      case MajorType::MAP:
      case MajorType::TAG:
      case MajorType::SIMPLE_VALUE:
        SetError(Error::CBOR_UNSUPPORTED_VALUE);
        return;
    }
  }
}
2635}

2637void CBORTokenizer::SetToken(CBORTokenTag token_tag, size_t token_byte_length) {
token_tag_ = token_tag;
token_byte_length_ = token_byte_length;
2640}

2642void CBORTokenizer::SetError(Error error) {
token_tag_ = CBORTokenTag::ERROR_VALUE;
status_.error = error;
2645}

2647// =============================================================================
2648// cbor::ParseCBOR - for receiving streaming parser events for CBOR messages
2649// =============================================================================

2651namespace {
2652// When parsing CBOR, we limit recursion depth for objects and arrays
2653// to this constant.
2654static constexpr int kStackLimit = 300;

2656// Below are three parsing routines for CBOR, which cover enough
2657// to roundtrip JSON messages.
2658bool ParseMap(int32_t stack_depth,
            CBORTokenizer* tokenizer,
            StreamingParserHandler* out);
2661bool ParseArray(int32_t stack_depth,
              CBORTokenizer* tokenizer,
              StreamingParserHandler* out);
2664bool ParseValue(int32_t stack_depth,
              CBORTokenizer* tokenizer,
              StreamingParserHandler* out);

2668void ParseUTF16String(CBORTokenizer* tokenizer, StreamingParserHandler* out) {
std::vector<uint16_t> value;
span<uint8_t> rep = tokenizer->GetString16WireRep();
for (size_t ii = 0; ii < rep.size(); ii += 2)
  value.push_back((rep[ii + 1] << 8) | rep[ii]);
out->HandleString16(span<uint16_t>(value.data(), value.size()));
tokenizer->Next();
2675}

2677bool ParseUTF8String(CBORTokenizer* tokenizer, StreamingParserHandler* out) {
assert(tokenizer->TokenTag() == CBORTokenTag::STRING8)(static_cast<void> (0));
out->HandleString8(tokenizer->GetString8());
tokenizer->Next();
return true;
2682}

2684bool ParseValue(int32_t stack_depth,
              CBORTokenizer* tokenizer,
              StreamingParserHandler* out) {
if (stack_depth > kStackLimit) {
  out->HandleError(
      Status{Error::CBOR_STACK_LIMIT_EXCEEDED, tokenizer->Status().pos});
  return false;
}
// Skip past the envelope to get to what's inside.
if (tokenizer->TokenTag() == CBORTokenTag::ENVELOPE)
  tokenizer->EnterEnvelope();
switch (tokenizer->TokenTag()) {
  case CBORTokenTag::ERROR_VALUE:
    out->HandleError(tokenizer->Status());
    return false;
  case CBORTokenTag::DONE:
    out->HandleError(Status{Error::CBOR_UNEXPECTED_EOF_EXPECTED_VALUE,
                            tokenizer->Status().pos});
    return false;
  case CBORTokenTag::TRUE_VALUE:
    out->HandleBool(true);
    tokenizer->Next();
    return true;
  case CBORTokenTag::FALSE_VALUE:
    out->HandleBool(false);
    tokenizer->Next();
    return true;
  case CBORTokenTag::NULL_VALUE:
    out->HandleNull();
    tokenizer->Next();
    return true;
  case CBORTokenTag::INT32:
    out->HandleInt32(tokenizer->GetInt32());
    tokenizer->Next();
    return true;
  case CBORTokenTag::DOUBLE:
    out->HandleDouble(tokenizer->GetDouble());
    tokenizer->Next();
    return true;
  case CBORTokenTag::STRING8:
    return ParseUTF8String(tokenizer, out);
  case CBORTokenTag::STRING16:
    ParseUTF16String(tokenizer, out);
    return true;
  case CBORTokenTag::BINARY: {
    out->HandleBinary(tokenizer->GetBinary());
    tokenizer->Next();
    return true;
  }
  case CBORTokenTag::MAP_START:
    return ParseMap(stack_depth + 1, tokenizer, out);
  case CBORTokenTag::ARRAY_START:
    return ParseArray(stack_depth + 1, tokenizer, out);
  default:
    out->HandleError(
        Status{Error::CBOR_UNSUPPORTED_VALUE, tokenizer->Status().pos});
    return false;
}
2742}

2744// |bytes| must start with the indefinite length array byte, so basically,
2745// ParseArray may only be called after an indefinite length array has been
2746// detected.
2747bool ParseArray(int32_t stack_depth,
              CBORTokenizer* tokenizer,
              StreamingParserHandler* out) {
assert(tokenizer->TokenTag() == CBORTokenTag::ARRAY_START)(static_cast<void> (0));
tokenizer->Next();
out->HandleArrayBegin();
while (tokenizer->TokenTag() != CBORTokenTag::STOP) {
  if (tokenizer->TokenTag() == CBORTokenTag::DONE) {
    out->HandleError(
        Status{Error::CBOR_UNEXPECTED_EOF_IN_ARRAY, tokenizer->Status().pos});
    return false;
  }
  if (tokenizer->TokenTag() == CBORTokenTag::ERROR_VALUE) {
    out->HandleError(tokenizer->Status());
    return false;
  }
  // Parse value.
  if (!ParseValue(stack_depth, tokenizer, out))
    return false;
}
out->HandleArrayEnd();
tokenizer->Next();
return true;
2770}

2772// |bytes| must start with the indefinite length array byte, so basically,
2773// ParseArray may only be called after an indefinite length array has been
2774// detected.
2775bool ParseMap(int32_t stack_depth,
            CBORTokenizer* tokenizer,
            StreamingParserHandler* out) {
assert(tokenizer->TokenTag() == CBORTokenTag::MAP_START)(static_cast<void> (0));
out->HandleMapBegin();
tokenizer->Next();
while (tokenizer->TokenTag() != CBORTokenTag::STOP) {
  if (tokenizer->TokenTag() == CBORTokenTag::DONE) {
    out->HandleError(
        Status{Error::CBOR_UNEXPECTED_EOF_IN_MAP, tokenizer->Status().pos});
    return false;
  }
  if (tokenizer->TokenTag() == CBORTokenTag::ERROR_VALUE) {
    out->HandleError(tokenizer->Status());
    return false;
  }
  // Parse key.
  if (tokenizer->TokenTag() == CBORTokenTag::STRING8) {
    if (!ParseUTF8String(tokenizer, out))
      return false;
  } else if (tokenizer->TokenTag() == CBORTokenTag::STRING16) {
    ParseUTF16String(tokenizer, out);
  } else {
    out->HandleError(
        Status{Error::CBOR_INVALID_MAP_KEY, tokenizer->Status().pos});
    return false;
  }
  // Parse value.
  if (!ParseValue(stack_depth, tokenizer, out))
    return false;
}
out->HandleMapEnd();
tokenizer->Next();
return true;
2809}
2810}  // namespace

2812void ParseCBOR(span<uint8_t> bytes, StreamingParserHandler* out) {
if (bytes.empty()) {
  out->HandleError(Status{Error::CBOR_NO_INPUT, 0});
  return;
}
if (bytes[0] != kInitialByteForEnvelope) {
  out->HandleError(Status{Error::CBOR_INVALID_START_BYTE, 0});
  return;
}
CBORTokenizer tokenizer(bytes);
if (tokenizer.TokenTag() == CBORTokenTag::ERROR_VALUE) {
  out->HandleError(tokenizer.Status());
  return;
}
// We checked for the envelope start byte above, so the tokenizer
// must agree here, since it's not an error.
assert(tokenizer.TokenTag() == CBORTokenTag::ENVELOPE)(static_cast<void> (0));
tokenizer.EnterEnvelope();
if (tokenizer.TokenTag() != CBORTokenTag::MAP_START) {
  out->HandleError(
      Status{Error::CBOR_MAP_START_EXPECTED, tokenizer.Status().pos});
  return;
}
if (!ParseMap(/*stack_depth=*/1, &tokenizer, out))
  return;
if (tokenizer.TokenTag() == CBORTokenTag::DONE)
  return;
if (tokenizer.TokenTag() == CBORTokenTag::ERROR_VALUE) {
  out->HandleError(tokenizer.Status());
  return;
}
out->HandleError(Status{Error::CBOR_TRAILING_JUNK, tokenizer.Status().pos});
2844}

2846// =============================================================================
2847// cbor::AppendString8EntryToMap - for limited in-place editing of messages
2848// =============================================================================

2850template <typename C>
2851Status AppendString8EntryToCBORMapTmpl(span<uint8_t> string8_key,
                                     span<uint8_t> string8_value,
                                     C* cbor) {
// Careful below: Don't compare (*cbor)[idx] with a uint8_t, since
// it could be a char (signed!). Instead, use bytes.
span<uint8_t> bytes(reinterpret_cast<const uint8_t*>(cbor->data()),
                    cbor->size());
CBORTokenizer tokenizer(bytes);
if (tokenizer.TokenTag() == CBORTokenTag::ERROR_VALUE)
  return tokenizer.Status();
if (tokenizer.TokenTag() != CBORTokenTag::ENVELOPE)
  return Status(Error::CBOR_INVALID_ENVELOPE, 0);
size_t envelope_size = tokenizer.GetEnvelopeContents().size();
size_t old_size = cbor->size();
if (old_size != envelope_size + kEncodedEnvelopeHeaderSize)
  return Status(Error::CBOR_INVALID_ENVELOPE, 0);
if (envelope_size == 0 ||
    (tokenizer.GetEnvelopeContents()[0] != EncodeIndefiniteLengthMapStart()))
  return Status(Error::CBOR_MAP_START_EXPECTED, kEncodedEnvelopeHeaderSize);
if (bytes[bytes.size() - 1] != EncodeStop())
  return Status(Error::CBOR_MAP_STOP_EXPECTED, cbor->size() - 1);
cbor->pop_back();
EncodeString8(string8_key, cbor);
EncodeString8(string8_value, cbor);
cbor->push_back(EncodeStop());
size_t new_envelope_size = envelope_size + (cbor->size() - old_size);
if (new_envelope_size > std::numeric_limits<uint32_t>::max())
  return Status(Error::CBOR_ENVELOPE_SIZE_LIMIT_EXCEEDED, 0);
size_t size_pos = cbor->size() - new_envelope_size - sizeof(uint32_t);
uint8_t* out = reinterpret_cast<uint8_t*>(&cbor->at(size_pos));
*(out++) = (new_envelope_size >> 24) & 0xff;
*(out++) = (new_envelope_size >> 16) & 0xff;
*(out++) = (new_envelope_size >> 8) & 0xff;
*(out) = new_envelope_size & 0xff;
return Status();
2886}
2887Status AppendString8EntryToCBORMap(span<uint8_t> string8_key,
                                 span<uint8_t> string8_value,
                                 std::vector<uint8_t>* cbor) {
return AppendString8EntryToCBORMapTmpl(string8_key, string8_value, cbor);
2891}
2892Status AppendString8EntryToCBORMap(span<uint8_t> string8_key,
                                 span<uint8_t> string8_value,
                                 std::string* cbor) {
return AppendString8EntryToCBORMapTmpl(string8_key, string8_value, cbor);
2896}
2897}  // namespace cbor

2899namespace json {

2901// =============================================================================
2902// json::NewJSONEncoder - for encoding streaming parser events as JSON
2903// =============================================================================

2905namespace {
2906// Prints |value| to |out| with 4 hex digits, most significant chunk first.
2907template <typename C>
2908void PrintHex(uint16_t value, C* out) {
for (int ii = 3; ii >= 0; --ii) {
  int four_bits = 0xf & (value >> (4 * ii));
  out->push_back(four_bits + ((four_bits <= 9) ? '0' : ('a' - 10)));
}
2913}

2915// In the writer below, we maintain a stack of State instances.
2916// It is just enough to emit the appropriate delimiters and brackets
2917// in JSON.
2918enum class Container {
// Used for the top-level, initial state.
NONE,
// Inside a JSON object.
MAP,
// Inside a JSON array.
ARRAY
2925};
2926class State {
public:
explicit State(Container container) : container_(container) {}
void StartElement(std::vector<uint8_t>* out) { StartElementTmpl(out); }
void StartElement(std::string* out) { StartElementTmpl(out); }
Container container() const { return container_; }

private:
template <typename C>
void StartElementTmpl(C* out) {
  assert(container_ != Container::NONE || size_ == 0)(static_cast<void> (0));
  if (size_ != 0) {
    char delim = (!(size_ & 1) || container_ == Container::ARRAY) ? ',' : ':';
    out->push_back(delim);
  }
  ++size_;
}

Container container_ = Container::NONE;
int size_ = 0;
2946};

2948constexpr char kBase64Table[] =
  "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  "abcdefghijklmnopqrstuvwxyz0123456789+/";

2952template <typename C>
2953void Base64Encode(const span<uint8_t>& in, C* out) {
// The following three cases are based on the tables in the example
// section in https://en.wikipedia.org/wiki/Base64. We process three
// input bytes at a time, emitting 4 output bytes at a time.
size_t ii = 0;

// While possible, process three input bytes.
for (; ii + 3 <= in.size(); ii += 3) {
  uint32_t twentyfour_bits = (in[ii] << 16) | (in[ii + 1] << 8) | in[ii + 2];
  out->push_back(kBase64Table[(twentyfour_bits >> 18)]);
  out->push_back(kBase64Table[(twentyfour_bits >> 12) & 0x3f]);
  out->push_back(kBase64Table[(twentyfour_bits >> 6) & 0x3f]);
  out->push_back(kBase64Table[twentyfour_bits & 0x3f]);
}
if (ii + 2 <= in.size()) {  // Process two input bytes.
  uint32_t twentyfour_bits = (in[ii] << 16) | (in[ii + 1] << 8);
  out->push_back(kBase64Table[(twentyfour_bits >> 18)]);
  out->push_back(kBase64Table[(twentyfour_bits >> 12) & 0x3f]);
  out->push_back(kBase64Table[(twentyfour_bits >> 6) & 0x3f]);
  out->push_back('=');  // Emit padding.
  return;
}
if (ii + 1 <= in.size()) {  // Process a single input byte.
  uint32_t twentyfour_bits = (in[ii] << 16);
  out->push_back(kBase64Table[(twentyfour_bits >> 18)]);
  out->push_back(kBase64Table[(twentyfour_bits >> 12) & 0x3f]);
  out->push_back('=');  // Emit padding.
  out->push_back('=');  // Emit padding.
}
2982}

2984// Implements a handler for JSON parser events to emit a JSON string.
2985template <typename C>
2986class JSONEncoder : public StreamingParserHandler {
public:
JSONEncoder(const Platform* platform, C* out, Status* status)
    : platform_(platform), out_(out), status_(status) {
  *status_ = Status();
  state_.emplace(Container::NONE);
}

void HandleMapBegin() override {
  if (!status_->ok())
    return;
  assert(!state_.empty())(static_cast<void> (0));
  state_.top().StartElement(out_);
  state_.emplace(Container::MAP);
  Emit('{');
}

void HandleMapEnd() override {
  if (!status_->ok())
    return;
  assert(state_.size() >= 2 && state_.top().container() == Container::MAP)(static_cast<void> (0));
  state_.pop();
  Emit('}');
}

void HandleArrayBegin() override {
  if (!status_->ok())
    return;
  state_.top().StartElement(out_);
  state_.emplace(Container::ARRAY);
  Emit('[');
}

void HandleArrayEnd() override {
  if (!status_->ok())
    return;
  assert(state_.size() >= 2 && state_.top().container() == Container::ARRAY)(static_cast<void> (0));
  state_.pop();
  Emit(']');
}

void HandleString16(span<uint16_t> chars) override {
  if (!status_->ok())
    return;
  state_.top().StartElement(out_);
  Emit('"');
  for (const uint16_t ch : chars) {
    if (ch == '"') {
      Emit("\\\"");
    } else if (ch == '\\') {
      Emit("\\\\");
    } else if (ch == '\b') {
      Emit("\\b");
    } else if (ch == '\f') {
      Emit("\\f");
    } else if (ch == '\n') {
      Emit("\\n");
    } else if (ch == '\r') {
      Emit("\\r");
    } else if (ch == '\t') {
      Emit("\\t");
    } else if (ch >= 32 && ch <= 126) {
      Emit(ch);
    } else {
      Emit("\\u");
      PrintHex(ch, out_);
    }
  }
  Emit('"');
}

void HandleString8(span<uint8_t> chars) override {
  if (!status_->ok())
    return;
  state_.top().StartElement(out_);
  Emit('"');
  for (size_t ii = 0; ii < chars.size(); ++ii) {
    uint8_t c = chars[ii];
    if (c == '"') {
      Emit("\\\"");
    } else if (c == '\\') {
      Emit("\\\\");
    } else if (c == '\b') {
      Emit("\\b");
    } else if (c == '\f') {
      Emit("\\f");
    } else if (c == '\n') {
      Emit("\\n");
    } else if (c == '\r') {
      Emit("\\r");
    } else if (c == '\t') {
      Emit("\\t");
    } else if (c >= 32 && c <= 126) {
      Emit(c);
    } else if (c < 32) {
      Emit("\\u");
      PrintHex(static_cast<uint16_t>(c), out_);
    } else {
      // Inspect the leading byte to figure out how long the utf8
      // byte sequence is; while doing this initialize |codepoint|
      // with the first few bits.
      // See table in: https://en.wikipedia.org/wiki/UTF-8
      // byte one is 110x xxxx -> 2 byte utf8 sequence
      // byte one is 1110 xxxx -> 3 byte utf8 sequence
      // byte one is 1111 0xxx -> 4 byte utf8 sequence
      uint32_t codepoint;
      int num_bytes_left;
      if ((c & 0xe0) == 0xc0) {  // 2 byte utf8 sequence
        num_bytes_left = 1;
        codepoint = c & 0x1f;
      } else if ((c & 0xf0) == 0xe0) {  // 3 byte utf8 sequence
        num_bytes_left = 2;
        codepoint = c & 0x0f;
      } else if ((c & 0xf8) == 0xf0) {  // 4 byte utf8 sequence
        codepoint = c & 0x07;
        num_bytes_left = 3;
      } else {
        continue;  // invalid leading byte
      }

      // If we have enough bytes in our input, decode the remaining ones
      // belonging to this Unicode character into |codepoint|.
      if (ii + num_bytes_left > chars.size())
        continue;
      while (num_bytes_left > 0) {
        c = chars[++ii];
        --num_bytes_left;
        // Check the next byte is a continuation byte, that is 10xx xxxx.
        if ((c & 0xc0) != 0x80)
          continue;
        codepoint = (codepoint << 6) | (c & 0x3f);
      }

      // Disallow overlong encodings for ascii characters, as these
      // would include " and other characters significant to JSON
      // string termination / control.
      if (codepoint < 0x7f)
        continue;
      // Invalid in UTF8, and can't be represented in UTF16 anyway.
      if (codepoint > 0x10ffff)
        continue;

      // So, now we transcode to UTF16,
      // using the math described at https://en.wikipedia.org/wiki/UTF-16,
      // for either one or two 16 bit characters.
      if (codepoint < 0xffff) {
        Emit("\\u");
        PrintHex(static_cast<uint16_t>(codepoint), out_);
        continue;
      }
      codepoint -= 0x10000;
      // high surrogate
      Emit("\\u");
      PrintHex(static_cast<uint16_t>((codepoint >> 10) + 0xd800), out_);
      // low surrogate
      Emit("\\u");
      PrintHex(static_cast<uint16_t>((codepoint & 0x3ff) + 0xdc00), out_);
    }
  }
  Emit('"');
}

void HandleBinary(span<uint8_t> bytes) override {
  if (!status_->ok())
    return;
  state_.top().StartElement(out_);
  Emit('"');
  Base64Encode(bytes, out_);
  Emit('"');
}

void HandleDouble(double value) override {
  if (!status_->ok())
    return;
  state_.top().StartElement(out_);
  // JSON cannot represent NaN or Infinity. So, for compatibility,
  // we behave like the JSON object in web browsers: emit 'null'.
  if (!std::isfinite(value)) {
    Emit("null");
    return;
  }
  std::unique_ptr<char[]> str_value = platform_->DToStr(value);

  // DToStr may fail to emit a 0 before the decimal dot. E.g. this is
  // the case in base::NumberToString in Chromium (which is based on
  // dmg_fp). So, much like
  // https://cs.chromium.org/chromium/src/base/json/json_writer.cc
  // we probe for this and emit the leading 0 anyway if necessary.
  const char* chars = str_value.get();
  if (chars[0] == '.') {
    Emit('0');
  } else if (chars[0] == '-' && chars[1] == '.') {
    Emit("-0");
    ++chars;
  }
  Emit(chars);
}

void HandleInt32(int32_t value) override {
  if (!status_->ok())
    return;
  state_.top().StartElement(out_);
  Emit(std::to_string(value));
}

void HandleBool(bool value) override {
  if (!status_->ok())
    return;
  state_.top().StartElement(out_);
  Emit(value ? "true" : "false");
}

void HandleNull() override {
  if (!status_->ok())
    return;
  state_.top().StartElement(out_);
  Emit("null");
}

void HandleError(Status error) override {
  assert(!error.ok())(static_cast<void> (0));
  *status_ = error;
  out_->clear();
}

private:
void Emit(char c) { out_->push_back(c); }
void Emit(const char* str) {
  out_->insert(out_->end(), str, str + strlen(str));
}
void Emit(const std::string& str) {
  out_->insert(out_->end(), str.begin(), str.end());
}

const Platform* platform_;
C* out_;
Status* status_;
std::stack<State> state_;
3224};
3225}  // namespace

3227std::unique_ptr<StreamingParserHandler> NewJSONEncoder(
  const Platform* platform,
  std::vector<uint8_t>* out,
  Status* status) {
return std::unique_ptr<StreamingParserHandler>(
    new JSONEncoder<std::vector<uint8_t>>(platform, out, status));
3233}
3234std::unique_ptr<StreamingParserHandler> NewJSONEncoder(const Platform* platform,
                                                     std::string* out,
                                                     Status* status) {
return std::unique_ptr<StreamingParserHandler>(
    new JSONEncoder<std::string>(platform, out, status));
3239}

3241// =============================================================================
3242// json::ParseJSON - for receiving streaming parser events for JSON.
3243// =============================================================================

3245namespace {
3246const int kStackLimit = 300;

3248enum Token {
ObjectBegin,
ObjectEnd,
ArrayBegin,
ArrayEnd,
StringLiteral,
Number,
BoolTrue,
BoolFalse,
NullToken,
ListSeparator,
ObjectPairSeparator,
InvalidToken,
NoInput
3262};

3264const char* const kNullString = "null";
3265const char* const kTrueString = "true";
3266const char* const kFalseString = "false";

3268template <typename Char>
3269class JsonParser {
public:
JsonParser(const Platform* platform, StreamingParserHandler* handler)
    : platform_(platform), handler_(handler) {}

void Parse(const Char* start, size_t length) {
  start_pos_ = start;
  const Char* end = start + length;
  const Char* tokenEnd = nullptr;
  ParseValue(start, end, &tokenEnd, 0);
  if (error_)
    return;
  if (tokenEnd != end) {
    HandleError(Error::JSON_PARSER_UNPROCESSED_INPUT_REMAINS, tokenEnd);
  }
}

private:
bool CharsToDouble(const uint16_t* chars, size_t length, double* result) {
  std::string buffer;
  buffer.reserve(length + 1);
  for (size_t ii = 0; ii < length; ++ii) {
    bool is_ascii = !(chars[ii] & ~0x7F);
    if (!is_ascii)
      return false;
    buffer.push_back(static_cast<char>(chars[ii]));
  }
  return platform_->StrToD(buffer.c_str(), result);
}

bool CharsToDouble(const uint8_t* chars, size_t length, double* result) {
  std::string buffer(reinterpret_cast<const char*>(chars), length);
  return platform_->StrToD(buffer.c_str(), result);
}

static bool ParseConstToken(const Char* start,
                            const Char* end,
                            const Char** token_end,
                            const char* token) {
  // |token| is \0 terminated, it's one of the constants at top of the file.
  while (start < end && *token != '\0' && *start++ == *token++) {
  }
  if (*token != '\0')
    return false;
  *token_end = start;
  return true;
}

static bool ReadInt(const Char* start,
                    const Char* end,
                    const Char** token_end,
                    bool allow_leading_zeros) {
  if (start == end)
    return false;
  bool has_leading_zero = '0' == *start;
  int length = 0;
  while (start < end && '0' <= *start && *start <= '9') {
    ++start;
    ++length;
  }
  if (!length)
    return false;
  if (!allow_leading_zeros && length > 1 && has_leading_zero)
    return false;
  *token_end = start;
  return true;
}

static bool ParseNumberToken(const Char* start,
                             const Char* end,
                             const Char** token_end) {
  // We just grab the number here. We validate the size in DecodeNumber.
  // According to RFC4627, a valid number is: [minus] int [frac] [exp]
  if (start == end)
    return false;
  Char c = *start;
  if ('-' == c)
    ++start;

  if (!ReadInt(start, end, &start, /*allow_leading_zeros=*/false))
    return false;
  if (start == end) {
    *token_end = start;
    return true;
  }

  // Optional fraction part
  c = *start;
  if ('.' == c) {
    ++start;
    if (!ReadInt(start, end, &start, /*allow_leading_zeros=*/true))
      return false;
    if (start == end) {
      *token_end = start;
      return true;
    }
    c = *start;
  }

  // Optional exponent part
  if ('e' == c || 'E' == c) {
    ++start;
    if (start == end)
      return false;
    c = *start;
    if ('-' == c || '+' == c) {
      ++start;
      if (start == end)
        return false;
    }
    if (!ReadInt(start, end, &start, /*allow_leading_zeros=*/true))
      return false;
  }

  *token_end = start;
  return true;
}

static bool ReadHexDigits(const Char* start,
                          const Char* end,
                          const Char** token_end,
                          int digits) {
  if (end - start < digits)
    return false;
  for (int i = 0; i < digits; ++i) {
    Char c = *start++;
    if (!(('0' <= c && c <= '9') || ('a' <= c && c <= 'f') ||
          ('A' <= c && c <= 'F')))
      return false;
  }
  *token_end = start;
  return true;
}

static bool ParseStringToken(const Char* start,
                             const Char* end,
                             const Char** token_end) {
  while (start < end) {
    Char c = *start++;
    if ('\\' == c) {
      if (start == end)
        return false;
      c = *start++;
      // Make sure the escaped char is valid.
      switch (c) {
        case 'x':
          if (!ReadHexDigits(start, end, &start, 2))
            return false;
          break;
        case 'u':
          if (!ReadHexDigits(start, end, &start, 4))
            return false;
          break;
        case '\\':
        case '/':
        case 'b':
        case 'f':
        case 'n':
        case 'r':
        case 't':
        case 'v':
        case '"':
          break;
        default:
          return false;
      }
    } else if ('"' == c) {
      *token_end = start;
      return true;
    }
  }
  return false;
}

static bool SkipComment(const Char* start,
                        const Char* end,
                        const Char** comment_end) {
  if (start == end)
    return false;

  if (*start != '/' || start + 1 >= end)
    return false;
  ++start;

  if (*start == '/') {
    // Single line comment, read to newline.
    for (++start; start < end; ++start) {
      if (*start == '\n' || *start == '\r') {
        *comment_end = start + 1;
        return true;
      }
    }
    *comment_end = end;
    // Comment reaches end-of-input, which is fine.
    return true;
  }

  if (*start == '*') {
    Char previous = '\0';
    // Block comment, read until end marker.
    for (++start; start < end; previous = *start++) {
      if (previous == '*' && *start == '/') {
        *comment_end = start + 1;
        return true;
      }
    }
    // Block comment must close before end-of-input.
    return false;
  }

  return false;
}

static bool IsSpaceOrNewLine(Char c) {
  // \v = vertial tab; \f = form feed page break.
  return c == ' ' || c == '\n' || c == '\v' || c == '\f' || c == '\r' ||
         c == '\t';
}

static void SkipWhitespaceAndComments(const Char* start,
                                      const Char* end,
                                      const Char** whitespace_end) {
  while (start < end) {
    if (IsSpaceOrNewLine(*start)) {
      ++start;
    } else if (*start == '/') {
      const Char* comment_end = nullptr;
      if (!SkipComment(start, end, &comment_end))
        break;
      start = comment_end;
    } else {
      break;
    }
  }
  *whitespace_end = start;
}

static Token ParseToken(const Char* start,
                        const Char* end,
                        const Char** tokenStart,
                        const Char** token_end) {
  SkipWhitespaceAndComments(start, end, tokenStart);
  start = *tokenStart;

  if (start == end)
    return NoInput;

  switch (*start) {
    case 'n':
      if (ParseConstToken(start, end, token_end, kNullString))
        return NullToken;
      break;
    case 't':
      if (ParseConstToken(start, end, token_end, kTrueString))
        return BoolTrue;
      break;
    case 'f':
      if (ParseConstToken(start, end, token_end, kFalseString))
        return BoolFalse;
      break;
    case '[':
      *token_end = start + 1;
      return ArrayBegin;
    case ']':
      *token_end = start + 1;
      return ArrayEnd;
    case ',':
      *token_end = start + 1;
      return ListSeparator;
    case '{':
      *token_end = start + 1;
      return ObjectBegin;
    case '}':
      *token_end = start + 1;
      return ObjectEnd;
    case ':':
      *token_end = start + 1;
      return ObjectPairSeparator;
    case '0':
    case '1':
    case '2':
    case '3':
    case '4':
    case '5':
    case '6':
    case '7':
    case '8':
    case '9':
    case '-':
      if (ParseNumberToken(start, end, token_end))
        return Number;
      break;
    case '"':
      if (ParseStringToken(start + 1, end, token_end))
        return StringLiteral;
      break;
  }
  return InvalidToken;
}

static int HexToInt(Char c) {
  if ('0' <= c && c <= '9')
    return c - '0';
  if ('A' <= c && c <= 'F')
    return c - 'A' + 10;
  if ('a' <= c && c <= 'f')
    return c - 'a' + 10;
  assert(false)(static_cast<void> (0));  // Unreachable.
  return 0;
}

static bool DecodeString(const Char* start,
                         const Char* end,
                         std::vector<uint16_t>* output) {
  if (start == end)
    return true;
  if (start > end)
    return false;
  output->reserve(end - start);
  while (start < end) {
    uint16_t c = *start++;
    // If the |Char| we're dealing with is really a byte, then
    // we have utf8 here, and we need to check for multibyte characters
    // and transcode them to utf16 (either one or two utf16 chars).
    if (sizeof(Char) == sizeof(uint8_t) && c > 0x7f) {
      // Inspect the leading byte to figure out how long the utf8
      // byte sequence is; while doing this initialize |codepoint|
      // with the first few bits.
      // See table in: https://en.wikipedia.org/wiki/UTF-8
      // byte one is 110x xxxx -> 2 byte utf8 sequence
      // byte one is 1110 xxxx -> 3 byte utf8 sequence
      // byte one is 1111 0xxx -> 4 byte utf8 sequence
      uint32_t codepoint;
      int num_bytes_left;
      if ((c & 0xe0) == 0xc0) {  // 2 byte utf8 sequence
        num_bytes_left = 1;
        codepoint = c & 0x1f;
      } else if ((c & 0xf0) == 0xe0) {  // 3 byte utf8 sequence
        num_bytes_left = 2;
        codepoint = c & 0x0f;
      } else if ((c & 0xf8) == 0xf0) {  // 4 byte utf8 sequence
        codepoint = c & 0x07;
        num_bytes_left = 3;
      } else {
        return false;  // invalid leading byte
      }

      // If we have enough bytes in our inpput, decode the remaining ones
      // belonging to this Unicode character into |codepoint|.
      if (start + num_bytes_left > end)
        return false;
      while (num_bytes_left > 0) {
        c = *start++;
        --num_bytes_left;
        // Check the next byte is a continuation byte, that is 10xx xxxx.
        if ((c & 0xc0) != 0x80)
          return false;
        codepoint = (codepoint << 6) | (c & 0x3f);
      }

      // Disallow overlong encodings for ascii characters, as these
      // would include " and other characters significant to JSON
      // string termination / control.
      if (codepoint <= 0x7f)
        return false;
      // Invalid in UTF8, and can't be represented in UTF16 anyway.
      if (codepoint > 0x10ffff)
        return false;

      // So, now we transcode to UTF16,
      // using the math described at https://en.wikipedia.org/wiki/UTF-16,
      // for either one or two 16 bit characters.
      if (codepoint < 0xffff) {
        output->push_back(codepoint);
        continue;
      }
      codepoint -= 0x10000;
      output->push_back((codepoint >> 10) + 0xd800);    // high surrogate
      output->push_back((codepoint & 0x3ff) + 0xdc00);  // low surrogate
      continue;
    }
    if ('\\' != c) {
      output->push_back(c);
      continue;
    }
    if (start == end)
      return false;
    c = *start++;

    if (c == 'x') {
      // \x is not supported.
      return false;
    }

    switch (c) {
      case '"':
      case '/':
      case '\\':
        break;
      case 'b':
        c = '\b';
        break;
      case 'f':
        c = '\f';
        break;
      case 'n':
        c = '\n';
        break;
      case 'r':
        c = '\r';
        break;
      case 't':
        c = '\t';
        break;
      case 'v':
        c = '\v';
        break;
      case 'u':
        c = (HexToInt(*start) << 12) + (HexToInt(*(start + 1)) << 8) +
            (HexToInt(*(start + 2)) << 4) + HexToInt(*(start + 3));
        start += 4;
        break;
      default:
        return false;
    }
    output->push_back(c);
  }
  return true;
}

void ParseValue(const Char* start,
                const Char* end,
                const Char** value_token_end,
                int depth) {
  if (depth > kStackLimit) {
    HandleError(Error::JSON_PARSER_STACK_LIMIT_EXCEEDED, start);
    return;
  }
  const Char* token_start = nullptr;
  const Char* token_end = nullptr;
  Token token = ParseToken(start, end, &token_start, &token_end);
  switch (token) {
    case NoInput:
      HandleError(Error::JSON_PARSER_NO_INPUT, token_start);
      return;
    case InvalidToken:
      HandleError(Error::JSON_PARSER_INVALID_TOKEN, token_start);
      return;
    case NullToken:
      handler_->HandleNull();
      break;
    case BoolTrue:
      handler_->HandleBool(true);
      break;
    case BoolFalse:
      handler_->HandleBool(false);
      break;
    case Number: {
      double value;
      if (!CharsToDouble(token_start, token_end - token_start, &value)) {
        HandleError(Error::JSON_PARSER_INVALID_NUMBER, token_start);
        return;
      }
      if (value >= std::numeric_limits<int32_t>::min() &&
          value <= std::numeric_limits<int32_t>::max() &&
          static_cast<int32_t>(value) == value)
        handler_->HandleInt32(static_cast<int32_t>(value));
      else
        handler_->HandleDouble(value);
      break;
    }
    case StringLiteral: {
      std::vector<uint16_t> value;
      bool ok = DecodeString(token_start + 1, token_end - 1, &value);
      if (!ok) {
        HandleError(Error::JSON_PARSER_INVALID_STRING, token_start);
        return;
      }
      handler_->HandleString16(span<uint16_t>(value.data(), value.size()));
      break;
    }
    case ArrayBegin: {
      handler_->HandleArrayBegin();
      start = token_end;
      token = ParseToken(start, end, &token_start, &token_end);
      while (token != ArrayEnd) {
        ParseValue(start, end, &token_end, depth + 1);
        if (error_)
          return;

        // After a list value, we expect a comma or the end of the list.
        start = token_end;
        token = ParseToken(start, end, &token_start, &token_end);
        if (token == ListSeparator) {
          start = token_end;
          token = ParseToken(start, end, &token_start, &token_end);
          if (token == ArrayEnd) {
            HandleError(Error::JSON_PARSER_UNEXPECTED_ARRAY_END, token_start);
            return;
          }
        } else if (token != ArrayEnd) {
          // Unexpected value after list value. Bail out.
          HandleError(Error::JSON_PARSER_COMMA_OR_ARRAY_END_EXPECTED,
                      token_start);
          return;
        }
      }
      handler_->HandleArrayEnd();
      break;
    }
    case ObjectBegin: {
      handler_->HandleMapBegin();
      start = token_end;
      token = ParseToken(start, end, &token_start, &token_end);
      while (token != ObjectEnd) {
        if (token != StringLiteral) {
          HandleError(Error::JSON_PARSER_STRING_LITERAL_EXPECTED,
                      token_start);
          return;
        }
        std::vector<uint16_t> key;
        if (!DecodeString(token_start + 1, token_end - 1, &key)) {
          HandleError(Error::JSON_PARSER_INVALID_STRING, token_start);
          return;
        }
        handler_->HandleString16(span<uint16_t>(key.data(), key.size()));
        start = token_end;

        token = ParseToken(start, end, &token_start, &token_end);
        if (token != ObjectPairSeparator) {
          HandleError(Error::JSON_PARSER_COLON_EXPECTED, token_start);
          return;
        }
        start = token_end;

        ParseValue(start, end, &token_end, depth + 1);
        if (error_)
          return;
        start = token_end;

        // After a key/value pair, we expect a comma or the end of the
        // object.
        token = ParseToken(start, end, &token_start, &token_end);
        if (token == ListSeparator) {
          start = token_end;
          token = ParseToken(start, end, &token_start, &token_end);
          if (token == ObjectEnd) {
            HandleError(Error::JSON_PARSER_UNEXPECTED_MAP_END, token_start);
            return;
          }
        } else if (token != ObjectEnd) {
          // Unexpected value after last object value. Bail out.
          HandleError(Error::JSON_PARSER_COMMA_OR_MAP_END_EXPECTED,
                      token_start);
          return;
        }
      }
      handler_->HandleMapEnd();
      break;
    }

    default:
      // We got a token that's not a value.
      HandleError(Error::JSON_PARSER_VALUE_EXPECTED, token_start);
      return;
  }

  SkipWhitespaceAndComments(token_end, end, value_token_end);
}

void HandleError(Error error, const Char* pos) {
  assert(error != Error::OK)(static_cast<void> (0));
  if (!error_) {
    handler_->HandleError(
        Status{error, static_cast<size_t>(pos - start_pos_)});
    error_ = true;
  }
}

const Char* start_pos_ = nullptr;
bool error_ = false;
const Platform* platform_;
StreamingParserHandler* handler_;
3852};
3853}  // namespace

3855void ParseJSON(const Platform& platform,
             span<uint8_t> chars,
             StreamingParserHandler* handler) {
JsonParser<uint8_t> parser(&platform, handler);
parser.Parse(chars.data(), chars.size());
3860}

3862void ParseJSON(const Platform& platform,
             span<uint16_t> chars,
             StreamingParserHandler* handler) {
JsonParser<uint16_t> parser(&platform, handler);
parser.Parse(chars.data(), chars.size());
3867}

3869// =============================================================================
3870// json::ConvertCBORToJSON, json::ConvertJSONToCBOR - for transcoding
3871// =============================================================================
3872template <typename C>
3873Status ConvertCBORToJSONTmpl(const Platform& platform,
                           span<uint8_t> cbor,
                           C* json) {
Status status;
std::unique_ptr<StreamingParserHandler> json_writer =
    NewJSONEncoder(&platform, json, &status);
cbor::ParseCBOR(cbor, json_writer.get());
return status;
3881}

3883Status ConvertCBORToJSON(const Platform& platform,
                       span<uint8_t> cbor,
                       std::vector<uint8_t>* json) {
return ConvertCBORToJSONTmpl(platform, cbor, json);
3887}
3888Status ConvertCBORToJSON(const Platform& platform,
                       span<uint8_t> cbor,
                       std::string* json) {
return ConvertCBORToJSONTmpl(platform, cbor, json);
3892}

3894template <typename T, typename C>
3895Status ConvertJSONToCBORTmpl(const Platform& platform, span<T> json, C* cbor) {
Status status;
std::unique_ptr<StreamingParserHandler> encoder =
    cbor::NewCBOREncoder(cbor, &status);
ParseJSON(platform, json, encoder.get());
return status;
3901}
3902Status ConvertJSONToCBOR(const Platform& platform,
                       span<uint8_t> json,
                       std::string* cbor) {
return ConvertJSONToCBORTmpl(platform, json, cbor);
3906}
3907Status ConvertJSONToCBOR(const Platform& platform,
                       span<uint16_t> json,
                       std::string* cbor) {
return ConvertJSONToCBORTmpl(platform, json, cbor);
3911}
3912Status ConvertJSONToCBOR(const Platform& platform,
                       span<uint8_t> json,
                       std::vector<uint8_t>* cbor) {
return ConvertJSONToCBORTmpl(platform, json, cbor);
3916}
3917Status ConvertJSONToCBOR(const Platform& platform,
                       span<uint16_t> json,
                       std::vector<uint8_t>* cbor) {
return ConvertJSONToCBORTmpl(platform, json, cbor);
3921}
3922}  // namespace json

3924} // namespace node
3925} // namespace inspector
3926} // namespace protocol


←

/home/maurizio/node-v18.6.0/out/Release/obj/gen/src/node/inspector/protocol/Protocol.h

1// This file is generated by ErrorSupport_h.template.
2 
3// Copyright 2016 The Chromium Authors. All rights reserved.
4// Use of this source code is governed by a BSD-style license that can be
5// found in the LICENSE file.
6 
7#ifndef node_inspector_protocol_ErrorSupport_h
8#define node_inspector_protocol_ErrorSupport_h
9 
10#include "src/node/inspector/protocol/Forward.h"
11 
12namespace node {
13namespace inspector {
14namespace protocol {
15 
16class  ErrorSupport {
17public:
18    ErrorSupport();
19    ~ErrorSupport();
20 
21    void push();
22    void setName(const char*);
23    void setName(const String&);
24    void pop();
25    void addError(const char*);
26    void addError(const String&);
27    bool hasErrors();
28    String errors();
29 
30private:
31    std::vector<String> m_path;
32    std::vector<String> m_errors;
33};
34 
35} // namespace node
36} // namespace inspector
37} // namespace protocol
38 
39#endif // !defined(node_inspector_protocol_ErrorSupport_h)
40 
41 
42// This file is generated by Values_h.template.
43 
44// Copyright 2016 The Chromium Authors. All rights reserved.
45// Use of this source code is governed by a BSD-style license that can be
46// found in the LICENSE file.
47 
48#ifndef node_inspector_protocol_Values_h
49#define node_inspector_protocol_Values_h
50 
51//#include "Allocator.h"
52//#include "Forward.h"
53 
54namespace node {
55namespace inspector {
56namespace protocol {
57 
58class ListValue;
59class DictionaryValue;
60class Value;
61 
62class  Value : public Serializable {
63    PROTOCOL_DISALLOW_COPY(Value)private: Value(const Value&) = delete; Value& operator
=(const Value&) = delete;
64public:
65    virtual ~Value() override { }
66 
67    static std::unique_ptr<Value> null()
68    {
69        return std::unique_ptr<Value>(new Value());
70    }
71 
72    static std::unique_ptr<Value> parseBinary(const uint8_t* data, size_t size);
73 
74    enum ValueType {
75        TypeNull = 0,
76        TypeBoolean,
77        TypeInteger,
78        TypeDouble,
79        TypeString,
80        TypeBinary,
81        TypeObject,
82        TypeArray,
83        TypeSerialized,
84        TypeImported
85    };
86 
87    ValueType type() const { return m_type; }
88 
89    bool isNull() const { return m_type == TypeNull; }
90 
91    virtual bool asBoolean(bool* output) const;
92    virtual bool asDouble(double* output) const;
93    virtual bool asInteger(int* output) const;
94    virtual bool asString(String* output) const;
95    virtual bool asBinary(Binary* output) const;
96 
97    virtual void writeJSON(StringBuilder* output) const;
98    virtual void writeBinary(std::vector<uint8_t>* bytes) const;
99    virtual std::unique_ptr<Value> clone() const;
100    String toJSONString() const;
101    String serializeToJSON() override;
102    std::vector<uint8_t> serializeToBinary() override;
103 
104protected:
105    Value() : m_type(TypeNull) { }
106    explicit Value(ValueType type) : m_type(type) { }
107 
108private:
109    friend class DictionaryValue;
110    friend class ListValue;
111 
112    ValueType m_type;
113};
114 
115class  FundamentalValue : public Value {
116public:
117    static std::unique_ptr<FundamentalValue> create(bool value)
118    {
119        return std::unique_ptr<FundamentalValue>(new FundamentalValue(value));
120    }
121 
122    static std::unique_ptr<FundamentalValue> create(int value)
123    {
124        return std::unique_ptr<FundamentalValue>(new FundamentalValue(value));
125    }
126 
127    static std::unique_ptr<FundamentalValue> create(double value)
128    {
129        return std::unique_ptr<FundamentalValue>(new FundamentalValue(value));
130    }
131 
132    bool asBoolean(bool* output) const override;
133    bool asDouble(double* output) const override;
134    bool asInteger(int* output) const override;
135    void writeJSON(StringBuilder* output) const override;
136    void writeBinary(std::vector<uint8_t>* bytes) const override;
137    std::unique_ptr<Value> clone() const override;
138 
139private:
140    explicit FundamentalValue(bool value) : Value(TypeBoolean), m_boolValue(value) { }
141    explicit FundamentalValue(int value) : Value(TypeInteger), m_integerValue(value) { }
142    explicit FundamentalValue(double value) : Value(TypeDouble), m_doubleValue(value) { }
143 
144    union {
145        bool m_boolValue;
146        double m_doubleValue;
147        int m_integerValue;
148    };
149};
150 
151class  StringValue : public Value {
152public:
153    static std::unique_ptr<StringValue> create(const String& value)
154    {
155        return std::unique_ptr<StringValue>(new StringValue(value));
156    }
157 
158    static std::unique_ptr<StringValue> create(const char* value)
159    {
160        return std::unique_ptr<StringValue>(new StringValue(value));
161    }
162 
163    bool asString(String* output) const override;
164    void writeJSON(StringBuilder* output) const override;
165    void writeBinary(std::vector<uint8_t>* bytes) const override;
166    std::unique_ptr<Value> clone() const override;
167 
168private:
169    explicit StringValue(const String& value) : Value(TypeString), m_stringValue(value) { }
170    explicit StringValue(const char* value) : Value(TypeString), m_stringValue(value) { }
171 
172    String m_stringValue;
173};
174 
175class  BinaryValue : public Value {
176public:
177    static std::unique_ptr<BinaryValue> create(const Binary& value)
178    {
179        return std::unique_ptr<BinaryValue>(new BinaryValue(value));
180    }
181 
182    bool asBinary(Binary* output) const override;
183    void writeJSON(StringBuilder* output) const override;
184    void writeBinary(std::vector<uint8_t>* bytes) const override;
185    std::unique_ptr<Value> clone() const override;
186 
187private:
188    explicit BinaryValue(const Binary& value) : Value(TypeBinary), m_binaryValue(value) { }
189 
190    Binary m_binaryValue;
191};
192 
193class  SerializedValue : public Value {
194public:
195    static std::unique_ptr<SerializedValue> fromJSON(const String& value)
196    {
197        return std::unique_ptr<SerializedValue>(new SerializedValue(value));
198    }
199 
200    static std::unique_ptr<SerializedValue> fromBinary(std::vector<uint8_t> value)
201    {
202        return std::unique_ptr<SerializedValue>(new SerializedValue(std::move(value)));
203    }
204 
205    void writeJSON(StringBuilder* output) const override;
206    void writeBinary(std::vector<uint8_t>* bytes) const override;
207    std::unique_ptr<Value> clone() const override;
208 
209private:
210    explicit SerializedValue(const String& json) : Value(TypeSerialized), m_serializedJSON(json) { }
211    explicit SerializedValue(std::vector<uint8_t> binary) : Value(TypeSerialized), m_serializedBinary(std::move(binary)) { }
212    SerializedValue(const String& json, const std::vector<uint8_t>& binary)
213        : Value(TypeSerialized), m_serializedJSON(json), m_serializedBinary(binary) { }
214    String m_serializedJSON;
215    std::vector<uint8_t> m_serializedBinary;
216};
217 
218class  DictionaryValue : public Value {
219public:
220    using Entry = std::pair<String, Value*>;
221    static std::unique_ptr<DictionaryValue> create()
222    {
223        return std::unique_ptr<DictionaryValue>(new DictionaryValue());
3
←
Memory is allocated→
224    }
225 
226    static DictionaryValue* cast(Value* value)
227    {
228        if (!value || value->type() != TypeObject)
229            return nullptr;
230        return static_cast<DictionaryValue*>(value);
231    }
232 
233    static std::unique_ptr<DictionaryValue> cast(std::unique_ptr<Value> value)
234    {
235        return std::unique_ptr<DictionaryValue>(DictionaryValue::cast(value.release()));
9
←
Potential leak of memory pointed to by 'value._M_t._M_t._M_head_impl'
236    }
237 
238    void writeJSON(StringBuilder* output) const override;
239    void writeBinary(std::vector<uint8_t>* bytes) const override;
240    std::unique_ptr<Value> clone() const override;
241 
242    size_t size() const { return m_data.size(); }
243 
244    void setBoolean(const String& name, bool);
245    void setInteger(const String& name, int);
246    void setDouble(const String& name, double);
247    void setString(const String& name, const String&);
248    void setValue(const String& name, std::unique_ptr<Value>);
249    void setObject(const String& name, std::unique_ptr<DictionaryValue>);
250    void setArray(const String& name, std::unique_ptr<ListValue>);
251 
252    bool getBoolean(const String& name, bool* output) const;
253    bool getInteger(const String& name, int* output) const;
254    bool getDouble(const String& name, double* output) const;
255    bool getString(const String& name, String* output) const;
256 
257    DictionaryValue* getObject(const String& name) const;
258    ListValue* getArray(const String& name) const;
259    Value* get(const String& name) const;
260    Entry at(size_t index) const;
261 
262    bool booleanProperty(const String& name, bool defaultValue) const;
263    int integerProperty(const String& name, int defaultValue) const;
264    double doubleProperty(const String& name, double defaultValue) const;
265    void remove(const String& name);
266 
267    ~DictionaryValue() override;
268 
269private:
270    DictionaryValue();
271    template<typename T>
272    void set(const String& key, std::unique_ptr<T>& value)
273    {
274        DCHECK(value);
275        bool isNew = m_data.find(key) == m_data.end();
276        m_data[key] = std::move(value);
277        if (isNew)
278            m_order.push_back(key);
279    }
280 
281    using Dictionary = std::unordered_map<String, std::unique_ptr<Value>>;
282    Dictionary m_data;
283    std::vector<String> m_order;
284};
285 
286class  ListValue : public Value {
287public:
288    static std::unique_ptr<ListValue> create()
289    {
290        return std::unique_ptr<ListValue>(new ListValue());
291    }
292 
293    static ListValue* cast(Value* value)
294    {
295        if (!value || value->type() != TypeArray)
296            return nullptr;
297        return static_cast<ListValue*>(value);
298    }
299 
300    static std::unique_ptr<ListValue> cast(std::unique_ptr<Value> value)
301    {
302        return std::unique_ptr<ListValue>(ListValue::cast(value.release()));
303    }
304 
305    ~ListValue() override;
306 
307    void writeJSON(StringBuilder* output) const override;
308    void writeBinary(std::vector<uint8_t>* bytes) const override;
309    std::unique_ptr<Value> clone() const override;
310 
311    void pushValue(std::unique_ptr<Value>);
312 
313    Value* at(size_t index);
314    size_t size() const { return m_data.size(); }
315 
316private:
317    ListValue();
318    std::vector<std::unique_ptr<Value>> m_data;
319};
320 
321void escapeLatinStringForJSON(const uint8_t* str, unsigned len, StringBuilder* dst);
322void escapeWideStringForJSON(const uint16_t* str, unsigned len, StringBuilder* dst);
323 
324} // namespace node
325} // namespace inspector
326} // namespace protocol
327 
328#endif // node_inspector_protocol_Values_h
329 
330 
331// This file is generated by Object_h.template.
332 
333// Copyright 2016 The Chromium Authors. All rights reserved.
334// Use of this source code is governed by a BSD-style license that can be
335// found in the LICENSE file.
336 
337#ifndef node_inspector_protocol_Object_h
338#define node_inspector_protocol_Object_h
339 
340//#include "ErrorSupport.h"
341//#include "Forward.h"
342//#include "Values.h"
343 
344namespace node {
345namespace inspector {
346namespace protocol {
347 
348class  Object {
349public:
350    static std::unique_ptr<Object> fromValue(protocol::Value*, ErrorSupport*);
351    explicit Object(std::unique_ptr<protocol::DictionaryValue>);
352    ~Object();
353 
354    std::unique_ptr<protocol::DictionaryValue> toValue() const;
355    std::unique_ptr<Object> clone() const;
356private:
357    std::unique_ptr<protocol::DictionaryValue> m_object;
358};
359 
360} // namespace node
361} // namespace inspector
362} // namespace protocol
363 
364#endif // !defined(node_inspector_protocol_Object_h)
365 
366 
367// This file is generated by ValueConversions_h.template.
368 
369// Copyright 2016 The Chromium Authors. All rights reserved.
370// Use of this source code is governed by a BSD-style license that can be
371// found in the LICENSE file.
372 
373#ifndef node_inspector_protocol_ValueConversions_h
374#define node_inspector_protocol_ValueConversions_h
375 
376//#include "ErrorSupport.h"
377//#include "Forward.h"
378//#include "Values.h"
379 
380namespace node {
381namespace inspector {
382namespace protocol {
383 
384template<typename T>
385struct ValueConversions {
386    static std::unique_ptr<T> fromValue(protocol::Value* value, ErrorSupport* errors)
387    {
388        return T::fromValue(value, errors);
389    }
390 
391    static std::unique_ptr<protocol::Value> toValue(T* value)
392    {
393        return value->toValue();
394    }
395 
396    static std::unique_ptr<protocol::Value> toValue(const std::unique_ptr<T>& value)
397    {
398        return value->toValue();
399    }
400};
401 
402template<>
403struct ValueConversions<bool> {
404    static bool fromValue(protocol::Value* value, ErrorSupport* errors)
405    {
406        bool result = false;
407        bool success = value ? value->asBoolean(&result) : false;
408        if (!success)
409            errors->addError("boolean value expected");
410        return result;
411    }
412 
413    static std::unique_ptr<protocol::Value> toValue(bool value)
414    {
415        return FundamentalValue::create(value);
416    }
417};
418 
419template<>
420struct ValueConversions<int> {
421    static int fromValue(protocol::Value* value, ErrorSupport* errors)
422    {
423        int result = 0;
424        bool success = value ? value->asInteger(&result) : false;
425        if (!success)
426            errors->addError("integer value expected");
427        return result;
428    }
429 
430    static std::unique_ptr<protocol::Value> toValue(int value)
431    {
432        return FundamentalValue::create(value);
433    }
434};
435 
436template<>
437struct ValueConversions<double> {
438    static double fromValue(protocol::Value* value, ErrorSupport* errors)
439    {
440        double result = 0;
441        bool success = value ? value->asDouble(&result) : false;
442        if (!success)
443            errors->addError("double value expected");
444        return result;
445    }
446 
447    static std::unique_ptr<protocol::Value> toValue(double value)
448    {
449        return FundamentalValue::create(value);
450    }
451};
452 
453template<>
454struct ValueConversions<String> {
455    static String fromValue(protocol::Value* value, ErrorSupport* errors)
456    {
457        String result;
458        bool success = value ? value->asString(&result) : false;
459        if (!success)
460            errors->addError("string value expected");
461        return result;
462    }
463 
464    static std::unique_ptr<protocol::Value> toValue(const String& value)
465    {
466        return StringValue::create(value);
467    }
468};
469 
470template<>
471struct ValueConversions<Binary> {
472    static Binary fromValue(protocol::Value* value, ErrorSupport* errors)
473    {
474        if (!value ||
475            (value->type() != Value::TypeBinary && value->type() != Value::TypeString)) {
476            errors->addError("Either string base64 or binary value expected");
477            return Binary();
478        }
479        Binary binary;
480        if (value->asBinary(&binary))
481            return binary;
482        String result;
483        value->asString(&result);
484        bool success;
485        Binary out = Binary::fromBase64(result, &success);
486        if (!success)
487          errors->addError("base64 decoding error");
488        return out;
489    }
490 
491    static std::unique_ptr<protocol::Value> toValue(const Binary& value)
492    {
493        return BinaryValue::create(value);
494    }
495};
496 
497template<>
498struct ValueConversions<Value> {
499    static std::unique_ptr<Value> fromValue(protocol::Value* value, ErrorSupport* errors)
500    {
501        bool success = !!value;
502        if (!success) {
503            errors->addError("value expected");
504            return nullptr;
505        }
506        return value->clone();
507    }
508 
509    static std::unique_ptr<protocol::Value> toValue(Value* value)
510    {
511        return value->clone();
512    }
513 
514    static std::unique_ptr<protocol::Value> toValue(const std::unique_ptr<Value>& value)
515    {
516        return value->clone();
517    }
518};
519 
520template<>
521struct ValueConversions<DictionaryValue> {
522    static std::unique_ptr<DictionaryValue> fromValue(protocol::Value* value, ErrorSupport* errors)
523    {
524        bool success = value && value->type() == protocol::Value::TypeObject;
525        if (!success)
526            errors->addError("object expected");
527        return DictionaryValue::cast(value->clone());
528    }
529 
530    static std::unique_ptr<protocol::Value> toValue(DictionaryValue* value)
531    {
532        return value->clone();
533    }
534 
535    static std::unique_ptr<protocol::Value> toValue(const std::unique_ptr<DictionaryValue>& value)
536    {
537        return value->clone();
538    }
539};
540 
541template<>
542struct ValueConversions<ListValue> {
543    static std::unique_ptr<ListValue> fromValue(protocol::Value* value, ErrorSupport* errors)
544    {
545        bool success = value && value->type() == protocol::Value::TypeArray;
546        if (!success)
547            errors->addError("list expected");
548        return ListValue::cast(value->clone());
549    }
550 
551    static std::unique_ptr<protocol::Value> toValue(ListValue* value)
552    {
553        return value->clone();
554    }
555 
556    static std::unique_ptr<protocol::Value> toValue(const std::unique_ptr<ListValue>& value)
557    {
558        return value->clone();
559    }
560};
561 
562} // namespace node
563} // namespace inspector
564} // namespace protocol
565 
566#endif // !defined(node_inspector_protocol_ValueConversions_h)
567 
568 
569// This file is generated by Maybe_h.template.
570 
571// Copyright 2016 The Chromium Authors. All rights reserved.
572// Use of this source code is governed by a BSD-style license that can be
573// found in the LICENSE file.
574 
575#ifndef node_inspector_protocol_Maybe_h
576#define node_inspector_protocol_Maybe_h
577 
578// This macro allows to test for the version of the GNU C++ compiler.
579// Note that this also applies to compilers that masquerade as GCC,
580// for example clang and the Intel C++ compiler for Linux.
581// Use like:
582//  #if IP_GNUC_PREREQ(4, 3, 1)
583//   ...
584//  #endif
585#if defined(__GNUC__4) && defined(__GNUC_MINOR__2) && defined(__GNUC_PATCHLEVEL__1)
586#define IP_GNUC_PREREQ(major, minor, patchlevel)                      \
587  ((__GNUC__4 * 10000 + __GNUC_MINOR__2 * 100 + __GNUC_PATCHLEVEL__1) >= \
588   ((major)*10000 + (minor)*100 + (patchlevel)))
589#elif defined(__GNUC__4) && defined(__GNUC_MINOR__2)
590#define IP_GNUC_PREREQ(major, minor, patchlevel) \
591  ((__GNUC__4 * 10000 + __GNUC_MINOR__2 * 100) >=  \
592   ((major)*10000 + (minor)*100 + (patchlevel)))
593#else
594#define IP_GNUC_PREREQ(major, minor, patchlevel) 0
595#endif
596 
597#if defined(__mips64)
598#define IP_TARGET_ARCH_MIPS64 1
599#elif defined(__MIPSEB__) || defined(__MIPSEL__)
600#define IP_TARGET_ARCH_MIPS 1
601#endif
602 
603// Allowing the use of noexcept by removing the keyword on older compilers that
604// do not support adding noexcept to default members.
605#if ((IP_GNUC_PREREQ(4, 9, 0) && !defined(IP_TARGET_ARCH_MIPS) && \
606      !defined(IP_TARGET_ARCH_MIPS64)) ||                         \
607     (defined(__clang__1) && __cplusplus201703L > 201300L))
608#define IP_NOEXCEPT noexcept
609#else
610#define IP_NOEXCEPT
611#endif
612 
613//#include "Forward.h"
614 
615namespace node {
616namespace inspector {
617namespace protocol {
618 
619template<typename T>
620class Maybe {
621public:
622    Maybe() : m_value() { }
623    Maybe(std::unique_ptr<T> value) : m_value(std::move(value)) { }
624    Maybe(Maybe&& other) IP_NOEXCEPT : m_value(std::move(other.m_value)) {}
625    void operator=(std::unique_ptr<T> value) { m_value = std::move(value); }
626    T* fromJust() const { DCHECK(m_value); return m_value.get(); }
627    T* fromMaybe(T* defaultValue) const { return m_value ? m_value.get() : defaultValue; }
628    bool isJust() const { return !!m_value; }
629    std::unique_ptr<T> takeJust() { DCHECK(m_value); return std::move(m_value); }
630private:
631    std::unique_ptr<T> m_value;
632};
633 
634template<typename T>
635class MaybeBase {
636public:
637    MaybeBase() : m_isJust(false) { }
638    MaybeBase(T value) : m_isJust(true), m_value(value) { }
639    MaybeBase(MaybeBase&& other) IP_NOEXCEPT
640        : m_isJust(other.m_isJust),
641          m_value(std::move(other.m_value)) {}
642    void operator=(T value) { m_value = value; m_isJust = true; }
643    T fromJust() const { DCHECK(m_isJust); return m_value; }
644    T fromMaybe(const T& defaultValue) const { return m_isJust ? m_value : defaultValue; }
645    bool isJust() const { return m_isJust; }
646    T takeJust() { DCHECK(m_isJust); return m_value; }
647 
648protected:
649    bool m_isJust;
650    T m_value;
651};
652 
653template<>
654class Maybe<bool> : public MaybeBase<bool> {
655public:
656    Maybe() { m_value = false; }
657    Maybe(bool value) : MaybeBase(value) { }
658    Maybe(Maybe&& other) IP_NOEXCEPT : MaybeBase(std::move(other)) {}
659    using MaybeBase::operator=;
660};
661 
662template<>
663class Maybe<int> : public MaybeBase<int> {
664public:
665    Maybe() { m_value = 0; }
666    Maybe(int value) : MaybeBase(value) { }
667    Maybe(Maybe&& other) IP_NOEXCEPT : MaybeBase(std::move(other)) {}
668    using MaybeBase::operator=;
669};
670 
671template<>
672class Maybe<double> : public MaybeBase<double> {
673public:
674    Maybe() { m_value = 0; }
675    Maybe(double value) : MaybeBase(value) { }
676    Maybe(Maybe&& other) IP_NOEXCEPT : MaybeBase(std::move(other)) {}
677    using MaybeBase::operator=;
678};
679 
680template<>
681class Maybe<String> : public MaybeBase<String> {
682public:
683    Maybe() { }
684    Maybe(const String& value) : MaybeBase(value) { }
685    Maybe(Maybe&& other) IP_NOEXCEPT : MaybeBase(std::move(other)) {}
686    using MaybeBase::operator=;
687};
688 
689template<>
690class Maybe<Binary> : public MaybeBase<Binary> {
691public:
692    Maybe() { }
693    Maybe(Binary value) : MaybeBase(value) { }
694    Maybe(Maybe&& other) IP_NOEXCEPT : MaybeBase(std::move(other)) {}
695    using MaybeBase::operator=;
696};
697 
698} // namespace node
699} // namespace inspector
700} // namespace protocol
701 
702#undef IP_GNUC_PREREQ
703#undef IP_TARGET_ARCH_MIPS64
704#undef IP_TARGET_ARCH_MIPS
705#undef IP_NOEXCEPT
706 
707#endif // !defined(node_inspector_protocol_Maybe_h)
708 
709 
710// This file is generated by Array_h.template.
711 
712// Copyright 2016 The Chromium Authors. All rights reserved.
713// Use of this source code is governed by a BSD-style license that can be
714// found in the LICENSE file.
715 
716#ifndef node_inspector_protocol_Array_h
717#define node_inspector_protocol_Array_h
718 
719//#include "ErrorSupport.h"
720//#include "Forward.h"
721//#include "ValueConversions.h"
722//#include "Values.h"
723 
724namespace node {
725namespace inspector {
726namespace protocol {
727 
728template<typename T>
729class Array {
730public:
731    static std::unique_ptr<Array<T>> create()
732    {
733        return std::unique_ptr<Array<T>>(new Array<T>());
734    }
735 
736    static std::unique_ptr<Array<T>> fromValue(protocol::Value* value, ErrorSupport* errors)
737    {
738        protocol::ListValue* array = ListValue::cast(value);
739        if (!array) {
740            errors->addError("array expected");
741            return nullptr;
742        }
743        std::unique_ptr<Array<T>> result(new Array<T>());
744        errors->push();
745        for (size_t i = 0; i < array->size(); ++i) {
746            errors->setName(StringUtil::fromInteger(i));
747            std::unique_ptr<T> item = ValueConversions<T>::fromValue(array->at(i), errors);
748            result->m_vector.push_back(std::move(item));
749        }
750        errors->pop();
751        if (errors->hasErrors())
752            return nullptr;
753        return result;
754    }
755 
756    void addItem(std::unique_ptr<T> value)
757    {
758        m_vector.push_back(std::move(value));
759    }
760 
761    size_t length()
762    {
763        return m_vector.size();
764    }
765 
766    T* get(size_t index)
767    {
768        return m_vector[index].get();
769    }
770 
771    std::unique_ptr<protocol::ListValue> toValue()
772    {
773        std::unique_ptr<protocol::ListValue> result = ListValue::create();
774        for (auto& item : m_vector)
775            result->pushValue(ValueConversions<T>::toValue(item));
776        return result;
777    }
778 
779private:
780    std::vector<std::unique_ptr<T>> m_vector;
781};
782 
783template<typename T>
784class ArrayBase {
785public:
786    static std::unique_ptr<Array<T>> create()
787    {
788        return std::unique_ptr<Array<T>>(new Array<T>());
789    }
790 
791    static std::unique_ptr<Array<T>> fromValue(protocol::Value* value, ErrorSupport* errors)
792    {
793        protocol::ListValue* array = ListValue::cast(value);
794        if (!array) {
795            errors->addError("array expected");
796            return nullptr;
797        }
798        errors->push();
799        std::unique_ptr<Array<T>> result(new Array<T>());
800        for (size_t i = 0; i < array->size(); ++i) {
801            errors->setName(StringUtil::fromInteger(i));
802            T item = ValueConversions<T>::fromValue(array->at(i), errors);
803            result->m_vector.push_back(item);
804        }
805        errors->pop();
806        if (errors->hasErrors())
807            return nullptr;
808        return result;
809    }
810 
811    void addItem(const T& value)
812    {
813        m_vector.push_back(value);
814    }
815 
816    size_t length()
817    {
818        return m_vector.size();
819    }
820 
821    T get(size_t index)
822    {
823        return m_vector[index];
824    }
825 
826    std::unique_ptr<protocol::ListValue> toValue()
827    {
828        std::unique_ptr<protocol::ListValue> result = ListValue::create();
829        for (auto& item : m_vector)
830            result->pushValue(ValueConversions<T>::toValue(item));
831        return result;
832    }
833 
834private:
835    std::vector<T> m_vector;
836};
837 
838template<> class Array<String> : public ArrayBase<String> {};
839template<> class Array<int> : public ArrayBase<int> {};
840template<> class Array<double> : public ArrayBase<double> {};
841template<> class Array<bool> : public ArrayBase<bool> {};
842 
843} // namespace node
844} // namespace inspector
845} // namespace protocol
846 
847#endif // !defined(node_inspector_protocol_Array_h)
848 
849 
850// This file is generated by DispatcherBase_h.template.
851 
852// Copyright 2016 The Chromium Authors. All rights reserved.
853// Use of this source code is governed by a BSD-style license that can be
854// found in the LICENSE file.
855 
856#ifndef node_inspector_protocol_DispatcherBase_h
857#define node_inspector_protocol_DispatcherBase_h
858 
859//#include "Forward.h"
860//#include "ErrorSupport.h"
861//#include "Values.h"
862 
863namespace node {
864namespace inspector {
865namespace protocol {
866 
867class WeakPtr;
868 
869class  DispatchResponse {
870public:
871    enum Status {
872        kSuccess = 0,
873        kError = 1,
874        kFallThrough = 2,
875    };
876 
877    enum ErrorCode {
878        kParseError = -32700,
879        kInvalidRequest = -32600,
880        kMethodNotFound = -32601,
881        kInvalidParams = -32602,
882        kInternalError = -32603,
883        kServerError = -32000,
884    };
885 
886    Status status() const { return m_status; }
887    const String& errorMessage() const { return m_errorMessage; }
888    ErrorCode errorCode() const { return m_errorCode; }
889    bool isSuccess() const { return m_status == kSuccess; }
890 
891    static DispatchResponse OK();
892    static DispatchResponse Error(const String&);
893    static DispatchResponse InternalError();
894    static DispatchResponse InvalidParams(const String&);
895    static DispatchResponse FallThrough();
896 
897private:
898    Status m_status;
899    String m_errorMessage;
900    ErrorCode m_errorCode;
901};
902 
903class  DispatcherBase {
904    PROTOCOL_DISALLOW_COPY(DispatcherBase)private: DispatcherBase(const DispatcherBase&) = delete; DispatcherBase
& operator=(const DispatcherBase&) = delete;
905public:
906    static const char kInvalidParamsString[];
907    class  WeakPtr {
908    public:
909        explicit WeakPtr(DispatcherBase*);
910        ~WeakPtr();
911        DispatcherBase* get() { return m_dispatcher; }
912        void dispose() { m_dispatcher = nullptr; }
913 
914    private:
915        DispatcherBase* m_dispatcher;
916    };
917 
918    class  Callback {
919    public:
920        Callback(std::unique_ptr<WeakPtr> backendImpl, int callId, const String& method, const ProtocolMessage& message);
921        virtual ~Callback();
922        void dispose();
923 
924    protected:
925        void sendIfActive(std::unique_ptr<protocol::DictionaryValue> partialMessage, const DispatchResponse& response);
926        void fallThroughIfActive();
927 
928    private:
929        std::unique_ptr<WeakPtr> m_backendImpl;
930        int m_callId;
931        String m_method;
932        ProtocolMessage m_message;
933    };
934 
935    explicit DispatcherBase(FrontendChannel*);
936    virtual ~DispatcherBase();
937 
938    virtual bool canDispatch(const String& method) = 0;
939    virtual void dispatch(int callId, const String& method, const ProtocolMessage& rawMessage, std::unique_ptr<protocol::DictionaryValue> messageObject) = 0;
940    FrontendChannel* channel() { return m_frontendChannel; }
941 
942    void sendResponse(int callId, const DispatchResponse&, std::unique_ptr<protocol::DictionaryValue> result);
943    void sendResponse(int callId, const DispatchResponse&);
944 
945    void reportProtocolError(int callId, DispatchResponse::ErrorCode, const String& errorMessage, ErrorSupport* errors);
946    void clearFrontend();
947 
948    std::unique_ptr<WeakPtr> weakPtr();
949 
950private:
951    FrontendChannel* m_frontendChannel;
952    std::unordered_set<WeakPtr*> m_weakPtrs;
953};
954 
955class  UberDispatcher {
956    PROTOCOL_DISALLOW_COPY(UberDispatcher)private: UberDispatcher(const UberDispatcher&) = delete; UberDispatcher
& operator=(const UberDispatcher&) = delete;
957public:
958    explicit UberDispatcher(FrontendChannel*);
959    void registerBackend(const String& name, std::unique_ptr<protocol::DispatcherBase>);
960    void setupRedirects(const std::unordered_map<String, String>&);
961    bool parseCommand(Value* message, int* callId, String* method);
962    bool canDispatch(const String& method);
963    void dispatch(int callId, const String& method, std::unique_ptr<Value> message, const ProtocolMessage& rawMessage);
964    FrontendChannel* channel() { return m_frontendChannel; }
965    virtual ~UberDispatcher();
966 
967private:
968    protocol::DispatcherBase* findDispatcher(const String& method);
969    FrontendChannel* m_frontendChannel;
970    std::unordered_map<String, String> m_redirects;
971    std::unordered_map<String, std::unique_ptr<protocol::DispatcherBase>> m_dispatchers;
972};
973 
974class InternalResponse : public Serializable {
975    PROTOCOL_DISALLOW_COPY(InternalResponse)private: InternalResponse(const InternalResponse&) = delete
; InternalResponse& operator=(const InternalResponse&
) = delete;
976public:
977    static std::unique_ptr<InternalResponse> createResponse(int callId, std::unique_ptr<Serializable> params);
978    static std::unique_ptr<InternalResponse> createNotification(const String& notification, std::unique_ptr<Serializable> params = nullptr);
979 
980    String serializeToJSON() override;
981    std::vector<uint8_t> serializeToBinary() override;
982 
983    ~InternalResponse() override {}
984 
985private:
986    InternalResponse(int callId, const String& notification, std::unique_ptr<Serializable> params);
987 
988    int m_callId;
989    String m_notification;
990    std::unique_ptr<Serializable> m_params;
991};
992 
993class InternalRawNotification : public Serializable {
994public:
995    static std::unique_ptr<InternalRawNotification> fromJSON(String notification)
996    {
997        return std::unique_ptr<InternalRawNotification>(new InternalRawNotification(std::move(notification)));
998    }
999 
1000    static std::unique_ptr<InternalRawNotification> fromBinary(std::vector<uint8_t> notification)
1001    {
1002        return std::unique_ptr<InternalRawNotification>(new InternalRawNotification(std::move(notification)));
1003    }
1004 
1005    ~InternalRawNotification() override {}
1006 
1007    String serializeToJSON() override
1008    {
1009        return std::move(m_jsonNotification);
1010    }
1011 
1012    std::vector<uint8_t> serializeToBinary() override
1013    {
1014        return std::move(m_binaryNotification);
1015    }
1016 
1017private:
1018  explicit InternalRawNotification(String notification)
1019    : m_jsonNotification(std::move(notification)) { }
1020  explicit InternalRawNotification(std::vector<uint8_t> notification)
1021    : m_binaryNotification(std::move(notification)) { }
1022 
1023  String m_jsonNotification;
1024  std::vector<uint8_t> m_binaryNotification;
1025};
1026 
1027} // namespace node
1028} // namespace inspector
1029} // namespace protocol
1030 
1031#endif // !defined(node_inspector_protocol_DispatcherBase_h)
1032 
1033 
1034// This file is generated by Parser_h.template.
1035 
1036// Copyright 2016 The Chromium Authors. All rights reserved.
1037// Use of this source code is governed by a BSD-style license that can be
1038// found in the LICENSE file.
1039 
1040#ifndef node_inspector_protocol_Parser_h
1041#define node_inspector_protocol_Parser_h
1042 
1043//#include "Forward.h"
1044//#include "Values.h"
1045 
1046namespace node {
1047namespace inspector {
1048namespace protocol {
1049 
1050 std::unique_ptr<Value> parseJSONCharacters(const uint8_t*, unsigned);
1051 std::unique_ptr<Value> parseJSONCharacters(const uint16_t*, unsigned);
1052 
1053} // namespace node
1054} // namespace inspector
1055} // namespace protocol
1056 
1057#endif // !defined(node_inspector_protocol_Parser_h)
1058 
1059 
1060// Generated by lib/encoding_h.template.
1061 
1062// Copyright 2019 The Chromium Authors. All rights reserved.
1063// Use of this source code is governed by a BSD-style license that can be
1064// found in the LICENSE file.
1065 
1066#ifndef node_inspector_protocol_encoding_h
1067#define node_inspector_protocol_encoding_h
1068 
1069#include <cstddef>
1070#include <cstdint>
1071#include <cstring>
1072#include <limits>
1073#include <memory>
1074#include <string>
1075#include <vector>
1076 
1077namespace node {
1078namespace inspector {
1079namespace protocol {
1080 
1081// ===== encoding/encoding.h =====
1082 
1083 
1084// =============================================================================
1085// span - sequence of bytes
1086// =============================================================================
1087 
1088// This template is similar to std::span, which will be included in C++20.
1089template <typename T>
1090class span {
1091 public:
1092  using index_type = size_t;
1093 
1094  span() : data_(nullptr), size_(0) {}
1095  span(const T* data, index_type size) : data_(data), size_(size) {}
1096 
1097  const T* data() const { return data_; }
1098 
1099  const T* begin() const { return data_; }
1100  const T* end() const { return data_ + size_; }
1101 
1102  const T& operator[](index_type idx) const { return data_[idx]; }
1103 
1104  span<T> subspan(index_type offset, index_type count) const {
1105    return span(data_ + offset, count);
1106  }
1107 
1108  span<T> subspan(index_type offset) const {
1109    return span(data_ + offset, size_ - offset);
1110  }
1111 
1112  bool empty() const { return size_ == 0; }
1113 
1114  index_type size() const { return size_; }
1115  index_type size_bytes() const { return size_ * sizeof(T); }
1116 
1117 private:
1118  const T* data_;
1119  index_type size_;
1120};
1121 
1122template <typename T>
1123span<T> SpanFrom(const std::vector<T>& v) {
1124  return span<T>(v.data(), v.size());
1125}
1126 
1127template <size_t N>
1128span<uint8_t> SpanFrom(const char (&str)[N]) {
1129  return span<uint8_t>(reinterpret_cast<const uint8_t*>(str), N - 1);
1130}
1131 
1132inline span<uint8_t> SpanFrom(const char* str) {
1133  return str ? span<uint8_t>(reinterpret_cast<const uint8_t*>(str), strlen(str))
1134             : span<uint8_t>();
1135}
1136 
1137inline span<uint8_t> SpanFrom(const std::string& v) {
1138  return span<uint8_t>(reinterpret_cast<const uint8_t*>(v.data()), v.size());
1139}
1140 
1141// =============================================================================
1142// Status and Error codes
1143// =============================================================================
1144enum class Error {
1145  OK = 0,
1146  // JSON parsing errors - json_parser.{h,cc}.
1147  JSON_PARSER_UNPROCESSED_INPUT_REMAINS = 0x01,
1148  JSON_PARSER_STACK_LIMIT_EXCEEDED = 0x02,
1149  JSON_PARSER_NO_INPUT = 0x03,
1150  JSON_PARSER_INVALID_TOKEN = 0x04,
1151  JSON_PARSER_INVALID_NUMBER = 0x05,
1152  JSON_PARSER_INVALID_STRING = 0x06,
1153  JSON_PARSER_UNEXPECTED_ARRAY_END = 0x07,
1154  JSON_PARSER_COMMA_OR_ARRAY_END_EXPECTED = 0x08,
1155  JSON_PARSER_STRING_LITERAL_EXPECTED = 0x09,
1156  JSON_PARSER_COLON_EXPECTED = 0x0a,
1157  JSON_PARSER_UNEXPECTED_MAP_END = 0x0b,
1158  JSON_PARSER_COMMA_OR_MAP_END_EXPECTED = 0x0c,
1159  JSON_PARSER_VALUE_EXPECTED = 0x0d,
1160 
1161  CBOR_INVALID_INT32 = 0x0e,
1162  CBOR_INVALID_DOUBLE = 0x0f,
1163  CBOR_INVALID_ENVELOPE = 0x10,
1164  CBOR_INVALID_STRING8 = 0x11,
1165  CBOR_INVALID_STRING16 = 0x12,
1166  CBOR_INVALID_BINARY = 0x13,
1167  CBOR_UNSUPPORTED_VALUE = 0x14,
1168  CBOR_NO_INPUT = 0x15,
1169  CBOR_INVALID_START_BYTE = 0x16,
1170  CBOR_UNEXPECTED_EOF_EXPECTED_VALUE = 0x17,
1171  CBOR_UNEXPECTED_EOF_IN_ARRAY = 0x18,
1172  CBOR_UNEXPECTED_EOF_IN_MAP = 0x19,
1173  CBOR_INVALID_MAP_KEY = 0x1a,
1174  CBOR_STACK_LIMIT_EXCEEDED = 0x1b,
1175  CBOR_TRAILING_JUNK = 0x1c,
1176  CBOR_MAP_START_EXPECTED = 0x1d,
1177  CBOR_MAP_STOP_EXPECTED = 0x1e,
1178  CBOR_ENVELOPE_SIZE_LIMIT_EXCEEDED = 0x1f,
1179};
1180 
1181// A status value with position that can be copied. The default status
1182// is OK. Usually, error status values should come with a valid position.
1183struct Status {
1184  static constexpr size_t npos() { return std::numeric_limits<size_t>::max(); }
1185 
1186  bool ok() const { return error == Error::OK; }
1187 
1188  Error error = Error::OK;
1189  size_t pos = npos();
1190  Status(Error error, size_t pos) : error(error), pos(pos) {}
1191  Status() = default;
1192 
1193  // Returns a 7 bit US-ASCII string, either "OK" or an error message
1194  // that includes the position.
1195  std::string ToASCIIString() const;
1196 
1197 private:
1198  std::string ToASCIIString(const char* msg) const;
1199};
1200 
1201// Handler interface for parser events emitted by a streaming parser.
1202// See cbor::NewCBOREncoder, cbor::ParseCBOR, json::NewJSONEncoder,
1203// json::ParseJSON.
1204class StreamingParserHandler {
1205 public:
1206  virtual ~StreamingParserHandler() = default;
1207  virtual void HandleMapBegin() = 0;
1208  virtual void HandleMapEnd() = 0;
1209  virtual void HandleArrayBegin() = 0;
1210  virtual void HandleArrayEnd() = 0;
1211  virtual void HandleString8(span<uint8_t> chars) = 0;
1212  virtual void HandleString16(span<uint16_t> chars) = 0;
1213  virtual void HandleBinary(span<uint8_t> bytes) = 0;
1214  virtual void HandleDouble(double value) = 0;
1215  virtual void HandleInt32(int32_t value) = 0;
1216  virtual void HandleBool(bool value) = 0;
1217  virtual void HandleNull() = 0;
1218 
1219  // The parser may send one error even after other events have already
1220  // been received. Client code is reponsible to then discard the
1221  // already processed events.
1222  // |error| must be an eror, as in, |error.is_ok()| can't be true.
1223  virtual void HandleError(Status error) = 0;
1224};
1225 
1226namespace cbor {
1227// The binary encoding for the inspector protocol follows the CBOR specification
1228// (RFC 7049). Additional constraints:
1229// - Only indefinite length maps and arrays are supported.
1230// - Maps and arrays are wrapped with an envelope, that is, a
1231//   CBOR tag with value 24 followed by a byte string specifying
1232//   the byte length of the enclosed map / array. The byte string
1233//   must use a 32 bit wide length.
1234// - At the top level, a message must be an indefinite length map
1235//   wrapped by an envelope.
1236// - Maximal size for messages is 2^32 (4 GiB).
1237// - For scalars, we support only the int32_t range, encoded as
1238//   UNSIGNED/NEGATIVE (major types 0 / 1).
1239// - UTF16 strings, including with unbalanced surrogate pairs, are encoded
1240//   as CBOR BYTE_STRING (major type 2). For such strings, the number of
1241//   bytes encoded must be even.
1242// - UTF8 strings (major type 3) are supported.
1243// - 7 bit US-ASCII strings must always be encoded as UTF8 strings, never
1244//   as UTF16 strings.
1245// - Arbitrary byte arrays, in the inspector protocol called 'binary',
1246//   are encoded as BYTE_STRING (major type 2), prefixed with a byte
1247//   indicating base64 when rendered as JSON.
1248 
1249// =============================================================================
1250// Detecting CBOR content
1251// =============================================================================
1252 
1253// The first byte for an envelope, which we use for wrapping dictionaries
1254// and arrays; and the byte that indicates a byte string with 32 bit length.
1255// These two bytes start an envelope, and thereby also any CBOR message
1256// produced or consumed by this protocol. See also |EnvelopeEncoder| below.
1257uint8_t InitialByteForEnvelope();
1258uint8_t InitialByteFor32BitLengthByteString();
1259 
1260// Checks whether |msg| is a cbor message.
1261bool IsCBORMessage(span<uint8_t> msg);
1262 
1263// =============================================================================
1264// Encoding individual CBOR items
1265// =============================================================================
1266 
1267// Some constants for CBOR tokens that only take a single byte on the wire.
1268uint8_t EncodeTrue();
1269uint8_t EncodeFalse();
1270uint8_t EncodeNull();
1271uint8_t EncodeIndefiniteLengthArrayStart();
1272uint8_t EncodeIndefiniteLengthMapStart();
1273uint8_t EncodeStop();
1274 
1275// Encodes |value| as |UNSIGNED| (major type 0) iff >= 0, or |NEGATIVE|
1276// (major type 1) iff < 0.
1277void EncodeInt32(int32_t value, std::vector<uint8_t>* out);
1278void EncodeInt32(int32_t value, std::string* out);
1279 
1280// Encodes a UTF16 string as a BYTE_STRING (major type 2). Each utf16
1281// character in |in| is emitted with most significant byte first,
1282// appending to |out|.
1283void EncodeString16(span<uint16_t> in, std::vector<uint8_t>* out);
1284void EncodeString16(span<uint16_t> in, std::string* out);
1285 
1286// Encodes a UTF8 string |in| as STRING (major type 3).
1287void EncodeString8(span<uint8_t> in, std::vector<uint8_t>* out);
1288void EncodeString8(span<uint8_t> in, std::string* out);
1289 
1290// Encodes the given |latin1| string as STRING8.
1291// If any non-ASCII character is present, it will be represented
1292// as a 2 byte UTF8 sequence.
1293void EncodeFromLatin1(span<uint8_t> latin1, std::vector<uint8_t>* out);
1294void EncodeFromLatin1(span<uint8_t> latin1, std::string* out);
1295 
1296// Encodes the given |utf16| string as STRING8 if it's entirely US-ASCII.
1297// Otherwise, encodes as STRING16.
1298void EncodeFromUTF16(span<uint16_t> utf16, std::vector<uint8_t>* out);
1299void EncodeFromUTF16(span<uint16_t> utf16, std::string* out);
1300 
1301// Encodes arbitrary binary data in |in| as a BYTE_STRING (major type 2) with
1302// definitive length, prefixed with tag 22 indicating expected conversion to
1303// base64 (see RFC 7049, Table 3 and Section 2.4.4.2).
1304void EncodeBinary(span<uint8_t> in, std::vector<uint8_t>* out);
1305void EncodeBinary(span<uint8_t> in, std::string* out);
1306 
1307// Encodes / decodes a double as Major type 7 (SIMPLE_VALUE),
1308// with additional info = 27, followed by 8 bytes in big endian.
1309void EncodeDouble(double value, std::vector<uint8_t>* out);
1310void EncodeDouble(double value, std::string* out);
1311 
1312// =============================================================================
1313// cbor::EnvelopeEncoder - for wrapping submessages
1314// =============================================================================
1315 
1316// An envelope indicates the byte length of a wrapped item.
1317// We use this for maps and array, which allows the decoder
1318// to skip such (nested) values whole sale.
1319// It's implemented as a CBOR tag (major type 6) with additional
1320// info = 24, followed by a byte string with a 32 bit length value;
1321// so the maximal structure that we can wrap is 2^32 bits long.
1322// See also: https://tools.ietf.org/html/rfc7049#section-2.4.4.1
1323class EnvelopeEncoder {
1324 public:
1325  // Emits the envelope start bytes and records the position for the
1326  // byte size in |byte_size_pos_|. Also emits empty bytes for the
1327  // byte sisze so that encoding can continue.
1328  void EncodeStart(std::vector<uint8_t>* out);
1329  void EncodeStart(std::string* out);
1330  // This records the current size in |out| at position byte_size_pos_.
1331  // Returns true iff successful.
1332  bool EncodeStop(std::vector<uint8_t>* out);
1333  bool EncodeStop(std::string* out);
1334 
1335 private:
1336  size_t byte_size_pos_ = 0;
1337};
1338 
1339// =============================================================================
1340// cbor::NewCBOREncoder - for encoding from a streaming parser
1341// =============================================================================
1342 
1343// This can be used to convert to CBOR, by passing the return value to a parser
1344// that drives it. The handler will encode into |out|, and iff an error occurs
1345// it will set |status| to an error and clear |out|. Otherwise, |status.ok()|
1346// will be |true|.
1347std::unique_ptr<StreamingParserHandler> NewCBOREncoder(
1348    std::vector<uint8_t>* out,
1349    Status* status);
1350std::unique_ptr<StreamingParserHandler> NewCBOREncoder(std::string* out,
1351                                                       Status* status);
1352 
1353// =============================================================================
1354// cbor::CBORTokenizer - for parsing individual CBOR items
1355// =============================================================================
1356 
1357// Tags for the tokens within a CBOR message that CBORTokenizer understands.
1358// Note that this is not the same terminology as the CBOR spec (RFC 7049),
1359// but rather, our adaptation. For instance, we lump unsigned and signed
1360// major type into INT32 here (and disallow values outside the int32_t range).
1361enum class CBORTokenTag {
1362  // Encountered an error in the structure of the message. Consult
1363  // status() for details.
1364  ERROR_VALUE,
1365  // Booleans and NULL.
1366  TRUE_VALUE,
1367  FALSE_VALUE,
1368  NULL_VALUE,
1369  // An int32_t (signed 32 bit integer).
1370  INT32,
1371  // A double (64 bit floating point).
1372  DOUBLE,
1373  // A UTF8 string.
1374  STRING8,
1375  // A UTF16 string.
1376  STRING16,
1377  // A binary string.
1378  BINARY,
1379  // Starts an indefinite length map; after the map start we expect
1380  // alternating keys and values, followed by STOP.
1381  MAP_START,
1382  // Starts an indefinite length array; after the array start we
1383  // expect values, followed by STOP.
1384  ARRAY_START,
1385  // Ends a map or an array.
1386  STOP,
1387  // An envelope indicator, wrapping a map or array.
1388  // Internally this carries the byte length of the wrapped
1389  // map or array. While CBORTokenizer::Next() will read / skip the entire
1390  // envelope, CBORTokenizer::EnterEnvelope() reads the tokens
1391  // inside of it.
1392  ENVELOPE,
1393  // We've reached the end there is nothing else to read.
1394  DONE,
1395};
1396 
1397// The major types from RFC 7049 Section 2.1.
1398enum class MajorType {
1399  UNSIGNED = 0,
1400  NEGATIVE = 1,
1401  BYTE_STRING = 2,
1402  STRING = 3,
1403  ARRAY = 4,
1404  MAP = 5,
1405  TAG = 6,
1406  SIMPLE_VALUE = 7
1407};
1408 
1409// CBORTokenizer segments a CBOR message, presenting the tokens therein as
1410// numbers, strings, etc. This is not a complete CBOR parser, but makes it much
1411// easier to implement one (e.g. ParseCBOR, above). It can also be used to parse
1412// messages partially.
1413class CBORTokenizer {
1414 public:
1415  explicit CBORTokenizer(span<uint8_t> bytes);
1416  ~CBORTokenizer();
1417 
1418  // Identifies the current token that we're looking at,
1419  // or ERROR_VALUE (in which ase ::Status() has details)
1420  // or DONE (if we're past the last token).
1421  CBORTokenTag TokenTag() const;
1422 
1423  // Advances to the next token.
1424  void Next();
1425  // Can only be called if TokenTag() == CBORTokenTag::ENVELOPE.
1426  // While Next() would skip past the entire envelope / what it's
1427  // wrapping, EnterEnvelope positions the cursor inside of the envelope,
1428  // letting the client explore the nested structure.
1429  void EnterEnvelope();
1430 
1431  // If TokenTag() is CBORTokenTag::ERROR_VALUE, then Status().error describes
1432  // the error more precisely; otherwise it'll be set to Error::OK.
1433  // In either case, Status().pos is the current position.
1434  struct Status Status() const;
1435 
1436  // The following methods retrieve the token values. They can only
1437  // be called if TokenTag() matches.
1438 
1439  // To be called only if ::TokenTag() == CBORTokenTag::INT32.
1440  int32_t GetInt32() const;
1441 
1442  // To be called only if ::TokenTag() == CBORTokenTag::DOUBLE.
1443  double GetDouble() const;
1444 
1445  // To be called only if ::TokenTag() == CBORTokenTag::STRING8.
1446  span<uint8_t> GetString8() const;
1447 
1448  // Wire representation for STRING16 is low byte first (little endian).
1449  // To be called only if ::TokenTag() == CBORTokenTag::STRING16.
1450  span<uint8_t> GetString16WireRep() const;
1451 
1452  // To be called only if ::TokenTag() == CBORTokenTag::BINARY.
1453  span<uint8_t> GetBinary() const;
1454 
1455  // To be called only if ::TokenTag() == CBORTokenTag::ENVELOPE.
1456  span<uint8_t> GetEnvelopeContents() const;
1457 
1458 private:
1459  void ReadNextToken(bool enter_envelope);
1460  void SetToken(CBORTokenTag token, size_t token_byte_length);
1461  void SetError(Error error);
1462 
1463  span<uint8_t> bytes_;
1464  CBORTokenTag token_tag_;
1465  struct Status status_;
1466  size_t token_byte_length_;
1467  MajorType token_start_type_;
1468  uint64_t token_start_internal_value_;
1469};
1470 
1471// =============================================================================
1472// cbor::ParseCBOR - for receiving streaming parser events for CBOR messages
1473// =============================================================================
1474 
1475// Parses a CBOR encoded message from |bytes|, sending events to
1476// |out|. If an error occurs, sends |out->HandleError|, and parsing stops.
1477// The client is responsible for discarding the already received information in
1478// that case.
1479void ParseCBOR(span<uint8_t> bytes, StreamingParserHandler* out);
1480 
1481// =============================================================================
1482// cbor::AppendString8EntryToMap - for limited in-place editing of messages
1483// =============================================================================
1484 
1485// Modifies the |cbor| message by appending a new key/value entry at the end
1486// of the map. Patches up the envelope size; Status.ok() iff successful.
1487// If not successful, |cbor| may be corrupted after this call.
1488Status AppendString8EntryToCBORMap(span<uint8_t> string8_key,
1489                                   span<uint8_t> string8_value,
1490                                   std::vector<uint8_t>* cbor);
1491Status AppendString8EntryToCBORMap(span<uint8_t> string8_key,
1492                                   span<uint8_t> string8_value,
1493                                   std::string* cbor);
1494 
1495namespace internals {  // Exposed only for writing tests.
1496size_t ReadTokenStart(span<uint8_t> bytes,
1497                      cbor::MajorType* type,
1498                      uint64_t* value);
1499 
1500void WriteTokenStart(cbor::MajorType type,
1501                     uint64_t value,
1502                     std::vector<uint8_t>* encoded);
1503void WriteTokenStart(cbor::MajorType type,
1504                     uint64_t value,
1505                     std::string* encoded);
1506}  // namespace internals
1507}  // namespace cbor
1508 
1509namespace json {
1510// Client code must provide an instance. Implementation should delegate
1511// to whatever is appropriate.
1512class Platform {
1513 public:
1514  virtual ~Platform() = default;
1515  // Parses |str| into |result|. Returns false iff there are
1516  // leftover characters or parsing errors.
1517  virtual bool StrToD(const char* str, double* result) const = 0;
1518 
1519  // Prints |value| in a format suitable for JSON.
1520  virtual std::unique_ptr<char[]> DToStr(double value) const = 0;
1521};
1522 
1523// =============================================================================
1524// json::NewJSONEncoder - for encoding streaming parser events as JSON
1525// =============================================================================
1526 
1527// Returns a handler object which will write ascii characters to |out|.
1528// |status->ok()| will be false iff the handler routine HandleError() is called.
1529// In that case, we'll stop emitting output.
1530// Except for calling the HandleError routine at any time, the client
1531// code must call the Handle* methods in an order in which they'd occur
1532// in valid JSON; otherwise we may crash (the code uses assert).
1533std::unique_ptr<StreamingParserHandler> NewJSONEncoder(
1534    const Platform* platform,
1535    std::vector<uint8_t>* out,
1536    Status* status);
1537std::unique_ptr<StreamingParserHandler> NewJSONEncoder(const Platform* platform,
1538                                                       std::string* out,
1539                                                       Status* status);
1540 
1541// =============================================================================
1542// json::ParseJSON - for receiving streaming parser events for JSON
1543// =============================================================================
1544 
1545void ParseJSON(const Platform& platform,
1546               span<uint8_t> chars,
1547               StreamingParserHandler* handler);
1548void ParseJSON(const Platform& platform,
1549               span<uint16_t> chars,
1550               StreamingParserHandler* handler);
1551 
1552// =============================================================================
1553// json::ConvertCBORToJSON, json::ConvertJSONToCBOR - for transcoding
1554// =============================================================================
1555Status ConvertCBORToJSON(const Platform& platform,
1556                         span<uint8_t> cbor,
1557                         std::string* json);
1558Status ConvertCBORToJSON(const Platform& platform,
1559                         span<uint8_t> cbor,
1560                         std::vector<uint8_t>* json);
1561Status ConvertJSONToCBOR(const Platform& platform,
1562                         span<uint8_t> json,
1563                         std::vector<uint8_t>* cbor);
1564Status ConvertJSONToCBOR(const Platform& platform,
1565                         span<uint16_t> json,
1566                         std::vector<uint8_t>* cbor);
1567Status ConvertJSONToCBOR(const Platform& platform,
1568                         span<uint8_t> json,
1569                         std::string* cbor);
1570Status ConvertJSONToCBOR(const Platform& platform,
1571                         span<uint16_t> json,
1572                         std::string* cbor);
1573}  // namespace json
1574 
1575} // namespace node
1576} // namespace inspector
1577} // namespace protocol
1578#endif // !defined(node_inspector_protocol_encoding_h)