lecp: add CBOR stream parser LECP like JSON LEJP
This provides very memory-efficient CBOR stream parsing
and writing.
The parser converts pieces of CBOR into callbacks that define
the structure and collate string and blobs into buffer chunks
for extensible and easy access.
It is fragementation-safe and does not need all the CBOR in
the same place at one time, chunks of CBOR are parsed and
discarded as provided.
It does not allocate and just needs a few hundred bytes of
stack for even huge CBOR objects. Huge strings and blobs
are handled without needing memory to hold them atomically.
Includes ./minimal-examples/api-tests/api-test-lecp that
unit tests it against 82 official example CBORs and
26 additional test vectors from COSE (just checking the CBOR
parsing).
The writing apis allow printf style semantics with a variety
of CBOR-aware %-formats. The apis write into a context that
manages output buffer usage, if the output buffer fills,
then the apis return with an AGAIN code that lets you issue
and reset the output buffer and repeat the api all to issue
more output. The subsequent calls can occur much later or
from a different function context, so this is perfect for
WRITEABLE-mediated output from the network parts of lws.
See ./READMEs/README.cbor-lecp.md
diff --git a/.sai.json b/.sai.json
index 1365d5c..fbaab56 100644
--- a/.sai.json
+++ b/.sai.json
@@ -130,7 +130,7 @@
"platforms": "w10/x86_64-amd/msvc, w10/x86_64-amd/noptmsvc, freertos-linkit/arm32-m4-mt7697-usi/gcc, linux-ubuntu-2004/aarch64-a72-bcm2711-rpi4/gcc, w10/x86_64-amd/mingw32, w10/x86_64-amd/mingw64, netbsd/aarch64BE-bcm2837-a53/gcc, netbsd/x86_64-amd/gcc, w10/x86_64-amd/wmbedtlsmsvc"
},
"fault-injection": {
- "cmake": "-DLWS_WITH_SYS_FAULT_INJECTION=1 -DLWS_WITH_MINIMAL_EXAMPLES=1",
+ "cmake": "-DLWS_WITH_SYS_FAULT_INJECTION=1 -DLWS_WITH_MINIMAL_EXAMPLES=1 -DLWS_WITH_CBOR=1",
"platforms": "w10/x86_64-amd/msvc"
},
"esp32-heltec": {
@@ -139,7 +139,7 @@
"platforms": "none, freertos-espidf/xl6-esp32/gcc"
},
"esp32-wrover": {
- "cmake": "-DLWS_IPV6=0",
+ "cmake": "-DLWS_IPV6=0 -DLWS_WITH_CBOR=1",
"cpack": "esp-wrover-kit",
"platforms": "none, freertos-espidf/xl6-esp32/gcc"
},
diff --git a/CMakeLists.txt b/CMakeLists.txt
index afdd5ca..d92cd63 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -231,6 +231,8 @@
option(LWS_WITHOUT_DAEMONIZE "Don't build the daemonization api" ON)
option(LWS_SSL_SERVER_WITH_ECDH_CERT "Include SSL server use ECDH certificate" OFF)
option(LWS_WITH_LEJP "With the Lightweight JSON Parser" ON)
+option(LWS_WITH_CBOR "With the Lightweight LECP CBOR Parser" OFF)
+option(LWS_WITH_CBOR_FLOAT "Build floating point types if building CBOR LECP" ON)
option(LWS_WITH_SQLITE3 "Require SQLITE3 support" OFF)
option(LWS_WITH_STRUCT_JSON "Generic struct serialization to and from JSON" OFF)
option(LWS_WITH_STRUCT_SQLITE3 "Generic struct serialization to and from SQLITE3" OFF)
diff --git a/LICENSE b/LICENSE
index 2135e32..917f8dc 100644
--- a/LICENSE
+++ b/LICENSE
@@ -8,9 +8,10 @@
- lib/misc/sha-1.c - 3-clause BSD license retained, link to original [BSD3]
- win32port/zlib - ZLIB license (see zlib.h) [ZLIB]
- - lib/tls/mbedtls/wrapper - Apache 2.0 (only built if linked against mbedtls) {APACHE2]
+ - lib/tls/mbedtls/wrapper - Apache 2.0 (only built if linked against mbedtls) [APACHE2]
lib/tls/mbedtls/mbedtls-extensions.c
- lib/misc/base64-decode.c - already MIT
+ - lib/misc/ieeehalfprecision.c - 2-clause BSD license retained [BSD2]
Relicensed to MIT:
@@ -55,6 +56,31 @@
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
IN THE SOFTWARE.
+## BSD2
+
+```
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the distribution
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+```
## BSD3
diff --git a/READMEs/README.cbor-lecp.md b/READMEs/README.cbor-lecp.md
new file mode 100644
index 0000000..109dc0c
--- /dev/null
+++ b/READMEs/README.cbor-lecp.md
@@ -0,0 +1,344 @@
+# RFC8949 CBOR Stream Parsing and Writing
+
+|||
+|---|---|---|
+|cmake| `LWS_WITH_CBOR`, `LWS_WITH_CBOR_FLOAT`|
+|Header| ./include/libwebsockets/lws-lecp.h|
+|api-test| ./minimal-examples/api-tests/api-test-lecp/|
+|test app| ./test-apps/test-lecp.c -> libwebsockets-test-lecp|
+
+LECP is the RFC8949 CBOR stream parsing counterpart to LEJP for JSON.
+
+## Features
+
+ - Completely immune to input fragmentation, give it any size blocks of CBOR as
+ they become available; 1 byte, or 100K at a time give identical parsing
+ results
+ - Input chunks discarded as they are parsed, whole CBOR never needed in memory
+ - Nonrecursive, fixed stack usage of a few dozen bytes
+ - No heap allocations at all, just requires ~500 byte context usually on
+ caller stack
+ - Creates callbacks to a user-provided handler as members are parsed out
+ - No payload size limit, supports huge / endless strings or blobs bigger than
+ system memory
+ - Collates utf-8 text and blob payloads into a 250-byte chunk buffer for ease
+ of access
+ - Write apis don't use any heap allocations or recursion either
+ - Write apis use an explicit context with its own lifecycle, and printf style
+ vaargs including sized blobs, C strings, double, int, unsigned long etc
+ - Completely immune to output fragmentation, supports huge strings and blobs
+ into small buffers, api returns to indicates unfinished if it needs to be
+ called again to continue; 1 byte or 100K output buffer give same results
+ - Write apis completely fill available buffer and if unfinished, continues
+ into same or different buffer when called again with same args; no
+ requirement for subsequent calls to be done sequentially or even from same
+ function
+
+## Type limits
+
+CBOR allows negative integers of up to 64 bits, these do not fit into a `uint64_t`.
+LECP has a union for numbers that includes the types `uint64_t` and `int64_t`,
+but it does not separately handle negative integers. Only -2^63.. 2^64 -1 can
+be handled by the C types, the oversize negative numbers wrap and should be
+avoided.
+
+## Floating point support
+
+Floats are handled using the IEEE memory format, it means they can be parsed
+from the CBOR without needing any floating point support in the build. If
+floating point is available, you can also enable `LWS_WITH_CBOR_FLOAT` and
+a `float` and `double` types are available in the number item union. Otherwise
+these are handled as `ctx->item.u.u32` and `ctx->item.u.u64` union members.
+
+Half-float (16-bit) is defined in CBOR and always handled as a `uint16_t`
+number union member `ctx->item.u.hf`.
+
+## Callback reasons
+
+The user callback does not have to handle any callbacks, it only needs to
+process the data for the ones it is interested in.
+
+|Callback reason|CBOR structure|Associated data|
+|---|---|---|
+|`LECPCB_CONSTRUCTED`|Created the parse context||
+|`LECPCB_DESTRUCTED`|Destroyed the parse context||
+|`LECPCB_COMPLETE`|The parsing completed OK||
+|`LECPCB_FAILED`|The parsing failed||
+|`LECPCB_VAL_TRUE`|boolean true||
+|`LECPCB_VAL_FALSE`|boolean false||
+|`LECPCB_VAL_NULL`|explicit NULL||
+|`LECPCB_VAL_NUM_INT`|signed integer|`ctx->item.u.i64`|
+|`LECPCB_VAL_STR_START`|A UTF-8 string is starting||
+|`LECPCB_VAL_STR_CHUNK`|The next string chunk|`ctx->npos` bytes in `ctx->buf`|
+|`LECPCB_VAL_STR_END`|The last string chunk|`ctx->npos` bytes in `ctx->buf`|
+|`LECPCB_ARRAY_START`|An array is starting||
+|`LECPCB_ARRAY_END`|An array has ended||
+|`LECPCB_OBJECT_START`|A CBOR map is starting||
+|`LECPCB_OBJECT_END`|A CBOR map has ended||
+|`LECPCB_TAG_START`|The following data has a tag index|`ctx->item.u.u64`|
+|`LECPCB_TAG_END`|The end of the data referenced by the last tag||
+|`LECPCB_VAL_NUM_UINT`|Unsigned integer|`ctx->item.u.u64`|
+|`LECPCB_VAL_UNDEFINED`|CBOR undefined||
+|`LECPCB_VAL_FLOAT16`|half-float available as host-endian `uint16_t`|`ctx->item.u.hf`|
+|`LECPCB_VAL_FLOAT32`|`float` (`uint32_t` if no float support) available|`ctx->item.u.f`|
+|`LECPCB_VAL_FLOAT64`|`double` (`uint64_t` if no float support) available|`ctx->item.u.d`|
+|`LECPCB_VAL_SIMPLE`|CBOR simple|`ctx->item.u.u64`|
+|`LECPCB_VAL_BLOB_START`|A binary blob is starting||
+|`LECPCB_VAL_BLOB_CHUNK`|The next blob chunk|`ctx->npos` bytes in `ctx->buf`|
+|`LECPCB_VAL_BLOB_END`|The last blob chunk|`ctx->npos` bytes in `ctx->buf`|
+|`LECPCB_ARRAY_ITEM_START`|A logical item in an array is starting|
+|`LCEPDB_ARRAY_ITEM_END`|A logical item in an array has completed|
+
+## CBOR indeterminite lengths
+
+Indeterminite lengths are supported, but are concealed in the parser as far as
+possible, the CBOR lengths or its indeterminacy are not exposed in the callback
+interface at all, just chunks of data that may be the start, the middle, or the
+end.
+
+## Handling CBOR UTF-8 strings and blobs
+
+When a string or blob is parsed, an advisory callback of `LECPCB_VAL_STR_START` or
+`LECPCB_VAL_BLOB_START` occurs first. The `_STR_` callbacks indicate the
+content is a CBOR UTF-8 string, `_BLOB_` indicates it is binary data.
+
+Strings or blobs may have indeterminite length, but if so, they are composed
+of logical chunks which must have known lengths. When the `_START` callback
+occurs, the logical length either of the whole string, or of the sub-chunk if
+indeterminite length, can be found in `ctx->item.u.u64`.
+
+Payload is collated into `ctx->buf[]`, the valid length is in `ctx->npos`.
+
+For short strings or blobs where the length is known, the whole payload is
+delivered in a single `LECPCB_VAL_STR_END` or `LECPCB_VAL_BLOB_END` callback.
+
+For payloads larger than the size of `ctx->buf[]`, `LECPCB_VAL_STR_CHUNK` or
+`LECPCB_VAL_BLOB_CHUNK` callbacks occur delivering each sequential bufferload.
+If the CBOR indicates the total length, the last chunk is delievered in a
+`LECPCB_VAL_STR_END` or `LECPCB_VAL_BLOB_END`.
+
+If the CBOR indicates the string end after the chunk, a zero-length `..._END`
+callback is provided.
+
+## Handling CBOR tags
+
+CBOR tags are exposed as `LECPCB_TAG_START` and `LECPCB_TAG_END` pairs, at
+the `_START` callback the tag index is available in `ctx->item.u.u64`.
+
+## CBOR maps
+
+You can check if you are on the "key" part of a map "key:value" pair using the
+helper api `lecp_parse_map_is_key(ctx)`.
+
+## Parsing paths
+
+LECP maintains a "parsing path" in `ctx->path` that represents the context of
+the callback events. As a convenience, at LECP context creation time, you can
+pass in an array of path strings you want to match on, and have any match
+checkable in the callback using `ctx->path_match`, it's 0 if no active match,
+or the match index from your path array starting from 1 for the first entry.
+
+|CBOR element|Representation in path|
+|---|---|
+|CBOR Array|`[]`|
+|CBOR Map|`.`|
+|CBOR Map entry key string|`keystring`|
+
+## Accessing raw CBOR subtrees
+
+Some CBOR usages like COSE require access to selected raw CBOR from the input
+stream. `lecp_parse_report_raw(ctx, on)` lets you turn on and off buffering of
+raw CBOR and reporting it in the parse callback with `LECPCB_LITERAL_CBOR`
+callbacks. The callbacks mean the temp buffer `ctx->cbor[]` has `ctx->cbor_pos`
+bytes of raw CBOR available in it. Callbacks are triggered when the buffer
+fills, or reporting is turned off and the buffer has something in it.
+
+By turning the reporting on and off according to the outer CBOR parsing state,
+it's possible to get exactly the raw CBOR subtree that's needed.
+
+Capturing and reporting the raw CBOR does not change that the same CBOR is being
+passed to the parser as usual as well.
+
+## Comparison with LEJP (JSON parser)
+
+LECP is based on the same principles as LEJP and shares most of the callbacks.
+The major differences:
+
+ - LEJP value callbacks all appear in `ctx->buf[]`, ie, floating-point is
+ provided to the callback in ascii form like `"1.0"`. CBOR provides a more
+ strict typing system, and the different type values are provided either in
+ `ctx->buf[]` for blobs or utf-8 text strtings, or the `item.u` union for
+ converted types, with additional callback reasons specific to each type.
+
+ - CBOR "maps" use `_OBJECT_START` and `_END` parsing callbacks around the
+ key / value pairs. LEJP has a special callback type `PAIR_NAME` for the
+ key string / integer, but in LECP these are provided as generic callbacks
+ dependent on type, ie, generic string callbacks or integer ones, and the
+ value part is represented according to whatever comes.
+
+
+# Writing CBOR
+
+CBOR is written into a `lws_lec_pctx_t` object that has been initialized to
+point to an output buffer of a specified size, using printf type formatting.
+
+Output is paused if the buffer fills, and the write api may be called again
+later with the same context object, to resume emitting to the same or different
+buffer.
+
+This allows bufferloads of encoded CBOR to be produced on demand, it's designed
+to fit usage in WRITEABLE callbacks and Secure Streams tx() callbacks where the
+buffer size for one packet is already fixed.
+
+CBOR array and map lengths are deduced from the format string, as is whether to
+use indeterminite length formatting or not. For indeterminite text or binary
+strings, a container of < >
+
+|Format|Arg(s)|Meaning|
+|---|---|---|
+|`123`||unsigned literal number|
+|`-123`||signed literal number|
+|`%u`|`unsigned int`|number|
+|`%lu`|`unsigned long int`|number|
+|`%llu`|`unsigned long long int`|number|
+|`%d`|`signed int`|number|
+|`%ld`|`signed long int`|number|
+|`%lld`|`signed long long int`|number|
+|`%f`|`double`|floating point number|
+|`123(...)`||literal tag and scope|
+|`%t(...)`|`unsigned int`|tag and scope|
+|`%lt(...)`|`unsigned long int`|tag and scope|
+|`%llt(...)`|`unsigned long long int`|tag and scope|
+|`[...]`||Array (fixed len if `]` in same format string)|
+|`{...}`||Map (fixed len if `}` in same format string)|
+|`<t...>`||Container for indeterminite text string frags|
+|`<b...>`||Container for indeterminite binary string frags|
+|`'string'`||Literal text of known length|
+|`%s`|`const char *`|NUL-terminated string|
+|`%.*s`|`int`, `const char *`|length-specified string|
+|`%.*b`|`int`, `const uint8_t *`|length-specified binary|
+|`:`||separator between Map items (a:b)|
+|`,`||separator between Map pairs or array items|
+
+Backslash is used as an escape in `'...'` literal strings, so `'\\'` represents
+a string consisting of a single backslash, and `'\''` a string consisting of a
+single single-quote.
+
+For integers, various natural C types are available, but in all cases, the
+number is represented in CBOR using the smallest valid way based on its value,
+the long or long-long modifiers just apply to the expected C type in the args.
+
+For floats, the C argument is always expected to be a `double` type following
+C type promotion, but again it is represented in CBOR using the smallest valid
+way based on value, half-floats are used for NaN / Infinity and where possible
+for values like 0.0 and -1.0.
+
+## Examples
+
+### Literal ints
+
+```
+ uint8_t buf[128];
+ lws_lec_pctx_t cbw;
+
+ lws_lec_init(&cbw, buf, sizeof(buf));
+ lws_lec_printf(ctx, "-1");
+```
+|||
+|---|---|
+|Return| `LWS_LECPCTX_RET_FINISHED`|
+|`ctx->used`|1|
+|`buf[]`|20|
+
+### Dynamic ints
+
+```
+ uint8_t buf[128];
+ lws_lec_pctx_t cbw;
+ int n = -1; /* could be long */
+
+ lws_lec_init(&cbw, buf, sizeof(buf));
+ lws_lec_printf(ctx, "%d", n); /* use %ld for long */
+```
+|||
+|---|---|
+|Return| `LWS_LECPCTX_RET_FINISHED`|
+|`ctx->used`|1|
+|`buf[]`|20|
+
+### Maps, arrays and dynamic ints
+
+```
+ ...
+ int args[3] = { 1, 2, 3 };
+
+ lws_lec_printf(ctx, "{'a':%d,'b':[%d,%d]}", args[0], args[1], args[2]);
+```
+
+|||
+|---|---|
+|Return| `LWS_LECPCTX_RET_FINISHED`|
+|`ctx->used`|9|
+|`buf[]`|A2 61 61 01 61 62 82 02 03|
+
+### String longer than the buffer
+
+Using `%s` and the same string as an arg gives same results
+
+```
+ uint8_t buf[16];
+ lws_lec_pctx_t cbw;
+
+ lws_lec_init(&cbw, buf, sizeof(buf));
+ lws_lec_printf(ctx, "'A literal string > one buf'");
+ /* not required to be in same function context or same buf,
+ * but the string must remain the same */
+ lws_lec_setbuf(&cbw, buf, sizeof(buf));
+ lws_lec_printf(ctx, "'A literal string > one buf'");
+```
+
+First call
+
+|||
+|---|---|
+|Return| `LWS_LECPCTX_RET_AGAIN`|
+|`ctx->used`|16|
+|`buf[]`|78 1A 41 20 6C 69 74 65 72 61 6C 20 73 74 72 69|
+
+Second call
+
+|||
+|---|---|
+|Return| `LWS_LECPCTX_RET_FINISHED`|
+|`ctx->used`|12|
+|`buf[]`|6E 67 20 3E 20 6F 6E 65 20 62 75 66|
+
+### Binary blob longer than the buffer
+
+```
+ uint8_t buf[16], blob[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18 };
+ lws_lec_pctx_t cbw;
+
+ lws_lec_init(&cbw, buf, sizeof(buf));
+ lws_lec_printf(ctx, "%.*b", (int)sizeof(blob), blob);
+ /* not required to be in same function context or same buf,
+ * but the length and blob must remain the same */
+ lws_lec_setbuf(&cbw, buf, sizeof(buf));
+ lws_lec_printf(ctx, "%.*b", (int)sizeof(blob), blob);
+```
+
+First call
+
+|||
+|---|---|
+|Return| `LWS_LECPCTX_RET_AGAIN`|
+|`ctx->used`|16|
+|`buf[]`|52 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F|
+
+Second call
+
+|||
+|---|---|
+|Return| `LWS_LECPCTX_RET_FINISHED`|
+|`ctx->used`|3|
+|`buf[]`|10 11 12|
diff --git a/READMEs/README.json-lejp.md b/READMEs/README.json-lejp.md
new file mode 100644
index 0000000..1471c17
--- /dev/null
+++ b/READMEs/README.json-lejp.md
@@ -0,0 +1,107 @@
+# LEJP JSON Stream Parser
+
+|||
+|---|---|---|
+|cmake| `LWS_WITH_LEJP`|
+|Header| ./include/libwebsockets/lws-lejp.h|
+|api-test| ./minimal-examples/api-tests/api-test-lejp/|
+|test app| ./test-apps/test-lejp.c -> libwebsockets-test-lejp|
+
+LEJP is a lightweight JSON stream parser.
+
+The features are:
+
+ - completely immune to input fragmentation, give it any size blocks of JSON as
+ they become available, 1 byte, or 100K at a time give identical parsing
+ results
+ - input chunks discarded as they are parsed, whole JSON never needed in memory
+ - nonrecursive, fixed stack usage of a few dozen bytes
+ - no heap allocations at all, just requires ~500 byte context usually on
+ caller stack
+ - creates callbacks to a user-provided handler as members are parsed out
+ - no payload size limit, supports huge / endless strings bigger than
+ system memory
+ - collates utf-8 text payloads into a 250-byte chunk buffer in the json parser
+ context object for ease of access
+
+## Type handling
+
+LEJP leaves all numbers in text form, they are signalled in different callbacks
+according to int or float, but delivered as text strings in the first
+`ctx->npos` chars of `ctx->buf`.
+
+For numeric types, you would typically use `atoi()` or similar to recover the
+number as a host type.
+
+## Callback reasons
+
+The user callback does not have to handle any callbacks, it only needs to
+process the data for the ones it is interested in.
+
+|Callback reason|JSON structure|Associated data|
+|---|---|---|
+|`LEJPCB_CONSTRUCTED`|Created the parse context||
+|`LEJPCB_DESTRUCTED`|Destroyed the parse context||
+|`LEJPCB_COMPLETE`|The parsing completed OK||
+|`LEJPCB_FAILED`|The parsing failed||
+|`LEJPCB_VAL_TRUE`|boolean true||
+|`LEJPCB_VAL_FALSE`|boolean false||
+|`LEJPCB_VAL_NULL`|explicit NULL||
+|`LEJPCB_PAIR_NAME`|The name part of a JSON `key: value` map pair|`ctx->buf`|
+|`LEJPCB_VAL_STR_START`|A UTF-8 string is starting||
+|`LEJPCB_VAL_STR_CHUNK`|The next string chunk|`ctx->npos` bytes in `ctx->buf`|
+|`LEJPCB_VAL_STR_END`|The last string chunk|`ctx->npos` bytes in `ctx->buf`|
+|`LEJPCB_ARRAY_START`|An array is starting||
+|`LEJPCB_ARRAY_END`|An array has ended||
+|`LEJPCB_OBJECT_START`|A JSON object is starting||
+|`LEJPCB_OBJECT_END`|A JSON object has ended||
+
+## Handling JSON UTF-8 strings
+
+When a string is parsed, an advisory callback of `LECPCB_VAL_STR_START` occurs
+first. No payload is delivered with the START callback.
+
+Payload is collated into `ctx->buf[]`, the valid length is in `ctx->npos`.
+
+For short strings or blobs where the length is known, the whole payload is
+delivered in a single `LECPCB_VAL_STR_END` callback.
+
+For payloads larger than the size of `ctx->buf[]`, `LECPCB_VAL_STR_CHUNK`
+callbacks occur delivering each sequential bufferload.
+
+The last chunk (which may be zero length) is delievered by `LECPCB_VAL_STR_END`.
+
+## Parsing paths
+
+LEJP maintains a "parsing path" in `ctx->path` that represents the context of
+the callback events. As a convenience, at LEJP context creation time, you can
+pass in an array of path strings you want to match on, and have any match
+checkable in the callback using `ctx->path_match`, it's 0 if no active match,
+or the match index from your path array starting from 1 for the first entry.
+
+|CBOR element|Representation in path|
+|---|---|
+|JSON Array|`[]`|
+|JSON Map|`.`|
+|JSON Map entry key string|`keystring`|
+
+
+
+## Comparison with LECP (CBOR parser)
+
+LECP is based on the same principles as LEJP and shares most of the callbacks.
+The major differences:
+
+ - LEJP value callbacks all appear in `ctx->buf[]`, ie, floating-point is
+ provided to the callback in ascii form like `"1.0"`. CBOR provides a more
+ strict typing system, and the different type values are provided either in
+ `ctx->buf[]` for blobs or utf-8 text strtings, or the `item.u` union for
+ converted types, with additional callback reasons specific to each type.
+
+ - CBOR "maps" use `_OBJECT_START` and `_END` parsing callbacks around the
+ key / value pairs. LEJP has a special callback type `PAIR_NAME` for the
+ key string / integer, but in LECP these are provided as generic callbacks
+ dependent on type, ie, generic string callbacks or integer ones, and the
+ value part is represented according to whatever comes.
+
+
diff --git a/cmake/lws_config.h.in b/cmake/lws_config.h.in
index b64f29e..a5d3d9d 100644
--- a/cmake/lws_config.h.in
+++ b/cmake/lws_config.h.in
@@ -167,6 +167,8 @@
#cmakedefine LWS_WITH_HTTP_UNCOMMON_HEADERS
#cmakedefine LWS_WITH_IPV6
#cmakedefine LWS_WITH_JOSE
+#cmakedefine LWS_WITH_CBOR
+#cmakedefine LWS_WITH_CBOR_FLOAT
#cmakedefine LWS_WITH_LEJP
#cmakedefine LWS_WITH_LIBEV
#cmakedefine LWS_WITH_LIBEVENT
diff --git a/include/libwebsockets.h b/include/libwebsockets.h
index 306fd90..37aec68 100644
--- a/include/libwebsockets.h
+++ b/include/libwebsockets.h
@@ -617,6 +617,7 @@
#include <libwebsockets/lws-vfs.h>
#endif
#include <libwebsockets/lws-lejp.h>
+#include <libwebsockets/lws-lecp.h>
#include <libwebsockets/lws-struct.h>
#include <libwebsockets/lws-threadpool.h>
#include <libwebsockets/lws-tokenize.h>
diff --git a/include/libwebsockets/lws-lecp.h b/include/libwebsockets/lws-lecp.h
new file mode 100644
index 0000000..04de86a
--- /dev/null
+++ b/include/libwebsockets/lws-lecp.h
@@ -0,0 +1,542 @@
+/*
+ * libwebsockets - small server side websockets and web server implementation
+ *
+ * Copyright (C) 2010 - 2021 Andy Green <andy@warmcat.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+/** \defgroup lecp CBOR parser
+ * ##CBOR parsing related functions
+ * \ingroup lwsapi
+ *
+ * LECP is an extremely lightweight CBOR stream parser included in lws. It
+ * is aligned in approach with the LEJP JSON stream parser, with some additional
+ * things needed for CBOR.
+ */
+//@{
+
+#ifndef LECP_MAX_PARSING_STACK_DEPTH
+#define LECP_MAX_PARSING_STACK_DEPTH 5
+#endif
+#ifndef LECP_MAX_DEPTH
+#define LECP_MAX_DEPTH 12
+#endif
+#ifndef LECP_MAX_INDEX_DEPTH
+#define LECP_MAX_INDEX_DEPTH 8
+#endif
+#ifndef LECP_MAX_PATH
+#define LECP_MAX_PATH 128
+#endif
+#ifndef LECP_STRING_CHUNK
+/* must be >= 30 to assemble floats */
+#define LECP_STRING_CHUNK 254
+#endif
+
+#define LECP_FLAG_CB_IS_VALUE 64
+
+/*
+ * CBOR initial byte 3 x MSB bits are these
+ */
+
+enum {
+ LWS_CBOR_MAJTYP_UINT = 0 << 5,
+ LWS_CBOR_MAJTYP_INT_NEG = 1 << 5,
+ LWS_CBOR_MAJTYP_BSTR = 2 << 5,
+ LWS_CBOR_MAJTYP_TSTR = 3 << 5,
+ LWS_CBOR_MAJTYP_ARRAY = 4 << 5,
+ LWS_CBOR_MAJTYP_MAP = 5 << 5,
+ LWS_CBOR_MAJTYP_TAG = 6 << 5,
+ LWS_CBOR_MAJTYP_FLOAT = 7 << 5, /* also BREAK */
+
+ LWS_CBOR_MAJTYP_MASK = 7 << 5,
+
+ /*
+ * For the low 5 bits of the opcode, 0-23 are literals, unless it's
+ * FLOAT.
+ *
+ * 24 = 1 byte; 25 = 2..., 26 = 4... and 27 = 8 bytes following literal.
+ */
+ LWS_CBOR_1 = 24,
+ LWS_CBOR_2 = 25,
+ LWS_CBOR_4 = 26,
+ LWS_CBOR_8 = 27,
+
+ LWS_CBOR_RESERVED = 28,
+
+ LWS_CBOR_SUBMASK = 0x1f,
+
+ /*
+ * Major type 7 discriminators in low 5 bits
+ * 0 - 23 is SIMPLE implicit value (like, eg, LWS_CBOR_SWK_TRUE)
+ */
+ LWS_CBOR_SWK_FALSE = 20,
+ LWS_CBOR_SWK_TRUE = 21,
+ LWS_CBOR_SWK_NULL = 22,
+ LWS_CBOR_SWK_UNDEFINED = 23,
+
+ LWS_CBOR_M7_SUBTYP_SIMPLE_X8 = 24, /* simple with additional byte */
+ LWS_CBOR_M7_SUBTYP_FLOAT16 = 25,
+ LWS_CBOR_M7_SUBTYP_FLOAT32 = 26,
+ LWS_CBOR_M7_SUBTYP_FLOAT64 = 27,
+ LWS_CBOR_M7_BREAK = 31,
+
+/* 28, 29, 30 are illegal.
+ *
+ * 31 is illegal for UINT, INT_NEG, and TAG;
+ * for BSTR, TSTR, ARRAY and MAP it means "indefinite length", ie,
+ * it's made up of an endless amount of determinite-length
+ * fragments terminated with a BREAK (FLOAT | 31) instead of the
+ * next determinite-length fragment. The second framing level
+ * means no need for escapes for BREAK in the data.
+ */
+
+ LWS_CBOR_INDETERMINITE = 31,
+
+/*
+ * Well-known tags
+ */
+
+ LWS_CBOR_WKTAG_DATETIME_STD = 0, /* text */
+ LWS_CBOR_WKTAG_DATETIME_EPOCH = 1, /* int or float */
+ LWS_CBOR_WKTAG_BIGNUM_UNSIGNED = 2, /* byte string */
+ LWS_CBOR_WKTAG_BIGNUM_NEGATIVE = 3, /* byte string */
+ LWS_CBOR_WKTAG_DECIMAL_FRAC = 4, /* array */
+ LWS_CBOR_WKTAG_BIGFLOAT = 5, /* array */
+
+ LWS_CBOR_WKTAG_COSE_ENC0 = 16,
+ LWS_CBOR_WKTAG_COSE_MAC0 = 17,
+ LWS_CBOR_WKTAG_COSE_SIGN1 = 18,
+
+ LWS_CBOR_WKTAG_TO_B64U = 21, /* any */
+ LWS_CBOR_WKTAG_TO_B64 = 22, /* any */
+ LWS_CBOR_WKTAG_TO_B16 = 23, /* any */
+ LWS_CBOR_WKTAG_CBOR = 24, /* byte string */
+
+ LWS_CBOR_WKTAG_URI = 32, /* text string */
+ LWS_CBOR_WKTAG_B64U = 33, /* text string */
+ LWS_CBOR_WKTAG_B64 = 34, /* text string */
+ LWS_CBOR_WKTAG_MIME = 36, /* text string */
+
+ LWS_CBOR_WKTAG_COSE_ENC = 96,
+ LWS_CBOR_WKTAG_COSE_MAC = 97,
+ LWS_CBOR_WKTAG_COSE_SIGN = 98,
+
+ LWS_CBOR_WKTAG_SELFDESCCBOR = 55799
+};
+
+enum lecp_callbacks {
+ LECPCB_CONSTRUCTED = 0,
+ LECPCB_DESTRUCTED = 1,
+
+ LECPCB_COMPLETE = 3,
+ LECPCB_FAILED = 4,
+
+ LECPCB_PAIR_NAME = 5,
+
+ LECPCB_VAL_TRUE = LECP_FLAG_CB_IS_VALUE | 6,
+ LECPCB_VAL_FALSE = LECP_FLAG_CB_IS_VALUE | 7,
+ LECPCB_VAL_NULL = LECP_FLAG_CB_IS_VALUE | 8,
+ LECPCB_VAL_NUM_INT = LECP_FLAG_CB_IS_VALUE | 9,
+ LECPCB_VAL_RESERVED = LECP_FLAG_CB_IS_VALUE | 10,
+ LECPCB_VAL_STR_START = 11, /* notice handle separately */
+ LECPCB_VAL_STR_CHUNK = LECP_FLAG_CB_IS_VALUE | 12,
+ LECPCB_VAL_STR_END = LECP_FLAG_CB_IS_VALUE | 13,
+
+ LECPCB_ARRAY_START = 14,
+ LECPCB_ARRAY_END = 15,
+
+ LECPCB_OBJECT_START = 16,
+ LECPCB_OBJECT_END = 17,
+
+ LECPCB_TAG_START = 18,
+ LECPCB_TAG_END = 19,
+
+ LECPCB_VAL_NUM_UINT = LECP_FLAG_CB_IS_VALUE | 20,
+ LECPCB_VAL_UNDEFINED = LECP_FLAG_CB_IS_VALUE | 21,
+ LECPCB_VAL_FLOAT16 = LECP_FLAG_CB_IS_VALUE | 22,
+ LECPCB_VAL_FLOAT32 = LECP_FLAG_CB_IS_VALUE | 23,
+ LECPCB_VAL_FLOAT64 = LECP_FLAG_CB_IS_VALUE | 24,
+
+ LECPCB_VAL_SIMPLE = LECP_FLAG_CB_IS_VALUE | 25,
+
+ LECPCB_VAL_BLOB_START = 26, /* notice handle separately */
+ LECPCB_VAL_BLOB_CHUNK = LECP_FLAG_CB_IS_VALUE | 27,
+ LECPCB_VAL_BLOB_END = LECP_FLAG_CB_IS_VALUE | 28,
+
+ LECPCB_ARRAY_ITEM_START = 29,
+ LECPCB_ARRAY_ITEM_END = 30,
+
+ LECPCB_LITERAL_CBOR = 31,
+};
+
+enum lecp_reasons {
+ LECP_CONTINUE = -1,
+ LECP_REJECT_BAD_CODING = -2,
+ LECP_REJECT_UNKNOWN = -3,
+ LECP_REJECT_CALLBACK = -4,
+ LECP_STACK_OVERFLOW = -5,
+};
+
+
+struct lecp_item {
+ union {
+ uint64_t u64;
+ int64_t i64;
+
+ uint64_t u32;
+
+ uint16_t hf;
+#if defined(LWS_WITH_CBOR_FLOAT)
+ float f;
+ double d;
+#else
+ uint32_t f;
+ uint64_t d;
+#endif
+ } u;
+ uint8_t opcode;
+};
+
+struct lecp_ctx;
+typedef signed char (*lecp_callback)(struct lecp_ctx *ctx, char reason);
+
+struct _lecp_stack {
+ char s; /* lejp_state stack*/
+ uint8_t p; /* path length */
+ char i; /* index array length */
+ char indet; /* indeterminite */
+ char intermediate; /* in middle of string */
+
+ char pop_iss;
+ uint64_t tag;
+ uint64_t collect_rem;
+ uint32_t ordinal;
+ uint8_t opcode;
+ uint8_t send_new_array_item;
+ uint8_t barrier;
+};
+
+struct _lecp_parsing_stack {
+ void *user; /* private to the stack level */
+ lecp_callback cb;
+ const char * const *paths;
+ uint8_t count_paths;
+ uint8_t ppos;
+ uint8_t path_match;
+};
+
+struct lecp_ctx {
+
+ /* sorted by type for most compact alignment
+ *
+ * pointers
+ */
+ void *user;
+ uint8_t *collect_tgt;
+
+ /* arrays */
+
+ struct _lecp_parsing_stack pst[LECP_MAX_PARSING_STACK_DEPTH];
+ struct _lecp_stack st[LECP_MAX_DEPTH];
+ uint16_t i[LECP_MAX_INDEX_DEPTH]; /* index array */
+ uint16_t wild[LECP_MAX_INDEX_DEPTH]; /* index array */
+ char path[LECP_MAX_PATH];
+ uint8_t cbor[64]; /* literal cbor capture */
+
+ struct lecp_item item;
+
+
+ /* size_t */
+
+ size_t path_stride; /* 0 means default ptr size, else
+ * stride... allows paths to be
+ * provided composed inside a
+ * larger user struct instead of a
+ * duplicated array */
+ size_t used_in; /* bytes of input consumed */
+
+ /* short */
+
+ uint16_t uni;
+
+ /* char */
+
+ uint8_t npos;
+ uint8_t dcount;
+ uint8_t f;
+ uint8_t sp; /* stack head */
+ uint8_t ipos; /* index stack depth */
+ uint8_t count_paths;
+ uint8_t path_match;
+ uint8_t path_match_len;
+ uint8_t wildcount;
+ uint8_t pst_sp; /* parsing stack head */
+ uint8_t outer_array;
+ uint8_t cbor_pos;
+ uint8_t literal_cbor_report;
+ char present; /* temp for cb reason to use */
+
+ uint8_t be; /* big endian */
+
+ /* at end so we can memset the rest of it */
+
+ char buf[LECP_STRING_CHUNK + 1];
+};
+
+struct lws_lec_pctx;
+typedef struct lws_lec_pctx lws_lec_pctx_t;
+
+enum lws_lec_pctx_ret {
+ LWS_LECPCTX_RET_FINISHED = 0,
+ LWS_LECPCTX_RET_AGAIN, /* call again to continue writing buffer */
+ LWS_LECPCTX_RET_FAIL /* something broken, eg, format string */
+};
+
+enum cbp_state {
+ CBPS_IDLE,
+ CBPS_PC1,
+ CBPS_PC2,
+ CBPS_PC3,
+
+ CBPS_STRING_BODY,
+
+ CBPS_NUM_LIT,
+
+ CBPS_STRING_LIT,
+
+ CBPS_CONTYPE,
+};
+
+typedef struct lws_lec_pctx {
+ uint8_t stack[16];
+ uint8_t vaa[16];
+ uint8_t indet[16];
+ uint8_t scratch[24];
+ uint8_t *start; /* the beginning of the out buf */
+ uint8_t *buf; /* cur pos in output buf */
+ uint8_t *end; /* the end of the output buf */
+
+ const uint8_t *ongoing_src;
+ uint64_t ongoing_len;
+ uint64_t ongoing_done;
+
+ struct lecp_item item;
+
+ size_t used; /* number of bytes valid from start */
+
+ int opaque[4]; /* ignored by lws, caller may use */
+
+ enum cbp_state state;
+ unsigned int fmt_pos;
+ uint8_t sp;
+ uint8_t scratch_len;
+ uint8_t escflag;
+ uint8_t _long;
+ uint8_t vaa_pos;
+ uint8_t dotstar;
+} lws_lec_pctx_t;
+
+LWS_VISIBLE LWS_EXTERN void
+lws_lec_int(lws_lec_pctx_t *ctx, uint8_t opcode, uint8_t indet, uint64_t num);
+
+LWS_VISIBLE LWS_EXTERN int
+lws_lec_scratch(lws_lec_pctx_t *ctx);
+
+/*
+ * lws_lec_init() - prepare a cbor writing context
+ *
+ * \param ctx: the cbor writing context to prepare
+ * \param buf: the output buffer start
+ * \param len: the amount of the output buffer we can use
+ *
+ * Prepares a cbor writing context so that les_lec_printf can be used to
+ * write into it.
+ */
+LWS_VISIBLE LWS_EXTERN void
+lws_lec_init(lws_lec_pctx_t *ctx, uint8_t *buf, size_t len);
+
+/*
+ * lws_lec_setbuf() - update the output buffer for an initialized cbor writing ctx
+ *
+ * \param ctx: the cbor writing context to prepare
+ * \param buf: the output buffer start
+ * \param len: the amount of the output buffer we can use
+ *
+ * Leaves the cbor writing context state as it is, but resets the output buffer
+ * it writes into as given in \p buf and \p len
+ */
+LWS_VISIBLE LWS_EXTERN void
+lws_lec_setbuf(lws_lec_pctx_t *ctx, uint8_t *buf, size_t len);
+
+/*
+ * lws_lec_vsprintf() - write into a cbor writing context
+ *
+ * \param ctx: the cbor writing context to prepare
+ * \param format: a printf style argument map
+ * \param args: the va args
+ *
+ * CBOR-aware vsprintf which pauses output when it fills the output buffer. You
+ * can call it again with the same args and same lws_lex_pctx to resume filling
+ *
+ * Returns either LWS_LECPCTX_RET_FINISHED if we have nothing left over that we
+ * want to put in the buffer, or LWS_LECPCTX_RET_AGAIN if the function should
+ * be called again with the same arguments (perhaps into a different output
+ * buffer) to continue emitting output from where it left off.
+ *
+ * If LWS_LECPCTX_RET_AGAIN is returned, lws_lec_setbuf() must be used on the
+ * context to reset or change the output buffer before calling again.
+ *
+ * The number of bytes placed in the output buffer is available in ctx->used.
+ *
+ * \p format is a printf-type format string that is specialized for CBOR
+ * generation. It understands the following specifiers
+ *
+ * |`123`||unsigned literal number|
+ * |`-123`||signed literal number|
+ * |`%u`|`unsigned int`|number|
+ * |`%lu`|`unsigned long int`|number|
+ * |`%llu`|`unsigned long long int`|number|
+ * |`%d`|`signed int`|number|
+ * |`%ld`|`signed long int`|number|
+ * |`%lld`|`signed long long int`|number|
+ * |`%f`|`double`|floating point number|
+ * |`123(...)`||literal tag and scope|
+ * |`%t(...)`|`unsigned int`|tag and scope|
+ * |`%lt(...)`|`unsigned long int`|tag and scope|
+ * |`%llt(...)`|`unsigned long long int`|tag and scope|
+ * |`[...]`||Array (fixed len if `]` in same format string)|
+ * |`{...}`||Map (fixed len if `}` in same format string)|
+ * |`<t...>`||Container for indeterminite text string frags|
+ * |`<b...>`||Container for indeterminite binary string frags|
+ * |`'string'`||Literal text of known length|
+ * |`%s`|`const char *`|NUL-terminated string|
+ * |`%.*s`|`int`, `const char *`|length-specified string|
+ * |`%.*b`|`int`, `const uint8_t *`|length-specified binary|
+ * |`:`||separator between Map items (a:b)|
+ * |`,`||separator between Map pairs or array items|
+ *
+ * See READMEs/README.cbor-lecp.md for more details.
+ */
+LWS_VISIBLE LWS_EXTERN enum lws_lec_pctx_ret
+lws_lec_vsprintf(lws_lec_pctx_t *ctx, const char *format, va_list args);
+
+/*
+ * lws_lec_printf() - write into a cbor writing context
+ *
+ * \param ctx: the cbor writing context to prepare
+ * \param format: a printf style argument map
+ * \param ...: format args
+ *
+ * See lws_lec_vsprintf() for format details. This is the most common way
+ * to format the CBOR output.
+ *
+ * See READMEs/README.cbor-lecp.md for more details.
+ */
+LWS_VISIBLE LWS_EXTERN enum lws_lec_pctx_ret
+lws_lec_printf(lws_lec_pctx_t *ctx, const char *format, ...);
+
+/**
+ * lecp_construct() - Construct an LECP parser context
+ *
+ * \param ctx: the parser context object to be initialized
+ * \param cb: the user callback to receive the parsing events
+ * \param user: an opaque user pointer available at \p cb
+ * \param paths: an optional array of parsing paths
+ * \param paths_count: how many paths in \p paths
+ *
+ * Prepares an LECP parser context for parsing.
+ */
+LWS_VISIBLE LWS_EXTERN void
+lecp_construct(struct lecp_ctx *ctx, lecp_callback cb, void *user,
+ const char * const *paths, unsigned char paths_count);
+
+/**
+ * lecp_destruct() - Destroys an LECP parser context
+ *
+ * \param ctx: the parser context object to be destroyed
+ */
+LWS_VISIBLE LWS_EXTERN void
+lecp_destruct(struct lecp_ctx *ctx);
+
+/**
+ * lecp_parse() - parses a chunk of input CBOR
+ *
+ * \p ctx: the parsing context
+ * \p cbor: the start of the chunk of CBOR
+ * \p len: the number of bytes of CBOR available at \p cbor
+ *
+ * Returns LECP_CONTINUE if more input needed, one of enum lecp_reasons for a
+ * fatal error, else 0 for successful parsing completion.
+ *
+ * On success or _CONTINUE, ctx->used_in is set to the number of input bytes
+ * consumed.
+ */
+LWS_VISIBLE LWS_EXTERN int
+lecp_parse(struct lecp_ctx *ctx, const uint8_t *cbor, size_t len);
+
+LWS_VISIBLE LWS_EXTERN void
+lecp_change_callback(struct lecp_ctx *ctx, lecp_callback cb);
+
+LWS_VISIBLE LWS_EXTERN const char *
+lecp_error_to_string(int e);
+
+/**
+ * lecp_parse_report_raw() - turn cbor raw reporting on and off
+ *
+ * \param ctx: the lecp context
+ * \param on: 0 to disable (defaults disabled), 1 to enable
+ *
+ * For cose_sign, it needs access to raw cbor subtrees for the hash input.
+ * This api causes LECPCB_LITERAL_CBOR parse callbacks when there are
+ * ctx->cbor_pos bytes of raw cbor available in ctx->cbor[]. the callbacks
+ * occur when the ctx->cbor[] buffer fills or if it holds anything when this
+ * spi is used to stop the reports.
+ *
+ * The same CBOR that is being captured continues to be passed for parsing.
+ */
+LWS_VISIBLE LWS_EXTERN void
+lecp_parse_report_raw(struct lecp_ctx *ctx, int on);
+
+/**
+ * lecp_parse_map_is_key() - return nonzero if we're in a map and this is a key
+ *
+ * \param ctx: the lwcp context
+ *
+ * Checks if the current value is a key in a map, ie, that you are on a "key" in
+ * a list of "{key: value}" pairs. Zero means you're either not in a map or not
+ * on the key part, and nonzero means you are in a map and on a key part.
+ */
+LWS_VISIBLE LWS_EXTERN int
+lecp_parse_map_is_key(struct lecp_ctx *ctx);
+
+LWS_VISIBLE LWS_EXTERN int
+lecp_parse_subtree(struct lecp_ctx *ctx, const uint8_t *in, size_t len);
+
+/*
+ * Helpers for half-float
+ */
+
+LWS_VISIBLE LWS_EXTERN void
+lws_singles2halfp(uint16_t *hp, uint32_t x);
+
+LWS_VISIBLE LWS_EXTERN void
+lws_halfp2singles(uint32_t *xp, uint16_t h);
+
+//@}
diff --git a/include/libwebsockets/lws-lejp.h b/include/libwebsockets/lws-lejp.h
index 6ea6d3d..f9f5027 100644
--- a/include/libwebsockets/lws-lejp.h
+++ b/include/libwebsockets/lws-lejp.h
@@ -193,26 +193,26 @@
#endif
enum num_flags {
- LEJP_SEEN_MINUS = (1 << 0),
- LEJP_SEEN_POINT = (1 << 1),
- LEJP_SEEN_POST_POINT = (1 << 2),
- LEJP_SEEN_EXP = (1 << 3)
+ LEJP_SEEN_MINUS = (1 << 0),
+ LEJP_SEEN_POINT = (1 << 1),
+ LEJP_SEEN_POST_POINT = (1 << 2),
+ LEJP_SEEN_EXP = (1 << 3)
};
struct _lejp_stack {
- char s; /* lejp_state stack*/
- char p; /* path length */
- char i; /* index array length */
- char b; /* user bitfield */
+ char s; /* lejp_state stack*/
+ char p; /* path length */
+ char i; /* index array length */
+ char b; /* user bitfield */
};
struct _lejp_parsing_stack {
- void *user; /* private to the stack level */
- signed char (*callback)(struct lejp_ctx *ctx, char reason);
- const char * const *paths;
- uint8_t count_paths;
- uint8_t ppos;
- uint8_t path_match;
+ void *user; /* private to the stack level */
+ signed char (*callback)(struct lejp_ctx *ctx, char reason);
+ const char * const *paths;
+ uint8_t count_paths;
+ uint8_t ppos;
+ uint8_t path_match;
};
struct lejp_ctx {
diff --git a/lib/misc/CMakeLists.txt b/lib/misc/CMakeLists.txt
index fcdb2a5..337367a 100644
--- a/lib/misc/CMakeLists.txt
+++ b/lib/misc/CMakeLists.txt
@@ -110,6 +110,12 @@
list(APPEND SOURCES
misc/lejp.c)
endif()
+if (LWS_WITH_CBOR)
+ list(APPEND SOURCES
+ misc/lecp.c
+ misc/ieeehalfprecision.c)
+endif()
+
if (UNIX)
if (NOT LWS_HAVE_GETIFADDRS)
diff --git a/lib/misc/ieeehalfprecision.c b/lib/misc/ieeehalfprecision.c
new file mode 100644
index 0000000..075eb1d
--- /dev/null
+++ b/lib/misc/ieeehalfprecision.c
@@ -0,0 +1,228 @@
+/******************************************************************************
+ *
+ * Filename: ieeehalfprecision.c
+ * Programmer: James Tursa
+ * Version: 1.0
+ * Date: March 3, 2009
+ * Copyright: (c) 2009 by James Tursa, All Rights Reserved
+ *
+ * This code uses the BSD License:
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the distribution
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This file contains C code to convert between IEEE double, single, and half
+ * precision floating point formats. The intended use is for standalone C code
+ * that does not rely on MATLAB mex.h. The bit pattern for the half precision
+ * floating point format is stored in a 16-bit unsigned int variable. The half
+ * precision bit pattern definition is:
+ *
+ * 1 bit sign bit
+ * 5 bits exponent, biased by 15
+ * 10 bits mantissa, hidden leading bit, normalized to 1.0
+ *
+ * Special floating point bit patterns recognized and supported:
+ *
+ * All exponent bits zero:
+ * - If all mantissa bits are zero, then number is zero (possibly signed)
+ * - Otherwise, number is a denormalized bit pattern
+ *
+ * All exponent bits set to 1:
+ * - If all mantissa bits are zero, then number is +Infinity or -Infinity
+ * - Otherwise, number is NaN (Not a Number)
+ *
+ * For the denormalized cases, note that 2^(-24) is the smallest number that can
+ * be represented in half precision exactly. 2^(-25) will convert to 2^(-24)
+ * because of the rounding algorithm used, and 2^(-26) is too small and
+ * underflows to zero.
+ *
+ ******************************************************************************/
+
+/*
+ changes by K. Rogovin:
+ - changed macros UINT16_TYPE, etc to types from stdint.h
+ (i.e. UINT16_TYPE-->uint16_t, INT16_TYPE-->int16_t, etc)
+
+ - removed double conversion routines.
+
+ - changed run time checks of endianness to compile time macro.
+
+ - removed return value from routines
+
+ - changed source parameter type from * to const *
+
+ - changed pointer types from void ot uint16_t and uint32_t
+ */
+
+/*
+ * andy@warmcat.com:
+ *
+ * - clean style and indenting
+ * - convert to single operation
+ * - export as lws_
+ */
+
+#include <string.h>
+#include <stdint.h>
+
+void
+lws_singles2halfp(uint16_t *hp, uint32_t x)
+{
+ uint32_t xs, xe, xm;
+ uint16_t hs, he, hm;
+ int hes;
+
+ if (!(x & 0x7FFFFFFFu)) {
+ /* Signed zero */
+ *hp = (uint16_t)(x >> 16);
+
+ return;
+ }
+
+ xs = x & 0x80000000u; // Pick off sign bit
+ xe = x & 0x7F800000u; // Pick off exponent bits
+ xm = x & 0x007FFFFFu; // Pick off mantissa bits
+
+ if (xe == 0) { // Denormal will underflow, return a signed zero
+ *hp = (uint16_t) (xs >> 16);
+ return;
+ }
+
+ if (xe == 0x7F800000u) { // Inf or NaN (all the exponent bits are set)
+ if (!xm) { // If mantissa is zero ...
+ *hp = (uint16_t) ((xs >> 16) | 0x7C00u); // Signed Inf
+ return;
+ }
+
+ *hp = (uint16_t) 0xFE00u; // NaN, only 1st mantissa bit set
+
+ return;
+ }
+
+ /* Normalized number */
+
+ hs = (uint16_t) (xs >> 16); // Sign bit
+ /* Exponent unbias the single, then bias the halfp */
+ hes = ((int)(xe >> 23)) - 127 + 15;
+
+ if (hes >= 0x1F) { // Overflow
+ *hp = (uint16_t) ((xs >> 16) | 0x7C00u); // Signed Inf
+ return;
+ }
+
+ if (hes <= 0) { // Underflow
+ if ((14 - hes) > 24)
+ /*
+ * Mantissa shifted all the way off & no
+ * rounding possibility
+ */
+ hm = (uint16_t) 0u; // Set mantissa to zero
+ else {
+ xm |= 0x00800000u; // Add the hidden leading bit
+ hm = (uint16_t) (xm >> (14 - hes)); // Mantissa
+ if ((xm >> (13 - hes)) & 1u) // Check for rounding
+ /* Round, might overflow into exp bit,
+ * but this is OK */
+ hm = (uint16_t)(hm + 1u);
+ }
+ /* Combine sign bit and mantissa bits, biased exponent is 0 */
+ *hp = hs | hm;
+
+ return;
+ }
+
+ he = (uint16_t)(hes << 10); // Exponent
+ hm = (uint16_t)(xm >> 13); // Mantissa
+
+ if (xm & 0x00001000u) // Check for rounding
+ /* Round, might overflow to inf, this is OK */
+ *hp = (uint16_t)((hs | he | hm) + (uint16_t)1u);
+ else
+ *hp = hs | he | hm; // No rounding
+}
+
+void
+lws_halfp2singles(uint32_t *xp, uint16_t h)
+{
+ uint16_t hs, he, hm;
+ uint32_t xs, xe, xm;
+ int32_t xes;
+ int e;
+
+ if (!(h & 0x7FFFu)) { // Signed zero
+ *xp = ((uint32_t)h) << 16; // Return the signed zero
+
+ return;
+ }
+
+ hs = h & 0x8000u; // Pick off sign bit
+ he = h & 0x7C00u; // Pick off exponent bits
+ hm = h & 0x03FFu; // Pick off mantissa bits
+
+ if (!he) { // Denormal will convert to normalized
+ e = -1;
+
+ /* figure out how much extra to adjust the exponent */
+ do {
+ e++;
+ hm = (uint16_t)(hm << 1);
+ /* Shift until leading bit overflows into exponent */
+ } while (!(hm & 0x0400u));
+
+ xs = ((uint32_t) hs) << 16; // Sign bit
+
+ /* Exponent unbias the halfp, then bias the single */
+ xes = ((int32_t)(he >> 10)) - 15 + 127 - e;
+ xe = (uint32_t)(xes << 23); // Exponent
+ xm = ((uint32_t)(hm & 0x03FFu)) << 13; // Mantissa
+
+ *xp = xs | xe | xm;
+
+ return;
+ }
+
+ if (he == 0x7C00u) { /* Inf or NaN (all the exponent bits are set) */
+ if (!hm) { /* If mantissa is zero ...
+ * Signed Inf
+ */
+ *xp = (((uint32_t)hs) << 16) | ((uint32_t)0x7F800000u);
+
+ return;
+ }
+
+ /* ... NaN, only 1st mantissa bit set */
+ *xp = (uint32_t)0xFFC00000u;
+
+ return;
+ }
+
+ /* Normalized number */
+
+ xs = ((uint32_t)hs) << 16; // Sign bit
+ /* Exponent unbias the halfp, then bias the single */
+ xes = ((int32_t)(he >> 10)) - 15 + 127;
+ xe = (uint32_t)(xes << 23); // Exponent
+ xm = ((uint32_t)hm) << 13; // Mantissa
+
+ /* Combine sign bit, exponent bits, and mantissa bits */
+ *xp = xs | xe | xm;
+}
diff --git a/lib/misc/lecp.c b/lib/misc/lecp.c
new file mode 100644
index 0000000..4783241
--- /dev/null
+++ b/lib/misc/lecp.c
@@ -0,0 +1,1686 @@
+/*
+ * libwebsockets - small server side websockets and web server implementation
+ *
+ * Copyright (C) 2010 - 2021 Andy Green <andy@warmcat.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ *
+ * Stream parser for RFC8949 CBOR
+ */
+
+#include "private-lib-core.h"
+#include <string.h>
+#include <stdio.h>
+
+#if defined(LWS_WITH_CBOR_FLOAT)
+#include <math.h>
+#endif
+
+#define lwsl_lecp lwsl_debug
+
+static const char * const parser_errs[] = {
+ "",
+ "",
+ "Bad CBOR coding",
+ "Unknown",
+ "Parser callback errored (see earlier error)",
+ "Overflow"
+};
+
+enum lecp_states {
+ LECP_OPC,
+ LECP_COLLECT,
+ LECP_SIMPLEX8,
+ LECP_COLLATE,
+ LECP_ONLY_SAME
+};
+
+void
+lecp_construct(struct lecp_ctx *ctx, lecp_callback cb, void *user,
+ const char * const *paths, unsigned char count_paths)
+{
+ uint16_t x = 0x1234;
+
+ memset(ctx, 0, sizeof(*ctx) - sizeof(ctx->buf));
+
+ ctx->user = user;
+ ctx->pst[0].cb = cb;
+ ctx->pst[0].paths = paths;
+ ctx->pst[0].count_paths = count_paths;
+ ctx->be = *((uint8_t *)&x) == 0x12;
+
+ ctx->st[0].s = LECP_OPC;
+
+ ctx->pst[0].cb(ctx, LECPCB_CONSTRUCTED);
+}
+
+void
+lecp_destruct(struct lecp_ctx *ctx)
+{
+ /* no allocations... just let callback know what it happening */
+ if (ctx->pst[0].cb)
+ ctx->pst[0].cb(ctx, LECPCB_DESTRUCTED);
+}
+
+void
+lecp_change_callback(struct lecp_ctx *ctx, lecp_callback cb)
+{
+ ctx->pst[0].cb(ctx, LECPCB_DESTRUCTED);
+ ctx->pst[0].cb = cb;
+ ctx->pst[0].cb(ctx, LECPCB_CONSTRUCTED);
+}
+
+
+const char *
+lecp_error_to_string(int e)
+{
+ if (e > 0)
+ e = 0;
+ else
+ e = -e;
+
+ if (e >= (int)LWS_ARRAY_SIZE(parser_errs))
+ return "Unknown error";
+
+ return parser_errs[e];
+}
+
+static void
+ex(struct lecp_ctx *ctx, void *_start, size_t len)
+{
+ struct _lecp_stack *st = &ctx->st[ctx->sp];
+ uint8_t *start = (uint8_t *)_start;
+
+ st->s = LECP_COLLECT;
+ st->collect_rem = (uint8_t)len;
+
+ if (ctx->be)
+ ctx->collect_tgt = start;
+ else
+ ctx->collect_tgt = start + len - 1;
+}
+
+static void
+lecp_check_path_match(struct lecp_ctx *ctx)
+{
+ const char *p, *q;
+ size_t s = sizeof(char *);
+ int n;
+
+ if (ctx->path_stride)
+ s = ctx->path_stride;
+
+ /* we only need to check if a match is not active */
+ for (n = 0; !ctx->path_match &&
+ n < ctx->pst[ctx->pst_sp].count_paths; n++) {
+ ctx->wildcount = 0;
+ p = ctx->path;
+
+ q = *((char **)(((char *)ctx->pst[ctx->pst_sp].paths) +
+ ((unsigned int)n * s)));
+
+ while (*p && *q) {
+ if (*q != '*') {
+ if (*p != *q)
+ break;
+ p++;
+ q++;
+ continue;
+ }
+ ctx->wild[ctx->wildcount++] =
+ (uint16_t)lws_ptr_diff_size_t(p, ctx->path);
+ q++;
+ /*
+ * if * has something after it, match to .
+ * if ends with *, eat everything.
+ * This implies match sequences must be ordered like
+ * x.*.*
+ * x.*
+ * if both options are possible
+ */
+ while (*p && (*p != '.' || !*q))
+ p++;
+ }
+ if (*p || *q)
+ continue;
+
+ ctx->path_match = (uint8_t)(n + 1);
+ ctx->path_match_len = ctx->pst[ctx->pst_sp].ppos;
+ return;
+ }
+
+ if (!ctx->path_match)
+ ctx->wildcount = 0;
+}
+
+int
+lecp_push(struct lecp_ctx *ctx, char s_start, char s_end, char state)
+{
+ struct _lecp_stack *st = &ctx->st[ctx->sp];
+
+ if (ctx->sp + 1 == LWS_ARRAY_SIZE(ctx->st))
+ return LECP_STACK_OVERFLOW;
+
+ if (s_start && ctx->pst[ctx->pst_sp].cb(ctx, s_start))
+ return LECP_REJECT_CALLBACK;
+
+ lwsl_lecp("%s: pushing from sp %d, parent "
+ "(opc %d, indet %d, collect_rem %d)\n",
+ __func__, ctx->sp, st->opcode >> 5, st->indet,
+ (int)st->collect_rem);
+
+
+ st->pop_iss = s_end; /* issue this when we pop back here */
+ ctx->st[ctx->sp + 1] = *st;
+ ctx->sp++;
+ st++;
+
+ st->s = state;
+ st->collect_rem = 0;
+ st->intermediate = 0;
+ st->indet = 0;
+ st->ordinal = 0;
+ st->send_new_array_item = 0;
+ st->barrier = 0;
+
+ return 0;
+}
+
+int
+lecp_pop(struct lecp_ctx *ctx)
+{
+ struct _lecp_stack *st;
+
+ assert(ctx->sp);
+ ctx->sp--;
+
+ st = &ctx->st[ctx->sp];
+
+ if (st->pop_iss == LECPCB_ARRAY_END) {
+ assert(ctx->ipos);
+ ctx->ipos--;
+ }
+
+ ctx->pst[ctx->pst_sp].ppos = st->p;
+ ctx->path[st->p] = '\0';
+ lecp_check_path_match(ctx);
+
+ lwsl_lecp("%s: popping to sp %d, parent "
+ "(opc %d, indet %d, collect_rem %d)\n",
+ __func__, ctx->sp, st->opcode >> 5, st->indet,
+ (int)st->collect_rem);
+
+ if (st->pop_iss && ctx->pst[ctx->pst_sp].cb(ctx, st->pop_iss))
+ return LECP_REJECT_CALLBACK;
+
+ return 0;
+}
+
+static struct _lecp_stack *
+lwcp_st_parent(struct lecp_ctx *ctx)
+{
+ assert(ctx->sp);
+
+ return &ctx->st[ctx->sp - 1];
+}
+
+int
+lwcp_completed(struct lecp_ctx *ctx, char indet)
+{
+ int r, il = ctx->ipos;
+
+ ctx->st[ctx->sp].s = LECP_OPC;
+
+ while (ctx->sp && !ctx->st[ctx->sp].barrier) {
+ struct _lecp_stack *parent = lwcp_st_parent(ctx);
+
+ lwsl_lecp("%s: sp %d, parent "
+ "(opc %d, indet %d, collect_rem %d)\n",
+ __func__, ctx->sp, parent->opcode >> 5, parent->indet,
+ (int)parent->collect_rem);
+
+ parent->ordinal++;
+ if (parent->opcode == LWS_CBOR_MAJTYP_ARRAY) {
+ assert(il);
+ il--;
+ ctx->i[il]++;
+ if (!parent->send_new_array_item) {
+ if (ctx->pst[ctx->pst_sp].cb(ctx,
+ LECPCB_ARRAY_ITEM_END))
+ return LECP_REJECT_CALLBACK;
+ parent->send_new_array_item = 1;
+ }
+ }
+
+ if (!indet && parent->indet) {
+ lwsl_lecp("%s: abandoning walk as parent needs indet\n", __func__);
+ break;
+ }
+
+ if (!parent->indet && parent->collect_rem) {
+ parent->collect_rem--;
+ lwsl_lecp("%s: sp %d, parent (opc %d, indet %d, collect_rem -> %d)\n",
+ __func__, ctx->sp, parent->opcode >> 5, parent->indet, (int)parent->collect_rem);
+
+ if (parent->collect_rem) {
+ /* more items to come */
+ if (parent->opcode == LWS_CBOR_MAJTYP_ARRAY)
+ parent->send_new_array_item = 1;
+ break;
+ }
+ }
+
+ lwsl_lecp("%s: parent (opc %d) collect_rem became zero\n", __func__, parent->opcode >> 5);
+
+ ctx->st[ctx->sp - 1].s = LECP_OPC;
+ r = lecp_pop(ctx);
+ if (r)
+ return r;
+ indet = 0;
+ }
+
+ return 0;
+}
+
+static int
+lwcp_is_indet_string(struct lecp_ctx *ctx)
+{
+ if (ctx->st[ctx->sp].indet)
+ return 1;
+
+ if (!ctx->sp)
+ return 0;
+
+ if (lwcp_st_parent(ctx)->opcode != LWS_CBOR_MAJTYP_BSTR &&
+ lwcp_st_parent(ctx)->opcode != LWS_CBOR_MAJTYP_TSTR)
+ return 0;
+
+ if (ctx->st[ctx->sp - 1].indet)
+ return 1;
+
+ return 0;
+}
+
+static int
+report_raw_cbor(struct lecp_ctx *ctx)
+{
+ struct _lecp_parsing_stack *pst = &ctx->pst[ctx->pst_sp];
+
+ if (!ctx->cbor_pos)
+ return 0;
+
+ if (pst->cb(ctx, LECPCB_LITERAL_CBOR))
+ return 1;
+
+ ctx->cbor_pos = 0;
+
+ return 0;
+}
+
+void
+lecp_parse_report_raw(struct lecp_ctx *ctx, int on)
+{
+ ctx->literal_cbor_report = (uint8_t)on;
+ report_raw_cbor(ctx);
+}
+
+int
+lecp_parse_map_is_key(struct lecp_ctx *ctx)
+{
+ return lwcp_st_parent(ctx)->opcode == LWS_CBOR_MAJTYP_MAP &&
+ !(lwcp_st_parent(ctx)->ordinal & 1);
+}
+
+int
+lecp_parse_subtree(struct lecp_ctx *ctx, const uint8_t *in, size_t len)
+{
+ struct _lecp_stack *st = &ctx->st[++ctx->sp];
+ int n;
+
+ st->s = 0;
+ st->collect_rem = 0;
+ st->intermediate = 0;
+ st->indet = 0;
+ st->ordinal = 0;
+ st->send_new_array_item = 0;
+ st->barrier = 1;
+
+ n = lecp_parse(ctx, in, len);
+ ctx->sp--;
+
+ return n;
+}
+
+int
+lecp_parse(struct lecp_ctx *ctx, const uint8_t *cbor, size_t len)
+{
+ size_t olen = len;
+ int ret;
+
+ while (len--) {
+ struct _lecp_parsing_stack *pst = &ctx->pst[ctx->pst_sp];
+ struct _lecp_stack *st = &ctx->st[ctx->sp];
+ uint8_t c, sm, o;
+ char to;
+
+ c = *cbor++;
+
+ /*
+ * for, eg, cose_sign, we sometimes need to collect subtrees of
+ * raw CBOR. Report buffers of it via the callback if we filled
+ * the buffer, or we stopped collecting.
+ */
+
+ if (ctx->literal_cbor_report) {
+ ctx->cbor[ctx->cbor_pos++] = c;
+ if (ctx->cbor_pos == sizeof(ctx->cbor) &&
+ report_raw_cbor(ctx))
+ goto reject_callback;
+ }
+
+ switch (st->s) {
+ /*
+ * We're getting the nex opcode
+ */
+ case LECP_OPC:
+ st->opcode = ctx->item.opcode = c & LWS_CBOR_MAJTYP_MASK;
+ sm = c & LWS_CBOR_SUBMASK;
+ to = 0;
+
+ lwsl_lecp("%s: %d: OPC %d|%d\n", __func__, ctx->sp,
+ c >> 5, sm);
+
+ if (c != 0xff && ctx->sp &&
+ ctx->st[ctx->sp - 1].send_new_array_item) {
+ ctx->st[ctx->sp - 1].send_new_array_item = 0;
+ if (ctx->pst[ctx->pst_sp].cb(ctx,
+ LECPCB_ARRAY_ITEM_START))
+ goto reject_callback;
+ }
+
+ switch (st->opcode) {
+ case LWS_CBOR_MAJTYP_UINT:
+ ctx->present = LECPCB_VAL_NUM_UINT;
+ if (sm < LWS_CBOR_1) {
+ ctx->item.u.i64 = (int64_t)sm;
+ goto issue;
+ }
+ goto i2;
+
+ case LWS_CBOR_MAJTYP_INT_NEG:
+ ctx->present = LECPCB_VAL_NUM_INT;
+ if (sm < 24) {
+ ctx->item.u.i64 = (-1ll) - (int64_t)sm;
+ goto issue;
+ }
+i2:
+ if (sm >= LWS_CBOR_RESERVED)
+ goto bad_coding;
+ ctx->item.u.u64 = 0;
+ o = (uint8_t)(1 << (sm - LWS_CBOR_1));
+ ex(ctx, (uint8_t *)&ctx->item.u.u64, o);
+ break;
+
+ case LWS_CBOR_MAJTYP_BSTR:
+ to = LECPCB_VAL_BLOB_END - LECPCB_VAL_STR_END;
+
+ /* fallthru */
+
+ case LWS_CBOR_MAJTYP_TSTR:
+ /*
+ * The first thing is the string length, it's
+ * going to either be a byte count for the
+ * string or the indefinite length marker
+ * followed by determinite-length chunks of the
+ * same MAJTYP
+ */
+
+ ctx->npos = 0;
+ ctx->buf[0] = '\0';
+
+ if (!sm) {
+ if ((!ctx->sp || (ctx->sp &&
+ !ctx->st[ctx->sp - 1].intermediate)) &&
+ pst->cb(ctx, (char)(LECPCB_VAL_STR_START + to)))
+ goto reject_callback;
+
+ if (pst->cb(ctx, (char)(LECPCB_VAL_STR_END + to)))
+ goto reject_callback;
+ lwcp_completed(ctx, 0);
+ break;
+ }
+
+ if (sm < LWS_CBOR_1) {
+ ctx->item.u.u64 = (uint64_t)sm;
+ if ((!ctx->sp || (ctx->sp &&
+ !ctx->st[ctx->sp - 1].intermediate)) &&
+ pst->cb(ctx, (char)(LECPCB_VAL_STR_START + to)))
+ goto reject_callback;
+
+ st->indet = 0;
+ st->collect_rem = sm;
+ st->s = LECP_COLLATE;
+ break;
+ }
+
+ if (sm < LWS_CBOR_RESERVED)
+ goto i2;
+
+ if (sm != LWS_CBOR_INDETERMINITE)
+ goto bad_coding;
+
+ if ((!ctx->sp || (ctx->sp &&
+ !ctx->st[ctx->sp - 1].intermediate)) &&
+ pst->cb(ctx, (char)(LECPCB_VAL_STR_START + to)))
+ goto reject_callback;
+
+ st->indet = 1;
+
+ st->p = pst->ppos;
+ lecp_push(ctx, 0, (char)(LECPCB_VAL_STR_END + to),
+ LECP_ONLY_SAME);
+ break;
+
+ case LWS_CBOR_MAJTYP_ARRAY:
+ ctx->npos = 0;
+ ctx->buf[0] = '\0';
+
+ if (pst->ppos + 3u >= sizeof(ctx->path))
+ goto reject_overflow;
+
+ st->p = pst->ppos;
+ ctx->path[pst->ppos++] = '[';
+ ctx->path[pst->ppos++] = ']';
+ ctx->path[pst->ppos] = '\0';
+
+ lecp_check_path_match(ctx);
+
+ if (ctx->ipos + 1u >= LWS_ARRAY_SIZE(ctx->i))
+ goto reject_overflow;
+
+ ctx->i[ctx->ipos++] = 0;
+
+ if (pst->cb(ctx, LECPCB_ARRAY_START))
+ goto reject_callback;
+
+ if (!sm) {
+ if (pst->cb(ctx, LECPCB_ARRAY_END))
+ goto reject_callback;
+ pst->ppos = st->p;
+ ctx->path[pst->ppos] = '\0';
+ ctx->ipos--;
+ lecp_check_path_match(ctx);
+ lwcp_completed(ctx, 0);
+ break;
+ }
+
+ ctx->st[ctx->sp].send_new_array_item = 1;
+
+ if (sm < LWS_CBOR_1) {
+ st->indet = 0;
+ st->collect_rem = sm;
+ goto push_a;
+ }
+
+ if (sm < LWS_CBOR_RESERVED)
+ goto i2;
+
+ if (sm != LWS_CBOR_INDETERMINITE)
+ goto bad_coding;
+
+ st->indet = 1;
+push_a:
+ lecp_push(ctx, 0, LECPCB_ARRAY_END, LECP_OPC);
+ break;
+
+ case LWS_CBOR_MAJTYP_MAP:
+ ctx->npos = 0;
+ ctx->buf[0] = '\0';
+
+ if (pst->ppos + 1u >= sizeof(ctx->path))
+ goto reject_overflow;
+
+ st->p = pst->ppos;
+ ctx->path[pst->ppos++] = '.';
+ ctx->path[pst->ppos] = '\0';
+
+ lecp_check_path_match(ctx);
+
+ if (pst->cb(ctx, LECPCB_OBJECT_START))
+ goto reject_callback;
+
+ if (!sm) {
+ if (pst->cb(ctx, LECPCB_OBJECT_END))
+ goto reject_callback;
+ pst->ppos = st->p;
+ ctx->path[pst->ppos] = '\0';
+ lecp_check_path_match(ctx);
+ lwcp_completed(ctx, 0);
+ break;
+ }
+ if (sm < LWS_CBOR_1) {
+ st->indet = 0;
+ st->collect_rem = (uint64_t)(sm * 2);
+ goto push_m;
+ }
+
+ if (sm < LWS_CBOR_RESERVED)
+ goto i2;
+
+ if (sm != LWS_CBOR_INDETERMINITE)
+ goto bad_coding;
+
+ st->indet = 1;
+push_m:
+ lecp_push(ctx, 0, LECPCB_OBJECT_END, LECP_OPC);
+ break;
+
+ case LWS_CBOR_MAJTYP_TAG:
+ /* tag has one or another kind of int first */
+ if (sm < LWS_CBOR_1) {
+ /*
+ * We have a literal tag number, push
+ * to decode the tag body
+ */
+ ctx->item.u.u64 = st->tag = (uint64_t)sm;
+ goto start_tag_enclosure;
+ }
+ /*
+ * We have to do more stuff to get the tag
+ * number...
+ */
+ goto i2;
+
+ case LWS_CBOR_MAJTYP_FLOAT:
+ /*
+ * This can also be a bunch of specials as well
+ * as sizes of float...
+ */
+ sm = c & LWS_CBOR_SUBMASK;
+
+ switch (sm) {
+ case LWS_CBOR_SWK_FALSE:
+ ctx->present = LECPCB_VAL_FALSE;
+ goto issue;
+
+ case LWS_CBOR_SWK_TRUE:
+ ctx->present = LECPCB_VAL_TRUE;
+ goto issue;
+
+ case LWS_CBOR_SWK_NULL:
+ ctx->present = LECPCB_VAL_NULL;
+ goto issue;
+
+ case LWS_CBOR_SWK_UNDEFINED:
+ ctx->present = LECPCB_VAL_UNDEFINED;
+ goto issue;
+
+ case LWS_CBOR_M7_SUBTYP_SIMPLE_X8:
+ st->s = LECP_SIMPLEX8;
+ break;
+
+ case LWS_CBOR_M7_SUBTYP_FLOAT16:
+ ctx->present = LECPCB_VAL_FLOAT16;
+ ex(ctx, &ctx->item.u.hf, 2);
+ break;
+
+ case LWS_CBOR_M7_SUBTYP_FLOAT32:
+ ctx->present = LECPCB_VAL_FLOAT32;
+ ex(ctx, &ctx->item.u.f, 4);
+ break;
+
+ case LWS_CBOR_M7_SUBTYP_FLOAT64:
+ ctx->present = LECPCB_VAL_FLOAT64;
+ ex(ctx, &ctx->item.u.d, 8);
+ break;
+
+ case LWS_CBOR_M7_BREAK:
+ if (!ctx->sp ||
+ !ctx->st[ctx->sp - 1].indet)
+ goto bad_coding;
+
+ lwcp_completed(ctx, 1);
+ break;
+
+ default:
+ /* handle as simple */
+ ctx->item.u.u64 = (uint64_t)sm;
+ if (pst->cb(ctx, LECPCB_VAL_SIMPLE))
+ goto reject_callback;
+ break;
+ }
+ break;
+ }
+ break;
+
+ /*
+ * We're collecting int / float pieces
+ */
+ case LECP_COLLECT:
+ if (ctx->be)
+ *ctx->collect_tgt++ = c;
+ else
+ *ctx->collect_tgt-- = c;
+
+ if (--st->collect_rem)
+ break;
+
+ /*
+ * We collected whatever it was...
+ */
+
+ ctx->npos = 0;
+ ctx->buf[0] = '\0';
+
+ switch (st->opcode) {
+ case LWS_CBOR_MAJTYP_BSTR:
+ case LWS_CBOR_MAJTYP_TSTR:
+ st->collect_rem = ctx->item.u.u64;
+ if ((!ctx->sp || (ctx->sp &&
+ !ctx->st[ctx->sp - 1].intermediate)) &&
+ pst->cb(ctx, (char)((st->opcode ==
+ LWS_CBOR_MAJTYP_TSTR) ?
+ LECPCB_VAL_STR_START :
+ LECPCB_VAL_BLOB_START)))
+ goto reject_callback;
+ st->s = LECP_COLLATE;
+ break;
+
+ case LWS_CBOR_MAJTYP_ARRAY:
+ st->collect_rem = ctx->item.u.u64;
+ lecp_push(ctx, 0, LECPCB_ARRAY_END, LECP_OPC);
+ break;
+
+ case LWS_CBOR_MAJTYP_MAP:
+ st->collect_rem = ctx->item.u.u64 * 2;
+ lecp_push(ctx, 0, LECPCB_OBJECT_END, LECP_OPC);
+ break;
+
+ case LWS_CBOR_MAJTYP_TAG:
+ st->tag = ctx->item.u.u64;
+ goto start_tag_enclosure;
+
+ default:
+ /*
+ * ... then issue what we collected as a
+ * literal
+ */
+
+ if (st->opcode == LWS_CBOR_MAJTYP_INT_NEG)
+ ctx->item.u.i64 = (-1ll) - ctx->item.u.i64;
+
+ goto issue;
+ }
+ break;
+
+ case LECP_SIMPLEX8:
+ /*
+ * Extended SIMPLE byte for 7|24 opcode, no uses
+ * for it in RFC8949
+ */
+ if (c <= LWS_CBOR_INDETERMINITE)
+ /*
+ * Duplication of implicit simple values is
+ * denied by RFC8949 3.3
+ */
+ goto bad_coding;
+
+ ctx->item.u.u64 = (uint64_t)c;
+ if (pst->cb(ctx, LECPCB_VAL_SIMPLE))
+ goto reject_callback;
+
+ lwcp_completed(ctx, 0);
+ break;
+
+ case LECP_COLLATE:
+ /*
+ * let's grab b/t string content into the context
+ * buffer, and issue chunks from there
+ */
+
+ ctx->buf[ctx->npos++] = (char)c;
+ if (st->collect_rem)
+ st->collect_rem--;
+
+ /* spill at chunk boundaries, or if we filled the buf */
+ if (ctx->npos != sizeof(ctx->buf) - 1 &&
+ st->collect_rem)
+ break;
+
+ /* spill */
+ ctx->buf[ctx->npos] = '\0';
+
+ /* if it's a map name, deal with the path */
+ if (ctx->sp && lecp_parse_map_is_key(ctx)) {
+ if (lwcp_st_parent(ctx)->ordinal)
+ pst->ppos = st->p;
+ st->p = pst->ppos;
+ if (pst->ppos + ctx->npos > sizeof(ctx->path))
+ goto reject_overflow;
+ memcpy(&ctx->path[pst->ppos], ctx->buf,
+ (size_t)(ctx->npos + 1));
+ pst->ppos = (uint8_t)(pst->ppos + ctx->npos);
+ lecp_check_path_match(ctx);
+ }
+
+ to = 0;
+ if (ctx->item.opcode == LWS_CBOR_MAJTYP_BSTR)
+ to = LECPCB_VAL_BLOB_END - LECPCB_VAL_STR_END;
+
+ o = (uint8_t)(LECPCB_VAL_STR_END + to);
+ c = (st->collect_rem /* more to come at this layer */ ||
+ /* we or direct parent is indeterminite */
+ lwcp_is_indet_string(ctx));
+
+ if (ctx->sp)
+ ctx->st[ctx->sp - 1].intermediate = !!c;
+ if (c)
+ o--;
+
+ if (pst->cb(ctx, (char)o))
+ goto reject_callback;
+ ctx->npos = 0;
+ ctx->buf[0] = '\0';
+
+ if (ctx->sp && lwcp_st_parent(ctx)->indet)
+ st->s = LECP_OPC;
+ if (o == LECPCB_VAL_STR_END + to)
+ lwcp_completed(ctx, 0);
+
+ break;
+
+ case LECP_ONLY_SAME:
+ /*
+ * deterministic sized chunks same MAJTYP as parent
+ * level only (BSTR and TSTR frags inside interderminite
+ * BSTR or TSTR)
+ *
+ * Clean end when we see M7|31
+ */
+ if (!ctx->sp) {
+ /*
+ * We should only come here by pushing on stack
+ */
+ assert(0);
+ return LECP_STACK_OVERFLOW;
+ }
+
+ if (c == (LWS_CBOR_MAJTYP_FLOAT | LWS_CBOR_M7_BREAK)) {
+ /* if's the end of an interdetminite list */
+ if (!ctx->sp || !ctx->st[ctx->sp - 1].indet)
+ /*
+ * Can't have a break without an
+ * indeterminite parent
+ */
+ goto bad_coding;
+
+ if (lwcp_completed(ctx, 1))
+ goto reject_callback;
+ break;
+ }
+
+ if (st->opcode != lwcp_st_parent(ctx)->opcode)
+ /*
+ * Fragments have to be of the same type as the
+ * outer opcode
+ */
+ goto bad_coding;
+
+ sm = c & LWS_CBOR_SUBMASK;
+
+ if (sm == LWS_CBOR_INDETERMINITE)
+ /* indeterminite length frags not allowed */
+ goto bad_coding;
+
+ if (sm < LWS_CBOR_1) {
+ st->indet = 0;
+ st->collect_rem = (uint64_t)sm;
+ st->s = LECP_COLLATE;
+ break;
+ }
+
+ if (sm >= LWS_CBOR_RESERVED)
+ goto bad_coding;
+
+ goto i2;
+
+ default:
+ assert(0);
+ return -1;
+ }
+
+ continue;
+
+start_tag_enclosure:
+ st->p = pst->ppos;
+ ret = lecp_push(ctx, LECPCB_TAG_START, LECPCB_TAG_END, LECP_OPC);
+ if (ret)
+ return ret;
+
+ continue;
+
+issue:
+ if (ctx->item.opcode == LWS_CBOR_MAJTYP_TAG) {
+ st->tag = ctx->item.u.u64;
+ goto start_tag_enclosure;
+ }
+
+ /* we are just a number */
+
+ if (pst->cb(ctx, ctx->present))
+ goto reject_callback;
+
+ lwcp_completed(ctx, 0);
+
+ }
+
+ ctx->used_in = olen - len;
+
+ if (!ctx->sp && ctx->st[0].s == LECP_OPC)
+ return 0;
+
+ return LECP_CONTINUE;
+
+reject_overflow:
+ ret = LECP_STACK_OVERFLOW;
+ goto reject;
+
+bad_coding:
+ ret = LECP_REJECT_BAD_CODING;
+ goto reject;
+
+reject_callback:
+ ret = LECP_REJECT_CALLBACK;
+
+reject:
+ ctx->pst[ctx->pst_sp].cb(ctx, LECPCB_FAILED);
+
+ return ret;
+}
+
+
+
+void
+lws_lec_init(lws_lec_pctx_t *ctx, uint8_t *buf, size_t len)
+{
+ memset(ctx, 0, sizeof(*ctx));
+ ctx->start = ctx->buf = buf;
+ ctx->end = ctx->start + len;
+ ctx->fmt_pos = 0;
+}
+
+void
+lws_lec_setbuf(lws_lec_pctx_t *ctx, uint8_t *buf, size_t len)
+{
+ ctx->start = ctx->buf = buf;
+ ctx->end = ctx->start + len;
+ ctx->used = 0;
+ ctx->vaa_pos = 0;
+}
+
+enum lws_lec_pctx_ret
+lws_lec_printf(lws_lec_pctx_t *ctx, const char *format, ...)
+{
+ enum lws_lec_pctx_ret r;
+ va_list ap;
+
+ va_start(ap, format);
+ r = lws_lec_vsprintf(ctx, format, ap);
+ va_end(ap);
+
+ return r;
+}
+
+/*
+ * Report how many next-level elements inbetween fmt[0] and the matching
+ * closure, eg, [] returns 0, [123] would return 1, [123,456] returns 2, and
+ * [123,{'a':[123,456]}] returns 2. Counts for { } maps are in pairs, ie,
+ * {'a':1, 'b': 2} returns 2
+ *
+ * If there is no closure in the string it returns -1
+ *
+ * We use this to figure out if we should use indeterminite lengths or specific
+ * lengths for items in the format string
+ */
+
+#define bump(_r) count[sp]++
+//; lwsl_notice("%s: count[%d] -> %d\n", _r, sp, count[sp])
+
+static int
+format_scan(const char *fmt)
+{
+ char stack[12], literal = 0, numeric = 0;
+ int count[12], sp = 0, pc = 0, swallow = 0;
+
+ literal = *fmt == '\'';
+ stack[sp] = *fmt++;
+ count[sp] = 0;
+
+// lwsl_notice("%s: start %s\n", __func__, fmt - 1);
+
+ while (*fmt) {
+
+// lwsl_notice("%s: %c %d %d\n", __func__, *fmt, sp, literal);
+
+ if (swallow) {
+ swallow--;
+ fmt++;
+ continue;
+ }
+
+ if (numeric) {
+ if (*fmt >= '0' && *fmt <= '9')
+ fmt++;
+ numeric = 0;
+ if (*fmt != '(')
+ bump("a");
+ }
+
+ if (literal) {
+ if (*fmt == '\\' && fmt[1]) {
+ fmt += 2;
+ continue;
+ }
+ if (*fmt == '\'') {
+ literal = 0;
+ if (!sp && stack[sp] == '\'')
+ return count[sp];
+
+ if (sp)
+ sp--;
+ fmt++;
+ continue;
+ }
+
+ bump("b");
+ fmt++;
+ continue;
+ }
+
+ if (*fmt == '\'') {
+ bump("c");
+ sp++;
+ literal = 1;
+ fmt++;
+ continue;
+ }
+
+ switch (pc) {
+ case 1:
+ if (*fmt == '.') {
+ pc++;
+ fmt++;
+ continue;
+ }
+ if (*fmt == 'l') {
+ pc++;
+ fmt++;
+ continue;
+ }
+ /* fallthru */
+ case 2:
+ if (*fmt == '*') {
+ pc++;
+ fmt++;
+ continue;
+ }
+ if (*fmt == 'l') {
+ pc++;
+ fmt++;
+ continue;
+ }
+ /* fallthru */
+ case 3:
+ bump("pc");
+ pc = 0;
+ fmt++;
+ continue;
+ }
+
+ switch (*fmt) {
+
+ case '<':
+ swallow = 1;
+ /* fallthru */
+ case '[':
+ case '(':
+ case '{':
+ if (sp == sizeof(stack))
+ return -2;
+
+ bump("d");
+ sp++;
+ stack[sp] = *fmt;
+ count[sp] = 0;
+ break;
+ case ' ':
+ break;
+ case ',':
+ //count[sp]++;
+ break;
+ case ':':
+ if (stack[sp] != '{')
+ goto mismatch;
+ //count[sp]++;
+ break;
+ case '%':
+ pc = 1;
+ break;
+ case ']':
+ if (stack[sp] != '[')
+ goto mismatch;
+ goto pop;
+ case ')':
+ if (stack[sp] != '(')
+ goto mismatch;
+ goto pop;
+ case '}':
+ if (stack[sp] != '{')
+ goto mismatch;
+ goto pop;
+ case '>':
+ if (stack[sp] != '<')
+ goto mismatch;
+pop:
+ if (sp) {
+ sp--;
+ break;
+ }
+
+ if (stack[0] == '{') {
+ /* args have to come in pairs */
+ if (count[0] & 1) {
+ lwsl_err("%s: odd map args %d %s\n",
+ __func__, count[0], fmt);
+ return -2;
+ }
+ // lwsl_notice("%s: return %d pairs\n", __func__, count[0] >> 1);
+ /* report how many pairs */
+ return count[0] >> 1;
+ }
+
+ // lwsl_notice("%s: return %d items\n", __func__, count[0]);
+
+ return count[0];
+
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ numeric = 1;
+
+ break;
+
+ default:
+ bump("e");
+ break;
+ }
+ fmt++;
+ }
+
+ return -1;
+
+mismatch:
+ lwsl_err("%s: format mismatch %c %c\n", __func__, stack[sp], *fmt);
+
+ return -2;
+}
+
+void
+lws_lec_signed(lws_lec_pctx_t *ctx, int64_t num)
+{
+ if (num < 0)
+ lws_lec_int(ctx, LWS_CBOR_MAJTYP_INT_NEG, 0,
+ (uint64_t)(-1ll - num));
+ else
+ lws_lec_int(ctx, LWS_CBOR_MAJTYP_UINT, 0, (uint64_t)num);
+}
+
+void
+lws_lec_int(lws_lec_pctx_t *ctx, uint8_t opcode, uint8_t indet, uint64_t num)
+{
+ uint8_t hint = 0;
+ unsigned int n;
+
+ if (indet) {
+ ctx->scratch[ctx->scratch_len++] = (uint8_t)(opcode |
+ LWS_CBOR_INDETERMINITE);
+ return;
+ }
+
+ if ((opcode & LWS_CBOR_MAJTYP_MASK) == LWS_CBOR_MAJTYP_FLOAT) {
+ hint = opcode & LWS_CBOR_SUBMASK;
+ switch (hint) {
+ case LWS_CBOR_M7_SUBTYP_FLOAT16:
+ num <<= 48;
+ break;
+ case LWS_CBOR_M7_SUBTYP_FLOAT32:
+ num <<= 32;
+ break;
+ }
+ } else {
+
+ if (num < LWS_CBOR_1) {
+ ctx->scratch[ctx->scratch_len++] = (uint8_t)(opcode | num);
+ return;
+ }
+
+ if (!(num & (uint64_t)(~0xffull))) {
+ hint = LWS_CBOR_1;
+ num <<= 56;
+ } else
+ if (!(num & (uint64_t)(~0xffffull))) {
+ hint = LWS_CBOR_2;
+ num <<= 48;
+ } else
+ if (!(num & (uint64_t)(~0xffffffffull))) {
+ hint = LWS_CBOR_4;
+ num <<= 32;
+ }
+ else
+ hint = LWS_CBOR_8;
+ }
+
+ ctx->scratch[ctx->scratch_len++] = (uint8_t)(opcode | hint);
+ n = 1u << (hint - LWS_CBOR_1);
+ while (n--) {
+ ctx->scratch[ctx->scratch_len++] = (uint8_t)(num >> 56);
+ num <<= 8;
+ }
+}
+
+enum {
+ NATTYPE_INT,
+ NATTYPE_LONG,
+ NATTYPE_LONG_LONG,
+ NATTYPE_PTR,
+ NATTYPE_DOUBLE,
+};
+
+int
+lws_lec_scratch(lws_lec_pctx_t *ctx)
+{
+ size_t s;
+
+ if (!ctx->scratch_len)
+ return 0;
+
+ s = lws_ptr_diff_size_t(ctx->end, ctx->buf);
+ if (s > (size_t)ctx->scratch_len)
+ s = (size_t)ctx->scratch_len;
+
+ memcpy(ctx->buf, ctx->scratch, s);
+ ctx->buf += s;
+ ctx->scratch_len = (uint8_t)(ctx->scratch_len - (uint8_t)s);
+
+ return ctx->buf == ctx->end;
+}
+
+enum lws_lec_pctx_ret
+lws_lec_vsprintf(lws_lec_pctx_t *ctx, const char *fmt, va_list args)
+{
+ size_t fl = strlen(fmt);
+ uint64_t u64;
+ int64_t i64;
+#if defined(LWS_WITH_CBOR_FLOAT)
+ double dbl;
+#endif
+ size_t s;
+ char c;
+ int n;
+
+ /*
+ * We might be being called after the first time, since we had to emit
+ * output buffer(s) before we could move on in the format string. For
+ * this case, reposition ourselves at the vaarg we got to from the last
+ * call.
+ */
+
+ for (n = 0; n < ctx->vaa_pos; n++) {
+
+ switch (ctx->vaa[n]) {
+ case NATTYPE_INT:
+ (void)va_arg(args, int);
+ break;
+ case NATTYPE_LONG:
+ (void)va_arg(args, long);
+ break;
+ case NATTYPE_LONG_LONG:
+ (void)va_arg(args, long long);
+ break;
+ case NATTYPE_PTR:
+ (void)va_arg(args, const char *);
+ break;
+ case NATTYPE_DOUBLE:
+ (void)va_arg(args, double);
+ break;
+ }
+ if (ctx->state == CBPS_STRING_BODY)
+ /*
+ * when copying out text or binary strings, we reload
+ * the %s or %.*s pointer on subsequent calls, in case
+ * it was on the stack. The length and contents should
+ * not change between calls, but it's OK if the source
+ * address does.
+ */
+ ctx->ongoing_src = va_arg(args, uint8_t *);
+ }
+
+ while (ctx->buf != ctx->end) {
+
+ /*
+ * We write small things into the context scratch array, then
+ * copy that into the output buffer fragmenting as needed. Next
+ * time we will finish emptying the scratch into the output
+ * buffer preferentially.
+ *
+ * Then we don't otherwise have to handle fragmentations in
+ * order to exactly fill the output buffer, simplifying
+ * everything else.
+ */
+
+ if (lws_lec_scratch(ctx))
+ break;
+
+ if (ctx->fmt_pos >= fl) {
+ if (ctx->state == CBPS_IDLE)
+ break;
+ c = 0;
+ } else
+ c = fmt[ctx->fmt_pos];
+
+ // lwsl_notice("%s: %d %d %c\n", __func__, ctx->state, ctx->sp, c);
+
+ switch (ctx->state) {
+ case CBPS_IDLE:
+ ctx->scratch_len = 0;
+ switch (c) {
+ case '[':
+ n = format_scan(&fmt[ctx->fmt_pos]);
+ if (n == -2)
+ return LWS_LECPCTX_RET_FAIL;
+ lws_lec_int(ctx, LWS_CBOR_MAJTYP_ARRAY, n == -1,
+ (uint64_t)n);
+ goto stack_push;
+ case '{':
+ n = format_scan(&fmt[ctx->fmt_pos]);
+ if (n == -2)
+ return LWS_LECPCTX_RET_FAIL;
+ lws_lec_int(ctx, LWS_CBOR_MAJTYP_MAP, n == -1,
+ (uint64_t)n);
+ goto stack_push;
+ case '(':
+ /* must be preceded by a number */
+ goto fail;
+
+ case '<': /* <t or <b */
+ ctx->state = CBPS_CONTYPE;
+ break;
+
+ case ']':
+ if (!ctx->sp || ctx->stack[ctx->sp - 1] != '[')
+ return LWS_LECPCTX_RET_FAIL;
+ ctx->sp--;
+ break;
+ case '}':
+ if (!ctx->sp || ctx->stack[ctx->sp - 1] != '{')
+ return LWS_LECPCTX_RET_FAIL;
+ ctx->sp--;
+ break;
+ case ')':
+ if (!ctx->sp || ctx->stack[ctx->sp - 1] != '(') {
+ lwsl_notice("bad tag end %d %c\n",
+ ctx->sp, ctx->stack[ctx->sp - 1]);
+ goto fail;
+ }
+ ctx->sp--;
+ break;
+ case '>':
+ if (!ctx->sp || ctx->stack[ctx->sp - 1] != '<')
+ return LWS_LECPCTX_RET_FAIL;
+ ctx->scratch[ctx->scratch_len++] =
+ (uint8_t)(LWS_CBOR_MAJTYP_FLOAT |
+ LWS_CBOR_M7_BREAK);
+ ctx->sp--;
+ break;
+ case '\'':
+ n = format_scan(&fmt[ctx->fmt_pos]);
+ // lwsl_notice("%s: quote fs %d\n", __func__, n);
+ if (n < 0)
+ return LWS_LECPCTX_RET_FAIL;
+ lws_lec_int(ctx, LWS_CBOR_MAJTYP_TSTR, 0,
+ (uint64_t)n);
+ ctx->state = CBPS_STRING_LIT;
+ break;
+ case '%':
+ if (ctx->vaa_pos >= sizeof(ctx->vaa) - 1) {
+ lwsl_err("%s: too many %%\n", __func__);
+ goto fail;
+ }
+ ctx->_long = 0;
+ ctx->dotstar = 0;
+ ctx->state = CBPS_PC1;
+ break;
+ case ':':
+ break;
+ case ',':
+ break;
+ case '-':
+ ctx->item.opcode = LWS_CBOR_MAJTYP_INT_NEG;
+ ctx->item.u.i64 = 0;
+ ctx->state = CBPS_NUM_LIT;
+ break;
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ ctx->item.opcode = LWS_CBOR_MAJTYP_UINT;
+ ctx->item.u.u64 = (uint64_t)(c - '0');
+ ctx->state = CBPS_NUM_LIT;
+ break;
+ }
+ break;
+ case CBPS_PC1:
+ if (c == 'l') {
+ ctx->_long++;
+ ctx->state = CBPS_PC2;
+ break;
+ }
+ if (c == '.') {
+ ctx->dotstar++;
+ ctx->state = CBPS_PC2;
+ break;
+ }
+ /* fallthru */
+
+ case CBPS_PC2:
+ if (c == 'l') {
+ ctx->_long++;
+ ctx->state = CBPS_PC3;
+ break;
+ }
+ if (c == '*') {
+ ctx->dotstar++;
+ ctx->state = CBPS_PC3;
+ break;
+ }
+ /* fallthru */
+
+ case CBPS_PC3:
+ switch (c) {
+ case 'd':
+ switch (ctx->_long) {
+ case 0:
+ i64 = (int64_t)va_arg(args, int);
+ ctx->vaa[ctx->vaa_pos++] = NATTYPE_INT;
+ break;
+ case 1:
+ i64 = (int64_t)va_arg(args, long);
+ ctx->vaa[ctx->vaa_pos++] = NATTYPE_LONG;
+ break;
+ case 2:
+ i64 = (int64_t)va_arg(args, long long);
+ ctx->vaa[ctx->vaa_pos++] = NATTYPE_LONG_LONG;
+ break;
+ }
+ if (i64 < 0)
+ lws_lec_int(ctx,
+ LWS_CBOR_MAJTYP_INT_NEG, 0,
+ (uint64_t)(-1ll - i64));
+ else
+ lws_lec_int(ctx,
+ LWS_CBOR_MAJTYP_UINT, 0,
+ (uint64_t)i64);
+ break;
+ case 'u':
+ switch (ctx->_long) {
+ case 0:
+ u64 = (uint64_t)va_arg(args, unsigned int);
+ ctx->vaa[ctx->vaa_pos++] = NATTYPE_INT;
+ break;
+ case 1:
+ u64 = (uint64_t)va_arg(args, unsigned long);
+ ctx->vaa[ctx->vaa_pos++] = NATTYPE_LONG;
+ break;
+ case 2:
+ u64 = (uint64_t)va_arg(args, unsigned long long);
+ ctx->vaa[ctx->vaa_pos++] = NATTYPE_LONG_LONG;
+ break;
+ }
+ lws_lec_int(ctx, LWS_CBOR_MAJTYP_UINT, 0, u64);
+ break;
+ case 's': /* text string */
+ ctx->ongoing_done = 0;
+ if (ctx->dotstar == 2) {
+ ctx->ongoing_len = (uint64_t)va_arg(args, int);
+ ctx->vaa[ctx->vaa_pos++] = NATTYPE_INT;
+ }
+ /* vaa for ptr done at end of body copy */
+ ctx->ongoing_src = va_arg(args, uint8_t *);
+ if (ctx->dotstar != 2)
+ ctx->ongoing_len = (uint64_t)strlen(
+ (const char *)ctx->ongoing_src);
+ lws_lec_int(ctx, LWS_CBOR_MAJTYP_TSTR, 0, ctx->ongoing_len);
+ ctx->state = CBPS_STRING_BODY;
+ ctx->fmt_pos++;
+ continue;
+ case 'b': /* binary string (%.*b only) */
+ if (ctx->dotstar != 2)
+ goto fail;
+ ctx->vaa[ctx->vaa_pos++] = NATTYPE_INT;
+ ctx->ongoing_done = 0;
+ ctx->ongoing_len = (uint64_t)va_arg(args, int);
+ /* vaa for ptr done at end of body copy */
+ ctx->ongoing_src = va_arg(args, uint8_t *);
+ lws_lec_int(ctx, LWS_CBOR_MAJTYP_BSTR, 0, ctx->ongoing_len);
+ ctx->state = CBPS_STRING_BODY;
+ ctx->fmt_pos++;
+ continue;
+ case 't': /* dynamic tag */
+ switch (ctx->_long) {
+ case 0:
+ ctx->item.u.u64 = (uint64_t)va_arg(args, int);
+ ctx->vaa[ctx->vaa_pos++] = NATTYPE_INT;
+ break;
+ case 1:
+ ctx->item.u.u64 = (uint64_t)va_arg(args, long);
+ ctx->vaa[ctx->vaa_pos++] = NATTYPE_LONG;
+ break;
+ case 2:
+ ctx->item.u.u64 = (uint64_t)va_arg(args, long long);
+ ctx->vaa[ctx->vaa_pos++] = NATTYPE_LONG_LONG;
+ break;
+ }
+ ctx->item.opcode = LWS_CBOR_MAJTYP_UINT;
+ ctx->fmt_pos++;
+ if (ctx->fmt_pos >= fl)
+ continue;
+ c = fmt[ctx->fmt_pos];
+ if (c != '(')
+ goto fail;
+ goto tag_body;
+#if defined(LWS_WITH_CBOR_FLOAT)
+ case 'f': /* floating point double */
+ dbl = va_arg(args, double);
+
+ if (dbl == (float)dbl) {
+ uint16_t hf;
+ union {
+ uint32_t ui;
+ float f;
+ } u1, u2;
+
+ u1.f = (float)dbl;
+ lws_singles2halfp(&hf, u1.ui);
+ lws_halfp2singles(&u2.ui, hf);
+
+ if ((isinf(u1.f) && isinf(u2.f)) ||
+ (isnan(u1.f) && isnan(u2.f)) ||
+ u1.f == u2.f) {
+ lws_lec_int(ctx,
+ LWS_CBOR_MAJTYP_FLOAT |
+ LWS_CBOR_M7_SUBTYP_FLOAT16,
+ 0, hf);
+ break;
+ }
+ /* do it as 32-bit float */
+ lws_lec_int(ctx,
+ LWS_CBOR_MAJTYP_FLOAT |
+ LWS_CBOR_M7_SUBTYP_FLOAT32,
+ 0, u1.ui);
+ break;
+ }
+
+ /* do it as 64-bit double */
+
+ {
+ union {
+ uint64_t ui;
+ double f;
+ } u3;
+
+ u3.f = dbl;
+ lws_lec_int(ctx,
+ LWS_CBOR_MAJTYP_FLOAT |
+ LWS_CBOR_M7_SUBTYP_FLOAT64,
+ 0, u3.ui);
+ }
+ break;
+#else
+ case 'f':
+ lwsl_err("%s: no FP support\n", __func__);
+ goto fail;
+#endif
+ }
+ ctx->state = CBPS_IDLE;
+ break;
+
+ case CBPS_STRING_BODY:
+ s = lws_ptr_diff_size_t(ctx->end, ctx->buf);
+ if (s > (size_t)(ctx->ongoing_len - ctx->ongoing_done))
+ s = (size_t)(ctx->ongoing_len - ctx->ongoing_done);
+ memcpy(ctx->buf, ctx->ongoing_src + ctx->ongoing_done, s);
+ ctx->buf += s;
+ ctx->ongoing_done += s;
+ if (ctx->ongoing_len == ctx->ongoing_done) {
+ /* vaa for ptr */
+ ctx->vaa[ctx->vaa_pos++] = NATTYPE_PTR;
+ ctx->state = CBPS_IDLE;
+ }
+ continue;
+
+ case CBPS_NUM_LIT:
+ if (c >= '0' && c <= '9') {
+ ctx->item.u.u64 = (ctx->item.u.u64 * 10) +
+ (uint64_t)(c - '0');
+ break;
+ }
+
+ if (ctx->item.opcode == LWS_CBOR_MAJTYP_INT_NEG)
+ ctx->item.u.i64--;
+
+ if (c == '(') { /* tag qualifier */
+tag_body:
+ n = format_scan(&fmt[ctx->fmt_pos]);
+ if (n == -2)
+ goto fail;
+ /*
+ * inteterminite length not possible for tag,
+ * take it to mean that the closure is in a
+ * later format string
+ */
+
+ lws_lec_int(ctx, LWS_CBOR_MAJTYP_TAG, 0,
+ ctx->item.u.u64);
+
+stack_push:
+ if (ctx->sp >= sizeof(ctx->stack))
+ return LWS_LECPCTX_RET_FAIL;
+ ctx->stack[ctx->sp] = (uint8_t)c;
+ ctx->indet[ctx->sp++] = (uint8_t)(n == -1);
+ // lwsl_notice("%s: pushed %c\n", __func__, c);
+ ctx->state = CBPS_IDLE;
+ break;
+ }
+
+ lws_lec_int(ctx, ctx->item.opcode, 0, ctx->item.u.u64);
+
+ ctx->state = CBPS_IDLE;
+ /* deal with the terminating char fresh */
+ continue;
+
+ case CBPS_STRING_LIT:
+ if (!ctx->escflag && c == '\\') {
+ ctx->escflag = 1;
+ break;
+ }
+ if (!ctx->escflag && c == '\'') {
+ ctx->state = CBPS_IDLE;
+ break;
+ }
+
+ *ctx->buf++ = (uint8_t)c;
+ ctx->escflag = 0;
+
+ break;
+
+ case CBPS_CONTYPE:
+ if (c != 't' && c != 'b')
+ return LWS_LECPCTX_RET_FAIL;
+
+ lws_lec_int(ctx, c == 't' ? LWS_CBOR_MAJTYP_TSTR :
+ LWS_CBOR_MAJTYP_BSTR, 1, 0);
+ c = '<';
+ n = 0;
+ goto stack_push;
+ }
+
+ ctx->fmt_pos++;
+ }
+
+ ctx->used = lws_ptr_diff_size_t(ctx->buf, ctx->start);
+ // lwsl_notice("%s: ctx->used %d\n", __func__, (int)ctx->used);
+
+ if (ctx->buf == ctx->end || ctx->scratch_len)
+ return LWS_LECPCTX_RET_AGAIN;
+
+ ctx->fmt_pos = 0;
+ ctx->vaa_pos = 0;
+
+ return LWS_LECPCTX_RET_FINISHED;
+
+fail:
+ lwsl_notice("%s: failed\n", __func__);
+
+ ctx->fmt_pos = 0;
+
+ return LWS_LECPCTX_RET_FAIL;
+}
diff --git a/lib/misc/lejp.c b/lib/misc/lejp.c
index ee84734..893f0b2 100644
--- a/lib/misc/lejp.c
+++ b/lib/misc/lejp.c
@@ -468,6 +468,9 @@
/* push */
ctx->st[ctx->sp].s = LEJP_MP_ARRAY_END;
c = LEJP_MP_VALUE;
+ if (ctx->pst[ctx->pst_sp].ppos + 3u >=
+ sizeof(ctx->path))
+ goto reject;
ctx->path[ctx->pst[ctx->pst_sp].ppos++] = '[';
ctx->path[ctx->pst[ctx->pst_sp].ppos++] = ']';
ctx->path[ctx->pst[ctx->pst_sp].ppos] = '\0';
@@ -881,3 +884,4 @@
return parser_errs[e];
}
+
diff --git a/minimal-examples/api-tests/api-test-lecp/CMakeLists.txt b/minimal-examples/api-tests/api-test-lecp/CMakeLists.txt
new file mode 100644
index 0000000..b09ee02
--- /dev/null
+++ b/minimal-examples/api-tests/api-test-lecp/CMakeLists.txt
@@ -0,0 +1,22 @@
+project(lws-api-test-lecp C)
+cmake_minimum_required(VERSION 2.8.12)
+find_package(libwebsockets CONFIG REQUIRED)
+list(APPEND CMAKE_MODULE_PATH ${LWS_CMAKE_DIR})
+include(CheckCSourceCompiles)
+include(LwsCheckRequirements)
+
+set(requirements 1)
+require_lws_config(LWS_WITH_CBOR 1 requirements)
+
+if (requirements)
+
+ add_executable(${PROJECT_NAME} main.c)
+ add_test(NAME api-test-lecp COMMAND lws-api-test-lecp)
+
+ if (websockets_shared)
+ target_link_libraries(${PROJECT_NAME} websockets_shared ${LIBWEBSOCKETS_DEP_LIBS})
+ add_dependencies(${PROJECT_NAME} websockets_shared)
+ else()
+ target_link_libraries(${PROJECT_NAME} websockets ${LIBWEBSOCKETS_DEP_LIBS})
+ endif()
+endif()
diff --git a/minimal-examples/api-tests/api-test-lecp/README.md b/minimal-examples/api-tests/api-test-lecp/README.md
new file mode 100644
index 0000000..ebe930d
--- /dev/null
+++ b/minimal-examples/api-tests/api-test-lecp/README.md
@@ -0,0 +1,56 @@
+# lws api test lws_struct JSON
+
+Demonstrates how to use and performs selftests for lws_struct
+JSON serialization and deserialization
+
+## build
+
+```
+ $ cmake . && make
+```
+
+## usage
+
+Commandline option|Meaning
+---|---
+-d <loglevel>|Debug verbosity in decimal, eg, -d15
+
+```
+ $ ./lws-api-test-lws_struct-json
+[2019/03/30 22:09:09:2529] USER: LWS API selftest: lws_struct JSON
+[2019/03/30 22:09:09:2625] NOTICE: main: ++++++++++++++++ test 1
+[2019/03/30 22:09:09:2812] NOTICE: builder.hostname = 'learn', timeout = 1800, targets (2)
+[2019/03/30 22:09:09:2822] NOTICE: target.name 'target1' (target 0x543a830)
+[2019/03/30 22:09:09:2824] NOTICE: target.name 'target2' (target 0x543a860)
+[2019/03/30 22:09:09:2826] NOTICE: main: .... strarting serialization of test 1
+[2019/03/30 22:09:09:2899] NOTICE: ser says 1
+{"schema":"com-warmcat-sai-builder","hostname":"learn","nspawn_timeout":1800,"targets":[{"name":"target1"},{"name":"target2"}]}
+[2019/03/30 22:09:09:2929] NOTICE: main: ++++++++++++++++ test 2
+[2019/03/30 22:09:09:2932] NOTICE: builder.hostname = 'learn', timeout = 0, targets (3)
+[2019/03/30 22:09:09:2932] NOTICE: target.name 'target1' (target 0x543b060)
+[2019/03/30 22:09:09:2933] NOTICE: target.name 'target2' (target 0x543b090)
+[2019/03/30 22:09:09:2933] NOTICE: target.name 'target3' (target 0x543b0c0)
+[2019/03/30 22:09:09:2934] NOTICE: main: .... strarting serialization of test 2
+[2019/03/30 22:09:09:2935] NOTICE: ser says 1
+{"schema":"com-warmcat-sai-builder","hostname":"learn","nspawn_timeout":0,"targets":[{"name":"target1"},{"name":"target2"},{"name":"target3"}]}
+[2019/03/30 22:09:09:2940] NOTICE: main: ++++++++++++++++ test 3
+[2019/03/30 22:09:09:2959] NOTICE: builder.hostname = 'learn', timeout = 1800, targets (2)
+[2019/03/30 22:09:09:2960] NOTICE: target.name 'target1' (target 0x543b450)
+[2019/03/30 22:09:09:2961] NOTICE: child 0x543b480, target.child.somename 'abc'
+[2019/03/30 22:09:09:2961] NOTICE: target.name 'target2' (target 0x543b490)
+[2019/03/30 22:09:09:2962] NOTICE: main: .... strarting serialization of test 3
+[2019/03/30 22:09:09:2969] NOTICE: ser says 1
+{"schema":"com-warmcat-sai-builder","hostname":"learn","nspawn_timeout":1800,"targets":[{"name":"target1","child":{"somename":"abc"}},{"name":"target2"}]}
+[2019/03/30 22:09:09:2970] NOTICE: main: ++++++++++++++++ test 4
+[2019/03/30 22:09:09:2971] NOTICE: builder.hostname = 'learn', timeout = 1800, targets (0)
+[2019/03/30 22:09:09:2971] NOTICE: main: .... strarting serialization of test 4
+[2019/03/30 22:09:09:2973] NOTICE: ser says 1
+{"schema":"com-warmcat-sai-builder","hostname":"learn","nspawn_timeout":1800}
+[2019/03/30 22:09:09:2974] NOTICE: main: ++++++++++++++++ test 5
+[2019/03/30 22:09:09:2978] NOTICE: builder.hostname = '', timeout = 0, targets (0)
+[2019/03/30 22:09:09:2979] NOTICE: main: .... strarting serialization of test 5
+[2019/03/30 22:09:09:2980] NOTICE: ser says 1
+{"schema":"com-warmcat-sai-builder","hostname":"","nspawn_timeout":0}
+[2019/03/30 22:09:09:2982] USER: Completed: PASS
+```
+
diff --git a/minimal-examples/api-tests/api-test-lecp/main.c b/minimal-examples/api-tests/api-test-lecp/main.c
new file mode 100644
index 0000000..1e66541
--- /dev/null
+++ b/minimal-examples/api-tests/api-test-lecp/main.c
@@ -0,0 +1,5019 @@
+/*
+ * lws-api-test-lecp
+ *
+ * Written in 2010-2021 by Andy Green <andy@warmcat.com>
+ *
+ * This file is made available under the Creative Commons CC0 1.0
+ * Universal Public Domain Dedication.
+ *
+ * unit tests for lecp
+ */
+
+#include <libwebsockets.h>
+
+#if defined(LWS_WITH_CBOR_FLOAT)
+#include <math.h>
+#endif
+
+#define VERBOSE
+
+#if defined(VERBOSE)
+static const char * const reason_names[] = {
+ "LECPCB_CONSTRUCTED",
+ "LECPCB_DESTRUCTED",
+ "LECPCB_START",
+ "LECPCB_COMPLETE",
+ "LECPCB_FAILED",
+ "LECPCB_PAIR_NAME",
+ "LECPCB_VAL_TRUE",
+ "LECPCB_VAL_FALSE",
+ "LECPCB_VAL_NULL",
+ "LECPCB_VAL_NUM_INT",
+ "LECPCB_VAL_RESERVED", /* float in lejp */
+ "LECPCB_VAL_STR_START",
+ "LECPCB_VAL_STR_CHUNK",
+ "LECPCB_VAL_STR_END",
+ "LECPCB_ARRAY_START",
+ "LECPCB_ARRAY_END",
+ "LECPCB_OBJECT_START",
+ "LECPCB_OBJECT_END",
+ "LECPCB_TAG_START",
+ "LECPCB_TAG_END",
+ "LECPCB_VAL_NUM_UINT",
+ "LECPCB_VAL_UNDEFINED",
+ "LECPCB_VAL_FLOAT16",
+ "LECPCB_VAL_FLOAT32",
+ "LECPCB_VAL_FLOAT64",
+ "LECPCB_VAL_SIMPLE",
+ "LECPCB_VAL_BLOB_START",
+ "LECPCB_VAL_BLOB_CHUNK",
+ "LECPCB_VAL_BLOB_END",
+ "LECPCB_ARRAY_ITEM_START",
+ "LECPCB_ARRAY_ITEM_END",
+};
+#endif
+
+/*
+ * Based on the official CBOR test vectors from here
+ *
+ * https://github.com/cbor/test-vectors/blob/master/appendix_a.json
+ */
+
+static const uint8_t
+ test1[] = { 0x00 },
+ test2[] = { 0x01 },
+ test3[] = { 0x0a },
+ test4[] = { 0x17 },
+ test5[] = { 0x18, 0x18 },
+ test6[] = { 0x18, 0x19 },
+ test7[] = { 0x18, 0x64 },
+ test8[] = { 0x19, 0x03, 0xe8 },
+ test9[] = { 0x1a, 0x00, 0x0f, 0x42, 0x40 },
+ test10[] = { 0x1b, 0x00, 0x00, 0x00,
+ 0xe8, 0xd4, 0xa5, 0x10, 0x00 },
+ test11[] = { 0x1b, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff },
+ test12[] = { 0xc2, 0x49, 0x01, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00 },
+ test13[] = { 0x3b, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff },
+ test14[] = { 0xc3, 0x49, 0x01, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00 },
+ test15[] = { 0x20 },
+ test16[] = { 0x29 },
+ test17[] = { 0x38, 0x63 },
+ test18[] = { 0x39, 0x03, 0xe7 },
+ test19[] = { 0xf9, 0x00, 0x00 },
+ test20[] = { 0xf9, 0x80, 0x00 },
+ test21[] = { 0xf9, 0x3c, 0x00 },
+ test22[] = { 0xfb, 0x3f, 0xf1, 0x99, 0x99,
+ 0x99, 0x99, 0x99, 0x9a },
+ test23[] = { 0xf9, 0x3e, 0x00 },
+ test24[] = { 0xf9, 0x7b, 0xff },
+ test25[] = { 0xfa, 0x47, 0xc3, 0x50, 0x00 },
+ test26[] = { 0xfa, 0x7f, 0x7f, 0xff, 0xff },
+ test27[] = { 0xfb, 0x7e, 0x37, 0xe4, 0x3c,
+ 0x88, 0x00, 0x75, 0x9c },
+ test28[] = { 0xf9, 0x00, 0x01 },
+ test29[] = { 0xf9, 0x04, 0x00 },
+ test30[] = { 0xf9, 0xc4, 0x00 },
+ test31[] = { 0xfb, 0xc0, 0x10, 0x66, 0x66,
+ 0x66, 0x66, 0x66, 0x66 },
+ test32[] = { 0xf9, 0x7c, 0x00 },
+ test33[] = { 0xf9, 0x7e, 0x00 },
+ test34[] = { 0xf9, 0xfc, 0x00 },
+ test35[] = { 0xfa, 0x7f, 0x80, 0x00, 0x00 },
+ test36[] = { 0xfa, 0x7f, 0xc0, 0x00, 0x00 },
+ test37[] = { 0xfa, 0xff, 0x80, 0x00, 0x00 },
+ test38[] = { 0xfb, 0x7f, 0xf0, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00 },
+ test39[] = { 0xfb, 0x7f, 0xf8, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00 },
+ test40[] = { 0xfb, 0xff, 0xf0, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00 },
+ test41[] = { 0xf4 },
+ test42[] = { 0xf5 },
+ test43[] = { 0xf6 },
+ test44[] = { 0xf7 },
+ test45[] = { 0xf0 },
+ test46[] = { 0xf8, 0x18 },
+ test47[] = { 0xf8, 0xff },
+ test48[] = { 0xc0, 0x74, 0x32, 0x30, 0x31,
+ 0x33, 0x2d, 0x30, 0x33, 0x2d,
+ 0x32, 0x31, 0x54, 0x32, 0x30,
+ 0x3a, 0x30, 0x34, 0x3a, 0x30,
+ 0x30, 0x5a },
+ test49[] = { 0xc1, 0x1a, 0x51, 0x4b, 0x67,
+ 0xb0 },
+ test50[] = { 0xc1, 0xfb, 0x41, 0xd4, 0x52,
+ 0xd9, 0xec, 0x20, 0x00, 0x00 },
+ test51[] = { 0xd7, 0x44, 0x01, 0x02, 0x03,
+ 0x04 },
+ test52[] = { 0xd8, 0x18, 0x45, 0x64, 0x49,
+ 0x45, 0x54, 0x46 },
+ test53[] = { 0xd8, 0x20, 0x76, 0x68, 0x74,
+ 0x74, 0x70, 0x3a, 0x2f, 0x2f,
+ 0x77, 0x77, 0x77, 0x2e, 0x65,
+ 0x78, 0x61, 0x6d, 0x70, 0x6c,
+ 0x65, 0x2e, 0x63, 0x6f, 0x6d },
+ test54[] = { 0x40 },
+ test55[] = { 0x44, 0x01, 0x02, 0x03, 0x04 },
+ test56[] = { 0x60 },
+ test57[] = { 0x61, 0x61 },
+ test58[] = { 0x64, 0x49, 0x45, 0x54, 0x46 },
+ test59[] = { 0x62, 0x22, 0x5c },
+ test60[] = { 0x62, 0xc3, 0xbc },
+ test61[] = { 0x63, 0xe6, 0xb0, 0xb4 },
+ test62[] = { 0x64, 0xf0, 0x90, 0x85, 0x91 },
+ test63[] = { 0x80 },
+ test64[] = { 0x83, 0x01, 0x02, 0x03 },
+ test65[] = { 0x83, 0x01, 0x82, 0x02, 0x03,
+ 0x82, 0x04, 0x05 },
+ test66[] = { 0x98, 0x19, 0x01, 0x02, 0x03,
+ 0x04, 0x05, 0x06, 0x07, 0x08,
+ 0x09, 0x0a, 0x0b, 0x0c, 0x0d,
+ 0x0e, 0x0f, 0x10, 0x11, 0x12,
+ 0x13, 0x14, 0x15, 0x16, 0x17,
+ 0x18, 0x18, 0x18, 0x19 },
+ test67[] = { 0xa0 },
+ test68[] = { 0xa2, 0x01, 0x02, 0x03, 0x04 },
+ test69[] = { 0xa2, 0x61, 0x61, 0x01, 0x61,
+ 0x62, 0x82, 0x02, 0x03 },
+ test70[] = { 0x82, 0x61, 0x61, 0xa1, 0x61,
+ 0x62, 0x61, 0x63 },
+ test71[] = { 0xa5, 0x61, 0x61, 0x61, 0x41,
+ 0x61, 0x62, 0x61, 0x42, 0x61,
+ 0x63, 0x61, 0x43, 0x61, 0x64,
+ 0x61, 0x44, 0x61, 0x65, 0x61,
+ 0x45 },
+ test72[] = { 0x5f, 0x42, 0x01, 0x02, 0x43,
+ 0x03, 0x04, 0x05, 0xff },
+ test73[] = { 0x7f, 0x65, 0x73, 0x74, 0x72,
+ 0x65, 0x61, 0x64, 0x6d, 0x69,
+ 0x6e, 0x67, 0xff },
+ test74[] = { 0x9f, 0xff },
+ test75[] = { 0x9f, 0x01, 0x82, 0x02, 0x03,
+ 0x9f, 0x04, 0x05, 0xff, 0xff },
+ test76[] = { 0x9f, 0x01, 0x82, 0x02, 0x03,
+ 0x82, 0x04, 0x05, 0xff },
+ test77[] = { 0x83, 0x01, 0x82, 0x02, 0x03,
+ 0x9f, 0x04, 0x05, 0xff },
+ test78[] = { 0x83, 0x01, 0x9f, 0x02, 0x03,
+ 0xff, 0x82, 0x04, 0x05 },
+ test79[] = { 0x9f, 0x01, 0x02, 0x03, 0x04,
+ 0x05, 0x06, 0x07, 0x08, 0x09,
+ 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
+ 0x0f, 0x10, 0x11, 0x12, 0x13,
+ 0x14, 0x15, 0x16, 0x17, 0x18,
+ 0x18, 0x18, 0x19, 0xff },
+ test80[] = { 0xbf, 0x61, 0x61, 0x01, 0x61,
+ 0x62, 0x9f, 0x02, 0x03, 0xff,
+ 0xff },
+ test81[] = { 0x82, 0x61, 0x61, 0xbf, 0x61,
+ 0x62, 0x61, 0x63, 0xff },
+ test82[] = { 0xbf, 0x63, 0x46, 0x75, 0x6e,
+ 0xf5, 0x63, 0x41, 0x6d, 0x74,
+ 0x21, 0xff },
+
+ /* some random COSE examples
+ *
+ * COSE hmac-01 test vector
+ */
+
+ test83[] = { 0xD8, 0x61, 0x85, 0x43, 0xA1,
+ 0x01, 0x05, 0xA0, 0x54, 0x54,
+ 0x68, 0x69, 0x73, 0x20, 0x69,
+ 0x73, 0x20, 0x74, 0x68, 0x65,
+ 0x20, 0x63, 0x6F, 0x6E, 0x74,
+ 0x65, 0x6E, 0x74, 0x2E, 0x58,
+ 0x20, 0x2B, 0xDC, 0xC8, 0x9F,
+ 0x05, 0x82, 0x16, 0xB8, 0xA2,
+ 0x08, 0xDD, 0xC6, 0xD8, 0xB5,
+ 0x4A, 0xA9, 0x1F, 0x48, 0xBD,
+ 0x63, 0x48, 0x49, 0x86, 0x56,
+ 0x51, 0x05, 0xC9, 0xAD, 0x5A,
+ 0x66, 0x82, 0xF6, 0x81, 0x83,
+ 0x40, 0xA2, 0x01, 0x25, 0x04,
+ 0x4A, 0x6F, 0x75, 0x72, 0x2D,
+ 0x73, 0x65, 0x63, 0x72, 0x65,
+ 0x74, 0x40 },
+ /*
+ * COSE hmac-02 test vector
+ */
+ test84[] = { 0xD8, 0x61, 0x85, 0x43, 0xA1,
+ 0x01, 0x06, 0xA0, 0x54, 0x54,
+ 0x68, 0x69, 0x73, 0x20, 0x69,
+ 0x73, 0x20, 0x74, 0x68, 0x65,
+ 0x20, 0x63, 0x6F, 0x6E, 0x74,
+ 0x65, 0x6E, 0x74, 0x2E, 0x58,
+ 0x30, 0xB3, 0x09, 0x7F, 0x70,
+ 0x00, 0x9A, 0x11, 0x50, 0x74,
+ 0x09, 0x59, 0x8A, 0x83, 0xE1,
+ 0x5B, 0xBB, 0xBF, 0x19, 0x82,
+ 0xDC, 0xE2, 0x8E, 0x5A, 0xB6,
+ 0xD5, 0xA6, 0xAF, 0xF6, 0x89,
+ 0x7B, 0xD2, 0x4B, 0xB8, 0xB7,
+ 0x47, 0x96, 0x22, 0xC9, 0x40,
+ 0x1B, 0x24, 0x09, 0x0D, 0x45,
+ 0x82, 0x06, 0xD5, 0x87, 0x81,
+ 0x83, 0x40, 0xA2, 0x01, 0x25,
+ 0x04, 0x46, 0x73, 0x65, 0x63,
+ 0x2D, 0x34, 0x38, 0x40 },
+ test85[] = { 0xD8, 0x61, 0x85, 0x43, 0xA1,
+ 0x01, 0x07, 0xA0, 0x54, 0x54,
+ 0x68, 0x69, 0x73, 0x20, 0x69,
+ 0x73, 0x20, 0x74, 0x68, 0x65,
+ 0x20, 0x63, 0x6F, 0x6E, 0x74,
+ 0x65, 0x6E, 0x74, 0x2E, 0x58,
+ 0x40, 0xCD, 0x28, 0xA6, 0xB3,
+ 0xCF, 0xBB, 0xBF, 0x21, 0x48,
+ 0x51, 0xB9, 0x06, 0xE0, 0x50,
+ 0x05, 0x6C, 0xB4, 0x38, 0xA8,
+ 0xB8, 0x89, 0x05, 0xB8, 0xB7,
+ 0x46, 0x19, 0x77, 0x02, 0x27,
+ 0x11, 0xA9, 0xD8, 0xAC, 0x5D,
+ 0xBC, 0x54, 0xE2, 0x9A, 0x56,
+ 0xD9, 0x26, 0x04, 0x6B, 0x40,
+ 0xFC, 0x26, 0x07, 0xC2, 0x5B,
+ 0x34, 0x44, 0x54, 0xAA, 0x5F,
+ 0x68, 0xDE, 0x09, 0xA3, 0xE5,
+ 0x25, 0xD3, 0x86, 0x5A, 0x05,
+ 0x81, 0x83, 0x40, 0xA2, 0x01,
+ 0x25, 0x04, 0x46, 0x73, 0x65,
+ 0x63, 0x2D, 0x36, 0x34, 0x40 },
+ test86[] = { 0xD8, 0x61, 0x85, 0x43, 0xA1,
+ 0x01, 0x05, 0xA0, 0x54, 0x54,
+ 0x68, 0x69, 0x73, 0x20, 0x69,
+ 0x73, 0x20, 0x74, 0x68, 0x65,
+ 0x20, 0x63, 0x6F, 0x6E, 0x74,
+ 0x65, 0x6E, 0x74, 0x2E, 0x58,
+ 0x20, 0x2B, 0xDC, 0xC8, 0x9F,
+ 0x05, 0x82, 0x16, 0xB8, 0xA2,
+ 0x08, 0xDD, 0xC6, 0xD8, 0xB5,
+ 0x4A, 0xA9, 0x1F, 0x48, 0xBD,
+ 0x63, 0x48, 0x49, 0x86, 0x56,
+ 0x51, 0x05, 0xC9, 0xAD, 0x5A,
+ 0x66, 0x82, 0xF7, 0x81, 0x83,
+ 0x40, 0xA2, 0x01, 0x25, 0x04,
+ 0x4A, 0x6F, 0x75, 0x72, 0x2D,
+ 0x73, 0x65, 0x63, 0x72, 0x65,
+ 0x74, 0x40 },
+ test87[] = { 0xD8, 0x61, 0x85, 0x43, 0xA1,
+ 0x01, 0x04, 0xA0, 0x54, 0x54,
+ 0x68, 0x69, 0x73, 0x20, 0x69,
+ 0x73, 0x20, 0x74, 0x68, 0x65,
+ 0x20, 0x63, 0x6F, 0x6E, 0x74,
+ 0x65, 0x6E, 0x74, 0x2E, 0x48,
+ 0x6F, 0x35, 0xCA, 0xB7, 0x79,
+ 0xF7, 0x78, 0x33, 0x81, 0x83,
+ 0x40, 0xA2, 0x01, 0x25, 0x04,
+ 0x4A, 0x6F, 0x75, 0x72, 0x2D,
+ 0x73, 0x65, 0x63, 0x72, 0x65,
+ 0x74, 0x40
+
+ /* COSE HMAX Enc 01 vector */
+
+ }, test88[] = { 0xD1, 0x84, 0x43, 0xA1, 0x01,
+ 0x05, 0xA0, 0x54, 0x54, 0x68,
+ 0x69, 0x73, 0x20, 0x69, 0x73,
+ 0x20, 0x74, 0x68, 0x65, 0x20,
+ 0x63, 0x6F, 0x6E, 0x74, 0x65,
+ 0x6E, 0x74, 0x2E, 0x58, 0x20,
+ 0xA1, 0xA8, 0x48, 0xD3, 0x47,
+ 0x1F, 0x9D, 0x61, 0xEE, 0x49,
+ 0x01, 0x8D, 0x24, 0x4C, 0x82,
+ 0x47, 0x72, 0xF2, 0x23, 0xAD,
+ 0x4F, 0x93, 0x52, 0x93, 0xF1,
+ 0x78, 0x9F, 0xC3, 0xA0, 0x8D,
+ 0x8C, 0x58
+ }, test89[] = { 0xD1, 0x84, 0x43, 0xA1, 0x01,
+ 0x06, 0xA0, 0x54, 0x54, 0x68,
+ 0x69, 0x73, 0x20, 0x69, 0x73,
+ 0x20, 0x74, 0x68, 0x65, 0x20,
+ 0x63, 0x6F, 0x6E, 0x74, 0x65,
+ 0x6E, 0x74, 0x2E, 0x58, 0x30,
+ 0x99, 0x8D, 0x26, 0xC6, 0x45,
+ 0x9A, 0xAE, 0xEC, 0xF4, 0x4E,
+ 0xD2, 0x0C, 0xE0, 0x0C, 0x8C,
+ 0xCE, 0xDF, 0x0A, 0x1F, 0x3D,
+ 0x22, 0xA9, 0x2F, 0xC0, 0x5D,
+ 0xB0, 0x8C, 0x5A, 0xEB, 0x1C,
+ 0xB5, 0x94, 0xCA, 0xAF, 0x5A,
+ 0x5C, 0x5E, 0x2E, 0x9D, 0x01,
+ 0xCC, 0xE7, 0xE7, 0x7A, 0x93,
+ 0xAA, 0x8C, 0x62
+ }, test90[] = { 0xD1, 0x84, 0x43, 0xA1, 0x01,
+ 0x07, 0xA0, 0x54, 0x54, 0x68,
+ 0x69, 0x73, 0x20, 0x69, 0x73,
+ 0x20, 0x74, 0x68, 0x65, 0x20,
+ 0x63, 0x6F, 0x6E, 0x74, 0x65,
+ 0x6E, 0x74, 0x2E, 0x58, 0x40,
+ 0x4A, 0x55, 0x5B, 0xF9, 0x71,
+ 0xF7, 0xC1, 0x89, 0x1D, 0x9D,
+ 0xDF, 0x30, 0x4A, 0x1A, 0x13,
+ 0x2E, 0x2D, 0x6F, 0x81, 0x74,
+ 0x49, 0x47, 0x4D, 0x81, 0x3E,
+ 0x6D, 0x04, 0xD6, 0x59, 0x62,
+ 0xBE, 0xD8, 0xBB, 0xA7, 0x0C,
+ 0x17, 0xE1, 0xF5, 0x30, 0x8F,
+ 0xA3, 0x99, 0x62, 0x95, 0x9A,
+ 0x4B, 0x9B, 0x8D, 0x7D, 0xA8,
+ 0xE6, 0xD8, 0x49, 0xB2, 0x09,
+ 0xDC, 0xD3, 0xE9, 0x8C, 0xC0,
+ 0xF1, 0x1E, 0xDD, 0xF2
+
+ }, test91[] = { 0xD1, 0x84, 0x43, 0xA1, 0x01,
+ 0x05, 0xA0, 0x54, 0x54, 0x68,
+ 0x69, 0x73, 0x20, 0x69, 0x73,
+ 0x20, 0x74, 0x68, 0x65, 0x20,
+ 0x63, 0x6F, 0x6E, 0x74, 0x65,
+ 0x6E, 0x74, 0x2E, 0x58, 0x20,
+ 0xA1, 0xA8, 0x48, 0xD3, 0x47,
+ 0x1F, 0x9D, 0x61, 0xEE, 0x49,
+ 0x01, 0x8D, 0x24, 0x4C, 0x82,
+ 0x47, 0x72, 0xF2, 0x23, 0xAD,
+ 0x4F, 0x93, 0x52, 0x93, 0xF1,
+ 0x78, 0x9F, 0xC3, 0xA0, 0x8D,
+ 0x8C, 0x59
+
+ }, test92[] = { 0xD1, 0x84, 0x43, 0xA1, 0x01,
+ 0x04, 0xA0, 0x54, 0x54, 0x68,
+ 0x69, 0x73, 0x20, 0x69, 0x73,
+ 0x20, 0x74, 0x68, 0x65, 0x20,
+ 0x63, 0x6F, 0x6E, 0x74, 0x65,
+ 0x6E, 0x74, 0x2E, 0x48, 0x11,
+ 0xF9, 0xE3, 0x57, 0x97, 0x5F,
+ 0xB8, 0x49
+
+ /*
+ * COSE countersign encrypt-01
+ */
+
+ }, test93[] = {
+ 0xd0, 0x83, 0x43, 0xa1, 0x01,
+ 0x01, 0xa2, 0x05, 0x4c, 0x02,
+ 0xd1, 0xf7, 0xe6, 0xf2, 0x6c,
+ 0x43, 0xd4, 0x86, 0x8d, 0x87,
+ 0xce, 0x07, 0x83, 0x43, 0xa1,
+ 0x01, 0x27, 0xa1, 0x04, 0x42,
+ 0x31, 0x31, 0x58, 0x40, 0xe1,
+ 0x04, 0x39, 0x15, 0x4c, 0xc7,
+ 0x5c, 0x7a, 0x3a, 0x53, 0x91,
+ 0x49, 0x1f, 0x88, 0x65, 0x1e,
+ 0x02, 0x92, 0xfd, 0x0f, 0xe0,
+ 0xe0, 0x2c, 0xf7, 0x40, 0x54,
+ 0x7e, 0xaf, 0x66, 0x77, 0xb4,
+ 0xa4, 0x04, 0x0b, 0x8e, 0xca,
+ 0x16, 0xdb, 0x59, 0x28, 0x81,
+ 0x26, 0x2f, 0x77, 0xb1, 0x4c,
+ 0x1a, 0x08, 0x6c, 0x02, 0x26,
+ 0x8b, 0x17, 0x17, 0x1c, 0xa1,
+ 0x6b, 0xe4, 0xb8, 0x59, 0x5f,
+ 0x8c, 0x0a, 0x08, 0x58, 0x24,
+ 0x60, 0x97, 0x3a, 0x94, 0xbb,
+ 0x28, 0x98, 0x00, 0x9e, 0xe5,
+ 0x2e, 0xcf, 0xd9, 0xab, 0x1d,
+ 0xd2, 0x58, 0x67, 0x37, 0x4b,
+ 0x16, 0x2e, 0x2c, 0x03, 0x56,
+ 0x8b, 0x41, 0xf5, 0x7c, 0x3c,
+ 0xc1, 0x6f, 0x91, 0x66, 0x25,
+ 0x0a
+ /*
+ * COSE countersign encrypt-02
+ */
+ }, test94[] = {
+ 0xd0, 0x83, 0x43, 0xa1, 0x01,
+ 0x01, 0xa2, 0x05, 0x4c, 0x02,
+ 0xd1, 0xf7, 0xe6, 0xf2, 0x6c,
+ 0x43, 0xd4, 0x86, 0x8d, 0x87,
+ 0xce, 0x07, 0x82, 0x83, 0x43,
+ 0xa1, 0x01, 0x27, 0xa1, 0x04,
+ 0x42, 0x31, 0x31, 0x58, 0x40,
+ 0xe1, 0x04, 0x39, 0x15, 0x4c,
+ 0xc7, 0x5c, 0x7a, 0x3a, 0x53,
+ 0x91, 0x49, 0x1f, 0x88, 0x65,
+ 0x1e, 0x02, 0x92, 0xfd, 0x0f,
+ 0xe0, 0xe0, 0x2c, 0xf7, 0x40,
+ 0x54, 0x7e, 0xaf, 0x66, 0x77,
+ 0xb4, 0xa4, 0x04, 0x0b, 0x8e,
+ 0xca, 0x16, 0xdb, 0x59, 0x28,
+ 0x81, 0x26, 0x2f, 0x77, 0xb1,
+ 0x4c, 0x1a, 0x08, 0x6c, 0x02,
+ 0x26, 0x8b, 0x17, 0x17, 0x1c,
+ 0xa1, 0x6b, 0xe4, 0xb8, 0x59,
+ 0x5f, 0x8c, 0x0a, 0x08, 0x83,
+ 0x43, 0xa1, 0x01, 0x26, 0xa1,
+ 0x04, 0x42, 0x31, 0x31, 0x58,
+ 0x40, 0xfc, 0xa9, 0x8e, 0xca,
+ 0xc8, 0x0b, 0x5f, 0xeb, 0x3a,
+ 0xc7, 0xc1, 0x08, 0xb2, 0xb7,
+ 0x91, 0x10, 0xde, 0x88, 0x86,
+ 0x7b, 0xc0, 0x42, 0x6f, 0xc8,
+ 0x3c, 0x53, 0xcc, 0xd6, 0x78,
+ 0x96, 0x94, 0xed, 0xc5, 0xfe,
+ 0xe3, 0xc4, 0x0d, 0xe8, 0xe7,
+ 0xb4, 0x4f, 0xe8, 0xaa, 0xd3,
+ 0x67, 0xe0, 0x95, 0xc8, 0xfc,
+ 0x31, 0xb7, 0x9e, 0xe6, 0x66,
+ 0xdf, 0x9c, 0xf9, 0x09, 0x06,
+ 0xeb, 0x43, 0x75, 0x6c, 0x73,
+ 0x58, 0x24, 0x60, 0x97, 0x3a,
+ 0x94, 0xbb, 0x28, 0x98, 0x00,
+ 0x9e, 0xe5, 0x2e, 0xcf, 0xd9,
+ 0xab, 0x1d, 0xd2, 0x58, 0x67,
+ 0x37, 0x4b, 0x16, 0x2e, 0x2c,
+ 0x03, 0x56, 0x8b, 0x41, 0xf5,
+ 0x7c, 0x3c, 0xc1, 0x6f, 0x91,
+ 0x66, 0x25, 0x0a
+
+ /*
+ * COSE countersign enveloped-01
+ */
+ }, test95[] = {
+ 0xd8, 0x60, 0x84, 0x43, 0xa1,
+ 0x01, 0x01, 0xa2, 0x05, 0x4c,
+ 0x02, 0xd1, 0xf7, 0xe6, 0xf2,
+ 0x6c, 0x43, 0xd4, 0x86, 0x8d,
+ 0x87, 0xce, 0x07, 0x83, 0x43,
+ 0xa1, 0x01, 0x27, 0xa1, 0x04,
+ 0x42, 0x31, 0x31, 0x58, 0x40,
+ 0x9a, 0x8e, 0xed, 0xe3, 0xb3,
+ 0xcb, 0x83, 0x7b, 0xa0, 0x0d,
+ 0xf0, 0x8f, 0xa2, 0x1b, 0x12,
+ 0x8b, 0x2d, 0x6d, 0x91, 0x62,
+ 0xa4, 0x29, 0x0a, 0x58, 0x2d,
+ 0x9f, 0x19, 0xbd, 0x0f, 0xb5,
+ 0x02, 0xf0, 0xf9, 0x2b, 0x9b,
+ 0xf4, 0x53, 0xa4, 0x05, 0x40,
+ 0x1f, 0x8b, 0x70, 0x55, 0xef,
+ 0x4e, 0x95, 0x8d, 0xf7, 0xf4,
+ 0xfb, 0xd7, 0xcf, 0xb4, 0xa0,
+ 0xc9, 0x71, 0x60, 0xf9, 0x47,
+ 0x2b, 0x0a, 0xa1, 0x04, 0x58,
+ 0x24, 0x60, 0x97, 0x3a, 0x94,
+ 0xbb, 0x28, 0x98, 0x00, 0x9e,
+ 0xe5, 0x2e, 0xcf, 0xd9, 0xab,
+ 0x1d, 0xd2, 0x58, 0x67, 0x37,
+ 0x4b, 0x35, 0x81, 0xf2, 0xc8,
+ 0x00, 0x39, 0x82, 0x63, 0x50,
+ 0xb9, 0x7a, 0xe2, 0x30, 0x0e,
+ 0x42, 0xfc, 0x81, 0x83, 0x40,
+ 0xa2, 0x01, 0x25, 0x04, 0x4a,
+ 0x6f, 0x75, 0x72, 0x2d, 0x73,
+ 0x65, 0x63, 0x72, 0x65, 0x74,
+ 0x40
+ }, test96[] = {
+ 0xd8, 0x60, 0x84, 0x43, 0xa1,
+ 0x01, 0x01, 0xa2, 0x05, 0x4c,
+ 0x02, 0xd1, 0xf7, 0xe6, 0xf2,
+ 0x6c, 0x43, 0xd4, 0x86, 0x8d,
+ 0x87, 0xce, 0x07, 0x82, 0x83,
+ 0x43, 0xa1, 0x01, 0x27, 0xa1,
+ 0x04, 0x42, 0x31, 0x31, 0x58,
+ 0x40, 0x9a, 0x8e, 0xed, 0xe3,
+ 0xb3, 0xcb, 0x83, 0x7b, 0xa0,
+ 0x0d, 0xf0, 0x8f, 0xa2, 0x1b,
+ 0x12, 0x8b, 0x2d, 0x6d, 0x91,
+ 0x62, 0xa4, 0x29, 0x0a, 0x58,
+ 0x2d, 0x9f, 0x19, 0xbd, 0x0f,
+ 0xb5, 0x02, 0xf0, 0xf9, 0x2b,
+ 0x9b, 0xf4, 0x53, 0xa4, 0x05,
+ 0x40, 0x1f, 0x8b, 0x70, 0x55,
+ 0xef, 0x4e, 0x95, 0x8d, 0xf7,
+ 0xf4, 0xfb, 0xd7, 0xcf, 0xb4,
+ 0xa0, 0xc9, 0x71, 0x60, 0xf9,
+ 0x47, 0x2b, 0x0a, 0xa1, 0x04,
+ 0x83, 0x43, 0xa1, 0x01, 0x26,
+ 0xa1, 0x04, 0x42, 0x31, 0x31,
+ 0x58, 0x40, 0x24, 0x27, 0xcb,
+ 0x37, 0x56, 0x85, 0x0f, 0xbb,
+ 0x79, 0x05, 0x18, 0x07, 0xc8,
+ 0xb2, 0x3d, 0x2e, 0x6d, 0x16,
+ 0xa3, 0x22, 0x4f, 0x99, 0x01,
+ 0xb4, 0x73, 0x99, 0xcf, 0xc7,
+ 0xe3, 0xfa, 0xc4, 0xcc, 0x62,
+ 0x1d, 0xbb, 0xeb, 0x02, 0x02,
+ 0xa6, 0xd8, 0xbb, 0x25, 0x69,
+ 0x5c, 0x9d, 0xcc, 0x9c, 0x47,
+ 0x49, 0x20, 0xff, 0x57, 0x60,
+ 0x6d, 0x76, 0x4d, 0xea, 0x19,
+ 0x2f, 0xc8, 0x67, 0x41, 0x16,
+ 0xf2, 0x58, 0x24, 0x60, 0x97,
+ 0x3a, 0x94, 0xbb, 0x28, 0x98,
+ 0x00, 0x9e, 0xe5, 0x2e, 0xcf,
+ 0xd9, 0xab, 0x1d, 0xd2, 0x58,
+ 0x67, 0x37, 0x4b, 0x35, 0x81,
+ 0xf2, 0xc8, 0x00, 0x39, 0x82,
+ 0x63, 0x50, 0xb9, 0x7a, 0xe2,
+ 0x30, 0x0e, 0x42, 0xfc, 0x81,
+ 0x83, 0x40, 0xa2, 0x01, 0x25,
+ 0x04, 0x4a, 0x6f, 0x75, 0x72,
+ 0x2d, 0x73, 0x65, 0x63, 0x72,
+ 0x65, 0x74, 0x40
+
+ }, test97[] = {
+ 0xd8, 0x60, 0x84, 0x43, 0xa1,
+ 0x01, 0x01, 0xa1, 0x05, 0x4c,
+ 0x02, 0xd1, 0xf7, 0xe6, 0xf2,
+ 0x6c, 0x43, 0xd4, 0x86, 0x8d,
+ 0x87, 0xce, 0x58, 0x24, 0x60,
+ 0x97, 0x3a, 0x94, 0xbb, 0x28,
+ 0x98, 0x00, 0x9e, 0xe5, 0x2e,
+ 0xcf, 0xd9, 0xab, 0x1d, 0xd2,
+ 0x58, 0x67, 0x37, 0x4b, 0x35,
+ 0x81, 0xf2, 0xc8, 0x00, 0x39,
+ 0x82, 0x63, 0x50, 0xb9, 0x7a,
+ 0xe2, 0x30, 0x0e, 0x42, 0xfc,
+ 0x81, 0x83, 0x40, 0xa3, 0x01,
+ 0x25, 0x04, 0x4a, 0x6f, 0x75,
+ 0x72, 0x2d, 0x73, 0x65, 0x63,
+ 0x72, 0x65, 0x74, 0x07, 0x83,
+ 0x43, 0xa1, 0x01, 0x27, 0xa1,
+ 0x04, 0x42, 0x31, 0x31, 0x58,
+ 0x40, 0xcc, 0xb1, 0xf3, 0xfe,
+ 0xdf, 0xce, 0xa7, 0x2b, 0x9c,
+ 0x86, 0x79, 0x63, 0xe2, 0x52,
+ 0xb6, 0x65, 0x8a, 0xd0, 0x7f,
+ 0x3f, 0x5f, 0x15, 0xa3, 0x26,
+ 0xa3, 0xf5, 0x72, 0x54, 0xcc,
+ 0xb8, 0xd4, 0x8d, 0x60, 0x02,
+ 0x1d, 0x2f, 0x1f, 0x8a, 0x80,
+ 0x3b, 0x84, 0x4b, 0x78, 0x72,
+ 0x16, 0x6c, 0x6d, 0x45, 0x90,
+ 0x25, 0xd2, 0x1c, 0x8c, 0x84,
+ 0x62, 0xa2, 0x44, 0xba, 0x19,
+ 0x60, 0x4e, 0xc4, 0xd5, 0x0b,
+ 0x40
+ }, test98[] = {
+ 0xd8, 0x61, 0x85, 0x43, 0xa1,
+ 0x01, 0x05, 0xa1, 0x07, 0x83,
+ 0x43, 0xa1, 0x01, 0x27, 0xa1,
+ 0x04, 0x42, 0x31, 0x31, 0x58,
+ 0x40, 0xb4, 0x92, 0x4b, 0x18,
+ 0xeb, 0x4e, 0x04, 0x73, 0x13,
+ 0xc7, 0x07, 0xb0, 0xed, 0xa4,
+ 0xab, 0x84, 0x43, 0x45, 0xf2,
+ 0xc4, 0x49, 0x87, 0xd6, 0xf9,
+ 0xeb, 0xcc, 0x77, 0x7e, 0xfd,
+ 0x40, 0x78, 0xcc, 0x0f, 0x4c,
+ 0x10, 0x8d, 0xef, 0x95, 0x9f,
+ 0x78, 0xf1, 0xed, 0xb2, 0x76,
+ 0x54, 0x25, 0x78, 0x5f, 0xcd,
+ 0x17, 0xd5, 0x12, 0xbe, 0x31,
+ 0xee, 0xb6, 0x6b, 0xef, 0xf1,
+ 0xe8, 0xfc, 0x27, 0x47, 0x07,
+ 0x54, 0x54, 0x68, 0x69, 0x73,
+ 0x20, 0x69, 0x73, 0x20, 0x74,
+ 0x68, 0x65, 0x20, 0x63, 0x6f,
+ 0x6e, 0x74, 0x65, 0x6e, 0x74,
+ 0x2e, 0x58, 0x20, 0x2b, 0xdc,
+ 0xc8, 0x9f, 0x05, 0x82, 0x16,
+ 0xb8, 0xa2, 0x08, 0xdd, 0xc6,
+ 0xd8, 0xb5, 0x4a, 0xa9, 0x1f,
+ 0x48, 0xbd, 0x63, 0x48, 0x49,
+ 0x86, 0x56, 0x51, 0x05, 0xc9,
+ 0xad, 0x5a, 0x66, 0x82, 0xf6,
+ 0x81, 0x83, 0x40, 0xa2, 0x01,
+ 0x25, 0x04, 0x4a, 0x6f, 0x75,
+ 0x72, 0x2d, 0x73, 0x65, 0x63,
+ 0x72, 0x65, 0x74, 0x40
+ }, test99[] = {
+ 0xd8, 0x61, 0x85, 0x43, 0xa1,
+ 0x01, 0x05, 0xa1, 0x07, 0x82,
+ 0x83, 0x43, 0xa1, 0x01, 0x27,
+ 0xa1, 0x04, 0x42, 0x31, 0x31,
+ 0x58, 0x40, 0xb4, 0x92, 0x4b,
+ 0x18, 0xeb, 0x4e, 0x04, 0x73,
+ 0x13, 0xc7, 0x07, 0xb0, 0xed,
+ 0xa4, 0xab, 0x84, 0x43, 0x45,
+ 0xf2, 0xc4, 0x49, 0x87, 0xd6,
+ 0xf9, 0xeb, 0xcc, 0x77, 0x7e,
+ 0xfd, 0x40, 0x78, 0xcc, 0x0f,
+ 0x4c, 0x10, 0x8d, 0xef, 0x95,
+ 0x9f, 0x78, 0xf1, 0xed, 0xb2,
+ 0x76, 0x54, 0x25, 0x78, 0x5f,
+ 0xcd, 0x17, 0xd5, 0x12, 0xbe,
+ 0x31, 0xee, 0xb6, 0x6b, 0xef,
+ 0xf1, 0xe8, 0xfc, 0x27, 0x47,
+ 0x07, 0x83, 0x43, 0xa1, 0x01,
+ 0x26, 0xa1, 0x04, 0x42, 0x31,
+ 0x31, 0x58, 0x40, 0x6a, 0xcd,
+ 0x94, 0xd3, 0xcc, 0xf7, 0x1d,
+ 0x19, 0x2e, 0x85, 0x28, 0x36,
+ 0x0b, 0xa7, 0xe3, 0x46, 0xda,
+ 0xc4, 0x64, 0xe9, 0xed, 0xca,
+ 0x4c, 0xfe, 0xb6, 0xce, 0xb6,
+ 0xbd, 0xe7, 0xba, 0xec, 0x9f,
+ 0xf2, 0x6c, 0xa6, 0xbd, 0xf7,
+ 0x3d, 0x0b, 0xe4, 0x1e, 0x36,
+ 0x12, 0x9d, 0xcf, 0xf7, 0x51,
+ 0xdd, 0x2b, 0x5a, 0xd5, 0xce,
+ 0x11, 0x6e, 0x8a, 0x96, 0x3a,
+ 0x27, 0x38, 0xa2, 0x99, 0x47,
+ 0x7a, 0x68, 0x54, 0x54, 0x68,
+ 0x69, 0x73, 0x20, 0x69, 0x73,
+ 0x20, 0x74, 0x68, 0x65, 0x20,
+ 0x63, 0x6f, 0x6e, 0x74, 0x65,
+ 0x6e, 0x74, 0x2e, 0x58, 0x20,
+ 0x2b, 0xdc, 0xc8, 0x9f, 0x05,
+ 0x82, 0x16, 0xb8, 0xa2, 0x08,
+ 0xdd, 0xc6, 0xd8, 0xb5, 0x4a,
+ 0xa9, 0x1f, 0x48, 0xbd, 0x63,
+ 0x48, 0x49, 0x86, 0x56, 0x51,
+ 0x05, 0xc9, 0xad, 0x5a, 0x66,
+ 0x82, 0xf6, 0x81, 0x83, 0x40,
+ 0xa2, 0x01, 0x25, 0x04, 0x4a,
+ 0x6f, 0x75, 0x72, 0x2d, 0x73,
+ 0x65, 0x63, 0x72, 0x65, 0x74,
+ 0x40
+ }, test100[] = {
+ 0xd1, 0x84, 0x43, 0xa1, 0x01,
+ 0x05, 0xa1, 0x07, 0x83, 0x43,
+ 0xa1, 0x01, 0x27, 0xa1, 0x04,
+ 0x42, 0x31, 0x31, 0x58, 0x40,
+ 0xb4, 0x92, 0x4b, 0x18, 0xeb,
+ 0x4e, 0x04, 0x73, 0x13, 0xc7,
+ 0x07, 0xb0, 0xed, 0xa4, 0xab,
+ 0x84, 0x43, 0x45, 0xf2, 0xc4,
+ 0x49, 0x87, 0xd6, 0xf9, 0xeb,
+ 0xcc, 0x77, 0x7e, 0xfd, 0x40,
+ 0x78, 0xcc, 0x0f, 0x4c, 0x10,
+ 0x8d, 0xef, 0x95, 0x9f, 0x78,
+ 0xf1, 0xed, 0xb2, 0x76, 0x54,
+ 0x25, 0x78, 0x5f, 0xcd, 0x17,
+ 0xd5, 0x12, 0xbe, 0x31, 0xee,
+ 0xb6, 0x6b, 0xef, 0xf1, 0xe8,
+ 0xfc, 0x27, 0x47, 0x07, 0x54,
+ 0x54, 0x68, 0x69, 0x73, 0x20,
+ 0x69, 0x73, 0x20, 0x74, 0x68,
+ 0x65, 0x20, 0x63, 0x6f, 0x6e,
+ 0x74, 0x65, 0x6e, 0x74, 0x2e,
+ 0x58, 0x20, 0xa1, 0xa8, 0x48,
+ 0xd3, 0x47, 0x1f, 0x9d, 0x61,
+ 0xee, 0x49, 0x01, 0x8d, 0x24,
+ 0x4c, 0x82, 0x47, 0x72, 0xf2,
+ 0x23, 0xad, 0x4f, 0x93, 0x52,
+ 0x93, 0xf1, 0x78, 0x9f, 0xc3,
+ 0xa0, 0x8d, 0x8c, 0x58
+ }, test101[] = { /* mac-02 */
+ 0xd8, 0x61, 0x85, 0x43, 0xa1,
+ 0x01, 0x05, 0xa1, 0x07, 0x82,
+ 0x83, 0x43, 0xa1, 0x01, 0x27,
+ 0xa1, 0x04, 0x42, 0x31, 0x31,
+ 0x58, 0x40, 0xb4, 0x92, 0x4b,
+ 0x18, 0xeb, 0x4e, 0x04, 0x73,
+ 0x13, 0xc7, 0x07, 0xb0, 0xed,
+ 0xa4, 0xab, 0x84, 0x43, 0x45,
+ 0xf2, 0xc4, 0x49, 0x87, 0xd6,
+ 0xf9, 0xeb, 0xcc, 0x77, 0x7e,
+ 0xfd, 0x40, 0x78, 0xcc, 0x0f,
+ 0x4c, 0x10, 0x8d, 0xef, 0x95,
+ 0x9f, 0x78, 0xf1, 0xed, 0xb2,
+ 0x76, 0x54, 0x25, 0x78, 0x5f,
+ 0xcd, 0x17, 0xd5, 0x12, 0xbe,
+ 0x31, 0xee, 0xb6, 0x6b, 0xef,
+ 0xf1, 0xe8, 0xfc, 0x27, 0x47,
+ 0x07, 0x83, 0x43, 0xa1, 0x01,
+ 0x26, 0xa1, 0x04, 0x42, 0x31,
+ 0x31, 0x58, 0x40, 0x6a, 0xcd,
+ 0x94, 0xd3, 0xcc, 0xf7, 0x1d,
+ 0x19, 0x2e, 0x85, 0x28, 0x36,
+ 0x0b, 0xa7, 0xe3, 0x46, 0xda,
+ 0xc4, 0x64, 0xe9, 0xed, 0xca,
+ 0x4c, 0xfe, 0xb6, 0xce, 0xb6,
+ 0xbd, 0xe7, 0xba, 0xec, 0x9f,
+ 0xf2, 0x6c, 0xa6, 0xbd, 0xf7,
+ 0x3d, 0x0b, 0xe4, 0x1e, 0x36,
+ 0x12, 0x9d, 0xcf, 0xf7, 0x51,
+ 0xdd, 0x2b, 0x5a, 0xd5, 0xce,
+ 0x11, 0x6e, 0x8a, 0x96, 0x3a,
+ 0x27, 0x38, 0xa2, 0x99, 0x47,
+ 0x7a, 0x68, 0x54, 0x54, 0x68,
+ 0x69, 0x73, 0x20, 0x69, 0x73,
+ 0x20, 0x74, 0x68, 0x65, 0x20,
+ 0x63, 0x6f, 0x6e, 0x74, 0x65,
+ 0x6e, 0x74, 0x2e, 0x58, 0x20,
+ 0x2b, 0xdc, 0xc8, 0x9f, 0x05,
+ 0x82, 0x16, 0xb8, 0xa2, 0x08,
+ 0xdd, 0xc6, 0xd8, 0xb5, 0x4a,
+ 0xa9, 0x1f, 0x48, 0xbd, 0x63,
+ 0x48, 0x49, 0x86, 0x56, 0x51,
+ 0x05, 0xc9, 0xad, 0x5a, 0x66,
+ 0x82, 0xf6, 0x81, 0x83, 0x40,
+ 0xa2, 0x01, 0x25, 0x04, 0x4a,
+ 0x6f, 0x75, 0x72, 0x2d, 0x73,
+ 0x65, 0x63, 0x72, 0x65, 0x74,
+ 0x40
+ }, test102[] = { /* mac0-01 */
+ 0xd1, 0x84, 0x43, 0xa1, 0x01,
+ 0x05, 0xa1, 0x07, 0x83, 0x43,
+ 0xa1, 0x01, 0x27, 0xa1, 0x04,
+ 0x42, 0x31, 0x31, 0x58, 0x40,
+ 0xb4, 0x92, 0x4b, 0x18, 0xeb,
+ 0x4e, 0x04, 0x73, 0x13, 0xc7,
+ 0x07, 0xb0, 0xed, 0xa4, 0xab,
+ 0x84, 0x43, 0x45, 0xf2, 0xc4,
+ 0x49, 0x87, 0xd6, 0xf9, 0xeb,
+ 0xcc, 0x77, 0x7e, 0xfd, 0x40,
+ 0x78, 0xcc, 0x0f, 0x4c, 0x10,
+ 0x8d, 0xef, 0x95, 0x9f, 0x78,
+ 0xf1, 0xed, 0xb2, 0x76, 0x54,
+ 0x25, 0x78, 0x5f, 0xcd, 0x17,
+ 0xd5, 0x12, 0xbe, 0x31, 0xee,
+ 0xb6, 0x6b, 0xef, 0xf1, 0xe8,
+ 0xfc, 0x27, 0x47, 0x07, 0x54,
+ 0x54, 0x68, 0x69, 0x73, 0x20,
+ 0x69, 0x73, 0x20, 0x74, 0x68,
+ 0x65, 0x20, 0x63, 0x6f, 0x6e,
+ 0x74, 0x65, 0x6e, 0x74, 0x2e,
+ 0x58, 0x20, 0xa1, 0xa8, 0x48,
+ 0xd3, 0x47, 0x1f, 0x9d, 0x61,
+ 0xee, 0x49, 0x01, 0x8d, 0x24,
+ 0x4c, 0x82, 0x47, 0x72, 0xf2,
+ 0x23, 0xad, 0x4f, 0x93, 0x52,
+ 0x93, 0xf1, 0x78, 0x9f, 0xc3,
+ 0xa0, 0x8d, 0x8c, 0x58
+ }, test103[] = { /* mac0-02 */
+ 0xd1, 0x84, 0x43, 0xa1, 0x01,
+ 0x05, 0xa1, 0x07, 0x82, 0x83,
+ 0x43, 0xa1, 0x01, 0x27, 0xa1,
+ 0x04, 0x42, 0x31, 0x31, 0x58,
+ 0x40, 0xb4, 0x92, 0x4b, 0x18,
+ 0xeb, 0x4e, 0x04, 0x73, 0x13,
+ 0xc7, 0x07, 0xb0, 0xed, 0xa4,
+ 0xab, 0x84, 0x43, 0x45, 0xf2,
+ 0xc4, 0x49, 0x87, 0xd6, 0xf9,
+ 0xeb, 0xcc, 0x77, 0x7e, 0xfd,
+ 0x40, 0x78, 0xcc, 0x0f, 0x4c,
+ 0x10, 0x8d, 0xef, 0x95, 0x9f,
+ 0x78, 0xf1, 0xed, 0xb2, 0x76,
+ 0x54, 0x25, 0x78, 0x5f, 0xcd,
+ 0x17, 0xd5, 0x12, 0xbe, 0x31,
+ 0xee, 0xb6, 0x6b, 0xef, 0xf1,
+ 0xe8, 0xfc, 0x27, 0x47, 0x07,
+ 0x83, 0x43, 0xa1, 0x01, 0x26,
+ 0xa1, 0x04, 0x42, 0x31, 0x31,
+ 0x58, 0x40, 0x6a, 0xcd, 0x94,
+ 0xd3, 0xcc, 0xf7, 0x1d, 0x19,
+ 0x2e, 0x85, 0x28, 0x36, 0x0b,
+ 0xa7, 0xe3, 0x46, 0xda, 0xc4,
+ 0x64, 0xe9, 0xed, 0xca, 0x4c,
+ 0xfe, 0xb6, 0xce, 0xb6, 0xbd,
+ 0xe7, 0xba, 0xec, 0x9f, 0xf2,
+ 0x6c, 0xa6, 0xbd, 0xf7, 0x3d,
+ 0x0b, 0xe4, 0x1e, 0x36, 0x12,
+ 0x9d, 0xcf, 0xf7, 0x51, 0xdd,
+ 0x2b, 0x5a, 0xd5, 0xce, 0x11,
+ 0x6e, 0x8a, 0x96, 0x3a, 0x27,
+ 0x38, 0xa2, 0x99, 0x47, 0x7a,
+ 0x68, 0x54, 0x54, 0x68, 0x69,
+ 0x73, 0x20, 0x69, 0x73, 0x20,
+ 0x74, 0x68, 0x65, 0x20, 0x63,
+ 0x6f, 0x6e, 0x74, 0x65, 0x6e,
+ 0x74, 0x2e, 0x58, 0x20, 0xa1,
+ 0xa8, 0x48, 0xd3, 0x47, 0x1f,
+ 0x9d, 0x61, 0xee, 0x49, 0x01,
+ 0x8d, 0x24, 0x4c, 0x82, 0x47,
+ 0x72, 0xf2, 0x23, 0xad, 0x4f,
+ 0x93, 0x52, 0x93, 0xf1, 0x78,
+ 0x9f, 0xc3, 0xa0, 0x8d, 0x8c,
+ 0x58
+ }, test104[] = { /* signed-01 */
+ 0xd8, 0x62, 0x84, 0x43, 0xa1,
+ 0x03, 0x00, 0xa0, 0x54, 0x54,
+ 0x68, 0x69, 0x73, 0x20, 0x69,
+ 0x73, 0x20, 0x74, 0x68, 0x65,
+ 0x20, 0x63, 0x6f, 0x6e, 0x74,
+ 0x65, 0x6e, 0x74, 0x2e, 0x81,
+ 0x83, 0x43, 0xa1, 0x01, 0x27,
+ 0xa2, 0x07, 0x83, 0x43, 0xa1,
+ 0x01, 0x27, 0xa1, 0x04, 0x42,
+ 0x31, 0x31, 0x58, 0x40, 0x8e,
+ 0x1b, 0xe2, 0xf9, 0x45, 0x3d,
+ 0x26, 0x48, 0x12, 0xe5, 0x90,
+ 0x49, 0x91, 0x32, 0xbe, 0xf3,
+ 0xfb, 0xf9, 0xee, 0x9d, 0xb2,
+ 0x7c, 0x2c, 0x16, 0x87, 0x88,
+ 0xe3, 0xb7, 0xeb, 0xe5, 0x06,
+ 0xc0, 0x4f, 0xd3, 0xd1, 0x9f,
+ 0xaa, 0x9f, 0x51, 0x23, 0x2a,
+ 0xf5, 0xc9, 0x59, 0xe4, 0xef,
+ 0x47, 0x92, 0x88, 0x34, 0x64,
+ 0x7f, 0x56, 0xdf, 0xbe, 0x93,
+ 0x91, 0x12, 0x88, 0x4d, 0x08,
+ 0xef, 0x25, 0x05, 0x04, 0x42,
+ 0x31, 0x31, 0x58, 0x40, 0x77,
+ 0xf3, 0xea, 0xcd, 0x11, 0x85,
+ 0x2c, 0x4b, 0xf9, 0xcb, 0x1d,
+ 0x72, 0xfa, 0xbe, 0x6b, 0x26,
+ 0xfb, 0xa1, 0xd7, 0x60, 0x92,
+ 0xb2, 0xb5, 0xb7, 0xec, 0x83,
+ 0xb8, 0x35, 0x57, 0x65, 0x22,
+ 0x64, 0xe6, 0x96, 0x90, 0xdb,
+ 0xc1, 0x17, 0x2d, 0xdc, 0x0b,
+ 0xf8, 0x84, 0x11, 0xc0, 0xd2,
+ 0x5a, 0x50, 0x7f, 0xdb, 0x24,
+ 0x7a, 0x20, 0xc4, 0x0d, 0x5e,
+ 0x24, 0x5f, 0xab, 0xd3, 0xfc,
+ 0x9e, 0xc1, 0x06
+ }, test105[] = { /* signed-02 */
+ 0xd8, 0x62, 0x84, 0x43, 0xa1,
+ 0x03, 0x00, 0xa0, 0x54, 0x54,
+ 0x68, 0x69, 0x73, 0x20, 0x69,
+ 0x73, 0x20, 0x74, 0x68, 0x65,
+ 0x20, 0x63, 0x6f, 0x6e, 0x74,
+ 0x65, 0x6e, 0x74, 0x2e, 0x81,
+ 0x83, 0x43, 0xa1, 0x01, 0x27,
+ 0xa2, 0x07, 0x82, 0x83, 0x43,
+ 0xa1, 0x01, 0x27, 0xa1, 0x04,
+ 0x42, 0x31, 0x31, 0x58, 0x40,
+ 0x8e, 0x1b, 0xe2, 0xf9, 0x45,
+ 0x3d, 0x26, 0x48, 0x12, 0xe5,
+ 0x90, 0x49, 0x91, 0x32, 0xbe,
+ 0xf3, 0xfb, 0xf9, 0xee, 0x9d,
+ 0xb2, 0x7c, 0x2c, 0x16, 0x87,
+ 0x88, 0xe3, 0xb7, 0xeb, 0xe5,
+ 0x06, 0xc0, 0x4f, 0xd3, 0xd1,
+ 0x9f, 0xaa, 0x9f, 0x51, 0x23,
+ 0x2a, 0xf5, 0xc9, 0x59, 0xe4,
+ 0xef, 0x47, 0x92, 0x88, 0x34,
+ 0x64, 0x7f, 0x56, 0xdf, 0xbe,
+ 0x93, 0x91, 0x12, 0x88, 0x4d,
+ 0x08, 0xef, 0x25, 0x05, 0x83,
+ 0x43, 0xa1, 0x01, 0x26, 0xa1,
+ 0x04, 0x42, 0x31, 0x31, 0x58,
+ 0x40, 0xaf, 0x04, 0x9b, 0x80,
+ 0xd5, 0x2c, 0x36, 0x69, 0xb2,
+ 0x99, 0x70, 0xc1, 0x33, 0x54,
+ 0x37, 0x54, 0xf9, 0xcc, 0x60,
+ 0x8c, 0xe4, 0x11, 0x23, 0xae,
+ 0x1c, 0x82, 0x7e, 0x36, 0xb3,
+ 0x8c, 0xb8, 0x25, 0x98, 0x7f,
+ 0x01, 0xf2, 0x2b, 0xb8, 0xab,
+ 0x13, 0xe9, 0xc6, 0x62, 0x26,
+ 0xee, 0x23, 0x17, 0x8f, 0xfa,
+ 0x00, 0xa4, 0xfc, 0x22, 0x05,
+ 0x93, 0xb6, 0xe5, 0xac, 0x38,
+ 0x96, 0x00, 0x71, 0xc9, 0xc8,
+ 0x04, 0x42, 0x31, 0x31, 0x58,
+ 0x40, 0x77, 0xf3, 0xea, 0xcd,
+ 0x11, 0x85, 0x2c, 0x4b, 0xf9,
+ 0xcb, 0x1d, 0x72, 0xfa, 0xbe,
+ 0x6b, 0x26, 0xfb, 0xa1, 0xd7,
+ 0x60, 0x92, 0xb2, 0xb5, 0xb7,
+ 0xec, 0x83, 0xb8, 0x35, 0x57,
+ 0x65, 0x22, 0x64, 0xe6, 0x96,
+ 0x90, 0xdb, 0xc1, 0x17, 0x2d,
+ 0xdc, 0x0b, 0xf8, 0x84, 0x11,
+ 0xc0, 0xd2, 0x5a, 0x50, 0x7f,
+ 0xdb, 0x24, 0x7a, 0x20, 0xc4,
+ 0x0d, 0x5e, 0x24, 0x5f, 0xab,
+ 0xd3, 0xfc, 0x9e, 0xc1, 0x06
+ }, test106[] = { /* signed-03 */
+ 0xd8, 0x62, 0x84, 0x43, 0xa1,
+ 0x03, 0x00, 0xa1, 0x07, 0x83,
+ 0x43, 0xa1, 0x01, 0x27, 0xa1,
+ 0x04, 0x42, 0x31, 0x31, 0x58,
+ 0x40, 0xb7, 0xca, 0xcb, 0xa2,
+ 0x85, 0xc4, 0xcd, 0x3e, 0xd2,
+ 0xf0, 0x14, 0x6f, 0x41, 0x98,
+ 0x86, 0x14, 0x4c, 0xa6, 0x38,
+ 0xd0, 0x87, 0xde, 0x12, 0x3d,
+ 0x40, 0x01, 0x67, 0x30, 0x8a,
+ 0xce, 0xab, 0xc4, 0xb5, 0xe5,
+ 0xc6, 0xa4, 0x0c, 0x0d, 0xe0,
+ 0xb7, 0x11, 0x67, 0xa3, 0x91,
+ 0x75, 0xea, 0x56, 0xc1, 0xfe,
+ 0x96, 0xc8, 0x9e, 0x5e, 0x7d,
+ 0x30, 0xda, 0xf2, 0x43, 0x8a,
+ 0x45, 0x61, 0x59, 0xa2, 0x0a,
+ 0x54, 0x54, 0x68, 0x69, 0x73,
+ 0x20, 0x69, 0x73, 0x20, 0x74,
+ 0x68, 0x65, 0x20, 0x63, 0x6f,
+ 0x6e, 0x74, 0x65, 0x6e, 0x74,
+ 0x2e, 0x81, 0x83, 0x43, 0xa1,
+ 0x01, 0x27, 0xa1, 0x04, 0x42,
+ 0x31, 0x31, 0x58, 0x40, 0x77,
+ 0xf3, 0xea, 0xcd, 0x11, 0x85,
+ 0x2c, 0x4b, 0xf9, 0xcb, 0x1d,
+ 0x72, 0xfa, 0xbe, 0x6b, 0x26,
+ 0xfb, 0xa1, 0xd7, 0x60, 0x92,
+ 0xb2, 0xb5, 0xb7, 0xec, 0x83,
+ 0xb8, 0x35, 0x57, 0x65, 0x22,
+ 0x64, 0xe6, 0x96, 0x90, 0xdb,
+ 0xc1, 0x17, 0x2d, 0xdc, 0x0b,
+ 0xf8, 0x84, 0x11, 0xc0, 0xd2,
+ 0x5a, 0x50, 0x7f, 0xdb, 0x24,
+ 0x7a, 0x20, 0xc4, 0x0d, 0x5e,
+ 0x24, 0x5f, 0xab, 0xd3, 0xfc,
+ 0x9e, 0xc1, 0x06
+ }, test107[] = { /* signed1-01 */
+ 0xd2, 0x84, 0x45, 0xa2, 0x01,
+ 0x27, 0x03, 0x00, 0xa2, 0x07,
+ 0x83, 0x43, 0xa1, 0x01, 0x27,
+ 0xa1, 0x04, 0x42, 0x31, 0x31,
+ 0x58, 0x40, 0x6d, 0xae, 0xd1,
+ 0x58, 0xaf, 0xe4, 0x03, 0x2e,
+ 0x8d, 0xd4, 0x77, 0xd3, 0xd2,
+ 0xb7, 0xf6, 0x67, 0xe7, 0x95,
+ 0x7a, 0xa8, 0x30, 0x2b, 0xb5,
+ 0xe5, 0x68, 0xb4, 0xdc, 0xbc,
+ 0xce, 0x3c, 0xf0, 0xed, 0x5a,
+ 0x90, 0xf8, 0x31, 0x35, 0x1c,
+ 0x85, 0xd6, 0x15, 0x5a, 0x42,
+ 0xa1, 0x7c, 0xa1, 0xf2, 0x5f,
+ 0x50, 0x1c, 0xc1, 0x3f, 0x67,
+ 0x10, 0x8a, 0xe5, 0x3b, 0xda,
+ 0x92, 0xdb, 0x88, 0x27, 0x2e,
+ 0x00, 0x04, 0x42, 0x31, 0x31,
+ 0x54, 0x54, 0x68, 0x69, 0x73,
+ 0x20, 0x69, 0x73, 0x20, 0x74,
+ 0x68, 0x65, 0x20, 0x63, 0x6f,
+ 0x6e, 0x74, 0x65, 0x6e, 0x74,
+ 0x2e, 0x58, 0x40, 0x71, 0x42,
+ 0xfd, 0x2f, 0xf9, 0x6d, 0x56,
+ 0xdb, 0x85, 0xbe, 0xe9, 0x05,
+ 0xa7, 0x6b, 0xa1, 0xd0, 0xb7,
+ 0x32, 0x1a, 0x95, 0xc8, 0xc4,
+ 0xd3, 0x60, 0x7c, 0x57, 0x81,
+ 0x93, 0x2b, 0x7a, 0xfb, 0x87,
+ 0x11, 0x49, 0x7d, 0xfa, 0x75,
+ 0x1b, 0xf4, 0x0b, 0x58, 0xb3,
+ 0xbc, 0xc3, 0x23, 0x00, 0xb1,
+ 0x48, 0x7f, 0x3d, 0xb3, 0x40,
+ 0x85, 0xee, 0xf0, 0x13, 0xbf,
+ 0x08, 0xf4, 0xa4, 0x4d, 0x6f,
+ 0xef, 0x0d
+ }, test108[] = { /* signed1-02 */
+ 0xd2, 0x84, 0x45, 0xa2, 0x01,
+ 0x27, 0x03, 0x00, 0xa2, 0x07,
+ 0x82, 0x83, 0x43, 0xa1, 0x01,
+ 0x27, 0xa1, 0x04, 0x42, 0x31,
+ 0x31, 0x58, 0x40, 0x6d, 0xae,
+ 0xd1, 0x58, 0xaf, 0xe4, 0x03,
+ 0x2e, 0x8d, 0xd4, 0x77, 0xd3,
+ 0xd2, 0xb7, 0xf6, 0x67, 0xe7,
+ 0x95, 0x7a, 0xa8, 0x30, 0x2b,
+ 0xb5, 0xe5, 0x68, 0xb4, 0xdc,
+ 0xbc, 0xce, 0x3c, 0xf0, 0xed,
+ 0x5a, 0x90, 0xf8, 0x31, 0x35,
+ 0x1c, 0x85, 0xd6, 0x15, 0x5a,
+ 0x42, 0xa1, 0x7c, 0xa1, 0xf2,
+ 0x5f, 0x50, 0x1c, 0xc1, 0x3f,
+ 0x67, 0x10, 0x8a, 0xe5, 0x3b,
+ 0xda, 0x92, 0xdb, 0x88, 0x27,
+ 0x2e, 0x00, 0x83, 0x43, 0xa1,
+ 0x01, 0x26, 0xa1, 0x04, 0x42,
+ 0x31, 0x31, 0x58, 0x40, 0x93,
+ 0x48, 0x7d, 0x09, 0x25, 0x6a,
+ 0x3e, 0xf4, 0x96, 0x37, 0x19,
+ 0xba, 0x5c, 0xf1, 0x01, 0xac,
+ 0xe2, 0xfc, 0x13, 0xd6, 0x31,
+ 0x4b, 0x49, 0x58, 0x21, 0x71,
+ 0xff, 0xa4, 0xa1, 0x31, 0x4d,
+ 0xc9, 0x3e, 0x4a, 0x4a, 0xdf,
+ 0xa4, 0x2a, 0x79, 0xe3, 0x1b,
+ 0x35, 0xd7, 0x30, 0x43, 0x58,
+ 0x58, 0x5b, 0x41, 0x79, 0x96,
+ 0x78, 0xce, 0x00, 0xca, 0x47,
+ 0xc3, 0xe0, 0x23, 0x86, 0x39,
+ 0x23, 0xf8, 0xc8, 0x04, 0x42,
+ 0x31, 0x31, 0x54, 0x54, 0x68,
+ 0x69, 0x73, 0x20, 0x69, 0x73,
+ 0x20, 0x74, 0x68, 0x65, 0x20,
+ 0x63, 0x6f, 0x6e, 0x74, 0x65,
+ 0x6e, 0x74, 0x2e, 0x58, 0x40,
+ 0x71, 0x42, 0xfd, 0x2f, 0xf9,
+ 0x6d, 0x56, 0xdb, 0x85, 0xbe,
+ 0xe9, 0x05, 0xa7, 0x6b, 0xa1,
+ 0xd0, 0xb7, 0x32, 0x1a, 0x95,
+ 0xc8, 0xc4, 0xd3, 0x60, 0x7c,
+ 0x57, 0x81, 0x93, 0x2b, 0x7a,
+ 0xfb, 0x87, 0x11, 0x49, 0x7d,
+ 0xfa, 0x75, 0x1b, 0xf4, 0x0b,
+ 0x58, 0xb3, 0xbc, 0xc3, 0x23,
+ 0x00, 0xb1, 0x48, 0x7f, 0x3d,
+ 0xb3, 0x40, 0x85, 0xee, 0xf0,
+ 0x13, 0xbf, 0x08, 0xf4, 0xa4,
+ 0x4d, 0x6f, 0xef, 0x0d
+ };
+;
+
+struct seq {
+ char reason;
+ struct lecp_item item;
+ const uint8_t *buf;
+ size_t buf_len;
+};
+
+static const uint8_t bm12[] = {
+ 0x01, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x00
+}, bm48[] = {
+ 0x32, 0x30, 0x31, 0x33,
+ 0x2D, 0x30, 0x33, 0x2D,
+ 0x32, 0x31, 0x54, 0x32,
+ 0x30, 0x3A, 0x30, 0x34,
+ 0x3A, 0x30, 0x30, 0x5A
+}, bm51[] = {
+ 0x01, 0x02, 0x03, 0x04
+}, bm52[] = {
+ 0x64, 0x49, 0x45, 0x54,
+ 0x46
+}, bm53[] = {
+ 0x68, 0x74, 0x74, 0x70,
+ 0x3A, 0x2F, 0x2F, 0x77,
+ 0x77, 0x77, 0x2E, 0x65,
+ 0x78, 0x61, 0x6D, 0x70,
+ 0x6C, 0x65, 0x2E, 0x63,
+ 0x6F, 0x6D
+}, bm57[] = {
+ 0x61
+}, bm58[] = {
+ 0x49, 0x45, 0x54, 0x46
+}, bm59[] = {
+ 0x22, 0x5C
+}, bm60[] = {
+ 0xc3, 0xbc
+}, bm61[] = {
+ 0xe6, 0xb0, 0xb4
+}, bm62[] = {
+ 0xF0, 0x90, 0x85, 0x91
+}, bm72a[] = {
+ 0x01, 0x02
+}, bm72b[] = {
+ 0x03, 0x04, 0x05
+}, bm83a[] = {
+ 0xa1, 0x01, 0x05
+}, bm83b[] = {
+ 0x54, 0x68, 0x69, 0x73,
+ 0x20, 0x69, 0x73, 0x20,
+ 0x74, 0x68, 0x65, 0x20,
+ 0x63, 0x6F, 0x6E, 0x74,
+ 0x65, 0x6E, 0x74, 0x2E
+}, bm83c[] = {
+ 0x2B, 0xDC, 0xC8, 0x9F,
+ 0x05, 0x82, 0x16, 0xB8,
+ 0xA2, 0x08, 0xDD, 0xC6,
+ 0xD8, 0xB5, 0x4A, 0xA9,
+ 0x1F, 0x48, 0xBD, 0x63,
+ 0x48, 0x49, 0x86, 0x56,
+ 0x51, 0x05, 0xC9, 0xAD,
+ 0x5A, 0x66, 0x82, 0xF6
+}, bm83d[] = {
+ 0x6F, 0x75, 0x72, 0x2D,
+ 0x73, 0x65, 0x63, 0x72,
+ 0x65, 0x74
+}, bm84a[] = {
+ 0xa1, 0x01, 0x06
+}, bm84b[] = {
+ 0x54, 0x68, 0x69, 0x73,
+ 0x20, 0x69, 0x73, 0x20,
+ 0x74, 0x68, 0x65, 0x20,
+ 0x63, 0x6F, 0x6E, 0x74,
+ 0x65, 0x6E, 0x74, 0x2E
+}, bm84c[] = {
+ 0xB3, 0x09, 0x7F, 0x70,
+ 0x00, 0x9A, 0x11, 0x50,
+ 0x74, 0x09, 0x59, 0x8A,
+ 0x83, 0xE1, 0x5B, 0xBB,
+ 0xBF, 0x19, 0x82, 0xDC,
+ 0xE2, 0x8E, 0x5A, 0xB6,
+ 0xD5, 0xA6, 0xAF, 0xF6,
+ 0x89, 0x7B, 0xD2, 0x4B,
+ 0xB8, 0xB7, 0x47, 0x96,
+ 0x22, 0xC9, 0x40, 0x1B,
+ 0x24, 0x09, 0x0D, 0x45,
+ 0x82, 0x06, 0xD5, 0x87
+}, bm84d[] = {
+ 0x73, 0x65, 0x63, 0x2D,
+ 0x34, 0x38
+}, bm85a[] = {
+ 0xa1, 0x01, 0x07
+}, bm85b[] = {
+ 0x54, 0x68, 0x69, 0x73,
+ 0x20, 0x69, 0x73, 0x20,
+ 0x74, 0x68, 0x65, 0x20,
+ 0x63, 0x6F, 0x6E, 0x74,
+ 0x65, 0x6E, 0x74, 0x2E
+}, bm85c[] = {
+ 0xCD, 0x28, 0xA6, 0xB3,
+ 0xCF, 0xBB, 0xBF, 0x21,
+ 0x48, 0x51, 0xB9, 0x06,
+ 0xE0, 0x50, 0x05, 0x6C,
+ 0xB4, 0x38, 0xA8, 0xB8,
+ 0x89, 0x05, 0xB8, 0xB7,
+ 0x46, 0x19, 0x77, 0x02,
+ 0x27, 0x11, 0xA9, 0xD8,
+ 0xAC, 0x5D, 0xBC, 0x54,
+ 0xE2, 0x9A, 0x56, 0xD9,
+ 0x26, 0x04, 0x6B, 0x40,
+ 0xFC, 0x26, 0x07, 0xC2,
+ 0x5B, 0x34, 0x44, 0x54,
+ 0xAA, 0x5F, 0x68, 0xDE,
+ 0x09, 0xA3, 0xE5, 0x25,
+ 0xD3, 0x86, 0x5A, 0x05
+}, bm85d[] = {
+ 0x73, 0x65, 0x63, 0x2D,
+ 0x36, 0x34
+}, bm86a[] = {
+ 0xa1, 0x01, 0x05
+}, bm86b[] = {
+ 0x54, 0x68, 0x69, 0x73,
+ 0x20, 0x69, 0x73, 0x20,
+ 0x74, 0x68, 0x65, 0x20,
+ 0x63, 0x6F, 0x6E, 0x74,
+ 0x65, 0x6E, 0x74, 0x2E
+}, bm86c[] = {
+ 0x2B, 0xDC, 0xC8, 0x9F,
+ 0x05, 0x82, 0x16, 0xB8,
+ 0xA2, 0x08, 0xDD, 0xC6,
+ 0xD8, 0xB5, 0x4A, 0xA9,
+ 0x1F, 0x48, 0xBD, 0x63,
+ 0x48, 0x49, 0x86, 0x56,
+ 0x51, 0x05, 0xC9, 0xAD,
+ 0x5A, 0x66, 0x82, 0xF7
+}, bm86d[] = {
+ 0x6F, 0x75, 0x72, 0x2D,
+ 0x73, 0x65, 0x63, 0x72,
+ 0x65, 0x74
+}, bm87a[] = {
+ 0xa1, 0x01, 0x04
+}, bm87b[] = {
+ 0x54, 0x68, 0x69, 0x73,
+ 0x20, 0x69, 0x73, 0x20,
+ 0x74, 0x68, 0x65, 0x20,
+ 0x63, 0x6F, 0x6E, 0x74,
+ 0x65, 0x6E, 0x74, 0x2E
+}, bm87c[] = {
+ 0x6F, 0x35, 0xCA, 0xB7,
+ 0x79, 0xF7, 0x78, 0x33
+}, bm87d[] = {
+ 0x6F, 0x75, 0x72, 0x2D,
+ 0x73, 0x65, 0x63, 0x72,
+ 0x65, 0x74
+}, bm88a[] = {
+ 0xa1, 0x01, 0x05
+}, bm88b[] = {
+ 0x54, 0x68, 0x69, 0x73,
+ 0x20, 0x69, 0x73, 0x20,
+ 0x74, 0x68, 0x65, 0x20,
+ 0x63, 0x6F, 0x6E, 0x74,
+ 0x65, 0x6E, 0x74, 0x2E
+}, bm88c[] = {
+ 0xA1, 0xA8, 0x48, 0xD3,
+ 0x47, 0x1F, 0x9D, 0x61,
+ 0xEE, 0x49, 0x01, 0x8D,
+ 0x24, 0x4C, 0x82, 0x47,
+ 0x72, 0xF2, 0x23, 0xAD,
+ 0x4F, 0x93, 0x52, 0x93,
+ 0xF1, 0x78, 0x9F, 0xC3,
+ 0xA0, 0x8D, 0x8C, 0x58
+}, bm89a[] = {
+ 0xa1, 0x01, 0x06
+}, bm89b[] = {
+ 0x54, 0x68, 0x69, 0x73,
+ 0x20, 0x69, 0x73, 0x20,
+ 0x74, 0x68, 0x65, 0x20,
+ 0x63, 0x6F, 0x6E, 0x74,
+ 0x65, 0x6E, 0x74, 0x2E
+}, bm89c[] = {
+ 0x99, 0x8D, 0x26, 0xC6,
+ 0x45, 0x9A, 0xAE, 0xEC,
+ 0xF4, 0x4E, 0xD2, 0x0C,
+ 0xE0, 0x0C, 0x8C, 0xCE,
+ 0xDF, 0x0A, 0x1F, 0x3D,
+ 0x22, 0xA9, 0x2F, 0xC0,
+ 0x5D, 0xB0, 0x8C, 0x5A,
+ 0xEB, 0x1C, 0xB5, 0x94,
+ 0xCA, 0xAF, 0x5A, 0x5C,
+ 0x5E, 0x2E, 0x9D, 0x01,
+ 0xCC, 0xE7, 0xE7, 0x7A,
+ 0x93, 0xAA, 0x8C, 0x62
+}, bm90a[] = {
+ 0xa1, 0x01, 0x07
+}, bm90b[] = {
+ 0x54, 0x68, 0x69, 0x73,
+ 0x20, 0x69, 0x73, 0x20,
+ 0x74, 0x68, 0x65, 0x20,
+ 0x63, 0x6F, 0x6E, 0x74,
+ 0x65, 0x6E, 0x74, 0x2E
+}, bm90c[] = {
+ 0x4A, 0x55, 0x5B, 0xF9,
+ 0x71, 0xF7, 0xC1, 0x89,
+ 0x1D, 0x9D, 0xDF, 0x30,
+ 0x4A, 0x1A, 0x13, 0x2E,
+ 0x2D, 0x6F, 0x81, 0x74,
+ 0x49, 0x47, 0x4D, 0x81,
+ 0x3E, 0x6D, 0x04, 0xD6,
+ 0x59, 0x62, 0xBE, 0xD8,
+ 0xBB, 0xA7, 0x0C, 0x17,
+ 0xE1, 0xF5, 0x30, 0x8F,
+ 0xA3, 0x99, 0x62, 0x95,
+ 0x9A, 0x4B, 0x9B, 0x8D,
+ 0x7D, 0xA8, 0xE6, 0xD8,
+ 0x49, 0xB2, 0x09, 0xDC,
+ 0xD3, 0xE9, 0x8C, 0xC0,
+ 0xF1, 0x1E, 0xDD, 0xF2
+}, bm91a[] = {
+ 0xa1, 0x01, 0x05
+}, bm91b[] = {
+ 0x54, 0x68, 0x69, 0x73,
+ 0x20, 0x69, 0x73, 0x20,
+ 0x74, 0x68, 0x65, 0x20,
+ 0x63, 0x6F, 0x6E, 0x74,
+ 0x65, 0x6E, 0x74, 0x2E
+}, bm91c[] = {
+ 0xA1, 0xA8, 0x48, 0xD3,
+ 0x47, 0x1F, 0x9D, 0x61,
+ 0xEE, 0x49, 0x01, 0x8D,
+ 0x24, 0x4C, 0x82, 0x47,
+ 0x72, 0xF2, 0x23, 0xAD,
+ 0x4F, 0x93, 0x52, 0x93,
+ 0xF1, 0x78, 0x9F, 0xC3,
+ 0xA0, 0x8D, 0x8C, 0x59
+}, bm92a[] = {
+ 0xa1, 0x01, 0x04
+}, bm92b[] = {
+ 0x54, 0x68, 0x69, 0x73,
+ 0x20, 0x69, 0x73, 0x20,
+ 0x74, 0x68, 0x65, 0x20,
+ 0x63, 0x6F, 0x6E, 0x74,
+ 0x65, 0x6E, 0x74, 0x2E
+}, bm92c[] = {
+ 0x11, 0xF9, 0xE3, 0x57,
+ 0x97, 0x5F, 0xB8, 0x49
+}, bm93a[] = {
+ 0xa1, 0x01, 0x01
+}, bm93b[] = {
+ 0x02, 0xd1, 0xf7, 0xe6, 0xf2,
+ 0x6c, 0x43, 0xd4, 0x86, 0x8d,
+ 0x87, 0xce
+}, bm93c[] = {
+ 0xa1, 0x01, 0x27
+}, bm93d[] = {
+ 0x31, 0x31
+}, bm93e[] = {
+ 0xe1, 0x04, 0x39, 0x15, 0x4c,
+ 0xc7, 0x5c, 0x7a, 0x3a, 0x53,
+ 0x91, 0x49, 0x1f, 0x88, 0x65,
+ 0x1e, 0x02, 0x92, 0xfd, 0x0f,
+ 0xe0, 0xe0, 0x2c, 0xf7, 0x40,
+ 0x54, 0x7e, 0xaf, 0x66, 0x77,
+ 0xb4, 0xa4, 0x04, 0x0b, 0x8e,
+ 0xca, 0x16, 0xdb, 0x59, 0x28,
+ 0x81, 0x26, 0x2f, 0x77, 0xb1,
+ 0x4c, 0x1a, 0x08, 0x6c, 0x02,
+ 0x26, 0x8b, 0x17, 0x17, 0x1c,
+ 0xa1, 0x6b, 0xe4, 0xb8, 0x59,
+ 0x5f, 0x8c, 0x0a, 0x08
+}, bm93f[] = {
+ 0x60, 0x97, 0x3a, 0x94, 0xbb,
+ 0x28, 0x98, 0x00, 0x9e, 0xe5,
+ 0x2e, 0xcf, 0xd9, 0xab, 0x1d,
+ 0xd2, 0x58, 0x67, 0x37, 0x4b,
+ 0x16, 0x2e, 0x2c, 0x03, 0x56,
+ 0x8b, 0x41, 0xf5, 0x7c, 0x3c,
+ 0xc1, 0x6f, 0x91, 0x66, 0x25,
+ 0x0a
+
+}, bm94a[] = {
+ 0xa1, 0x01, 0x01
+}, bm94b[] = {
+ 0x02, 0xd1, 0xf7, 0xe6, 0xf2,
+ 0x6c, 0x43, 0xd4, 0x86, 0x8d,
+ 0x87, 0xce
+}, bm94c[] = {
+ 0xa1, 0x01, 0x27
+}, bm94d[] = {
+ 0x31, 0x31
+}, bm94e[] = {
+ 0xe1, 0x04, 0x39, 0x15, 0x4c,
+ 0xc7, 0x5c, 0x7a, 0x3a, 0x53,
+ 0x91, 0x49, 0x1f, 0x88, 0x65,
+ 0x1e, 0x02, 0x92, 0xfd, 0x0f,
+ 0xe0, 0xe0, 0x2c, 0xf7, 0x40,
+ 0x54, 0x7e, 0xaf, 0x66, 0x77,
+ 0xb4, 0xa4, 0x04, 0x0b, 0x8e,
+ 0xca, 0x16, 0xdb, 0x59, 0x28,
+ 0x81, 0x26, 0x2f, 0x77, 0xb1,
+ 0x4c, 0x1a, 0x08, 0x6c, 0x02,
+ 0x26, 0x8b, 0x17, 0x17, 0x1c,
+ 0xa1, 0x6b, 0xe4, 0xb8, 0x59,
+ 0x5f, 0x8c, 0x0a, 0x08
+}, bm94f[] = {
+ 0xa1, 0x01, 0x26
+}, bm94g[] = {
+ 0x31, 0x31
+}, bm94h[] = {
+ 0xfc, 0xa9, 0x8e, 0xca, 0xc8,
+ 0x0b, 0x5f, 0xeb, 0x3a, 0xc7,
+ 0xc1, 0x08, 0xb2, 0xb7, 0x91,
+ 0x10, 0xde, 0x88, 0x86, 0x7b,
+ 0xc0, 0x42, 0x6f, 0xc8, 0x3c,
+ 0x53, 0xcc, 0xd6, 0x78, 0x96,
+ 0x94, 0xed, 0xc5, 0xfe, 0xe3,
+ 0xc4, 0x0d, 0xe8, 0xe7, 0xb4,
+ 0x4f, 0xe8, 0xaa, 0xd3, 0x67,
+ 0xe0, 0x95, 0xc8, 0xfc, 0x31,
+ 0xb7, 0x9e, 0xe6, 0x66, 0xdf,
+ 0x9c, 0xf9, 0x09, 0x06, 0xeb,
+ 0x43, 0x75, 0x6c, 0x73
+}, bm94i[] = {
+ 0x60, 0x97, 0x3a, 0x94, 0xbb,
+ 0x28, 0x98, 0x00, 0x9e, 0xe5,
+ 0x2e, 0xcf, 0xd9, 0xab, 0x1d,
+ 0xd2, 0x58, 0x67, 0x37, 0x4b,
+ 0x16, 0x2e, 0x2c, 0x03, 0x56,
+ 0x8b, 0x41, 0xf5, 0x7c, 0x3c,
+ 0xc1, 0x6f, 0x91, 0x66, 0x25,
+ 0x0a
+
+}, bm95a[] = {
+ 0xa1, 0x01, 0x01
+}, bm95b[] = {
+ 0x02, 0xd1, 0xf7, 0xe6, 0xf2,
+ 0x6c, 0x43, 0xd4, 0x86, 0x8d,
+ 0x87, 0xce
+}, bm95c[] = {
+ 0xa1, 0x01, 0x27
+}, bm95d[] = {
+ 0x31, 0x31
+}, bm95e[] = {
+ 0x9a, 0x8e, 0xed, 0xe3, 0xb3,
+ 0xcb, 0x83, 0x7b, 0xa0, 0x0d,
+ 0xf0, 0x8f, 0xa2, 0x1b, 0x12,
+ 0x8b, 0x2d, 0x6d, 0x91, 0x62,
+ 0xa4, 0x29, 0x0a, 0x58, 0x2d,
+ 0x9f, 0x19, 0xbd, 0x0f, 0xb5,
+ 0x02, 0xf0, 0xf9, 0x2b, 0x9b,
+ 0xf4, 0x53, 0xa4, 0x05, 0x40,
+ 0x1f, 0x8b, 0x70, 0x55, 0xef,
+ 0x4e, 0x95, 0x8d, 0xf7, 0xf4,
+ 0xfb, 0xd7, 0xcf, 0xb4, 0xa0,
+ 0xc9, 0x71, 0x60, 0xf9, 0x47,
+ 0x2b, 0x0a, 0xa1, 0x04
+}, bm95f[] = {
+ 0x60, 0x97, 0x3a, 0x94, 0xbb,
+ 0x28, 0x98, 0x00, 0x9e, 0xe5,
+ 0x2e, 0xcf, 0xd9, 0xab, 0x1d,
+ 0xd2, 0x58, 0x67, 0x37, 0x4b,
+ 0x35, 0x81, 0xf2, 0xc8, 0x00,
+ 0x39, 0x82, 0x63, 0x50, 0xb9,
+ 0x7a, 0xe2, 0x30, 0x0E, 0x42,
+ 0xFC
+}, bm95g[] = {
+ 0x6f, 0x75, 0x72, 0x2d, 0x73,
+ 0x65, 0x63, 0x72, 0x65, 0x74
+
+}, bm96a[] = {
+ 0xa1, 0x01, 0x01
+}, bm96b[] = {
+ 0x02, 0xd1, 0xf7, 0xe6, 0xf2,
+ 0x6c, 0x43, 0xd4, 0x86, 0x8d,
+ 0x87, 0xce
+}, bm96c[] = {
+ 0xa1, 0x01, 0x27
+}, bm96d[] = {
+ 0x31, 0x31
+}, bm96e[] = {
+ 0x9a, 0x8e, 0xed, 0xe3, 0xb3,
+ 0xcb, 0x83, 0x7b, 0xa0, 0x0d,
+ 0xf0, 0x8f, 0xa2, 0x1b, 0x12,
+ 0x8b, 0x2d, 0x6d, 0x91, 0x62,
+ 0xa4, 0x29, 0x0a, 0x58, 0x2d,
+ 0x9f, 0x19, 0xbd, 0x0f, 0xb5,
+ 0x02, 0xf0, 0xf9, 0x2b, 0x9b,
+ 0xf4, 0x53, 0xa4, 0x05, 0x40,
+ 0x1f, 0x8b, 0x70, 0x55, 0xef,
+ 0x4e, 0x95, 0x8d, 0xf7, 0xf4,
+ 0xfb, 0xd7, 0xcf, 0xb4, 0xa0,
+ 0xc9, 0x71, 0x60, 0xf9, 0x47,
+ 0x2b, 0x0a, 0xa1, 0x04
+}, bm96f[] = {
+ 0xa1, 0x01, 0x26
+}, bm96g[] = {
+ 0x31, 0x31
+}, bm96h[] = {
+ 0x24, 0x27, 0xcb, 0x37, 0x56,
+ 0x85, 0x0f, 0xbb, 0x79, 0x05,
+ 0x18, 0x07, 0xc8, 0xb2, 0x3d,
+ 0x2e, 0x6d, 0x16, 0xa3, 0x22,
+ 0x4f, 0x99, 0x01, 0xb4, 0x73,
+ 0x99, 0xcf, 0xc7, 0xe3, 0xfa,
+ 0xc4, 0xcc, 0x62, 0x1d, 0xbb,
+ 0xeb, 0x02, 0x02, 0xa6, 0xd8,
+ 0xbb, 0x25, 0x69, 0x5c, 0x9d,
+ 0xcc, 0x9c, 0x47, 0x49, 0x20,
+ 0xff, 0x57, 0x60, 0x6d, 0x76,
+ 0x4d, 0xea, 0x19, 0x2f, 0xc8,
+ 0x67, 0x41, 0x16, 0xf2
+}, bm96i[] = {
+ 0x60, 0x97, 0x3a, 0x94, 0xbb,
+ 0x28, 0x98, 0x00, 0x9e, 0xe5,
+ 0x2e, 0xcf, 0xd9, 0xab, 0x1d,
+ 0xd2, 0x58, 0x67, 0x37, 0x4b,
+ 0x35, 0x81, 0xf2, 0xc8, 0x00,
+ 0x39, 0x82, 0x63, 0x50, 0xb9,
+ 0x7a, 0xe2, 0x30, 0x0e, 0x42,
+ 0xfc
+}, bm96j[] = {
+ 0x6f, 0x75, 0x72, 0x2d, 0x73,
+ 0x65, 0x63, 0x72, 0x65, 0x74
+
+}, bm97a[] = {
+ 0xa1, 0x01, 0x01
+}, bm97b[] = {
+ 0x02, 0xd1, 0xf7, 0xe6, 0xf2,
+ 0x6c, 0x43, 0xd4, 0x86, 0x8d,
+ 0x87, 0xce
+}, bm97c[] = {
+ 0x60, 0x97, 0x3a, 0x94, 0xbb,
+ 0x28, 0x98, 0x00, 0x9e, 0xe5,
+ 0x2e, 0xcf, 0xd9, 0xab, 0x1d,
+ 0xd2, 0x58, 0x67, 0x37, 0x4b,
+ 0x35, 0x81, 0xf2, 0xc8, 0x00,
+ 0x39, 0x82, 0x63, 0x50, 0xb9,
+ 0x7a, 0xe2, 0x30, 0x0e, 0x42,
+ 0xfc
+}, bm97d[] = {
+ 0x6f, 0x75, 0x72, 0x2d, 0x73,
+ 0x65, 0x63, 0x72, 0x65, 0x74
+}, bm97e[] = {
+ 0xa1, 0x01, 0x27
+}, bm97f[] = {
+ 0x31, 0x31
+}, bm97g[] = {
+ 0xcc, 0xb1, 0xf3, 0xfe, 0xdf,
+ 0xce, 0xa7, 0x2b, 0x9c, 0x86,
+ 0x79, 0x63, 0xe2, 0x52, 0xb6,
+ 0x65, 0x8a, 0xd0, 0x7f, 0x3f,
+ 0x5f, 0x15, 0xa3, 0x26, 0xa3,
+ 0xf5, 0x72, 0x54, 0xcc, 0xb8,
+ 0xd4, 0x8d, 0x60, 0x02, 0x1d,
+ 0x2f, 0x1f, 0x8a, 0x80, 0x3b,
+ 0x84, 0x4b, 0x78, 0x72, 0x16,
+ 0x6c, 0x6d, 0x45, 0x90, 0x25,
+ 0xd2, 0x1c, 0x8c, 0x84, 0x62,
+ 0xa2, 0x44, 0xba, 0x19, 0x60,
+ 0x4e, 0xc4, 0xd5, 0x0b
+
+}, bm98a[] = {
+ 0xa1, 0x01, 0x05
+}, bm98b[] = {
+ 0xa1, 0x01, 0x27
+}, bm98c[] = {
+ 0x31, 0x31
+}, bm98d[] = {
+ 0xb4, 0x92, 0x4b, 0x18, 0xeb,
+ 0x4e, 0x04, 0x73, 0x13, 0xc7,
+ 0x07, 0xb0, 0xed, 0xa4, 0xab,
+ 0x84, 0x43, 0x45, 0xf2, 0xc4,
+ 0x49, 0x87, 0xd6, 0xf9, 0xeb,
+ 0xcc, 0x77, 0x7e, 0xfd, 0x40,
+ 0x78, 0xcc, 0x0f, 0x4c, 0x10,
+ 0x8d, 0xef, 0x95, 0x9f, 0x78,
+ 0xf1, 0xed, 0xb2, 0x76, 0x54,
+ 0x25, 0x78, 0x5f, 0xcd, 0x17,
+ 0xd5, 0x12, 0xbe, 0x31, 0xee,
+ 0xb6, 0x6b, 0xef, 0xf1, 0xe8,
+ 0xfc, 0x27, 0x47, 0x07
+}, bm98e[] = {
+ 0x54, 0x68, 0x69, 0x73, 0x20,
+ 0x69, 0x73, 0x20, 0x74, 0x68,
+ 0x65, 0x20, 0x63, 0x6f, 0x6e,
+ 0x74, 0x65, 0x6e, 0x74, 0x2e
+}, bm98f[] = {
+ 0x2b, 0xdc, 0xc8, 0x9f, 0x05,
+ 0x82, 0x16, 0xb8, 0xa2, 0x08,
+ 0xdd, 0xc6, 0xd8, 0xb5, 0x4a,
+ 0xa9, 0x1f, 0x48, 0xbd, 0x63,
+ 0x48, 0x49, 0x86, 0x56, 0x51,
+ 0x05, 0xc9, 0xad, 0x5a, 0x66,
+ 0x82, 0xf6
+}, bm98g[] = {
+ 0x6f, 0x75, 0x72, 0x2d, 0x73,
+ 0x65, 0x63, 0x72, 0x65, 0x74
+
+}, bm99a[] = {
+ 0xa1, 0x01, 0x05
+}, bm99b[] = {
+ 0xa1, 0x01, 0x27
+}, bm99c[] = {
+ 0x31, 0x31
+}, bm99d[] = {
+ 0xb4, 0x92, 0x4b, 0x18, 0xeb,
+ 0x4e, 0x04, 0x73, 0x13, 0xc7,
+ 0x07, 0xb0, 0xed, 0xa4, 0xab,
+ 0x84, 0x43, 0x45, 0xf2, 0xc4,
+ 0x49, 0x87, 0xd6, 0xf9, 0xeb,
+ 0xcc, 0x77, 0x7e, 0xfd, 0x40,
+ 0x78, 0xcc, 0x0f, 0x4c, 0x10,
+ 0x8d, 0xef, 0x95, 0x9f, 0x78,
+ 0xf1, 0xed, 0xb2, 0x76, 0x54,
+ 0x25, 0x78, 0x5f, 0xcd, 0x17,
+ 0xd5, 0x12, 0xbe, 0x31, 0xee,
+ 0xb6, 0x6b, 0xef, 0xf1, 0xe8,
+ 0xfc, 0x27, 0x47, 0x07
+}, bm99e[] = {
+ 0xa1, 0x01, 0x26
+}, bm99f[] = {
+ 0x31, 0x31
+}, bm99g[] = {
+ 0x6a, 0xcd, 0x94, 0xd3, 0xcc,
+ 0xf7, 0x1d, 0x19, 0x2e, 0x85,
+ 0x28, 0x36, 0x0b, 0xa7, 0xe3,
+ 0x46, 0xda, 0xc4, 0x64, 0xe9,
+ 0xed, 0xca, 0x4c, 0xfe, 0xb6,
+ 0xce, 0xb6, 0xbd, 0xe7, 0xba,
+ 0xec, 0x9f, 0xf2, 0x6c, 0xa6,
+ 0xbd, 0xf7, 0x3d, 0x0b, 0xe4,
+ 0x1e, 0x36, 0x12, 0x9d, 0xcf,
+ 0xf7, 0x51, 0xdd, 0x2b, 0x5a,
+ 0xd5, 0xce, 0x11, 0x6e, 0x8a,
+ 0x96, 0x3a, 0x27, 0x38, 0xa2,
+ 0x99, 0x47, 0x7a, 0x68
+}, bm99h[] = {
+ 0x54, 0x68, 0x69, 0x73, 0x20,
+ 0x69, 0x73, 0x20, 0x74, 0x68,
+ 0x65, 0x20, 0x63, 0x6f, 0x6e,
+ 0x74, 0x65, 0x6e, 0x74, 0x2e
+}, bm99i[] = {
+ 0x2b, 0xdc, 0xc8, 0x9f, 0x05,
+ 0x82, 0x16, 0xb8, 0xa2, 0x08,
+ 0xdd, 0xc6, 0xd8, 0xb5, 0x4a,
+ 0xa9, 0x1f, 0x48, 0xbd, 0x63,
+ 0x48, 0x49, 0x86, 0x56, 0x51,
+ 0x05, 0xc9, 0xad, 0x5a, 0x66,
+ 0x82, 0xf6
+}, bm99j[] = {
+ 0x6f, 0x75, 0x72, 0x2d, 0x73,
+ 0x65, 0x63, 0x72, 0x65, 0x74
+
+}, bm100a[] = {
+ 0xa1, 0x01, 0x05
+}, bm100b[] = {
+ 0xa1, 0x01, 0x27
+}, bm100c[] = {
+ 0x31, 0x31
+}, bm100d[] = {
+ 0xb4, 0x92, 0x4b, 0x18, 0xeb,
+ 0x4e, 0x04, 0x73, 0x13, 0xc7,
+ 0x07, 0xb0, 0xed, 0xa4, 0xab,
+ 0x84, 0x43, 0x45, 0xf2, 0xc4,
+ 0x49, 0x87, 0xd6, 0xf9, 0xeb,
+ 0xcc, 0x77, 0x7e, 0xfd, 0x40,
+ 0x78, 0xcc, 0x0f, 0x4c, 0x10,
+ 0x8d, 0xef, 0x95, 0x9f, 0x78,
+ 0xf1, 0xed, 0xb2, 0x76, 0x54,
+ 0x25, 0x78, 0x5f, 0xcd, 0x17,
+ 0xd5, 0x12, 0xbe, 0x31, 0xee,
+ 0xb6, 0x6b, 0xef, 0xf1, 0xe8,
+ 0xfc, 0x27, 0x47, 0x07
+}, bm100e[] = {
+ 0x54, 0x68, 0x69, 0x73, 0x20,
+ 0x69, 0x73, 0x20, 0x74, 0x68,
+ 0x65, 0x20, 0x63, 0x6f, 0x6e,
+ 0x74, 0x65, 0x6e, 0x74, 0x2e
+}, bm100f[] = {
+ 0xa1, 0xa8, 0x48, 0xd3, 0x47,
+ 0x1f, 0x9d, 0x61, 0xee, 0x49,
+ 0x01, 0x8d, 0x24, 0x4c, 0x82,
+ 0x47, 0x72, 0xf2, 0x23, 0xad,
+ 0x4f, 0x93, 0x52, 0x93, 0xf1,
+ 0x78, 0x9f, 0xc3, 0xa0, 0x8d,
+ 0x8c, 0x58
+
+
+}, bm101a[] = {
+ 0xa1, 0x01, 0x05
+}, bm101b[] = {
+ 0xa1, 0x01, 0x27
+}, bm101c[] = {
+ 0x31, 0x31
+}, bm101d[] = {
+ 0xb4, 0x92, 0x4b, 0x18, 0xeb,
+ 0x4e, 0x04, 0x73, 0x13, 0xc7,
+ 0x07, 0xb0, 0xed, 0xa4, 0xab,
+ 0x84, 0x43, 0x45, 0xf2, 0xc4,
+ 0x49, 0x87, 0xd6, 0xf9, 0xeb,
+ 0xcc, 0x77, 0x7e, 0xfd, 0x40,
+ 0x78, 0xcc, 0x0f, 0x4c, 0x10,
+ 0x8d, 0xef, 0x95, 0x9f, 0x78,
+ 0xf1, 0xed, 0xb2, 0x76, 0x54,
+ 0x25, 0x78, 0x5f, 0xcd, 0x17,
+ 0xd5, 0x12, 0xbe, 0x31, 0xee,
+ 0xb6, 0x6b, 0xef, 0xf1, 0xe8,
+ 0xfc, 0x27, 0x47, 0x07
+}, bm101e[] = {
+ 0xa1, 0x01, 0x26
+}, bm101f[] = {
+ 0x31, 0x31
+}, bm101g[] = {
+ 0x6a, 0xcd, 0x94, 0xd3, 0xcc,
+ 0xf7, 0x1d, 0x19, 0x2e, 0x85,
+ 0x28, 0x36, 0x0b, 0xa7, 0xe3,
+ 0x46, 0xda, 0xc4, 0x64, 0xe9,
+ 0xed, 0xca, 0x4c, 0xfe, 0xb6,
+ 0xce, 0xb6, 0xbd, 0xe7, 0xba,
+ 0xec, 0x9f, 0xf2, 0x6c, 0xa6,
+ 0xbd, 0xf7, 0x3d, 0x0b, 0xe4,
+ 0x1e, 0x36, 0x12, 0x9d, 0xcf,
+ 0xf7, 0x51, 0xdd, 0x2b, 0x5a,
+ 0xd5, 0xce, 0x11, 0x6e, 0x8a,
+ 0x96, 0x3a, 0x27, 0x38, 0xa2,
+ 0x99, 0x47, 0x7a, 0x68
+}, bm101h[] = {
+ 0x54, 0x68, 0x69, 0x73, 0x20,
+ 0x69, 0x73, 0x20, 0x74, 0x68,
+ 0x65, 0x20, 0x63, 0x6f, 0x6e,
+ 0x74, 0x65, 0x6e, 0x74, 0x2e
+}, bm101i[] = {
+ 0x2b, 0xdc, 0xc8, 0x9f, 0x05,
+ 0x82, 0x16, 0xb8, 0xa2, 0x08,
+ 0xdd, 0xc6, 0xd8, 0xb5, 0x4a,
+ 0xa9, 0x1f, 0x48, 0xbd, 0x63,
+ 0x48, 0x49, 0x86, 0x56, 0x51,
+ 0x05, 0xc9, 0xad, 0x5a, 0x66,
+ 0x82, 0xf6
+}, bm101j[] = {
+ 0x6f, 0x75, 0x72, 0x2d, 0x73,
+ 0x65, 0x63, 0x72, 0x65, 0x74
+
+}, bm102a[] = { /* mac0-01 */
+ 0xa1, 0x01, 0x05
+}, bm102b[] = {
+ 0xa1, 0x01, 0x27
+}, bm102c[] = {
+ 0x31, 0x31
+}, bm102d[] = {
+ 0xb4, 0x92, 0x4b, 0x18, 0xeb,
+ 0x4e, 0x04, 0x73, 0x13, 0xc7,
+ 0x07, 0xb0, 0xed, 0xa4, 0xab,
+ 0x84, 0x43, 0x45, 0xf2, 0xc4,
+ 0x49, 0x87, 0xd6, 0xf9, 0xeb,
+ 0xcc, 0x77, 0x7e, 0xfd, 0x40,
+ 0x78, 0xcc, 0x0f, 0x4c, 0x10,
+ 0x8d, 0xef, 0x95, 0x9f, 0x78,
+ 0xf1, 0xed, 0xb2, 0x76, 0x54,
+ 0x25, 0x78, 0x5f, 0xcd, 0x17,
+ 0xd5, 0x12, 0xbe, 0x31, 0xee,
+ 0xb6, 0x6b, 0xef, 0xf1, 0xe8,
+ 0xfc, 0x27, 0x47, 0x07
+}, bm102e[] = {
+ 0x54, 0x68, 0x69, 0x73, 0x20,
+ 0x69, 0x73, 0x20, 0x74, 0x68,
+ 0x65, 0x20, 0x63, 0x6f, 0x6e,
+ 0x74, 0x65, 0x6e, 0x74, 0x2e
+}, bm102f[] = {
+ 0xa1, 0xa8, 0x48, 0xd3, 0x47,
+ 0x1f, 0x9d, 0x61, 0xee, 0x49,
+ 0x01, 0x8d, 0x24, 0x4c, 0x82,
+ 0x47, 0x72, 0xf2, 0x23, 0xad,
+ 0x4f, 0x93, 0x52, 0x93, 0xf1,
+ 0x78, 0x9f, 0xc3, 0xa0, 0x8d,
+ 0x8c, 0x58
+
+}, bm103a[] = {
+ 0xa1, 0x01, 0x05
+}, bm103b[] = {
+ 0xa1, 0x01, 0x27
+}, bm103c[] = {
+ 0x31, 0x31
+}, bm103d[] = {
+ 0xb4, 0x92, 0x4b, 0x18, 0xeb,
+ 0x4e, 0x04, 0x73, 0x13, 0xc7,
+ 0x07, 0xb0, 0xed, 0xa4, 0xab,
+ 0x84, 0x43, 0x45, 0xf2, 0xc4,
+ 0x49, 0x87, 0xd6, 0xf9, 0xeb,
+ 0xcc, 0x77, 0x7e, 0xfd, 0x40,
+ 0x78, 0xcc, 0x0f, 0x4c, 0x10,
+ 0x8d, 0xef, 0x95, 0x9f, 0x78,
+ 0xf1, 0xed, 0xb2, 0x76, 0x54,
+ 0x25, 0x78, 0x5f, 0xcd, 0x17,
+ 0xd5, 0x12, 0xbe, 0x31, 0xee,
+ 0xb6, 0x6b, 0xef, 0xf1, 0xe8,
+ 0xfc, 0x27, 0x47, 0x07
+}, bm103e[] = {
+ 0xa1, 0x01, 0x26
+}, bm103f[] = {
+ 0x31, 0x31
+}, bm103g[] = {
+ 0x6a, 0xcd, 0x94, 0xd3, 0xcc,
+ 0xf7, 0x1d, 0x19, 0x2e, 0x85,
+ 0x28, 0x36, 0x0b, 0xa7, 0xe3,
+ 0x46, 0xda, 0xc4, 0x64, 0xe9,
+ 0xed, 0xca, 0x4c, 0xfe, 0xb6,
+ 0xce, 0xb6, 0xbd, 0xe7, 0xba,
+ 0xec, 0x9f, 0xf2, 0x6c, 0xa6,
+ 0xbd, 0xf7, 0x3d, 0x0b, 0xe4,
+ 0x1e, 0x36, 0x12, 0x9d, 0xcf,
+ 0xf7, 0x51, 0xdd, 0x2b, 0x5a,
+ 0xd5, 0xce, 0x11, 0x6e, 0x8a,
+ 0x96, 0x3a, 0x27, 0x38, 0xa2,
+ 0x99, 0x47, 0x7a, 0x68
+}, bm103h[] = {
+ 0x54, 0x68, 0x69, 0x73, 0x20,
+ 0x69, 0x73, 0x20, 0x74, 0x68,
+ 0x65, 0x20, 0x63, 0x6f, 0x6e,
+ 0x74, 0x65, 0x6e, 0x74, 0x2e
+}, bm103i[] = {
+ 0xa1, 0xa8, 0x48, 0xd3, 0x47,
+ 0x1f, 0x9d, 0x61, 0xee, 0x49,
+ 0x01, 0x8d, 0x24, 0x4c, 0x82,
+ 0x47, 0x72, 0xf2, 0x23, 0xad,
+ 0x4f, 0x93, 0x52, 0x93, 0xf1,
+ 0x78, 0x9f, 0xc3, 0xa0, 0x8d,
+ 0x8c, 0x58
+
+}, bm104a[] = {
+ 0xa1, 0x03, 0x00
+}, bm104b[] = {
+ 0x54, 0x68, 0x69, 0x73, 0x20,
+ 0x69, 0x73, 0x20, 0x74, 0x68,
+ 0x65, 0x20, 0x63, 0x6f, 0x6e,
+ 0x74, 0x65, 0x6e, 0x74, 0x2e
+}, bm104c[] = {
+ 0xa1, 0x01, 0x27
+}, bm104d[] = {
+ 0xa1, 0x01, 0x27
+}, bm104e[] = {
+ 0x31, 0x31
+}, bm104f[] = {
+ 0x8e, 0x1b, 0xe2, 0xf9, 0x45,
+ 0x3d, 0x26, 0x48, 0x12, 0xe5,
+ 0x90, 0x49, 0x91, 0x32, 0xbe,
+ 0xf3, 0xfb, 0xf9, 0xee, 0x9d,
+ 0xb2, 0x7c, 0x2c, 0x16, 0x87,
+ 0x88, 0xe3, 0xb7, 0xeb, 0xe5,
+ 0x06, 0xc0, 0x4f, 0xd3, 0xd1,
+ 0x9f, 0xaa, 0x9f, 0x51, 0x23,
+ 0x2a, 0xf5, 0xc9, 0x59, 0xe4,
+ 0xef, 0x47, 0x92, 0x88, 0x34,
+ 0x64, 0x7f, 0x56, 0xdf, 0xbe,
+ 0x93, 0x91, 0x12, 0x88, 0x4d,
+ 0x08, 0xef, 0x25, 0x05
+}, bm104g[] = {
+ 0x31, 0x31
+}, bm104h[] = {
+ 0x77, 0xf3, 0xea, 0xcd, 0x11,
+ 0x85, 0x2c, 0x4b, 0xf9, 0xcb,
+ 0x1d, 0x72, 0xfa, 0xbe, 0x6b,
+ 0x26, 0xfb, 0xa1, 0xd7, 0x60,
+ 0x92, 0xb2, 0xb5, 0xb7, 0xec,
+ 0x83, 0xb8, 0x35, 0x57, 0x65,
+ 0x22, 0x64, 0xe6, 0x96, 0x90,
+ 0xdb, 0xc1, 0x17, 0x2d, 0xdc,
+ 0x0b, 0xf8, 0x84, 0x11, 0xc0,
+ 0xd2, 0x5a, 0x50, 0x7f, 0xdb,
+ 0x24, 0x7a, 0x20, 0xc4, 0x0d,
+ 0x5e, 0x24, 0x5f, 0xab, 0xd3,
+ 0xfc, 0x9e, 0xc1, 0x06
+
+}, bm105a[] = {
+ 0xa1, 0x03, 0x00
+}, bm105b[] = {
+ 0x54, 0x68, 0x69, 0x73, 0x20,
+ 0x69, 0x73, 0x20, 0x74, 0x68,
+ 0x65, 0x20, 0x63, 0x6f, 0x6e,
+ 0x74, 0x65, 0x6e, 0x74, 0x2e
+}, bm105c[] = {
+ 0xa1, 0x01, 0x27
+}, bm105d[] = {
+ 0xa1, 0x01, 0x27
+}, bm105e[] = {
+ 0x31, 0x31
+}, bm105f[] = {
+ 0x8e, 0x1b, 0xe2, 0xf9, 0x45,
+ 0x3d, 0x26, 0x48, 0x12, 0xe5,
+ 0x90, 0x49, 0x91, 0x32, 0xbe,
+ 0xf3, 0xfb, 0xf9, 0xee, 0x9d,
+ 0xb2, 0x7c, 0x2c, 0x16, 0x87,
+ 0x88, 0xe3, 0xb7, 0xeb, 0xe5,
+ 0x06, 0xc0, 0x4f, 0xd3, 0xd1,
+ 0x9f, 0xaa, 0x9f, 0x51, 0x23,
+ 0x2a, 0xf5, 0xc9, 0x59, 0xe4,
+ 0xef, 0x47, 0x92, 0x88, 0x34,
+ 0x64, 0x7f, 0x56, 0xdf, 0xbe,
+ 0x93, 0x91, 0x12, 0x88, 0x4d,
+ 0x08, 0xef, 0x25, 0x05
+}, bm105g[] = {
+ 0xa1, 0x01, 0x26
+}, bm105h[] = {
+ 0x31, 0x31
+}, bm105i[] = {
+ 0xaf, 0x04, 0x9b, 0x80, 0xd5,
+ 0x2c, 0x36, 0x69, 0xb2, 0x99,
+ 0x70, 0xc1, 0x33, 0x54, 0x37,
+ 0x54, 0xf9, 0xcc, 0x60, 0x8c,
+ 0xe4, 0x11, 0x23, 0xae, 0x1c,
+ 0x82, 0x7e, 0x36, 0xb3, 0x8c,
+ 0xb8, 0x25, 0x98, 0x7f, 0x01,
+ 0xf2, 0x2b, 0xb8, 0xab, 0x13,
+ 0xe9, 0xc6, 0x62, 0x26, 0xee,
+ 0x23, 0x17, 0x8f, 0xfa, 0x00,
+ 0xa4, 0xfc, 0x22, 0x05, 0x93,
+ 0xb6, 0xe5, 0xac, 0x38, 0x96,
+ 0x00, 0x71, 0xc9, 0xc8
+}, bm105j[] = {
+ 0x31, 0x31
+}, bm105k[] = {
+ 0x77, 0xf3, 0xea, 0xcd, 0x11,
+ 0x85, 0x2c, 0x4b, 0xf9, 0xcb,
+ 0x1d, 0x72, 0xfa, 0xbe, 0x6b,
+ 0x26, 0xfb, 0xa1, 0xd7, 0x60,
+ 0x92, 0xb2, 0xb5, 0xb7, 0xec,
+ 0x83, 0xb8, 0x35, 0x57, 0x65,
+ 0x22, 0x64, 0xe6, 0x96, 0x90,
+ 0xdb, 0xc1, 0x17, 0x2d, 0xdc,
+ 0x0b, 0xf8, 0x84, 0x11, 0xc0,
+ 0xd2, 0x5a, 0x50, 0x7f, 0xdb,
+ 0x24, 0x7a, 0x20, 0xc4, 0x0d,
+ 0x5e, 0x24, 0x5f, 0xab, 0xd3,
+ 0xfc, 0x9e, 0xc1, 0x06
+
+}, bm106a[] = {
+ 0xa1, 0x03, 0x00
+}, bm106b[] = {
+ 0xa1, 0x01, 0x27
+}, bm106c[] = {
+ 0x31, 0x31
+}, bm106d[] = {
+ 0xb7, 0xca, 0xcb, 0xa2, 0x85,
+ 0xc4, 0xcd, 0x3e, 0xd2, 0xf0,
+ 0x14, 0x6f, 0x41, 0x98, 0x86,
+ 0x14, 0x4c, 0xa6, 0x38, 0xd0,
+ 0x87, 0xde, 0x12, 0x3d, 0x40,
+ 0x01, 0x67, 0x30, 0x8a, 0xce,
+ 0xab, 0xc4, 0xb5, 0xe5, 0xc6,
+ 0xa4, 0x0c, 0x0d, 0xe0, 0xb7,
+ 0x11, 0x67, 0xa3, 0x91, 0x75,
+ 0xea, 0x56, 0xc1, 0xfe, 0x96,
+ 0xc8, 0x9e, 0x5e, 0x7d, 0x30,
+ 0xda, 0xf2, 0x43, 0x8a, 0x45,
+ 0x61, 0x59, 0xa2, 0x0a
+}, bm106e[] = {
+ 0x54, 0x68, 0x69, 0x73, 0x20,
+ 0x69, 0x73, 0x20, 0x74, 0x68,
+ 0x65, 0x20, 0x63, 0x6f, 0x6e,
+ 0x74, 0x65, 0x6e, 0x74, 0x2e
+}, bm106f[] = {
+ 0xa1, 0x01, 0x27
+}, bm106g[] = {
+ 0x31, 0x31
+}, bm106h[] = {
+ 0x77, 0xf3, 0xea, 0xcd, 0x11,
+ 0x85, 0x2c, 0x4b, 0xf9, 0xcb,
+ 0x1d, 0x72, 0xfa, 0xbe, 0x6b,
+ 0x26, 0xfb, 0xa1, 0xd7, 0x60,
+ 0x92, 0xb2, 0xb5, 0xb7, 0xec,
+ 0x83, 0xb8, 0x35, 0x57, 0x65,
+ 0x22, 0x64, 0xe6, 0x96, 0x90,
+ 0xdb, 0xc1, 0x17, 0x2d, 0xdc,
+ 0x0b, 0xf8, 0x84, 0x11, 0xc0,
+ 0xd2, 0x5a, 0x50, 0x7f, 0xdb,
+ 0x24, 0x7a, 0x20, 0xc4, 0x0d,
+ 0x5e, 0x24, 0x5f, 0xab, 0xd3,
+ 0xfc, 0x9e, 0xc1, 0x06
+
+}, bm107a[] = {
+ 0xa2, 0x01, 0x27, 0x03, 0x00
+}, bm107b[] = {
+ 0xa1, 0x01, 0x27,
+}, bm107c[] = {
+ 0x31, 0x31
+}, bm107d[] = {
+ 0x6d, 0xae, 0xd1, 0x58, 0xaf,
+ 0xe4, 0x03, 0x2e, 0x8d, 0xd4,
+ 0x77, 0xd3, 0xd2, 0xb7, 0xf6,
+ 0x67, 0xe7, 0x95, 0x7a, 0xa8,
+ 0x30, 0x2b, 0xb5, 0xe5, 0x68,
+ 0xb4, 0xdc, 0xbc, 0xce, 0x3c,
+ 0xf0, 0xed, 0x5a, 0x90, 0xf8,
+ 0x31, 0x35, 0x1c, 0x85, 0xd6,
+ 0x15, 0x5a, 0x42, 0xa1, 0x7c,
+ 0xa1, 0xf2, 0x5f, 0x50, 0x1c,
+ 0xc1, 0x3f, 0x67, 0x10, 0x8a,
+ 0xe5, 0x3b, 0xda, 0x92, 0xdb,
+ 0x88, 0x27, 0x2e, 0x00
+}, bm107e[] = {
+ 0x31, 0x31
+}, bm107f[] = {
+ 0x54, 0x68, 0x69, 0x73, 0x20,
+ 0x69, 0x73, 0x20, 0x74, 0x68,
+ 0x65, 0x20, 0x63, 0x6f, 0x6e,
+ 0x74, 0x65, 0x6e, 0x74, 0x2e
+}, bm107g[] = {
+ 0x71, 0x42, 0xfd, 0x2f, 0xf9,
+ 0x6d, 0x56, 0xdb, 0x85, 0xbe,
+ 0xe9, 0x05, 0xa7, 0x6b, 0xa1,
+ 0xd0, 0xb7, 0x32, 0x1a, 0x95,
+ 0xc8, 0xc4, 0xd3, 0x60, 0x7c,
+ 0x57, 0x81, 0x93, 0x2b, 0x7a,
+ 0xfb, 0x87, 0x11, 0x49, 0x7d,
+ 0xfa, 0x75, 0x1b, 0xf4, 0x0b,
+ 0x58, 0xb3, 0xbc, 0xc3, 0x23,
+ 0x00, 0xb1, 0x48, 0x7f, 0x3d,
+ 0xb3, 0x40, 0x85, 0xee, 0xf0,
+ 0x13, 0xbf, 0x08, 0xf4, 0xa4,
+ 0x4d, 0x6f, 0xef, 0x0d
+
+}, bm108a[] = {
+ 0xa2, 0x01, 0x27, 0x03, 0x00
+}, bm108b[] = {
+ 0xa1, 0x01, 0x27
+}, bm108c[] = {
+ 0x31, 0x31
+}, bm108d[] = {
+ 0x6d, 0xae, 0xd1, 0x58, 0xaf,
+ 0xe4, 0x03, 0x2e, 0x8d, 0xd4,
+ 0x77, 0xd3, 0xd2, 0xb7, 0xf6,
+ 0x67, 0xe7, 0x95, 0x7a, 0xa8,
+ 0x30, 0x2b, 0xb5, 0xe5, 0x68,
+ 0xb4, 0xdc, 0xbc, 0xce, 0x3c,
+ 0xf0, 0xed, 0x5a, 0x90, 0xf8,
+ 0x31, 0x35, 0x1c, 0x85, 0xd6,
+ 0x15, 0x5a, 0x42, 0xa1, 0x7c,
+ 0xa1, 0xf2, 0x5f, 0x50, 0x1c,
+ 0xc1, 0x3f, 0x67, 0x10, 0x8a,
+ 0xe5, 0x3b, 0xda, 0x92, 0xdb,
+ 0x88, 0x27, 0x2e, 0x00
+}, bm108e[] = {
+ 0xa1, 0x01, 0x26
+}, bm108f[] = {
+ 0x31, 0x31
+}, bm108g[] = {
+ 0x93, 0x48, 0x7d, 0x09, 0x25,
+ 0x6a, 0x3e, 0xf4, 0x96, 0x37,
+ 0x19, 0xba, 0x5c, 0xf1, 0x01,
+ 0xac, 0xe2, 0xfc, 0x13, 0xd6,
+ 0x31, 0x4b, 0x49, 0x58, 0x21,
+ 0x71, 0xff, 0xa4, 0xa1, 0x31,
+ 0x4d, 0xc9, 0x3e, 0x4a, 0x4a,
+ 0xdf, 0xa4, 0x2a, 0x79, 0xe3,
+ 0x1b, 0x35, 0xd7, 0x30, 0x43,
+ 0x58, 0x58, 0x5b, 0x41, 0x79,
+ 0x96, 0x78, 0xce, 0x00, 0xca,
+ 0x47, 0xc3, 0xe0, 0x23, 0x86,
+ 0x39, 0x23, 0xf8, 0xc8
+}, bm108h[] = {
+ 0x31, 0x31
+}, bm108i[] = {
+ 0x54, 0x68, 0x69, 0x73, 0x20,
+ 0x69, 0x73, 0x20, 0x74, 0x68,
+ 0x65, 0x20, 0x63, 0x6f, 0x6e,
+ 0x74, 0x65, 0x6e, 0x74, 0x2e
+}, bm108j[] = {
+ 0x71, 0x42, 0xfd, 0x2f, 0xf9,
+ 0x6d, 0x56, 0xdb, 0x85, 0xbe,
+ 0xe9, 0x05, 0xa7, 0x6b, 0xa1,
+ 0xd0, 0xb7, 0x32, 0x1a, 0x95,
+ 0xc8, 0xc4, 0xd3, 0x60, 0x7c,
+ 0x57, 0x81, 0x93, 0x2b, 0x7a,
+ 0xfb, 0x87, 0x11, 0x49, 0x7d,
+ 0xfa, 0x75, 0x1b, 0xf4, 0x0b,
+ 0x58, 0xb3, 0xbc, 0xc3, 0x23,
+ 0x00, 0xb1, 0x48, 0x7f, 0x3d,
+ 0xb3, 0x40, 0x85, 0xee, 0xf0,
+ 0x13, 0xbf, 0x08, 0xf4, 0xa4,
+ 0x4d, 0x6f, 0xef, 0x0d
+};
+
+static const struct seq
+seq1[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 0 } },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq2[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1 } },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq3[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 10 } },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq4[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 23 } },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq5[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 24 } },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq6[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 25 } },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq7[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 100 } },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq8[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1000 } },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq9[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1000000 } },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq10[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1000000000000 } },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq11[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 18446744073709551615ull } },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq12[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_TAG_START, .item = { .u.u64 = 0 } },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm12, .buf_len = sizeof(bm12)},
+ { .reason = LECPCB_TAG_END },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq13[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_VAL_NUM_INT, .item = { .u.i64 = 0ull } },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq14[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_TAG_START, .item = { .u.u64 = 3 } },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm12, .buf_len = sizeof(bm12)},
+ { .reason = LECPCB_TAG_END },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq15[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_VAL_NUM_INT, .item = { .u.i64 = -1ll } },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq16[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_VAL_NUM_INT, .item = { .u.i64 = -10ll } },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq17[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_VAL_NUM_INT, .item = { .u.i64 = -100ll } },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq18[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_VAL_NUM_INT, .item = { .u.i64 = -1000ll } },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq19[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_VAL_FLOAT16, .item = { .u.hf = 0 } },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq20[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_VAL_FLOAT16, .item = { .u.hf = 0x8000 } },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq21[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_VAL_FLOAT16, .item = { .u.hf = 0x3c00 } },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq22[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+#if defined(LWS_WITH_CBOR_FLOAT)
+ { .reason = LECPCB_VAL_FLOAT64, .item = { .u.d = 1.1 } },
+#else
+ { .reason = LECPCB_VAL_FLOAT64, .item = { .u.u64 = 0x3ff199999999999aull } },
+#endif
+ { .reason = LECPCB_DESTRUCTED },
+}, seq23[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_VAL_FLOAT16, .item = { .u.hf = 0x3e00 } },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq24[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_VAL_FLOAT16, .item = { .u.hf = 0x7bff } },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq25[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+#if defined(LWS_WITH_CBOR_FLOAT)
+ { .reason = LECPCB_VAL_FLOAT32, .item = { .u.f = 100000.0 } },
+#else
+ { .reason = LECPCB_VAL_FLOAT32, .item = { .u.f = 0x47c35000 } },
+#endif
+ { .reason = LECPCB_DESTRUCTED },
+}, seq26[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+#if defined(LWS_WITH_CBOR_FLOAT)
+ { .reason = LECPCB_VAL_FLOAT32, .item = { .u.f = 3.4028234663852886e+38 } },
+#else
+ { .reason = LECPCB_VAL_FLOAT32, .item = { .u.f = 0x7f7fffff } },
+#endif
+ { .reason = LECPCB_DESTRUCTED },
+}, seq27[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_VAL_FLOAT64, .item = { .u.u64 = 0x7e37e43c8800759cull } },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq28[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_VAL_FLOAT16, .item = { .u.hf = 0x0001 } },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq29[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_VAL_FLOAT16, .item = { .u.hf = 0x0400 } },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq30[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_VAL_FLOAT16, .item = { .u.hf = 0xc400 } },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq31[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_VAL_FLOAT64, .item = { .u.u64 = 0xc010666666666666ull } },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq32[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_VAL_FLOAT16, .item = { .u.hf = 0x7c00 } },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq33[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_VAL_FLOAT16, .item = { .u.hf = 0x7e00 } },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq34[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_VAL_FLOAT16, .item = { .u.hf = 0xfc00 } },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq35[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+#if defined(LWS_WITH_CBOR_FLOAT)
+ { .reason = LECPCB_VAL_FLOAT32, .item = { .u.u32 = 0x7f800000 } },
+#else
+ { .reason = LECPCB_VAL_FLOAT32, .item = { .u.f = 0x7f800000 } },
+#endif
+ { .reason = LECPCB_DESTRUCTED },
+}, seq36[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+#if defined(LWS_WITH_CBOR_FLOAT)
+ { .reason = LECPCB_VAL_FLOAT32, .item = { .u.f = NAN } },
+#else
+ { .reason = LECPCB_VAL_FLOAT32, .item = { .u.f = 0x7fc00000 } },
+#endif
+ { .reason = LECPCB_DESTRUCTED },
+}, seq37[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+#if defined(LWS_WITH_CBOR_FLOAT)
+ { .reason = LECPCB_VAL_FLOAT32, .item = { .u.u32 = 0xff800000 } },
+#else
+ { .reason = LECPCB_VAL_FLOAT32, .item = { .u.f = 0xff800000 } },
+#endif
+ { .reason = LECPCB_DESTRUCTED },
+}, seq38[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+#if defined(LWS_WITH_CBOR_FLOAT)
+ { .reason = LECPCB_VAL_FLOAT64, .item = { .u.u64 = 0x7ff0000000000000ull } },
+#else
+ { .reason = LECPCB_VAL_FLOAT64, .item = { .u.u64 = 0x7ff0000000000000ull } },
+#endif
+ { .reason = LECPCB_DESTRUCTED },
+}, seq39[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+#if defined(LWS_WITH_CBOR_FLOAT)
+ { .reason = LECPCB_VAL_FLOAT64, .item = { .u.u64 = 0x7ff8000000000000ull } },
+#else
+ { .reason = LECPCB_VAL_FLOAT64, .item = { .u.u64 = 0x7ff8000000000000ull } },
+#endif
+ { .reason = LECPCB_DESTRUCTED },
+}, seq40[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+#if defined(LWS_WITH_CBOR_FLOAT)
+ { .reason = LECPCB_VAL_FLOAT64, .item = { .u.u64 = 0xfff0000000000000ull } },
+#else
+ { .reason = LECPCB_VAL_FLOAT64, .item = { .u.u64 = 0xfff0000000000000ull } },
+#endif
+ { .reason = LECPCB_DESTRUCTED },
+}, seq41[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_VAL_FALSE },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq42[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_VAL_TRUE },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq43[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_VAL_NULL },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq44[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_VAL_UNDEFINED },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq45[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_VAL_SIMPLE, .item = { .u.u64 = 16 } },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq46[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_FAILED }, /* example disallowed by RFC! */
+ { .reason = LECPCB_DESTRUCTED },
+}, seq47[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_VAL_SIMPLE, .item = { .u.u64 = 255 } },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq48[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_TAG_START, .item = { .u.u64 = 0 } },
+ { .reason = LECPCB_VAL_STR_START, },
+ { .reason = LECPCB_VAL_STR_END, .buf = bm48, .buf_len = sizeof(bm48)},
+ { .reason = LECPCB_TAG_END },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq49[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_TAG_START, .item = { .u.u64 = 1 } },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1363896240 } },
+ { .reason = LECPCB_TAG_END },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq50[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_TAG_START, .item = { .u.u64 = 1 } },
+ { .reason = LECPCB_VAL_FLOAT64, .item = { .u.u64 = 0x41d452d9ec200000ull } },
+ { .reason = LECPCB_TAG_END },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq51[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_TAG_START, .item = { .u.u64 = 23 } },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm51, .buf_len = sizeof(bm51)},
+ { .reason = LECPCB_TAG_END },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq52[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_TAG_START, .item = { .u.u64 = 24 } },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm52, .buf_len = sizeof(bm52)},
+ { .reason = LECPCB_TAG_END },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq53[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_TAG_START, .item = { .u.u64 = 32 } },
+ { .reason = LECPCB_VAL_STR_START, },
+ { .reason = LECPCB_VAL_STR_END, .buf = bm53, .buf_len = sizeof(bm53)},
+ { .reason = LECPCB_TAG_END },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq54[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm53, .buf_len = 0},
+ { .reason = LECPCB_DESTRUCTED },
+}, seq55[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm51, .buf_len = sizeof(bm51)},
+ { .reason = LECPCB_DESTRUCTED },
+}, seq56[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_VAL_STR_START, },
+ { .reason = LECPCB_VAL_STR_END, .buf = bm53, .buf_len = 0},
+ { .reason = LECPCB_DESTRUCTED },
+}, seq57[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_VAL_STR_START, },
+ { .reason = LECPCB_VAL_STR_END, .buf = bm57, .buf_len = sizeof(bm57)},
+ { .reason = LECPCB_DESTRUCTED },
+}, seq58[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_VAL_STR_START, },
+ { .reason = LECPCB_VAL_STR_END, .buf = bm58, .buf_len = sizeof(bm58)},
+ { .reason = LECPCB_DESTRUCTED },
+}, seq59[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_VAL_STR_START, },
+ { .reason = LECPCB_VAL_STR_END, .buf = bm59, .buf_len = sizeof(bm59)},
+ { .reason = LECPCB_DESTRUCTED },
+}, seq60[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_VAL_STR_START, },
+ { .reason = LECPCB_VAL_STR_END, .buf = bm60, .buf_len = sizeof(bm60)},
+ { .reason = LECPCB_DESTRUCTED },
+}, seq61[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_VAL_STR_START, },
+ { .reason = LECPCB_VAL_STR_END, .buf = bm61, .buf_len = sizeof(bm61)},
+ { .reason = LECPCB_DESTRUCTED },
+}, seq62[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_VAL_STR_START, },
+ { .reason = LECPCB_VAL_STR_END, .buf = bm62, .buf_len = sizeof(bm62)},
+ { .reason = LECPCB_DESTRUCTED },
+}, seq63[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_END },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq64[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 2 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 3 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq65[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_ARRAY_START, },
+
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 2 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 3 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 5 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+
+ { .reason = LECPCB_ARRAY_END },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq66[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 2 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 3 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 5 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 6 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 7 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 8 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 9 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 10 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 11 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 12 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 13 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 14 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 15 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 16 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 17 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 18 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 19 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 20 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 21 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 22 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 23 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 24 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 25 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq67[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq68[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1 } },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 2 } },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 3 } },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq69[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_STR_START, },
+ { .reason = LECPCB_VAL_STR_END, .buf = (const uint8_t *)"a", .buf_len = 1},
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1 } },
+ { .reason = LECPCB_VAL_STR_START, },
+ { .reason = LECPCB_VAL_STR_END, .buf = (const uint8_t *)"b", .buf_len = 1},
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 2 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 3 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq70[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_STR_START, },
+ { .reason = LECPCB_VAL_STR_END, .buf = (const uint8_t *)"a", .buf_len = 1},
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_STR_START, },
+ { .reason = LECPCB_VAL_STR_END, .buf = (const uint8_t *)"b", .buf_len = 1},
+ { .reason = LECPCB_VAL_STR_START, },
+ { .reason = LECPCB_VAL_STR_END, .buf = (const uint8_t *)"c", .buf_len = 1},
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq71[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_STR_START, },
+ { .reason = LECPCB_VAL_STR_END, .buf = (const uint8_t *)"a", .buf_len = 1},
+ { .reason = LECPCB_VAL_STR_START, },
+ { .reason = LECPCB_VAL_STR_END, .buf = (const uint8_t *)"A", .buf_len = 1},
+ { .reason = LECPCB_VAL_STR_START, },
+ { .reason = LECPCB_VAL_STR_END, .buf = (const uint8_t *)"b", .buf_len = 1},
+ { .reason = LECPCB_VAL_STR_START, },
+ { .reason = LECPCB_VAL_STR_END, .buf = (const uint8_t *)"B", .buf_len = 1},
+ { .reason = LECPCB_VAL_STR_START, },
+ { .reason = LECPCB_VAL_STR_END, .buf = (const uint8_t *)"c", .buf_len = 1},
+ { .reason = LECPCB_VAL_STR_START, },
+ { .reason = LECPCB_VAL_STR_END, .buf = (const uint8_t *)"C", .buf_len = 1},
+ { .reason = LECPCB_VAL_STR_START, },
+ { .reason = LECPCB_VAL_STR_END, .buf = (const uint8_t *)"d", .buf_len = 1},
+ { .reason = LECPCB_VAL_STR_START, },
+ { .reason = LECPCB_VAL_STR_END, .buf = (const uint8_t *)"D", .buf_len = 1},
+ { .reason = LECPCB_VAL_STR_START, },
+ { .reason = LECPCB_VAL_STR_END, .buf = (const uint8_t *)"e", .buf_len = 1},
+ { .reason = LECPCB_VAL_STR_START, },
+ { .reason = LECPCB_VAL_STR_END, .buf = (const uint8_t *)"E", .buf_len = 1},
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq72[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_CHUNK, .buf = bm72a, .buf_len = sizeof(bm72a)},
+ { .reason = LECPCB_VAL_BLOB_CHUNK, .buf = bm72b, .buf_len = sizeof(bm72b)},
+ { .reason = LECPCB_VAL_BLOB_END, },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq73[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_VAL_STR_START, },
+ { .reason = LECPCB_VAL_STR_CHUNK, .buf = (const uint8_t *)"stream", .buf_len = 5},
+ { .reason = LECPCB_VAL_STR_CHUNK, .buf = (const uint8_t *)"ming", .buf_len = 4},
+ { .reason = LECPCB_VAL_STR_END, },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq74[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_END },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq75[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 2 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 3 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 5 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq76[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 2 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 3 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 5 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq77[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 2 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 3 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 5 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq78[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 2 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 3 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 5 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq79[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 2 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 3 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 5 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 6 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 7 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 8 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 9 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 10 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 11 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 12 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 13 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 14 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 15 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 16 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 17 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 18 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 19 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 20 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 21 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 22 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 23 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 24 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 25 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq80[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_STR_START, },
+ { .reason = LECPCB_VAL_STR_END, .buf = (const uint8_t *)"a", .buf_len = 1},
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1 } },
+ { .reason = LECPCB_VAL_STR_START, },
+ { .reason = LECPCB_VAL_STR_END, .buf = (const uint8_t *)"b", .buf_len = 1},
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 2 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 3 } },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq81[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_STR_START, },
+ { .reason = LECPCB_VAL_STR_END, .buf = (const uint8_t *)"a", .buf_len = 1},
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_STR_START, },
+ { .reason = LECPCB_VAL_STR_END, .buf = (const uint8_t *)"b", .buf_len = 1},
+ { .reason = LECPCB_VAL_STR_START, },
+ { .reason = LECPCB_VAL_STR_END, .buf = (const uint8_t *)"c", .buf_len = 1},
+ { .reason = LECPCB_OBJECT_END, },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq82[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_STR_START, },
+ { .reason = LECPCB_VAL_STR_END, .buf = (const uint8_t *)"Fun", .buf_len = 3},
+ { .reason = LECPCB_VAL_TRUE },
+ { .reason = LECPCB_VAL_STR_START, },
+ { .reason = LECPCB_VAL_STR_END, .buf = (const uint8_t *)"Amt", .buf_len = 3},
+ { .reason = LECPCB_VAL_NUM_INT, .item = { .u.i64 = (int64_t)-2ll } },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_DESTRUCTED },
+
+}, seq83[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_TAG_START, .item = { .u.u64 = 97 } },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm83a, .buf_len = sizeof(bm83a) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm83b, .buf_len = sizeof(bm83b) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm83c, .buf_len = sizeof(bm83c) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm83a, .buf_len = 0 },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1 } },
+ { .reason = LECPCB_VAL_NUM_INT, .item = { .u.i64 = -6 } },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm83d, .buf_len = sizeof(bm83d) },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm83a, .buf_len = 0 },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_TAG_END, },
+ { .reason = LECPCB_DESTRUCTED },
+
+}, seq84[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_TAG_START, .item = { .u.u64 = 97 } },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm84a, .buf_len = sizeof(bm84a) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm84b, .buf_len = sizeof(bm84b) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm84c, .buf_len = sizeof(bm84c) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm84a, .buf_len = 0 },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1 } },
+ { .reason = LECPCB_VAL_NUM_INT, .item = { .u.i64 = -6 } },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm84d, .buf_len = sizeof(bm84d) },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm84a, .buf_len = 0 },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_TAG_END, },
+ { .reason = LECPCB_DESTRUCTED },
+
+}, seq85[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_TAG_START, .item = { .u.u64 = 97 } },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm85a, .buf_len = sizeof(bm85a) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm85b, .buf_len = sizeof(bm85b) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm85c, .buf_len = sizeof(bm85c) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm85a, .buf_len = 0 },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1 } },
+ { .reason = LECPCB_VAL_NUM_INT, .item = { .u.i64 = -6 } },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm85d, .buf_len = sizeof(bm85d) },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm85a, .buf_len = 0 },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_TAG_END, },
+ { .reason = LECPCB_DESTRUCTED },
+
+}, seq86[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_TAG_START, .item = { .u.u64 = 97 } },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm86a, .buf_len = sizeof(bm86a) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm86b, .buf_len = sizeof(bm86b) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm86c, .buf_len = sizeof(bm86c) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm86a, .buf_len = 0 },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1 } },
+ { .reason = LECPCB_VAL_NUM_INT, .item = { .u.i64 = -6 } },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm86d, .buf_len = sizeof(bm86d) },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm86a, .buf_len = 0 },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_TAG_END, },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq87[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_TAG_START, .item = { .u.u64 = 97 } },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm87a, .buf_len = sizeof(bm87a) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm87b, .buf_len = sizeof(bm87b) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm87c, .buf_len = sizeof(bm87c) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm87a, .buf_len = 0 },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1 } },
+ { .reason = LECPCB_VAL_NUM_INT, .item = { .u.i64 = -6 } },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm87d, .buf_len = sizeof(bm87d) },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm87a, .buf_len = 0 },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_TAG_END, },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq88[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_TAG_START, .item = { .u.u64 = 17 } },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm88a, .buf_len = sizeof(bm88a) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm88b, .buf_len = sizeof(bm88b) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm88c, .buf_len = sizeof(bm88c) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_TAG_END, },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq89[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_TAG_START, .item = { .u.u64 = 17 } },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm89a, .buf_len = sizeof(bm89a) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm89b, .buf_len = sizeof(bm89b) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm89c, .buf_len = sizeof(bm89c) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_TAG_END, },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq90[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_TAG_START, .item = { .u.u64 = 17 } },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm90a, .buf_len = sizeof(bm90a) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm90b, .buf_len = sizeof(bm90b) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm90c, .buf_len = sizeof(bm90c) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_TAG_END, },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq91[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_TAG_START, .item = { .u.u64 = 17 } },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm91a, .buf_len = sizeof(bm91a) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm91b, .buf_len = sizeof(bm91b) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm91c, .buf_len = sizeof(bm91c) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_TAG_END, },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq92[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_TAG_START, .item = { .u.u64 = 17 } },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm92a, .buf_len = sizeof(bm92a) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm92b, .buf_len = sizeof(bm92b) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm92c, .buf_len = sizeof(bm92c) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_TAG_END, },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq93[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_TAG_START, .item = { .u.u64 = 16 } },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm93a, .buf_len = sizeof(bm93a) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 5 } },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm93b, .buf_len = sizeof(bm93b) },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 7 } },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm93c, .buf_len = sizeof(bm93c) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm93d, .buf_len = sizeof(bm93d) },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm93e, .buf_len = sizeof(bm93e) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm93f, .buf_len = sizeof(bm93f) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_TAG_END, },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq94[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_TAG_START, .item = { .u.u64 = 16 } },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm94a, .buf_len = sizeof(bm94a) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 5 } },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm94b, .buf_len = sizeof(bm94b) },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 7 } },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm94c, .buf_len = sizeof(bm94c) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm94d, .buf_len = sizeof(bm94d) },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm94e, .buf_len = sizeof(bm94e) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm94f, .buf_len = sizeof(bm94f) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm94g, .buf_len = sizeof(bm94g) },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm94h, .buf_len = sizeof(bm94h) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm94i, .buf_len = sizeof(bm94i) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_TAG_END, },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq95[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_TAG_START, .item = { .u.u64 = 96 } },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm95a, .buf_len = sizeof(bm95a) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 5 } },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm95b, .buf_len = sizeof(bm95b) },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 7 } },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm95c, .buf_len = sizeof(bm95c) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm95d, .buf_len = sizeof(bm95d) },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm95e, .buf_len = sizeof(bm95e) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm95f, .buf_len = sizeof(bm95f) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm95f, .buf_len = 0 },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1 } },
+ { .reason = LECPCB_VAL_NUM_INT, .item = { .u.i64 = -6 } },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm95g, .buf_len = sizeof(bm95g) },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm95f, .buf_len = 0 },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_TAG_END, },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq96[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_TAG_START, .item = { .u.u64 = 96 } },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm96a, .buf_len = sizeof(bm96a) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 5 } },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm96b, .buf_len = sizeof(bm96b) },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 7 } },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm96c, .buf_len = sizeof(bm96c) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm96d, .buf_len = sizeof(bm96d) },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm96e, .buf_len = sizeof(bm96e) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm96f, .buf_len = sizeof(bm96f) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm96g, .buf_len = sizeof(bm96g) },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm96h, .buf_len = sizeof(bm96h) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm96i, .buf_len = sizeof(bm96i) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm96f, .buf_len = 0 },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1 } },
+ { .reason = LECPCB_VAL_NUM_INT, .item = { .u.i64 = -6 } },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm96j, .buf_len = sizeof(bm96j) },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm96f, .buf_len = 0 },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_TAG_END, },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq97[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_TAG_START, .item = { .u.u64 = 96 } },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm97a, .buf_len = sizeof(bm97a) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 5 } },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm97b, .buf_len = sizeof(bm97b) },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm97c, .buf_len = sizeof(bm97c) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm97f, .buf_len = 0 },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1 } },
+ { .reason = LECPCB_VAL_NUM_INT, .item = { .u.i64 = -6 } },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm97d, .buf_len = sizeof(bm97d) },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 7 } },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm97e, .buf_len = sizeof(bm97e) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm97f, .buf_len = sizeof(bm97f) },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm97g, .buf_len = sizeof(bm97g) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm97e, .buf_len = 0 },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_TAG_END, },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq98[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_TAG_START, .item = { .u.u64 = 97 } },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm98a, .buf_len = sizeof(bm98a) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 7 } },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm98b, .buf_len = sizeof(bm98b) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm98c, .buf_len = sizeof(bm98c) },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm98d, .buf_len = sizeof(bm98d) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm98e, .buf_len = sizeof(bm98e) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm98f, .buf_len = sizeof(bm98f) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm98e, .buf_len = 0 },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1 } },
+ { .reason = LECPCB_VAL_NUM_INT, .item = { .u.i64 = -6 } },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm98g, .buf_len = sizeof(bm98g) },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm98e, .buf_len = 0 },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_TAG_END, },
+ { .reason = LECPCB_DESTRUCTED },
+
+}, seq99[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_TAG_START, .item = { .u.u64 = 97 } },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm99a, .buf_len = sizeof(bm99a) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 7 } },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm99b, .buf_len = sizeof(bm99b) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm99c, .buf_len = sizeof(bm99c) },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm99d, .buf_len = sizeof(bm99d) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm99e, .buf_len = sizeof(bm99e) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm99f, .buf_len = sizeof(bm99f) },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm99g, .buf_len = sizeof(bm99g) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm99h, .buf_len = sizeof(bm99h) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm99i, .buf_len = sizeof(bm99i) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm99a, .buf_len = 0 },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1 } },
+ { .reason = LECPCB_VAL_NUM_INT, .item = { .u.i64 = -6 } },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm99j, .buf_len = sizeof(bm99j) },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm98e, .buf_len = 0 },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_TAG_END, },
+ { .reason = LECPCB_DESTRUCTED },
+
+}, seq100[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_TAG_START, .item = { .u.u64 = 17 } },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm100a, .buf_len = sizeof(bm100a) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 7 } },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm100b, .buf_len = sizeof(bm100b) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm100c, .buf_len = sizeof(bm100c) },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm100d, .buf_len = sizeof(bm100d) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm100e, .buf_len = sizeof(bm100e) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm100f, .buf_len = sizeof(bm100f) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_TAG_END, },
+ { .reason = LECPCB_DESTRUCTED },
+
+}, seq101[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_TAG_START, .item = { .u.u64 = 17 } },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm101a, .buf_len = sizeof(bm101a) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 7 } },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm101b, .buf_len = sizeof(bm101b) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm101c, .buf_len = sizeof(bm101c) },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm101d, .buf_len = sizeof(bm101d) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm101e, .buf_len = sizeof(bm101e) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm101f, .buf_len = sizeof(bm101f) },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm101g, .buf_len = sizeof(bm101g) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm101h, .buf_len = sizeof(bm101h) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm101i, .buf_len = sizeof(bm101i) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm101j, .buf_len = 0 },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1 } },
+ { .reason = LECPCB_VAL_NUM_INT, .item = { .u.i64 = -6 } },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm101j, .buf_len = sizeof(bm101j) },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm101j, .buf_len = 0 },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_TAG_END, },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq102[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_TAG_START, .item = { .u.u64 = 17 } },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm102a, .buf_len = sizeof(bm102a) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 7 } },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm102b, .buf_len = sizeof(bm102b) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm102c, .buf_len = sizeof(bm102c) },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm102d, .buf_len = sizeof(bm102d) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm102e, .buf_len = sizeof(bm102e) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm102f, .buf_len = sizeof(bm102f) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_TAG_END, },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq103[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_TAG_START, .item = { .u.u64 = 17 } },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm103a, .buf_len = sizeof(bm103a) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 7 } },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm103b, .buf_len = sizeof(bm103b) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm103c, .buf_len = sizeof(bm103c) },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm103d, .buf_len = sizeof(bm103d) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm103e, .buf_len = sizeof(bm103e) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm103f, .buf_len = sizeof(bm103f) },
+
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm103g, .buf_len = sizeof(bm103g) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm103h, .buf_len = sizeof(bm103h) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm103i, .buf_len = sizeof(bm103i) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_TAG_END, },
+ { .reason = LECPCB_DESTRUCTED },
+
+}, seq104[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_TAG_START, .item = { .u.u64 = 98 } },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm104a, .buf_len = sizeof(bm104a) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm104b, .buf_len = sizeof(bm104b) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm104c, .buf_len = sizeof(bm104c) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 7 } },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm104d, .buf_len = sizeof(bm104d) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm104e, .buf_len = sizeof(bm104e) },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm104f, .buf_len = sizeof(bm104f) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm104g, .buf_len = sizeof(bm104g) },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm104h, .buf_len = sizeof(bm104h) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_TAG_END, },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq105[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_TAG_START, .item = { .u.u64 = 98 } },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm105a, .buf_len = sizeof(bm105a) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_OBJECT_END, },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm105b, .buf_len = sizeof(bm105b) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm105c, .buf_len = sizeof(bm105c) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 7 } },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm105d, .buf_len = sizeof(bm105d) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm105e, .buf_len = sizeof(bm105e) },
+ { .reason = LECPCB_OBJECT_END, },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm105f, .buf_len = sizeof(bm105f) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm105g, .buf_len = sizeof(bm105g) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm105h, .buf_len = sizeof(bm105h) },
+ { .reason = LECPCB_OBJECT_END, },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm105i, .buf_len = sizeof(bm105i) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm105j, .buf_len = sizeof(bm105j) },
+ { .reason = LECPCB_OBJECT_END, },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm105k, .buf_len = sizeof(bm105k) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_TAG_END, },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq106[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_TAG_START, .item = { .u.u64 = 98 } },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm106a, .buf_len = sizeof(bm106a) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 7 } },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm106b, .buf_len = sizeof(bm106b) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm106c, .buf_len = sizeof(bm106c) },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm106d, .buf_len = sizeof(bm106d) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm106e, .buf_len = sizeof(bm106e) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm106f, .buf_len = sizeof(bm106f) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm106g, .buf_len = sizeof(bm106g) },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm106h, .buf_len = sizeof(bm106h) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_TAG_END, },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq107[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_TAG_START, .item = { .u.u64 = 17 } },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm107a, .buf_len = sizeof(bm107a) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 7 } },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm107b, .buf_len = sizeof(bm107b) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm107c, .buf_len = sizeof(bm107c) },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm107d, .buf_len = sizeof(bm107d) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm107e, .buf_len = sizeof(bm107e) },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm107f, .buf_len = sizeof(bm107f) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm107g, .buf_len = sizeof(bm107g) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_TAG_END, },
+ { .reason = LECPCB_DESTRUCTED },
+}, seq108[] = {
+ { .reason = LECPCB_CONSTRUCTED },
+ { .reason = LECPCB_TAG_START, .item = { .u.u64 = 18 } },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm108a, .buf_len = sizeof(bm108a) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 7 } },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm108b, .buf_len = sizeof(bm108b) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm108c, .buf_len = sizeof(bm108c) },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm108d, .buf_len = sizeof(bm108d) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_ARRAY_START, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm108e, .buf_len = sizeof(bm108e) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_OBJECT_START, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm108f, .buf_len = sizeof(bm108f) },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm108g, .buf_len = sizeof(bm108g) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm108h, .buf_len = sizeof(bm108h) },
+ { .reason = LECPCB_OBJECT_END },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm108i, .buf_len = sizeof(bm108i) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_ITEM_START, },
+ { .reason = LECPCB_VAL_BLOB_START, },
+ { .reason = LECPCB_VAL_BLOB_END, .buf = bm108j, .buf_len = sizeof(bm108j) },
+ { .reason = LECPCB_ARRAY_ITEM_END, },
+ { .reason = LECPCB_ARRAY_END, },
+ { .reason = LECPCB_TAG_END, },
+ { .reason = LECPCB_DESTRUCTED },
+};
+
+
+struct cbort {
+ const uint8_t *b;
+ size_t blen;
+ const struct seq *seq;
+ size_t seq_size;
+};
+
+static const struct cbort cbor_tests[] = {
+ { .b = test1, .blen = sizeof(test1),
+ .seq = seq1, .seq_size = LWS_ARRAY_SIZE(seq1) },
+ { .b = test2, .blen = sizeof(test2),
+ .seq = seq2, .seq_size = LWS_ARRAY_SIZE(seq2) },
+ { .b = test3, .blen = sizeof(test3),
+ .seq = seq3, .seq_size = LWS_ARRAY_SIZE(seq3) },
+ { .b = test4, .blen = sizeof(test4),
+ .seq = seq4, .seq_size = LWS_ARRAY_SIZE(seq4) },
+ { .b = test5, .blen = sizeof(test5),
+ .seq = seq5, .seq_size = LWS_ARRAY_SIZE(seq5) },
+ { .b = test6, .blen = sizeof(test6),
+ .seq = seq6, .seq_size = LWS_ARRAY_SIZE(seq6) },
+ { .b = test7, .blen = sizeof(test7),
+ .seq = seq7, .seq_size = LWS_ARRAY_SIZE(seq7) },
+ { .b = test8, .blen = sizeof(test8),
+ .seq = seq8, .seq_size = LWS_ARRAY_SIZE(seq8) },
+ { .b = test9, .blen = sizeof(test9),
+ .seq = seq9, .seq_size = LWS_ARRAY_SIZE(seq9) },
+ { .b = test10, .blen = sizeof(test10),
+ .seq = seq10, .seq_size = LWS_ARRAY_SIZE(seq10) },
+ { .b = test11, .blen = sizeof(test11),
+ .seq = seq11, .seq_size = LWS_ARRAY_SIZE(seq11) },
+ { .b = test12, .blen = sizeof(test12),
+ .seq = seq12, .seq_size = LWS_ARRAY_SIZE(seq12) },
+ { .b = test13, .blen = sizeof(test13),
+ .seq = seq13, .seq_size = LWS_ARRAY_SIZE(seq13) },
+ { .b = test14, .blen = sizeof(test14),
+ .seq = seq14, .seq_size = LWS_ARRAY_SIZE(seq14) },
+ { .b = test15, .blen = sizeof(test15),
+ .seq = seq15, .seq_size = LWS_ARRAY_SIZE(seq15) },
+ { .b = test16, .blen = sizeof(test16),
+ .seq = seq16, .seq_size = LWS_ARRAY_SIZE(seq16) },
+ { .b = test17, .blen = sizeof(test17),
+ .seq = seq17, .seq_size = LWS_ARRAY_SIZE(seq17) },
+ { .b = test18, .blen = sizeof(test18),
+ .seq = seq18, .seq_size = LWS_ARRAY_SIZE(seq18) },
+ { .b = test19, .blen = sizeof(test19),
+ .seq = seq19, .seq_size = LWS_ARRAY_SIZE(seq19) },
+ { .b = test20, .blen = sizeof(test20),
+ .seq = seq20, .seq_size = LWS_ARRAY_SIZE(seq20) },
+ { .b = test21, .blen = sizeof(test21),
+ .seq = seq21, .seq_size = LWS_ARRAY_SIZE(seq21) },
+ { .b = test22, .blen = sizeof(test22),
+ .seq = seq22, .seq_size = LWS_ARRAY_SIZE(seq22) },
+ { .b = test23, .blen = sizeof(test23),
+ .seq = seq23, .seq_size = LWS_ARRAY_SIZE(seq23) },
+ { .b = test24, .blen = sizeof(test24),
+ .seq = seq24, .seq_size = LWS_ARRAY_SIZE(seq24) },
+ { .b = test25, .blen = sizeof(test25),
+ .seq = seq25, .seq_size = LWS_ARRAY_SIZE(seq25) },
+ { .b = test26, .blen = sizeof(test26),
+ .seq = seq26, .seq_size = LWS_ARRAY_SIZE(seq26) },
+ { .b = test27, .blen = sizeof(test27),
+ .seq = seq27, .seq_size = LWS_ARRAY_SIZE(seq27) },
+ { .b = test28, .blen = sizeof(test28),
+ .seq = seq28, .seq_size = LWS_ARRAY_SIZE(seq28) },
+ { .b = test29, .blen = sizeof(test29),
+ .seq = seq29, .seq_size = LWS_ARRAY_SIZE(seq29) },
+ { .b = test30, .blen = sizeof(test30),
+ .seq = seq30, .seq_size = LWS_ARRAY_SIZE(seq30) },
+ { .b = test31, .blen = sizeof(test31),
+ .seq = seq31, .seq_size = LWS_ARRAY_SIZE(seq31) },
+ { .b = test32, .blen = sizeof(test32),
+ .seq = seq32, .seq_size = LWS_ARRAY_SIZE(seq32) },
+ { .b = test33, .blen = sizeof(test33),
+ .seq = seq33, .seq_size = LWS_ARRAY_SIZE(seq33) },
+ { .b = test34, .blen = sizeof(test34),
+ .seq = seq34, .seq_size = LWS_ARRAY_SIZE(seq34) },
+ { .b = test35, .blen = sizeof(test35),
+ .seq = seq35, .seq_size = LWS_ARRAY_SIZE(seq35) },
+ { .b = test36, .blen = sizeof(test36),
+ .seq = seq36, .seq_size = LWS_ARRAY_SIZE(seq36) },
+ { .b = test37, .blen = sizeof(test37),
+ .seq = seq37, .seq_size = LWS_ARRAY_SIZE(seq37) },
+ { .b = test38, .blen = sizeof(test38),
+ .seq = seq38, .seq_size = LWS_ARRAY_SIZE(seq38) },
+ { .b = test39, .blen = sizeof(test39),
+ .seq = seq39, .seq_size = LWS_ARRAY_SIZE(seq39) },
+ { .b = test40, .blen = sizeof(test40),
+ .seq = seq40, .seq_size = LWS_ARRAY_SIZE(seq40) },
+ { .b = test41, .blen = sizeof(test41),
+ .seq = seq41, .seq_size = LWS_ARRAY_SIZE(seq41) },
+ { .b = test42, .blen = sizeof(test42),
+ .seq = seq42, .seq_size = LWS_ARRAY_SIZE(seq42) },
+ { .b = test43, .blen = sizeof(test43),
+ .seq = seq43, .seq_size = LWS_ARRAY_SIZE(seq43) },
+ { .b = test44, .blen = sizeof(test44),
+ .seq = seq44, .seq_size = LWS_ARRAY_SIZE(seq44) },
+ { .b = test45, .blen = sizeof(test45),
+ .seq = seq45, .seq_size = LWS_ARRAY_SIZE(seq45) },
+ { .b = test46, .blen = sizeof(test46),
+ .seq = seq46, .seq_size = LWS_ARRAY_SIZE(seq46) },
+ { .b = test47, .blen = sizeof(test47),
+ .seq = seq47, .seq_size = LWS_ARRAY_SIZE(seq47) },
+ { .b = test48, .blen = sizeof(test48),
+ .seq = seq48, .seq_size = LWS_ARRAY_SIZE(seq48) },
+ { .b = test49, .blen = sizeof(test49),
+ .seq = seq49, .seq_size = LWS_ARRAY_SIZE(seq49) },
+ { .b = test50, .blen = sizeof(test50),
+ .seq = seq50, .seq_size = LWS_ARRAY_SIZE(seq50) },
+ { .b = test51, .blen = sizeof(test51),
+ .seq = seq51, .seq_size = LWS_ARRAY_SIZE(seq51) },
+ { .b = test52, .blen = sizeof(test52),
+ .seq = seq52, .seq_size = LWS_ARRAY_SIZE(seq52) },
+ { .b = test53, .blen = sizeof(test53),
+ .seq = seq53, .seq_size = LWS_ARRAY_SIZE(seq53) },
+ { .b = test54, .blen = sizeof(test54),
+ .seq = seq54, .seq_size = LWS_ARRAY_SIZE(seq54) },
+ { .b = test55, .blen = sizeof(test55),
+ .seq = seq55, .seq_size = LWS_ARRAY_SIZE(seq55) },
+ { .b = test56, .blen = sizeof(test56),
+ .seq = seq56, .seq_size = LWS_ARRAY_SIZE(seq56) },
+ { .b = test57, .blen = sizeof(test57),
+ .seq = seq57, .seq_size = LWS_ARRAY_SIZE(seq57) },
+ { .b = test58, .blen = sizeof(test58),
+ .seq = seq58, .seq_size = LWS_ARRAY_SIZE(seq58) },
+ { .b = test59, .blen = sizeof(test59),
+ .seq = seq59, .seq_size = LWS_ARRAY_SIZE(seq59) },
+ { .b = test60, .blen = sizeof(test60),
+ .seq = seq60, .seq_size = LWS_ARRAY_SIZE(seq60) },
+ { .b = test61, .blen = sizeof(test61),
+ .seq = seq61, .seq_size = LWS_ARRAY_SIZE(seq61) },
+ { .b = test62, .blen = sizeof(test62),
+ .seq = seq62, .seq_size = LWS_ARRAY_SIZE(seq62) },
+ { .b = test63, .blen = sizeof(test63),
+ .seq = seq63, .seq_size = LWS_ARRAY_SIZE(seq63) },
+ { .b = test64, .blen = sizeof(test64),
+ .seq = seq64, .seq_size = LWS_ARRAY_SIZE(seq64) },
+ { .b = test65, .blen = sizeof(test65),
+ .seq = seq65, .seq_size = LWS_ARRAY_SIZE(seq65) },
+ { .b = test66, .blen = sizeof(test66),
+ .seq = seq66, .seq_size = LWS_ARRAY_SIZE(seq66) },
+ { .b = test67, .blen = sizeof(test67),
+ .seq = seq67, .seq_size = LWS_ARRAY_SIZE(seq67) },
+ { .b = test68, .blen = sizeof(test68),
+ .seq = seq68, .seq_size = LWS_ARRAY_SIZE(seq68) },
+ { .b = test69, .blen = sizeof(test69),
+ .seq = seq69, .seq_size = LWS_ARRAY_SIZE(seq69) },
+ { .b = test70, .blen = sizeof(test70),
+ .seq = seq70, .seq_size = LWS_ARRAY_SIZE(seq70) },
+ { .b = test71, .blen = sizeof(test71),
+ .seq = seq71, .seq_size = LWS_ARRAY_SIZE(seq71) },
+ { .b = test72, .blen = sizeof(test72),
+ .seq = seq72, .seq_size = LWS_ARRAY_SIZE(seq72) },
+ { .b = test73, .blen = sizeof(test73),
+ .seq = seq73, .seq_size = LWS_ARRAY_SIZE(seq73) },
+ { .b = test74, .blen = sizeof(test74),
+ .seq = seq74, .seq_size = LWS_ARRAY_SIZE(seq74) },
+ { .b = test75, .blen = sizeof(test75),
+ .seq = seq75, .seq_size = LWS_ARRAY_SIZE(seq75) },
+ { .b = test76, .blen = sizeof(test76),
+ .seq = seq76, .seq_size = LWS_ARRAY_SIZE(seq76) },
+ { .b = test77, .blen = sizeof(test77),
+ .seq = seq77, .seq_size = LWS_ARRAY_SIZE(seq77) },
+ { .b = test78, .blen = sizeof(test78),
+ .seq = seq78, .seq_size = LWS_ARRAY_SIZE(seq78) },
+ { .b = test79, .blen = sizeof(test79),
+ .seq = seq79, .seq_size = LWS_ARRAY_SIZE(seq79) },
+ { .b = test80, .blen = sizeof(test80),
+ .seq = seq80, .seq_size = LWS_ARRAY_SIZE(seq80) },
+ { .b = test81, .blen = sizeof(test81),
+ .seq = seq81, .seq_size = LWS_ARRAY_SIZE(seq81) },
+ { .b = test82, .blen = sizeof(test82),
+ .seq = seq82, .seq_size = LWS_ARRAY_SIZE(seq82) },
+
+ /* COSE-dervied test vectors */
+
+ { .b = test83, .blen = sizeof(test83),
+ .seq = seq83, .seq_size = LWS_ARRAY_SIZE(seq83) },
+ { .b = test84, .blen = sizeof(test84),
+ .seq = seq84, .seq_size = LWS_ARRAY_SIZE(seq84) },
+ { .b = test85, .blen = sizeof(test85),
+ .seq = seq85, .seq_size = LWS_ARRAY_SIZE(seq85) },
+ { .b = test86, .blen = sizeof(test86),
+ .seq = seq86, .seq_size = LWS_ARRAY_SIZE(seq86) },
+ { .b = test87, .blen = sizeof(test87),
+ .seq = seq87, .seq_size = LWS_ARRAY_SIZE(seq87) },
+ { .b = test88, .blen = sizeof(test88),
+ .seq = seq88, .seq_size = LWS_ARRAY_SIZE(seq88) },
+ { .b = test89, .blen = sizeof(test89),
+ .seq = seq89, .seq_size = LWS_ARRAY_SIZE(seq89) },
+ { .b = test90, .blen = sizeof(test90),
+ .seq = seq90, .seq_size = LWS_ARRAY_SIZE(seq90) },
+ { .b = test91, .blen = sizeof(test91),
+ .seq = seq91, .seq_size = LWS_ARRAY_SIZE(seq91) },
+ { .b = test92, .blen = sizeof(test92),
+ .seq = seq92, .seq_size = LWS_ARRAY_SIZE(seq92) },
+ { .b = test93, .blen = sizeof(test93),
+ .seq = seq93, .seq_size = LWS_ARRAY_SIZE(seq93) },
+ { .b = test94, .blen = sizeof(test94),
+ .seq = seq94, .seq_size = LWS_ARRAY_SIZE(seq94) },
+ { .b = test95, .blen = sizeof(test95),
+ .seq = seq95, .seq_size = LWS_ARRAY_SIZE(seq95) },
+ { .b = test96, .blen = sizeof(test96),
+ .seq = seq96, .seq_size = LWS_ARRAY_SIZE(seq96) },
+ { .b = test97, .blen = sizeof(test97),
+ .seq = seq97, .seq_size = LWS_ARRAY_SIZE(seq97) },
+ { .b = test98, .blen = sizeof(test98),
+ .seq = seq98, .seq_size = LWS_ARRAY_SIZE(seq98) },
+ { .b = test99, .blen = sizeof(test99),
+ .seq = seq99, .seq_size = LWS_ARRAY_SIZE(seq99) },
+ { .b = test100, .blen = sizeof(test100),
+ .seq = seq100, .seq_size = LWS_ARRAY_SIZE(seq100) },
+ { .b = test101, .blen = sizeof(test101),
+ .seq = seq101, .seq_size = LWS_ARRAY_SIZE(seq101) },
+ { .b = test102, .blen = sizeof(test102),
+ .seq = seq102, .seq_size = LWS_ARRAY_SIZE(seq102) },
+ { .b = test103, .blen = sizeof(test103),
+ .seq = seq103, .seq_size = LWS_ARRAY_SIZE(seq103) },
+ { .b = test104, .blen = sizeof(test104),
+ .seq = seq104, .seq_size = LWS_ARRAY_SIZE(seq104) },
+ { .b = test105, .blen = sizeof(test105),
+ .seq = seq105, .seq_size = LWS_ARRAY_SIZE(seq105) },
+ { .b = test106, .blen = sizeof(test106),
+ .seq = seq106, .seq_size = LWS_ARRAY_SIZE(seq106) },
+ { .b = test107, .blen = sizeof(test107),
+ .seq = seq107, .seq_size = LWS_ARRAY_SIZE(seq107) },
+ { .b = test108, .blen = sizeof(test108),
+ .seq = seq108, .seq_size = LWS_ARRAY_SIZE(seq108) },
+};
+
+static const uint8_t
+ w1[] = { 0x65, 0x68, 0x65, 0x6C,
+ 0x6C, 0x6F },
+ w2[] = { 0xc2 },
+ w3[] = { 0x82, 0x63, 0x61, 0x62,
+ 0x63, 0x63, 0x64, 0x65,
+ 0x66 },
+ w4[] = { 0xA2, 0x63, 0x67, 0x68,
+ 0x69, 0x01, 0x63, 0x6A,
+ 0x6B, 0x6C, 0x02 },
+ w5[] = { 0xD8, 0x7B, 0xA2, 0x63,
+ 0x67, 0x68, 0x69, 0x01,
+ 0x63, 0x6A, 0x6B, 0x6C,
+ 0x02 },
+ w6[] = { 0xCC, 0xA2, 0x63, 0x67,
+ 0x68, 0x69, 0x01, 0x63,
+ 0x6A, 0x6B, 0x6C, 0x82,
+ 0x61, 0x61, 0x61, 0x62 },
+ w7[] = { 0x20, },
+ w8[] = { 0x0c, },
+ w13[] = { 0x18, 0x34 },
+ w14[] = { 0x19, 0x12, 0x34 },
+ w15[] = { 0x1a, 0x12, 0x34, 0x56, 0x78 },
+ w16[] = { 0x1b, 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0 },
+ w17[] = { 0x65, 0x68, 0x65, 0x6C, 0x6C, 0x6F },
+ w18[] = { 0x25 },
+ w19[] = {
+ 0xd8, 0x7b, 0x58, 0xb7,
+ 0xd8, 0x62, 0x84, 0x43, 0xa1,
+ 0x03, 0x00, 0xa1, 0x07, 0x83,
+ 0x43, 0xa1, 0x01, 0x27, 0xa1,
+ 0x04, 0x42, 0x31, 0x31, 0x58,
+ 0x40, 0xb7, 0xca, 0xcb, 0xa2,
+ 0x85, 0xc4, 0xcd, 0x3e, 0xd2,
+ 0xf0, 0x14, 0x6f, 0x41, 0x98,
+ 0x86, 0x14, 0x4c, 0xa6, 0x38,
+ 0xd0, 0x87, 0xde, 0x12, 0x3d,
+ 0x40, 0x01, 0x67, 0x30, 0x8a,
+ 0xce, 0xab, 0xc4, 0xb5, 0xe5,
+ 0xc6, 0xa4, 0x0c, 0x0d, 0xe0,
+ },
+ w19a[] = {
+ 0xb7, 0x11, 0x67, 0xa3, 0x91,
+ 0x75, 0xea, 0x56, 0xc1, 0xfe,
+ 0x96, 0xc8, 0x9e, 0x5e, 0x7d,
+ 0x30, 0xda, 0xf2, 0x43, 0x8a,
+ 0x45, 0x61, 0x59, 0xa2, 0x0a,
+ 0x54, 0x54, 0x68, 0x69, 0x73,
+ 0x20, 0x69, 0x73, 0x20, 0x74,
+ 0x68, 0x65, 0x20, 0x63, 0x6f,
+ 0x6e, 0x74, 0x65, 0x6e, 0x74,
+ 0x2e, 0x81, 0x83, 0x43, 0xa1,
+ 0x01, 0x27, 0xa1, 0x04, 0x42,
+ 0x31, 0x31, 0x58, 0x40, 0x77,
+ 0xf3, 0xea, 0xcd, 0x11,},
+ w19b[] = {
+ 0x85, 0x2c, 0x4b, 0xf9, 0xcb, 0x1d,
+ 0x72, 0xfa, 0xbe, 0x6b, 0x26,
+ 0xfb, 0xa1, 0xd7, 0x60, 0x92,
+ 0xb2, 0xb5, 0xb7, 0xec, 0x83,
+ 0xb8, 0x35, 0x57, 0x65, 0x22,
+ 0x64, 0xe6, 0x96, 0x90, 0xdb,
+ 0xc1, 0x17, 0x2d, 0xdc, 0x0b,
+ 0xf8, 0x84, 0x11, 0xc0, 0xd2,
+ 0x5a, 0x50, 0x7f, 0xdb, 0x24,
+ 0x7a, 0x20, 0xc4, 0x0d, 0x5e,
+ 0x24, 0x5f, 0xab, 0xd3, 0xfc,
+ 0x9e, 0xc1, 0x06 },
+ w22[] = { 0xD8, 0x7B, 0x19, 0x01, 0xC8 },
+ w24[] = { 0xDB, 0x12, 0x34, 0x56, 0x78, 0x9A,
+ 0xBC, 0xED, 0xF0, 0x19, 0x01, 0xC8},
+ w25[] = { 0xF9, 0x3C, 0x00 },
+ w26[] = { 0xF9, 0x3E, 0x00 },
+ w27[] = { 0xFB, 0x3F, 0xF1, 0xF7, 0xCE, 0xD9, 0x16, 0x87, 0x2B },
+ w28[] = { 0xA2, 0x61, 0x61, 0x01, 0x61, 0x62, 0x82, 0x02, 0x03 },
+ w29[] = { 0x7F, 0x65, 0x68, 0x65, 0x6C, 0x6C, 0x6F, 0xFF
+}
+;
+
+static const char * const tok[] = {
+ "something",
+};
+
+struct priv {
+ const struct cbort *cbt;
+ size_t idx;
+};
+
+static int pass;
+
+static signed char
+test_cb(struct lecp_ctx *ctx, char reason)
+{
+ struct priv *priv = (struct priv *)ctx->user;
+ size_t i = priv->idx++;
+
+#if defined(VERBOSE)
+ lwsl_notice("%s: %s, ctx->path %s\n", __func__,
+ reason_names[(int)reason & 0x1f], ctx->path);
+#endif
+
+ // if (ctx->npos)
+ // lwsl_hexdump_notice(ctx->buf, ctx->npos);
+
+ if (!priv->cbt->seq)
+ return 0;
+
+ if (i >= priv->cbt->seq_size) {
+ lwsl_warn("%s: unexpected parse states\n", __func__);
+ return 1;
+ }
+
+ if (priv->cbt->seq[i].reason != reason) {
+ lwsl_warn("%s: reason mismatch\n", __func__);
+ return 1;
+ }
+
+ if (priv->cbt->seq[i].buf &&
+ (priv->cbt->seq[i].buf_len != ctx->npos ||
+ memcmp(priv->cbt->seq[i].buf, ctx->buf, ctx->npos))) {
+ lwsl_warn("%s: buf mismatch\n", __func__);
+ lwsl_hexdump_notice(ctx->buf, (size_t)ctx->npos);
+ return 1;
+ }
+
+ switch (reason) {
+ case LECPCB_VAL_SIMPLE:
+ case LECPCB_VAL_NUM_UINT:
+ case LECPCB_VAL_NUM_INT:
+ if (ctx->item.u.u64 != priv->cbt->seq[i].item.u.u64) {
+ lwsl_warn("%s: number mismatch %llu %llu\n", __func__,
+ (unsigned long long)ctx->item.u.u64,
+ (unsigned long long)priv->cbt->seq[i].item.u.u64);
+ return 1;
+ }
+ break;
+
+ case LECPCB_VAL_FLOAT16:
+ if (ctx->item.u.hf != priv->cbt->seq[i].item.u.hf) {
+ lwsl_warn("%s: number mismatch %llu %llu\n", __func__,
+ (unsigned long long)ctx->item.u.hf,
+ (unsigned long long)priv->cbt->seq[i].item.u.hf);
+ return 1;
+ }
+ break;
+ case LECPCB_VAL_FLOAT32:
+#if defined(LWS_WITH_CBOR_FLOAT)
+ if (!isfinite(ctx->item.u.f) &&
+ !isfinite(priv->cbt->seq[i].item.u.f))
+ break;
+ if (isnan(ctx->item.u.f) &&
+ isnan(priv->cbt->seq[i].item.u.f))
+ break;
+#endif
+ if (ctx->item.u.f != priv->cbt->seq[i].item.u.f) {
+#if defined(LWS_WITH_CBOR_FLOAT)
+ lwsl_warn("%s: number mismatch %f %f\n", __func__,
+ ctx->item.u.f,
+ priv->cbt->seq[i].item.u.f);
+#else
+ lwsl_warn("%s: f32 number mismatch %llu %llu\n", __func__,
+ (unsigned long long)ctx->item.u.f,
+ (unsigned long long)priv->cbt->seq[i].item.u.f);
+#endif
+ return 1;
+ }
+ break;
+ case LECPCB_VAL_FLOAT64:
+#if defined(LWS_WITH_CBOR_FLOAT)
+ if (!isfinite(ctx->item.u.d) &&
+ !isfinite(priv->cbt->seq[i].item.u.d))
+ break;
+ if (isnan(ctx->item.u.d) &&
+ isnan(priv->cbt->seq[i].item.u.d))
+ break;
+#endif
+ if (ctx->item.u.d != priv->cbt->seq[i].item.u.d) {
+#if defined(LWS_WITH_CBOR_FLOAT)
+ lwsl_warn("%s: f64 number mismatch %f %f\n", __func__,
+ ctx->item.u.d,
+ priv->cbt->seq[i].item.u.d);
+#else
+ lwsl_warn("%s: number mismatch %llu %llu\n", __func__,
+ (unsigned long long)ctx->item.u.d,
+ (unsigned long long)priv->cbt->seq[i].item.u.d);
+#endif
+ return 1;
+ }
+ break;
+
+ case LECPCB_DESTRUCTED:
+ pass++;
+ break;
+ }
+
+ return 0;
+}
+
+int main(int argc, const char **argv)
+{
+ int n, m, e = 0, logs = LLL_USER | LLL_ERR | LLL_WARN | LLL_NOTICE,
+ expected = (int)LWS_ARRAY_SIZE(cbor_tests) +
+ 29 /* <-- how many write tests */;
+ struct lecp_ctx ctx;
+ const char *p;
+
+ if ((p = lws_cmdline_option(argc, argv, "-d")))
+ logs = atoi(p);
+
+ lws_set_log_level(logs, NULL);
+ lwsl_user("LWS API selftest: LECP CBOR parser\n");
+
+ for (m = 0; m < (int)LWS_ARRAY_SIZE(cbor_tests); m++) {
+
+ struct priv priv;
+
+ priv.cbt = &cbor_tests[m];
+ priv.idx = 0;
+
+ lwsl_notice("%s: ++++++++++++++++ test %d\n", __func__, m + 1);
+
+ lecp_construct(&ctx, test_cb, &priv, tok, LWS_ARRAY_SIZE(tok));
+
+ lwsl_hexdump_info(cbor_tests[m].b, cbor_tests[m].blen);
+
+#if 0
+ {
+ char fn[128];
+ int fd;
+
+ lws_snprintf(fn, sizeof(fn), "/tmp/cbor-%d", m + 1);
+ fd = open(fn, LWS_O_CREAT | LWS_O_TRUNC | LWS_O_WRONLY, 0600);
+ if (fd != -1) {
+ write(fd, cbor_tests[m].b,
+ cbor_tests[m].blen);
+ close(fd);
+ }
+ }
+#endif
+
+ n = lecp_parse(&ctx, cbor_tests[m].b,
+ cbor_tests[m].blen);
+
+ lecp_destruct(&ctx);
+
+ if (n < 0 && m + 1 != 46 /* expected to fail */) {
+ lwsl_err("%s: test %d: CBOR decode failed %d '%s'\n",
+ __func__, m + 1, n,
+ lecp_error_to_string(n));
+ e++;
+ }
+ }
+
+ {
+ lws_lec_pctx_t ctx;
+ uint8_t buf[64];
+
+ lws_lec_init(&ctx, buf, sizeof(buf));
+
+ if (lws_lec_printf(&ctx, "'hello'") !=
+ LWS_LECPCTX_RET_FINISHED ||
+ ctx.used != sizeof(w1) || memcmp(w1, buf, ctx.used)) {
+ lwsl_hexdump_notice(ctx.start, ctx.used);
+ e++;
+ } else
+ pass++;
+
+ lws_lec_setbuf(&ctx, buf, sizeof(buf));
+
+ if (lws_lec_printf(&ctx, "2()") !=
+ LWS_LECPCTX_RET_FINISHED ||
+ ctx.used != sizeof(w2) || memcmp(w2, buf, ctx.used)) {
+ lwsl_hexdump_notice(ctx.start, ctx.used);
+ e++;
+ } else
+ pass++;
+
+ lws_lec_setbuf(&ctx, buf, sizeof(buf));
+
+ if (lws_lec_printf(&ctx, "['abc','def']") !=
+ LWS_LECPCTX_RET_FINISHED ||
+ ctx.used != sizeof(w3) || memcmp(w3, buf, ctx.used)) {
+ lwsl_hexdump_notice(ctx.start, ctx.used);
+ e++;
+ } else
+ pass++;
+
+ lwsl_user("%s: test4\n", __func__);
+
+ lws_lec_setbuf(&ctx, buf, sizeof(buf));
+
+ if (lws_lec_printf(&ctx, "{'ghi':1,'jkl':2}") !=
+ LWS_LECPCTX_RET_FINISHED ||
+ ctx.used != sizeof(w4) || memcmp(w4, buf, ctx.used)) {
+ lwsl_hexdump_notice(ctx.start, ctx.used);
+ e++;
+ } else
+ pass++;
+
+ lwsl_user("%s: test5\n", __func__);
+
+ lws_lec_setbuf(&ctx, buf, sizeof(buf));
+
+ if (lws_lec_printf(&ctx, "123({'ghi':1,'jkl':2})") !=
+ LWS_LECPCTX_RET_FINISHED ||
+ ctx.used != sizeof(w5) || memcmp(w5, buf, ctx.used)) {
+ lwsl_hexdump_notice(ctx.start, ctx.used);
+ e++;
+ } else
+ pass++;
+
+ lwsl_user("%s: test6\n", __func__);
+
+ lws_lec_setbuf(&ctx, buf, sizeof(buf));
+
+ if (lws_lec_printf(&ctx, "12({'ghi':1,'jkl':['a', 'b']})") !=
+ LWS_LECPCTX_RET_FINISHED ||
+ ctx.used != sizeof(w6) || memcmp(w6, buf, ctx.used)) {
+ lwsl_hexdump_notice(ctx.start, ctx.used);
+ e++;
+ } else
+ pass++;
+
+ lwsl_user("%s: test7\n", __func__);
+
+ lws_lec_setbuf(&ctx, buf, sizeof(buf));
+
+ if (lws_lec_printf(&ctx, "%d", -1) !=
+ LWS_LECPCTX_RET_FINISHED ||
+ ctx.used != sizeof(w7) || memcmp(w7, buf, ctx.used)) {
+ lwsl_hexdump_notice(ctx.start, ctx.used);
+ e++;
+ } else
+ pass++;
+
+ lwsl_user("%s: test8\n", __func__);
+
+ lws_lec_setbuf(&ctx, buf, sizeof(buf));
+
+ if (lws_lec_printf(&ctx, "%ld", -1l) !=
+ LWS_LECPCTX_RET_FINISHED ||
+ ctx.used != sizeof(w7) || memcmp(w7, buf, ctx.used)) {
+ lwsl_hexdump_notice(ctx.start, ctx.used);
+ e++;
+ } else
+ pass++;
+
+ lwsl_user("%s: test9\n", __func__);
+
+ lws_lec_setbuf(&ctx, buf, sizeof(buf));
+
+ if (lws_lec_printf(&ctx, "%lld", -1ll) !=
+ LWS_LECPCTX_RET_FINISHED ||
+ ctx.used != sizeof(w7) || memcmp(w7, buf, ctx.used)) {
+ lwsl_hexdump_notice(ctx.start, ctx.used);
+ e++;
+ } else
+ pass++;
+
+ lwsl_user("%s: test10\n", __func__);
+
+ lws_lec_setbuf(&ctx, buf, sizeof(buf));
+
+ if (lws_lec_printf(&ctx, "%u", 12) !=
+ LWS_LECPCTX_RET_FINISHED ||
+ ctx.used != sizeof(w8) || memcmp(w8, buf, ctx.used)) {
+ lwsl_hexdump_notice(ctx.start, ctx.used);
+ e++;
+ } else
+ pass++;
+
+ lwsl_user("%s: test11\n", __func__);
+
+ lws_lec_setbuf(&ctx, buf, sizeof(buf));
+
+ if (lws_lec_printf(&ctx, "%ld", 12l) !=
+ LWS_LECPCTX_RET_FINISHED ||
+ ctx.used != sizeof(w8) || memcmp(w8, buf, ctx.used)) {
+ lwsl_hexdump_notice(ctx.start, ctx.used);
+ e++;
+ } else
+ pass++;
+
+ lwsl_user("%s: test12\n", __func__);
+
+ lws_lec_setbuf(&ctx, buf, sizeof(buf));
+
+ if (lws_lec_printf(&ctx, "%lld", 12ll) !=
+ LWS_LECPCTX_RET_FINISHED ||
+ ctx.used != sizeof(w8) || memcmp(w8, buf, ctx.used)) {
+ lwsl_hexdump_notice(ctx.start, ctx.used);
+ e++;
+ } else
+ pass++;
+
+ lwsl_user("%s: test13\n", __func__);
+
+ lws_lec_setbuf(&ctx, buf, sizeof(buf));
+
+ if (lws_lec_printf(&ctx, "%u", 0x34u) !=
+ LWS_LECPCTX_RET_FINISHED ||
+ ctx.used != sizeof(w13) || memcmp(w13, buf, ctx.used)) {
+ lwsl_hexdump_notice(ctx.start, ctx.used);
+ e++;
+ } else
+ pass++;
+
+ lwsl_user("%s: test14\n", __func__);
+
+ lws_lec_setbuf(&ctx, buf, sizeof(buf));
+
+ if (lws_lec_printf(&ctx, "%ld", 0x1234ul) !=
+ LWS_LECPCTX_RET_FINISHED ||
+ ctx.used != sizeof(w14) || memcmp(w14, buf, ctx.used)) {
+ lwsl_hexdump_notice(ctx.start, ctx.used);
+ e++;
+ } else
+ pass++;
+
+ lwsl_user("%s: test15\n", __func__);
+
+ lws_lec_setbuf(&ctx, buf, sizeof(buf));
+
+ if (lws_lec_printf(&ctx, "%lld", 0x12345678ull) !=
+ LWS_LECPCTX_RET_FINISHED ||
+ ctx.used != sizeof(w15) || memcmp(w15, buf, ctx.used)) {
+ lwsl_hexdump_notice(ctx.start, ctx.used);
+ e++;
+ } else
+ pass++;
+
+ lwsl_user("%s: test16\n", __func__);
+
+ lws_lec_setbuf(&ctx, buf, sizeof(buf));
+
+ if (lws_lec_printf(&ctx, "%lld", 0x123456789abcdef0ull) !=
+ LWS_LECPCTX_RET_FINISHED ||
+ ctx.used != sizeof(w16) || memcmp(w16, buf, ctx.used)) {
+ lwsl_hexdump_notice(ctx.start, ctx.used);
+ e++;
+ } else
+ pass++;
+
+ lwsl_user("%s: test17\n", __func__);
+ lws_lec_setbuf(&ctx, buf, sizeof(buf));
+
+ if (lws_lec_printf(&ctx, "%s", "hello") !=
+ LWS_LECPCTX_RET_FINISHED ||
+ ctx.used != sizeof(w17) || memcmp(w17, buf, ctx.used)) {
+ lwsl_hexdump_notice(ctx.start, ctx.used);
+ e++;
+ } else
+ pass++;
+
+ lwsl_user("%s: test18\n", __func__);
+ lws_lec_setbuf(&ctx, buf, sizeof(buf));
+
+ if (lws_lec_printf(&ctx, "-6") !=
+ LWS_LECPCTX_RET_FINISHED ||
+ ctx.used != sizeof(w18) || memcmp(w18, buf, ctx.used)) {
+ lwsl_hexdump_notice(ctx.start, ctx.used);
+ e++;
+ } else
+ pass++;
+
+ /*
+ * A big binary blob is going to get emitted in 3 output
+ * buffers, by calling it two more times while still handling
+ * the same format object, format objects before that which
+ * were completed are skipped on the subsequent calls
+ */
+
+ lwsl_user("%s: test19\n", __func__);
+ lws_lec_setbuf(&ctx, buf, sizeof(buf));
+
+ if (lws_lec_printf(&ctx, "123(%.*b)", (int)sizeof(test106), test106) !=
+ LWS_LECPCTX_RET_AGAIN ||
+ ctx.used != sizeof(w19) || memcmp(w19, buf, ctx.used)) {
+ lwsl_hexdump_notice(ctx.start, ctx.used);
+ e++;
+ } else
+ pass++;
+
+ lwsl_user("%s: test20\n", __func__);
+ lws_lec_setbuf(&ctx, buf, sizeof(buf));
+
+ if (lws_lec_printf(&ctx, "123(%.*b)", (int)sizeof(test106), test106) !=
+ LWS_LECPCTX_RET_AGAIN ||
+ ctx.used != sizeof(w19a) || memcmp(w19a, buf, ctx.used)) {
+ lwsl_hexdump_notice(ctx.start, ctx.used);
+ e++;
+ } else
+ pass++;
+
+ lwsl_user("%s: test21\n", __func__);
+ lws_lec_setbuf(&ctx, buf, sizeof(buf));
+
+ if (lws_lec_printf(&ctx, "123(%.*b)", (int)sizeof(test106), test106) !=
+ LWS_LECPCTX_RET_FINISHED ||
+ ctx.used != sizeof(w19b) || memcmp(w19b, buf, ctx.used)) {
+ lwsl_hexdump_notice(ctx.start, ctx.used);
+ e++;
+ } else
+ pass++;
+
+ lwsl_user("%s: test22\n", __func__);
+ lws_lec_setbuf(&ctx, buf, sizeof(buf));
+
+ if (lws_lec_printf(&ctx, "%t(456)", 123) !=
+ LWS_LECPCTX_RET_FINISHED ||
+ ctx.used != sizeof(w22) || memcmp(w22, buf, ctx.used)) {
+ lwsl_hexdump_notice(ctx.start, ctx.used);
+ e++;
+ } else
+ pass++;
+
+ lwsl_user("%s: test23\n", __func__);
+ lws_lec_setbuf(&ctx, buf, sizeof(buf));
+
+ if (lws_lec_printf(&ctx, "%lt(456)", 123ul) !=
+ LWS_LECPCTX_RET_FINISHED ||
+ ctx.used != sizeof(w22) || memcmp(w22, buf, ctx.used)) {
+ lwsl_hexdump_notice(ctx.start, ctx.used);
+ e++;
+ } else
+ pass++;
+
+ lwsl_user("%s: test24\n", __func__);
+ lws_lec_setbuf(&ctx, buf, sizeof(buf));
+
+ if (lws_lec_printf(&ctx, "%llt(456)", 0x123456789abcedf0ull) !=
+ LWS_LECPCTX_RET_FINISHED ||
+ ctx.used != sizeof(w24) || memcmp(w24, buf, ctx.used)) {
+ lwsl_hexdump_notice(ctx.start, ctx.used);
+ e++;
+ } else
+ pass++;
+
+ lwsl_user("%s: test25\n", __func__);
+ lws_lec_setbuf(&ctx, buf, sizeof(buf));
+
+ if (lws_lec_printf(&ctx, "%f", 1.0) !=
+ LWS_LECPCTX_RET_FINISHED ||
+ ctx.used != sizeof(w25) || memcmp(w25, buf, ctx.used)) {
+ lwsl_hexdump_notice(ctx.start, ctx.used);
+ e++;
+ } else
+ pass++;
+
+ lwsl_user("%s: test26\n", __func__);
+ lws_lec_setbuf(&ctx, buf, sizeof(buf));
+
+ if (lws_lec_printf(&ctx, "%f", 1.5) !=
+ LWS_LECPCTX_RET_FINISHED ||
+ ctx.used != sizeof(w26) || memcmp(w26, buf, ctx.used)) {
+ lwsl_hexdump_notice(ctx.start, ctx.used);
+ e++;
+ } else
+ pass++;
+
+ lwsl_user("%s: test27\n", __func__);
+ lws_lec_setbuf(&ctx, buf, sizeof(buf));
+
+ if (lws_lec_printf(&ctx, "%f", 1.123) !=
+ LWS_LECPCTX_RET_FINISHED ||
+ ctx.used != sizeof(w27) || memcmp(w27, buf, ctx.used)) {
+ lwsl_hexdump_notice(ctx.start, ctx.used);
+ e++;
+ } else
+ pass++;
+
+ {
+ int args[3] = { 1, 2, 3 };
+
+ lwsl_user("%s: test28\n", __func__);
+ lws_lec_setbuf(&ctx, buf, sizeof(buf));
+
+ if (lws_lec_printf(&ctx, "{'a':%d,'b':[%d,%d]}",
+ args[0], args[1], args[2]) !=
+ LWS_LECPCTX_RET_FINISHED ||
+ ctx.used != sizeof(w28) ||
+ memcmp(w28, buf, ctx.used)) {
+ lwsl_hexdump_notice(ctx.start, ctx.used);
+ e++;
+ } else
+ pass++;
+ }
+
+ lwsl_user("%s: test29\n", __func__);
+ lws_lec_setbuf(&ctx, buf, sizeof(buf));
+
+ if (lws_lec_printf(&ctx, "<t'hello'>") !=
+ LWS_LECPCTX_RET_FINISHED ||
+ ctx.used != sizeof(w29) || memcmp(w29, buf, ctx.used)) {
+ lwsl_hexdump_notice(ctx.start, ctx.used);
+ e++;
+ } else
+ pass++;
+ }
+
+ if (e)
+ goto bail;
+
+ if (pass != expected)
+ goto bail;
+
+ lwsl_user("Completed: PASS %d / %d\n", pass, expected);
+
+ return 0;
+
+bail:
+ lwsl_user("Completed: FAIL, passed %d / %d (e %d)\n", pass,
+ expected, e);
+
+ return 1;
+}
diff --git a/test-apps/CMakeLists.txt b/test-apps/CMakeLists.txt
index cb3c980..9ffed9f 100644
--- a/test-apps/CMakeLists.txt
+++ b/test-apps/CMakeLists.txt
@@ -185,6 +185,19 @@
target_compile_definitions(test-lejp PRIVATE LWS_BUILDING_STATIC)
endif()
+ if (LWS_WITH_CBOR)
+ create_test_app(
+ test-lecp
+ "test-lecp.c"
+ ""
+ ""
+ ""
+ ""
+ "")
+ target_compile_definitions(test-lecp PRIVATE LWS_BUILDING_STATIC)
+ endif()
+
+
# Data files for running the test server.
list(APPEND TEST_SERVER_DATA
"${PROJECT_SOURCE_DIR}/test-apps/favicon.ico"
diff --git a/test-apps/test-lecp.c b/test-apps/test-lecp.c
new file mode 100644
index 0000000..f10f0d2
--- /dev/null
+++ b/test-apps/test-lecp.c
@@ -0,0 +1,170 @@
+/*
+ * lejp test app
+ *
+ * Written in 2010-2019 by Andy Green <andy@warmcat.com>
+ *
+ * This file is made available under the Creative Commons CC0 1.0
+ * Universal Public Domain Dedication.
+ *
+ * This demonstrates a minimal http server that performs a form GET with a couple
+ * of parameters. It dumps the parameters to the console log and redirects
+ * to another page.
+ */
+
+#include <libwebsockets.h>
+#include <string.h>
+
+
+static const char * const reason_names[] = {
+ "LECPCB_CONSTRUCTED",
+ "LECPCB_DESTRUCTED",
+ "LECPCB_START",
+ "LECPCB_COMPLETE",
+ "LECPCB_FAILED",
+ "LECPCB_PAIR_NAME",
+ "LECPCB_VAL_TRUE",
+ "LECPCB_VAL_FALSE",
+ "LECPCB_VAL_NULL",
+ "LECPCB_VAL_NUM_INT",
+ "LECPCB_VAL_RESERVED", /* float in lejp */
+ "LECPCB_VAL_STR_START",
+ "LECPCB_VAL_STR_CHUNK",
+ "LECPCB_VAL_STR_END",
+ "LECPCB_ARRAY_START",
+ "LECPCB_ARRAY_END",
+ "LECPCB_OBJECT_START",
+ "LECPCB_OBJECT_END",
+ "LECPCB_TAG_START",
+ "LECPCB_TAG_END",
+ "LECPCB_VAL_NUM_UINT",
+ "LECPCB_VAL_UNDEFINED",
+ "LECPCB_VAL_FLOAT16",
+ "LECPCB_VAL_FLOAT32",
+ "LECPCB_VAL_FLOAT64",
+ "LECPCB_VAL_SIMPLE",
+ "LECPCB_VAL_BLOB_START",
+ "LECPCB_VAL_BLOB_CHUNK",
+ "LECPCB_VAL_BLOB_END",
+};
+
+static const char * const tok[] = {
+ "dummy___"
+};
+
+static signed char
+cb(struct lecp_ctx *ctx, char reason)
+{
+ char buf[1024], *p = buf, *end = &buf[sizeof(buf)];
+ int n;
+
+ for (n = 0; n < ctx->sp; n++)
+ *p++ = ' ';
+ *p = '\0';
+
+ lwsl_notice("%s%s: path %s match %d statckp %d\r\n", buf,
+ reason_names[(unsigned int)(reason) &
+ (LEJP_FLAG_CB_IS_VALUE - 1)], ctx->path,
+ ctx->path_match, ctx->pst[ctx->pst_sp].ppos);
+
+ if (reason & LECP_FLAG_CB_IS_VALUE) {
+
+ switch (reason) {
+ case LECPCB_VAL_NUM_UINT:
+ p += lws_snprintf(p, lws_ptr_diff_size_t(end, p),
+ " value %llu ",
+ (unsigned long long)ctx->item.u.u64);
+ break;
+ case LECPCB_VAL_STR_START:
+ case LECPCB_VAL_STR_CHUNK:
+ case LECPCB_VAL_STR_END:
+ p += lws_snprintf(p, lws_ptr_diff_size_t(end, p),
+ " value '%s' ", ctx->buf);
+ break;
+
+ case LECPCB_VAL_BLOB_START:
+ case LECPCB_VAL_BLOB_CHUNK:
+ case LECPCB_VAL_BLOB_END:
+ if (ctx->npos)
+ lwsl_hexdump_notice(ctx->buf, (size_t)ctx->npos);
+ break;
+
+ case LECPCB_VAL_NUM_INT:
+ p += lws_snprintf(p, lws_ptr_diff_size_t(end, p),
+ " value %lld ",
+ (long long)ctx->item.u.i64);
+ break;
+ case LECPCB_VAL_FLOAT16:
+ case LECPCB_VAL_FLOAT32:
+ case LECPCB_VAL_FLOAT64:
+ break;
+
+ case LECPCB_VAL_SIMPLE:
+ p += lws_snprintf(p, lws_ptr_diff_size_t(end, p),
+ " simple %llu ",
+ (unsigned long long)ctx->item.u.u64);
+ break;
+ }
+ if (ctx->ipos) {
+ int n;
+
+ p += lws_snprintf(p, lws_ptr_diff_size_t(end, p), "(array indexes: ");
+ for (n = 0; n < ctx->ipos; n++)
+ p += lws_snprintf(p, lws_ptr_diff_size_t(end, p), "%d ", ctx->i[n]);
+ p += lws_snprintf(p, lws_ptr_diff_size_t(end, p), ") ");
+ }
+
+ lwsl_notice("%s \r\n", buf);
+
+ (void)reason_names; /* NO_LOGS... */
+ return 0;
+ }
+
+ switch (reason) {
+ case LECPCB_COMPLETE:
+ lwsl_notice("%sParsing Completed (LEJPCB_COMPLETE)\n", buf);
+ break;
+ case LECPCB_PAIR_NAME:
+ lwsl_notice("%spath: '%s' (LEJPCB_PAIR_NAME)\n", buf, ctx->path);
+ break;
+ case LECPCB_TAG_START:
+ lwsl_notice("LECPCB_TAG_START: %llu\r\n", (unsigned long long)ctx->item.u.u64);
+ return 0;
+ }
+
+ return 0;
+}
+
+int
+main(int argc, char *argv[])
+{
+ int fd, n = 1, ret = 1, m = 0;
+ struct lecp_ctx ctx;
+ char buf[128];
+
+ lws_set_log_level(7, NULL);
+
+ lwsl_notice("libwebsockets-test-lecp (C) 2017 - 2021 andy@warmcat.com\n");
+ lwsl_notice(" usage: cat my.cbor | libwebsockets-test-lecp\n\n");
+
+ lecp_construct(&ctx, cb, NULL, tok, LWS_ARRAY_SIZE(tok));
+
+ fd = 0;
+
+ while (n > 0) {
+ n = (int)read(fd, buf, sizeof(buf));
+ if (n <= 0)
+ continue;
+
+ m = lecp_parse(&ctx, (uint8_t *)buf, (size_t)n);
+ if (m < 0 && m != LEJP_CONTINUE) {
+ lwsl_err("parse failed %d\n", m);
+ goto bail;
+ }
+ }
+ lwsl_notice("okay (%d)\n", m);
+ ret = 0;
+bail:
+ lecp_destruct(&ctx);
+
+ return ret;
+}
