Update the C bindings to build with the current PGF API

contrib/c-bindings/PGFFFI.hs

@@ -53,8 +53,7 @@ listToArray list = do
     return buf
 
 
--- PGF:
+-- * PGF
-
 foreign export ccall "gf_freePGF" freeStablePtr :: StablePtr PGF -> IO ()
 
 foreign export ccall gf_readPGF :: CString -> IO (StablePtr PGF)
@@ -63,6 +62,34 @@ gf_readPGF path = do
   result <- (readPGF p)
   (newStablePtr result)
 
+-- * Identifiers
+foreign export ccall "gf_freeCId" freeStablePtr :: StablePtr CId -> IO ()
+
+foreign export ccall gf_mkCId :: CString -> IO (StablePtr CId)
+gf_mkCId str = do
+  s <- (peekCString str)
+  (newStablePtr (mkCId s))
+
+foreign export ccall gf_wildCId :: IO (StablePtr CId)
+gf_wildCId = do
+  (newStablePtr (wildCId))
+
+foreign export ccall gf_showCId :: StablePtr CId -> IO CString
+gf_showCId cid = do
+  c <- (deRefStablePtr cid)
+  (newCString (showCId c))
+
+foreign export ccall gf_readCId :: CString -> IO (StablePtr CId)
+gf_readCId str = do
+  s <- (peekCString str)
+  case (readCId s) of
+    Just x -> (newStablePtr x)
+    Nothing -> (return (nullStablePtr))
+
+-- TODO: So we can create, print and free a CId, but can we do anything useful with it?
+--       We need some kind of C wrapper for the tree datastructures.
+
+-- * Languages
 foreign export ccall "gf_freeLanguage" freeStablePtr :: StablePtr Language -> IO ()
 
 foreign export ccall gf_showLanguage :: StablePtr Language -> IO CString
@@ -95,12 +122,16 @@ gf_languageCode pgf lang = do
     Just s -> (newCString s)
     Nothing -> (return nullPtr)
 
+-- * Types
 foreign export ccall "gf_freeType" freeStablePtr :: StablePtr Type -> IO ()
 
+-- TODO: Hypo
+
+-- TODO: allow nonempty scope
 foreign export ccall gf_showType :: StablePtr Type -> IO CString
 gf_showType tp = do
   t <- (deRefStablePtr tp)
-  (newCString (showType t))
+  (newCString (showType [] t))
 
 foreign export ccall gf_readType :: CString -> IO (StablePtr Type)
 gf_readType str = do
@@ -109,7 +140,9 @@ gf_readType str = do
     Just x -> (newStablePtr x)
     Nothing -> (return (nullStablePtr))
 
-foreign export ccall gf_categories :: StablePtr PGF -> IO (Ptr (StablePtr Type))
+-- TODO: mkType, mkHypo, mkDepHypo, mkImplHypo
+
+foreign export ccall gf_categories :: StablePtr PGF -> IO (Ptr (StablePtr CId))
 gf_categories pgf = do
   p <- (deRefStablePtr pgf)
   (listToArray (categories p))
@@ -119,51 +152,20 @@ gf_startCat pgf = do
   p <- (deRefStablePtr pgf)
   (newStablePtr (startCat p))
 
-foreign export ccall "gf_freeCId" freeStablePtr :: StablePtr CId -> IO ()
+-- TODO: * Functions
-
-foreign export ccall gf_mkCId :: CString -> IO (StablePtr CId)
-gf_mkCId str = do
-  s <- (peekCString str)
-  (newStablePtr (mkCId s))
-
-foreign export ccall gf_prCId :: StablePtr CId -> IO CString
-gf_prCId cid = do
-  c <- (deRefStablePtr cid)
-  (newCString (prCId c))
-
-foreign export ccall gf_wildCId :: IO (StablePtr CId)
-gf_wildCId = do
-  (newStablePtr (wildCId))
-
--- TODO: So we can create, print and free a CId, but can we do anything useful with it?
---       We need some kind of C wrapper for the tree datastructures.
 
+-- * Expressions & Trees
+-- ** Tree
 foreign export ccall "gf_freeTree" freeStablePtr :: StablePtr Tree -> IO ()
 
