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 {
