/tmp/bitcoin/src/univalue/lib/univalue_read.cpp

Source
// Copyright 2014 BitPay Inc.
// Copyright (c) 2015-present The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or https://opensource.org/licenses/mit-license.php.

#include <univalue.h>
#include <univalue_utffilter.h>

#include <cstdint>
#include <cstring>
#include <string>
#include <string_view>
#include <utility>
#include <vector>

/*
 * According to stackexchange, the original json test suite wanted
 * to limit depth to 22.  Widely-deployed PHP bails at depth 512,
 * so we will follow PHP's lead, which should be more than sufficient
 * (further stackexchange comments indicate depth > 32 rarely occurs).
 */
static constexpr size_t MAX_JSON_DEPTH = 512;

static bool json_isdigit(int ch)
{
    return ((ch >= '0') && (ch <= '9'));
}

// convert hexadecimal string to unsigned integer
static const char *hatoui(const char *first, const char *last,
                          unsigned int& out)
{
    unsigned int result = 0;
    for (; first != last; ++first)
    {
        int digit;
        if (json_isdigit(*first))
            digit = *first - '0';

        else if (*first >= 'a' && *first <= 'f')
            digit = *first - 'a' + 10;

        else if (*first >= 'A' && *first <= 'F')
            digit = *first - 'A' + 10;

        else
            break;

        result = 16 * result + digit;
    }
    out = result;

    return first;
}

enum jtokentype getJsonToken(std::string& tokenVal, unsigned int& consumed,
                            const char *raw, const char *end)
{
    tokenVal.clear();
    consumed = 0;

    const char *rawStart = raw;

    while (raw < end && (json_isspace(*raw)))          // skip whitespace
        raw++;

    if (raw >= end)
        return JTOK_NONE;

    switch (*raw) {

    case '{':
        raw++;
        consumed = (raw - rawStart);
        return JTOK_OBJ_OPEN;
    case '}':
        raw++;
        consumed = (raw - rawStart);
        return JTOK_OBJ_CLOSE;
    case '[':
        raw++;
        consumed = (raw - rawStart);
        return JTOK_ARR_OPEN;
    case ']':
        raw++;
        consumed = (raw - rawStart);
        return JTOK_ARR_CLOSE;

    case ':':
        raw++;
        consumed = (raw - rawStart);
        return JTOK_COLON;
    case ',':
        raw++;
        consumed = (raw - rawStart);
        return JTOK_COMMA;

    case 'n':
    case 't':
    case 'f':
        if (!strncmp(raw, "null", 4)) {
            raw += 4;
            consumed = (raw - rawStart);
            return JTOK_KW_NULL;
        } else if (!strncmp(raw, "true", 4)) {
            raw += 4;
            consumed = (raw - rawStart);
            return JTOK_KW_TRUE;
        } else if (!strncmp(raw, "false", 5)) {
            raw += 5;
            consumed = (raw - rawStart);
            return JTOK_KW_FALSE;
        } else
            return JTOK_ERR;

    case '-':
    case '0':
    case '1':
    case '2':
    case '3':
    case '4':
    case '5':
    case '6':
    case '7':
    case '8':
    case '9': {
        // part 1: int
        std::string numStr;

        const char *first = raw;

        const char *firstDigit = first;
        if (!json_isdigit(*firstDigit))
            firstDigit++;
        if ((*firstDigit == '0') && json_isdigit(firstDigit[1]))
            return JTOK_ERR;

        numStr += *raw;                       // copy first char
        raw++;

        if ((*first == '-') && (raw < end) && (!json_isdigit(*raw)))
            return JTOK_ERR;

        while (raw < end && json_isdigit(*raw)) {  // copy digits
            numStr += *raw;
            raw++;
        }

        // part 2: frac
        if (raw < end && *raw == '.') {
            numStr += *raw;                   // copy .
            raw++;

            if (raw >= end || !json_isdigit(*raw))
                return JTOK_ERR;
            while (raw < end && json_isdigit(*raw)) { // copy digits
                numStr += *raw;
                raw++;
            }
        }

        // part 3: exp
        if (raw < end && (*raw == 'e' || *raw == 'E')) {
            numStr += *raw;                   // copy E
            raw++;

            if (raw < end && (*raw == '-' || *raw == '+')) { // copy +/-
                numStr += *raw;
                raw++;
            }

            if (raw >= end || !json_isdigit(*raw))
                return JTOK_ERR;
            while (raw < end && json_isdigit(*raw)) { // copy digits
                numStr += *raw;
                raw++;
            }
        }

        tokenVal = numStr;
        consumed = (raw - rawStart);
        return JTOK_NUMBER;
        }

    case '"': {
        raw++;                                // skip "

        std::string valStr;
        JSONUTF8StringFilter writer(valStr);

        while (true) {
            if (raw >= end || (unsigned char)*raw < 0x20)
                return JTOK_ERR;

            else if (*raw == '\\') {
                raw++;                        // skip backslash

                if (raw >= end)
                    return JTOK_ERR;

                switch (*raw) {
                case '"':  writer.push_back('\"'); break;
                case '\\': writer.push_back('\\'); break;
                case '/':  writer.push_back('/'); break;
                case 'b':  writer.push_back('\b'); break;
                case 'f':  writer.push_back('\f'); break;
                case 'n':  writer.push_back('\n'); break;
                case 'r':  writer.push_back('\r'); break;
                case 't':  writer.push_back('\t'); break;

                case 'u': {
                    unsigned int codepoint;
                    if (raw + 1 + 4 >= end ||
                        hatoui(raw + 1, raw + 1 + 4, codepoint) !=
                               raw + 1 + 4)
                        return JTOK_ERR;
                    writer.push_back_u(codepoint);
                    raw += 4;
                    break;
                    }
                default:
                    return JTOK_ERR;

                }

                raw++;                        // skip esc'd char
            }

            else if (*raw == '"') {
                raw++;                        // skip "
                break;                        // stop scanning
            }

            else {
                writer.push_back(static_cast<unsigned char>(*raw));
                raw++;
            }
        }

        if (!writer.finalize())
            return JTOK_ERR;
        tokenVal = valStr;
        consumed = (raw - rawStart);
        return JTOK_STRING;
        }

    default:
        return JTOK_ERR;
    }
}

