msyds/gf-core
1
0
Fork 0
forked from GitHub/gf-core
Code Pull Requests Activity

remove the pgf2yaml tool which was both broken and redundant. The declarations for generic programming from data.c are removed as well

Browse Source
This commit is contained in:
kr.angelov
2013-02-11 13:51:12 +00:00
parent 10ef298fa0
commit 90c3304147
11 changed files with 281 additions and 593 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/runtime/c/Makefile.am
View File

@@ -117,15 +117,11 @@ libpgf_la_SOURCES = \
pgf/pgf.h
bin_PROGRAMS = \
utils/pgf2yaml \
utils/pgf-print \
utils/pgf-translate \
utils/pgf-parse \
utils/pgf-chunk
utils_pgf2yaml_SOURCES = utils/pgf2yaml.c
utils_pgf2yaml_LDADD = libpgf.la libgu.la
utils_pgf_print_SOURCES = utils/pgf-print.c
utils_pgf_print_LDADD = libpgf.la libgu.la

201
src/runtime/c/pgf/data.c
View File

@@ -22,218 +22,33 @@ pgf_tokens_equal(PgfTokens t1, PgfTokens t2)
return true;
}
GU_DEFINE_TYPE(PgfTokens, GuSeq, gu_type(GuString));
GU_DEFINE_TYPE(PgfCId, typedef, gu_type(GuString));
GU_DEFINE_TYPE(GuStringL, GuList, gu_type(GuString));
#define gu_type__PgfCIdMap gu_type__GuStringMap
typedef GuType_GuStringMap GuType_PgfCIdMap;
#define GU_TYPE_INIT_PgfCIdMap GU_TYPE_INIT_GuStringMap
GU_DEFINE_TYPE(PgfCCat, struct,
GU_MEMBER_S(PgfCCat, cnccat, PgfCncCat),
GU_MEMBER_P(PgfCCat, lindefs, PgfFunIds),
GU_MEMBER(PgfCCat, prods, PgfProductionSeq));
GU_DEFINE_TYPE(PgfCCat, abstract);
GU_DEFINE_TYPE(PgfCCatId, shared, gu_type(PgfCCat));
GU_DEFINE_TYPE(PgfCncCat, abstract);
GU_DEFINE_TYPE(PgfCCatIds, GuList, gu_type(PgfCCatId));
GU_DEFINE_TYPE(PgfFlags, GuStringMap, gu_type(GuVariant), &gu_null_variant);
GU_DEFINE_TYPE(PgfCCatSeq, GuSeq, gu_type(PgfCCatId));
GU_DEFINE_TYPE(PgfProductionSeq, GuSeq, gu_type(GuVariant));
GU_DEFINE_TYPE(PgfAlternative, struct,
GU_MEMBER(PgfAlternative, form, PgfTokens),
GU_MEMBER_P(PgfAlternative, prefixes, GuStringL));
GU_DEFINE_TYPE(
PgfSymbol, GuVariant,
GU_CONSTRUCTOR_S(
PGF_SYMBOL_CAT, PgfSymbolCat,
GU_MEMBER(PgfSymbolCat, d, int),
GU_MEMBER(PgfSymbolCat, r, int)),
GU_CONSTRUCTOR_S(
PGF_SYMBOL_LIT, PgfSymbolLit,
GU_MEMBER(PgfSymbolLit, d, int),
GU_MEMBER(PgfSymbolLit, r, int)),
GU_CONSTRUCTOR_S(
PGF_SYMBOL_VAR, PgfSymbolVar,
GU_MEMBER(PgfSymbolVar, d, int),
GU_MEMBER(PgfSymbolVar, r, int)),
GU_CONSTRUCTOR_S(
PGF_SYMBOL_KS, PgfSymbolKS,
GU_MEMBER(PgfSymbolKS, tokens, PgfTokens)),
GU_CONSTRUCTOR_S(
PGF_SYMBOL_KP, PgfSymbolKP,
GU_MEMBER(PgfSymbolKP, default_form, PgfTokens),
GU_MEMBER(PgfSymbolKP, n_forms, GuLength),
GU_FLEX_MEMBER(PgfSymbolKP, forms, PgfAlternative)));
GU_DEFINE_TYPE(
PgfCncCat, struct,
GU_MEMBER(PgfCncCat, abscat, PgfCat),
GU_MEMBER_P(PgfCncCat, cats, PgfCCatIds),
GU_MEMBER(PgfCncCat, n_lins, size_t),
GU_FLEX_MEMBER(PgfCncCat, labels, GuString));
// GU_DEFINE_TYPE(PgfSequence, GuList, gu_ptr_type(PgfSymbol));
// GU_DEFINE_TYPE(PgfSequence, GuList, gu_type(PgfSymbol));
GU_DEFINE_TYPE(PgfSequence, GuSeq, gu_type(PgfSymbol));
GU_DEFINE_TYPE(PgfFlags, GuStringMap, gu_type(PgfLiteral), &gu_null_variant);
typedef PgfFlags* PgfFlagsP;
GU_DEFINE_TYPE(PgfFlagsP, pointer, gu_type(PgfFlags));
GU_DEFINE_TYPE(PgfSequences, GuList, gu_type(PgfSequence));
GU_DEFINE_TYPE(PgfSeqId, typedef, gu_type(PgfSequence));
GU_DEFINE_TYPE(
PgfCncFun, struct,
GU_MEMBER(PgfCncFun, name, PgfCId),
GU_MEMBER(PgfCncFun, n_lins, GuLength),
GU_FLEX_MEMBER(PgfCncFun, lins, PgfSeqId));
GU_DEFINE_TYPE(PgfCncFuns, GuList,
GU_TYPE_LIT(referenced, _, gu_ptr_type(PgfCncFun)));
GU_DEFINE_TYPE(PgfFunId, shared, gu_type(PgfCncFun));
GU_DEFINE_TYPE(PgfFunIds, GuList, gu_type(PgfFunId));
GU_DEFINE_TYPE(
PgfPArg, struct,
GU_MEMBER_P(PgfPArg, hypos, PgfCCatIds),
GU_MEMBER(PgfPArg, ccat, PgfCCatId));
GU_DEFINE_TYPE(PgfPArgs, GuSeq, gu_type(PgfPArg));
GU_DEFINE_TYPE(
PgfProduction, GuVariant,
GU_CONSTRUCTOR_S(
PGF_PRODUCTION_APPLY, PgfProductionApply,
GU_MEMBER(PgfProductionApply, fun, PgfFunId),
GU_MEMBER(PgfProductionApply, args, PgfPArgs)),
GU_CONSTRUCTOR_S(
PGF_PRODUCTION_COERCE, PgfProductionCoerce,
GU_MEMBER(PgfProductionCoerce, coerce, PgfCCatId)),
GU_CONSTRUCTOR_S(
PGF_PRODUCTION_EXTERN, PgfProductionExtern,
GU_MEMBER(PgfProductionExtern, callback, PgfLiteralCallback),
GU_MEMBER(PgfProductionExtern, lins, GuSeq)),
GU_CONSTRUCTOR_S(
PGF_PRODUCTION_META, PgfProductionMeta,
GU_MEMBER(PgfProductionMeta, args, PgfPArgs)));
GU_DEFINE_TYPE(PgfProductions, GuList, gu_type(PgfProduction));
GU_DEFINE_TYPE(PgfProductionSeq, GuSeq, gu_type(PgfProduction));
GU_DEFINE_TYPE(
PgfPatt, GuVariant,
GU_CONSTRUCTOR_S(
PGF_PATT_APP, PgfPattApp,
GU_MEMBER(PgfPattApp, ctor, PgfCId),
GU_MEMBER(PgfPattApp, n_args, GuLength),
GU_FLEX_MEMBER(PgfPattApp, args, PgfPatt)),
GU_CONSTRUCTOR_S(
PGF_PATT_VAR, PgfPattVar,
GU_MEMBER(PgfPattVar, var, PgfCId)),
GU_CONSTRUCTOR_S(
PGF_PATT_AS, PgfPattAs,
GU_MEMBER(PgfPattAs, var, PgfCId),
GU_MEMBER(PgfPattAs, patt, PgfPatt)),
GU_CONSTRUCTOR(
PGF_PATT_WILD, void),
GU_CONSTRUCTOR_S(
PGF_PATT_LIT, PgfPattLit,
GU_MEMBER(PgfPattLit, lit, PgfLiteral)),
GU_CONSTRUCTOR_S(
PGF_PATT_IMPL_ARG, PgfPattImplArg,
GU_MEMBER(PgfPattImplArg, patt, PgfPatt)),
GU_CONSTRUCTOR_S(
PGF_PATT_TILDE, PgfPattTilde,
GU_MEMBER(PgfPattTilde, expr, PgfExpr)));
GU_DEFINE_TYPE(
PgfEquation, struct,
GU_MEMBER(PgfEquation, body, PgfExpr),
GU_MEMBER(PgfEquation, n_patts, GuLength),
GU_FLEX_MEMBER(PgfEquation, patts, PgfPatt));
// Distinct type so we can give it special treatment in the reader
GU_DEFINE_TYPE(PgfEquationsM, GuSeq, gu_type(PgfEquation));
GU_DEFINE_TYPE(PgfExprProb, struct,
GU_MEMBER(PgfExprProb, prob, double),
GU_MEMBER(PgfExprProb, expr, PgfExpr));
GU_DEFINE_TYPE(
PgfFunDecl, struct,
GU_MEMBER_P(PgfFunDecl, type, PgfType),
GU_MEMBER(PgfFunDecl, arity, int),
GU_MEMBER(PgfFunDecl, defns, PgfEquationsM),
GU_MEMBER(PgfFunDecl, ep, PgfExprProb));
GU_DEFINE_TYPE(PgfAbsFun, abstract);
static prob_t inf_prob = INFINITY;
GU_DEFINE_TYPE(prob_t, GuFloating, _);
GU_DEFINE_TYPE(PgfMetaChildMap, GuMap,
gu_type(PgfCat), NULL,
gu_type(PgfAbsCat), NULL,
gu_type(prob_t), &inf_prob);
GU_DEFINE_TYPE(
PgfCat, struct,
GU_MEMBER(PgfCat, context, PgfHypos));
GU_DEFINE_TYPE(
PgfAbstr, struct,
GU_MEMBER(PgfAbstr, aflags, PgfFlagsP),
GU_MEMBER_V(PgfAbstr, funs,
GU_TYPE_LIT(pointer, PgfCIdMap*,
GU_TYPE_LIT(PgfCIdMap, _,
gu_ptr_type(PgfFunDecl),
&gu_null_struct))),
GU_MEMBER_V(PgfAbstr, cats,
GU_TYPE_LIT(pointer, PgfCIdMap*,
GU_TYPE_LIT(PgfCIdMap, _,
gu_ptr_type(PgfCat),
&gu_null_struct))));
GU_DEFINE_TYPE(PgfAbsCat, abstract);
GU_DEFINE_TYPE(
PgfPrintNames, PgfCIdMap, gu_type(GuString), &gu_empty_string);
GU_DEFINE_TYPE(
PgfConcr, struct,
GU_MEMBER(PgfConcr, cflags, PgfFlagsP),
GU_MEMBER_P(PgfConcr, ccats, GuMap),
GU_MEMBER_P(PgfConcr, cncfuns, PgfCncFuns),
GU_MEMBER_P(PgfConcr, sequences, PgfSequences),
GU_MEMBER_P(PgfConcr, printnames, PgfPrintNames),
GU_MEMBER_V(PgfConcr, cnccats,
GU_TYPE_LIT(pointer, PgfCIdMap*,
GU_TYPE_LIT(PgfCIdMap, _,
gu_ptr_type(PgfCncCat),
&gu_null_struct))));
GU_DEFINE_TYPE(
PgfPGF, struct,
GU_MEMBER(PgfPGF, major_version, uint16_t),
GU_MEMBER(PgfPGF, minor_version, uint16_t),
GU_MEMBER(PgfPGF, gflags, PgfFlagsP),
GU_MEMBER(PgfPGF, absname, PgfCId),
GU_MEMBER(PgfPGF, abstract, PgfAbstr),
GU_MEMBER_V(PgfPGF, concretes,
GU_TYPE_LIT(pointer, PgfCIdMap*,
GU_TYPE_LIT(PgfCIdMap, _,
gu_ptr_type(PgfConcr),
&gu_null_struct))));
GU_DEFINE_TYPE(PgfConcr, abstract);

