#include <stdlib.h>
#include "codegen_c.h"
#include "flatcc/flatcc_types.h"
#include "catalog.h"

/* -DFLATCC_PORTABLE may help if inttypes.h is missing. */
#ifndef PRId64
#include <inttypes.h>
#endif

#define PRINTLN_SPMAX 64
static char println_spaces[PRINTLN_SPMAX];

static void println(fb_output_t *out, const char * format, ...)
{
    int i = out->indent * out->opts->cgen_spacing;
    va_list ap;

    if (println_spaces[0] == 0) {
        memset(println_spaces, 0x20, PRINTLN_SPMAX);
    }
    /* Don't indent on blank lines. */
    if (*format) {
        while (i > PRINTLN_SPMAX) {
            fprintf(out->fp, "%.*s", (int)PRINTLN_SPMAX, println_spaces);
            i -= PRINTLN_SPMAX;
        }
        /* Use modulo to reset margin if we go too far. */
        fprintf(out->fp, "%.*s", i, println_spaces);
        va_start (ap, format);
        vfprintf (out->fp, format, ap);
        va_end (ap);
    }
    fprintf(out->fp, "\n");
}

/*
 * Unknown fields and unknown union members can be failed
 * rather than ignored with a config flag.
 *
 * Default values an be forced with a config flat.
 *
 * Forward schema isn't perfect: Unknown symbolic constants
 * cannot be used with known fields but will be ignored
 * in ignored fields.
 */

static int gen_json_parser_pretext(fb_output_t *out)
{
    println(out, "#ifndef %s_JSON_PARSER_H", out->S->basenameup);
    println(out, "#define %s_JSON_PARSER_H", out->S->basenameup);
    println(out, "");
    println(out, "/* " FLATCC_GENERATED_BY " */");
    println(out, "");
    println(out, "#include \"flatcc/flatcc_json_parser.h\"");
    fb_gen_c_includes(out, "_json_parser.h", "_JSON_PARSER_H");
    gen_prologue(out);
    println(out, "");
    return 0;
}

static int gen_json_parser_footer(fb_output_t *out)
{
    gen_epilogue(out);
    println(out, "#endif /* %s_JSON_PARSER_H */", out->S->basenameup);
    return 0;
}

typedef struct dict_entry dict_entry_t;
struct dict_entry {
    const char *text;
    int len;
    void *data;
    int hint;
};

/* Returns length of name that reminds after tag at current position. */
static int get_dict_suffix_len(dict_entry_t *de, int pos)
{
    int n;

    n = de->len;
    if (pos + 8 > n) {
        return 0;
    }
    return n - pos - 8;
}

/*
 * Returns the length name that reminds if it terminates at the tag
 * and 0 if it has a suffix.
 */
static int get_dict_tag_len(dict_entry_t *de, int pos)
{
    int n;

    n = de->len;
    if (pos + 8 >= n) {
        return n - pos;
    }
    return 0;
}

/*
 * 8 byte word part of the name starting at characert `pos` in big
 * endian encoding with first char always at msb, zero padded at lsb.
 * Returns length of tag [0;8].
 */
static int get_dict_tag(dict_entry_t *de, int pos, uint64_t *tag, uint64_t *mask,
        const char **tag_name, int *tag_len)
{
    int i, n = 0;
    const char *a = 0;
    uint64_t w = 0;

    if (pos > de->len) {
        goto done;
    }
    a = de->text + pos;
    n = de->len - pos;
    if (n > 8) {
        n = 8;
    }
    i = n;
    while (i--) {
        w |= ((uint64_t)a[i]) << (56 - (i * 8));
    }
    *tag = w;
    *mask = ~(((uint64_t)(1) << (8 - n) * 8) - 1);
done:
    if (tag_name) {
        *tag_name = a;
    }
    if (tag_len) {
        *tag_len = n;
    }
    return n;
}


/*
 * Find the median, but move earlier if the previous entry
 * is a strict prefix within the range.
 *
 * `b` is inclusive.
 *
 * The `pos` is a window into the key at an 8 byte multiple.
 *
 * Only consider the range `[pos;pos+8)` and move the median
 * up if an earlier key is a prefix or match within this
 * window. This is needed to handle trailing data in
 * a compared external key, and also to handle sub-tree
 * branching when two keys has same tag at pos.
 *
 * Worst case we get a linear search of length 8 if all
 * keys are perfect prefixes of their successor key:
 *   `a, ab, abc, ..., abcdefgh`
 * While the midpoint stills seeks towards 'a' for longer
 * such sequences, the branch logic will pool those
 * squences the share prefix groups of length 8.
 */
static int split_dict_left(dict_entry_t *dict, int a, int b, int pos)
{
    int m = a + (b - a) / 2;
    uint64_t wf = 0, wg = 0, wmf = 0, wmg = 0;

    while (m > a) {
        get_dict_tag(&dict[m - 1], pos, &wf, &wmf, 0, 0);
        get_dict_tag(&dict[m], pos, &wg, &wmg, 0, 0);
        if (((wf ^ wg) & wmf) != 0) {
            return m;
        }
        --m;
    }
    return m;
}

/*
 * When multiple tags are identical after split_dict_left has moved
 * intersection up so a == m, we need to split in the opposite direction
 * to ensure progress untill all tags in the range are identical
 * at which point the trie must descend.
 *
 * If all tags are the same from intersection to end, b + 1 is returned
 * which is not a valid element.
 */
static int split_dict_right(dict_entry_t *dict, int a, int b, int pos)
{
    int m = a + (b - a) / 2;
    uint64_t wf = 0, wg = 0, wmf = 0, wmg = 0;

    while (m < b) {
        get_dict_tag(&dict[m], pos, &wf, &wmf, 0, 0);
        get_dict_tag(&dict[m + 1], pos, &wg, &wmg, 0, 0);
        if (((wf ^ wg) & wmf) != 0) {
            return m + 1;
        }
        ++m;
    }
    return m + 1;
}

/*
 * Returns the first index where the tag does not terminate at
 * [pos..pos+7], or b + 1 if none exists.
 */
static int split_dict_descend(dict_entry_t *dict, int a, int b, int pos)
{
    while (a <= b) {
        if (0 < get_dict_suffix_len(&dict[a], pos)) {
            break;
        }
        ++a;
    }
    return a;
}


static int dict_cmp(const void *x, const void *y)
{
    const dict_entry_t *a = x, *b = y;
    int k, n = a->len > b->len ? b->len : a->len;

    k = memcmp(a->text, b->text, (size_t)n);
    return k ? k : a->len - b->len;
}

/* Includes union vectors. */
static inline int is_union_member(fb_member_t *member)
{
    return (member->type.type == vt_compound_type_ref || member->type.type == vt_vector_compound_type_ref)
            && member->type.ct->symbol.kind == fb_is_union;
}

static dict_entry_t *build_compound_dict(fb_compound_type_t *ct, int *count_out)
{
    fb_symbol_t *sym;
    fb_member_t *member;
    size_t n;
    dict_entry_t *dict, *de;
    char *strbuf = 0;
    size_t strbufsiz = 0;
    int is_union;
    size_t union_index = 0;

    n = 0;
    for (sym = ct->members; sym; sym = sym->link) {
        member = (fb_member_t *)sym;
        if (member->metadata_flags & fb_f_deprecated) {
            continue;
        }
        is_union = is_union_member(member);
        if (is_union) {
            ++n;
            strbufsiz += (size_t)member->symbol.ident->len + 6;
        }
        ++n;
    }
    *count_out = (int)n;
    if (n == 0) {
        return 0;
    }
    dict = malloc(n * sizeof(dict_entry_t) + strbufsiz);
    if (!dict) {
        return 0;
    }
    strbuf = (char *)dict + n * sizeof(dict_entry_t);
    de = dict;
    for (sym = ct->members; sym; sym = sym->link) {
        member = (fb_member_t *)sym;
        if (member->metadata_flags & fb_f_deprecated) {
            continue;
        }
        de->text = member->symbol.ident->text;
        de->len = (int)member->symbol.ident->len;
        de->data = member;
        de->hint = 0;
        ++de;
        is_union = is_union_member(member);
        if (is_union) {
            member->export_index = union_index++;
            de->len = (int)member->symbol.ident->len + 5;
            de->text = strbuf;
            memcpy(strbuf, member->symbol.ident->text, (size_t)member->symbol.ident->len);
            strbuf += member->symbol.ident->len;
            strcpy(strbuf, "_type");
            strbuf += 6;
            de->data = member;
            de->hint = 1;
            ++de;
        }
    }
    qsort(dict, n, sizeof(dict[0]), dict_cmp);
    return dict;
}

typedef struct {
    int count;
    fb_schema_t *schema;
    dict_entry_t *de;
} install_enum_context_t;

