Add example/cbor-to-json

This commit is contained in:
Nigel Tao committed 2020-08-09 23:03:42 +10:00
1 parent 9dd8c32683
commit 0b7eaf291b
9 files changed
+1511 -1

No files matched your search

+1
View File
@@ -10,6 +10,7 @@
- Added `base` library support for UTF-8.
- Added `base` library support for `atoi`-like string conversion.
- Added `endwhile` syntax.
- Added `example/cbor-to-json`.
- Added `example/convert-to-nia`.
- Added `example/imageviewer`.
- Added `example/json-to-cbor`.
+663
View File
@@ -0,0 +1,663 @@
// 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.
// ----------------
/*
cbor-to-json reads CBOR (a binary format) from stdin and writes the equivalent
formatted JSON (a text format) to stdout.
See the "const char* g_usage" string below for details.
----
To run:
$CXX cbor-to-json.cc && ./a.out < ../../test/data/json-things.cbor; 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 <stdio.h>
#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__AUX__BASE
#define WUFFS_CONFIG__MODULE__AUX__CBOR
#define WUFFS_CONFIG__MODULE__BASE
#define WUFFS_CONFIG__MODULE__CBOR
// 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: cbor-to-json -flags input.cbor\n"
"\n"
"Flags:\n"
" -c -compact-output\n"
" -s=NUM -spaces=NUM\n"
" -t -tabs\n"
" -output-cbor-metadata-as-comments\n"
" -output-extra-comma\n"
" -output-inf-nan-numbers\n"
"\n"
"The input.cbor filename is optional. If absent, it reads from stdin.\n"
"\n"
"----\n"
"\n"
"cbor-to-json reads CBOR (a binary format) from stdin and writes the\n"
"equivalent formatted JSON (a text format) to stdout.\n"
"\n"
"The output JSON's arrays' and objects' elements are indented, each on\n"
"its own line. Configure this with the -c / -compact-output, -s=NUM /\n"
"-spaces=NUM (for NUM ranging from 0 to 8) and -t / -tabs flags.\n"
"\n"
"The conversion may be lossy. For example, CBOR metadata such as tags or\n"
"distinguishing undefined from null are either dropped or, with\n"
"-output-cbor-metadata-as-comments, converted to \"/*comments*/\". Such\n"
"comments are non-compliant with the JSON specification but many parsers\n"
"accept them.\n"
"\n"
"The -output-extra-comma flag writes output like \"[1,2,]\", with a comma\n"
"after the final element of a JSON list or dictionary. Such commas are\n"
"non-compliant with the JSON specification but many parsers accept them\n"
"and they can produce simpler line-based diffs. This flag is ignored when\n"
"-compact-output is set.\n"
"\n"
"The -output-inf-nan-numbers flag writes Inf and NaN instead of a\n"
"substitute null value. Such values are non-compliant with the JSON\n"
"specification but many parsers accept them.\n"
"\n"
"CBOR is more permissive about map keys but JSON only allows strings.\n"
"When converting from -i=cbor to -o=json, this program rejects keys other\n"
"than integers and strings (CBOR major types 0, 1, 2 and 3). Integer\n"
"keys like 123 quoted to be string keys like \"123\".\n"
"\n"
"The CBOR specification permits implementations to set their own maximum\n"
"input depth. This CBOR implementation sets it to 1024.";
// ----
// parse_flags enforces that g_flags.spaces <= 8 (the length of
// INDENT_SPACES_STRING).
#define INDENT_SPACES_STRING " "
#define INDENT_TAB_STRING "\t"
uint8_t g_dst_array[32768];
wuffs_base__io_buffer g_dst;
uint32_t g_depth;
enum class context {
none,
in_list_after_bracket,
in_list_after_value,
in_dict_after_brace,
in_dict_after_key,
in_dict_after_value,
} g_ctx;
bool g_wrote_to_dst;
std::vector<uint64_t> g_cbor_tags;
std::vector<uint32_t> g_quirks;
struct {
int remaining_argc;
char** remaining_argv;
bool compact_output;
bool output_cbor_metadata_as_comments;
bool output_extra_comma;
bool output_inf_nan_numbers;
size_t spaces;
bool tabs;
} g_flags = {0};
std::string //
parse_flags(int argc, char** argv) {
g_flags.spaces = 4;
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, "c") || !strcmp(arg, "compact-output")) {
g_flags.compact_output = true;
continue;
}
if (!strcmp(arg, "output-cbor-metadata-as-comments")) {
g_flags.output_cbor_metadata_as_comments = true;
continue;
}
if (!strcmp(arg, "output-extra-comma")) {
g_flags.output_extra_comma = true;
continue;
}
if (!strcmp(arg, "output-inf-nan-numbers")) {
g_flags.output_inf_nan_numbers = true;
continue;
}
if (!strncmp(arg, "s=", 2) || !strncmp(arg, "spaces=", 7)) {
while (*arg++ != '=') {
}
if (('0' <= arg[0]) && (arg[0] <= '8') && (arg[1] == '\x00')) {
g_flags.spaces = arg[0] - '0';
continue;
}
return g_usage;
}
if (!strcmp(arg, "t") || !strcmp(arg, "tabs")) {
g_flags.tabs = true;
continue;
}
return g_usage;
}
g_flags.remaining_argc = argc - c;
g_flags.remaining_argv = argv + c;
return "";
}
// ----
std::string //
flush_dst() {
while (true) {
size_t n = g_dst.reader_length();
if (n == 0) {
break;
}
ssize_t i = fwrite(g_dst.reader_pointer(), 1, n, stdout);
if (i >= 0) {
g_dst.meta.ri += i;
}
if (i < n) {
return "main: error writing to stdout";
}
}
g_dst.compact();
return "";
}
std::string //
write_dst(const void* s, size_t n) {
const uint8_t* p = static_cast<const uint8_t*>(s);
while (n > 0) {
size_t i = g_dst.writer_length();
if (i == 0) {
TRY(flush_dst());
i = g_dst.writer_length();
if (i == 0) {
return "main: g_dst buffer is full";
}
}
if (i > n) {
i = n;
}
memcpy(g_dst.data.ptr + g_dst.meta.wi, p, i);
g_dst.meta.wi += i;
p += i;
n -= i;
g_wrote_to_dst = true;
}
return "";
}
// ----
class Callbacks : public wuffs_aux::DecodeCborCallbacks {
public:
Callbacks() = default;
std::string WritePreambleAndUpdateContext() {
// Write preceding punctuation, whitespace and indentation. Update g_ctx.
do {
switch (g_ctx) {
case context::none:
// No-op.
break;
case context::in_list_after_bracket:
TRY(write_dst("\n", g_flags.compact_output ? 0 : 1));
g_ctx = context::in_list_after_value;
break;
case context::in_list_after_value:
TRY(write_dst(",\n", g_flags.compact_output ? 1 : 2));
break;
case context::in_dict_after_brace:
TRY(write_dst("\n", g_flags.compact_output ? 0 : 1));
g_ctx = context::in_dict_after_key;
break;
case context::in_dict_after_key:
TRY(write_dst(": ", g_flags.compact_output ? 1 : 2));
g_ctx = context::in_dict_after_value;
goto skip_indentation;
case context::in_dict_after_value:
TRY(write_dst(",\n", g_flags.compact_output ? 1 : 2));
g_ctx = context::in_dict_after_key;
break;
}
if (!g_flags.compact_output) {
for (size_t i = 0; i < g_depth; i++) {
TRY(write_dst(g_flags.tabs ? INDENT_TAB_STRING : INDENT_SPACES_STRING,
g_flags.tabs ? 1 : g_flags.spaces));
}
}
} while (false);
skip_indentation:
// Write any CBOR tags.
if (g_flags.output_cbor_metadata_as_comments) {
for (const auto& cbor_tag : g_cbor_tags) {
uint8_t buf[WUFFS_BASE__U64__BYTE_LENGTH__MAX_INCL];
size_t n = wuffs_base__render_number_u64(
wuffs_base__make_slice_u8(&buf[0],
WUFFS_BASE__U64__BYTE_LENGTH__MAX_INCL),
cbor_tag, WUFFS_BASE__RENDER_NUMBER_XXX__DEFAULT_OPTIONS);
TRY(write_dst("/*cbor:tag", 10));
TRY(write_dst(&buf[0], n));
TRY(write_dst("*/", 2));
}
g_cbor_tags.clear();
}
return "";
}
virtual std::string AppendNull() {
TRY(WritePreambleAndUpdateContext());
if (g_ctx == context::in_dict_after_key) {
return "main: invalid JSON map key";
}
return write_dst("null", 4);
}
virtual std::string AppendUndefined() {
TRY(WritePreambleAndUpdateContext());
if (g_ctx == context::in_dict_after_key) {
return "main: invalid JSON map key";
}
// JSON's closest approximation to "undefined" is "null".
if (g_flags.output_cbor_metadata_as_comments) {
return write_dst("/*cbor:undefined*/null", 22);
}
return write_dst("null", 4);
}
virtual std::string AppendBool(bool val) {
TRY(WritePreambleAndUpdateContext());
if (g_ctx == context::in_dict_after_key) {
return "main: invalid JSON map key";
}
if (val) {
return write_dst("true", 4);
}
return write_dst("false", 5);
}
virtual std::string AppendF64(double val) {
TRY(WritePreambleAndUpdateContext());
if (g_ctx == context::in_dict_after_key) {
return "main: invalid JSON map key";
}
uint8_t buf[64];
constexpr uint32_t precision = 0;
size_t n = wuffs_base__render_number_f64(
wuffs_base__make_slice_u8(&buf[0], sizeof buf), val, precision,
WUFFS_BASE__RENDER_NUMBER_FXX__JUST_ENOUGH_PRECISION);
if (!g_flags.output_inf_nan_numbers) {
// JSON numbers don't include Infinities or NaNs. For such numbers, their
// IEEE 754 bit representation's 11 exponent bits are all on.
uint64_t u =
wuffs_base__ieee_754_bit_representation__from_f64_to_u64(val);
if (((u >> 52) & 0x7FF) == 0x7FF) {
if (g_flags.output_cbor_metadata_as_comments) {
TRY(write_dst("/*cbor:", 7));
TRY(write_dst(&buf[0], n));
TRY(write_dst("*/", 2));
}
return write_dst("null", 4);
}
}
return write_dst(&buf[0], n);
}
virtual std::string AppendI64(int64_t val) {
TRY(WritePreambleAndUpdateContext());
if (g_ctx == context::in_dict_after_key) {
TRY(write_dst("\"", 1));
}
uint8_t buf[WUFFS_BASE__I64__BYTE_LENGTH__MAX_INCL];
size_t n = wuffs_base__render_number_i64(
wuffs_base__make_slice_u8(&buf[0], sizeof buf), val,
WUFFS_BASE__RENDER_NUMBER_XXX__DEFAULT_OPTIONS);
TRY(write_dst(&buf[0], n));
if (g_ctx == context::in_dict_after_key) {
TRY(write_dst("\"", 1));
}
return "";
}
virtual std::string AppendU64(uint64_t val) {
TRY(WritePreambleAndUpdateContext());
if (g_ctx == context::in_dict_after_key) {
TRY(write_dst("\"", 1));
}
uint8_t buf[WUFFS_BASE__U64__BYTE_LENGTH__MAX_INCL];
size_t n = wuffs_base__render_number_u64(
wuffs_base__make_slice_u8(&buf[0], sizeof buf), val,
WUFFS_BASE__RENDER_NUMBER_XXX__DEFAULT_OPTIONS);
TRY(write_dst(&buf[0], n));
if (g_ctx == context::in_dict_after_key) {
TRY(write_dst("\"", 1));
}
return "";
}
virtual std::string AppendByteString(std::string&& val) {
TRY(WritePreambleAndUpdateContext());
if (g_flags.output_cbor_metadata_as_comments) {
TRY(write_dst("/*cbor:base64url*/\"", 19));
} else {
TRY(write_dst("\"", 1));
}
const uint8_t* ptr =
static_cast<const uint8_t*>(static_cast<const void*>(val.data()));
size_t len = val.length();
while (len > 0) {
constexpr bool closed = true;
wuffs_base__transform__output o = wuffs_base__base_64__encode(
g_dst.writer_slice(),
wuffs_base__make_slice_u8(const_cast<uint8_t*>(ptr), len), closed,
WUFFS_BASE__BASE_64__URL_ALPHABET);
g_dst.meta.wi += o.num_dst;
ptr += o.num_src;
len -= o.num_src;
if (o.status.repr == nullptr) {
if (len != 0) {
return "main: internal error: inconsistent base-64 length";
}
break;
} else if (o.status.repr != wuffs_base__suspension__short_write) {
return o.status.message();
}
TRY(flush_dst());
}
return write_dst("\"", 1);
}
virtual std::string AppendTextString(std::string&& val) {
TRY(WritePreambleAndUpdateContext());
TRY(write_dst("\"", 1));
const uint8_t* ptr =
static_cast<const uint8_t*>(static_cast<const void*>(val.data()));
size_t len = val.length();
loop:
if (len > 0) {
for (size_t i = 0; i < len; i++) {
uint8_t c = ptr[i];
if ((c == '"') || (c == '\\') || (c < 0x20)) {
TRY(write_dst(ptr, i));
TRY(AppendAsciiByte(c));
ptr += i + 1;
len -= i + 1;
goto loop;
}
}
TRY(write_dst(ptr, len));
}
return write_dst("\"", 1);
}
std::string AppendAsciiByte(uint8_t c) {
switch (c) {
case '\b':
return write_dst("\\b", 2);
case '\f':
return write_dst("\\f", 2);
case '\n':
return write_dst("\\n", 2);
case '\r':
return write_dst("\\r", 2);
case '\t':
return write_dst("\\t", 2);
case '\"':
return write_dst("\\\"", 2);
case '\\':
return write_dst("\\\\", 2);
}
static const char* hex_digits = "0123456789ABCDEF";
uint8_t esc6[6];
esc6[0] = '\\';
esc6[1] = 'u';
esc6[2] = '0';
esc6[3] = '0';
esc6[4] = hex_digits[c >> 4];
esc6[5] = hex_digits[c & 0x1F];
return write_dst(&esc6[0], 6);
}
virtual std::string AppendMinus1MinusX(uint64_t val) {
TRY(WritePreambleAndUpdateContext());
if (g_ctx == context::in_dict_after_key) {
TRY(write_dst("\"", 1));
}
val++;
if (val == 0) {
// See the cbor.TOKEN_VALUE_MINOR__MINUS_1_MINUS_X comment re overflow.
TRY(write_dst("-18446744073709551616", 21));
} else {
uint8_t buf[1 + WUFFS_BASE__U64__BYTE_LENGTH__MAX_INCL];
uint8_t* b = &buf[0];
*b++ = '-';
size_t n = wuffs_base__render_number_u64(
wuffs_base__make_slice_u8(b, WUFFS_BASE__U64__BYTE_LENGTH__MAX_INCL),
val, WUFFS_BASE__RENDER_NUMBER_XXX__DEFAULT_OPTIONS);
TRY(write_dst(&buf[0], 1 + n));
}
if (g_ctx == context::in_dict_after_key) {
TRY(write_dst("\"", 1));
}
return "";
}
virtual std::string AppendCborSimpleValue(uint8_t val) {
TRY(WritePreambleAndUpdateContext());
if (g_ctx == context::in_dict_after_key) {
return "main: invalid JSON map key";
}
if (!g_flags.output_cbor_metadata_as_comments) {
return write_dst("null", 4);
}
uint8_t buf[WUFFS_BASE__U64__BYTE_LENGTH__MAX_INCL];
size_t n = wuffs_base__render_number_u64(
wuffs_base__make_slice_u8(&buf[0],
WUFFS_BASE__U64__BYTE_LENGTH__MAX_INCL),
val, WUFFS_BASE__RENDER_NUMBER_XXX__DEFAULT_OPTIONS);
TRY(write_dst("/*cbor:simple", 13));
TRY(write_dst(&buf[0], n));
return write_dst("*/null", 6);
}
virtual std::string AppendCborTag(uint64_t val) {
// No call to WritePreambleAndUpdateContext. A CBOR tag isn't a value. It
// decorates the upcoming value.
if (g_flags.output_cbor_metadata_as_comments) {
g_cbor_tags.push_back(val);
}
return "";
}
virtual std::string Push(uint32_t flags) {
TRY(WritePreambleAndUpdateContext());
if (g_ctx == context::in_dict_after_key) {
return "main: invalid JSON map key";
}
g_depth++;
g_ctx = (flags & WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_LIST)
? context::in_list_after_bracket
: context::in_dict_after_brace;
return write_dst(
(flags & WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_LIST) ? "[" : "{", 1);
}
virtual std::string Pop(uint32_t flags) {
// No call to WritePreambleAndUpdateContext. We write the extra comma,
// outdent, etc. ourselves.
g_depth--;
if (g_flags.compact_output) {
// No-op.
} else if ((g_ctx != context::in_list_after_bracket) &&
(g_ctx != context::in_dict_after_brace)) {
if (g_flags.output_extra_comma) {
TRY(write_dst(",\n", 2));
} else {
TRY(write_dst("\n", 1));
}
for (size_t i = 0; i < g_depth; i++) {
TRY(write_dst(g_flags.tabs ? INDENT_TAB_STRING : INDENT_SPACES_STRING,
g_flags.tabs ? 1 : g_flags.spaces));
}
}
g_ctx = (flags & WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_LIST)
? context::in_list_after_value
: context::in_dict_after_value;
return write_dst(
(flags & WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_LIST) ? "]" : "}", 1);
}
};
// ----
std::string //
main1(int argc, char** argv) {
g_dst = wuffs_base__ptr_u8__writer(
&g_dst_array[0], (sizeof(g_dst_array) / sizeof(g_dst_array[0])));
g_depth = 0;
g_ctx = context::none;
g_wrote_to_dst = false;
TRY(parse_flags(argc, argv));
FILE* in = stdin;
if (g_flags.remaining_argc > 1) {
return g_usage;
} else if (g_flags.remaining_argc == 1) {
in = fopen(g_flags.remaining_argv[0], "r");
if (!in) {
return std::string("main: cannot read input file");
}
}
return wuffs_aux::DecodeCbor(
Callbacks(), wuffs_aux::sync_io::FileInput(in),
wuffs_base__make_slice_u32(g_quirks.data(), g_quirks.size()))
.error_message;
}
// ----
int //
compute_exit_code(std::string status_msg) {
if (status_msg.empty()) {
return 0;
}
fputs(status_msg.c_str(), stderr);
fputc('\n', stderr);
// 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);
if (g_wrote_to_dst) {
std::string z1 = write_dst("\n", 1);
std::string z2 = flush_dst();
z = !z.empty() ? z : (!z1.empty() ? z1 : z2);
}
return compute_exit_code(z);
}
+343
View File
@@ -0,0 +1,343 @@
// After editing this file, run "go generate" in the ../data directory.
// 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.
// ---------------- Auxiliary - CBOR
#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__AUX__CBOR)
#include <utility>
namespace wuffs_aux {
DecodeCborResult::DecodeCborResult(std::string&& error_message0,
uint64_t cursor_position0)
: error_message(std::move(error_message0)),
cursor_position(cursor_position0) {}
void DecodeCborCallbacks::Done(DecodeCborResult& result,
sync_io::Input& input,
IOBuffer& buffer) {}
DecodeCborResult //
DecodeCbor(DecodeCborCallbacks&& callbacks,
sync_io::Input&& input,
wuffs_base__slice_u32 quirks) {
// Prepare the wuffs_base__io_buffer and the resultant error_message.
wuffs_base__io_buffer* io_buf = input.BringsItsOwnIOBuffer();
wuffs_base__io_buffer fallback_io_buf = wuffs_base__empty_io_buffer();
std::unique_ptr<uint8_t[]> fallback_io_array(nullptr);
if (!io_buf) {
fallback_io_array = std::unique_ptr<uint8_t[]>(new uint8_t[4096]);
fallback_io_buf = wuffs_base__ptr_u8__writer(fallback_io_array.get(), 4096);
io_buf = &fallback_io_buf;
}
size_t cursor_index = 0;
std::string ret_error_message;
std::string io_error_message;
do {
// Prepare the low-level CBOR decoder.
wuffs_cbor__decoder::unique_ptr dec = wuffs_cbor__decoder::alloc();
if (!dec) {
ret_error_message = "wuffs_aux::CborDecoder: out of memory";
goto done;
}
for (size_t i = 0; i < quirks.len; i++) {
dec->set_quirk_enabled(quirks.ptr[i], true);
}
// Prepare the wuffs_base__tok_buffer.
wuffs_base__token tok_array[256];
wuffs_base__token_buffer tok_buf =
wuffs_base__slice_token__writer(wuffs_base__make_slice_token(
&tok_array[0], (sizeof(tok_array) / sizeof(tok_array[0]))));
wuffs_base__status tok_status = wuffs_base__make_status(nullptr);
// Prepare other state.
uint32_t depth = 0;
std::string str;
int64_t extension_category = 0;
uint64_t extension_detail = 0;
// Valid token's VBCs range in 0 ..= 15. Values over that are for tokens
// from outside of the base package, such as the CBOR package.
constexpr int64_t EXT_CAT__CBOR_TAG = 16;
// Loop, doing these two things:
// 1. Get the next token.
// 2. Process that token.
while (true) {
// 1. Get the next token.
while (tok_buf.meta.ri >= tok_buf.meta.wi) {
if (tok_status.repr == nullptr) {
// No-op.
} else if (tok_status.repr == wuffs_base__suspension__short_write) {
tok_buf.compact();
} else if (tok_status.repr == wuffs_base__suspension__short_read) {
// Read from input to io_buf.
if (!io_error_message.empty()) {
ret_error_message = std::move(io_error_message);
goto done;
} else if (cursor_index != io_buf->meta.ri) {
ret_error_message =
"wuffs_aux::CborDecoder: internal error: bad cursor_index";
goto done;
} else if (io_buf->meta.closed) {
ret_error_message =
"wuffs_aux::CborDecoder: internal error: io_buf is closed";
goto done;
}
io_buf->compact();
if (io_buf->meta.wi >= io_buf->data.len) {
ret_error_message =
"wuffs_aux::CborDecoder: internal error: io_buf is full";
goto done;
}
cursor_index = io_buf->meta.ri;
io_error_message = input.CopyIn(io_buf);
} else {
ret_error_message = tok_status.message();
goto done;
}
if (WUFFS_CBOR__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE != 0) {
ret_error_message =
"wuffs_aux::CborDecoder: internal error: bad WORKBUF_LEN";
goto done;
}
wuffs_base__slice_u8 work_buf = wuffs_base__empty_slice_u8();
tok_status = dec->decode_tokens(&tok_buf, io_buf, work_buf);
}
wuffs_base__token token = tok_buf.data.ptr[tok_buf.meta.ri++];
uint64_t token_len = token.length();
if ((io_buf->meta.ri < cursor_index) ||
((io_buf->meta.ri - cursor_index) < token_len)) {
ret_error_message =
"wuffs_aux::CborDecoder: internal error: bad token indexes";
goto done;
}
uint8_t* token_ptr = io_buf->data.ptr + cursor_index;
cursor_index += token_len;
// 2. Process that token.
uint64_t vbd = token.value_base_detail();
if (extension_category != 0) {
int64_t ext = token.value_extension();
if ((ext >= 0) && !token.continued()) {
extension_detail = (extension_detail
<< WUFFS_BASE__TOKEN__VALUE_EXTENSION__NUM_BITS) |
static_cast<uint64_t>(ext);
switch (extension_category) {
case WUFFS_BASE__TOKEN__VBC__INLINE_INTEGER_SIGNED:
extension_category = 0;
ret_error_message =
callbacks.AppendI64(static_cast<int64_t>(extension_detail));
goto parsed_a_value;
case WUFFS_BASE__TOKEN__VBC__INLINE_INTEGER_UNSIGNED:
extension_category = 0;
ret_error_message = callbacks.AppendU64(extension_detail);
goto parsed_a_value;
case EXT_CAT__CBOR_TAG:
extension_category = 0;
ret_error_message = callbacks.AppendCborTag(extension_detail);
if (!ret_error_message.empty()) {
goto done;
}
continue;
}
}
ret_error_message =
"wuffs_aux::CborDecoder: internal error: bad extended token";
goto done;
}
switch (token.value_base_category()) {
case WUFFS_BASE__TOKEN__VBC__FILLER:
continue;
case WUFFS_BASE__TOKEN__VBC__STRUCTURE: {
if (vbd & WUFFS_BASE__TOKEN__VBD__STRUCTURE__PUSH) {
ret_error_message = callbacks.Push(static_cast<uint32_t>(vbd));
if (!ret_error_message.empty()) {
goto done;
}
depth++;
continue;
}
ret_error_message = callbacks.Pop(static_cast<uint32_t>(vbd));
depth--;
goto parsed_a_value;
}
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*>(token_ptr));
str.append(ptr, token_len);
} else {
goto fail;
}
if (token.continued()) {
continue;
}
ret_error_message =
(vbd & WUFFS_BASE__TOKEN__VBD__STRING__CHAIN_MUST_BE_UTF_8)
? callbacks.AppendTextString(std::move(str))
: callbacks.AppendByteString(std::move(str));
str.clear();
goto parsed_a_value;
}
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),
static_cast<uint32_t>(vbd));
const char* ptr = // Convert from (uint8_t*).
static_cast<const char*>(static_cast<void*>(&u[0]));
str.append(ptr, n);
if (token.continued()) {
continue;
}
goto fail;
}
case WUFFS_BASE__TOKEN__VBC__LITERAL: {
if (vbd & WUFFS_BASE__TOKEN__VBD__LITERAL__NULL) {
ret_error_message = callbacks.AppendNull();
} else if (vbd & WUFFS_BASE__TOKEN__VBD__LITERAL__UNDEFINED) {
ret_error_message = callbacks.AppendUndefined();
} else {
ret_error_message = callbacks.AppendBool(
vbd & WUFFS_BASE__TOKEN__VBD__LITERAL__TRUE);
}
goto parsed_a_value;
}
case WUFFS_BASE__TOKEN__VBC__NUMBER: {
const uint64_t cfp_fbbe_fifb =
WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_FLOATING_POINT |
WUFFS_BASE__TOKEN__VBD__NUMBER__FORMAT_BINARY_BIG_ENDIAN |
WUFFS_BASE__TOKEN__VBD__NUMBER__FORMAT_IGNORE_FIRST_BYTE;
if ((vbd & cfp_fbbe_fifb) == cfp_fbbe_fifb) {
double f;
switch (token_len) {
case 3:
f = wuffs_base__ieee_754_bit_representation__from_u16_to_f64(
wuffs_base__load_u16be__no_bounds_check(token_ptr + 1));
break;
case 5:
f = wuffs_base__ieee_754_bit_representation__from_u32_to_f64(
wuffs_base__load_u32be__no_bounds_check(token_ptr + 1));
break;
case 9:
f = wuffs_base__ieee_754_bit_representation__from_u64_to_f64(
wuffs_base__load_u64be__no_bounds_check(token_ptr + 1));
break;
default:
goto fail;
}
ret_error_message = callbacks.AppendF64(f);
goto parsed_a_value;
}
goto fail;
}
case WUFFS_BASE__TOKEN__VBC__INLINE_INTEGER_SIGNED: {
if (token.continued()) {
extension_category = WUFFS_BASE__TOKEN__VBC__INLINE_INTEGER_SIGNED;
extension_detail =
static_cast<uint64_t>(token.value_base_detail__sign_extended());
continue;
}
ret_error_message =
callbacks.AppendI64(token.value_base_detail__sign_extended());
goto parsed_a_value;
}
case WUFFS_BASE__TOKEN__VBC__INLINE_INTEGER_UNSIGNED: {
if (token.continued()) {
extension_category =
WUFFS_BASE__TOKEN__VBC__INLINE_INTEGER_UNSIGNED;
extension_detail = vbd;
continue;
}
ret_error_message = callbacks.AppendU64(vbd);
goto parsed_a_value;
}
}
if (token.value_major() == WUFFS_CBOR__TOKEN_VALUE_MAJOR) {
uint64_t value_minor = token.value_minor();
if (value_minor & WUFFS_CBOR__TOKEN_VALUE_MINOR__MINUS_1_MINUS_X) {
if (token_len == 9) {
ret_error_message = callbacks.AppendMinus1MinusX(
wuffs_base__load_u64be__no_bounds_check(token_ptr + 1));
goto parsed_a_value;
}
} else if (value_minor & WUFFS_CBOR__TOKEN_VALUE_MINOR__SIMPLE_VALUE) {
ret_error_message =
callbacks.AppendCborSimpleValue(static_cast<uint8_t>(
value_minor & WUFFS_CBOR__TOKEN_VALUE_MINOR__DETAIL_MASK));
goto parsed_a_value;
} else if (value_minor & WUFFS_CBOR__TOKEN_VALUE_MINOR__TAG) {
if (token.continued()) {
extension_category = EXT_CAT__CBOR_TAG;
extension_detail =
value_minor & WUFFS_CBOR__TOKEN_VALUE_MINOR__DETAIL_MASK;
continue;
}
ret_error_message = callbacks.AppendCborTag(
value_minor & WUFFS_CBOR__TOKEN_VALUE_MINOR__DETAIL_MASK);
if (!ret_error_message.empty()) {
goto done;
}
continue;
}
}
fail:
ret_error_message =
"wuffs_aux::CborDecoder: internal error: unexpected token";
goto done;
parsed_a_value:
if (!ret_error_message.empty() || (depth == 0)) {
goto done;
}
}
} while (false);
done:
DecodeCborResult result(
std::move(ret_error_message),
wuffs_base__u64__sat_add(io_buf->meta.pos, cursor_index));
callbacks.Done(result, input, *io_buf);
return result;
}
} // namespace wuffs_aux
#endif // !defined(WUFFS_CONFIG__MODULES) ||
// defined(WUFFS_CONFIG__MODULE__AUX__CBOR)
+80
View File
@@ -0,0 +1,80 @@
// After editing this file, run "go generate" in the ../data directory.
// 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.
// ---------------- Auxiliary - CBOR
namespace wuffs_aux {
struct DecodeCborResult {
DecodeCborResult(std::string&& error_message0, uint64_t cursor_position0);
std::string error_message;
uint64_t cursor_position;
};
class DecodeCborCallbacks {
public:
// AppendXxx are called for leaf nodes: literals, numbers, strings, etc.
virtual std::string AppendNull() = 0;
virtual std::string AppendUndefined() = 0;
virtual std::string AppendBool(bool val) = 0;
virtual std::string AppendF64(double val) = 0;
virtual std::string AppendI64(int64_t val) = 0;
virtual std::string AppendU64(uint64_t val) = 0;
virtual std::string AppendByteString(std::string&& val) = 0;
virtual std::string AppendTextString(std::string&& val) = 0;
virtual std::string AppendMinus1MinusX(uint64_t val) = 0;
virtual std::string AppendCborSimpleValue(uint8_t val) = 0;
virtual std::string AppendCborTag(uint64_t val) = 0;
// Push and Pop are called for container nodes: CBOR arrays (lists) and CBOR
// maps (dictionaries).
//
// The flags bits combine exactly one of:
// - WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_NONE
// - WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_LIST
// - WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_DICT
// and exactly one of:
// - WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_NONE
// - WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_LIST
// - WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_DICT
virtual std::string Push(uint32_t flags) = 0;
virtual std::string Pop(uint32_t flags) = 0;
// Done is always the last Callback method called by DecodeCbor, whether or
// not parsing the input as CBOR encountered an error. Even when successful,
// trailing data may remain in input and buffer.
//
// Do not keep a reference to buffer or buffer.data.ptr after Done returns,
// as DecodeCbor may then de-allocate the backing array.
virtual void Done(DecodeCborResult& result,
sync_io::Input& input,
IOBuffer& buffer);
};
// DecodeCbor calls callbacks based on the CBOR-formatted data in input.
//
// On success, the returned error_message is empty and cursor_position counts
// the number of bytes consumed. On failure, error_message is non-empty and
// cursor_position is the location of the error. That error may be a content
// error (invalid CBOR) or an input error (e.g. network failure).
DecodeCborResult DecodeCbor(DecodeCborCallbacks&& callbacks,
sync_io::Input&& input,
wuffs_base__slice_u32 quirks);
} // namespace wuffs_aux
+23
View File
@@ -625,6 +625,27 @@ const AuxBaseHh = "" +
"// --------\n\n} // namespace sync_io\n\n} // namespace wuffs_aux\n" +
""
const AuxCborCc = "" +
"// ---------------- Auxiliary - CBOR\n\n#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__AUX__CBOR)\n\n#include <utility>\n\nnamespace wuffs_aux {\n\nDecodeCborResult::DecodeCborResult(std::string&& error_message0,\n uint64_t cursor_position0)\n : error_message(std::move(error_message0)),\n cursor_position(cursor_position0) {}\n\nvoid DecodeCborCallbacks::Done(DecodeCborResult& result,\n sync_io::Input& input,\n IOBuffer& buffer) {}\n\nDecodeCborResult //\nDecodeCbor(DecodeCborCallbacks&& callbacks,\n sync_io::Input&& input,\n wuffs_base__slice_u32 quirks) {\n // Prepare the wuffs_base__io_buffer and the resultant error_message.\n wuffs_base__io_buffer* io_buf = input.BringsItsOwnIOBuffer();\n wuffs_base__io_buffer fallback_io_buf = wuffs_base__empty_io_buffer();\n std::unique_ptr<uint8_t[]> fallback_io_array(nullptr);\n if (!io_buf) {\n fallback_io_array = std::unique_ptr<uint8_t[]>(ne" +
"w uint8_t[4096]);\n fallback_io_buf = wuffs_base__ptr_u8__writer(fallback_io_array.get(), 4096);\n io_buf = &fallback_io_buf;\n }\n size_t cursor_index = 0;\n std::string ret_error_message;\n std::string io_error_message;\n\n do {\n // Prepare the low-level CBOR decoder.\n wuffs_cbor__decoder::unique_ptr dec = wuffs_cbor__decoder::alloc();\n if (!dec) {\n ret_error_message = \"wuffs_aux::CborDecoder: out of memory\";\n goto done;\n }\n for (size_t i = 0; i < quirks.len; i++) {\n dec->set_quirk_enabled(quirks.ptr[i], true);\n }\n\n // Prepare the wuffs_base__tok_buffer.\n wuffs_base__token tok_array[256];\n wuffs_base__token_buffer tok_buf =\n wuffs_base__slice_token__writer(wuffs_base__make_slice_token(\n &tok_array[0], (sizeof(tok_array) / sizeof(tok_array[0]))));\n wuffs_base__status tok_status = wuffs_base__make_status(nullptr);\n\n // Prepare other state.\n uint32_t depth = 0;\n std::string str;\n int64_t extension_category = 0;\n uint64_t extension" +
"_detail = 0;\n\n // Valid token's VBCs range in 0 ..= 15. Values over that are for tokens\n // from outside of the base package, such as the CBOR package.\n constexpr int64_t EXT_CAT__CBOR_TAG = 16;\n\n // Loop, doing these two things:\n // 1. Get the next token.\n // 2. Process that token.\n while (true) {\n // 1. Get the next token.\n\n while (tok_buf.meta.ri >= tok_buf.meta.wi) {\n if (tok_status.repr == nullptr) {\n // No-op.\n } else if (tok_status.repr == wuffs_base__suspension__short_write) {\n tok_buf.compact();\n } else if (tok_status.repr == wuffs_base__suspension__short_read) {\n // Read from input to io_buf.\n if (!io_error_message.empty()) {\n ret_error_message = std::move(io_error_message);\n goto done;\n } else if (cursor_index != io_buf->meta.ri) {\n ret_error_message =\n \"wuffs_aux::CborDecoder: internal error: bad cursor_index\";\n goto done;\n } else if" +
" (io_buf->meta.closed) {\n ret_error_message =\n \"wuffs_aux::CborDecoder: internal error: io_buf is closed\";\n goto done;\n }\n io_buf->compact();\n if (io_buf->meta.wi >= io_buf->data.len) {\n ret_error_message =\n \"wuffs_aux::CborDecoder: internal error: io_buf is full\";\n goto done;\n }\n cursor_index = io_buf->meta.ri;\n io_error_message = input.CopyIn(io_buf);\n } else {\n ret_error_message = tok_status.message();\n goto done;\n }\n\n if (WUFFS_CBOR__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE != 0) {\n ret_error_message =\n \"wuffs_aux::CborDecoder: internal error: bad WORKBUF_LEN\";\n goto done;\n }\n wuffs_base__slice_u8 work_buf = wuffs_base__empty_slice_u8();\n tok_status = dec->decode_tokens(&tok_buf, io_buf, work_buf);\n }\n\n wuffs_base__token token = tok_buf.data.ptr[tok_buf.meta.ri++];\n uint64_t t" +
"oken_len = token.length();\n if ((io_buf->meta.ri < cursor_index) ||\n ((io_buf->meta.ri - cursor_index) < token_len)) {\n ret_error_message =\n \"wuffs_aux::CborDecoder: internal error: bad token indexes\";\n goto done;\n }\n uint8_t* token_ptr = io_buf->data.ptr + cursor_index;\n cursor_index += token_len;\n\n // 2. Process that token.\n\n uint64_t vbd = token.value_base_detail();\n\n if (extension_category != 0) {\n int64_t ext = token.value_extension();\n if ((ext >= 0) && !token.continued()) {\n extension_detail = (extension_detail\n << WUFFS_BASE__TOKEN__VALUE_EXTENSION__NUM_BITS) |\n static_cast<uint64_t>(ext);\n switch (extension_category) {\n case WUFFS_BASE__TOKEN__VBC__INLINE_INTEGER_SIGNED:\n extension_category = 0;\n ret_error_message =\n callbacks.AppendI64(static_cast<int64_t>(extension_detail));\n g" +
"oto parsed_a_value;\n case WUFFS_BASE__TOKEN__VBC__INLINE_INTEGER_UNSIGNED:\n extension_category = 0;\n ret_error_message = callbacks.AppendU64(extension_detail);\n goto parsed_a_value;\n case EXT_CAT__CBOR_TAG:\n extension_category = 0;\n ret_error_message = callbacks.AppendCborTag(extension_detail);\n if (!ret_error_message.empty()) {\n goto done;\n }\n continue;\n }\n }\n ret_error_message =\n \"wuffs_aux::CborDecoder: internal error: bad extended token\";\n goto done;\n }\n\n switch (token.value_base_category()) {\n case WUFFS_BASE__TOKEN__VBC__FILLER:\n continue;\n\n case WUFFS_BASE__TOKEN__VBC__STRUCTURE: {\n if (vbd & WUFFS_BASE__TOKEN__VBD__STRUCTURE__PUSH) {\n ret_error_message = callbacks.Push(static_cast<uint32_t>(vbd));\n if (!ret_error_message.empty()) {\n goto done;\n " +
" }\n depth++;\n continue;\n }\n ret_error_message = callbacks.Pop(static_cast<uint32_t>(vbd));\n depth--;\n goto parsed_a_value;\n }\n\n case WUFFS_BASE__TOKEN__VBC__STRING: {\n if (vbd & WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_0_DST_1_SRC_DROP) {\n // No-op.\n } else if (vbd &\n WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_1_DST_1_SRC_COPY) {\n const char* ptr = // Convert from (uint8_t*).\n static_cast<const char*>(static_cast<void*>(token_ptr));\n str.append(ptr, token_len);\n } else {\n goto fail;\n }\n if (token.continued()) {\n continue;\n }\n ret_error_message =\n (vbd & WUFFS_BASE__TOKEN__VBD__STRING__CHAIN_MUST_BE_UTF_8)\n ? callbacks.AppendTextString(std::move(str))\n : callbacks.AppendByteString(std::move(str));\n str.clear();\n goto par" +
"sed_a_value;\n }\n\n case WUFFS_BASE__TOKEN__VBC__UNICODE_CODE_POINT: {\n uint8_t u[WUFFS_BASE__UTF_8__BYTE_LENGTH__MAX_INCL];\n size_t n = wuffs_base__utf_8__encode(\n wuffs_base__make_slice_u8(\n &u[0], WUFFS_BASE__UTF_8__BYTE_LENGTH__MAX_INCL),\n static_cast<uint32_t>(vbd));\n const char* ptr = // Convert from (uint8_t*).\n static_cast<const char*>(static_cast<void*>(&u[0]));\n str.append(ptr, n);\n if (token.continued()) {\n continue;\n }\n goto fail;\n }\n\n case WUFFS_BASE__TOKEN__VBC__LITERAL: {\n if (vbd & WUFFS_BASE__TOKEN__VBD__LITERAL__NULL) {\n ret_error_message = callbacks.AppendNull();\n } else if (vbd & WUFFS_BASE__TOKEN__VBD__LITERAL__UNDEFINED) {\n ret_error_message = callbacks.AppendUndefined();\n } else {\n ret_error_message = callbacks.AppendBool(\n vbd & WUFFS_BASE__TOKEN__VBD__LITER" +
"AL__TRUE);\n }\n goto parsed_a_value;\n }\n\n case WUFFS_BASE__TOKEN__VBC__NUMBER: {\n const uint64_t cfp_fbbe_fifb =\n WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_FLOATING_POINT |\n WUFFS_BASE__TOKEN__VBD__NUMBER__FORMAT_BINARY_BIG_ENDIAN |\n WUFFS_BASE__TOKEN__VBD__NUMBER__FORMAT_IGNORE_FIRST_BYTE;\n if ((vbd & cfp_fbbe_fifb) == cfp_fbbe_fifb) {\n double f;\n switch (token_len) {\n case 3:\n f = wuffs_base__ieee_754_bit_representation__from_u16_to_f64(\n wuffs_base__load_u16be__no_bounds_check(token_ptr + 1));\n break;\n case 5:\n f = wuffs_base__ieee_754_bit_representation__from_u32_to_f64(\n wuffs_base__load_u32be__no_bounds_check(token_ptr + 1));\n break;\n case 9:\n f = wuffs_base__ieee_754_bit_representation__from_u64_to_f64(\n wuffs_base__load_u64be__" +
"no_bounds_check(token_ptr + 1));\n break;\n default:\n goto fail;\n }\n ret_error_message = callbacks.AppendF64(f);\n goto parsed_a_value;\n }\n goto fail;\n }\n\n case WUFFS_BASE__TOKEN__VBC__INLINE_INTEGER_SIGNED: {\n if (token.continued()) {\n extension_category = WUFFS_BASE__TOKEN__VBC__INLINE_INTEGER_SIGNED;\n extension_detail =\n static_cast<uint64_t>(token.value_base_detail__sign_extended());\n continue;\n }\n ret_error_message =\n callbacks.AppendI64(token.value_base_detail__sign_extended());\n goto parsed_a_value;\n }\n\n case WUFFS_BASE__TOKEN__VBC__INLINE_INTEGER_UNSIGNED: {\n if (token.continued()) {\n extension_category =\n WUFFS_BASE__TOKEN__VBC__INLINE_INTEGER_UNSIGNED;\n extension_detail = vbd;\n continue;\n }\n ret_error_message = ca" +
"llbacks.AppendU64(vbd);\n goto parsed_a_value;\n }\n }\n\n if (token.value_major() == WUFFS_CBOR__TOKEN_VALUE_MAJOR) {\n uint64_t value_minor = token.value_minor();\n if (value_minor & WUFFS_CBOR__TOKEN_VALUE_MINOR__MINUS_1_MINUS_X) {\n if (token_len == 9) {\n ret_error_message = callbacks.AppendMinus1MinusX(\n wuffs_base__load_u64be__no_bounds_check(token_ptr + 1));\n goto parsed_a_value;\n }\n } else if (value_minor & WUFFS_CBOR__TOKEN_VALUE_MINOR__SIMPLE_VALUE) {\n ret_error_message =\n callbacks.AppendCborSimpleValue(static_cast<uint8_t>(\n value_minor & WUFFS_CBOR__TOKEN_VALUE_MINOR__DETAIL_MASK));\n goto parsed_a_value;\n } else if (value_minor & WUFFS_CBOR__TOKEN_VALUE_MINOR__TAG) {\n if (token.continued()) {\n extension_category = EXT_CAT__CBOR_TAG;\n extension_detail =\n value_minor & WUFFS_CBOR__TOKEN_VALUE_MINOR__DETAIL_" +
"MASK;\n continue;\n }\n ret_error_message = callbacks.AppendCborTag(\n value_minor & WUFFS_CBOR__TOKEN_VALUE_MINOR__DETAIL_MASK);\n if (!ret_error_message.empty()) {\n goto done;\n }\n continue;\n }\n }\n\n fail:\n ret_error_message =\n \"wuffs_aux::CborDecoder: internal error: unexpected token\";\n goto done;\n\n parsed_a_value:\n if (!ret_error_message.empty() || (depth == 0)) {\n goto done;\n }\n }\n } while (false);\n\ndone:\n DecodeCborResult result(\n std::move(ret_error_message),\n wuffs_base__u64__sat_add(io_buf->meta.pos, cursor_index));\n callbacks.Done(result, input, *io_buf);\n return result;\n}\n\n} // namespace wuffs_aux\n\n#endif // !defined(WUFFS_CONFIG__MODULES) ||\n // defined(WUFFS_CONFIG__MODULE__AUX__CBOR)\n" +
""
const AuxCborHh = "" +
"// ---------------- Auxiliary - CBOR\n\nnamespace wuffs_aux {\n\nstruct DecodeCborResult {\n DecodeCborResult(std::string&& error_message0, uint64_t cursor_position0);\n\n std::string error_message;\n uint64_t cursor_position;\n};\n\nclass DecodeCborCallbacks {\n public:\n // AppendXxx are called for leaf nodes: literals, numbers, strings, etc.\n\n virtual std::string AppendNull() = 0;\n virtual std::string AppendUndefined() = 0;\n virtual std::string AppendBool(bool val) = 0;\n virtual std::string AppendF64(double val) = 0;\n virtual std::string AppendI64(int64_t val) = 0;\n virtual std::string AppendU64(uint64_t val) = 0;\n virtual std::string AppendByteString(std::string&& val) = 0;\n virtual std::string AppendTextString(std::string&& val) = 0;\n virtual std::string AppendMinus1MinusX(uint64_t val) = 0;\n virtual std::string AppendCborSimpleValue(uint8_t val) = 0;\n virtual std::string AppendCborTag(uint64_t val) = 0;\n\n // Push and Pop are called for container nodes: CBOR arrays (lists) and CBOR\n // maps (dictiona" +
"ries).\n //\n // The flags bits combine exactly one of:\n // - WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_NONE\n // - WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_LIST\n // - WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_DICT\n // and exactly one of:\n // - WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_NONE\n // - WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_LIST\n // - WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_DICT\n\n virtual std::string Push(uint32_t flags) = 0;\n virtual std::string Pop(uint32_t flags) = 0;\n\n // Done is always the last Callback method called by DecodeCbor, whether or\n // not parsing the input as CBOR encountered an error. Even when successful,\n // trailing data may remain in input and buffer.\n //\n // Do not keep a reference to buffer or buffer.data.ptr after Done returns,\n // as DecodeCbor may then de-allocate the backing array.\n virtual void Done(DecodeCborResult& result,\n sync_io::Input& input,\n IOBuffer& buffer);\n};\n\n// DecodeCbor calls callbacks based on the CBOR-form" +
"atted data in input.\n//\n// On success, the returned error_message is empty and cursor_position counts\n// the number of bytes consumed. On failure, error_message is non-empty and\n// cursor_position is the location of the error. That error may be a content\n// error (invalid CBOR) or an input error (e.g. network failure).\nDecodeCborResult DecodeCbor(DecodeCborCallbacks&& callbacks,\n sync_io::Input&& input,\n wuffs_base__slice_u32 quirks);\n\n} // namespace wuffs_aux\n" +
""
const AuxJsonCc = "" +
"// ---------------- Auxiliary - JSON\n\n#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__AUX__JSON)\n\n#include <utility>\n\nnamespace wuffs_aux {\n\nDecodeJsonResult::DecodeJsonResult(std::string&& error_message0,\n uint64_t cursor_position0)\n : error_message(std::move(error_message0)),\n cursor_position(cursor_position0) {}\n\nDecodeJsonResult //\nDecodeJson(DecodeJsonCallbacks&& callbacks,\n sync_io::Input&& input,\n wuffs_base__slice_u32 quirks) {\n // Prepare the wuffs_base__io_buffer and the resultant error_message.\n wuffs_base__io_buffer* io_buf = input.BringsItsOwnIOBuffer();\n wuffs_base__io_buffer fallback_io_buf = wuffs_base__empty_io_buffer();\n std::unique_ptr<uint8_t[]> fallback_io_array(nullptr);\n if (!io_buf) {\n fallback_io_array = std::unique_ptr<uint8_t[]>(new uint8_t[4096]);\n fallback_io_buf = wuffs_base__ptr_u8__writer(fallback_io_array.get(), 4096);\n io_buf = &fallback_io_buf;\n }\n size_t cursor_index = 0;\n s" +
"td::string ret_error_message;\n std::string io_error_message;\n\n do {\n // Prepare the low-level JSON decoder.\n wuffs_json__decoder::unique_ptr dec = wuffs_json__decoder::alloc();\n if (!dec) {\n ret_error_message = \"wuffs_aux::JsonDecoder: out of memory\";\n goto done;\n }\n for (size_t i = 0; i < quirks.len; i++) {\n dec->set_quirk_enabled(quirks.ptr[i], true);\n }\n\n // Prepare the wuffs_base__tok_buffer.\n wuffs_base__token tok_array[256];\n wuffs_base__token_buffer tok_buf =\n wuffs_base__slice_token__writer(wuffs_base__make_slice_token(\n &tok_array[0], (sizeof(tok_array) / sizeof(tok_array[0]))));\n wuffs_base__status tok_status = wuffs_base__make_status(nullptr);\n\n // Prepare other state.\n uint32_t depth = 0;\n std::string str;\n\n // Loop, doing these two things:\n // 1. Get the next token.\n // 2. Process that token.\n while (true) {\n // 1. Get the next token.\n\n while (tok_buf.meta.ri >= tok_buf.meta.wi) {\n if (tok_sta" +
@@ -644,10 +665,12 @@ const AuxJsonHh = "" +
""
var AuxNonBaseCcFiles = []string{
AuxCborCc,
AuxJsonCc,
}
var AuxNonBaseHhFiles = []string{
AuxCborHh,
AuxJsonHh,
}
+2
View File
@@ -99,6 +99,8 @@ func genData(out *bytes.Buffer) error {
{"../auxiliary/base.cc", "AuxBaseCc"},
{"../auxiliary/base.hh", "AuxBaseHh"},
{"../auxiliary/cbor.cc", "AuxCborCc"},
{"../auxiliary/cbor.hh", "AuxCborHh"},
{"../auxiliary/json.cc", "AuxJsonCc"},
{"../auxiliary/json.hh", "AuxJsonHh"},
}
+395
View File
@@ -5648,6 +5648,8 @@ extern const char wuffs_cbor__error__unsupported_recursion_depth[];
// ---------------- Public Consts
#define WUFFS_CBOR__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 0
#define WUFFS_CBOR__TOKEN_VALUE_MAJOR 787997
#define WUFFS_CBOR__TOKEN_VALUE_MINOR__DETAIL_MASK 262143
@@ -8409,6 +8411,71 @@ class MemoryInput : public Input {
} // namespace wuffs_aux
// ---------------- Auxiliary - CBOR
namespace wuffs_aux {
struct DecodeCborResult {
DecodeCborResult(std::string&& error_message0, uint64_t cursor_position0);
std::string error_message;
uint64_t cursor_position;
};
class DecodeCborCallbacks {
public:
// AppendXxx are called for leaf nodes: literals, numbers, strings, etc.
virtual std::string AppendNull() = 0;
virtual std::string AppendUndefined() = 0;
virtual std::string AppendBool(bool val) = 0;
virtual std::string AppendF64(double val) = 0;
virtual std::string AppendI64(int64_t val) = 0;
virtual std::string AppendU64(uint64_t val) = 0;
virtual std::string AppendByteString(std::string&& val) = 0;
virtual std::string AppendTextString(std::string&& val) = 0;
virtual std::string AppendMinus1MinusX(uint64_t val) = 0;
virtual std::string AppendCborSimpleValue(uint8_t val) = 0;
virtual std::string AppendCborTag(uint64_t val) = 0;
// Push and Pop are called for container nodes: CBOR arrays (lists) and CBOR
// maps (dictionaries).
//
// The flags bits combine exactly one of:
// - WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_NONE
// - WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_LIST
// - WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_DICT
// and exactly one of:
// - WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_NONE
// - WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_LIST
// - WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_DICT
virtual std::string Push(uint32_t flags) = 0;
virtual std::string Pop(uint32_t flags) = 0;
// Done is always the last Callback method called by DecodeCbor, whether or
// not parsing the input as CBOR encountered an error. Even when successful,
// trailing data may remain in input and buffer.
//
// Do not keep a reference to buffer or buffer.data.ptr after Done returns,
// as DecodeCbor may then de-allocate the backing array.
virtual void Done(DecodeCborResult& result,
sync_io::Input& input,
IOBuffer& buffer);
};
// DecodeCbor calls callbacks based on the CBOR-formatted data in input.
//
// On success, the returned error_message is empty and cursor_position counts
// the number of bytes consumed. On failure, error_message is non-empty and
// cursor_position is the location of the error. That error may be a content
// error (invalid CBOR) or an input error (e.g. network failure).
DecodeCborResult DecodeCbor(DecodeCborCallbacks&& callbacks,
sync_io::Input&& input,
wuffs_base__slice_u32 quirks);
} // namespace wuffs_aux
// ---------------- Auxiliary - JSON
namespace wuffs_aux {
@@ -28859,6 +28926,334 @@ MemoryInput::CopyIn(IOBuffer* dst) {
#endif // !defined(WUFFS_CONFIG__MODULES) ||
// defined(WUFFS_CONFIG__MODULE__AUX__BASE)
// ---------------- Auxiliary - CBOR
#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__AUX__CBOR)
#include <utility>
namespace wuffs_aux {
DecodeCborResult::DecodeCborResult(std::string&& error_message0,
uint64_t cursor_position0)
: error_message(std::move(error_message0)),
cursor_position(cursor_position0) {}
void DecodeCborCallbacks::Done(DecodeCborResult& result,
sync_io::Input& input,
IOBuffer& buffer) {}
DecodeCborResult //
DecodeCbor(DecodeCborCallbacks&& callbacks,
sync_io::Input&& input,
wuffs_base__slice_u32 quirks) {
// Prepare the wuffs_base__io_buffer and the resultant error_message.
wuffs_base__io_buffer* io_buf = input.BringsItsOwnIOBuffer();
wuffs_base__io_buffer fallback_io_buf = wuffs_base__empty_io_buffer();
std::unique_ptr<uint8_t[]> fallback_io_array(nullptr);
if (!io_buf) {
fallback_io_array = std::unique_ptr<uint8_t[]>(new uint8_t[4096]);
fallback_io_buf = wuffs_base__ptr_u8__writer(fallback_io_array.get(), 4096);
io_buf = &fallback_io_buf;
}
size_t cursor_index = 0;
std::string ret_error_message;
std::string io_error_message;
do {
// Prepare the low-level CBOR decoder.
wuffs_cbor__decoder::unique_ptr dec = wuffs_cbor__decoder::alloc();
if (!dec) {
ret_error_message = "wuffs_aux::CborDecoder: out of memory";
goto done;
}
for (size_t i = 0; i < quirks.len; i++) {
dec->set_quirk_enabled(quirks.ptr[i], true);
}
// Prepare the wuffs_base__tok_buffer.
wuffs_base__token tok_array[256];
wuffs_base__token_buffer tok_buf =
wuffs_base__slice_token__writer(wuffs_base__make_slice_token(
&tok_array[0], (sizeof(tok_array) / sizeof(tok_array[0]))));
wuffs_base__status tok_status = wuffs_base__make_status(nullptr);
// Prepare other state.
uint32_t depth = 0;
std::string str;
int64_t extension_category = 0;
uint64_t extension_detail = 0;
// Valid token's VBCs range in 0 ..= 15. Values over that are for tokens
// from outside of the base package, such as the CBOR package.
constexpr int64_t EXT_CAT__CBOR_TAG = 16;
// Loop, doing these two things:
// 1. Get the next token.
// 2. Process that token.
while (true) {
// 1. Get the next token.
while (tok_buf.meta.ri >= tok_buf.meta.wi) {
if (tok_status.repr == nullptr) {
// No-op.
} else if (tok_status.repr == wuffs_base__suspension__short_write) {
tok_buf.compact();
} else if (tok_status.repr == wuffs_base__suspension__short_read) {
// Read from input to io_buf.
if (!io_error_message.empty()) {
ret_error_message = std::move(io_error_message);
goto done;
} else if (cursor_index != io_buf->meta.ri) {
ret_error_message =
"wuffs_aux::CborDecoder: internal error: bad cursor_index";
goto done;
} else if (io_buf->meta.closed) {
ret_error_message =
"wuffs_aux::CborDecoder: internal error: io_buf is closed";
goto done;
}
io_buf->compact();
if (io_buf->meta.wi >= io_buf->data.len) {
ret_error_message =
"wuffs_aux::CborDecoder: internal error: io_buf is full";
goto done;
}
cursor_index = io_buf->meta.ri;
io_error_message = input.CopyIn(io_buf);
} else {
ret_error_message = tok_status.message();
goto done;
}
if (WUFFS_CBOR__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE != 0) {
ret_error_message =
"wuffs_aux::CborDecoder: internal error: bad WORKBUF_LEN";
goto done;
}
wuffs_base__slice_u8 work_buf = wuffs_base__empty_slice_u8();
tok_status = dec->decode_tokens(&tok_buf, io_buf, work_buf);
}
wuffs_base__token token = tok_buf.data.ptr[tok_buf.meta.ri++];
uint64_t token_len = token.length();
if ((io_buf->meta.ri < cursor_index) ||
((io_buf->meta.ri - cursor_index) < token_len)) {
ret_error_message =
"wuffs_aux::CborDecoder: internal error: bad token indexes";
goto done;
}
uint8_t* token_ptr = io_buf->data.ptr + cursor_index;
cursor_index += token_len;
// 2. Process that token.
uint64_t vbd = token.value_base_detail();
if (extension_category != 0) {
int64_t ext = token.value_extension();
if ((ext >= 0) && !token.continued()) {
extension_detail = (extension_detail
<< WUFFS_BASE__TOKEN__VALUE_EXTENSION__NUM_BITS) |
static_cast<uint64_t>(ext);
switch (extension_category) {
case WUFFS_BASE__TOKEN__VBC__INLINE_INTEGER_SIGNED:
extension_category = 0;
ret_error_message =
callbacks.AppendI64(static_cast<int64_t>(extension_detail));
goto parsed_a_value;
case WUFFS_BASE__TOKEN__VBC__INLINE_INTEGER_UNSIGNED:
extension_category = 0;
ret_error_message = callbacks.AppendU64(extension_detail);
goto parsed_a_value;
case EXT_CAT__CBOR_TAG:
extension_category = 0;
ret_error_message = callbacks.AppendCborTag(extension_detail);
if (!ret_error_message.empty()) {
goto done;
}
continue;
}
}
ret_error_message =
"wuffs_aux::CborDecoder: internal error: bad extended token";
goto done;
}
switch (token.value_base_category()) {
case WUFFS_BASE__TOKEN__VBC__FILLER:
continue;
case WUFFS_BASE__TOKEN__VBC__STRUCTURE: {
if (vbd & WUFFS_BASE__TOKEN__VBD__STRUCTURE__PUSH) {
ret_error_message = callbacks.Push(static_cast<uint32_t>(vbd));
if (!ret_error_message.empty()) {
goto done;
}
depth++;
continue;
}
ret_error_message = callbacks.Pop(static_cast<uint32_t>(vbd));
depth--;
goto parsed_a_value;
}
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*>(token_ptr));
str.append(ptr, token_len);
} else {
goto fail;
}
if (token.continued()) {
continue;
}
ret_error_message =
(vbd & WUFFS_BASE__TOKEN__VBD__STRING__CHAIN_MUST_BE_UTF_8)
? callbacks.AppendTextString(std::move(str))
: callbacks.AppendByteString(std::move(str));
str.clear();
goto parsed_a_value;
}
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),
static_cast<uint32_t>(vbd));
const char* ptr = // Convert from (uint8_t*).
static_cast<const char*>(static_cast<void*>(&u[0]));
str.append(ptr, n);
if (token.continued()) {
continue;
}
goto fail;
}
case WUFFS_BASE__TOKEN__VBC__LITERAL: {
if (vbd & WUFFS_BASE__TOKEN__VBD__LITERAL__NULL) {
ret_error_message = callbacks.AppendNull();
} else if (vbd & WUFFS_BASE__TOKEN__VBD__LITERAL__UNDEFINED) {
ret_error_message = callbacks.AppendUndefined();
} else {
ret_error_message = callbacks.AppendBool(
vbd & WUFFS_BASE__TOKEN__VBD__LITERAL__TRUE);
}
goto parsed_a_value;
}
case WUFFS_BASE__TOKEN__VBC__NUMBER: {
const uint64_t cfp_fbbe_fifb =
WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_FLOATING_POINT |
WUFFS_BASE__TOKEN__VBD__NUMBER__FORMAT_BINARY_BIG_ENDIAN |
WUFFS_BASE__TOKEN__VBD__NUMBER__FORMAT_IGNORE_FIRST_BYTE;
if ((vbd & cfp_fbbe_fifb) == cfp_fbbe_fifb) {
double f;
switch (token_len) {
case 3:
f = wuffs_base__ieee_754_bit_representation__from_u16_to_f64(
wuffs_base__load_u16be__no_bounds_check(token_ptr + 1));
break;
case 5:
f = wuffs_base__ieee_754_bit_representation__from_u32_to_f64(
wuffs_base__load_u32be__no_bounds_check(token_ptr + 1));
break;
case 9:
f = wuffs_base__ieee_754_bit_representation__from_u64_to_f64(
wuffs_base__load_u64be__no_bounds_check(token_ptr + 1));
break;
default:
goto fail;
}
ret_error_message = callbacks.AppendF64(f);
goto parsed_a_value;
}
goto fail;
}
case WUFFS_BASE__TOKEN__VBC__INLINE_INTEGER_SIGNED: {
if (token.continued()) {
extension_category = WUFFS_BASE__TOKEN__VBC__INLINE_INTEGER_SIGNED;
extension_detail =
static_cast<uint64_t>(token.value_base_detail__sign_extended());
continue;
}
ret_error_message =
callbacks.AppendI64(token.value_base_detail__sign_extended());
goto parsed_a_value;
}
case WUFFS_BASE__TOKEN__VBC__INLINE_INTEGER_UNSIGNED: {
if (token.continued()) {
extension_category =
WUFFS_BASE__TOKEN__VBC__INLINE_INTEGER_UNSIGNED;
extension_detail = vbd;
continue;
}
ret_error_message = callbacks.AppendU64(vbd);
goto parsed_a_value;
}
}
if (token.value_major() == WUFFS_CBOR__TOKEN_VALUE_MAJOR) {
uint64_t value_minor = token.value_minor();
if (value_minor & WUFFS_CBOR__TOKEN_VALUE_MINOR__MINUS_1_MINUS_X) {
if (token_len == 9) {
ret_error_message = callbacks.AppendMinus1MinusX(
wuffs_base__load_u64be__no_bounds_check(token_ptr + 1));
goto parsed_a_value;
}
} else if (value_minor & WUFFS_CBOR__TOKEN_VALUE_MINOR__SIMPLE_VALUE) {
ret_error_message =
callbacks.AppendCborSimpleValue(static_cast<uint8_t>(
value_minor & WUFFS_CBOR__TOKEN_VALUE_MINOR__DETAIL_MASK));
goto parsed_a_value;
} else if (value_minor & WUFFS_CBOR__TOKEN_VALUE_MINOR__TAG) {
if (token.continued()) {
extension_category = EXT_CAT__CBOR_TAG;
extension_detail =
value_minor & WUFFS_CBOR__TOKEN_VALUE_MINOR__DETAIL_MASK;
continue;
}
ret_error_message = callbacks.AppendCborTag(
value_minor & WUFFS_CBOR__TOKEN_VALUE_MINOR__DETAIL_MASK);
if (!ret_error_message.empty()) {
goto done;
}
continue;
}
}
fail:
ret_error_message =
"wuffs_aux::CborDecoder: internal error: unexpected token";
goto done;
parsed_a_value:
if (!ret_error_message.empty() || (depth == 0)) {
goto done;
}
}
} while (false);
done:
DecodeCborResult result(
std::move(ret_error_message),
wuffs_base__u64__sat_add(io_buf->meta.pos, cursor_index));
callbacks.Done(result, input, *io_buf);
return result;
}
} // namespace wuffs_aux
#endif // !defined(WUFFS_CONFIG__MODULES) ||
// defined(WUFFS_CONFIG__MODULE__AUX__CBOR)
// ---------------- Auxiliary - JSON
#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__AUX__JSON)
+2
View File
@@ -18,6 +18,8 @@ pub status "#unsupported recursion depth"
pri status "#internal error: inconsistent I/O"
pri status "#internal error: inconsistent token length"
pub const DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE : base.u64 = 0
// TOKEN_VALUE_MAJOR is the base-38 encoding of "cbor".
pub const TOKEN_VALUE_MAJOR : base.u32 = 0x0C_061D
+2 -1
View File
@@ -34,7 +34,8 @@ world examples of various file formats, or deriviations of them.
<nigeltao@golang.org>.
`cbor-rfc-7049-examples.cbor` is the concatenated examples from RFC 7049. The
`cbor-rfc-7049-examples.*.json` files were then generated by `example/jsonptr`.
`cbor-rfc-7049-examples.*.json` files were then generated by
`example/cbor-to-json`.
`crude-flag.*` is an original animation by Nigel Tao
<nigeltao@golang.org>. See the `lib/nie` documentation.