enum expect_bits : unsigned {
    EXP_OBJ_NAME = (1U << 0),
    EXP_COLON = (1U << 1),
    EXP_ARR_VALUE = (1U << 2),
    EXP_VALUE = (1U << 3),
    EXP_NOT_VALUE = (1U << 4),
};

#define expect(bit) (expectMask & (EXP_##bit))
#define setExpect(bit) (expectMask |= EXP_##bit)
#define clearExpect(bit) (expectMask &= ~EXP_##bit)

bool UniValue::read(std::string_view json)
{
    UniValue parsed;
    if (!parsed.read_impl(json)) {
        setNull();
        return false;
    }
    *this = std::move(parsed);
    return true;
}

bool UniValue::read_impl(std::string_view str_in)
{
    clear();

    uint32_t expectMask = 0;
    std::vector<UniValue*> stack;

    std::string tokenVal;
    unsigned int consumed;
    enum jtokentype tok = JTOK_NONE;
    enum jtokentype last_tok = JTOK_NONE;
    const char* raw{str_in.data()};
    const char* end{raw + str_in.size()};
    do {
        last_tok = tok;

        tok = getJsonToken(tokenVal, consumed, raw, end);
        if (tok == JTOK_NONE || tok == JTOK_ERR)
            return false;
        raw += consumed;

        bool isValueOpen = jsonTokenIsValue(tok) ||
            tok == JTOK_OBJ_OPEN || tok == JTOK_ARR_OPEN;

        if (expect(VALUE)) {
            if (!isValueOpen)
                return false;
            clearExpect(VALUE);

        } else if (expect(ARR_VALUE)) {
            bool isArrValue = isValueOpen || (tok == JTOK_ARR_CLOSE);
            if (!isArrValue)
                return false;

            clearExpect(ARR_VALUE);

        } else if (expect(OBJ_NAME)) {
            bool isObjName = (tok == JTOK_OBJ_CLOSE || tok == JTOK_STRING);
            if (!isObjName)
                return false;

        } else if (expect(COLON)) {
            if (tok != JTOK_COLON)
                return false;
            clearExpect(COLON);

        } else if (!expect(COLON) && (tok == JTOK_COLON)) {
            return false;
        }

        if (expect(NOT_VALUE)) {
            if (isValueOpen)
                return false;
            clearExpect(NOT_VALUE);
        }

        switch (tok) {

        case JTOK_OBJ_OPEN:
        case JTOK_ARR_OPEN: {
            VType utyp = (tok == JTOK_OBJ_OPEN ? VOBJ : VARR);
            if (!stack.size()) {
                if (utyp == VOBJ)
                    setObject();
                else
                    setArray();
                stack.push_back(this);
            } else {
                UniValue tmpVal(utyp);
                UniValue *top = stack.back();
                top->values.push_back(tmpVal);

                UniValue *newTop = &(top->values.back());
                stack.push_back(newTop);
            }

            if (stack.size() > MAX_JSON_DEPTH)
                return false;

            if (utyp == VOBJ)
                setExpect(OBJ_NAME);
            else
                setExpect(ARR_VALUE);
            break;
            }

        case JTOK_OBJ_CLOSE:
        case JTOK_ARR_CLOSE: {
            if (!stack.size() || (last_tok == JTOK_COMMA))
                return false;

            VType utyp = (tok == JTOK_OBJ_CLOSE ? VOBJ : VARR);
            UniValue *top = stack.back();
            if (utyp != top->getType())
                return false;

            stack.pop_back();
            clearExpect(OBJ_NAME);
            setExpect(NOT_VALUE);
            break;
            }

        case JTOK_COLON: {
            if (!stack.size())
                return false;

            UniValue *top = stack.back();
            if (top->getType() != VOBJ)
                return false;

            setExpect(VALUE);
            break;
            }

        case JTOK_COMMA: {
            if (!stack.size() ||
                (last_tok == JTOK_COMMA) || (last_tok == JTOK_ARR_OPEN))
                return false;

            UniValue *top = stack.back();
            if (top->getType() == VOBJ)
                setExpect(OBJ_NAME);
            else
                setExpect(ARR_VALUE);
            break;
            }

        case JTOK_KW_NULL:
        case JTOK_KW_TRUE:
        case JTOK_KW_FALSE: {
            UniValue tmpVal;
            switch (tok) {
            case JTOK_KW_NULL:
                // do nothing more
                break;
            case JTOK_KW_TRUE:
                tmpVal.setBool(true);
                break;
            case JTOK_KW_FALSE:
                tmpVal.setBool(false);
                break;
            default: /* impossible */ break;
            }

            if (!stack.size()) {
                *this = tmpVal;
                break;
            }

            UniValue *top = stack.back();
            top->values.push_back(tmpVal);

            setExpect(NOT_VALUE);
            break;
            }

        case JTOK_NUMBER: {
            UniValue tmpVal(VNUM, tokenVal);
            if (!stack.size()) {
                *this = tmpVal;
                break;
            }

            UniValue *top = stack.back();
            top->values.push_back(tmpVal);

            setExpect(NOT_VALUE);
            break;
            }

        case JTOK_STRING: {
            if (expect(OBJ_NAME)) {
                UniValue *top = stack.back();
                top->keys.push_back(tokenVal);
                clearExpect(OBJ_NAME);
                setExpect(COLON);
            } else {
                UniValue tmpVal(VSTR, tokenVal);
                if (!stack.size()) {
                    *this = tmpVal;
                    break;
                }
                UniValue *top = stack.back();
                top->values.push_back(tmpVal);
            }

            setExpect(NOT_VALUE);
            break;
            }

        default:
            return false;
        }
    } while (!stack.empty ());

    /* Check that nothing follows the initial construct (parsed above).  */
    tok = getJsonToken(tokenVal, consumed, raw, end);
    if (tok != JTOK_NONE)
        return false;

    return true;
}