static void count_visible_enum_symbol(void *context, fb_symbol_t *sym)
{
    install_enum_context_t *p = context;

    if (get_enum_if_visible(p->schema, sym)) {
        p->count++;
    }
}

static void install_visible_enum_symbol(void *context, fb_symbol_t *sym)
{
    install_enum_context_t *p = context;

    if (get_enum_if_visible(p->schema, sym)) {
        p->de->text = sym->ident->text;
        p->de->len = (int)sym->ident->len;
        p->de->data = sym;
        p->de++;
    }
}

/*
 * A scope dictionary contains all the enum types defined under the given
 * namespace of the scope. The actually namespace is not contained in
 * the name - it is an implicit prefix. It is used when looking up a
 * symbolic constant assigned to a field such that the constant is first
 * searched for in the same scope (namespace) as the one that defined
 * the table owning the field assigned to. If that fails, a global
 * namespace prefixed lookup is needed, but this is separate from this
 * dictionary. In case of conflicts the local scope takes precedence
 * and must be searched first. Because each table parsed can a have a
 * unique local scope, we cannot install the the unprefixed lookup in
 * the same dictionary as the global lookup.
 *
 * NOTE: the scope may have been contanimated by being expanded by a
 * parent schema so we check that each symbol is visible to the current
 * schema. If we didn't do this, we would risk referring to enum parsers
 * that are not included in the generated source. The default empty
 * namespace (i.e. scope) is an example where this easily could happen.
 */
static dict_entry_t *build_local_scope_dict(fb_schema_t *schema, fb_scope_t *scope, int *count_out)
{
    dict_entry_t *dict;
    install_enum_context_t iec;

    fb_clear(iec);

    iec.schema = schema;

    fb_symbol_table_visit(&scope->symbol_index, count_visible_enum_symbol, &iec);
    *count_out = iec.count;

    if (iec.count == 0) {
        return 0;
    }
    dict = malloc((size_t)iec.count * sizeof(dict[0]));
    if (!dict) {
        return 0;
    }
    iec.de = dict;
    fb_symbol_table_visit(&scope->symbol_index, install_visible_enum_symbol, &iec);
    qsort(dict, (size_t)iec.count, sizeof(dict[0]), dict_cmp);
    return dict;
}

static dict_entry_t *build_global_scope_dict(catalog_t *catalog, int *count_out)
{
    size_t i, n = (size_t)catalog->nenums;
    dict_entry_t *dict;

    *count_out = (int)n;
    if (n == 0) {
        return 0;
    }
    dict = malloc(n * sizeof(dict[0]));
    if (!dict) {
        return 0;
    }
    for (i = 0; i < (size_t)catalog->nenums; ++i) {
        dict[i].text = catalog->enums[i].name;
        dict[i].len = (int)strlen(catalog->enums[i].name);
        dict[i].data = catalog->enums[i].ct;
        dict[i].hint = 0;
    }
    qsort(dict, (size_t)catalog->nenums, sizeof(dict[0]), dict_cmp);
    *count_out = catalog->nenums;
    return dict;
}

static void clear_dict(dict_entry_t *dict)
{
    if (dict) {
        free(dict);
    }
}