--- TODO: Literal(..)
+-- ** Expr
--- (Not much use exporting a free function for that type if you can't do anything with it.)
-
-foreign export ccall gf_showTree :: StablePtr Tree -> IO CString
-gf_showTree tree = do
-  t <- (deRefStablePtr tree)
-  (newCString (showTree t))
-
-foreign export ccall gf_readTree :: CString -> IO (StablePtr Tree)
-gf_readTree str = do
-  s <- (peekCString str)
-  case (readTree s) of
-    Just x -> (newStablePtr x)
-    Nothing -> (return (nullStablePtr))
-
 foreign export ccall "gf_freeExpr" freeStablePtr :: StablePtr Expr -> IO ()
 
--- TODO: Equation(..)
+-- TODO: allow nonempty scope
--- (Not much use exporting a free function for that type if you can't do anything with it.)
-
 foreign export ccall gf_showExpr :: StablePtr Expr -> IO CString
 gf_showExpr expr = do
   e <- (deRefStablePtr expr)
-  (newCString (showExpr e))
+  (newCString (showExpr [] e))
 
 foreign export ccall gf_readExpr :: CString -> IO (StablePtr Expr)
 gf_readExpr str = do
@@ -172,6 +174,8 @@ gf_readExpr str = do
     Just x -> (newStablePtr x)
     Nothing -> (return (nullStablePtr))
 
+-- * Operations
+-- ** Linearization
 foreign export ccall gf_linearize :: StablePtr PGF -> StablePtr Language -> StablePtr Tree -> IO CString
 gf_linearize pgf lang tree = do
   p <- (deRefStablePtr pgf)
@@ -179,15 +183,19 @@ gf_linearize pgf lang tree = do
   t <- (deRefStablePtr tree)
   (newCString (linearize p l t))
 
--- TODO: linearizeAllLang, linearizeAll
+-- TODO: linearizeAllLang, linearizeAll, bracketedLinearize, tabularLinearizes
+-- TODO: groupResults
 
-foreign export ccall gf_showPrintName :: StablePtr PGF -> StablePtr Language -> StablePtr Type -> IO CString
+foreign export ccall gf_showPrintName :: StablePtr PGF -> StablePtr Language -> StablePtr CId -> IO CString
-gf_showPrintName pgf lang tp = do
+gf_showPrintName pgf lang cid = do
   p <- (deRefStablePtr pgf)
   l <- (deRefStablePtr lang)
-  t <- (deRefStablePtr tp)
+  c <- (deRefStablePtr cid)
-  (newCString (showPrintName p l t))
+  (newCString (showPrintName p l c))
 
+-- TODO: BracketedString(..), FId, LIndex, Forest.showBracketedString
+
+-- ** Parsing
 foreign export ccall gf_parse :: StablePtr PGF -> StablePtr Language -> StablePtr Type -> CString -> IO (Ptr (StablePtr Tree))
 gf_parse pgf lang cat input = do
   p <- (deRefStablePtr pgf)
@@ -196,22 +204,16 @@ gf_parse pgf lang cat input = do
   i <- (peekCString input)
   (listToArray (parse p l c i))
 
-foreign export ccall gf_canParse :: StablePtr PGF -> StablePtr Language -> IO CInt
+-- TODO: parseAllLang, parseAll, parse_, parseWithRecovery
-gf_canParse pgf lang = do
-  p <- (deRefStablePtr pgf)
-  l <- (deRefStablePtr lang)
-  case (canParse p l) of
-    True -> (return 1)
-    False -> (return 0)
 
--- TODO: parseAllLang, parseAll
+-- TODO: ** Evaluation
-
+-- TODO: ** Type Checking
--- TODO: tree2expr, expr2tree, PGF.compute, paraphrase, typecheck
+-- TODO: ** Low level parsing API
-
+-- TODO: ** Generation
--- TODO: complete, Incremental.ParseState, initState, Incremental.nextState, Incremental.getCompletions, extractExps
+-- TODO: ** Morphological Analysis
-
+-- TODO: ** Visualizations
--- TODO: generateRandom, generateAll, generateAllDepth
 
+-- TODO: * Browsing
 
 -- GF.Text.Lexing:
 

contrib/c-bindings/gfctest.c

@@ -32,7 +32,7 @@ int main(int argc, char *argv[])
   GF_Tree *p = result;
   if (*p) {
     do {
-      char *str = gf_showTree(*(p++));
+      char *str = gf_showExpr(*(p++));
       puts(str);
       free(str);
     } while (*p);

contrib/c-bindings/pgf.h

@@ -36,13 +36,21 @@ static inline void gf_exit(void)
   hs_exit();
 }
 
-typedef HsStablePtr GF_Language;
 typedef HsStablePtr GF_PGF;
-typedef HsStablePtr GF_Type;
 typedef HsStablePtr GF_CId;
+typedef HsStablePtr GF_Language;
+typedef HsStablePtr GF_Type;
 typedef HsStablePtr GF_Tree;
 typedef HsStablePtr GF_Expr;
 
+static inline void gf_freeCIds(GF_CId *p)
+{
+  GF_CId *q = p;
+  while (*q)
+    gf_freeCId(*(q++));
+  free(p);
+}
+
 static inline void gf_freeLanguages(GF_Language *p)
 {
   GF_Language *q = p;
@@ -51,14 +59,6 @@ static inline void gf_freeLanguages(GF_Language *p)
   free(p);
 }
 
-static inline void gf_freeTypes(GF_Type *p)
-{
-  GF_Type *q = p;
-  while (*q)
-    gf_freeType(*(q++));
-  free(p);
-}
-
 static inline void gf_freeTrees(GF_Tree *p)
 {
   GF_Type *q = p;

contrib/c-bindings/readme-ffi.txt

@@ -25,26 +25,25 @@ applications. To use it:
 
 Currently, the following functions from PGF are wrapped:
 readPGF  :: FilePath -> IO PGF
+mkCId :: String -> CId
+wildCId :: CId
+showCId :: CId -> String
+readCId :: String -> Maybe CId
 showLanguage :: Language -> String
 readLanguage :: String -> Maybe Language
-languages    :: PGF -> [Language]
+languages :: PGF -> [Language]
 abstractName :: PGF -> Language
 languageCode :: PGF -> Language -> Maybe String
-showType :: Type -> String
+showType :: Type -> [CId] -> String (*)
 readType :: String -> Maybe Type
-categories :: PGF -> [Type]
+categories :: PGF -> [CId]
-startCat   :: PGF -> Type
+startCat :: PGF -> Type
-mkCId :: String -> CId
+showExpr :: Expr -> [CId] -> String (*)
-prCId :: CId -> String
-wildCId :: CId
-showTree :: Tree -> String
-readTree :: String -> Maybe Tree
-showExpr :: Expr -> String
 readExpr :: String -> Maybe Expr
-linearize    :: PGF -> Language -> Tree -> String
+linearize :: PGF -> Language -> Tree -> String
-showPrintName :: PGF -> Language -> Type -> String
+showPrintName :: PGF -> Language -> CId -> String
-parse        :: PGF -> Language -> Type -> String -> [Tree]
+parse :: PGF -> Language -> Type -> String -> [Tree]
-canParse     :: PGF -> Language -> Bool
+(*) The [CId] parameter is currently not mapped; instead, [] is always passed.
 
 
 Some notes about the wrapping:
@@ -78,6 +77,10 @@ Some notes about the wrapping:
 
 Thus, the C prototypes for the wrapped functions are:
 GF_PGF *gf_readPGF(char *path);
+GF_CId gf_mkCId(char *str);
+GF_CId wildCId(void);
+char *gf_showCId(GF_CID cid);
+GF_CId gf_readCId(char *str); /* may return NULL */
 char *gf_showLanguage(GF_Language lang);
 GF_Language gf_readLanguage(char *str); /* may return NULL */
 GF_Language *gf_languages(GF_PGF pgf);
@@ -85,29 +88,23 @@ GF_Language gf_abstractName(GF_PGF pgf);
 char *gf_languageCode(GF_PGF pgf, GF_Language lang); /* may return NULL */
 char *gf_showType(GF_Type tp);
 GF_Type gf_readType(char *str); /* may return NULL */
-GF_Type *gf_categories(GF_PGF pgf);
+GF_CId *gf_categories(GF_PGF pgf);
 GF_Type gf_startCat(GF_PGF pgf);
-GF_CId gf_mkCId(char *str);
-char *gf_prCId(GF_CID cid);
-GF_CId wildCId(void);
-char *gf_showTree(GF_Tree tree);
-GF_Tree gf_readTree(char *str); /* may return NULL */
 char *gf_showExpr(GF_Expr expr);
 GF_Expr gf_readExpr(char *str); /* may return NULL */
 char *gf_linearize(GF_PGF pgf, GF_Language lang, GF_Tree tree);
-char *gf_showPrintName(GF_PGF pgf, GF_Language lang, GF_Type tp);
+char *gf_showPrintName(GF_PGF pgf, GF_Language lang, GF_CId cid);
 GF_Tree *gf_parse(GF_PGF pgf, GF_Language lang, GF_Type cat, char *input);
-int gf_canParse(GF_PGF pgf, GF_Language lang); /* returns 0 or 1 */
 
 The C prototypes for the freeing functions are:
 void gf_freePGF(GF_PGF pgf);
+void gf_freeCId(GF_CId cid);
 void gf_freeLanguage(GF_Language lang);
 void gf_freeType(GF_Type tp);
-void gf_freeCId(GF_CId cid);
 void gf_freeTree(GF_Tree tree);
 void gf_freeExpr(GF_Expr expr);
+void gf_freeCIds(GF_Type *p);
 void gf_freeLanguages(GF_Language *p);
-void gf_freeTypes(GF_Type *p);
 void gf_freeTrees(GF_Tree *p);