if (LOG_ENABLED) {

log_depth =0;

printf("\n");

printf("| %-*s | %-*s | %-*s | %-*s |%-*s |Detail |\n", LOG_EVENT_LEN,"Event", LOG_BUFFER_LEN,"Buffer", LOG_SMALL_BUFFER_LEN,"Next",5,"Next#",5,"Tape#");

printf("|%.*s|%.*s|%.*s|%.*s|%.*s|--------|\n", LOG_EVENT_LEN+2, DASHES, LOG_BUFFER_LEN+2, DASHES, LOG_SMALL_BUFFER_LEN+2, DASHES,5+2, DASHES,5+2, DASHES);

printf("| %-*s | %-*s | %-*s | %-*s | Detail |\n", LOG_EVENT_LEN,"Event", LOG_BUFFER_LEN,"Buffer", LOG_SMALL_BUFFER_LEN,"Next",5,"Next#");

printf("|%.*s|%.*s|%.*s|%.*s|--------|\n", LOG_EVENT_LEN+2, DASHES, LOG_BUFFER_LEN+2, DASHES, LOG_SMALL_BUFFER_LEN+2, DASHES,5+2, DASHES);

}

}

}else {

printf("| %-*s", LOG_INDEX_LEN,"");

}

printf("| %*u", LOG_INDEX_LEN, structurals.next_tape_index());

printf("| %-s", detail);

printf("|\n");

}

#include"generic/stage2/tape_writer.h"

#include"generic/stage2/logger.h"

#include"generic/stage2/atomparsing.h"

#include"generic/stage2/structural_iterator.h"