static int gen_field_match_handler(fb_output_t *out, fb_compound_type_t *ct, void *data, int is_union_type)
{
    fb_member_t *member = data;
    fb_scoped_name_t snref;
    fb_symbol_text_t scope_name;

    int is_struct_container;
    int is_string = 0;
    int is_enum = 0;
    int is_vector = 0;
    int is_offset = 0;
    int is_scalar = 0;
    int is_optional = 0;
    int is_table = 0;
    int is_struct = 0;
    int is_union = 0;
    int is_union_vector = 0;
    int is_union_type_vector = 0;
    int is_base64 = 0;
    int is_base64url = 0;
    int is_nested = 0;
    int is_array = 0;
    int is_char_array = 0;
    size_t array_len = 0;
    fb_scalar_type_t st = 0;
    const char *tname_prefix = "n/a", *tname = "n/a"; /* suppress compiler warnigns */
    fb_literal_t literal;

    fb_clear(snref);

    fb_copy_scope(ct->scope, scope_name);
    is_struct_container = ct->symbol.kind == fb_is_struct;
    is_optional = !!(member->flags & fb_fm_optional);

    switch (member->type.type) {
    case vt_vector_type:
    case vt_vector_compound_type_ref:
    case vt_vector_string_type:
        is_vector = 1;
        break;
    }

    switch (member->type.type) {
    case vt_fixed_array_compound_type_ref:
    case vt_vector_compound_type_ref:
    case vt_compound_type_ref:
        fb_compound_name(member->type.ct, &snref);
        is_enum = member->type.ct->symbol.kind == fb_is_enum;
        is_struct = member->type.ct->symbol.kind == fb_is_struct;
        is_table = member->type.ct->symbol.kind == fb_is_table;
        is_union = member->type.ct->symbol.kind == fb_is_union && !is_union_type;
        if (is_enum) {
            st = member->type.ct->type.st;
            is_scalar = 1;
        }
        break;
    case vt_vector_string_type:
    case vt_string_type:
        is_string = 1;
        break;
    case vt_vector_type:
        /* Nested types are processed twice, once as an array, once as an object. */
        is_nested = member->nest != 0;
        is_base64 = member->metadata_flags & fb_f_base64;
        is_base64url = member->metadata_flags & fb_f_base64url;
        is_scalar = 1;
        st = member->type.st;
        break;
    case vt_fixed_array_type:
        is_scalar = 1;
        is_array = 1;
        array_len = member->type.len;
        st = member->type.st;
        break;
    case vt_scalar_type:
        is_scalar = 1;
        st = member->type.st;
        break;
    }
    if (member->type.type == vt_fixed_array_compound_type_ref) {
        assert(is_struct_container);
        is_array = 1;
        array_len = member->type.len;
    }
    if (is_base64 || is_base64url) {
        /* Even if it is nested, parse it as a regular base64 or base64url encoded vector. */
        if (st != fb_ubyte || !is_vector) {
            gen_panic(out, "internal error: unexpected base64 or base64url field type\n");
            return -1;
        }
        is_nested = 0;
        is_vector = 0;
        is_scalar = 0;
    }
    if (is_union_type) {
        is_scalar = 0;
    }
    if (is_vector && is_union_type) {
        is_union_type_vector = 1;
        is_vector = 0;
    }
    if (is_vector && is_union) {
        is_union_vector = 1;
        is_vector = 0;
    }
    if (is_array && is_scalar && st == fb_char) {
        is_array = 0;
        is_scalar = 0;
        is_char_array = 1;
    }
    if (is_nested == 1) {
        println(out, "if (buf != end && *buf == '[') { /* begin nested */"); indent();
    }
repeat_nested:
    if (is_nested == 2) {
        unindent(); println(out, "} else { /* nested */"); indent();
        fb_compound_name((fb_compound_type_t *)&member->nest->symbol, &snref);
        if (member->nest->symbol.kind == fb_is_table) {
            is_table = 1;
        } else {
            is_struct = 1;
        }
        is_vector = 0;
        is_scalar = 0;
        println(out, "if (flatcc_builder_start_buffer(ctx->ctx, 0, 0, 0)) goto failed;");
    }
    is_offset = !is_scalar && !is_struct && !is_union_type;

    if (is_scalar) {
        tname_prefix = scalar_type_prefix(st);
        tname = st == fb_bool ? "uint8_t" : scalar_type_name(st);
    }

    /* Other types can also be vector, so we wrap. */
    if (is_vector) {
        if (is_offset) {
            println(out, "if (flatcc_builder_start_offset_vector(ctx->ctx)) goto failed;");
        } else {
            println(out,
                "if (flatcc_builder_start_vector(ctx->ctx, %"PRIu64", %hu, UINT64_C(%"PRIu64"))) goto failed;",
                (uint64_t)member->size, (short)member->align,
                (uint64_t)FLATBUFFERS_COUNT_MAX(member->size));
        }
    }
    if (is_array) {
        if (is_scalar) {
            println(out, "size_t count = %d;", array_len);
            println(out, "%s *base = (%s *)((size_t)struct_base + %"PRIu64");",
                    tname, tname, (uint64_t)member->offset);
        }
        else {
            println(out, "size_t count = %d;", array_len);
            println(out, "void *base = (void *)((size_t)struct_base + %"PRIu64");",
                    (uint64_t)member->offset);
        }
    }
    if (is_char_array) {
        println(out, "char *base = (char *)((size_t)struct_base + %"PRIu64");",
                    (uint64_t)member->offset);
        println(out, "buf = flatcc_json_parser_char_array(ctx, buf, end, base, %d);", array_len);
    }
    if (is_array || is_vector) {
        println(out, "buf = flatcc_json_parser_array_start(ctx, buf, end, &more);");
        /* Note that we reuse `more` which is safe because it is updated at the end of the main loop. */
        println(out, "while (more) {"); indent();
    }
    if (is_scalar) {
        println(out, "%s val = 0;", tname);
        println(out, "static flatcc_json_parser_integral_symbol_f *symbolic_parsers[] = {");
        indent(); indent();
        /*
         * The scope name may be empty when no namespace is used. In that
         * case the global scope is the same, but performance the
         * duplicate doesn't matter.
         */
        if (is_enum) {
            println(out, "%s_parse_json_enum,", snref.text);
            println(out, "%s_local_%sjson_parser_enum,", out->S->basename, scope_name);
            println(out, "%s_global_json_parser_enum, 0 };", out->S->basename);
        } else {
            println(out, "%s_local_%sjson_parser_enum,", out->S->basename, scope_name);
            println(out, "%s_global_json_parser_enum, 0 };", out->S->basename);
        }
        unindent(); unindent();
    }
    /* It is not safe to acquire the pointer before building element table or string. */
    if (is_vector && !is_offset) {
        println(out, "if (!(pval = flatcc_builder_extend_vector(ctx->ctx, 1))) goto failed;");
    }
    if (is_struct_container) {
        if (!is_array && !is_char_array) {
            /* `struct_base` is given as argument to struct parsers. */
            println(out, "pval = (void *)((size_t)struct_base + %"PRIu64");", (uint64_t)member->offset);
        }
    } else if (is_struct && !is_vector) {
        /* Same logic as scalars in tables, but scalars must be tested for default. */
        println(out,
            "if (!(pval = flatcc_builder_table_add(ctx->ctx, %"PRIu64", %"PRIu64", %"PRIu16"))) goto failed;",
            (uint64_t)member->id, (uint64_t)member->size, (uint16_t)member->align);
    }
    if (is_scalar) {
        println(out, "buf = flatcc_json_parser_%s(ctx, (mark = buf), end, &val);", tname_prefix);
        println(out, "if (mark == buf) {"); indent();
        println(out, "buf = flatcc_json_parser_symbolic_%s(ctx, (mark = buf), end, symbolic_parsers, &val);", tname_prefix);
        println(out, "if (buf == mark || buf == end) goto failed;");
        unindent(); println(out, "}");
        if (!is_struct_container && !is_vector && !is_base64 && !is_base64url) {
#if !FLATCC_JSON_PARSE_FORCE_DEFAULTS
            /* We need to create a check for the default value and create a table field if not the default. */
            if (!is_optional) {
                if (!print_literal(st, &member->value, literal)) return -1;
                println(out, "if (val != %s || (ctx->flags & flatcc_json_parser_f_force_add)) {", literal); indent();
            }
#endif
            println(out, "if (!(pval = flatcc_builder_table_add(ctx->ctx, %"PRIu64", %"PRIu64", %hu))) goto failed;",
                    (uint64_t)member->id, (uint64_t)member->size, (short)member->align);
#if !FLATCC_JSON_PARSE_FORCE_DEFAULTS
#endif
        }
        /* For scalars in table field, and in struct container. */
        if (is_array) {
            println(out, "if (count) {"); indent();
            println(out, "%s%s_write_to_pe(base, val);", out->nsc, tname_prefix);
            println(out, "--count;");
            println(out, "++base;");
            unindent(); println(out, "} else if (!(ctx->flags & flatcc_json_parser_f_skip_array_overflow)) {"); indent();
            println(out, "return flatcc_json_parser_set_error(ctx, buf, end, flatcc_json_parser_error_array_overflow);");
            unindent(); println(out, "}");
        } else {
            println(out, "%s%s_write_to_pe(pval, val);", out->nsc, tname_prefix);
        }
        if (!is_struct_container && !is_vector && !(is_scalar && is_optional)) {
            unindent(); println(out, "}");
        }
    } else if (is_struct) {
        if (is_array) {
            println(out, "if (count) {"); indent();
            println(out, "buf = %s_parse_json_struct_inline(ctx, buf, end, base);", snref.text);
            println(out, "--count;");
            println(out, "base = (void *)((size_t)base + %"PRIu64");", member->type.ct->size);
            unindent(); println(out, "} else if (!(ctx->flags & flatcc_json_parser_f_skip_array_overflow)) {"); indent();
            println(out, "return flatcc_json_parser_set_error(ctx, buf, end, flatcc_json_parser_error_array_overflow);");
            unindent(); println(out, "}");
        } else {
            println(out, "buf = %s_parse_json_struct_inline(ctx, buf, end, pval);", snref.text);
        }
    } else if (is_string) {
        println(out, "buf = flatcc_json_parser_build_string(ctx, buf, end, &ref);");
    } else if (is_base64 || is_base64url) {
        println(out, "buf = flatcc_json_parser_build_uint8_vector_base64(ctx, buf, end, &ref, %u);",
                !is_base64);
    } else if (is_table) {
        println(out, "buf = %s_parse_json_table(ctx, buf, end, &ref);", snref.text);
    } else if (is_union) {
        if (is_union_vector) {
            println(out, "buf = flatcc_json_parser_union_vector(ctx, buf, end, %"PRIu64", %"PRIu64", h_unions, %s_parse_json_union);",
                (uint64_t)member->export_index, member->id, snref.text);
        } else {
            println(out, "buf = flatcc_json_parser_union(ctx, buf, end, %"PRIu64", %"PRIu64", h_unions, %s_parse_json_union);",
                (uint64_t)member->export_index, member->id, snref.text);
        }
    } else if (is_union_type) {
        println(out, "static flatcc_json_parser_integral_symbol_f *symbolic_parsers[] = {");
        indent(); indent();
        println(out, "%s_parse_json_enum,", snref.text);
        println(out, "%s_local_%sjson_parser_enum,", out->S->basename, scope_name);
        println(out, "%s_global_json_parser_enum, 0 };", out->S->basename);
        unindent(); unindent();
        if (is_union_type_vector) {
        println(out, "buf = flatcc_json_parser_union_type_vector(ctx, buf, end, %"PRIu64", %"PRIu64", h_unions, symbolic_parsers, %s_parse_json_union, %s_json_union_accept_type);",
                (uint64_t)member->export_index, member->id, snref.text, snref.text);
        } else {
            println(out, "buf = flatcc_json_parser_union_type(ctx, buf, end, %"PRIu64", %"PRIu64", h_unions, symbolic_parsers, %s_parse_json_union);",
                (uint64_t)member->export_index, member->id, snref.text);
        }
    } else if (!is_vector && !is_char_array) {
        gen_panic(out, "internal error: unexpected type for trie member\n");
        return -1;
    }
    if (is_vector) {
        if (is_offset) {
            /* Deal with table and string vector elements - unions cannot be elements. */
            println(out, "if (!ref || !(pref = flatcc_builder_extend_offset_vector(ctx->ctx, 1))) goto failed;");
            /* We don't need to worry about endian conversion - offsets vectors fix this automatically. */
            println(out, "*pref = ref;");
        }
        println(out, "buf = flatcc_json_parser_array_end(ctx, buf, end, &more);");
        unindent(); println(out, "}");
        if (is_offset) {
            println(out, "ref = flatcc_builder_end_offset_vector(ctx->ctx);");
        } else {
            println(out, "ref = flatcc_builder_end_vector(ctx->ctx);");
        }
    }
    if (is_array) {
        println(out, "buf = flatcc_json_parser_array_end(ctx, buf, end, &more);");
        unindent(); println(out, "}");
        println(out, "if (count) {"); indent();
        println(out, "if (ctx->flags & flatcc_json_parser_f_reject_array_underflow) {"); indent();
        println(out, "return flatcc_json_parser_set_error(ctx, buf, end, flatcc_json_parser_error_array_underflow);");
        unindent(); println(out, "}");
        if (is_scalar) {
            println(out, "memset(base, 0, count * sizeof(*base));");
        } else {
            println(out, "memset(base, 0, count * %"PRIu64");", (uint64_t)member->type.ct->size);
        }
        unindent(); println(out, "}");
    }
    if (is_nested == 1) {
        is_nested = 2;
        goto repeat_nested;
    }
    if (is_nested == 2) {
        println(out, "if (!ref) goto failed;");
        println(out, "ref = flatcc_builder_end_buffer(ctx->ctx, ref);");
        unindent(); println(out, "} /* end nested */");
    }
    if (is_nested || is_vector || is_table || is_string || is_base64 || is_base64url) {
        println(out, "if (!ref || !(pref = flatcc_builder_table_add_offset(ctx->ctx, %"PRIu64"))) goto failed;", member->id);
        println(out, "*pref = ref;");
    }
    return 0;
}

static void gen_field_match(fb_output_t *out, fb_compound_type_t *ct, void *data, int hint, int n)
{
    println(out, "buf = flatcc_json_parser_match_symbol(ctx, (mark = buf), end, %d);", n);
    println(out, "if (mark != buf) {"); indent();
    gen_field_match_handler(out, ct, data, hint);
    unindent(); println(out, "} else {"); indent();
}

