From d278965095723460985989f183b8fab4a7fde779 Mon Sep 17 00:00:00 2001 From: "kr.angelov" Date: Fri, 25 Apr 2014 08:53:18 +0000 Subject: [PATCH] an initial Java/C API for predicting literals. Still not utilized --- src/runtime/c/pgf/literals.c | 25 ++++++-- src/runtime/c/pgf/pgf.h | 4 ++ src/runtime/java/jpgf.c | 62 ++++++++++++++++--- .../pgf/LiteralCallback.java | 6 +- .../pgf/NercLiteralCallback.java | 7 +++ 5 files changed, 91 insertions(+), 13 deletions(-) diff --git a/src/runtime/c/pgf/literals.c b/src/runtime/c/pgf/literals.c index 6b47aaf31..cf2003385 100644 --- a/src/runtime/c/pgf/literals.c +++ b/src/runtime/c/pgf/literals.c @@ -48,8 +48,25 @@ pgf_match_string_lit(PgfLiteralCallback* self, } } +static void +pgf_predict_empty_next(GuEnum* self, void* to, GuPool* pool) +{ + *((PgfTokenProb**) to) = NULL; +} + +static GuEnum* +pgf_predict_empty(PgfLiteralCallback* self, + size_t lin_idx, + GuString prefix, + GuPool *out_pool) +{ + GuEnum* en = gu_new(GuEnum, out_pool); + en->next = pgf_predict_empty_next; + return en; +} + static PgfLiteralCallback pgf_string_literal_callback = - { pgf_match_string_lit } ; + { pgf_match_string_lit, pgf_predict_empty } ; @@ -101,7 +118,7 @@ pgf_match_int_lit(PgfLiteralCallback* self, } static PgfLiteralCallback pgf_int_literal_callback = - { pgf_match_int_lit } ; + { pgf_match_int_lit, pgf_predict_empty } ; @@ -153,7 +170,7 @@ pgf_match_float_lit(PgfLiteralCallback* self, } static PgfLiteralCallback pgf_float_literal_callback = - { pgf_match_float_lit } ; + { pgf_match_float_lit, pgf_predict_empty } ; @@ -231,7 +248,7 @@ pgf_match_name_lit(PgfLiteralCallback* self, } PgfLiteralCallback pgf_nerc_literal_callback = - { pgf_match_name_lit } ; + { pgf_match_name_lit, pgf_predict_empty } ; PgfCallbacksMap* diff --git a/src/runtime/c/pgf/pgf.h b/src/runtime/c/pgf/pgf.h index d8c364b56..d6de05e90 100644 --- a/src/runtime/c/pgf/pgf.h +++ b/src/runtime/c/pgf/pgf.h @@ -161,6 +161,10 @@ struct PgfLiteralCallback { size_t lin_idx, GuString sentence, size_t* poffset, GuPool *out_pool); + GuEnum* (*predict)(PgfLiteralCallback* self, + size_t lin_idx, + GuString prefix, + GuPool *out_pool); }; void diff --git a/src/runtime/java/jpgf.c b/src/runtime/java/jpgf.c index 6f88250f0..c0a9873a8 100644 --- a/src/runtime/java/jpgf.c +++ b/src/runtime/java/jpgf.c @@ -713,19 +713,26 @@ typedef struct { PgfLiteralCallback callback; jobject jcallback; jmethodID match_methodId; + jmethodID predict_methodId; GuFinalizer fin; } JPgfLiteralCallback; -static PgfExprProb* -jpgf_literal_callback_fn(PgfLiteralCallback* self, - size_t lin_idx, - GuString sentence, size_t* poffset, - GuPool *out_pool) +typedef struct { + GuEnum en; + jobject jiterator; + GuFinalizer fin; +} JPgfTokenProbEnum; + +static PgfExprProb* +jpgf_literal_callback_match(PgfLiteralCallback* self, + size_t lin_idx, + GuString sentence, size_t* poffset, + GuPool *out_pool) { JPgfLiteralCallback* callback = gu_container(self, JPgfLiteralCallback, callback); JNIEnv *env; - (*cachedJVM)->AttachCurrentThread(cachedJVM, (void **)&env, NULL); + (*cachedJVM)->AttachCurrentThread(cachedJVM, &env, NULL); jstring jsentence = gu2j_string(env, sentence); jobject result = (*env)->CallObjectMethod(env, callback->jcallback, callback->match_methodId, lin_idx, jsentence, *poffset); @@ -782,13 +789,50 @@ jpgf_literal_callback_fn(PgfLiteralCallback* self, return ep; } +static void +jpgf_token_prob_enum_fin(GuFinalizer* self) +{ + JPgfTokenProbEnum* en = gu_container(self, JPgfTokenProbEnum, fin); + + JNIEnv *env; + (*cachedJVM)->AttachCurrentThread(cachedJVM, &env, NULL); + + (*env)->DeleteGlobalRef(env, en->jiterator); +} + +static GuEnum* +jpgf_literal_callback_predict(PgfLiteralCallback* self, + size_t lin_idx, + GuString prefix, + GuPool *out_pool) +{ + JPgfLiteralCallback* callback = gu_container(self, JPgfLiteralCallback, callback); + + JNIEnv *env; + (*cachedJVM)->AttachCurrentThread(cachedJVM, &env, NULL); + + jstring jprefix = gu2j_string(env, prefix); + jobject jiterator = (*env)->CallObjectMethod(env, callback->jcallback, callback->predict_methodId, lin_idx, jprefix); + if (jiterator == NULL) + return NULL; + + JPgfTokenProbEnum* en = gu_new(JPgfTokenProbEnum, out_pool); + en->en.next = NULL; + en->jiterator = (*env)->NewGlobalRef(env, jiterator); + en->fin.fn = jpgf_token_prob_enum_fin; + + gu_pool_finally(out_pool, &en->fin); + + return &en->en; +} + static void jpgf_literal_callback_fin(GuFinalizer* self) { JPgfLiteralCallback* callback = gu_container(self, JPgfLiteralCallback, fin); JNIEnv *env; - (*cachedJVM)->AttachCurrentThread(cachedJVM, (void **)&env, NULL); + (*cachedJVM)->AttachCurrentThread(cachedJVM, &env, NULL); (*env)->DeleteGlobalRef(env, callback->jcallback); } @@ -800,12 +844,14 @@ Java_org_grammaticalframework_pgf_Concr_addLiteral(JNIEnv* env, jobject self, js GuPool* pool = pgf_concr_get_pool(concr); JPgfLiteralCallback* callback = gu_new(JPgfLiteralCallback, pool); - callback->callback.match = jpgf_literal_callback_fn; + callback->callback.match = jpgf_literal_callback_match; + callback->callback.predict = jpgf_literal_callback_predict; callback->jcallback = (*env)->NewGlobalRef(env, jcallback); callback->fin.fn = jpgf_literal_callback_fin; jclass callback_class = (*env)->GetObjectClass(env, jcallback); callback->match_methodId = (*env)->GetMethodID(env, callback_class, "match", "(ILjava/lang/String;I)Lorg/grammaticalframework/pgf/LiteralCallback$CallbackResult;"); + callback->predict_methodId = (*env)->GetMethodID(env, callback_class, "predict", "(ILjava/lang/String;)Ljava/util/Iterator;"); gu_pool_finally(pool, &callback->fin); diff --git a/src/runtime/java/org/grammaticalframework/pgf/LiteralCallback.java b/src/runtime/java/org/grammaticalframework/pgf/LiteralCallback.java index 87e832ae2..106b528e6 100644 --- a/src/runtime/java/org/grammaticalframework/pgf/LiteralCallback.java +++ b/src/runtime/java/org/grammaticalframework/pgf/LiteralCallback.java @@ -1,8 +1,12 @@ package org.grammaticalframework.pgf; +import java.util.Iterator; + public interface LiteralCallback { public CallbackResult match(int lin_idx, String sentence, int start_offset); - + + public Iterator predict(int lin_idx, String prefix); + public static class CallbackResult { private ExprProb ep; private int offset; diff --git a/src/runtime/java/org/grammaticalframework/pgf/NercLiteralCallback.java b/src/runtime/java/org/grammaticalframework/pgf/NercLiteralCallback.java index 72f24e712..627cbdd4f 100644 --- a/src/runtime/java/org/grammaticalframework/pgf/NercLiteralCallback.java +++ b/src/runtime/java/org/grammaticalframework/pgf/NercLiteralCallback.java @@ -1,5 +1,8 @@ package org.grammaticalframework.pgf; +import java.util.Collections; +import java.util.Iterator; + public class NercLiteralCallback implements LiteralCallback { public CallbackResult match(int lin_idx, String sentence, int offset) { StringBuilder sbuilder = new StringBuilder(); @@ -33,4 +36,8 @@ public class NercLiteralCallback implements LiteralCallback { return null; } + + public Iterator predict(int lin_idx, String prefix) { + return Collections.emptyList().iterator(); + } }