GitHub/gf-core
1
0
Fork 1
mirror of https://github.com/GrammaticalFramework/gf-core.git synced 2026-04-09 04:59:31 -06:00
Code Issues Packages Projects Releases Wiki Activity

Update the C bindings to build with the current PGF API

Browse Source
This commit is contained in:
kevin.kofler
2010-05-16 21:09:51 +00:00
parent 218beec02c
commit 2e6512e3fd
4 changed files with 94 additions and 95 deletions
Download Patch File Download Diff File Expand all files Collapse all files

122
contrib/c-bindings/PGFFFI.hs
View File

@@ -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 ()
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.
-- TODO: * Functions
-- * Expressions & Trees
-- ** Tree
foreign export ccall "gf_freeTree" freeStablePtr :: StablePtr Tree -> IO ()
-- TODO: Literal(..)
-- (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))
-- ** Expr
foreign export ccall "gf_freeExpr" freeStablePtr :: StablePtr Expr -> IO ()
-- TODO: Equation(..)
-- (Not much use exporting a free function for that type if you can't do anything with it.)
-- TODO: allow nonempty scope
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
gf_showPrintName pgf lang tp = do
foreign export ccall gf_showPrintName :: StablePtr PGF -> StablePtr Language -> StablePtr CId -> IO CString
gf_showPrintName pgf lang cid = do
p <- (deRefStablePtr pgf)
l <- (deRefStablePtr lang)
t <- (deRefStablePtr tp)
(newCString (showPrintName p l t))
c <- (deRefStablePtr cid)
(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
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, parse_, parseWithRecovery
-- TODO: parseAllLang, parseAll
-- TODO: tree2expr, expr2tree, PGF.compute, paraphrase, typecheck
-- TODO: complete, Incremental.ParseState, initState, Incremental.nextState, Incremental.getCompletions, extractExps
-- TODO: generateRandom, generateAll, generateAllDepth
-- TODO: ** Evaluation
-- TODO: ** Type Checking
-- TODO: ** Low level parsing API
-- TODO: ** Generation
-- TODO: ** Morphological Analysis
-- TODO: ** Visualizations
-- TODO: * Browsing
-- GF.Text.Lexing:

2
contrib/c-bindings/gfctest.c
View File

@@ -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);

20
contrib/c-bindings/pgf.h
View File

@@ -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;

45
contrib/c-bindings/readme-ffi.txt
View File

@@ -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]
startCat :: PGF -> Type
mkCId :: String -> CId
prCId :: CId -> String
wildCId :: CId
showTree :: Tree -> String
readTree :: String -> Maybe Tree
showExpr :: Expr -> String
categories :: PGF -> [CId]
startCat :: PGF -> Type
showExpr :: Expr -> [CId] -> String (*)
readExpr :: String -> Maybe Expr
linearize :: PGF -> Language -> Tree -> String
showPrintName :: PGF -> Language -> Type -> String
parse :: PGF -> Language -> Type -> String -> [Tree]
canParse :: PGF -> Language -> Bool
linearize :: PGF -> Language -> Tree -> String
showPrintName :: PGF -> Language -> CId -> String
parse :: PGF -> Language -> Type -> String -> [Tree]
(*) 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);