/* This also handles union type enumerations. */
static void gen_enum_match_handler(fb_output_t *out, fb_compound_type_t *ct, void *data, int unused_hint)
{
    fb_member_t *member = data;

    (void)unused_hint;

    /*
     * This is rather unrelated to the rest, we just use the same
     * trie generation logic. Here we simply need to assign a known
     * value to the enum parsers output arguments.
     */
    switch (ct->type.st) {
    case fb_bool:
    case fb_ubyte:
    case fb_ushort:
    case fb_uint:
    case fb_ulong:
        println(out, "*value = UINT64_C(%"PRIu64"), *value_sign = 0;",
                member->value.u);
        break;
    case fb_byte:
    case fb_short:
    case fb_int:
    case fb_long:
        if (member->value.i < 0) {
            println(out, "*value = UINT64_C(%"PRIu64"), *value_sign = 1;", member->value.i);
        } else {
            println(out, "*value = UINT64_C(%"PRIu64"), *value_sign = 0;", member->value.i);
        }
        break;
    default:
        gen_panic(out, "internal error: invalid enum type\n");
    }
}

static void gen_enum_match(fb_output_t *out, fb_compound_type_t *ct, void *data, int hint, int n)
{
    println(out, "buf = flatcc_json_parser_match_constant(ctx, (mark = buf), end, %d, aggregate);", n);
    println(out, "if (buf != mark) {"); indent();
    gen_enum_match_handler(out, ct, data, hint);
    unindent(); println(out, "} else {"); indent();
}

static void gen_scope_match_handler(fb_output_t *out, fb_compound_type_t *unused_ct, void *data, int unused_hint)
{
    fb_compound_type_t *ct = data;
    fb_scoped_name_t snt;

    (void)unused_ct;
    (void)unused_hint;
    assert(ct->symbol.kind == fb_is_enum || ct->symbol.kind == fb_is_union);

    fb_clear(snt);
    fb_compound_name(ct, &snt);
    /* May be included from another file. Unions also have _enum parsers. */
    println(out, "buf = %s_parse_json_enum(ctx, buf, end, value_type, value, aggregate);", snt.text);
}

static void gen_scope_match(fb_output_t *out, fb_compound_type_t *ct, void *data, int hint, int n)
{
    println(out, "buf = flatcc_json_parser_match_scope(ctx, (mark = buf), end, %d);", n);
    println(out, "if (buf != mark) {"); indent();
    gen_scope_match_handler(out, ct, data, hint);
    unindent(); println(out, "} else {"); indent();
}

static void gen_field_unmatched(fb_output_t *out)
{
    println(out, "buf = flatcc_json_parser_unmatched_symbol(ctx, buf, end);");
}

static void gen_enum_unmatched(fb_output_t *out)
{
    println(out, "return unmatched;");
}

static void gen_scope_unmatched(fb_output_t *out)
{
    println(out, "return unmatched;");
}

/*
 * Generate a trie for all members or a compound type.
 * This may be a struct or a table.
 *
 * We have a ternary trie where a search word w compares:
 * w < wx_tag is one branch [a;x), iff a < x.
 * w > wx_tag is another branch (y;b], iff b > y
 * and w == wx_tag is a third branch [x;y].
 *
 * The sets [a;x) and (y;b] may be empty in which case a non-match
 * action is triggered.
 *
 * [x..y] is a set of one or more fields that share the same tag at the
 * current position. The first (and only the first) field name in this
 * set may terminate withint the current tag (when suffix length k ==
 * 0).  There is therefore potentially both a direct field action and a
 * sub-tree action. Once there is only one field in the set and the
 * field name terminates within the current tag, the search word is
 * masked and tested against the field tag and the search word is also
 * tested for termination in the buffer at the first position after the
 * field match. If the termination was not found a non-match action is
 * triggered.
 *
 * A non-match action may be to silently consume the rest of the
 * search identifier and then the json value, or to report and
 * error.
 *
 * A match action triggers a json value parse of a known type
 * which updates into a flatcc builder object. If the type is
 * basic (string or scalar) the update simple, otherwise if
 * the type is within the same schema, we push context
 * and switch to parse the nested type, otherwise we call
 * a parser in another schema. When a trie is done, we
 * switch back context if in the same schema. The context
 * lives on a stack. This avoids deep recursion because
 * schema parsers are not mutually recursive.
 *
 * The trie is also used to parse enums and scopes (namespace prefixes)
 * with a slight modification.
 */

enum trie_type { table_trie, struct_trie, enum_trie, local_scope_trie, global_scope_trie };
typedef struct trie trie_t;

typedef void gen_match_f(fb_output_t *out, fb_compound_type_t *ct, void *data, int hint, int n);
typedef void gen_unmatched_f(fb_output_t *out);

struct trie {
    dict_entry_t *dict;
    gen_match_f *gen_match;
    gen_unmatched_f *gen_unmatched;
    /* Not used with scopes. */
    fb_compound_type_t *ct;
    int type;
    int union_total;
    int label;
};

/*
 * This function is a final handler of the `gen_trie` function. Often
 * just to handle a single match, but also to handle a prefix range
 * special case like keys in `{ a, alpha, alpha2 }`.
 *
 * (See also special case of two non-prefix keys below).
 *
 * We know that all keys [a..b] have length in the range [pos..pos+8)
 * and also that key x is proper prefix of key x + 1, x in [a..b).
 *
 * It is possible that `a == b`.
 *
 * We conduct a binary search by testing the middle for masked match and
 * gradually refine until we do not have a match or have a single
 * element match.
 *
 * (An alternative algorithm xors 8 byte tag with longest prefix and
 * finds ceiling of log 2 using a few bit logic operations or intrinsic
 * zero count and creates a jump table of at most 8 elements, but is
 * hardly worthwhile vs 3 comparisons and 3 AND operations and often
 * less than that.)
 *
 * Once we have a single element match we need to confirm the successor
 * symbol is not any valid key - this differs among trie types and is
 * therefore the polymorph match logic handles the final confirmed match
 * or mismatch.
 *
 * Each trie type has special operation for implementing a matched and
 * a failed match. Our job is to call these for each key in the range.
 *
 * While not the original intention, the `gen_prefix_trie` also handles the
 * special case where the set has two keys where one is not a prefix of
 * the other, but both terminate in the same tag. In this case we can
 * immediately do an exact match test and skip the less than
 * comparision. We need no special code for this, assuming the function
 * is called correctly. This significantly reduces the branching in a
 * case like "Red, Green, Blue".
 *
 * If `label` is positive, it is used to jump to additional match logic
 * when a prefix was not matched. If 0 there is no additional logic and
 * the symbol is considered unmatched immediately.
 */
static void gen_prefix_trie(fb_output_t *out, trie_t *trie, int a, int b, int pos, int label)
{
    int m, n;
    uint64_t tag = 00, mask = 0;
    const char *name;
    int len;

    /*
     * Weigh the intersection towards the longer prefix. Notably if we
     * have two keys it makes no sense to check the shorter key first.
     */
    m = a + (b - a + 1) / 2;

    n = get_dict_tag(&trie->dict[m], pos, &tag, &mask, &name, &len);
    if (n == 8) {
        println(out, "if (w == 0x%"PRIx64") { /* \"%.*s\" */", tag, len, name); indent();
    } else {
        println(out, "if ((w & 0x%"PRIx64") == 0x%"PRIx64") { /* \"%.*s\" */",
                mask, tag, len, name); indent();
    }
    if (m == a) {
        /* There can be only one. */
        trie->gen_match(out, trie->ct, trie->dict[m].data, trie->dict[m].hint, n);
        if (label > 0) {
            println(out, "goto pfguard%d;", label);
        } else {
            trie->gen_unmatched(out);
        }
        unindent(); println(out, "}");
        unindent(); println(out, "} else { /* \"%.*s\" */", len, name); indent();
        if (label > 0) {
            println(out, "goto pfguard%d;", label);
        } else {
            trie->gen_unmatched(out);
        }
    } else {
        if (m == b) {
            trie->gen_match(out, trie->ct, trie->dict[m].data, trie->dict[m].hint, n);
            if (label > 0) {
                println(out, "goto pfguard%d;", label);
            } else {
                trie->gen_unmatched(out);
            }
            unindent(); println(out, "}");
        } else {
            gen_prefix_trie(out, trie, m, b, pos, label);
        }
        unindent(); println(out, "} else { /* \"%.*s\" */", len, name); indent();
        gen_prefix_trie(out, trie, a, m - 1, pos, label);
    }
    unindent(); println(out, "} /* \"%.*s\" */", len, name);
}