Coverage Report

Created: 2026-09-14 20:36

Line	Count	Source
1		// Copyright 2014 BitPay Inc.
2		// Copyright (c) 2015-present The Bitcoin Core developers
3		// Distributed under the MIT software license, see the accompanying
4		// file COPYING or https://opensource.org/licenses/mit-license.php.
5
6		#include <univalue.h>
7		#include <univalue_utffilter.h>
8
9		#include <cstdint>
10		#include <cstring>
11		#include <string>
12		#include <string_view>
13		#include <utility>
14		#include <vector>
15
16		/*
17		* According to stackexchange, the original json test suite wanted
18		* to limit depth to 22. Widely-deployed PHP bails at depth 512,
19		* so we will follow PHP's lead, which should be more than sufficient
20		* (further stackexchange comments indicate depth > 32 rarely occurs).
21		*/
22		static constexpr size_t MAX_JSON_DEPTH = 512;
23
24		static bool json_isdigit(int ch)
25	8.18M	{
26	8.18M	return ((ch >= '0') && (ch <= '9'));
27	8.18M	}
28
29		// convert hexadecimal string to unsigned integer
30		static const char hatoui(const char first, const char *last,
31		unsigned int& out)
32	682	{
33	682	unsigned int result = 0;
34	3.41k	for (; first != last; ++first)
35	2.72k	{
36	2.72k	int digit;
37	2.72k	if (json_isdigit(*first))
38	1.38k	digit = *first - '0';
39
40	1.34k	else if (first >= 'a' && first <= 'f')
41	1.32k	digit = *first - 'a' + 10;
42
43	22	else if (first >= 'A' && first <= 'F')
44	22	digit = *first - 'A' + 10;
45
46	0	else
47	0	break;
48
49	2.72k	result = 16 * result + digit;
50	2.72k	}
51	682	out = result;
52
53	682	return first;
54	682	}
55
56		enum jtokentype getJsonToken(std::string& tokenVal, unsigned int& consumed,
57		const char raw, const char end)
58	6.84M	{
59	6.84M	tokenVal.clear();
60	6.84M	consumed = 0;
61
62	6.84M	const char *rawStart = raw;
63
64	8.77M	while (raw < end && (json_isspace(*raw))) // skip whitespace
65	1.93M	raw++;
66
67	6.84M	if (raw >= end)
68	187k	return JTOK_NONE;
69
70	6.65M	switch (*raw) {
71
72	324k	case '{':
73	324k	raw++;
74	324k	consumed = (raw - rawStart);
75	324k	return JTOK_OBJ_OPEN;
76	324k	case '}':
77	324k	raw++;
78	324k	consumed = (raw - rawStart);
79	324k	return JTOK_OBJ_CLOSE;
80	124k	case '[':
81	124k	raw++;
82	124k	consumed = (raw - rawStart);
83	124k	return JTOK_ARR_OPEN;
84	123k	case ']':
85	123k	raw++;
86	123k	consumed = (raw - rawStart);
87	123k	return JTOK_ARR_CLOSE;
88
89	962k	case ':':
90	962k	raw++;
91	962k	consumed = (raw - rawStart);
92	962k	return JTOK_COLON;
93	930k	case ',':
94	930k	raw++;
95	930k	consumed = (raw - rawStart);
96	930k	return JTOK_COMMA;
97
98	796	case 'n':
99	16.8k	case 't':
100	19.2k	case 'f':
101	19.2k	if (!strncmp(raw, "null", 4)) {
102	794	raw += 4;
103	794	consumed = (raw - rawStart);
104	794	return JTOK_KW_NULL;
105	18.4k	} else if (!strncmp(raw, "true", 4)) {
106	16.0k	raw += 4;
107	16.0k	consumed = (raw - rawStart);
108	16.0k	return JTOK_KW_TRUE;
109	16.0k	} else if (!strncmp(raw, "false", 5)) {
110	2.40k	raw += 5;
111	2.40k	consumed = (raw - rawStart);
112	2.40k	return JTOK_KW_FALSE;
113	2.40k	} else
114	7	return JTOK_ERR;
115
116	40.6k	case '-':
117	429k	case '0':
118	1.09M	case '1':
119	1.41M	case '2':
120	1.60M	case '3':
121	1.74M	case '4':
122	1.81M	case '5':
123	1.90M	case '6':
124	1.96M	case '7':
125	2.07M	case '8':
126	2.14M	case '9': {
127		// part 1: int
128	2.14M	std::string numStr;
129
130	2.14M	const char *first = raw;
131
132	2.14M	const char *firstDigit = first;
133	2.14M	if (!json_isdigit(*firstDigit))
134	40.6k	firstDigit++;
135	2.14M	if ((*firstDigit == '0') && json_isdigit(firstDigit[1]))
136	1	return JTOK_ERR;
137
138	2.14M	numStr += *raw; // copy first char
139	2.14M	raw++;
140
141	2.14M	if ((first == '-') && (raw < end) && (!json_isdigit(raw)))
142	0	return JTOK_ERR;
143
144	6.72M	while (raw < end && json_isdigit(*raw)) { // copy digits
145	4.58M	numStr += *raw;
146	4.58M	raw++;
147	4.58M	}
148
149		// part 2: frac
150	2.14M	if (raw < end && *raw == '.') {
151	54.9k	numStr += *raw; // copy .
152	54.9k	raw++;
153
154	54.9k	if (raw >= end \|\| !json_isdigit(*raw))
155	0	return JTOK_ERR;
156	581k	while (raw < end && json_isdigit(*raw)) { // copy digits
157	526k	numStr += *raw;
158	526k	raw++;
159	526k	}
160	54.9k	}
161
162		// part 3: exp
163	2.14M	if (raw < end && (raw == 'e' \|\| raw == 'E')) {
164	24.2k	numStr += *raw; // copy E
165	24.2k	raw++;
166
167	24.2k	if (raw < end && (raw == '-' \|\| raw == '+')) { // copy +/-
168	24.1k	numStr += *raw;
169	24.1k	raw++;
170	24.1k	}
171
172	24.2k	if (raw >= end \|\| !json_isdigit(*raw))
173	3	return JTOK_ERR;
174	72.5k	while (raw < end && json_isdigit(*raw)) { // copy digits
175	48.3k	numStr += *raw;
176	48.3k	raw++;
177	48.3k	}
178	24.1k	}
179
180	2.14M	tokenVal = numStr;
181	2.14M	consumed = (raw - rawStart);
182	2.14M	return JTOK_NUMBER;
183	2.14M	}
184
185	1.69M	case '"': {
186	1.69M	raw++; // skip "
187
188	1.69M	std::string valStr;
189	1.69M	JSONUTF8StringFilter writer(valStr);
190
191	1.21G	while (true) {
192	1.21G	if (raw >= end \|\| (unsigned char)*raw < 0x20)
193	4	return JTOK_ERR;
194
195	1.21G	else if (*raw == '\\') {
196	736	raw++; // skip backslash
197
198	736	if (raw >= end)
199	0	return JTOK_ERR;
200
201	736	switch (*raw) {
202	15	case '"': writer.push_back('\"'); break;
203	5	case '\\': writer.push_back('\\'); break;
204	2	case '/': writer.push_back('/'); break;
205	5	case 'b': writer.push_back('\b'); break;
206	5	case 'f': writer.push_back('\f'); break;
207	8	case 'n': writer.push_back('\n'); break;
208	5	case 'r': writer.push_back('\r'); break;
209	5	case 't': writer.push_back('\t'); break;
210
211	682	case 'u': {
212	682	unsigned int codepoint;
213	682	if (raw + 1 + 4 >= end \|\|
214	682	hatoui(raw + 1, raw + 1 + 4, codepoint) !=
215	682	raw + 1 + 4)
216	0	return JTOK_ERR;
217	682	writer.push_back_u(codepoint);
218	682	raw += 4;
219	682	break;
220	682	}
221	4	default:
222	4	return JTOK_ERR;
223
224	736	}
225
226	732	raw++; // skip esc'd char
227	732	}
228
229	1.21G	else if (*raw == '"') {
230	1.69M	raw++; // skip "
231	1.69M	break; // stop scanning
232	1.69M	}
233
234	1.21G	else {
235	1.21G	writer.push_back(static_cast<unsigned char>(*raw));
236	1.21G	raw++;
237	1.21G	}
238	1.21G	}
239
240	1.69M	if (!writer.finalize())
241	4	return JTOK_ERR;
242	1.69M	tokenVal = valStr;
243	1.69M	consumed = (raw - rawStart);
244	1.69M	return JTOK_STRING;
245	1.69M	}
246
247	27	default:
248	27	return JTOK_ERR;
249	6.65M	}
250	6.65M	}
251
252		enum expect_bits : unsigned {
253		EXP_OBJ_NAME = (1U << 0),
254		EXP_COLON = (1U << 1),
255		EXP_ARR_VALUE = (1U << 2),
256		EXP_VALUE = (1U << 3),
257		EXP_NOT_VALUE = (1U << 4),
258		};
259
260	24.1M	#define expect(bit) (expectMask & (EXP_##bit))
261	5.76M	#define setExpect(bit) (expectMask \|= EXP_##bit)
262	5.96M	#define clearExpect(bit) (expectMask &= ~EXP_##bit)
263
264		bool UniValue::read(std::string_view json)
265	187k	{
266	187k	UniValue parsed;
267	187k	if (!parsed.read_impl(json)) {
268	81	setNull();
269	81	return false;
270	81	}
271	187k	*this = std::move(parsed);
272	187k	return true;
273	187k	}
274
275		bool UniValue::read_impl(std::string_view str_in)
276	187k	{
277	187k	clear();
278
279	187k	uint32_t expectMask = 0;
280	187k	std::vector<UniValue*> stack;
281
282	187k	std::string tokenVal;
283	187k	unsigned int consumed;
284	187k	enum jtokentype tok = JTOK_NONE;
285	187k	enum jtokentype last_tok = JTOK_NONE;
286	187k	const char* raw{str_in.data()};
287	187k	const char* end{raw + str_in.size()};
288	4.80M	do {
289	4.80M	last_tok = tok;
290
291	4.80M	tok = getJsonToken(tokenVal, consumed, raw, end);
292	4.80M	if (tok == JTOK_NONE \|\| tok == JTOK_ERR)
293	49	return false;
294	4.80M	raw += consumed;
295
296	4.80M	bool isValueOpen = jsonTokenIsValue(tok) \|\|
297	4.80M	tok == JTOK_OBJ_OPEN \|\| tok == JTOK_ARR_OPEN;
298
299	4.80M	if (expect(VALUE)) {
300	962k	if (!isValueOpen)
301	2	return false;
302	962k	clearExpect(VALUE);
303
304	3.84M	} else if (expect(ARR_VALUE)) {
305	353k	bool isArrValue = isValueOpen \|\| (tok == JTOK_ARR_CLOSE);
306	353k	if (!isArrValue)
307	2	return false;
308
309	353k	clearExpect(ARR_VALUE);
310
311	3.48M	} else if (expect(OBJ_NAME)) {
312	1.02M	bool isObjName = (tok == JTOK_OBJ_CLOSE \|\| tok == JTOK_STRING);
313	1.02M	if (!isObjName)
314	4	return false;
315
316	2.46M	} else if (expect(COLON)) {
317	962k	if (tok != JTOK_COLON)
318	3	return false;
319	962k	clearExpect(COLON);
320
321	1.50M	} else if (!expect(COLON) && (tok == JTOK_COLON)) {
322	1	return false;
323	1	}
324
325	4.80M	if (expect(NOT_VALUE)) {
326	2.27M	if (isValueOpen)
327	2	return false;
328	2.27M	clearExpect(NOT_VALUE);
329	2.27M	}
330
331	4.80M	switch (tok) {
332
333	324k	case JTOK_OBJ_OPEN:
334	449k	case JTOK_ARR_OPEN: {
335	449k	VType utyp = (tok == JTOK_OBJ_OPEN ? VOBJ : VARR);
336	449k	if (!stack.size()) {
337	187k	if (utyp == VOBJ)
338	186k	setObject();
339	737	else
340	737	setArray();
341	187k	stack.push_back(this);
342	261k	} else {
343	261k	UniValue tmpVal(utyp);
344	261k	UniValue *top = stack.back();
345	261k	top->values.push_back(tmpVal);
346
347	261k	UniValue *newTop = &(top->values.back());
348	261k	stack.push_back(newTop);
349	261k	}
350
351	449k	if (stack.size() > MAX_JSON_DEPTH)
352	2	return false;
353
354	449k	if (utyp == VOBJ)
355	324k	setExpect(OBJ_NAME);
356	124k	else
357	124k	setExpect(ARR_VALUE);
358	449k	break;
359	449k	}
360
361	324k	case JTOK_OBJ_CLOSE:
362	448k	case JTOK_ARR_CLOSE: {
363	448k	if (!stack.size() \|\| (last_tok == JTOK_COMMA))
364	2	return false;
365
366	448k	VType utyp = (tok == JTOK_OBJ_CLOSE ? VOBJ : VARR);
367	448k	UniValue *top = stack.back();
368	448k	if (utyp != top->getType())
369	1	return false;
370
371	448k	stack.pop_back();
372	448k	clearExpect(OBJ_NAME);
373	448k	setExpect(NOT_VALUE);
374	448k	break;
375	448k	}
376
377	962k	case JTOK_COLON: {
378	962k	if (!stack.size())
379	0	return false;
380
381	962k	UniValue *top = stack.back();
382	962k	if (top->getType() != VOBJ)
383	0	return false;
384
385	962k	setExpect(VALUE);
386	962k	break;
387	962k	}
388
389	930k	case JTOK_COMMA: {
390	930k	if (!stack.size() \|\|
391	930k	(last_tok == JTOK_COMMA) \|\| (last_tok == JTOK_ARR_OPEN))
392	0	return false;
393
394	930k	UniValue *top = stack.back();
395	930k	if (top->getType() == VOBJ)
396	701k	setExpect(OBJ_NAME);
397	228k	else
398	228k	setExpect(ARR_VALUE);
399	930k	break;
400	930k	}
401
402	793	case JTOK_KW_NULL:
403	16.8k	case JTOK_KW_TRUE:
404	19.2k	case JTOK_KW_FALSE: {
405	19.2k	UniValue tmpVal;
406	19.2k	switch (tok) {
407	793	case JTOK_KW_NULL:
408		// do nothing more
409	793	break;
410	16.0k	case JTOK_KW_TRUE:
411	16.0k	tmpVal.setBool(true);
412	16.0k	break;
413	2.40k	case JTOK_KW_FALSE:
414	2.40k	tmpVal.setBool(false);
415	2.40k	break;
416	0	default: /* impossible */ break;
417	19.2k	}
418
419	19.2k	if (!stack.size()) {
420	40	*this = tmpVal;
421	40	break;
422	40	}
423
424	19.2k	UniValue *top = stack.back();
425	19.2k	top->values.push_back(tmpVal);
426
427	19.2k	setExpect(NOT_VALUE);
428	19.2k	break;
429	19.2k	}
430
431	296k	case JTOK_NUMBER: {
432	296k	UniValue tmpVal(VNUM, tokenVal);
433	296k	if (!stack.size()) {
434	69	*this = tmpVal;
435	69	break;
436	69	}
437
438	296k	UniValue *top = stack.back();
439	296k	top->values.push_back(tmpVal);
440
441	296k	setExpect(NOT_VALUE);
442	296k	break;
443	296k	}
444
445	1.69M	case JTOK_STRING: {
446	1.69M	if (expect(OBJ_NAME)) {
447	962k	UniValue *top = stack.back();
448	962k	top->keys.push_back(tokenVal);
449	962k	clearExpect(OBJ_NAME);
450	962k	setExpect(COLON);
451	962k	} else {
452	736k	UniValue tmpVal(VSTR, tokenVal);
453	736k	if (!stack.size()) {
454	3	*this = tmpVal;
455	3	break;
456	3	}
457	736k	UniValue *top = stack.back();
458	736k	top->values.push_back(tmpVal);
459	736k	}
460
461	1.69M	setExpect(NOT_VALUE);
462	1.69M	break;
463	1.69M	}
464
465	0	default:
466	0	return false;
467	4.80M	}
468	4.80M	} while (!stack.empty ());
469
470		/* Check that nothing follows the initial construct (parsed above). */
471	187k	tok = getJsonToken(tokenVal, consumed, raw, end);
472	187k	if (tok != JTOK_NONE)
473	13	return false;
474
475	187k	return true;
476	187k	}