549
src/runtime/c/pgf/data.h
View File

@@ -1,22 +1,3 @@
/*
* Copyright 2010 University of Helsinki.
*
* This file is part of libpgf.
*
* Libpgf is free software: you can redistribute it and/or modify it under
* the terms of the GNU Lesser General Public License as published by the
* Free Software Foundation, either version 3 of the License, or (at your
* option) any later version.
*
* Libpgf is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
* License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with libpgf. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef PGF_DATA_H_
#define PGF_DATA_H_
@@ -29,310 +10,18 @@
#include <pgf/pgf.h>
typedef struct PgfCCat PgfCCat;
typedef PgfCCat* PgfCCatId;
extern GU_DECLARE_TYPE(PgfCCat, struct);
extern GU_DECLARE_TYPE(PgfCCatId, shared);
typedef GuList(PgfCCatId) PgfCCatIds;
extern GU_DECLARE_TYPE(PgfCCatIds, GuList);
typedef GuSeq PgfCCatSeq;
extern GU_DECLARE_TYPE(PgfCCatSeq, GuSeq);
extern GU_DECLARE_TYPE(PgfCCat, abstract);
typedef struct PgfAbstr PgfAbstr;
extern GU_DECLARE_TYPE(PgfAbstr, struct);
typedef GuList(PgfCCat*) PgfCCats;
typedef struct PgfFunDecl PgfFunDecl;
typedef int PgfLength;
typedef struct GuVariant PgfSymbol;
typedef struct PgfAlternative PgfAlternative;
typedef struct PgfCncFun PgfCncFun;
typedef GuSeq PgfSequence; // -> PgfSymbol
typedef PgfCncFun* PgfFunId; // key to PgfCncFuns
extern GU_DECLARE_TYPE(PgfFunId, shared);
typedef GuList(PgfCncFun*) PgfCncFuns;
extern GU_DECLARE_TYPE(PgfCncFuns, GuList);
typedef GuList(PgfFunId) PgfFunIds;
extern GU_DECLARE_TYPE(PgfFunIds, GuList);
// typedef GuStringMap PgfCIdMap; // PgfCId -> ?
#define PgfCIdMap GuStringMap
typedef PgfCIdMap PgfFlags; // PgfCId -> PgfLiteral
extern GU_DECLARE_TYPE(PgfFlags, GuMap);
extern GU_DECLARE_TYPE(PgfType, struct);
typedef GuVariant PgfProduction;
typedef GuList(PgfProduction) PgfProductions;
extern GU_DECLARE_TYPE(PgfProductions, GuList);
typedef GuSeq PgfProductionSeq;
extern GU_DECLARE_TYPE(PgfProductionSeq, GuSeq);
typedef struct PgfCatFun PgfCatFun;
typedef struct PgfCncCat PgfCncCat;
extern GU_DECLARE_TYPE(PgfCncCat, struct);
typedef GuVariant PgfPatt;
typedef GuList(GuString) GuStringL;
extern GU_DECLARE_TYPE(GuStringL, GuList);
typedef GuSeq PgfTokens; // -> PgfToken
extern GU_DECLARE_TYPE(PgfTokens, GuSeq);
bool
pgf_tokens_equal(PgfTokens t1, PgfTokens t2);
typedef PgfExpr PgfTree;
typedef struct PgfEquation PgfEquation;
typedef GuSeq PgfEquations;
typedef PgfEquations PgfEquationsM; // can be null
extern GU_DECLARE_TYPE(PgfEquationsM, GuSeq);
typedef struct PgfCat PgfCat;
extern GU_DECLARE_TYPE(PgfCat, struct);
typedef PgfSequence PgfSeqId; // shared reference
extern GU_DECLARE_TYPE(PgfSeqId, typedef);
typedef GuList(PgfSequence) PgfSequences;
extern GU_DECLARE_TYPE(PgfSequences, GuList);
struct PgfAbstr {
PgfFlags* aflags;
PgfCIdMap* funs; // |-> PgfFunDecl*
PgfCIdMap* cats; // |-> PgfCat*
};
struct PgfPGF {
uint16_t major_version;
uint16_t minor_version;
PgfFlags* gflags;
PgfCId absname;
PgfAbstr abstract;
PgfCIdMap* concretes; // |-> PgfConcr*
GuPool* pool;
};
extern GU_DECLARE_TYPE(PgfPGF, struct);
struct PgfFunDecl {
PgfType* type;
int arity;
PgfEquationsM defns; // maybe null
PgfExprProb ep;
};
extern GU_DECLARE_TYPE(PgfFunDecl, struct);
typedef GuMap PgfMetaChildMap;
extern GU_DECLARE_TYPE(PgfMetaChildMap, GuMap);
struct PgfCat {
PgfCId name;
PgfHypos context;
prob_t meta_prob;
prob_t meta_token_prob;
PgfMetaChildMap* meta_child_probs;
GuBuf* functions; // -->PgfFunDecl
};
struct PgfCncCat {
PgfCat *abscat;
PgfCCatIds* cats;
size_t n_lins;
GuString labels[];
/**< Labels for tuples. All nested tuples, records and tables
* in the GF linearization types are flattened into a single
* tuple in the corresponding PGF concrete category. This
* field holds the labels that indicate which GF field or
* parameter (or their combination) each tuple element
* represents. */
};
struct PgfCncFun {
PgfCId name;
PgfExprProb *ep;
int funid;
GuLength n_lins;
PgfSeqId lins[];
};
struct PgfAlternative {
PgfTokens form;
/**< The form of this variant as a list of tokens. */
GuStringL* prefixes;
/**< The prefixes of the following symbol that trigger this
* form. */
};
typedef struct PgfItemConts PgfItemConts;
struct PgfCCat {
PgfCncCat* cnccat;
PgfFunIds* lindefs;
size_t n_synprods;
PgfProductionSeq prods;
float viterbi_prob;
int fid;
PgfItemConts* conts;
};
extern PgfCCat pgf_ccat_string, pgf_ccat_int, pgf_ccat_float, pgf_ccat_var;
typedef PgfCIdMap PgfPrintNames;
extern GU_DECLARE_TYPE(PgfPrintNames, GuStringMap);
typedef GuStringMap PgfCncFunOverloadMap;
extern GU_DECLARE_TYPE(PgfCncFunOverloadMap, GuStringMap);
typedef GuMap PgfCncOverloadMap;
extern GU_DECLARE_TYPE(PgfCncOverloadMap, GuMap);
typedef GuMap PgfProductionIdx;
extern GU_DECLARE_TYPE(PgfProductionIdx, GuMap);
typedef GuMap PgfLeftcornerCatIdx;
extern GU_DECLARE_TYPE(PgfLeftcornerCatIdx, GuMap);
typedef GuMap PgfLeftcornerTokIdx;
extern GU_DECLARE_TYPE(PgfLeftcornerTokIdx, GuMap);
typedef struct PgfLiteralCallback PgfLiteralCallback;
extern GU_DECLARE_TYPE(PgfLiteralCallback, struct);
typedef struct PgfItem PgfItem;
struct PgfLiteralCallback {
bool (*match)(PgfConcr* concr, PgfItem* item, PgfToken tok,
PgfExprProb** out_ep, GuPool *pool);
};
typedef GuMap PgfCallbacksMap;
extern GU_DECLARE_TYPE(PgfCallbacksMap, GuMap);
struct PgfConcr {
PgfFlags* cflags;
PgfPrintNames* printnames;
GuMap* ccats;
PgfCncFunOverloadMap* fun_indices;
PgfCncOverloadMap* coerce_idx;
PgfProductionIdx* epsilon_idx;
PgfLeftcornerCatIdx* leftcorner_cat_idx;
PgfLeftcornerTokIdx* leftcorner_tok_idx;
PgfCncFuns* cncfuns;
PgfSequences* sequences;
PgfCIdMap* cnccats;
PgfCallbacksMap* callbacks;
int total_cats;
};
extern GU_DECLARE_TYPE(PgfConcr, struct);
typedef enum {
PGF_SYMBOL_CAT,
PGF_SYMBOL_LIT,
PGF_SYMBOL_VAR,
PGF_SYMBOL_KS,
PGF_SYMBOL_KP
} PgfSymbolTag;
typedef struct PgfSymbolIdx PgfSymbolIdx;
struct PgfSymbolIdx {
int d;
int r;
};
typedef PgfSymbolIdx PgfSymbolCat, PgfSymbolLit, PgfSymbolVar;
typedef struct {
PgfTokens tokens;
} PgfSymbolKS;
typedef struct PgfSymbolKP
/** A prefix-dependent symbol. The form that this symbol takes
* depends on the form of a prefix of the following symbol. */
{
PgfTokens default_form;
/**< Default form that this symbol takes if none of of the
* variant forms is triggered. */
GuLength n_forms;
PgfAlternative forms[];
/**< Variant forms whose choise depends on the following
* symbol. */
} PgfSymbolKP;
// PgfProduction
typedef enum {
PGF_PRODUCTION_APPLY,
PGF_PRODUCTION_COERCE,
PGF_PRODUCTION_EXTERN,
PGF_PRODUCTION_META
} PgfProductionTag;
typedef struct PgfPArg PgfPArg;
struct PgfPArg {
PgfCCatId ccat;
PgfCCatIds* hypos;
};
extern GU_DECLARE_TYPE(PgfPArg, struct);
typedef GuSeq PgfPArgs;
extern GU_DECLARE_TYPE(PgfPArgs, GuSeq);
typedef struct {
PgfFunId fun;
PgfPArgs args;
} PgfProductionApply;
typedef struct PgfProductionCoerce
/** A coercion. This production is a logical union of the coercions of
* another FId. This allows common subsets of productions to be
* shared. */
{
PgfCCatId coerce;
} PgfProductionCoerce;
typedef struct {
PgfLiteralCallback *callback;
PgfExprProb *ep;
GuSeq lins;
} PgfProductionExtern;
typedef struct {
PgfExprProb *ep;
PgfPArgs args;
} PgfProductionMeta;
extern GU_DECLARE_TYPE(PgfPatt, GuVariant);
extern GU_DECLARE_TYPE(PgfProduction, GuVariant);
extern GU_DECLARE_TYPE(PgfBindType, enum);
extern GU_DECLARE_TYPE(PgfLiteral, GuVariant);
// PgfPatt
typedef GuVariant PgfPatt;
typedef enum {
PGF_PATT_APP,
PGF_PATT_VAR,
@@ -373,12 +62,238 @@ typedef struct {
PgfExpr expr;
} PgfPattTilde;
struct PgfEquation {
typedef struct {
PgfExpr body;
GuLength n_patts;
PgfPatt patts[];
} PgfEquation;
typedef GuSeq PgfEquations;
typedef struct {
PgfType* type;
int arity;
PgfEquations defns; // maybe null
PgfExprProb ep;
} PgfAbsFun;
extern GU_DECLARE_TYPE(PgfAbsFun, abstract);
typedef GuMap PgfMetaChildMap;
extern GU_DECLARE_TYPE(PgfMetaChildMap, GuMap);
typedef struct {
PgfCId name;
PgfHypos context;
prob_t meta_prob;
prob_t meta_token_prob;
PgfMetaChildMap* meta_child_probs;
GuBuf* functions; // -->PgfFunDecl
} PgfAbsCat;
extern GU_DECLARE_TYPE(PgfAbsCat, abstract);
typedef struct {
PgfFlags* aflags;
PgfCIdMap* funs; // |-> PgfAbsFun*
PgfCIdMap* cats; // |-> PgfAbsCat*
} PgfAbstr;
struct PgfPGF {
uint16_t major_version;
uint16_t minor_version;
PgfFlags* gflags;
PgfCId absname;
PgfAbstr abstract;
PgfCIdMap* concretes; // |-> PgfConcr*
GuPool* pool;
};
typedef struct {
PgfAbsCat *abscat;
PgfCCats* cats;
size_t n_lins;
GuString labels[];
/**< Labels for tuples. All nested tuples, records and tables
* in the GF linearization types are flattened into a single
* tuple in the corresponding PGF concrete category. This
* field holds the labels that indicate which GF field or
* parameter (or their combination) each tuple element
* represents. */
} PgfCncCat;
extern GU_DECLARE_TYPE(PgfCncCat, abstract);
typedef GuSeq PgfTokens; // -> PgfToken
bool
pgf_tokens_equal(PgfTokens t1, PgfTokens t2);
typedef GuList(GuString) GuStringL;
typedef struct {
PgfTokens form;
/**< The form of this variant as a list of tokens. */
GuStringL* prefixes;
/**< The prefixes of the following symbol that trigger this
* form. */
} PgfAlternative;
typedef struct PgfItemConts PgfItemConts;
typedef PgfCIdMap PgfPrintNames;
extern GU_DECLARE_TYPE(PgfPrintNames, GuStringMap);
typedef GuStringMap PgfCncFunOverloadMap;
extern GU_DECLARE_TYPE(PgfCncFunOverloadMap, GuStringMap);
typedef GuMap PgfCncOverloadMap;
extern GU_DECLARE_TYPE(PgfCncOverloadMap, GuMap);
typedef GuMap PgfProductionIdx;
extern GU_DECLARE_TYPE(PgfProductionIdx, GuMap);
typedef GuMap PgfLeftcornerCatIdx;
extern GU_DECLARE_TYPE(PgfLeftcornerCatIdx, GuMap);
typedef GuMap PgfLeftcornerTokIdx;
extern GU_DECLARE_TYPE(PgfLeftcornerTokIdx, GuMap);
typedef struct PgfItem PgfItem;
typedef struct {
bool (*match)(PgfConcr* concr, PgfItem* item, PgfToken tok,
PgfExprProb** out_ep, GuPool *pool);
} PgfLiteralCallback;
typedef GuMap PgfCallbacksMap;
extern GU_DECLARE_TYPE(PgfCallbacksMap, GuMap);
typedef struct GuVariant PgfSymbol;
typedef enum {
PGF_SYMBOL_CAT,
PGF_SYMBOL_LIT,
PGF_SYMBOL_VAR,
PGF_SYMBOL_KS,
PGF_SYMBOL_KP
} PgfSymbolTag;
typedef struct {
int d;
int r;
} PgfSymbolIdx;
typedef PgfSymbolIdx PgfSymbolCat, PgfSymbolLit, PgfSymbolVar;
typedef struct {
PgfTokens tokens;
} PgfSymbolKS;
typedef struct PgfSymbolKP
/** A prefix-dependent symbol. The form that this symbol takes
* depends on the form of a prefix of the following symbol. */
{
PgfTokens default_form;
/**< Default form that this symbol takes if none of of the
* variant forms is triggered. */
GuLength n_forms;
PgfAlternative forms[];
/**< Variant forms whose choise depends on the following
* symbol. */
} PgfSymbolKP;
#endif /* PGF_PRIVATE_H_ */
typedef GuSeq PgfSequence; // -> PgfSymbol
typedef GuList(PgfSequence) PgfSequences;
typedef struct {
PgfCId name;
PgfExprProb *ep;
int funid;
GuLength n_lins;
PgfSequence lins[];
} PgfCncFun;
typedef GuList(PgfCncFun*) PgfCncFuns;
struct PgfConcr {
PgfFlags* cflags;
PgfPrintNames* printnames;
GuMap* ccats;
PgfCncFunOverloadMap* fun_indices;
PgfCncOverloadMap* coerce_idx;
PgfProductionIdx* epsilon_idx;
PgfLeftcornerCatIdx* leftcorner_cat_idx;
PgfLeftcornerTokIdx* leftcorner_tok_idx;
PgfCncFuns* cncfuns;
PgfSequences* sequences;
PgfCIdMap* cnccats;
PgfCallbacksMap* callbacks;
int total_cats;
};
extern GU_DECLARE_TYPE(PgfConcr, abstract);
// PgfProduction
typedef GuVariant PgfProduction;
typedef enum {
PGF_PRODUCTION_APPLY,
PGF_PRODUCTION_COERCE,
PGF_PRODUCTION_EXTERN,
PGF_PRODUCTION_META
} PgfProductionTag;
typedef struct {
PgfCCat* ccat;
PgfCCats* hypos;
} PgfPArg;
typedef GuSeq PgfPArgs;
typedef struct {
PgfCncFun* fun;
PgfPArgs args;
} PgfProductionApply;
typedef struct PgfProductionCoerce
/** A coercion. This production is a logical union of the coercions of
* another FId. This allows common subsets of productions to be
* shared. */
{
PgfCCat* coerce;
} PgfProductionCoerce;
typedef struct {
PgfLiteralCallback *callback;
PgfExprProb *ep;
GuSeq lins;
} PgfProductionExtern;
typedef struct {
PgfExprProb *ep;
PgfPArgs args;
} PgfProductionMeta;
typedef GuSeq PgfProductionSeq;
extern GU_DECLARE_TYPE(PgfProductionSeq, GuSeq);
struct PgfCCat {
PgfCncCat* cnccat;
PgfCncFuns* lindefs;
size_t n_synprods;
PgfProductionSeq prods;
float viterbi_prob;
int fid;
PgfItemConts* conts;
};
#endif

8
src/runtime/c/pgf/linearizer.c
View File

@@ -208,7 +208,7 @@ redo:;
}
static PgfCncTree
pgf_lzn_resolve_def(PgfLzn* lzn, PgfFunIds* lindefs, GuString s, GuPool* pool)
pgf_lzn_resolve_def(PgfLzn* lzn, PgfCncFuns* lindefs, GuString s, GuPool* pool)
{
PgfCncTree lit = gu_null_variant;
PgfCncTree ret = gu_null_variant;
@@ -286,13 +286,12 @@ pgf_lzn_resolve(PgfLzn* lzn, PgfExpr expr, PgfCCat* ccat, GuPool* pool)
goto done;
}
case PGF_EXPR_META: {
PgfFunIds* lindefs = NULL;
if (ccat != NULL && ccat->lindefs == NULL) {
goto done;
}
GuString s = gu_str_string("?", pool);
ret = pgf_lzn_resolve_def(lzn, lindefs, s, pool);
ret = pgf_lzn_resolve_def(lzn, ccat->lindefs, s, pool);
goto done;
}
case PGF_EXPR_FUN: {
@@ -301,7 +300,6 @@ pgf_lzn_resolve(PgfLzn* lzn, PgfExpr expr, PgfCCat* ccat, GuPool* pool)
PgfCncOverloadMap* overl_table =
gu_map_get(lzn->concr->fun_indices, &efun->fun, PgfCncOverloadMap*);
if (overl_table == NULL) {
PgfFunIds* lindefs = NULL;
if (ccat != NULL && ccat->lindefs == NULL) {
goto done;
}
@@ -316,7 +314,7 @@ pgf_lzn_resolve(PgfLzn* lzn, PgfExpr expr, PgfCCat* ccat, GuPool* pool)
gu_putc(']', wtr, err);
GuString s = gu_string_buf_freeze(sbuf, tmp_pool);
ret = pgf_lzn_resolve_def(lzn, lindefs, s, pool);
ret = pgf_lzn_resolve_def(lzn, ccat->lindefs, s, pool);
gu_pool_free(tmp_pool);
goto done;

2
src/runtime/c/pgf/parser.c
View File

@@ -1093,7 +1093,7 @@ pgf_parsing_meta_predict(GuMapItor* fn, const void* key, void* value, GuExn* err
{
(void) (err);
PgfCat* abscat = (PgfCat*) key;
PgfAbsCat* abscat = (PgfAbsCat*) key;
prob_t meta_prob = *((prob_t*) value);
PgfMetaPredictFn* clo = (PgfMetaPredictFn*) fn;
PgfParseState* before = clo->before;

14
src/runtime/c/pgf/pgf.c
View File

@@ -58,8 +58,8 @@ pgf_load_meta_child_probs(PgfPGF* pgf, const char* fpath,
prob = - log(prob);
GuString cat1 = gu_str_string(cat1_s, tmp_pool);
PgfCat* abscat1 =
gu_map_get(pgf->abstract.cats, &cat1, PgfCat*);
PgfAbsCat* abscat1 =
gu_map_get(pgf->abstract.cats, &cat1, PgfAbsCat*);
if (abscat1 == NULL) {
gu_raise(err, PgfExn);
goto close;
@@ -71,7 +71,7 @@ pgf_load_meta_child_probs(PgfPGF* pgf, const char* fpath,
abscat1->meta_token_prob = prob;
} else {
GuString cat2 = gu_str_string(cat2_s, tmp_pool);
PgfCat* abscat2 = gu_map_get(pgf->abstract.cats, &cat2, PgfCat*);
PgfAbsCat* abscat2 = gu_map_get(pgf->abstract.cats, &cat2, PgfAbsCat*);
if (abscat2 == NULL) {
gu_raise(err, PgfExn);
goto close;
@@ -148,8 +148,8 @@ void
pgf_iter_functions_by_cat(PgfPGF* pgf, PgfCId catname,
GuMapItor* fn, GuExn* err)
{
PgfCat* abscat =
gu_map_get(pgf->abstract.cats, &catname, PgfCat*);
PgfAbsCat* abscat =
gu_map_get(pgf->abstract.cats, &catname, PgfAbsCat*);
if (abscat == NULL) {
gu_raise(err, PgfExn);
return;
@@ -157,8 +157,8 @@ pgf_iter_functions_by_cat(PgfPGF* pgf, PgfCId catname,
size_t n_functions = gu_buf_length(abscat->functions);
for (size_t i = 0; i < n_functions; i++) {
PgfFunDecl* fun =
gu_buf_get(abscat->functions, PgfFunDecl*, i);
PgfAbsFun* fun =
gu_buf_get(abscat->functions, PgfAbsFun*, i);
GuVariantInfo i = gu_variant_open(fun->ep.expr);
switch (i.tag) {

2
src/runtime/c/pgf/pgf.h
View File

@@ -42,10 +42,8 @@ extern GU_DECLARE_TYPE(PgfExn, abstract);
/// @{
typedef struct PgfPGF PgfPGF;
extern GU_DECLARE_TYPE(PgfPGF, struct);
typedef struct PgfConcr PgfConcr;
extern GU_DECLARE_TYPE(PgfConcr, struct);
/**< A representation of a PGF grammar.

8
src/runtime/c/pgf/printer.c
View File

@@ -27,7 +27,7 @@ pgf_print_cat(GuMapItor* fn, const void* key, void* value,
{
PgfPrintFn* clo = (PgfPrintFn*) fn;
PgfCId name = *((PgfCId *) key);
PgfCat *cat = *((PgfCat **) value);
PgfAbsCat *cat = *((PgfAbsCat **) value);
GuWriter *wtr = clo->wtr;
gu_puts(" cat ", wtr, err);
@@ -49,7 +49,7 @@ pgf_print_absfun(GuMapItor* fn, const void* key, void* value,
{
PgfPrintFn* clo = (PgfPrintFn*) fn;
PgfCId name = *((PgfCId *) key);
PgfFunDecl *fun = *((PgfFunDecl **) value);
PgfAbsFun *fun = *((PgfAbsFun **) value);
GuWriter *wtr = clo->wtr;
gu_puts(gu_seq_is_null(fun->defns) ? " data " : " fun ", wtr, err);
@@ -149,8 +149,8 @@ pgf_print_lindefs(GuMapItor* fn, const void* key, void* value,
for (size_t i = 0; i < n_lindefs; i++) {
if (i > 0) gu_putc(' ', wtr, err);
PgfFunId funid = gu_list_index(ccat->lindefs, i);
gu_printf(wtr,err,"F%d",funid->funid);
PgfCncFun* fun = gu_list_index(ccat->lindefs, i);
gu_printf(wtr,err,"F%d",fun->funid);
}
gu_putc('\n', wtr,err);

42
src/runtime/c/pgf/reader.c
View File

@@ -412,10 +412,10 @@ pgf_read_patt(PgfReader* rdr)
return patt;
}
static PgfFunDecl*
pgf_read_fundecl(PgfReader* rdr, PgfCId name)
static PgfAbsFun*
pgf_read_absfun(PgfReader* rdr, PgfCId name)
{
PgfFunDecl* absfun = gu_new(PgfFunDecl, rdr->opool);
PgfAbsFun* absfun = gu_new(PgfAbsFun, rdr->opool);
absfun->type = pgf_read_type(rdr);
gu_return_on_exn(rdr->err, NULL);
@@ -474,7 +474,7 @@ pgf_read_absfuns(PgfReader* rdr)
{
GuMapType* map_type = (GuMapType*)
GU_TYPE_LIT(GuStringMap, _,
gu_ptr_type(PgfFunDecl),
gu_ptr_type(PgfAbsFun),
&gu_null_struct);
PgfCIdMap* absfuns = gu_map_type_make(map_type, rdr->opool);
@@ -485,19 +485,19 @@ pgf_read_absfuns(PgfReader* rdr)
PgfCId name = pgf_read_cid(rdr);
gu_return_on_exn(rdr->err, NULL);
PgfFunDecl* decl = pgf_read_fundecl(rdr, name);
PgfAbsFun* decl = pgf_read_absfun(rdr, name);
gu_return_on_exn(rdr->err, NULL);
gu_map_put(absfuns, &name, PgfFunDecl*, decl);
gu_map_put(absfuns, &name, PgfAbsFun*, decl);
}
return absfuns;
}
static PgfCat*
static PgfAbsCat*
pgf_read_abscat(PgfReader* rdr, PgfAbstr* abstr, PgfCId name)
{
PgfCat* abscat = gu_new(PgfCat, rdr->opool);
PgfAbsCat* abscat = gu_new(PgfAbsCat, rdr->opool);
abscat->name = name;
@@ -514,7 +514,7 @@ pgf_read_abscat(PgfReader* rdr, PgfAbstr* abstr, PgfCId name)
abscat->meta_token_prob = INFINITY;
abscat->meta_child_probs = NULL;
abscat->functions = gu_new_buf(PgfFunDecl*, rdr->opool);
abscat->functions = gu_new_buf(PgfAbsFun*, rdr->opool);
size_t n_functions = pgf_read_len(rdr);
gu_return_on_exn(rdr->err, NULL);
@@ -526,9 +526,9 @@ pgf_read_abscat(PgfReader* rdr, PgfAbstr* abstr, PgfCId name)
PgfCId name = pgf_read_cid(rdr);
gu_return_on_exn(rdr->err, NULL);
PgfFunDecl* absfun =
gu_map_get(abstr->funs, &name, PgfFunDecl*);
gu_buf_push(abscat->functions, PgfFunDecl*, absfun);
PgfAbsFun* absfun =
gu_map_get(abstr->funs, &name, PgfAbsFun*);
gu_buf_push(abscat->functions, PgfAbsFun*, absfun);
}
return abscat;
@@ -539,7 +539,7 @@ pgf_read_abscats(PgfReader* rdr, PgfAbstr* abstr)
{
GuMapType* map_type = (GuMapType*)
GU_TYPE_LIT(GuStringMap, _,
gu_ptr_type(PgfCat),
gu_ptr_type(PgfAbsCat),
&gu_null_struct);
PgfCIdMap* abscats = gu_map_type_make(map_type, rdr->opool);
@@ -550,10 +550,10 @@ pgf_read_abscats(PgfReader* rdr, PgfAbstr* abstr)
PgfCId name = pgf_read_cid(rdr);
gu_return_on_exn(rdr->err, NULL);
PgfCat* abscat = pgf_read_abscat(rdr, abstr, name);
PgfAbsCat* abscat = pgf_read_abscat(rdr, abstr, name);
gu_return_on_exn(rdr->err, NULL);
gu_map_put(abscats, &name, PgfCat*, abscat);
gu_map_put(abscats, &name, PgfAbsCat*, abscat);
}
return abscats;
@@ -763,8 +763,8 @@ pgf_read_cncfun(PgfReader* rdr, PgfAbstr* abstr, PgfConcr* concr, int funid)
cncfun->funid = funid;
cncfun->n_lins = len;
PgfFunDecl* absfun =
gu_map_get(abstr->funs, &cncfun->name, PgfFunDecl*);
PgfAbsFun* absfun =
gu_map_get(abstr->funs, &cncfun->name, PgfAbsFun*);
cncfun->ep = (absfun == NULL) ? NULL : &absfun->ep;
for (size_t i = 0; i < len; i++) {
@@ -849,7 +849,7 @@ pgf_read_lindefs(PgfReader* rdr, PgfConcr* concr)
size_t n_funs = pgf_read_len(rdr);
gu_return_on_exn(rdr->err, );
ccat->lindefs = gu_new_list(PgfFunIds, rdr->opool, n_funs);
ccat->lindefs = gu_new_list(PgfCncFuns, rdr->opool, n_funs);
for (size_t j = 0; j < n_funs; j++) {
PgfCncFun* fun = pgf_read_funid(rdr, concr);
gu_list_index(ccat->lindefs, j) = fun;
@@ -863,7 +863,7 @@ pgf_read_parg(PgfReader* rdr, PgfConcr* concr, PgfPArg* parg)
size_t n_hoas = pgf_read_len(rdr);
gu_return_on_exn(rdr->err, );
parg->hypos = gu_new_list(PgfCCatIds, rdr->opool, n_hoas);
parg->hypos = gu_new_list(PgfCCats, rdr->opool, n_hoas);
for (size_t i = 0; i < n_hoas; i++) {
gu_list_index(parg->hypos, i) = pgf_read_fid(rdr, concr);
gu_return_on_exn(rdr->err, );
@@ -967,11 +967,11 @@ pgf_read_cnccat(PgfReader* rdr, PgfAbstr* abstr, PgfConcr* concr, PgfCId name)
gu_malloc(rdr->opool, sizeof(PgfCncCat)+n_lins*sizeof(GuString));
cnccat->abscat =
gu_map_get(abstr->cats, &name, PgfCat*);
gu_map_get(abstr->cats, &name, PgfAbsCat*);
gu_assert(cnccat->abscat != NULL);
int len = last + 1 - first;
cnccat->cats = gu_new_list(PgfCCatIds, rdr->opool, len);
cnccat->cats = gu_new_list(PgfCCats, rdr->opool, len);
for (int i = 0; i < len; i++) {
int fid = first + i;

10
src/runtime/c/pgf/reasoner.c
View File

@@ -154,7 +154,7 @@ pgf_reasoner_predict(PgfReasoner* rs, PgfExprState* cont,
gu_buf_push(answers->conts, PgfExprState*, cont);
if (gu_buf_length(answers->conts) == 1) {
PgfCat* abscat = gu_map_get(rs->abstract->cats, &cat, PgfCat*);
PgfAbsCat* abscat = gu_map_get(rs->abstract->cats, &cat, PgfAbsCat*);
if (abscat == NULL) {
return;
}
@@ -166,7 +166,7 @@ pgf_reasoner_predict(PgfReasoner* rs, PgfExprState* cont,
q->choice_idx = 0;
q->choices = abscat->functions;
q->prob = answers->outside_prob + gu_buf_get(q->choices, PgfFunDecl*, 0)->ep.prob;
q->prob = answers->outside_prob + gu_buf_get(q->choices, PgfAbsFun*, 0)->ep.prob;
gu_buf_heap_push(rs->pqueue, &pgf_expr_qstate_order, &q);
}
} else {
@@ -196,8 +196,8 @@ pgf_reasoner_next(PgfReasoner* rs, GuPool* pool)
PgfExprState* st = NULL;
switch (q->kind) {
case PGF_EXPR_QSTATE_PREDICT: {
PgfFunDecl* absfun =
gu_buf_get(q->choices, PgfFunDecl*, q->choice_idx);
PgfAbsFun* absfun =
gu_buf_get(q->choices, PgfAbsFun*, q->choice_idx);
st = gu_new(PgfExprState, pool);
st->answers = q->single;
@@ -207,7 +207,7 @@ pgf_reasoner_next(PgfReasoner* rs, GuPool* pool)
q->choice_idx++;
if (q->choice_idx < gu_buf_length(q->choices)) {
q->prob = st->answers->outside_prob + gu_buf_get(q->choices, PgfFunDecl*, q->choice_idx)->ep.prob;
q->prob = st->answers->outside_prob + gu_buf_get(q->choices, PgfAbsFun*, q->choice_idx)->ep.prob;
gu_buf_heap_push(rs->pqueue, &pgf_expr_qstate_order, &q);
}
break;

34
src/runtime/c/utils/pgf2yaml.c
View File

@@ -1,34 +0,0 @@
#include <pgf/pgf.h>
#include <gu/dump.h>
#include <gu/file.h>
#include <gu/utf8.h>
int main(int argc, char* argv[]) {
if (argc != 1) {
fprintf(stderr, "usage: %s pgf\n", argv[0]);
return 1;
}
char* filename = argv[1];
GuPool* pool = gu_new_pool();
GuExn* err = gu_exn(NULL, type, pool);
PgfPGF* pgf = pgf_read(filename, pool, err);
int status = 0;
if (!gu_ok(err)) {
fprintf(stderr, "Reading PGF failed\n");
status = 1;
goto fail_read;
}
GuOut* out = gu_file_out(stdout, pool);
GuOut* bout = gu_out_buffered(out, pool);
// GuWriter* wtr = gu_locale_writer(bout, pool);
GuWriter* wtr = gu_new_utf8_writer(bout, pool);
GuDump* ctx = gu_new_dump(wtr, NULL, err, pool);
gu_dump(gu_type(PgfPGF), pgf, ctx);
gu_writer_flush(wtr, err);
fail_read:
gu_pool_free(pool);
return status;
}