bool gu_choice_advance(GuChoice* ch) { gu_assert(ch->path_idx <= gu_buf_length(ch->path)); while (gu_buf_length(ch->path) > ch->path_idx) { size_t last = gu_buf_pop(ch->path, size_t); if (last > 1) { gu_buf_push(ch->path, size_t, last-1); return true; } } return false; }
static void pgf_print_abs_productions(GuBuf* prods, GuOut* out, GuExn* err) { size_t n_prods = gu_buf_length(prods); for (size_t id = 1; id < n_prods; id++) { GuBuf* id_prods = gu_buf_get(prods, GuBuf*, id); size_t n_id_prods = gu_buf_length(id_prods); for (size_t i = 0; i < n_id_prods; i++) { PgfAbsProduction* prod = gu_buf_get(id_prods, PgfAbsProduction*, i); pgf_print_abs_production(id, prod, out, err); } } }
GuChoiceMark gu_choice_mark(GuChoice* ch) { gu_assert(ch->path_idx <= gu_buf_length(ch->path)); gu_debug("%p@%d: mark", ch, ch->path_idx); return (GuChoiceMark){ch->path_idx}; }
void gu_choice_reset(GuChoice* ch, GuChoiceMark mark) { gu_assert(ch->path_idx <= gu_buf_length(ch->path)); gu_debug("%p@%d: reset %d", ch, ch->path_idx, mark.path_idx); gu_require(mark.path_idx <= ch->path_idx ); ch->path_idx = mark.path_idx; }
int gu_choice_next(GuChoice* ch, int n_choices) { gu_assert(n_choices >= 0); gu_assert(ch->path_idx <= gu_buf_length(ch->path)); if (n_choices == 0) { return -1; } int i = 0; if (gu_buf_length(ch->path) > ch->path_idx) { i = (int) gu_buf_get(ch->path, size_t, ch->path_idx); gu_assert(i <= n_choices); } else { gu_buf_push(ch->path, size_t, n_choices); i = n_choices; } int ret = (i == 0) ? -1 : n_choices - i; gu_debug("%p@%d: %d", ch, ch->path_idx, ret); ch->path_idx++; return ret; }
static void pgf_bracket_lzn_end_phrase(PgfLinFuncs** funcs, PgfCId cat, int fid, int lindex, PgfCId fun) { PgfBracketLznState* state = gu_container(funcs, PgfBracketLznState, funcs); JNIEnv* env = state->env; GuBuf* parent = gu_buf_pop(state->stack, GuBuf*); if (gu_buf_length(state->list) > 0) { jstring jcat = gu2j_string(env, cat); jstring jfun = gu2j_string(env, fun); size_t len = gu_buf_length(state->list); jobjectArray jchildren = (*env)->NewObjectArray(env, len, state->object_class, NULL); for (int i = 0; i < len; i++) { jobject obj = gu_buf_get(state->list, jobject, i); (*env)->SetObjectArrayElement(env, jchildren, i, obj); (*env)->DeleteLocalRef(env, obj); } jobject jbracket = (*env)->NewObject(env, state->bracket_class, state->bracket_constrId, jcat, jfun, fid, lindex, jchildren); (*env)->DeleteLocalRef(env, jchildren); (*env)->DeleteLocalRef(env, jfun); (*env)->DeleteLocalRef(env, jcat); gu_buf_push(parent, jobject, jbracket); } state->list = parent; }
static void pgf_lookup_index_syms(GuMap* lexicon_idx, PgfSymbols* syms, PgfAbsFun* absfun, GuPool* pool) { size_t n_syms = gu_seq_length(syms); for (size_t j = 0; j < n_syms; j++) { PgfSymbol sym = gu_seq_get(syms, PgfSymbol, j); GuVariantInfo i = gu_variant_open(sym); switch (i.tag) { case PGF_SYMBOL_KP: { PgfSymbolKP* skp = (PgfSymbolKP*) i.data; pgf_lookup_index_syms(lexicon_idx, skp->default_form, absfun, pool); for (size_t k = 0; k < skp->n_forms; k++) { pgf_lookup_index_syms(lexicon_idx, skp->forms[k].form, absfun, pool); } break; } case PGF_SYMBOL_KS: { PgfSymbolKS* sks = (PgfSymbolKS*) i.data; GuBuf* funs = gu_map_get(lexicon_idx, sks->token, GuBuf*); if (funs == NULL) { funs = gu_new_buf(PgfAbsFun*, pool); gu_map_put(lexicon_idx, sks->token, GuBuf*, funs); } bool found = false; size_t n_funs = gu_buf_length(funs); for (size_t l = 0; l < n_funs; l++) { PgfAbsFun* absfun1 = gu_buf_get(funs, PgfAbsFun*, l); if (absfun1 == absfun) { found = true; break; } } if (!found) gu_buf_push(funs, PgfAbsFun*, absfun); break; } } }
JNIEXPORT jobjectArray JNICALL Java_org_grammaticalframework_pgf_Concr_bracketedLinearize(JNIEnv* env, jobject self, jobject jexpr) { jclass object_class = (*env)->FindClass(env, "java/lang/Object"); if (!object_class) return NULL; jclass bracket_class = (*env)->FindClass(env, "org/grammaticalframework/pgf/Bracket"); if (!bracket_class) return NULL; jmethodID bracket_constrId = (*env)->GetMethodID(env, bracket_class, "<init>", "(Ljava/lang/String;Ljava/lang/String;II[Ljava/lang/Object;)V"); if (!bracket_constrId) return NULL; GuPool* tmp_pool = gu_local_pool(); GuExn* err = gu_exn(tmp_pool); PgfConcr* concr = get_ref(env, self); GuEnum* cts = pgf_lzr_concretize(concr, gu_variant_from_ptr((void*) get_ref(env, jexpr)), err, tmp_pool); if (!gu_ok(err)) { if (gu_exn_caught(err, PgfExn)) { GuString msg = (GuString) gu_exn_caught_data(err); throw_string_exception(env, "org/grammaticalframework/pgf/PGFError", msg); } else { throw_string_exception(env, "org/grammaticalframework/pgf/PGFError", "The expression cannot be concretized"); } gu_pool_free(tmp_pool); return NULL; } PgfCncTree ctree = gu_next(cts, PgfCncTree, tmp_pool); if (gu_variant_is_null(ctree)) { throw_string_exception(env, "org/grammaticalframework/pgf/PGFError", "The expression cannot be concretized"); gu_pool_free(tmp_pool); return NULL; } ctree = pgf_lzr_wrap_linref(ctree, tmp_pool); PgfBracketLznState state; state.funcs = &pgf_bracket_lin_funcs; state.env = env; state.tmp_pool = tmp_pool; state.stack = gu_new_buf(GuBuf*, tmp_pool); state.list = gu_new_buf(jobject, tmp_pool); state.object_class = object_class; state.bracket_class = bracket_class; state.bracket_constrId = bracket_constrId; pgf_lzr_linearize(concr, ctree, 0, &state.funcs, tmp_pool); size_t len = gu_buf_length(state.list); jobjectArray array = (*env)->NewObjectArray(env, len, object_class, NULL); for (int i = 0; i < len; i++) { jobject obj = gu_buf_get(state.list, jobject, i); (*env)->SetObjectArrayElement(env, array, i, obj); (*env)->DeleteLocalRef(env, obj); } gu_pool_free(tmp_pool); return array; }
static PgfExpr pgf_value2expr(PgfReasoner* rs, int level, PgfClosure* clos) { clos = rs->eval_gates->enter(rs, clos); if (clos == NULL) return gu_null_variant; PgfExpr expr = gu_null_variant; size_t n_args = 0; PgfClosure** args; if (clos->code == rs->eval_gates->evaluate_value) { PgfValue* val = (PgfValue*) clos; PgfAbsFun* absfun = gu_container(val->con, PgfAbsFun, closure); expr = absfun->ep.expr; n_args = absfun->arity; args = val->args; } else if (clos->code == rs->eval_gates->evaluate_value_lit) { PgfValueLit* val = (PgfValueLit*) clos; PgfExprLit *elit = gu_new_variant(PGF_EXPR_LIT, PgfExprLit, &expr, rs->out_pool); GuVariantInfo i = gu_variant_open(val->lit); switch (i.tag) { case PGF_LITERAL_STR: { PgfLiteralStr* lstr = i.data; PgfLiteralStr* new_lstr = gu_new_flex_variant(PGF_LITERAL_STR, PgfLiteralStr, val, strlen(lstr->val)+1, &elit->lit, rs->out_pool); strcpy(new_lstr->val, lstr->val); break; } case PGF_LITERAL_INT: { PgfLiteralInt* lint = i.data; PgfLiteralInt* new_lint = gu_new_variant(PGF_LITERAL_INT, PgfLiteralInt, &elit->lit, rs->out_pool); new_lint->val = lint->val; break; } case PGF_LITERAL_FLT: { PgfLiteralFlt* lflt = i.data; PgfLiteralFlt* new_lflt = gu_new_variant(PGF_LITERAL_FLT, PgfLiteralFlt, &elit->lit, rs->out_pool); new_lflt->val = lflt->val; break; } default: gu_impossible(); } } else if (clos->code == rs->eval_gates->evaluate_value_pap) { PgfValuePAP *pap = (PgfValuePAP*) clos; PgfValueGen* gen = gu_new(PgfValueGen, rs->pool); gen->header.code = rs->eval_gates->evaluate_gen; gen->level = level; size_t n_args = pap->n_args/sizeof(PgfClosure*); PgfValuePAP* new_pap = gu_new_flex(rs->pool, PgfValuePAP, args, n_args+1); new_pap->header.code = rs->eval_gates->evaluate_value_pap; new_pap->fun = pap->fun; new_pap->n_args = pap->n_args+sizeof(PgfClosure*); new_pap->args[0] = &gen->header; for (size_t i = 0; i < n_args; i++) { new_pap->args[i+1] = pap->args[i]; } PgfExprAbs *eabs = gu_new_variant(PGF_EXPR_ABS, PgfExprAbs, &expr, rs->out_pool); eabs->bind_type = PGF_BIND_TYPE_EXPLICIT; eabs->id = gu_format_string(rs->out_pool, "v%d", level); eabs->body = pgf_value2expr(rs, level+1, &new_pap->header); } else if (clos->code == rs->eval_gates->evaluate_value_const) { PgfValuePAP* val = (PgfValuePAP*) clos; if (val->fun->code == rs->eval_gates->evaluate_meta) { PgfValueMeta* fun = (PgfValueMeta*) val->fun; PgfExprMeta *emeta = gu_new_variant(PGF_EXPR_META, PgfExprMeta, &expr, rs->out_pool); emeta->id = fun->id; } else if (val->fun->code == rs->eval_gates->evaluate_gen) { PgfValueGen* fun = (PgfValueGen*) val->fun; PgfExprVar *evar = gu_new_variant(PGF_EXPR_VAR, PgfExprVar, &expr, rs->out_pool); evar->var = level - fun->level - 1; } else if (val->fun->code == rs->eval_gates->evaluate_sum) { PgfValueSum* sum = (PgfValueSum*) val->fun; PgfExpr e1,e2; PgfExprFun *efun = gu_new_flex_variant(PGF_EXPR_FUN, PgfExprFun, fun, 2, &e1, rs->out_pool); strcpy(efun->fun, "+"); PgfExprLit *elit = gu_new_variant(PGF_EXPR_LIT, PgfExprLit, &e2, rs->out_pool); elit->lit = sum->lit; PgfExprApp* eapp = gu_new_variant(PGF_EXPR_APP, PgfExprApp, &expr, rs->out_pool); eapp->fun = e1; eapp->arg = e2; size_t n_consts = gu_buf_length(sum->consts); for (size_t i = 0; i < n_consts; i++) { PgfClosure* con = gu_buf_get(sum->consts, PgfClosure*, i); PgfExpr fun = expr; PgfExpr arg = pgf_value2expr(rs, level, con); if (gu_variant_is_null(arg)) return gu_null_variant; PgfExprApp* e = gu_new_variant(PGF_EXPR_APP, PgfExprApp, &expr, rs->out_pool); e->fun = fun; e->arg = arg; } } else {