namespace {// Make everything here private

namespaceSIMDJSON_IMPLEMENTATION {

namespacestage2 {

#defineSIMDJSON_TRY(EXPR) {auto _err = (EXPR);if (_err) {return _err; } }

template<typename T>

structstructural_parser : structural_iterator {

tape_writer tape;

uint8_t *current_string_buf_loc;

T builder;

uint32_t depth{0};

really_inlinestructural_parser(dom_parser_implementation &_parser,uint32_t start_structural_index)

: structural_iterator(_parser, start_structural_index),

tape{parser.doc->tape.get()},

current_string_buf_loc{parser.doc->string_buf.get()} {

}

WARN_UNUSED really_inline error_codestart_scope(bool is_array) {

depth++;

if (depth >= parser.max_depth()) {log_error("Exceeded max depth!");return DEPTH_ERROR; }

parser.containing_scope[depth].tape_index =next_tape_index();

parser.containing_scope[depth].count =0;

tape.skip();// We don't actually *write* the start element until the end.

parser.is_array[depth] = is_array;

return SUCCESS;

builder{parser.doc->tape.get(), parser.doc->string_buf.get()} {

}

WARN_UNUSED really_inline error_codestart_document() {

log_start_value("document");

parser.containing_scope[depth].tape_index =next_tape_index();

parser.containing_scope[depth].count =0;

tape.skip();// We don't actually *write* the start element until the end.

builder.start_document(*this);

parser.is_array[depth] =false;

return SUCCESS;

}

WARN_UNUSED really_inline error_codestart_object() {

log_start_value("object");

returnstart_scope(false);

depth++;

if (depth >= parser.max_depth()) {log_error("Exceeded max depth!");return DEPTH_ERROR; }

builder.start_object(*this);

parser.is_array[depth] =false;

return SUCCESS;

}

WARN_UNUSED really_inline error_codestart_array() {

log_start_value("array");

returnstart_scope(true);

}

really_inlinevoidend_scope(internal::tape_type start, internal::tape_type end)noexcept {

constuint32_t start_tape_index = parser.containing_scope[depth].tape_index;

tape.append(start_tape_index, end);

constuint32_t count = parser.containing_scope[depth].count;

constuint32_t cntsat = count >0xFFFFFF ?0xFFFFFF : count;

tape_writer::write(parser.doc->tape[start_tape_index],next_tape_index() | (uint64_t(cntsat) <<32), start);

depth--;

}

really_inlineuint32_tnext_tape_index() {

returnuint32_t(tape.next_tape_loc - parser.doc->tape.get());

depth++;

if (depth >= parser.max_depth()) {log_error("Exceeded max depth!");return DEPTH_ERROR; }

builder.start_array(*this);

parser.is_array[depth] =true;

return SUCCESS;

}

really_inlinevoidend_object() {

log_end_value("object");

end_scope(internal::tape_type::START_OBJECT, internal::tape_type::END_OBJECT);

builder.end_object(*this);

depth--;

}

really_inlinevoidend_array() {

log_end_value("array");

end_scope(internal::tape_type::START_ARRAY, internal::tape_type::END_ARRAY);

builder.end_array(*this);

depth--;

}

really_inlinevoidend_document() {

log_end_value("document");

constexpruint32_t start_tape_index =0;

tape.append(start_tape_index, internal::tape_type::ROOT);

tape_writer::write(parser.doc->tape[start_tape_index],next_tape_index(), internal::tape_type::ROOT);

builder.end_document(*this);

}

really_inlinevoidempty_container(internal::tape_type start, internal::tape_type end) {

auto start_index =next_tape_index();

tape.append(start_index+2, start);

tape.append(start_index, end);

}

WARN_UNUSED really_inlineboolempty_object() {

if (peek_next_char() =='}') {

advance_char();

log_value("empty object");

empty_container(internal::tape_type::START_OBJECT, internal::tape_type::END_OBJECT);

builder.empty_object(*this);

returntrue;

}

returnfalse;

}

WARN_UNUSED really_inlineboolempty_array() {

if (peek_next_char() ==']') {

advance_char();

log_value("empty array");

empty_container(internal::tape_type::START_ARRAY, internal::tape_type::END_ARRAY);

builder.empty_array(*this);

returntrue;

}

returnfalse;

}

really_inlinevoidincrement_count() {

parser.containing_scope[depth].count++;// we have a key value pair in the object at parser.depth - 1

}

really_inlineuint8_t *on_start_string()noexcept {

tape.append(current_string_buf_loc - parser.doc->string_buf.get(), internal::tape_type::STRING);

return current_string_buf_loc +sizeof(uint32_t);

}

really_inlinevoidon_end_string(uint8_t *dst)noexcept {

uint32_t str_length =uint32_t(dst - (current_string_buf_loc +sizeof(uint32_t)));

memcpy(current_string_buf_loc, &str_length,sizeof(uint32_t));

*dst =0;

current_string_buf_loc = dst +1;

builder.increment_count(*this);

}

WARN_UNUSED really_inline error_codeparse_key(constuint8_t *key) {

returnparse_string(key,true);

}

WARN_UNUSED really_inline error_codeparse_string(constuint8_t *value,bool key =false) {

log_value(key ?"key" :"string");

uint8_t *dst =on_start_string();

dst =stringparsing::parse_string(value, dst);

if (dst ==nullptr) {

log_error("Invalid escape in string");

return STRING_ERROR;

}

on_end_string(dst);

return SUCCESS;

return builder.parse_key(*this, key);

}

WARN_UNUSED really_inline error_codeparse_string(constuint8_t *value) {

return builder.parse_string(*this, value);

}

WARN_UNUSED really_inline error_codeparse_number(constuint8_t *value) {

log_value("number");

if (!numberparsing::parse_number(value, tape)) {log_error("Invalid number");return NUMBER_ERROR; }

return SUCCESS;

return builder.parse_number(*this, value);

}

really_inline error_codeparse_root_number(constuint8_t *value) {

uint8_t *copy =static_cast<uint8_t *>(malloc(remaining_len() + SIMDJSON_PADDING));

if (copy ==nullptr) {

return MEMALLOC;

}

memcpy(copy, value,remaining_len());

memset(copy +remaining_len(),'', SIMDJSON_PADDING);

error_code error =parse_number(copy);

free(copy);

return error;

WARN_UNUSED really_inline error_codeparse_root_number(constuint8_t *value) {

return builder.parse_root_number(*this, value);

}

WARN_UNUSED really_inline error_codeparse_true_atom(constuint8_t *value) {

log_value("true");

if (!atomparsing::is_valid_true_atom(value)) {return T_ATOM_ERROR; }

tape.append(0, internal::tape_type::TRUE_VALUE);

return SUCCESS;

return builder.parse_true_atom(*this, value);

}

WARN_UNUSED really_inline error_codeparse_root_true_atom(constuint8_t *value) {

log_value("true");

if (!atomparsing::is_valid_true_atom(value,remaining_len())) {return T_ATOM_ERROR; }

tape.append(0, internal::tape_type::TRUE_VALUE);

return SUCCESS;

return builder.parse_root_true_atom(*this, value);

}

WARN_UNUSED really_inline error_codeparse_false_atom(constuint8_t *value) {

log_value("false");

if (!atomparsing::is_valid_false_atom(value)) {return F_ATOM_ERROR; }

tape.append(0, internal::tape_type::FALSE_VALUE);

return SUCCESS;

return builder.parse_false_atom(*this, value);

}

WARN_UNUSED really_inline error_codeparse_root_false_atom(constuint8_t *value) {

log_value("false");

if (!atomparsing::is_valid_false_atom(value,remaining_len())) {return F_ATOM_ERROR; }

tape.append(0, internal::tape_type::FALSE_VALUE);

return SUCCESS;

return builder.parse_root_false_atom(*this, value);

}

WARN_UNUSED really_inline error_codeparse_null_atom(constuint8_t *value) {

log_value("null");

if (!atomparsing::is_valid_null_atom(value)) {return N_ATOM_ERROR; }

tape.append(0, internal::tape_type::NULL_VALUE);

return SUCCESS;

return builder.parse_null_atom(*this, value);

}

WARN_UNUSED really_inline error_codeparse_root_null_atom(constuint8_t *value) {

log_value("null");

if (!atomparsing::is_valid_null_atom(value,remaining_len())) {return N_ATOM_ERROR; }

tape.append(0, internal::tape_type::NULL_VALUE);

return SUCCESS;

return builder.parse_root_null_atom(*this, value);

}

WARN_UNUSED really_inline error_codestart() {

}

};// struct structural_parser

#defineSIMDJSON_TRY(EXPR) {auto _err = (EXPR);if (_err) {return _err; } }

}// namespace stage2

}// namespace SIMDJSON_IMPLEMENTATION

}// unnamed namespace

#include"generic/stage2/tape_builder.h"

namespace {// Make everything here private

namespaceSIMDJSON_IMPLEMENTATION {

namespacestage2 {

template<bool STREAMING>

WARN_UNUSEDstatic really_inline error_codeparse_structurals(dom_parser_implementation &dom_parser, dom::document &doc)noexcept {

dom_parser.doc = &doc;

stage2::structural_parserparser(dom_parser, STREAMING ? dom_parser.next_structural_index :0);

stage2::structural_parser<stage2::tape_builder>parser(dom_parser, STREAMING ? dom_parser.next_structural_index :0);

SIMDJSON_TRY( parser.start() );