static void gen_trie(fb_output_t *out, trie_t *trie, int a, int b, int pos)
{
    int x, k;
    uint64_t tag = 0, mask = 0;
    const char *name = "";
    int len = 0, has_prefix_key = 0, prefix_guard = 0, has_descend;
    int label = 0;

    /*
     * Process a trie at the level given by pos. A single level covers
     * one tag.
     *
     * A tag is a range of 8 characters [pos..pos+7] that is read as a
     * single big endian word and tested as against a ternary trie
     * generated in code. In generated code the tag is stored in "w".
     *
     * Normally trailing data in a tag is not a problem
     * because the difference between two keys happen in the middle and
     * trailing data is not valid key material. When the difference is
     * at the end, we get a lot of special cases to handle.
     *
     * Regardless, when we believe we have a match, a final check is
     * made to ensure that the next character after the match is not a
     * valid key character - for quoted keys a valid termiantot is a
     * quote, for unquoted keys it can be one of several characters -
     * therefore quoted keys are faster to parse, even if they consume
     * more space. The trie does not care about these details, the
     * gen_match function handles this transparently for different
     * symbol types.
     */


    /*
    * If we have one or two keys that terminate in this tag, there is no
    * need to do a branch test before matching exactly.
    *
    * We observe that `gen_prefix_trie` actually handles this
    * case well, even though it was not designed for it.
    */
    if ((get_dict_suffix_len(&trie->dict[a], pos) == 0) &&
        (b == a || (b == a + 1 && get_dict_suffix_len(&trie->dict[b], pos) == 0))) {
        gen_prefix_trie(out, trie, a, b, pos, 0);
        return;
    }

    /*
     * Due trie nature, we have a left, middle, and right range where
     * the middle range all compare the same at the current trie level
     * when masked against shortest (and first) key in middle range.
     */
    x = split_dict_left(trie->dict, a, b, pos);

    if (x > a) {
        /*
         * This is normal early branch with a key `a < x < b` such that
         * any shared prefix ranges do not span x.
         */
        get_dict_tag(&trie->dict[x], pos, &tag, &mask, &name, &len);
        println(out, "if (w < 0x%"PRIx64") { /* branch \"%.*s\" */", tag, len, name); indent();
        gen_trie(out, trie, a, x - 1, pos);
        unindent(); println(out, "} else { /* branch \"%.*s\" */", len, name); indent();
        gen_trie(out, trie, x, b, pos);
        unindent(); println(out, "} /* branch \"%.*s\" */", len, name);
        return;
    }
    x = split_dict_right(trie->dict, a, b, pos);

    /*
     * [a .. x-1] is a non-empty sequence of prefixes,
     * for example { a123, a1234, a12345 }.
     * The keys might not terminate in the current tag. To find those
     * that do, we will evaluate k such that:
     * [a .. k-1] are prefixes that terminate in the current tag if any
     * such exists.
     * [x..b] are keys that are prefixes up to at least pos + 7 but
     * do not terminate in the current tag.
     * [k..x-1] are prefixes that do not termiante in the current tag.
     * Note that they might not be prefixes when considering more than the
     * current tag.
     * The range [a .. x-1] can ge generated with `gen_prefix_trie`.
     *
     * We generally have the form
     *
     * [a..b] =
     * (a)<prefixes>, (k-1)<descend-prefix>, (k)<descend>, (x)<reminder>
     *
     * Where <prefixes> are keys that terminate at the current tag.
     * <descend> are keys that have the prefixes as prefix but do not
     * terminate at the current tag.
     * <descend-prerfix> is a single key that terminates exactly
     * where the tag ends. If there are no descend keys it is part of
     * prefixes, otherwise it is tested as a special case.
     * <reminder> are any keys larger than the prefixes.
     *
     * The reminder keys cannot be tested before we are sure that no
     * prefix is matching at least no prefixes that is not a
     * descend-prefix. This is because less than comparisons are
     * affected by trailing data within the tag caused by prefixes
     * terminating early. Trailing data is not a problem if two keys are
     * longer than the point where they differ even if they terminate
     * within the current tag.
     *
     * Thus, if we have non-empty <descend> and non-empty <reminder>,
     * the reminder must guard against any matches in prefix but not
     * against any matches in <descend>. If <descend> is empty and
     * <prefixes> == <descend-prefix> a guard is also not needed.
     */

    /* Find first prefix that does not terminate at the current level, or x if absent */
    k = split_dict_descend(trie->dict, a, x - 1, pos);
    has_descend = k < x;

    /* If we have a descend, process that in isolation. */
    if (has_descend) {
        has_prefix_key = k > a && get_dict_tag_len(&trie->dict[k - 1], pos) == 8;
        get_dict_tag(&trie->dict[k], pos, &tag, &mask, &name, &len);
        println(out, "if (w == 0x%"PRIx64") { /* descend \"%.*s\" */", tag, len, name); indent();
        if (has_prefix_key) {
            /* We have a key that terminates at the descend prefix. */
            println(out, "/* descend prefix key \"%.*s\" */", len, name);
            trie->gen_match(out, trie->ct, trie->dict[k - 1].data, trie->dict[k - 1].hint, 8);
            println(out, "/* descend suffix \"%.*s\" */", len, name);
        }
        println(out, "buf += 8;");
        println(out, "w = flatcc_json_parser_symbol_part(buf, end);");
        gen_trie(out, trie, k, x - 1, pos + 8);
        if (has_prefix_key) {
            unindent(); println(out, "} /* desend suffix \"%.*s\" */", len, name);
            /* Here we move the <descend-prefix> key out of the <descend> range. */
            --k;
        }
        unindent(); println(out, "} else { /* descend \"%.*s\" */", len, name); indent();
    }
    prefix_guard = a < k && x <= b;
    if (prefix_guard) {
        label = ++trie->label;
    }
    if (a < k) {
        gen_prefix_trie(out, trie, a, k - 1, pos, label);
    }
    if (prefix_guard) {
        /* All prefixes tested, but none matched. */
        println(out, "goto endpfguard%d;", label);
        margin();
        println(out, "pfguard%d:", label);
        unmargin();
    }
    if (x <= b) {
        gen_trie(out, trie, x, b, pos);
    } else if (a >= k) {
        trie->gen_unmatched(out);
    }
    if (prefix_guard) {
        margin();
        println(out, "endpfguard%d:", label);
        unmargin();
        println(out, "(void)0;");
    }
    if (has_descend) {
        unindent(); println(out, "} /* descend \"%.*s\" */", len, name);
    }
}


/*
 * Parsing symbolic constants:
 *
 * An enum parser parses the local symbols and translate them into
 * numeric values.
 *
 * If a symbol wasn't matched, e.g. "Red", it might be matched with
 * "Color.Red" but the enum parser does not handle this.
 *
 * Instead a scope parser maps each type in the scope to a call
 * to an enum parser, e.g. "Color." maps to a color enum parser
 * that understands "Red". If this also fails, a call is made
 * to a global scope parser that maps a namespace to a local
 * scope parser, for example "Graphics.Color.Red" first
 * recognizes the namespace "Graphics." which may or may not
 * be the same as the local scope tried earlier, then "Color."
 * is matched and finally "Red".
 *
 * The scope and namespace parsers may cover extend namespaces from
 * include files so each file calls into dependencies as necessary.
 * This means the same scope can have multiple parsers and must
 * therefore be name prefixed by the basename of the include file.
 *
 * The enums can only exist in a single file.
 *
 * The local scope is defined as the scope in which the consuming
 * fields container is defined, so if Pen is a table in Graphics
 * with a field named "ink" and the pen is parsed as
 *   { "ink": "Color.Red" }, then Color would be parsed in the
 * Graphics scope. If ink was and enum of type Color, the enum
 * parser would be tried first. If ink was, say, an integer
 * type, it would not try an enum parse first but try the local
 * scope, then the namespace scope.
 *
 * It is permitted to have multiple symbols in a string when
 * the enum type has flag attribute so values can be or'ed together.
 * The parser does not attempt to validate this and will simple
 * 'or' together multiple values after coercing each to the
 * receiving field type: "Has.ink Has.shape Has.brush".
 */


/*
 * Used by scalar/enum/union_type table fields to look up symbolic
 * constants in same scope as the table was defined, thus avoiding
 * namespace prefix.
 *
 * Theh matched name then calls into the type specific parser which
 * may be in a dependent file.
 *
 * Because each scope may be extended in dependent schema files
 * we recreate the scope in full in each file.
 */
