mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-18 00:32:11 +01:00
815 lines
26 KiB
C++
815 lines
26 KiB
C++
// Copyright 2020 The Wuffs Authors.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// https://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
// ----------------
|
|
|
|
/*
|
|
jsonfindptrs reads UTF-8 JSON from stdin and writes every node's JSON Pointer
|
|
(RFC 6901) to stdout.
|
|
|
|
See the "const char* g_usage" string below for details.
|
|
|
|
----
|
|
|
|
This program uses Wuffs' JSON decoder at a relatively high level, building
|
|
in-memory representations of JSON 'things' (e.g. numbers, strings, objects).
|
|
After the entire input has been converted, walking the tree prints the output
|
|
(in sorted order). The core conversion mechanism is to call JsonThing::parse,
|
|
which consumes a variable number of tokens (the output of Wuffs' JSON decoder).
|
|
JsonThing::parse can call itself recursively, as JSON values can nest.
|
|
|
|
This approach is centered around JSON things. Each JSON thing comprises one or
|
|
more JSON tokens.
|
|
|
|
An alternative, lower-level approach is in the sibling example/jsonptr program.
|
|
Neither approach is better or worse per se, but when studying this program, be
|
|
aware that there are multiple ways to use Wuffs' JSON decoder.
|
|
|
|
The two programs, jsonfindptrs and jsonptr, also demonstrate different
|
|
trade-offs with regard to JSON object duplicate keys. The JSON spec permits
|
|
different implementations to allow or reject duplicate keys. It is not always
|
|
clear which approach is safer. Rejecting them is certainly unambiguous, and
|
|
security bugs can lurk in ambiguous corners of a file format, if two different
|
|
implementations both silently accept a file but differ on how to interpret it.
|
|
On the other hand, in the worst case, detecting duplicate keys requires O(N)
|
|
memory, where N is the size of the (potentially untrusted) input.
|
|
|
|
This program (jsonfindptrs) rejects duplicate keys.
|
|
|
|
----
|
|
|
|
This example program differs from most other example Wuffs programs in that it
|
|
is written in C++, not C.
|
|
|
|
$CXX jsonfindptrs.cc && ./a.out < ../../test/data/github-tags.json; rm -f a.out
|
|
|
|
for a C++ compiler $CXX, such as clang++ or g++.
|
|
*/
|
|
|
|
#if defined(__cplusplus) && (__cplusplus < 201103L)
|
|
#error "This C++ program requires -std=c++11 or later"
|
|
#endif
|
|
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <unistd.h>
|
|
|
|
#include <iostream>
|
|
#include <map>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
// Wuffs ships as a "single file C library" or "header file library" as per
|
|
// https://github.com/nothings/stb/blob/master/docs/stb_howto.txt
|
|
//
|
|
// To use that single file as a "foo.c"-like implementation, instead of a
|
|
// "foo.h"-like header, #define WUFFS_IMPLEMENTATION before #include'ing or
|
|
// compiling it.
|
|
#define WUFFS_IMPLEMENTATION
|
|
|
|
// Defining the WUFFS_CONFIG__MODULE* macros are optional, but it lets users of
|
|
// release/c/etc.c whitelist which parts of Wuffs to build. That file contains
|
|
// the entire Wuffs standard library, implementing a variety of codecs and file
|
|
// formats. Without this macro definition, an optimizing compiler or linker may
|
|
// very well discard Wuffs code for unused codecs, but listing the Wuffs
|
|
// modules we use makes that process explicit. Preprocessing means that such
|
|
// code simply isn't compiled.
|
|
#define WUFFS_CONFIG__MODULES
|
|
#define WUFFS_CONFIG__MODULE__BASE
|
|
#define WUFFS_CONFIG__MODULE__JSON
|
|
|
|
// If building this program in an environment that doesn't easily accommodate
|
|
// relative includes, you can use the script/inline-c-relative-includes.go
|
|
// program to generate a stand-alone C++ file.
|
|
#include "../../release/c/wuffs-unsupported-snapshot.c"
|
|
|
|
#define TRY(error_msg) \
|
|
do { \
|
|
std::string z = error_msg; \
|
|
if (!z.empty()) { \
|
|
return z; \
|
|
} \
|
|
} while (false)
|
|
|
|
static const char* g_usage =
|
|
"Usage: jsonfindptrs -flags input.json\n"
|
|
"\n"
|
|
"Flags:\n"
|
|
" -d=NUM -max-output-depth=NUM\n"
|
|
" -s -strict-json-pointer-syntax\n"
|
|
"\n"
|
|
"The input.json filename is optional. If absent, it reads from stdin.\n"
|
|
"\n"
|
|
"----\n"
|
|
"\n"
|
|
"jsonfindptrs reads UTF-8 JSON from stdin and writes every node's JSON\n"
|
|
"Pointer (RFC 6901) to stdout.\n"
|
|
"\n"
|
|
"For example, given RFC 6901 section 5's sample input\n"
|
|
"(https://tools.ietf.org/rfc/rfc6901.txt), this command:\n"
|
|
" jsonfindptrs rfc-6901-json-pointer.json\n"
|
|
"will print:\n"
|
|
" \n"
|
|
" /\n"
|
|
" / \n"
|
|
" /a~1b\n"
|
|
" /c%d\n"
|
|
" /e^f\n"
|
|
" /foo\n"
|
|
" /foo/0\n"
|
|
" /foo/1\n"
|
|
" /g|h\n"
|
|
" /i\\j\n"
|
|
" /k\"l\n"
|
|
" /m~0n\n"
|
|
"\n"
|
|
"The first three lines are (1) a 0-byte \"\", (2) a 1-byte \"/\" and (3)\n"
|
|
"a 2-byte \"/ \". Unlike a file system, the \"/\" JSON Pointer does not\n"
|
|
"identify the root. Instead, \"\" is the root and \"/\" is the child (the\n"
|
|
"value in a key-value pair) of the root whose key is the empty string.\n"
|
|
"Similarly, \"/xyz\" and \"/xyz/\" are two different nodes.\n"
|
|
"\n"
|
|
"----\n"
|
|
"\n"
|
|
"The JSON specification (https://json.org/) permits implementations that\n"
|
|
"allow duplicate keys, but this one does not. Conversely, it prints keys\n"
|
|
"in sorted order, but the overall output is not necessarily sorted\n"
|
|
"lexicographically. For example, \"/a/9\" would come before \"/a/10\",\n"
|
|
"and \"/b/c\", a child of \"/b\", would come before \"/b+\".\n"
|
|
"\n"
|
|
"This JSON implementation also rejects integer values outside ±M, where\n"
|
|
"M is ((1<<53)-1), also known as JavaScript's Number.MAX_SAFE_INTEGER.\n"
|
|
"\n"
|
|
"----\n"
|
|
"\n"
|
|
"The -s or -strict-json-pointer-syntax flag restricts the output lines\n"
|
|
"to exactly RFC 6901, with only two escape sequences: \"~0\" and \"~1\"\n"
|
|
"for \"~\" and \"/\". Without this flag, this program also lets \"~n\"\n"
|
|
"and \"~r\" escape the New Line and Carriage Return ASCII control\n"
|
|
"characters, which can work better with line oriented Unix tools that\n"
|
|
"assume exactly one value (i.e. one JSON Pointer string) per line. With\n"
|
|
"this flag, the program will fail if the input JSON's object keys contain\n"
|
|
"\"\\u000A\" or \"\\u000D\".\n"
|
|
"\n"
|
|
"----\n"
|
|
"\n"
|
|
"The JSON specification permits implementations to set their own maximum\n"
|
|
"input depth. This JSON implementation sets it to 1024.\n"
|
|
"\n"
|
|
"The -d=NUM or -max-output-depth=NUM flag gives the maximum (inclusive)\n"
|
|
"output depth. JSON containers ([] arrays and {} objects) can hold other\n"
|
|
"containers. A bare -d or -max-output-depth is equivalent to -d=1,\n"
|
|
"analogous to the Unix ls command. The flag's absence is equivalent to an\n"
|
|
"unlimited output depth, analogous to the Unix find command (and hence\n"
|
|
"the name of this program: jsonfindptrs).";
|
|
|
|
// ----
|
|
|
|
struct {
|
|
int remaining_argc;
|
|
char** remaining_argv;
|
|
|
|
uint32_t max_output_depth;
|
|
bool strict_json_pointer_syntax;
|
|
} g_flags = {0};
|
|
|
|
std::string //
|
|
parse_flags(int argc, char** argv) {
|
|
g_flags.max_output_depth = 0xFFFFFFFF;
|
|
|
|
int c = (argc > 0) ? 1 : 0; // Skip argv[0], the program name.
|
|
for (; c < argc; c++) {
|
|
char* arg = argv[c];
|
|
if (*arg++ != '-') {
|
|
break;
|
|
}
|
|
|
|
// A double-dash "--foo" is equivalent to a single-dash "-foo". As special
|
|
// cases, a bare "-" is not a flag (some programs may interpret it as
|
|
// stdin) and a bare "--" means to stop parsing flags.
|
|
if (*arg == '\x00') {
|
|
break;
|
|
} else if (*arg == '-') {
|
|
arg++;
|
|
if (*arg == '\x00') {
|
|
c++;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!strcmp(arg, "d") || !strcmp(arg, "max-output-depth")) {
|
|
g_flags.max_output_depth = 1;
|
|
continue;
|
|
} else if (!strncmp(arg, "d=", 2) ||
|
|
!strncmp(arg, "max-output-depth=", 16)) {
|
|
while (*arg++ != '=') {
|
|
}
|
|
wuffs_base__result_u64 u = wuffs_base__parse_number_u64(
|
|
wuffs_base__make_slice_u8((uint8_t*)arg, strlen(arg)),
|
|
WUFFS_BASE__PARSE_NUMBER_XXX__DEFAULT_OPTIONS);
|
|
if (wuffs_base__status__is_ok(&u.status) && (u.value <= 0xFFFFFFFF)) {
|
|
g_flags.max_output_depth = (uint32_t)(u.value);
|
|
continue;
|
|
}
|
|
return g_usage;
|
|
}
|
|
if (!strcmp(arg, "s") || !strcmp(arg, "strict-json-pointer-syntax")) {
|
|
g_flags.strict_json_pointer_syntax = true;
|
|
continue;
|
|
}
|
|
|
|
return g_usage;
|
|
}
|
|
|
|
g_flags.remaining_argc = argc - c;
|
|
g_flags.remaining_argv = argv + c;
|
|
return "";
|
|
}
|
|
|
|
// ----
|
|
|
|
#define WORK_BUFFER_ARRAY_SIZE \
|
|
WUFFS_JSON__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE
|
|
|
|
#ifndef SRC_BUFFER_ARRAY_SIZE
|
|
#define SRC_BUFFER_ARRAY_SIZE (4 * 1024)
|
|
#endif
|
|
#ifndef TOKEN_BUFFER_ARRAY_SIZE
|
|
#define TOKEN_BUFFER_ARRAY_SIZE (1 * 1024)
|
|
#endif
|
|
|
|
class TokenStream {
|
|
public:
|
|
struct Result {
|
|
std::string status_msg;
|
|
wuffs_base__token token;
|
|
// src_data is a sub-slice of m_src (a slice is a pointer-length pair).
|
|
// Calling TokenStream::peek or TokenStream::next may change the backing
|
|
// array's contents, so handling a TokenStream::Result may require copying
|
|
// this src_data slice's contents.
|
|
wuffs_base__slice_u8 src_data;
|
|
|
|
Result(std::string s)
|
|
: status_msg(s),
|
|
token(wuffs_base__make_token(0)),
|
|
src_data(wuffs_base__empty_slice_u8()) {}
|
|
|
|
Result(std::string s, wuffs_base__token t, wuffs_base__slice_u8 d)
|
|
: status_msg(s), token(t), src_data(d) {}
|
|
};
|
|
|
|
TokenStream(int input_file_descriptor)
|
|
: m_status(wuffs_base__make_status(nullptr)),
|
|
m_src(wuffs_base__make_io_buffer(
|
|
wuffs_base__make_slice_u8(m_src_array, SRC_BUFFER_ARRAY_SIZE),
|
|
wuffs_base__empty_io_buffer_meta())),
|
|
m_tok(wuffs_base__make_token_buffer(
|
|
wuffs_base__make_slice_token(m_tok_array, TOKEN_BUFFER_ARRAY_SIZE),
|
|
wuffs_base__empty_token_buffer_meta())),
|
|
m_input_file_descriptor(input_file_descriptor),
|
|
m_curr_token_end_src_index(0) {
|
|
m_status =
|
|
m_dec.initialize(sizeof__wuffs_json__decoder(), WUFFS_VERSION, 0);
|
|
|
|
// Uncomment these lines to enable the WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_X
|
|
// option, discussed in a separate comment.
|
|
//
|
|
// if (m_status.is_ok()) {
|
|
// m_dec.set_quirk_enabled(WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_X, true);
|
|
// }
|
|
}
|
|
|
|
Result peek() { return peek_or_next(false); }
|
|
Result next() { return peek_or_next(true); }
|
|
|
|
private:
|
|
Result peek_or_next(bool next) {
|
|
while (m_tok.meta.ri >= m_tok.meta.wi) {
|
|
if (m_status.repr == nullptr) {
|
|
// No-op.
|
|
} else if (m_status.repr == wuffs_base__suspension__short_read) {
|
|
if (m_curr_token_end_src_index != m_src.meta.ri) {
|
|
return Result(
|
|
"TokenStream: internal error: inconsistent src indexes");
|
|
}
|
|
const char* z = read_src();
|
|
m_curr_token_end_src_index = m_src.meta.ri;
|
|
if (z) {
|
|
return Result(z);
|
|
}
|
|
} else if (m_status.repr == wuffs_base__suspension__short_write) {
|
|
m_tok.compact();
|
|
} else {
|
|
return Result(m_status.message());
|
|
}
|
|
|
|
m_status =
|
|
m_dec.decode_tokens(&m_tok, &m_src,
|
|
wuffs_base__make_slice_u8(
|
|
m_work_buffer_array, WORK_BUFFER_ARRAY_SIZE));
|
|
}
|
|
|
|
wuffs_base__token t = m_tok.data.ptr[m_tok.meta.ri];
|
|
size_t i = m_curr_token_end_src_index;
|
|
uint64_t n = t.length();
|
|
if ((m_src.meta.ri < i) || ((m_src.meta.ri - i) < n)) {
|
|
return Result("TokenStream: internal error: inconsistent src indexes");
|
|
}
|
|
if (next) {
|
|
m_tok.meta.ri++;
|
|
m_curr_token_end_src_index += n;
|
|
}
|
|
return Result("", t, wuffs_base__make_slice_u8(m_src.data.ptr + i, n));
|
|
}
|
|
|
|
const char* //
|
|
read_src() {
|
|
if (m_src.meta.closed) {
|
|
return "main: internal error: read requested on a closed source";
|
|
}
|
|
m_src.compact();
|
|
if (m_src.meta.wi >= m_src.data.len) {
|
|
return "main: src buffer is full";
|
|
}
|
|
while (true) {
|
|
ssize_t n = read(m_input_file_descriptor, m_src.data.ptr + m_src.meta.wi,
|
|
m_src.data.len - m_src.meta.wi);
|
|
if (n >= 0) {
|
|
m_src.meta.wi += n;
|
|
m_src.meta.closed = n == 0;
|
|
break;
|
|
} else if (errno != EINTR) {
|
|
return strerror(errno);
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
wuffs_base__status m_status;
|
|
wuffs_base__io_buffer m_src;
|
|
wuffs_base__token_buffer m_tok;
|
|
int m_input_file_descriptor;
|
|
// m_curr_token_end_src_index is the m_src.data.ptr index of the end of the
|
|
// current token. An invariant is that (m_curr_token_end_src_index <=
|
|
// m_src.meta.ri).
|
|
size_t m_curr_token_end_src_index;
|
|
|
|
wuffs_base__token m_tok_array[TOKEN_BUFFER_ARRAY_SIZE];
|
|
uint8_t m_src_array[SRC_BUFFER_ARRAY_SIZE];
|
|
#if WORK_BUFFER_ARRAY_SIZE > 0
|
|
uint8_t m_work_buffer_array[WORK_BUFFER_ARRAY_SIZE];
|
|
#else
|
|
// Not all C/C++ compilers support 0-length arrays.
|
|
uint8_t m_work_buffer_array[1];
|
|
#endif
|
|
wuffs_json__decoder m_dec;
|
|
};
|
|
|
|
// ----
|
|
|
|
class JsonThing {
|
|
public:
|
|
struct Result;
|
|
|
|
using Vector = std::vector<JsonThing>;
|
|
|
|
// We use a std::map in this example program to avoid dependencies outside of
|
|
// the C++ standard library. If you're copy/pasting this JsonThing code,
|
|
// consider a more efficient data structure such as an absl::btree_map.
|
|
//
|
|
// See CppCon 2014: Chandler Carruth "Efficiency with Algorithms, Performance
|
|
// with Data Structures" at https://www.youtube.com/watch?v=fHNmRkzxHWs
|
|
using Map = std::map<std::string, JsonThing>;
|
|
|
|
enum class Kind {
|
|
Null,
|
|
Bool,
|
|
Int64,
|
|
Float64,
|
|
String,
|
|
Array,
|
|
Object,
|
|
} kind = Kind::Null;
|
|
|
|
struct Value {
|
|
bool b = false;
|
|
int64_t i = 0;
|
|
double f = 0;
|
|
std::string s;
|
|
Vector a;
|
|
Map o;
|
|
} value;
|
|
|
|
static JsonThing::Result parse(TokenStream& ts);
|
|
|
|
private:
|
|
static JsonThing::Result parse_array(TokenStream& ts);
|
|
static JsonThing::Result parse_literal(TokenStream::Result tsr);
|
|
static JsonThing::Result parse_number(TokenStream::Result tsr);
|
|
static JsonThing::Result parse_object(TokenStream& ts);
|
|
static JsonThing::Result parse_string(TokenStream& ts,
|
|
TokenStream::Result tsr);
|
|
};
|
|
|
|
struct JsonThing::Result {
|
|
std::string status_msg;
|
|
JsonThing thing;
|
|
|
|
Result(std::string s) : status_msg(s), thing(JsonThing()) {}
|
|
|
|
Result(std::string s, JsonThing t) : status_msg(s), thing(t) {}
|
|
};
|
|
|
|
JsonThing::Result //
|
|
JsonThing::parse(TokenStream& ts) {
|
|
while (true) {
|
|
TokenStream::Result tsr = ts.next();
|
|
if (!tsr.status_msg.empty()) {
|
|
return Result(std::move(tsr.status_msg));
|
|
}
|
|
|
|
int64_t vbc = tsr.token.value_base_category();
|
|
uint64_t vbd = tsr.token.value_base_detail();
|
|
switch (vbc) {
|
|
case WUFFS_BASE__TOKEN__VBC__FILLER:
|
|
continue;
|
|
case WUFFS_BASE__TOKEN__VBC__STRUCTURE:
|
|
if (vbd & WUFFS_BASE__TOKEN__VBD__STRUCTURE__PUSH) {
|
|
if (vbd & WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_LIST) {
|
|
return parse_array(ts);
|
|
} else if (vbd & WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_DICT) {
|
|
return parse_object(ts);
|
|
}
|
|
}
|
|
break;
|
|
case WUFFS_BASE__TOKEN__VBC__STRING:
|
|
return parse_string(ts, tsr);
|
|
case WUFFS_BASE__TOKEN__VBC__LITERAL:
|
|
return parse_literal(tsr);
|
|
case WUFFS_BASE__TOKEN__VBC__NUMBER:
|
|
return parse_number(tsr);
|
|
}
|
|
|
|
return Result("main: internal error: unexpected token");
|
|
}
|
|
}
|
|
|
|
JsonThing::Result //
|
|
JsonThing::parse_array(TokenStream& ts) {
|
|
JsonThing jt;
|
|
jt.kind = Kind::Array;
|
|
while (true) {
|
|
TokenStream::Result tsr = ts.peek();
|
|
if (!tsr.status_msg.empty()) {
|
|
return Result(std::move(tsr.status_msg));
|
|
}
|
|
int64_t vbc = tsr.token.value_base_category();
|
|
uint64_t vbd = tsr.token.value_base_detail();
|
|
if (vbc == WUFFS_BASE__TOKEN__VBC__FILLER) {
|
|
ts.next();
|
|
continue;
|
|
} else if ((vbc == WUFFS_BASE__TOKEN__VBC__STRUCTURE) &&
|
|
(vbd & WUFFS_BASE__TOKEN__VBD__STRUCTURE__POP)) {
|
|
ts.next();
|
|
break;
|
|
}
|
|
|
|
JsonThing::Result jtr = JsonThing::parse(ts);
|
|
if (!jtr.status_msg.empty()) {
|
|
return Result(std::move(jtr.status_msg));
|
|
}
|
|
jt.value.a.push_back(std::move(jtr.thing));
|
|
}
|
|
return Result("", jt);
|
|
}
|
|
|
|
JsonThing::Result //
|
|
JsonThing::parse_literal(TokenStream::Result tsr) {
|
|
uint64_t vbd = tsr.token.value_base_detail();
|
|
if (vbd & WUFFS_BASE__TOKEN__VBD__LITERAL__NULL) {
|
|
JsonThing jt;
|
|
jt.kind = Kind::Null;
|
|
return Result("", jt);
|
|
} else if (vbd & WUFFS_BASE__TOKEN__VBD__LITERAL__FALSE) {
|
|
JsonThing jt;
|
|
jt.kind = Kind::Bool;
|
|
jt.value.b = false;
|
|
return Result("", jt);
|
|
} else if (vbd & WUFFS_BASE__TOKEN__VBD__LITERAL__TRUE) {
|
|
JsonThing jt;
|
|
jt.kind = Kind::Bool;
|
|
jt.value.b = true;
|
|
return Result("", jt);
|
|
}
|
|
return Result("main: internal error: unexpected token");
|
|
}
|
|
|
|
JsonThing::Result //
|
|
JsonThing::parse_number(TokenStream::Result tsr) {
|
|
// Parsing the number from its string representation (converting from "123"
|
|
// to 123) isn't necessary for the jsonfindptrs program, but if you're
|
|
// copy/pasting this JsonThing code, here's how to do it.
|
|
uint64_t vbd = tsr.token.value_base_detail();
|
|
if (vbd & WUFFS_BASE__TOKEN__VBD__NUMBER__FORMAT_TEXT) {
|
|
if (vbd & WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_INTEGER_SIGNED) {
|
|
static constexpr int64_t m = 0x001FFFFFFFFFFFFF; // ((1<<53) - 1).
|
|
wuffs_base__result_i64 r = wuffs_base__parse_number_i64(
|
|
tsr.src_data, WUFFS_BASE__PARSE_NUMBER_XXX__DEFAULT_OPTIONS);
|
|
if (!r.status.is_ok()) {
|
|
return Result(r.status.message());
|
|
} else if ((r.value < -m) || (+m < r.value)) {
|
|
return Result(wuffs_base__error__out_of_bounds);
|
|
}
|
|
JsonThing jt;
|
|
jt.kind = Kind::Int64;
|
|
jt.value.i = r.value;
|
|
return Result("", jt);
|
|
} else if (vbd & WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_FLOATING_POINT) {
|
|
wuffs_base__result_f64 r = wuffs_base__parse_number_f64(
|
|
tsr.src_data, WUFFS_BASE__PARSE_NUMBER_XXX__DEFAULT_OPTIONS);
|
|
if (!r.status.is_ok()) {
|
|
return Result(r.status.message());
|
|
}
|
|
JsonThing jt;
|
|
jt.kind = Kind::Float64;
|
|
jt.value.f = r.value;
|
|
return Result("", jt);
|
|
}
|
|
}
|
|
return Result("main: internal error: unexpected number");
|
|
}
|
|
|
|
JsonThing::Result //
|
|
JsonThing::parse_object(TokenStream& ts) {
|
|
JsonThing jt;
|
|
jt.kind = Kind::Object;
|
|
|
|
std::string key;
|
|
bool have_key = false;
|
|
|
|
while (true) {
|
|
TokenStream::Result tsr = ts.peek();
|
|
if (!tsr.status_msg.empty()) {
|
|
return Result(std::move(tsr.status_msg));
|
|
}
|
|
int64_t vbc = tsr.token.value_base_category();
|
|
uint64_t vbd = tsr.token.value_base_detail();
|
|
if (vbc == WUFFS_BASE__TOKEN__VBC__FILLER) {
|
|
ts.next();
|
|
continue;
|
|
} else if ((vbc == WUFFS_BASE__TOKEN__VBC__STRUCTURE) &&
|
|
(vbd & WUFFS_BASE__TOKEN__VBD__STRUCTURE__POP)) {
|
|
ts.next();
|
|
break;
|
|
}
|
|
|
|
JsonThing::Result jtr = JsonThing::parse(ts);
|
|
if (!jtr.status_msg.empty()) {
|
|
return Result(std::move(jtr.status_msg));
|
|
}
|
|
|
|
if (have_key) {
|
|
have_key = false;
|
|
auto iter = jt.value.o.find(key);
|
|
if (iter == jt.value.o.end()) {
|
|
jt.value.o.insert(
|
|
iter, Map::value_type(std::move(key), std::move(jtr.thing)));
|
|
} else {
|
|
return Result("main: duplicate key: " + key);
|
|
}
|
|
} else if (jtr.thing.kind == Kind::String) {
|
|
have_key = true;
|
|
key = std::move(jtr.thing.value.s);
|
|
} else {
|
|
return Result("main: internal error: unexpected non-string key");
|
|
}
|
|
}
|
|
if (have_key) {
|
|
return Result("main: internal error: unpaired key");
|
|
}
|
|
return Result("", jt);
|
|
}
|
|
|
|
JsonThing::Result //
|
|
JsonThing::parse_string(TokenStream& ts, TokenStream::Result tsr) {
|
|
JsonThing jt;
|
|
jt.kind = Kind::String;
|
|
while (true) {
|
|
int64_t vbc = tsr.token.value_base_category();
|
|
uint64_t vbd = tsr.token.value_base_detail();
|
|
|
|
switch (vbc) {
|
|
case WUFFS_BASE__TOKEN__VBC__STRING: {
|
|
if (vbd & WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_0_DST_1_SRC_DROP) {
|
|
// No-op.
|
|
|
|
} else if (vbd &
|
|
WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_1_DST_1_SRC_COPY) {
|
|
const char* ptr = // Convert from (uint8_t*).
|
|
static_cast<const char*>(static_cast<void*>(tsr.src_data.ptr));
|
|
jt.value.s.append(ptr, tsr.src_data.len);
|
|
|
|
} else if (
|
|
vbd &
|
|
WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_1_DST_4_SRC_BACKSLASH_X) {
|
|
// We shouldn't get here unless we enable the
|
|
// WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_X option. The jsonfindptrs
|
|
// program doesn't enable that by default, but if you're copy/pasting
|
|
// this JsonThing code and your program does enable that option,
|
|
// here's how to handle it.
|
|
//
|
|
// As per the quirk documentation, there are two options for how to
|
|
// interpret a backslash-x: as a byte or as a Unicode code point.
|
|
// This implementation chooses as a byte.
|
|
wuffs_base__slice_u8 encoded = tsr.src_data;
|
|
if (encoded.len & 3) {
|
|
return Result(
|
|
"main: internal error: \\x token length not a multiple of 4",
|
|
JsonThing());
|
|
}
|
|
while (encoded.len) {
|
|
uint8_t decoded[64];
|
|
size_t len = wuffs_base__hexadecimal__decode4(
|
|
wuffs_base__make_slice_u8(&decoded[0], 64), encoded);
|
|
if ((len > 64) || ((len * 4) > encoded.len)) {
|
|
return Result(
|
|
"main: internal error: inconsistent hexadecimal decoding",
|
|
JsonThing());
|
|
}
|
|
const char* ptr = // Convert from (uint8_t*).
|
|
static_cast<const char*>(static_cast<void*>(&decoded[0]));
|
|
jt.value.s.append(ptr, len);
|
|
encoded.ptr += len * 4;
|
|
encoded.len -= len * 4;
|
|
}
|
|
|
|
} else {
|
|
return Result(
|
|
"main: internal error: unexpected string-token conversion",
|
|
JsonThing());
|
|
}
|
|
break;
|
|
}
|
|
|
|
case WUFFS_BASE__TOKEN__VBC__UNICODE_CODE_POINT: {
|
|
uint8_t u[WUFFS_BASE__UTF_8__BYTE_LENGTH__MAX_INCL];
|
|
size_t n = wuffs_base__utf_8__encode(
|
|
wuffs_base__make_slice_u8(&u[0],
|
|
WUFFS_BASE__UTF_8__BYTE_LENGTH__MAX_INCL),
|
|
vbd);
|
|
const char* ptr = // Convert from (uint8_t*).
|
|
static_cast<const char*>(static_cast<void*>(&u[0]));
|
|
jt.value.s.append(ptr, n);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
return Result("main: internal error: unexpected token");
|
|
}
|
|
|
|
if (!tsr.token.continued()) {
|
|
break;
|
|
}
|
|
tsr = ts.next();
|
|
if (!tsr.status_msg.empty()) {
|
|
return Result(std::move(tsr.status_msg));
|
|
}
|
|
}
|
|
return Result("", jt);
|
|
}
|
|
|
|
// ----
|
|
|
|
std::string //
|
|
escape(std::string s) {
|
|
for (char& c : s) {
|
|
if ((c == '~') || (c == '/') || (c == '\n') || (c == '\r')) {
|
|
goto escape_needed;
|
|
}
|
|
}
|
|
return s;
|
|
|
|
escape_needed:
|
|
std::string e;
|
|
e.reserve(8 + s.length());
|
|
for (char& c : s) {
|
|
switch (c) {
|
|
case '~':
|
|
e += "~0";
|
|
break;
|
|
case '/':
|
|
e += "~1";
|
|
break;
|
|
case '\n':
|
|
if (g_flags.strict_json_pointer_syntax) {
|
|
return "";
|
|
}
|
|
e += "~n";
|
|
break;
|
|
case '\r':
|
|
if (g_flags.strict_json_pointer_syntax) {
|
|
return "";
|
|
}
|
|
e += "~r";
|
|
break;
|
|
default:
|
|
e += c;
|
|
break;
|
|
}
|
|
}
|
|
return e;
|
|
}
|
|
|
|
std::string //
|
|
print_json_pointers(JsonThing& jt, std::string s, uint32_t depth) {
|
|
std::cout << s << std::endl;
|
|
if (depth++ >= g_flags.max_output_depth) {
|
|
return "";
|
|
}
|
|
|
|
switch (jt.kind) {
|
|
case JsonThing::Kind::Array:
|
|
s += "/";
|
|
for (size_t i = 0; i < jt.value.a.size(); i++) {
|
|
TRY(print_json_pointers(jt.value.a[i], s + std::to_string(i), depth));
|
|
}
|
|
break;
|
|
case JsonThing::Kind::Object:
|
|
s += "/";
|
|
for (auto& kv : jt.value.o) {
|
|
std::string e = escape(kv.first);
|
|
if (e.empty() && !kv.first.empty()) {
|
|
return "main: unsupported \"\\u000A\" or \"\\u000D\" in object key";
|
|
}
|
|
TRY(print_json_pointers(kv.second, s + e, depth));
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return "";
|
|
}
|
|
|
|
std::string //
|
|
main1(int argc, char** argv) {
|
|
TRY(parse_flags(argc, argv));
|
|
|
|
int input_file_descriptor = 0; // A 0 default means stdin.
|
|
if (g_flags.remaining_argc > 1) {
|
|
return g_usage;
|
|
} else if (g_flags.remaining_argc == 1) {
|
|
const char* arg = g_flags.remaining_argv[0];
|
|
input_file_descriptor = open(arg, O_RDONLY);
|
|
if (input_file_descriptor < 0) {
|
|
return std::string("main: cannot read ") + arg + ": " + strerror(errno);
|
|
}
|
|
}
|
|
|
|
TokenStream ts(input_file_descriptor);
|
|
JsonThing::Result jtr = JsonThing::parse(ts);
|
|
if (!jtr.status_msg.empty()) {
|
|
return jtr.status_msg;
|
|
}
|
|
return print_json_pointers(jtr.thing, "", 0);
|
|
}
|
|
|
|
// ----
|
|
|
|
int //
|
|
compute_exit_code(std::string status_msg) {
|
|
if (status_msg.empty()) {
|
|
return 0;
|
|
}
|
|
std::cerr << status_msg << std::endl;
|
|
// Return an exit code of 1 for regular (forseen) errors, e.g. badly
|
|
// formatted or unsupported input.
|
|
//
|
|
// Return an exit code of 2 for internal (exceptional) errors, e.g. defensive
|
|
// run-time checks found that an internal invariant did not hold.
|
|
//
|
|
// Automated testing, including badly formatted inputs, can therefore
|
|
// discriminate between expected failure (exit code 1) and unexpected failure
|
|
// (other non-zero exit codes). Specifically, exit code 2 for internal
|
|
// invariant violation, exit code 139 (which is 128 + SIGSEGV on x86_64
|
|
// linux) for a segmentation fault (e.g. null pointer dereference).
|
|
return (status_msg.find("internal error:") != std::string::npos) ? 2 : 1;
|
|
}
|
|
|
|
int //
|
|
main(int argc, char** argv) {
|
|
std::string z = main1(argc, argv);
|
|
int exit_code = compute_exit_code(z);
|
|
return exit_code;
|
|
}
|