From 6c86e7fa91602e4863c95622934d45e383890156 Mon Sep 17 00:00:00 2001 From: "kr.angelov" Date: Thu, 9 Oct 2014 08:38:55 +0000 Subject: [PATCH] replace the hash maps in the abstract syntax with binary search tables --- src/runtime/c/pgf/data.c | 40 +++++++++-- src/runtime/c/pgf/data.h | 33 ++++++--- src/runtime/c/pgf/evaluator.c | 2 +- src/runtime/c/pgf/jit.c | 10 +-- src/runtime/c/pgf/parser.c | 101 ++++++++++++-------------- src/runtime/c/pgf/pgf.c | 81 +++++++++++---------- src/runtime/c/pgf/pgf.h | 8 +-- src/runtime/c/pgf/printer.c | 124 ++++++++++++++------------------ src/runtime/c/pgf/reader.c | 96 ++++++++++--------------- src/runtime/c/pgf/reasoner.c | 2 +- src/runtime/c/pgf/typechecker.c | 4 +- 11 files changed, 255 insertions(+), 246 deletions(-) diff --git a/src/runtime/c/pgf/data.c b/src/runtime/c/pgf/data.c index 79cd3e8a2..54df81a57 100644 --- a/src/runtime/c/pgf/data.c +++ b/src/runtime/c/pgf/data.c @@ -34,13 +34,19 @@ GU_DEFINE_TYPE(PgfCncCat, abstract); GU_DEFINE_TYPE(PgfDummyVariant, GuVariant); -GU_DEFINE_TYPE(PgfFlags, GuStringMap, gu_type(PgfDummyVariant), &gu_null_variant); +static int +pgf_flag_cmp_fn(GuOrder* self, const void* p1, const void* p2) +{ + (void) self; + return strcmp((GuString) p1, ((PgfFlag*) p2)->name); +} + +GuOrder pgf_flag_order[1] = { { pgf_flag_cmp_fn } }; + GU_DEFINE_TYPE(PgfProductionSeq, abstract); GU_DEFINE_TYPE(PgfProductionBuf, abstract); -GU_DEFINE_TYPE(PgfAbsFun, abstract); - static prob_t inf_prob = INFINITY; GU_DEFINE_TYPE(prob_t, GuFloating, _); @@ -51,9 +57,35 @@ GU_DEFINE_TYPE(PgfMetaChildMap, GuMap, GU_DEFINE_TYPE(PgfAbsCat, abstract); +static int +pgf_abscat_cmp_fn(GuOrder* self, const void* p1, const void* p2) +{ + (void) self; + return strcmp((GuString) p1, ((PgfAbsCat*) p2)->name); +} + +GuOrder pgf_abscat_order[1] = { { pgf_abscat_cmp_fn } }; + +static int +pgf_absfun_cmp_fn(GuOrder* self, const void* p1, const void* p2) +{ + (void) self; + return strcmp((GuString) p1, ((PgfAbsFun*) p2)->name); +} + +GuOrder pgf_absfun_order[1] = { { pgf_absfun_cmp_fn } }; + + static GuString empty_string = ""; GU_DEFINE_TYPE( PgfPrintNames, PgfCIdMap, gu_type(GuString), &empty_string); -GU_DEFINE_TYPE(PgfConcr, abstract); +static int +pgf_concr_cmp_fn(GuOrder* self, const void* p1, const void* p2) +{ + (void) self; + return strcmp((GuString) p1, ((PgfConcr*) p2)->name); +} + +GuOrder pgf_concr_order[1] = { { pgf_concr_cmp_fn } }; diff --git a/src/runtime/c/pgf/data.h b/src/runtime/c/pgf/data.h index ac319c59f..34e8ddb16 100644 --- a/src/runtime/c/pgf/data.h +++ b/src/runtime/c/pgf/data.h @@ -13,9 +13,16 @@ extern GU_DECLARE_TYPE(PgfCCat, abstract); typedef GuSeq PgfCCats; -#define PgfCIdMap GuStringMap -typedef PgfCIdMap PgfFlags; // PgfCId -> PgfLiteral -extern GU_DECLARE_TYPE(PgfFlags, GuMap); +#define PgfCIdMap GuStringMap + +typedef struct { + PgfCId name; + PgfLiteral value; +} PgfFlag; + +typedef GuSeq PgfFlags; + +extern GuOrder pgf_flag_order[1]; // PgfPatt @@ -87,7 +94,9 @@ typedef struct { } closure; } PgfAbsFun; -extern GU_DECLARE_TYPE(PgfAbsFun, abstract); +typedef GuSeq PgfAbsFuns; + +extern GuOrder pgf_absfun_order[1]; typedef GuMap PgfMetaChildMap; extern GU_DECLARE_TYPE(PgfMetaChildMap, GuMap); @@ -103,13 +112,18 @@ typedef struct { extern GU_DECLARE_TYPE(PgfAbsCat, abstract); +typedef GuSeq PgfAbsCats; + +extern GuOrder pgf_abscat_order[1]; + + typedef struct PgfEvalGates PgfEvalGates; typedef struct { PgfCId name; PgfFlags* aflags; - PgfCIdMap* funs; // |-> PgfAbsFun* - PgfCIdMap* cats; // |-> PgfAbsCat* + PgfAbsFuns* funs; + PgfAbsCats* cats; PgfAbsFun* abs_lin_fun; PgfEvalGates* eval_gates; } PgfAbstr; @@ -130,12 +144,16 @@ typedef enum { PGF_INSTR_FAIL = 14 } PgfInstruction; +typedef GuSeq PgfConcrs; + +extern GuOrder pgf_concr_order[1]; + struct PgfPGF { uint16_t major_version; uint16_t minor_version; PgfFlags* gflags; PgfAbstr abstract; - PgfCIdMap* concretes; // |-> PgfConcr* + PgfConcrs* concretes; GuPool* pool; // the pool in which the grammar is allocated }; @@ -269,7 +287,6 @@ struct PgfConcr { GuFinalizer fin; // and this is the finalizer in the pool of the whole grammar }; -extern GU_DECLARE_TYPE(PgfConcr, abstract); // PgfProduction diff --git a/src/runtime/c/pgf/evaluator.c b/src/runtime/c/pgf/evaluator.c index 812b9f130..bc89026fc 100644 --- a/src/runtime/c/pgf/evaluator.c +++ b/src/runtime/c/pgf/evaluator.c @@ -79,7 +79,7 @@ repeat:; PgfExprFun* efun = ei.data; PgfAbsFun* absfun = - gu_map_get(state->pgf->abstract.funs, efun->fun, PgfAbsFun*); + gu_seq_binsearch(state->pgf->abstract.funs, pgf_absfun_order, PgfAbsFun, efun->fun); gu_assert(absfun != NULL); if (absfun->closure.code != NULL) { diff --git a/src/runtime/c/pgf/jit.c b/src/runtime/c/pgf/jit.c index 570cf3e8e..645cc8378 100644 --- a/src/runtime/c/pgf/jit.c +++ b/src/runtime/c/pgf/jit.c @@ -111,11 +111,11 @@ pgf_jit_read_absfun(PgfReader* rdr, PgfAbstr* abstr) PgfCId name = pgf_read_cid(rdr, rdr->tmp_pool); gu_return_on_exn(rdr->err, NULL); - + PgfAbsFun* absfun = - gu_map_get(abstr->funs, name, PgfAbsFun*); + gu_seq_binsearch(abstr->funs, pgf_absfun_order, PgfAbsFun, name); assert(absfun != NULL); - + return absfun; } @@ -1176,12 +1176,12 @@ pgf_jit_done(PgfReader* rdr, PgfAbstr* abstr) gu_buf_index(rdr->jit_state->call_patches, PgfCallPatch, i); PgfAbsCat* arg = - gu_map_get(abstr->cats, patch->cid, PgfAbsCat*); + gu_seq_binsearch(abstr->cats, pgf_abscat_order, PgfAbsCat, patch->cid); if (arg != NULL) { jit_patch_calli(patch->ref,(jit_insn*) arg->predicate); } else { PgfAbsFun* fun = - gu_map_get(abstr->funs, patch->cid, PgfAbsFun*); + gu_seq_binsearch(abstr->funs, pgf_absfun_order, PgfAbsFun, patch->cid); if (fun == NULL) gu_impossible(); else { diff --git a/src/runtime/c/pgf/parser.c b/src/runtime/c/pgf/parser.c index 99c0a3432..c7e041c62 100644 --- a/src/runtime/c/pgf/parser.c +++ b/src/runtime/c/pgf/parser.c @@ -1482,54 +1482,48 @@ pgf_parsing_meta_scan(PgfParsing* ps, gu_buf_heap_push(ps->before->agenda, pgf_item_prob_order, &item); } -typedef struct { - GuMapItor fn; - PgfParsing* ps; - PgfItem* meta_item; -} PgfMetaPredictFn; - static void -pgf_parsing_meta_predict(GuMapItor* fn, const void* key, void* value, GuExn* err) +pgf_parsing_meta_predict(PgfParsing* ps, PgfItem* meta_item) { - (void) (err); + PgfAbsCats* cats = ps->concr->abstr->cats; + size_t n_cats = gu_seq_length(cats); - PgfAbsCat* abscat = *((PgfAbsCat**) value); - PgfMetaPredictFn* clo = (PgfMetaPredictFn*) fn; - PgfParsing* ps = clo->ps; - PgfItem* meta_item = clo->meta_item; - - if (abscat->prob == INFINITY) - return; - - PgfCncCat* cnccat = - gu_map_get(ps->concr->cnccats, abscat->name, PgfCncCat*); - if (cnccat == NULL) - return; - - size_t n_cats = gu_seq_length(cnccat->cats); for (size_t i = 0; i < n_cats; i++) { - PgfCCat* ccat = gu_seq_get(cnccat->cats, PgfCCat*, i); - if (ccat->prods == NULL) { - // empty category + PgfAbsCat* abscat = gu_seq_index(cats, PgfAbsCat, i); + + if (abscat->prob == INFINITY) continue; - } - for (size_t lin_idx = 0; lin_idx < cnccat->n_lins; lin_idx++) { - PgfItem* item = - pgf_item_copy(meta_item, ps); - item->inside_prob += - ccat->viterbi_prob+abscat->prob; + PgfCncCat* cnccat = + gu_map_get(ps->concr->cnccats, abscat->name, PgfCncCat*); + if (cnccat == NULL) + continue; - size_t nargs = gu_seq_length(meta_item->args); - item->args = gu_new_seq(PgfPArg, nargs+1, ps->pool); - memcpy(gu_seq_data(item->args), gu_seq_data(meta_item->args), - nargs * sizeof(PgfPArg)); - gu_seq_set(item->args, PgfPArg, nargs, - ((PgfPArg) { .hypos = NULL, .ccat = ccat })); + size_t n_cats = gu_seq_length(cnccat->cats); + for (size_t i = 0; i < n_cats; i++) { + PgfCCat* ccat = gu_seq_get(cnccat->cats, PgfCCat*, i); + if (ccat->prods == NULL) { + // empty category + continue; + } - pgf_add_extern_cat(&item->curr_sym, nargs, lin_idx, ps->pool); + for (size_t lin_idx = 0; lin_idx < cnccat->n_lins; lin_idx++) { + PgfItem* item = + pgf_item_copy(meta_item, ps); + item->inside_prob += + ccat->viterbi_prob+abscat->prob; - gu_buf_heap_push(ps->before->agenda, pgf_item_prob_order, &item); + size_t nargs = gu_seq_length(meta_item->args); + item->args = gu_new_seq(PgfPArg, nargs+1, ps->pool); + memcpy(gu_seq_data(item->args), gu_seq_data(meta_item->args), + nargs * sizeof(PgfPArg)); + gu_seq_set(item->args, PgfPArg, nargs, + ((PgfPArg) { .hypos = NULL, .ccat = ccat })); + + pgf_add_extern_cat(&item->curr_sym, nargs, lin_idx, ps->pool); + + gu_buf_heap_push(ps->before->agenda, pgf_item_prob_order, &item); + } } } } @@ -1833,8 +1827,7 @@ pgf_parsing_item(PgfParsing* ps, PgfItem* item) pgf_parsing_meta_scan(ps, item, meta_token_prob); } - PgfMetaPredictFn clo = { { pgf_parsing_meta_predict }, ps, item }; - gu_map_iter(ps->concr->abstr->cats, &clo.fn, NULL); + pgf_parsing_meta_predict(ps, item); } } else { pgf_parsing_symbol(ps, item, item->curr_sym); @@ -1849,28 +1842,28 @@ pgf_parsing_item(PgfParsing* ps, PgfItem* item) static void pgf_parsing_set_default_factors(PgfParsing* ps, PgfAbstr* abstr) { - PgfLiteral lit; + PgfFlag* flag; - lit = - gu_map_get(abstr->aflags, "heuristic_search_factor", PgfLiteral); - if (!gu_variant_is_null(lit)) { - GuVariantInfo pi = gu_variant_open(lit); + flag = + gu_seq_binsearch(abstr->aflags, pgf_flag_order, PgfFlag, "heuristic_search_factor"); + if (flag != NULL) { + GuVariantInfo pi = gu_variant_open(flag->value); gu_assert (pi.tag == PGF_LITERAL_FLT); ps->heuristic_factor = ((PgfLiteralFlt*) pi.data)->val; } - lit = - gu_map_get(abstr->aflags, "meta_prob", PgfLiteral); - if (!gu_variant_is_null(lit)) { - GuVariantInfo pi = gu_variant_open(lit); + flag = + gu_seq_binsearch(abstr->aflags, pgf_flag_order, PgfFlag, "meta_prob"); + if (flag != NULL) { + GuVariantInfo pi = gu_variant_open(flag->value); gu_assert (pi.tag == PGF_LITERAL_FLT); ps->meta_prob = - log(((PgfLiteralFlt*) pi.data)->val); } - lit = - gu_map_get(abstr->aflags, "meta_token_prob", PgfLiteral); - if (!gu_variant_is_null(lit)) { - GuVariantInfo pi = gu_variant_open(lit); + flag = + gu_seq_binsearch(abstr->aflags, pgf_flag_order, PgfFlag, "meta_token_prob"); + if (flag != NULL) { + GuVariantInfo pi = gu_variant_open(flag->value); gu_assert (pi.tag == PGF_LITERAL_FLT); ps->meta_token_prob = - log(((PgfLiteralFlt*) pi.data)->val); } diff --git a/src/runtime/c/pgf/pgf.c b/src/runtime/c/pgf/pgf.c index 60e838e84..875c65903 100644 --- a/src/runtime/c/pgf/pgf.c +++ b/src/runtime/c/pgf/pgf.c @@ -42,15 +42,21 @@ pgf_abstract_name(PgfPGF* pgf) } void -pgf_iter_languages(PgfPGF* pgf, GuMapItor* fn, GuExn* err) +pgf_iter_languages(PgfPGF* pgf, GuMapItor* itor, GuExn* err) { - gu_map_iter(pgf->concretes, fn, err); + size_t n_concrs = gu_seq_length(pgf->concretes); + for (size_t i = 0; i < n_concrs; i++) { + PgfConcr* concr = gu_seq_index(pgf->concretes, PgfConcr, i); + itor->fn(itor, concr->name, concr, err); + if (!gu_ok(err)) + break; + } } PgfConcr* pgf_get_language(PgfPGF* pgf, PgfCId lang) { - return gu_map_get(pgf->concretes, lang, PgfConcr*); + return gu_seq_binsearch(pgf->concretes, pgf_concr_order, PgfConcr, lang); } GuString @@ -60,21 +66,27 @@ pgf_concrete_name(PgfConcr* concr) } void -pgf_iter_categories(PgfPGF* pgf, GuMapItor* fn, GuExn* err) +pgf_iter_categories(PgfPGF* pgf, GuMapItor* itor, GuExn* err) { - gu_map_iter(pgf->abstract.cats, fn, err); + size_t n_cats = gu_seq_length(pgf->abstract.cats); + for (size_t i = 0; i < n_cats; i++) { + PgfAbsCat* cat = gu_seq_index(pgf->abstract.cats, PgfAbsCat, i); + itor->fn(itor, cat->name, cat, err); + if (!gu_ok(err)) + break; + } } PgfCId pgf_start_cat(PgfPGF* pgf) { - PgfLiteral lit = - gu_map_get(pgf->abstract.aflags, "startcat", PgfLiteral); + PgfFlag* flag = + gu_seq_binsearch(pgf->abstract.aflags, pgf_flag_order, PgfFlag, "startcat"); - if (gu_variant_is_null(lit)) + if (flag == NULL) return "S"; - GuVariantInfo i = gu_variant_open(lit); + GuVariantInfo i = gu_variant_open(flag->value); switch (i.tag) { case PGF_LITERAL_STR: { PgfLiteralStr *lstr = (PgfLiteralStr *) i.data; @@ -88,13 +100,13 @@ pgf_start_cat(PgfPGF* pgf) GuString pgf_language_code(PgfConcr* concr) { - PgfLiteral lit = - gu_map_get(concr->cflags, "language", PgfLiteral); + PgfFlag* flag = + gu_seq_binsearch(concr->cflags, pgf_flag_order, PgfFlag, "language"); - if (gu_variant_is_null(lit)) + if (flag == NULL) return ""; - GuVariantInfo i = gu_variant_open(lit); + GuVariantInfo i = gu_variant_open(flag->value); switch (i.tag) { case PGF_LITERAL_STR: { PgfLiteralStr *lstr = (PgfLiteralStr *) i.data; @@ -106,43 +118,38 @@ pgf_language_code(PgfConcr* concr) } void -pgf_iter_functions(PgfPGF* pgf, GuMapItor* fn, GuExn* err) +pgf_iter_functions(PgfPGF* pgf, GuMapItor* itor, GuExn* err) { - gu_map_iter(pgf->abstract.funs, fn, err); -} - -typedef struct { - GuMapItor fn; - PgfCId catname; - GuMapItor* client_fn; -} PgfFunByCatIter; - -static void -pgf_filter_by_cat(GuMapItor* fn, const void* key, void* value, GuExn* err) -{ - (void) (key && err); - - PgfFunByCatIter* clo = (PgfFunByCatIter*) fn; - PgfAbsFun* absfun = *((PgfAbsFun**) value); - - if (strcmp(absfun->type->cid, clo->catname) == 0) { - clo->client_fn->fn(clo->client_fn, absfun->name, NULL, err); + size_t n_funs = gu_seq_length(pgf->abstract.funs); + for (size_t i = 0; i < n_funs; i++) { + PgfAbsFun* fun = gu_seq_index(pgf->abstract.funs, PgfAbsFun, i); + itor->fn(itor, fun->name, fun, err); + if (!gu_ok(err)) + break; } } void pgf_iter_functions_by_cat(PgfPGF* pgf, PgfCId catname, - GuMapItor* fn, GuExn* err) + GuMapItor* itor, GuExn* err) { - PgfFunByCatIter clo = { { pgf_filter_by_cat }, catname, fn }; - gu_map_iter(pgf->abstract.funs, &clo.fn, err); + size_t n_funs = gu_seq_length(pgf->abstract.funs); + for (size_t i = 0; i < n_funs; i++) { + PgfAbsFun* fun = gu_seq_index(pgf->abstract.funs, PgfAbsFun, i); + + if (strcmp(fun->type->cid, catname) == 0) { + itor->fn(itor, fun->name, fun, err); + if (!gu_ok(err)) + break; + } + } } PgfType* pgf_function_type(PgfPGF* pgf, PgfCId funname) { PgfAbsFun* absfun = - gu_map_get(pgf->abstract.funs, funname, PgfAbsFun*); + gu_seq_binsearch(pgf->abstract.funs, pgf_absfun_order, PgfAbsFun, funname); if (absfun == NULL) return NULL; diff --git a/src/runtime/c/pgf/pgf.h b/src/runtime/c/pgf/pgf.h index 16444985f..41a59c26c 100644 --- a/src/runtime/c/pgf/pgf.h +++ b/src/runtime/c/pgf/pgf.h @@ -40,7 +40,7 @@ GuString pgf_abstract_name(PgfPGF*); void -pgf_iter_languages(PgfPGF*, GuMapItor*, GuExn* err); +pgf_iter_languages(PgfPGF*, GuMapItor* itor, GuExn* err); PgfConcr* pgf_get_language(PgfPGF*, PgfCId lang); @@ -52,17 +52,17 @@ GuString pgf_language_code(PgfConcr* concr); void -pgf_iter_categories(PgfPGF* pgf, GuMapItor* fn, GuExn* err); +pgf_iter_categories(PgfPGF* pgf, GuMapItor* itor, GuExn* err); PgfCId pgf_start_cat(PgfPGF* pgf); void -pgf_iter_functions(PgfPGF* pgf, GuMapItor* fn, GuExn* err); +pgf_iter_functions(PgfPGF* pgf, GuMapItor* itor, GuExn* err); void pgf_iter_functions_by_cat(PgfPGF* pgf, PgfCId catname, - GuMapItor* fn, GuExn* err); + GuMapItor* itor, GuExn* err); PgfType* pgf_function_type(PgfPGF* pgf, PgfCId funname); diff --git a/src/runtime/c/pgf/printer.c b/src/runtime/c/pgf/printer.c index 2417a3edd..10a9858c1 100644 --- a/src/runtime/c/pgf/printer.c +++ b/src/runtime/c/pgf/printer.c @@ -7,64 +7,61 @@ typedef struct { } PgfPrintFn; void -pgf_print_flag(GuMapItor* fn, const void* key, void* value, - GuExn* err) +pgf_print_flags(PgfFlags* flags, GuOut *out, GuExn* err) { - PgfPrintFn* clo = (PgfPrintFn*) fn; - PgfCId flag = (PgfCId) key; - PgfLiteral lit = *((PgfLiteral *) value); - GuOut *out = clo->out; - - gu_puts(" flag ", out, err); - pgf_print_cid(flag, out, err); - gu_puts(" = ", out, err); - pgf_print_literal(lit, out, err); - gu_puts(";\n", out, err); + size_t n_flags = gu_seq_length(flags); + for (size_t i = 0; i < n_flags; i++) { + PgfFlag* flag = gu_seq_index(flags, PgfFlag, i); + + gu_puts(" flag ", out, err); + pgf_print_cid(flag->name, out, err); + gu_puts(" = ", out, err); + pgf_print_literal(flag->value, out, err); + gu_puts(";\n", out, err); + } } void -pgf_print_cat(GuMapItor* fn, const void* key, void* value, - GuExn* err) +pgf_print_abscats(PgfAbsCats* abscats, GuOut *out, GuExn* err) { - PgfPrintFn* clo = (PgfPrintFn*) fn; - PgfCId name = (PgfCId) key; - PgfAbsCat *cat = *((PgfAbsCat **) value); - GuOut *out = clo->out; + size_t n_cats = gu_seq_length(abscats); + for (size_t i = 0; i < n_cats; i++) { + PgfAbsCat *abscat = gu_seq_index(abscats, PgfAbsCat, i); - gu_puts(" cat ", out, err); - pgf_print_cid(name, out, err); + gu_puts(" cat ", out, err); + pgf_print_cid(abscat->name, out, err); - PgfPrintContext* ctxt = NULL; - size_t n_hypos = gu_seq_length(cat->context); - for (size_t i = 0; i < n_hypos; i++) { - PgfHypo* hypo = gu_seq_index(cat->context, PgfHypo, i); - gu_putc(' ', out, err); - ctxt = pgf_print_hypo(hypo, ctxt, 4, out, err); + PgfPrintContext* ctxt = NULL; + size_t n_hypos = gu_seq_length(abscat->context); + for (size_t i = 0; i < n_hypos; i++) { + PgfHypo* hypo = gu_seq_index(abscat->context, PgfHypo, i); + gu_putc(' ', out, err); + ctxt = pgf_print_hypo(hypo, ctxt, 4, out, err); + } + + while (ctxt != NULL) { + PgfPrintContext* next = ctxt->next; + free(ctxt); + ctxt = next; + } + + gu_printf(out, err, " ; -- %f\n", abscat->prob); } - - while (ctxt != NULL) { - PgfPrintContext* next = ctxt->next; - free(ctxt); - ctxt = next; - } - - gu_printf(out, err, " ; -- %f\n", cat->prob); } void -pgf_print_absfun(GuMapItor* fn, const void* key, void* value, - GuExn* err) +pgf_print_absfuns(PgfAbsFuns* absfuns, GuOut *out, GuExn* err) { - PgfPrintFn* clo = (PgfPrintFn*) fn; - PgfCId name = (PgfCId) key; - PgfAbsFun *fun = *((PgfAbsFun **) value); - GuOut *out = clo->out; + size_t n_funs = gu_seq_length(absfuns); + for (size_t i = 0; i < n_funs; i++) { + PgfAbsFun *absfun = gu_seq_index(absfuns, PgfAbsFun, i); - gu_puts((fun->defns == NULL) ? " data " : " fun ", out, err); - pgf_print_cid(name, out, err); - gu_puts(" : ", out, err); - pgf_print_type(fun->type, NULL, 0, out, err); - gu_printf(out, err, " ; -- %f\n", fun->ep.prob); + gu_puts((absfun->defns == NULL) ? " data " : " fun ", out, err); + pgf_print_cid(absfun->name, out, err); + gu_puts(" : ", out, err); + pgf_print_type(absfun->type, NULL, 0, out, err); + gu_printf(out, err, " ; -- %f\n", absfun->ep.prob); + } } static void pgf_print_abstract(PgfAbstr* abstr, GuOut* out, GuExn* err) @@ -72,16 +69,11 @@ pgf_print_abstract(PgfAbstr* abstr, GuOut* out, GuExn* err) gu_puts("abstract ", out, err); pgf_print_cid(abstr->name, out, err); gu_puts(" {\n", out, err); - - PgfPrintFn clo1 = { { pgf_print_flag }, out }; - gu_map_iter(abstr->aflags, &clo1.fn, err); - PgfPrintFn clo2 = { { pgf_print_cat }, out }; - gu_map_iter(abstr->cats, &clo2.fn, err); + pgf_print_flags(abstr->aflags, out, err); + pgf_print_abscats(abstr->cats, out, err); + pgf_print_absfuns(abstr->funs, out, err); - PgfPrintFn clo3 = { { pgf_print_absfun }, out }; - gu_map_iter(abstr->funs, &clo3.fn, err); - gu_puts("}\n", out, err); } @@ -331,15 +323,13 @@ pgf_print_cnccat(GuMapItor* fn, const void* key, void* value, } static void -pgf_print_concrete(PgfCId cncname, PgfConcr* concr, - GuOut* out, GuExn* err) +pgf_print_concrete(PgfConcr* concr, GuOut* out, GuExn* err) { gu_puts("concrete ", out, err); - pgf_print_cid(cncname, out, err); + pgf_print_cid(concr->name, out, err); gu_puts(" {\n", out, err); - PgfPrintFn clo1 = { { pgf_print_flag }, out }; - gu_map_iter(concr->cflags, &clo1.fn, err); + pgf_print_flags(concr->cflags, out, err); gu_puts(" productions\n", out, err); PgfPrintFn clo2 = { { pgf_print_productions }, out }; @@ -376,22 +366,14 @@ pgf_print_concrete(PgfCId cncname, PgfConcr* concr, gu_puts("}\n", out, err); } -static void -pgf_print_concr_cb(GuMapItor* fn, const void* key, void* value, - GuExn* err) -{ - PgfPrintFn* clo = (PgfPrintFn*) fn; - PgfCId cncname = (PgfCId) key; - PgfConcr *concr = *((PgfConcr **) value); - - pgf_print_concrete(cncname, concr, clo->out, err); -} - void pgf_print(PgfPGF* pgf, GuOut* out, GuExn* err) { pgf_print_abstract(&pgf->abstract, out, err); - PgfPrintFn clo = { { pgf_print_concr_cb }, out }; - gu_map_iter(pgf->concretes, &clo.fn, err); + size_t n_concrs = gu_seq_length(pgf->concretes); + for (size_t i = 0; i < n_concrs; i++) { + PgfConcr* concr = gu_seq_index(pgf->concretes, PgfConcr, i); + pgf_print_concrete(concr, out, err); + } } diff --git a/src/runtime/c/pgf/reader.c b/src/runtime/c/pgf/reader.c index 2e8c154be..f42711e09 100644 --- a/src/runtime/c/pgf/reader.c +++ b/src/runtime/c/pgf/reader.c @@ -159,19 +159,18 @@ pgf_read_literal(PgfReader* rdr) static PgfFlags* pgf_read_flags(PgfReader* rdr) { - PgfFlags* flags = gu_map_type_new(PgfFlags, rdr->opool); - - GuLength len = pgf_read_len(rdr); + GuLength n_flags = pgf_read_len(rdr); gu_return_on_exn(rdr->err, NULL); - for (size_t i = 0; i < len; i++) { - PgfCId name = pgf_read_cid(rdr, rdr->opool); + PgfFlags* flags = gu_new_seq(PgfFlag, n_flags, rdr->opool); + for (size_t i = 0; i < n_flags; i++) { + PgfFlag* flag = gu_seq_index(flags, PgfFlag, i); + + flag->name = pgf_read_cid(rdr, rdr->opool); gu_return_on_exn(rdr->err, NULL); - PgfLiteral value = pgf_read_literal(rdr); + flag->value = pgf_read_literal(rdr); gu_return_on_exn(rdr->err, NULL); - - gu_map_put(flags, name, PgfLiteral, value); } return flags; @@ -415,10 +414,8 @@ pgf_read_patt(PgfReader* rdr) } static PgfAbsFun* -pgf_read_absfun(PgfReader* rdr, PgfAbstr* abstr) +pgf_read_absfun(PgfReader* rdr, PgfAbstr* abstr, PgfAbsFun* absfun) { - PgfAbsFun* absfun = gu_new(PgfAbsFun, rdr->opool); - size_t len = pgf_read_len(rdr); PgfExprFun *efun = @@ -486,33 +483,26 @@ pgf_read_absfun(PgfReader* rdr, PgfAbstr* abstr) return absfun; } -static PgfCIdMap* +static PgfAbsFuns* pgf_read_absfuns(PgfReader* rdr, PgfAbstr* abstr) { - GuMapType* map_type = (GuMapType*) - GU_TYPE_LIT(GuStringMap, _, - gu_ptr_type(PgfAbsFun), - &gu_null_struct); - PgfCIdMap* absfuns = gu_map_type_make(map_type, rdr->opool); - - size_t len = pgf_read_len(rdr); + size_t n_funs = pgf_read_len(rdr); gu_return_on_exn(rdr->err, NULL); - for (size_t i = 0; i < len; i++) { - PgfAbsFun* absfun = pgf_read_absfun(rdr, abstr); + PgfAbsFuns* absfuns = gu_new_seq(PgfAbsFun, n_funs, rdr->opool); + + for (size_t i = 0; i < n_funs; i++) { + PgfAbsFun* absfun = gu_seq_index(absfuns, PgfAbsFun, i); + pgf_read_absfun(rdr, abstr, absfun); gu_return_on_exn(rdr->err, NULL); - - gu_map_put(absfuns, absfun->name, PgfAbsFun*, absfun); } return absfuns; } static PgfAbsCat* -pgf_read_abscat(PgfReader* rdr, PgfAbstr* abstr, PgfCIdMap* abscats) +pgf_read_abscat(PgfReader* rdr, PgfAbstr* abstr, PgfAbsCat* abscat) { - PgfAbsCat* abscat = gu_new(PgfAbsCat, rdr->opool); - abscat->name = pgf_read_cid(rdr, rdr->opool); gu_return_on_exn(rdr->err, NULL); @@ -532,23 +522,18 @@ pgf_read_abscat(PgfReader* rdr, PgfAbstr* abstr, PgfCIdMap* abscats) return abscat; } -static PgfCIdMap* +static PgfAbsCats* pgf_read_abscats(PgfReader* rdr, PgfAbstr* abstr) { - GuMapType* map_type = (GuMapType*) - GU_TYPE_LIT(GuStringMap, _, - gu_ptr_type(PgfAbsCat), - &gu_null_struct); - PgfCIdMap* abscats = gu_map_type_make(map_type, rdr->opool); - - size_t len = pgf_read_len(rdr); + size_t n_cats = pgf_read_len(rdr); gu_return_on_exn(rdr->err, NULL); + + PgfAbsCats* abscats = gu_new_seq(PgfAbsCat, n_cats, rdr->opool); - for (size_t i = 0; i < len; i++) { - PgfAbsCat* abscat = pgf_read_abscat(rdr, abstr, abscats); + for (size_t i = 0; i < n_cats; i++) { + PgfAbsCat* abscat = gu_seq_index(abscats, PgfAbsCat, i); + pgf_read_abscat(rdr, abstr, abscat); gu_return_on_exn(rdr->err, NULL); - - gu_map_put(abscats, abscat->name, PgfAbsCat*, abscat); } return abscats; @@ -562,9 +547,9 @@ pgf_read_abstract(PgfReader* rdr, PgfAbstr* abstract) abstract->aflags = pgf_read_flags(rdr); gu_return_on_exn(rdr->err, ); - + abstract->eval_gates = pgf_jit_gates(rdr); - + abstract->funs = pgf_read_absfuns(rdr, abstract); gu_return_on_exn(rdr->err, ); @@ -787,7 +772,7 @@ pgf_read_cncfun(PgfReader* rdr, PgfAbstr* abstr, PgfConcr* concr, int funid) gu_return_on_exn(rdr->err, NULL); PgfAbsFun* absfun = - gu_map_get(abstr->funs, name, PgfAbsFun*); + gu_seq_binsearch(abstr->funs, pgf_absfun_order, PgfAbsFun, name); PgfCncFun* cncfun = gu_new_flex(rdr->opool, PgfCncFun, lins, len); cncfun->absfun = absfun; @@ -1032,7 +1017,7 @@ pgf_read_cnccat(PgfReader* rdr, PgfAbstr* abstr, PgfConcr* concr, PgfCId name) gu_malloc(rdr->opool, sizeof(PgfCncCat)+n_lins*sizeof(GuString)); cnccat->abscat = - gu_map_get(abstr->cats, name, PgfAbsCat*); + gu_seq_binsearch(abstr->cats, pgf_abscat_order, PgfAbsCat, name); gu_assert(cnccat->abscat != NULL); int len = last + 1 - first; @@ -1205,10 +1190,8 @@ gu_concr_fini(GuFinalizer* fin) } static PgfConcr* -pgf_read_concrete(PgfReader* rdr, PgfAbstr* abstr, bool with_content) +pgf_read_concrete(PgfReader* rdr, PgfAbstr* abstr, PgfConcr* concr, bool with_content) { - PgfConcr* concr = gu_new(PgfConcr, rdr->opool); - concr->name = pgf_read_cid(rdr, rdr->opool); gu_return_on_exn(rdr->err, NULL); @@ -1284,23 +1267,18 @@ pgf_concrete_unload(PgfConcr* concr) gu_concr_fini(&concr->fin); } -static PgfCIdMap* +static PgfConcrs* pgf_read_concretes(PgfReader* rdr, PgfAbstr* abstr, bool with_content) { - GuMapType* map_type = (GuMapType*) - GU_TYPE_LIT(GuStringMap, _, - gu_ptr_type(PgfConcr), - &gu_null_struct); - PgfCIdMap* concretes = gu_map_type_make(map_type, rdr->opool); - - size_t len = pgf_read_len(rdr); + size_t n_concrs = pgf_read_len(rdr); gu_return_on_exn(rdr->err, NULL); - for (size_t i = 0; i < len; i++) { - PgfConcr* concr = pgf_read_concrete(rdr, abstr, with_content); - gu_return_on_exn(rdr->err, NULL); + PgfConcrs* concretes = gu_new_seq(PgfConcr, n_concrs, rdr->opool); - gu_map_put(concretes, concr->name, PgfConcr*, concr); + for (size_t i = 0; i < n_concrs; i++) { + PgfConcr* concr = gu_seq_index(concretes, PgfConcr, i); + pgf_read_concrete(rdr, abstr, concr, with_content); + gu_return_on_exn(rdr->err, NULL); } return concretes; @@ -1323,10 +1301,10 @@ pgf_read_pgf(PgfReader* rdr) { gu_return_on_exn(rdr->err, NULL); bool with_content = - gu_variant_is_null(gu_map_get(pgf->gflags, "split", PgfLiteral)); + (gu_seq_binsearch(pgf->gflags, pgf_flag_order, PgfFlag, "split") == NULL); pgf->concretes = pgf_read_concretes(rdr, &pgf->abstract, with_content); gu_return_on_exn(rdr->err, NULL); - + pgf->pool = rdr->opool; return pgf; diff --git a/src/runtime/c/pgf/reasoner.c b/src/runtime/c/pgf/reasoner.c index 7cb4380cf..f71749ba0 100644 --- a/src/runtime/c/pgf/reasoner.c +++ b/src/runtime/c/pgf/reasoner.c @@ -399,7 +399,7 @@ pgf_generate_all(PgfPGF* pgf, PgfCId cat, GuPool* pool) answers->outside_prob = 0; gu_map_put(rs->table, cat, PgfAnswers*, answers); - PgfAbsCat* abscat = gu_map_get(rs->abstract->cats, cat, PgfAbsCat*); + PgfAbsCat* abscat = gu_seq_binsearch(rs->abstract->cats, pgf_abscat_order, PgfAbsCat, cat); if (abscat != NULL) { ((PgfPredicate) abscat->predicate)(rs, NULL); } diff --git a/src/runtime/c/pgf/typechecker.c b/src/runtime/c/pgf/typechecker.c index 12a27e125..b72d8fea1 100644 --- a/src/runtime/c/pgf/typechecker.c +++ b/src/runtime/c/pgf/typechecker.c @@ -292,7 +292,7 @@ pgf_tc_type(PgfTypeChecker* checker, PgfType** pty) PgfType* ty = *pty; PgfAbsCat* abs_cat = - gu_map_get(checker->abstr->cats, ty->cid, PgfAbsCat*); + gu_seq_binsearch(checker->abstr->cats, pgf_abscat_order, PgfAbsCat, ty->cid); if (abs_cat == NULL) { GuExnData* exn = gu_raise(checker->exn, PgfExn); exn->data = (void*) @@ -459,7 +459,7 @@ pgf_inf_expr(PgfTypeChecker* checker, PgfContext* ctxt, PgfExpr* pe) if (ty == NULL) { PgfAbsFun* abs_fun = - gu_map_get(checker->abstr->funs, efun->fun, PgfAbsFun*); + gu_seq_binsearch(checker->abstr->funs, pgf_absfun_order, PgfAbsFun, efun->fun); if (abs_fun == NULL) { GuExnData* exn = gu_raise(checker->exn, PgfExn); exn->data = (void*)