mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-17 16:32:11 +01:00
Add example/cbor-to-json
This commit is contained in:
1 parent
9dd8c32683
commit
0b7eaf291b
9 files changed
+1511
-1
No files matched your search
@@ -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`.
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
@@ -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)
|
||||
@@ -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
|
||||
@@ -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,
|
||||
}
|
||||
|
||||
|
||||
@@ -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"},
|
||||
}
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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
@@ -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.
|
||||
|
||||
Reference in new issue
Block a user