static void gen_local_scope_parser(void *context, fb_scope_t *scope)
{
    fb_output_t *out = context;
    int n = 0;
    trie_t trie;
    fb_symbol_text_t scope_name;

    fb_clear(trie);
    fb_copy_scope(scope, scope_name);
    if (((trie.dict = build_local_scope_dict(out->S, scope, &n)) == 0) && n > 0) {
        gen_panic(out, "internal error: could not build dictionary for json parser\n");
        return;
    }
    /* Not used for scopes. */
    trie.ct = 0;
    trie.type = local_scope_trie;
    trie.gen_match = gen_scope_match;
    trie.gen_unmatched = gen_scope_unmatched;
    println(out, "static const char *%s_local_%sjson_parser_enum(flatcc_json_parser_t *ctx, const char *buf, const char *end,",
        out->S->basename, scope_name);
    indent(); indent();
    println(out, "int *value_type, uint64_t *value, int *aggregate)");
    unindent(); unindent();
    println(out, "{"); indent();
    if (n == 0) {
        println(out, "/* Scope has no enum / union types to look up. */");
        println(out, "return buf; /* unmatched; */");
        unindent(); println(out, "}");
    } else {
        println(out, "const char *unmatched = buf;");
        println(out, "const char *mark;");
        println(out, "uint64_t w;");
        println(out, "");
        println(out, "w = flatcc_json_parser_symbol_part(buf, end);");
        gen_trie(out, &trie, 0, n - 1, 0);
        println(out, "return buf;");
        unindent(); println(out, "}");
    }
    println(out, "");
    clear_dict(trie.dict);
}

/*
 * This parses namespace prefixed types. Because scopes can be extended
 * in dependent schema files, each file has its own global scope parser.
 * The matched types call into type specific parsers that may be in
 * a dependent file.
 *
 * When a local scope is also parsed, it should be tried before the
 * global scope.
 */
static int gen_global_scope_parser(fb_output_t *out)
{
    int n = 0;
    trie_t trie;
    catalog_t catalog;

    fb_clear(trie);
    if (build_catalog(&catalog, out->S, 1, &out->S->root_schema->scope_index)) {
        return -1;
    }

    if ((trie.dict = build_global_scope_dict(&catalog, &n)) == 0 && n > 0) {
        clear_catalog(&catalog);
        gen_panic(out, "internal error: could not build dictionary for json parser\n");
        return -1;
    }
    /* Not used for scopes. */
    trie.ct = 0;
    trie.type = global_scope_trie;
    trie.gen_match = gen_scope_match;
    trie.gen_unmatched = gen_scope_unmatched;
    println(out, "static const char *%s_global_json_parser_enum(flatcc_json_parser_t *ctx, const char *buf, const char *end,", out->S->basename);
    indent(); indent();
    println(out, "int *value_type, uint64_t *value, int *aggregate)");
    unindent(); unindent();
    println(out, "{"); indent();
    if (n == 0) {
        println(out, "/* Global scope has no enum / union types to look up. */");
        println(out, "return buf; /* unmatched; */");
        unindent(); println(out, "}");
    } else {
        println(out, "const char *unmatched = buf;");
        println(out, "const char *mark;");
        println(out, "uint64_t w;");
        println(out, "");
        println(out, "w = flatcc_json_parser_symbol_part(buf, end);");
        gen_trie(out, &trie, 0, n - 1, 0);
        println(out, "return buf;");
        unindent(); println(out, "}");
    }
    println(out, "");
    clear_dict(trie.dict);
    clear_catalog(&catalog);
    return 0;
}

/*
 * Constants have the form `"Red"` or `Red` but may also be part
 * of a list of flags: `"Normal High Average"` or `Normal High
 * Average`. `more` indicates more symbols follow.
 *
 * Returns input argument if there was no valid match,
 * `end` on syntax error, and `more=1` if matched and
 * there are more constants to parse.
 * Applies the mached and coerced constant to `pval`
 * with a binary `or` operation so `pval` must be initialized
 * to 0 before teh first constant in a list.
 */
static int gen_enum_parser(fb_output_t *out, fb_compound_type_t *ct)
{
    fb_scoped_name_t snt;
    int n = 0;
    trie_t trie;

    fb_clear(trie);
    assert(ct->symbol.kind == fb_is_enum || ct->symbol.kind == fb_is_union);

    if ((trie.dict = build_compound_dict(ct, &n)) == 0 && n > 0) {
        gen_panic(out, "internal error: could not build dictionary for json parser\n");
        return -1;
    }
    trie.ct = ct;
    trie.type = enum_trie;
    trie.gen_match = gen_enum_match;
    trie.gen_unmatched = gen_enum_unmatched;

    fb_clear(snt);
    fb_compound_name(ct, &snt);

    println(out, "static const char *%s_parse_json_enum(flatcc_json_parser_t *ctx, const char *buf, const char *end,", snt.text);
    indent(); indent();
    println(out, "int *value_sign, uint64_t *value, int *aggregate)");
    unindent(); unindent();
    println(out, "{"); indent();
    if (n == 0) {
        println(out, "/* Enum has no fields. */");
        println(out, "*aggregate = 0;");
        println(out, "return buf; /* unmatched; */");
        unindent(); println(out, "}");
    } else {
        println(out, "const char *unmatched = buf;");
        println(out, "const char *mark;");
        println(out, "uint64_t w;");
        println(out, "");
        println(out, "w = flatcc_json_parser_symbol_part(buf, end);");
        gen_trie(out, &trie, 0, n - 1, 0);
        println(out, "return buf;");
        unindent(); println(out, "}");
    }
    println(out, "");
    clear_dict(trie.dict);
    return 0;
}

/*
 * We do not check for duplicate settings or missing struct fields.
 * Missing fields are zeroed.
 *
 * TODO: we should track nesting level because nested structs do not
 * interact with the builder so the builders level limit will not kick
 * in. As long as we get input from our own parser we should, however,
 * be reasonable safe as nesting is bounded.
 */
static int gen_struct_parser_inline(fb_output_t *out, fb_compound_type_t *ct)
{
    fb_scoped_name_t snt;
    int n;
    trie_t trie;

    fb_clear(trie);
    assert(ct->symbol.kind == fb_is_struct);
    if ((trie.dict = build_compound_dict(ct, &n)) == 0 && n > 0) {
        gen_panic(out, "internal error: could not build dictionary for json parser\n");
        return -1;
    }
    trie.ct = ct;
    trie.type = struct_trie;
    trie.gen_match = gen_field_match;
    trie.gen_unmatched = gen_field_unmatched;

    fb_clear(snt);
    fb_compound_name(ct, &snt);
    println(out, "static const char *%s_parse_json_struct_inline(flatcc_json_parser_t *ctx, const char *buf, const char *end, void *struct_base)", snt.text);
    println(out, "{"); indent();
    println(out, "int more;");
    if (n > 0) {
        println(out, "flatcc_builder_ref_t ref;");
        println(out, "void *pval;");
        println(out, "const char *mark;");
        println(out, "uint64_t w;");
    }
    println(out, "");
    println(out, "buf = flatcc_json_parser_object_start(ctx, buf, end, &more);");
    println(out, "while (more) {"); indent();
    if (n == 0) {
        println(out, "/* Empty struct. */");
        println(out, "buf = flatcc_json_parser_unmatched_symbol(ctx, buf, end);");
    } else {
        println(out, "buf = flatcc_json_parser_symbol_start(ctx, buf, end);");
        println(out, "w = flatcc_json_parser_symbol_part(buf, end);");
        gen_trie(out, &trie, 0, n - 1, 0);
    }
    println(out, "buf = flatcc_json_parser_object_end(ctx, buf, end , &more);");
    unindent(); println(out, "}");
    println(out, "return buf;");
    if (n > 0) {
        /* Set runtime error if no other error was set already. */
        margin();
        println(out, "failed:");
        unmargin();
        println(out, "return flatcc_json_parser_set_error(ctx, buf, end, flatcc_json_parser_error_runtime);");
    }
    unindent(); println(out, "}");
    println(out, "");
    clear_dict(trie.dict);
    return 0;
}

static int gen_struct_parser(fb_output_t *out, fb_compound_type_t *ct)
{
    fb_scoped_name_t snt;

    assert(ct->symbol.kind == fb_is_struct);
    fb_clear(snt);
    fb_compound_name(ct, &snt);
    println(out, "static const char *%s_parse_json_struct(flatcc_json_parser_t *ctx, const char *buf, const char *end, flatcc_builder_ref_t *result)", snt.text);
    println(out, "{"); indent();
    println(out, "void *pval;");
    println(out, "");
    println(out, "*result = 0;");
    println(out, "if (!(pval = flatcc_builder_start_struct(ctx->ctx, %"PRIu64", %"PRIu16"))) goto failed;",
            (uint64_t)ct->size, (uint16_t)ct->align);
    println(out, "buf = %s_parse_json_struct_inline(ctx, buf, end, pval);", snt.text);
    println(out, "if (ctx->error || !(*result = flatcc_builder_end_struct(ctx->ctx))) goto failed;");
    println(out, "return buf;");
    margin();
    println(out, "failed:");
    unmargin();
    println(out, "return flatcc_json_parser_set_error(ctx, buf, end, flatcc_json_parser_error_runtime);");
    unindent(); println(out, "}");
    println(out, "");
    println(out, "static inline int %s_parse_json_as_root(flatcc_builder_t *B, flatcc_json_parser_t *ctx, const char *buf, size_t bufsiz, flatcc_json_parser_flags_t flags, const char *fid)", snt.text);
    println(out, "{"); indent();
    println(out, "return flatcc_json_parser_struct_as_root(B, ctx, buf, bufsiz, flags, fid, %s_parse_json_struct);",
            snt.text);
    unindent(); println(out, "}");
    println(out, "");
    return 0;
}

