AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
616aa01b29
skia2/src/utils/SkJSON.cpp
Mike Klein c0bd9f9fe5 rewrite includes to not need so much -Ifoo 
Current strategy: everything from the top

Things to look at first are the manual changes:

   - added tools/rewrite_includes.py
   - removed -Idirectives from BUILD.gn
   - various compile.sh simplifications
   - tweak tools/embed_resources.py
   - update gn/find_headers.py to write paths from the top
   - update gn/gn_to_bp.py SkUserConfig.h layout
     so that #include "include/config/SkUserConfig.h" always
     gets the header we want.

No-Presubmit: true
Change-Id: I73a4b181654e0e38d229bc456c0d0854bae3363e
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/209706
Commit-Queue: Mike Klein <mtklein@google.com>
Reviewed-by: Hal Canary <halcanary@google.com>
Reviewed-by: Brian Osman <brianosman@google.com>
Reviewed-by: Florin Malita <fmalita@chromium.org>
2019-04-24 16:27:11 +00:00

918 lines
28 KiB
C++
Raw Blame History

/*
* Copyright 2018 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "src/utils/SkJSON.h"
#include "include/core/SkStream.h"
#include "include/core/SkString.h"
#include "include/private/SkMalloc.h"
#include "include/utils/SkParse.h"
#include "src/utils/SkUTF.h"
#include <cmath>
#include <tuple>
#include <vector>
namespace skjson {
// #define SK_JSON_REPORT_ERRORS
static_assert( sizeof(Value) == 8, "");
static_assert(alignof(Value) == 8, "");
static constexpr size_t kRecAlign = alignof(Value);
void Value::init_tagged(Tag t) {
memset(fData8, 0, sizeof(fData8));
fData8[Value::kTagOffset] = SkTo<uint8_t>(t);
SkASSERT(this->getTag() == t);
}
// Pointer values store a type (in the upper kTagBits bits) and a pointer.
void Value::init_tagged_pointer(Tag t, void* p) {
*this->cast<uintptr_t>() = reinterpret_cast<uintptr_t>(p);
if (sizeof(Value) == sizeof(uintptr_t)) {
// For 64-bit, we rely on the pointer upper bits being unused/zero.
SkASSERT(!(fData8[kTagOffset] & kTagMask));
fData8[kTagOffset] |= SkTo<uint8_t>(t);
} else {
// For 32-bit, we need to zero-initialize the upper 32 bits
SkASSERT(sizeof(Value) == sizeof(uintptr_t) * 2);
this->cast<uintptr_t>()[kTagOffset >> 2] = 0;
fData8[kTagOffset] = SkTo<uint8_t>(t);
}
SkASSERT(this->getTag() == t);
SkASSERT(this->ptr<void>() == p);
}
NullValue::NullValue() {
this->init_tagged(Tag::kNull);
SkASSERT(this->getTag() == Tag::kNull);
}
BoolValue::BoolValue(bool b) {
this->init_tagged(Tag::kBool);
*this->cast<bool>() = b;
SkASSERT(this->getTag() == Tag::kBool);
}
NumberValue::NumberValue(int32_t i) {
this->init_tagged(Tag::kInt);
*this->cast<int32_t>() = i;
SkASSERT(this->getTag() == Tag::kInt);
}
NumberValue::NumberValue(float f) {
this->init_tagged(Tag::kFloat);
*this->cast<float>() = f;
SkASSERT(this->getTag() == Tag::kFloat);
}
// Vector recs point to externally allocated slabs with the following layout:
//
// [size_t n] [REC_0] ... [REC_n-1] [optional extra trailing storage]
//
// Long strings use extra_alloc_size == 1 to store the \0 terminator.
//
template <typename T, size_t extra_alloc_size = 0>
static void* MakeVector(const void* src, size_t size, SkArenaAlloc& alloc) {
// The Ts are already in memory, so their size should be safe.
const auto total_size = sizeof(size_t) + size * sizeof(T) + extra_alloc_size;
auto* size_ptr = reinterpret_cast<size_t*>(alloc.makeBytesAlignedTo(total_size, kRecAlign));
*size_ptr = size;
sk_careful_memcpy(size_ptr + 1, src, size * sizeof(T));
return size_ptr;
}
ArrayValue::ArrayValue(const Value* src, size_t size, SkArenaAlloc& alloc) {
this->init_tagged_pointer(Tag::kArray, MakeVector<Value>(src, size, alloc));
SkASSERT(this->getTag() == Tag::kArray);
}
// Strings have two flavors:
//
// -- short strings (len <= 7) -> these are stored inline, in the record
// (one byte reserved for null terminator/type):
//
// [str] [\0]|[max_len - actual_len]
//
// Storing [max_len - actual_len] allows the 'len' field to double-up as a
// null terminator when size == max_len (this works 'cause kShortString == 0).
//
// -- long strings (len > 7) -> these are externally allocated vectors (VectorRec<char>).
//
// The string data plus a null-char terminator are copied over.
//
namespace {
// An internal string builder with a fast 8 byte short string load path
// (for the common case where the string is not at the end of the stream).
class FastString final : public Value {
public:
FastString(const char* src, size_t size, const char* eos, SkArenaAlloc& alloc) {
SkASSERT(src <= eos);
if (size > kMaxInlineStringSize) {
this->initLongString(src, size, alloc);
SkASSERT(this->getTag() == Tag::kString);
return;
}
static_assert(static_cast<uint8_t>(Tag::kShortString) == 0, "please don't break this");
static_assert(sizeof(Value) == 8, "");
// TODO: LIKELY
if (src + 7 <= eos) {
this->initFastShortString(src, size);
} else {
this->initShortString(src, size);
}
SkASSERT(this->getTag() == Tag::kShortString);
}
private:
static constexpr size_t kMaxInlineStringSize = sizeof(Value) - 1;
void initLongString(const char* src, size_t size, SkArenaAlloc& alloc) {
SkASSERT(size > kMaxInlineStringSize);
this->init_tagged_pointer(Tag::kString, MakeVector<char, 1>(src, size, alloc));
auto* data = this->cast<VectorValue<char, Value::Type::kString>>()->begin();
const_cast<char*>(data)[size] = '\0';
}
void initShortString(const char* src, size_t size) {
SkASSERT(size <= kMaxInlineStringSize);
this->init_tagged(Tag::kShortString);
sk_careful_memcpy(this->cast<char>(), src, size);
// Null terminator provided by init_tagged() above (fData8 is zero-initialized).
}
void initFastShortString(const char* src, size_t size) {
SkASSERT(size <= kMaxInlineStringSize);
// Load 8 chars and mask out the tag and \0 terminator.
uint64_t* s64 = this->cast<uint64_t>();
memcpy(s64, src, 8);
#if defined(SK_CPU_LENDIAN)
*s64 &= 0x00ffffffffffffffULL >> ((kMaxInlineStringSize - size) * 8);
#else
static_assert(false, "Big-endian builds are not supported at this time.");
#endif
}
};
} // namespace
StringValue::StringValue(const char* src, size_t size, SkArenaAlloc& alloc) {
new (this) FastString(src, size, src, alloc);
}
ObjectValue::ObjectValue(const Member* src, size_t size, SkArenaAlloc& alloc) {
this->init_tagged_pointer(Tag::kObject, MakeVector<Member>(src, size, alloc));
SkASSERT(this->getTag() == Tag::kObject);
}
// Boring public Value glue.
static int inline_strcmp(const char a[], const char b[]) {
for (;;) {
char c = *a++;
if (c == 0) {
break;
}
if (c != *b++) {
return 1;
}
}
return *b != 0;
}
const Value& ObjectValue::operator[](const char* key) const {
// Reverse search for duplicates resolution (policy: return last).
const auto* begin = this->begin();
const auto* member = this->end();
while (member > begin) {
--member;
if (0 == inline_strcmp(key, member->fKey.as<StringValue>().begin())) {
return member->fValue;
}
}
static const Value g_null = NullValue();
return g_null;
}
namespace {
// Lexer/parser inspired by rapidjson [1], sajson [2] and pjson [3].
//
// [1] https://github.com/Tencent/rapidjson/
// [2] https://github.com/chadaustin/sajson
// [3] https://pastebin.com/hnhSTL3h
// bit 0 (0x01) - plain ASCII string character
// bit 1 (0x02) - whitespace
// bit 2 (0x04) - string terminator (" \\ \0 [control chars] **AND } ]** <- see matchString notes)
// bit 3 (0x08) - 0-9
// bit 4 (0x10) - 0-9 e E .
// bit 5 (0x20) - scope terminator (} ])
static constexpr uint8_t g_token_flags[256] = {
// 0 1 2 3 4 5 6 7 8 9 A B C D E F
4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 6, 4, 4, 6, 4, 4, // 0
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, // 1
3, 1, 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0x11,1, // 2
0x19,0x19,0x19,0x19,0x19,0x19,0x19,0x19, 0x19,0x19, 1, 1, 1, 1, 1, 1, // 3
1, 1, 1, 1, 1, 0x11,1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 4
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4,0x25, 1, 1, // 5
1, 1, 1, 1, 1, 0x11,1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 6
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,0x25, 1, 1, // 7
// 128-255
0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0
};
static inline bool is_ws(char c) { return g_token_flags[static_cast<uint8_t>(c)] & 0x02; }
static inline bool is_eostring(char c) { return g_token_flags[static_cast<uint8_t>(c)] & 0x04; }
static inline bool is_digit(char c) { return g_token_flags[static_cast<uint8_t>(c)] & 0x08; }
static inline bool is_numeric(char c) { return g_token_flags[static_cast<uint8_t>(c)] & 0x10; }
static inline bool is_eoscope(char c) { return g_token_flags[static_cast<uint8_t>(c)] & 0x20; }
static inline const char* skip_ws(const char* p) {
while (is_ws(*p)) ++p;
return p;
}
static inline float pow10(int32_t exp) {
static constexpr float g_pow10_table[63] =
{
1.e-031f, 1.e-030f, 1.e-029f, 1.e-028f, 1.e-027f, 1.e-026f, 1.e-025f, 1.e-024f,
1.e-023f, 1.e-022f, 1.e-021f, 1.e-020f, 1.e-019f, 1.e-018f, 1.e-017f, 1.e-016f,
1.e-015f, 1.e-014f, 1.e-013f, 1.e-012f, 1.e-011f, 1.e-010f, 1.e-009f, 1.e-008f,
1.e-007f, 1.e-006f, 1.e-005f, 1.e-004f, 1.e-003f, 1.e-002f, 1.e-001f, 1.e+000f,
1.e+001f, 1.e+002f, 1.e+003f, 1.e+004f, 1.e+005f, 1.e+006f, 1.e+007f, 1.e+008f,
1.e+009f, 1.e+010f, 1.e+011f, 1.e+012f, 1.e+013f, 1.e+014f, 1.e+015f, 1.e+016f,
1.e+017f, 1.e+018f, 1.e+019f, 1.e+020f, 1.e+021f, 1.e+022f, 1.e+023f, 1.e+024f,
1.e+025f, 1.e+026f, 1.e+027f, 1.e+028f, 1.e+029f, 1.e+030f, 1.e+031f
};
static constexpr int32_t k_exp_offset = SK_ARRAY_COUNT(g_pow10_table) / 2;
// We only support negative exponents for now.
SkASSERT(exp <= 0);
return (exp >= -k_exp_offset) ? g_pow10_table[exp + k_exp_offset]
: std::pow(10.0f, static_cast<float>(exp));
}
class DOMParser {
public:
explicit DOMParser(SkArenaAlloc& alloc)
: fAlloc(alloc) {
fValueStack.reserve(kValueStackReserve);
fUnescapeBuffer.reserve(kUnescapeBufferReserve);
}
const Value parse(const char* p, size_t size) {
if (!size) {
return this->error(NullValue(), p, "invalid empty input");
}
const char* p_stop = p + size - 1;
// We're only checking for end-of-stream on object/array close('}',']'),
// so we must trim any whitespace from the buffer tail.
while (p_stop > p && is_ws(*p_stop)) --p_stop;
SkASSERT(p_stop >= p && p_stop < p + size);
if (!is_eoscope(*p_stop)) {
return this->error(NullValue(), p_stop, "invalid top-level value");
}
p = skip_ws(p);
switch (*p) {
case '{':
goto match_object;
case '[':
goto match_array;
default:
return this->error(NullValue(), p, "invalid top-level value");
}
match_object:
SkASSERT(*p == '{');
p = skip_ws(p + 1);
this->pushObjectScope();
if (*p == '}') goto pop_object;
// goto match_object_key;
match_object_key:
p = skip_ws(p);
if (*p != '"') return this->error(NullValue(), p, "expected object key");
p = this->matchString(p, p_stop, [this](const char* key, size_t size, const char* eos) {
this->pushObjectKey(key, size, eos);
});
if (!p) return NullValue();
p = skip_ws(p);
if (*p != ':') return this->error(NullValue(), p, "expected ':' separator");
++p;
// goto match_value;
match_value:
p = skip_ws(p);
switch (*p) {
case '\0':
return this->error(NullValue(), p, "unexpected input end");
case '"':
p = this->matchString(p, p_stop, [this](const char* str, size_t size, const char* eos) {
this->pushString(str, size, eos);
});
break;
case '[':
goto match_array;
case 'f':
p = this->matchFalse(p);
break;
case 'n':
p = this->matchNull(p);
break;
case 't':
p = this->matchTrue(p);
break;
case '{':
goto match_object;
default:
p = this->matchNumber(p);
break;
}
if (!p) return NullValue();
// goto match_post_value;
match_post_value:
SkASSERT(!this->inTopLevelScope());
p = skip_ws(p);
switch (*p) {
case ',':
++p;
if (this->inObjectScope()) {
goto match_object_key;
} else {
SkASSERT(this->inArrayScope());
goto match_value;
}
case ']':
goto pop_array;
case '}':
goto pop_object;
default:
return this->error(NullValue(), p - 1, "unexpected value-trailing token");
}
// unreachable
SkASSERT(false);
pop_object:
SkASSERT(*p == '}');
if (this->inArrayScope()) {
return this->error(NullValue(), p, "unexpected object terminator");
}
this->popObjectScope();
// goto pop_common
pop_common:
SkASSERT(is_eoscope(*p));
if (this->inTopLevelScope()) {
SkASSERT(fValueStack.size() == 1);
// Success condition: parsed the top level element and reached the stop token.
return p == p_stop
? fValueStack.front()
: this->error(NullValue(), p + 1, "trailing root garbage");
}
if (p == p_stop) {
return this->error(NullValue(), p, "unexpected end-of-input");
}
++p;
goto match_post_value;
match_array:
SkASSERT(*p == '[');
p = skip_ws(p + 1);
this->pushArrayScope();
if (*p != ']') goto match_value;
// goto pop_array;
pop_array:
SkASSERT(*p == ']');
if (this->inObjectScope()) {
return this->error(NullValue(), p, "unexpected array terminator");
}
this->popArrayScope();
goto pop_common;
SkASSERT(false);
return NullValue();
}
std::tuple<const char*, const SkString> getError() const {
return std::make_tuple(fErrorToken, fErrorMessage);
}
private:
SkArenaAlloc& fAlloc;
// Pending values stack.
static constexpr size_t kValueStackReserve = 256;
std::vector<Value> fValueStack;
// String unescape buffer.
static constexpr size_t kUnescapeBufferReserve = 512;
std::vector<char> fUnescapeBuffer;
// Tracks the current object/array scope, as an index into fStack:
//
// - for objects: fScopeIndex = (index of first value in scope)
// - for arrays : fScopeIndex = -(index of first value in scope)
//
// fScopeIndex == 0 IFF we are at the top level (no current/active scope).
intptr_t fScopeIndex = 0;
// Error reporting.
const char* fErrorToken = nullptr;
SkString fErrorMessage;
bool inTopLevelScope() const { return fScopeIndex == 0; }
bool inObjectScope() const { return fScopeIndex > 0; }
bool inArrayScope() const { return fScopeIndex < 0; }
// Helper for masquerading raw primitive types as Values (bypassing tagging, etc).
template <typename T>
class RawValue final : public Value {
public:
explicit RawValue(T v) {
static_assert(sizeof(T) <= sizeof(Value), "");
*this->cast<T>() = v;
}
T operator *() const { return *this->cast<T>(); }
};
template <typename VectorT>
void popScopeAsVec(size_t scope_start) {
SkASSERT(scope_start > 0);
SkASSERT(scope_start <= fValueStack.size());
using T = typename VectorT::ValueT;
static_assert( sizeof(T) >= sizeof(Value), "");
static_assert( sizeof(T) % sizeof(Value) == 0, "");
static_assert(alignof(T) == alignof(Value), "");
const auto scope_count = fValueStack.size() - scope_start,
count = scope_count / (sizeof(T) / sizeof(Value));
SkASSERT(scope_count % (sizeof(T) / sizeof(Value)) == 0);
const auto* begin = reinterpret_cast<const T*>(fValueStack.data() + scope_start);
// Restore the previous scope index from saved placeholder value,
// and instantiate as a vector of values in scope.
auto& placeholder = fValueStack[scope_start - 1];
fScopeIndex = *static_cast<RawValue<intptr_t>&>(placeholder);
placeholder = VectorT(begin, count, fAlloc);
// Drop the (consumed) values in scope.
fValueStack.resize(scope_start);
}
void pushObjectScope() {
// Save a scope index now, and then later we'll overwrite this value as the Object itself.
fValueStack.push_back(RawValue<intptr_t>(fScopeIndex));
// New object scope.
fScopeIndex = SkTo<intptr_t>(fValueStack.size());
}
void popObjectScope() {
SkASSERT(this->inObjectScope());
this->popScopeAsVec<ObjectValue>(SkTo<size_t>(fScopeIndex));
SkDEBUGCODE(
const auto& obj = fValueStack.back().as<ObjectValue>();
SkASSERT(obj.is<ObjectValue>());
for (const auto& member : obj) {
SkASSERT(member.fKey.is<StringValue>());
}
)
}
void pushArrayScope() {
// Save a scope index now, and then later we'll overwrite this value as the Array itself.
fValueStack.push_back(RawValue<intptr_t>(fScopeIndex));
// New array scope.
fScopeIndex = -SkTo<intptr_t>(fValueStack.size());
}
void popArrayScope() {
SkASSERT(this->inArrayScope());
this->popScopeAsVec<ArrayValue>(SkTo<size_t>(-fScopeIndex));
SkDEBUGCODE(
const auto& arr = fValueStack.back().as<ArrayValue>();
SkASSERT(arr.is<ArrayValue>());
)
}
void pushObjectKey(const char* key, size_t size, const char* eos) {
SkASSERT(this->inObjectScope());
SkASSERT(fValueStack.size() >= SkTo<size_t>(fScopeIndex));
SkASSERT(!((fValueStack.size() - SkTo<size_t>(fScopeIndex)) & 1));
this->pushString(key, size, eos);
}
void pushTrue() {
fValueStack.push_back(BoolValue(true));
}
void pushFalse() {
fValueStack.push_back(BoolValue(false));
}
void pushNull() {
fValueStack.push_back(NullValue());
}
void pushString(const char* s, size_t size, const char* eos) {
fValueStack.push_back(FastString(s, size, eos, fAlloc));
}
void pushInt32(int32_t i) {
fValueStack.push_back(NumberValue(i));
}
void pushFloat(float f) {
fValueStack.push_back(NumberValue(f));
}
template <typename T>
T error(T&& ret_val, const char* p, const char* msg) {
#if defined(SK_JSON_REPORT_ERRORS)
fErrorToken = p;
fErrorMessage.set(msg);
#endif
return ret_val;
}
const char* matchTrue(const char* p) {
SkASSERT(p[0] == 't');
if (p[1] == 'r' && p[2] == 'u' && p[3] == 'e') {
this->pushTrue();
return p + 4;
}
return this->error(nullptr, p, "invalid token");
}
const char* matchFalse(const char* p) {
SkASSERT(p[0] == 'f');
if (p[1] == 'a' && p[2] == 'l' && p[3] == 's' && p[4] == 'e') {
this->pushFalse();
return p + 5;
}
return this->error(nullptr, p, "invalid token");
}
const char* matchNull(const char* p) {
SkASSERT(p[0] == 'n');
if (p[1] == 'u' && p[2] == 'l' && p[3] == 'l') {
this->pushNull();
return p + 4;
}
return this->error(nullptr, p, "invalid token");
}
const std::vector<char>* unescapeString(const char* begin, const char* end) {
fUnescapeBuffer.clear();
for (const auto* p = begin; p != end; ++p) {
if (*p != '\\') {
fUnescapeBuffer.push_back(*p);
continue;
}
if (++p == end) {
return nullptr;
}
switch (*p) {
case '"': fUnescapeBuffer.push_back( '"'); break;
case '\\': fUnescapeBuffer.push_back('\\'); break;
case '/': fUnescapeBuffer.push_back( '/'); break;
case 'b': fUnescapeBuffer.push_back('\b'); break;
case 'f': fUnescapeBuffer.push_back('\f'); break;
case 'n': fUnescapeBuffer.push_back('\n'); break;
case 'r': fUnescapeBuffer.push_back('\r'); break;
case 't': fUnescapeBuffer.push_back('\t'); break;
case 'u': {
if (p + 4 >= end) {
return nullptr;
}
uint32_t hexed;
const char hex_str[] = {p[1], p[2], p[3], p[4], '\0'};
const auto* eos = SkParse::FindHex(hex_str, &hexed);
if (!eos || *eos) {
return nullptr;
}
char utf8[SkUTF::kMaxBytesInUTF8Sequence];
const auto utf8_len = SkUTF::ToUTF8(SkTo<SkUnichar>(hexed), utf8);
fUnescapeBuffer.insert(fUnescapeBuffer.end(), utf8, utf8 + utf8_len);
p += 4;
} break;
default: return nullptr;
}
}
return &fUnescapeBuffer;
}
template <typename MatchFunc>
const char* matchString(const char* p, const char* p_stop, MatchFunc&& func) {
SkASSERT(*p == '"');
const auto* s_begin = p + 1;
bool requires_unescape = false;
do {
// Consume string chars.
// This is the fast path, and hopefully we only hit it once then quick-exit below.
for (p = p + 1; !is_eostring(*p); ++p);
if (*p == '"') {
// Valid string found.
if (!requires_unescape) {
func(s_begin, p - s_begin, p_stop);
} else {
// Slow unescape. We could avoid this extra copy with some effort,
// but in practice escaped strings should be rare.
const auto* buf = this->unescapeString(s_begin, p);
if (!buf) {
break;
}
SkASSERT(!buf->empty());
func(buf->data(), buf->size(), buf->data() + buf->size() - 1);
}
return p + 1;
}
if (*p == '\\') {
requires_unescape = true;
++p;
continue;
}
// End-of-scope chars are special: we use them to tag the end of the input.
// Thus they cannot be consumed indiscriminately -- we need to check if we hit the
// end of the input. To that effect, we treat them as string terminators above,
// then we catch them here.
if (is_eoscope(*p)) {
continue;
}
// Invalid/unexpected char.
break;
} while (p != p_stop);
// Premature end-of-input, or illegal string char.
return this->error(nullptr, s_begin - 1, "invalid string");
}
const char* matchFastFloatDecimalPart(const char* p, int sign, float f, int exp) {
SkASSERT(exp <= 0);
for (;;) {
if (!is_digit(*p)) break;
f = f * 10.f + (*p++ - '0'); --exp;
if (!is_digit(*p)) break;
f = f * 10.f + (*p++ - '0'); --exp;
}
const auto decimal_scale = pow10(exp);
if (is_numeric(*p) || !decimal_scale) {
SkASSERT((*p == '.' || *p == 'e' || *p == 'E') || !decimal_scale);
// Malformed input, or an (unsupported) exponent, or a collapsed decimal factor.
return nullptr;
}
this->pushFloat(sign * f * decimal_scale);
return p;
}
const char* matchFastFloatPart(const char* p, int sign, float f) {
for (;;) {
if (!is_digit(*p)) break;
f = f * 10.f + (*p++ - '0');
if (!is_digit(*p)) break;
f = f * 10.f + (*p++ - '0');
}
if (!is_numeric(*p)) {
// Matched (integral) float.
this->pushFloat(sign * f);
return p;
}
return (*p == '.') ? this->matchFastFloatDecimalPart(p + 1, sign, f, 0)
: nullptr;
}
const char* matchFast32OrFloat(const char* p) {
int sign = 1;
if (*p == '-') {
sign = -1;
++p;
}
const auto* digits_start = p;
int32_t n32 = 0;
// This is the largest absolute int32 value we can handle before
// risking overflow *on the next digit* (214748363).
static constexpr int32_t kMaxInt32 = (std::numeric_limits<int32_t>::max() - 9) / 10;
if (is_digit(*p)) {
n32 = (*p++ - '0');
for (;;) {
if (!is_digit(*p) || n32 > kMaxInt32) break;
n32 = n32 * 10 + (*p++ - '0');
}
}
if (!is_numeric(*p)) {
// Did we actually match any digits?
if (p > digits_start) {
this->pushInt32(sign * n32);
return p;
}
return nullptr;
}
if (*p == '.') {
const auto* decimals_start = ++p;
int exp = 0;
for (;;) {
if (!is_digit(*p) || n32 > kMaxInt32) break;
n32 = n32 * 10 + (*p++ - '0'); --exp;
if (!is_digit(*p) || n32 > kMaxInt32) break;
n32 = n32 * 10 + (*p++ - '0'); --exp;
}
if (!is_numeric(*p)) {
// Did we actually match any digits?
if (p > decimals_start) {
this->pushFloat(sign * n32 * pow10(exp));
return p;
}
return nullptr;
}
if (n32 > kMaxInt32) {
// we ran out on n32 bits
return this->matchFastFloatDecimalPart(p, sign, n32, exp);
}
}
return this->matchFastFloatPart(p, sign, n32);
}
const char* matchNumber(const char* p) {
if (const auto* fast = this->matchFast32OrFloat(p)) return fast;
// slow fallback
char* matched;
float f = strtof(p, &matched);
if (matched > p) {
this->pushFloat(f);
return matched;
}
return this->error(nullptr, p, "invalid numeric token");
}
};
void Write(const Value& v, SkWStream* stream) {
switch (v.getType()) {
case Value::Type::kNull:
stream->writeText("null");
break;
case Value::Type::kBool:
stream->writeText(*v.as<BoolValue>() ? "true" : "false");
break;
case Value::Type::kNumber:
stream->writeScalarAsText(*v.as<NumberValue>());
break;
case Value::Type::kString:
stream->writeText("\"");
stream->writeText(v.as<StringValue>().begin());
stream->writeText("\"");
break;
case Value::Type::kArray: {
const auto& array = v.as<ArrayValue>();
stream->writeText("[");
bool first_value = true;
for (const auto& v : array) {
if (!first_value) stream->writeText(",");
Write(v, stream);
first_value = false;
}
stream->writeText("]");
break;
}
case Value::Type::kObject:
const auto& object = v.as<ObjectValue>();
stream->writeText("{");
bool first_member = true;
for (const auto& member : object) {
SkASSERT(member.fKey.getType() == Value::Type::kString);
if (!first_member) stream->writeText(",");
Write(member.fKey, stream);
stream->writeText(":");
Write(member.fValue, stream);
first_member = false;
}
stream->writeText("}");
break;
}
}
} // namespace
SkString Value::toString() const {
SkDynamicMemoryWStream wstream;
Write(*this, &wstream);
const auto data = wstream.detachAsData();
// TODO: is there a better way to pass data around without copying?
return SkString(static_cast<const char*>(data->data()), data->size());
}
static constexpr size_t kMinChunkSize = 4096;
DOM::DOM(const char* data, size_t size)
: fAlloc(kMinChunkSize) {
DOMParser parser(fAlloc);
fRoot = parser.parse(data, size);
}
void DOM::write(SkWStream* stream) const {
Write(fRoot, stream);
}
} // namespace skjson
Reference in New Issue View Git Blame Copy Permalink