static int gen_table_parser(fb_output_t *out, fb_compound_type_t *ct)
{
    fb_scoped_name_t snt;
    fb_member_t *member;
    int first, i, n;
    int is_union, is_required;
    trie_t trie;

    fb_clear(trie);
    assert(ct->symbol.kind == fb_is_table);
    if ((trie.dict = build_compound_dict(ct, &n)) == 0 && n > 0) {
        gen_panic(out, "internal error: could not build dictionary for json parser\n");
        return -1;
    }
    trie.ct = ct;
    trie.type = table_trie;
    trie.gen_match = gen_field_match;
    trie.gen_unmatched = gen_field_unmatched;

    trie.union_total = 0;
    for (i = 0; i < n; ++i) {
        trie.union_total += !!trie.dict[i].hint;
    }

    fb_clear(snt);
    fb_compound_name(ct, &snt);
    println(out, "static const char *%s_parse_json_table(flatcc_json_parser_t *ctx, const char *buf, const char *end, flatcc_builder_ref_t *result)", snt.text);
    println(out, "{"); indent();
    println(out, "int more;");

    if (n > 0) {
        println(out, "void *pval;");
        println(out, "flatcc_builder_ref_t ref, *pref;");
        println(out, "const char *mark;");
        println(out, "uint64_t w;");
    }
    if (trie.union_total) {
        println(out, "size_t h_unions;");
    }
    println(out, "");
    println(out, "*result = 0;");
    println(out, "if (flatcc_builder_start_table(ctx->ctx, %"PRIu64")) goto failed;",
        ct->count);
    if (trie.union_total) {
        println(out, "if (end == flatcc_json_parser_prepare_unions(ctx, buf, end, %"PRIu64", &h_unions)) goto failed;", (uint64_t)trie.union_total);
    }
    println(out, "buf = flatcc_json_parser_object_start(ctx, buf, end, &more);");
    println(out, "while (more) {"); indent();
    println(out, "buf = flatcc_json_parser_symbol_start(ctx, buf, end);");
    if (n > 0) {
        println(out, "w = flatcc_json_parser_symbol_part(buf, end);");
        gen_trie(out, &trie, 0, n - 1, 0);
    } else {
        println(out, "/* Table has no fields. */");
        println(out, "buf = flatcc_json_parser_unmatched_symbol(ctx, buf, end);");
    }
    println(out, "buf = flatcc_json_parser_object_end(ctx, buf, end, &more);");
    unindent(); println(out, "}");
    println(out, "if (ctx->error) goto failed;");
    for (first = 1, i = 0; i < n; ++i) {
        member = trie.dict[i].data;
        if (member->metadata_flags & fb_f_deprecated) {
            continue;
        }
        is_union = is_union_member(member);
        is_required = member->metadata_flags & fb_f_required;
        if (is_required) {
            if (first) {
                println(out, "if (!flatcc_builder_check_required_field(ctx->ctx, %"PRIu64")", member->id - !!is_union);
                indent();
            } else {
                println(out, "||  !flatcc_builder_check_required_field(ctx->ctx, %"PRIu64")", member->id - !!is_union);
            }
            first = 0;
        }
    }
    if (!first) {
        unindent(); println(out, ") {"); indent();
        println(out, "buf = flatcc_json_parser_set_error(ctx, buf, end, flatcc_json_parser_error_required);");
        println(out, "goto failed;");
        unindent(); println(out, "}");
    }
    if (trie.union_total) {
        println(out, "buf = flatcc_json_parser_finalize_unions(ctx, buf, end, h_unions);");
    }
    println(out, "if (!(*result = flatcc_builder_end_table(ctx->ctx))) goto failed;");
    println(out, "return buf;");
    /* Set runtime error if no other error was set already. */
    margin();
    println(out, "failed:");
    unmargin();
    println(out, "return flatcc_json_parser_set_error(ctx, buf, end, flatcc_json_parser_error_runtime);");
    unindent(); println(out, "}");
    println(out, "");
    println(out, "static inline int %s_parse_json_as_root(flatcc_builder_t *B, flatcc_json_parser_t *ctx, const char *buf, size_t bufsiz, flatcc_json_parser_flags_t flags, const char *fid)", snt.text);
    println(out, "{"); indent();
    println(out, "return flatcc_json_parser_table_as_root(B, ctx, buf, bufsiz, flags, fid, %s_parse_json_table);",
            snt.text);
    unindent(); println(out, "}");
    println(out, "");
    clear_dict(trie.dict);
    return 0;
}

static int gen_union_parser(fb_output_t *out, fb_compound_type_t *ct)
{
    fb_scoped_name_t snt, snref;
    fb_symbol_t *sym;
    fb_member_t *member;
    int n;
    const char *s;

    fb_clear(snt);
    fb_clear(snref);
    fb_compound_name(ct, &snt);
    println(out, "static const char *%s_parse_json_union(flatcc_json_parser_t *ctx, const char *buf, const char *end, uint8_t type, flatcc_builder_ref_t *result)", snt.text);
    println(out, "{"); indent();
    println(out, "");
    println(out, "*result = 0;");
    println(out, "switch (type) {");
    println(out, "case 0: /* NONE */"); indent();
    println(out, "return flatcc_json_parser_none(ctx, buf, end);");
    unindent();
    for (sym = ct->members; sym; sym = sym->link) {
        member = (fb_member_t *)sym;
        symbol_name(sym, &n, &s);
        switch (member->type.type) {
        case vt_missing:
            /* NONE is of type vt_missing and already handled. */
            continue;
        case vt_compound_type_ref:
            fb_compound_name(member->type.ct, &snref);
            println(out, "case %u: /* %.*s */", (unsigned)member->value.u, n, s); indent();
            switch (member->type.ct->symbol.kind) {
            case fb_is_table:
                println(out, "buf = %s_parse_json_table(ctx, buf, end, result);", snref.text);
                break;
            case fb_is_struct:
                println(out, "buf = %s_parse_json_struct(ctx, buf, end, result);", snref.text);
                break;
            default:
                gen_panic(out, "internal error: unexpected compound union member type\n");
                return -1;
            }
            println(out, "break;");
            unindent();
            continue;
        case vt_string_type:
            println(out, "case %u: /* %.*s */", (unsigned)member->value.u, n, s); indent();
            println(out, "buf = flatcc_json_parser_build_string(ctx, buf, end, result);");
            println(out, "break;");
            unindent();
            continue;
        default:
            gen_panic(out, "internal error: unexpected union member type\n");
            return -1;
        }
    }
    /* Unknown union, but not an error if we allow schema forwarding. */
    println(out, "default:"); indent();
    println(out, "if (!(ctx->flags & flatcc_json_parser_f_skip_unknown)) {"); indent();
    println(out, "return flatcc_json_parser_set_error(ctx, buf, end, flatcc_json_parser_error_unknown_union);");
    unindent(); println(out, "} else {"); indent();
    println(out, "return flatcc_json_parser_generic_json(ctx, buf, end);");
    unindent(); println(out, "}");
    unindent(); println(out, "}");
    println(out, "if (ctx->error) return buf;");
    println(out, "if (!*result) {");
    indent(); println(out, "return flatcc_json_parser_set_error(ctx, buf, end, flatcc_json_parser_error_runtime);");
    unindent(); println(out, "}");
    println(out, "return buf;");
    unindent(); println(out, "}");
    println(out, "");
    return 0;
}

static int gen_union_accept_type(fb_output_t *out, fb_compound_type_t *ct)
{
    fb_scoped_name_t snt, snref;
    fb_symbol_t *sym;
    fb_member_t *member;
    int n;
    const char *s;

    fb_clear(snt);
    fb_clear(snref);
    fb_compound_name(ct, &snt);
    println(out, "static int %s_json_union_accept_type(uint8_t type)", snt.text);
    println(out, "{"); indent();
    println(out, "switch (type) {");
    for (sym = ct->members; sym; sym = sym->link) {
        member = (fb_member_t *)sym;
        symbol_name(sym, &n, &s);
        if (member->type.type == vt_missing) {
            println(out, "case 0: return 1; /* NONE */");
            continue;
        }
        println(out, "case %u: return 1; /* %.*s */", (unsigned)member->value.u, n, s);
    }
    /* Unknown union, but not an error if we allow schema forwarding. */
    println(out, "default: return 0;"); indent();
    unindent(); println(out, "}");
    unindent(); println(out, "}");
    println(out, "");
    return 0;
}

static void gen_local_scope_prototype(void *context, fb_scope_t *scope)
{
    fb_output_t *out = context;
    fb_symbol_text_t scope_name;

    fb_copy_scope(scope, scope_name);

    println(out, "static const char *%s_local_%sjson_parser_enum(flatcc_json_parser_t *ctx, const char *buf, const char *end,",
        out->S->basename, scope_name);
    println(out, "int *value_type, uint64_t *value, int *aggregate);");
}

static int gen_root_table_parser(fb_output_t *out, fb_compound_type_t *ct)
{
    fb_scoped_name_t snt;

    fb_clear(snt);
    fb_compound_name(ct, &snt);

    println(out, "static int %s_parse_json(flatcc_builder_t *B, flatcc_json_parser_t *ctx,", out->S->basename);
    indent(); indent();
    println(out, "const char *buf, size_t bufsiz, flatcc_json_parser_flags_t flags)");
    unindent(); unindent();
    println(out, "{"); indent();
    println(out, "flatcc_json_parser_t parser;");
    println(out, "flatcc_builder_ref_t root;");
    println(out, "");
    println(out, "ctx = ctx ? ctx : &parser;");
    println(out, "flatcc_json_parser_init(ctx, B, buf, buf + bufsiz, flags);");
    if (out->S->file_identifier.type == vt_string) {
        println(out, "if (flatcc_builder_start_buffer(B, \"%.*s\", 0, 0)) return -1;",
        out->S->file_identifier.s.len, out->S->file_identifier.s.s);
    } else {
        println(out, "if (flatcc_builder_start_buffer(B, 0, 0, 0)) return -1;");
    }
    println(out, "%s_parse_json_table(ctx, buf, buf + bufsiz, &root);", snt.text);
    println(out, "if (ctx->error) {"); indent();
    println(out, "return ctx->error;");
    unindent(); println(out, "}");
    println(out, "if (!flatcc_builder_end_buffer(B, root)) return -1;");
    println(out, "ctx->end_loc = buf;");
    println(out, "return 0;");
    unindent(); println(out, "}");
    println(out, "");
    return 0;
}

static int gen_root_struct_parser(fb_output_t *out, fb_compound_type_t *ct)
{
    fb_scoped_name_t snt;

    fb_clear(snt);
    fb_compound_name(ct, &snt);

    println(out, "static int %s_parse_json(flatcc_builder_t *B, flatcc_json_parser_t *ctx,", out->S->basename);
    indent(); indent();
    println(out, "const char *buf, size_t bufsiz, int flags)");
    unindent(); unindent();
    println(out, "{"); indent();
    println(out, "flatcc_json_parser_t ctx_;");
    println(out, "flatcc_builder_ref_t root;");
    println(out, "");
    println(out, "ctx = ctx ? ctx : &ctx_;");
    println(out, "flatcc_json_parser_init(ctx, B, buf, buf + bufsiz, flags);");
    if (out->S->file_identifier.type == vt_string) {
        println(out, "if (flatcc_builder_start_buffer(B, \"%.*s\", 0, 0)) return -1;",
        out->S->file_identifier.s.len, out->S->file_identifier.s.s);
    } else {
        println(out, "if (flatcc_builder_start_buffer(B, 0, 0, 0)) return -1;");
    }
    println(out, "buf = %s_parse_json_struct(ctx, buf, buf + bufsiz, &root);", snt.text);
    println(out, "if (ctx->error) {"); indent();
    println(out, "return ctx->error;");
    unindent(); println(out, "}");
    println(out, "if (!flatcc_builder_end_buffer(B, root)) return -1;");
    println(out, "ctx->end_loc = buf;");
    println(out, "return 0;");
    unindent(); println(out, "}");
    println(out, "");
    return 0;
}


static int gen_root_parser(fb_output_t *out)
{
    fb_symbol_t *root_type = out->S->root_type.type;

    if (!root_type) {
        return 0;
    }
    if (root_type) {
        switch (root_type->kind) {
        case fb_is_table:
            return gen_root_table_parser(out, (fb_compound_type_t *)root_type);
        case fb_is_struct:
            return gen_root_struct_parser(out, (fb_compound_type_t *)root_type);
        default:
            break;
        }
    }
    return 0;
}

static int gen_json_parser_prototypes(fb_output_t *out)
{
    fb_symbol_t *sym;
    fb_scoped_name_t snt;
    fb_symbol_t *root_type = out->S->root_type.type;

    fb_clear(snt);

    if (root_type)
    switch (root_type->kind) {
    case fb_is_table:
    case fb_is_struct:
        println(out, "/*");
        println(out, " * Parses the default root table or struct of the schema and constructs a FlatBuffer.");
        println(out, " *");
        println(out, " * Builder `B` must be initialized. `ctx` can be null but will hold");
        println(out, " * hold detailed error info on return when available.");
        println(out, " * Returns 0 on success, or error code.");
        println(out, " * `flags` : 0 by default, `flatcc_json_parser_f_skip_unknown` silently");
        println(out, " * ignores unknown table and structs fields, and union types.");
        println(out, " */");
    println(out, "static int %s_parse_json(flatcc_builder_t *B, flatcc_json_parser_t *ctx,",
            out->S->basename);
    indent(); indent();
    println(out, "const char *buf, size_t bufsiz, flatcc_json_parser_flags_t flags);");
    unindent(); unindent();
        println(out, "");
        break;
    default:
        break;
    }
    for (sym = out->S->symbols; sym; sym = sym->link) {
        switch (sym->kind) {
        case fb_is_union:
            fb_compound_name((fb_compound_type_t *)sym, &snt);
            println(out, "static const char *%s_parse_json_union(flatcc_json_parser_t *ctx, const char *buf, const char *end, uint8_t type, flatcc_builder_ref_t *pref);", snt.text);
            println(out, "static int %s_json_union_accept_type(uint8_t type);", snt.text);
            /* A union also has an enum parser to get the type. */
            println(out, "static const char *%s_parse_json_enum(flatcc_json_parser_t *ctx, const char *buf, const char *end,", snt.text);
            indent(); indent();
            println(out, "int *value_type, uint64_t *value, int *aggregate);");
            unindent(); unindent();
            break;
        case fb_is_struct:
            fb_compound_name((fb_compound_type_t *)sym, &snt);
            println(out, "static const char *%s_parse_json_struct_inline(flatcc_json_parser_t *ctx, const char *buf, const char *end, void *struct_base);", snt.text);
            println(out, "static const char *%s_parse_json_struct(flatcc_json_parser_t *ctx, const char *buf, const char *end, flatcc_builder_ref_t *result);", snt.text);
            break;
        case fb_is_table:
            fb_compound_name((fb_compound_type_t *)sym, &snt);
            println(out, "static const char *%s_parse_json_table(flatcc_json_parser_t *ctx, const char *buf, const char *end, flatcc_builder_ref_t *result);", snt.text);
            break;
        case fb_is_enum:
            fb_compound_name((fb_compound_type_t *)sym, &snt);
            println(out, "static const char *%s_parse_json_enum(flatcc_json_parser_t *ctx, const char *buf, const char *end,", snt.text);
            indent(); indent();
            println(out, "int *value_type, uint64_t *value, int *aggregate);", snt.text);
            unindent(); unindent();
            break;
        }
    }
    fb_scope_table_visit(&out->S->root_schema->scope_index, gen_local_scope_prototype, out);
    println(out, "static const char *%s_global_json_parser_enum(flatcc_json_parser_t *ctx, const char *buf, const char *end,", out->S->basename);
    indent(); indent();
    println(out, "int *value_type, uint64_t *value, int *aggregate);");
    unindent(); unindent();
    println(out, "");
    return 0;
}

static int gen_json_parsers(fb_output_t *out)
{
    fb_symbol_t *sym;

    for (sym = out->S->symbols; sym; sym = sym->link) {
        switch (sym->kind) {
        case fb_is_union:
            gen_union_parser(out, (fb_compound_type_t *)sym);
            gen_union_accept_type(out, (fb_compound_type_t *)sym);
            gen_enum_parser(out, (fb_compound_type_t *)sym);
            break;
        case fb_is_struct:
            gen_struct_parser_inline(out, (fb_compound_type_t *)sym);
            gen_struct_parser(out, (fb_compound_type_t *)sym);
            break;
        case fb_is_table:
            gen_table_parser(out, (fb_compound_type_t *)sym);
            break;
        case fb_is_enum:
            gen_enum_parser(out, (fb_compound_type_t *)sym);
            break;
        }
    }
    fb_scope_table_visit(&out->S->root_schema->scope_index, gen_local_scope_parser, out);
    gen_global_scope_parser(out);
    gen_root_parser(out);
    return 0;
}

int fb_gen_c_json_parser(fb_output_t *out)
{
    gen_json_parser_pretext(out);
    gen_json_parser_prototypes(out);
    gen_json_parsers(out);
    gen_json_parser_footer(out);
    return 0;
}