initial import of the C runtime

16 files changed, 3586 insertions, 885 deletions

diff --git a/src/runtime/c/pgf/data.c b/src/runtime/c/pgf/data.c
new file mode 100644
index 000000000..98cbf5427
--- /dev/null
+++ b/src/runtime/c/pgf/data.c
@@ -0,0 +1,251 @@
+#include "data.h"
+#include "expr.h"
+#include <gu/type.h>
+#include <gu/variant.h>
+#include <gu/assert.h>
+
+
+PgfCCat pgf_ccat_string = { NULL, GU_NULL_SEQ, -1 };
+PgfCCat pgf_ccat_int = { NULL, GU_NULL_SEQ, -2 };
+PgfCCat pgf_ccat_float = { NULL, GU_NULL_SEQ, -3 };
+PgfCCat pgf_ccat_var = { NULL, GU_NULL_SEQ, -4 };
+
+PgfCCatId
+pgf_literal_cat(PgfLiteral lit)
+{
+	switch (gu_variant_tag(lit)) {
+	case PGF_LITERAL_STR:
+		return &pgf_ccat_string;
+	case PGF_LITERAL_INT:
+		return &pgf_ccat_int;
+	case PGF_LITERAL_FLT:
+		return &pgf_ccat_float;
+	default:
+		gu_impossible();
+		return NULL;
+	}
+}
+
+bool 
+pgf_tokens_equal(PgfTokens t1, PgfTokens t2)
+{
+	size_t len1 = gu_seq_length(t1);
+	size_t len2 = gu_seq_length(t2);
+	if (len1 != len2) {
+		return false;
+	}
+	for (size_t i = 0; i < len1; i++) {
+		GuString s1 = gu_seq_get(t1, PgfToken, i);
+		GuString s2 = gu_seq_get(t2, PgfToken, i);
+		if (!gu_string_eq(s1, s2)) {
+			return false;
+		}
+	}
+	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(PgfCCat, prods, PgfProductionSeq));
+
+GU_DEFINE_TYPE(PgfCCatId, shared, gu_type(PgfCCat));
+
+GU_DEFINE_TYPE(PgfCCatIds, GuList, gu_type(PgfCCatId));
+
+GU_DEFINE_TYPE(PgfCCatSeq, GuSeq, gu_type(PgfCCatId));
+
+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, cid, PgfCId),
+	GU_MEMBER_P(PgfCncCat, cats, PgfCCatIds),
+	GU_MEMBER(PgfCncCat, n_lins, size_t),
+	GU_MEMBER_P(PgfCncCat, lindefs, PgfFunIds),
+	GU_MEMBER_P(PgfCncCat, labels, GuStringL));
+
+// 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, fun, 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_CONST, PgfProductionConst,
+		GU_MEMBER(PgfProductionConst, expr, PgfExpr),
+		GU_MEMBER(PgfProductionConst, n_toks, GuLength),
+		GU_FLEX_MEMBER(PgfProductionConst, toks, GuString)));
+
+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_MEMBER(PgfPattApp, args, PgfPatt)),
+	GU_CONSTRUCTOR_S(
+		PGF_PATT_LIT, PgfPattLit,
+		GU_MEMBER(PgfPattLit, lit, PgfLiteral)),
+	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_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_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(
+	PgfFunDecl, struct, 
+	GU_MEMBER_P(PgfFunDecl, type, PgfType),
+	GU_MEMBER(PgfFunDecl, arity, int),
+	GU_MEMBER(PgfFunDecl, defns, PgfEquationsM),
+	GU_MEMBER(PgfFunDecl, prob, double));
+
+GU_DEFINE_TYPE(
+	PgfCatFun, struct,
+	GU_MEMBER(PgfCatFun, prob, double),
+	GU_MEMBER(PgfCatFun, fun, PgfCId));
+
+GU_DEFINE_TYPE(
+	PgfCat, struct, 
+	GU_MEMBER(PgfCat, context, PgfHypos),
+	GU_MEMBER(PgfCat, n_functions, GuLength),
+	GU_FLEX_MEMBER(PgfCat, functions, PgfCatFun));
+
+
+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(
+	PgfPrintNames, PgfCIdMap, gu_type(GuString), NULL);
+
+GU_DEFINE_TYPE(
+	PgfConcr, struct, 
+	GU_MEMBER(PgfConcr, cflags, PgfFlagsP),
+	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))));
+
diff --git a/src/runtime/c/pgf/data.h b/src/runtime/c/pgf/data.h
index b17ea6d66..d80a19526 100644
--- a/src/runtime/c/pgf/data.h
+++ b/src/runtime/c/pgf/data.h
@@ -1,76 +1,330 @@
-#ifndef PGF_DATA_H
-#define PGF_DATA_H
+/* 
+ * 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/>.
+ */
 
-typedef int BindType;
+#ifndef PGF_DATA_H_
+#define PGF_DATA_H_
 
-#include "expr.h"
-#include "type.h"
+#include <gu/list.h>
+#include <gu/variant.h>
+#include <gu/map.h>
+#include <gu/string.h>
+#include <gu/type.h>
+#include <gu/seq.h>
+#include <pgf/pgf.h>
+#include <pgf/expr.h>
 
-struct _String {
-  int len;
-  unsigned int chars[];
+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);
+
+typedef struct PgfAbstr PgfAbstr;
+typedef struct PgfFunDecl PgfFunDecl;
+typedef struct PgfConcr PgfConcr;
+
+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;
+
+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 _CId {
-  int len;
-  char chars[];
+struct PgfPGF {
+	uint16_t major_version;
+	uint16_t minor_version;
+	PgfFlags* gflags;
+	PgfCId absname;
+	PgfAbstr abstract;
+	PgfCIdMap* concretes; // |-> PgfConcr*
+	GuPool* pool;
 };
 
-typedef struct _CIdList {
-  int count;
-  CId names[];
-} *CIdList;
-
-typedef struct _AbsCat {
-  CId name;
-  Context hypos;
-  CIdList funs;
-} *AbsCat;
-
-typedef struct _AbsCats {
-  int count;
-  struct _AbsCat lst[];
-} *AbsCats;
-
-typedef struct _AbsFun {
-  CId name;
-  Type ty;
-  int arrity;
-  Equations equs;
-} *AbsFun;
-
-typedef struct _AbsFuns {
-  int count;
-  struct _AbsFun lst[];
-} *AbsFuns;
-
-struct _Flag {
-  CId name;
-  Literal value;
-} ;
-
-typedef struct _Flags {
-  int count;
-  struct _Flag values[];
-} *Flags;
-
-typedef struct _Abstract {
-  CId name;
-  Flags flags;
-  AbsFuns funs;
-  AbsCats cats;
-} *Abstract;
-
-typedef struct _Concrete {
-  CId name;
-  Flags flags;
-} *Concrete;
-
-struct _PGF {
-  Flags flags;
-  int   nConcr;
-  struct _Abstract abstract;
-  struct _Concrete concretes[];
+extern GU_DECLARE_TYPE(PgfPGF, struct);
+
+struct PgfFunDecl {
+	PgfType* type;
+	int arity; // Only for computational defs?
+	PgfEquationsM defns; // maybe null
+	double prob;
+};
+
+struct PgfCatFun {
+	double prob;
+	PgfCId fun;
+};
+
+struct PgfCat {
+	// TODO: Add cid here
+	PgfHypos context;
+	GuLength n_functions;
+	PgfCatFun functions[]; // XXX: resolve to PgfFunDecl*?
+};
+
+
+struct PgfCncCat {
+	PgfCId cid;
+	PgfCCatIds* cats;
+	PgfFunIds* lindefs;
+	size_t n_lins;
+
+	GuStringL* 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 fun; // XXX: resolve to PgfFunDecl*?
+	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. */
+};
+
+struct PgfCCat {
+	PgfCncCat* cnccat;
+	PgfProductionSeq prods;
+	int fid;
+};
+
+extern PgfCCat pgf_ccat_string, pgf_ccat_int, pgf_ccat_float, pgf_ccat_var;
+
+typedef PgfCIdMap PgfPrintNames;
+extern GU_DECLARE_TYPE(PgfPrintNames, GuStringMap);
+
+struct PgfConcr {
+	PgfFlags* cflags;
+	PgfPrintNames* printnames;
+	PgfCIdMap* cnccats;
+	PgfCCatSeq extra_ccats;
 };
 
-#endif
+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_CONST
+} PgfProductionTag;
+
+typedef struct PgfPArg PgfPArg;
+
+struct PgfPArg {
+	PgfCCatId ccat;
+	PgfCCatIds* hypos;
+};
+
+GU_DECLARE_TYPE(PgfPArg, struct);
+
+typedef GuSeq PgfPArgs;
+
+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 {
+	PgfExpr expr; // XXX
+	GuLength n_toks;
+	GuString toks[]; // XXX
+} PgfProductionConst;
+
+
+extern GU_DECLARE_TYPE(PgfProduction, GuVariant);
+extern GU_DECLARE_TYPE(PgfBindType, enum);
+extern GU_DECLARE_TYPE(PgfLiteral, GuVariant);
+
+
+PgfCCatId
+pgf_literal_cat(PgfLiteral lit);
+
+// PgfPatt
+
+typedef enum {
+	PGF_PATT_APP,
+	PGF_PATT_LIT,
+	PGF_PATT_VAR,
+	PGF_PATT_AS,
+	PGF_PATT_WILD,
+	PGF_PATT_IMPL_ARG,
+	PGF_PATT_TILDE,
+	PGF_PATT_NUM_TAGS
+} PgfPattTag;
+
+typedef	struct {
+	PgfCId ctor;
+	GuLength n_args;
+	PgfPatt args[];
+} PgfPattApp;
+
+typedef struct {
+	PgfLiteral* lit;
+} PgfPattLit;
+
+typedef struct {
+	PgfCId var;
+} PgfPattVar;
+
+typedef struct {
+	PgfCId var;
+	PgfPatt patt;
+} PgfPattAs;
+
+typedef void PgfPattWild;
+
+typedef struct {
+	PgfPatt patt;
+} PgfPattImplArg;
+
+typedef struct {
+	PgfExpr expr;
+} PgfPattTilde;
+
+struct PgfEquation {
+	PgfExpr body;
+	GuLength n_patts;
+	PgfPatt patts[];
+};
+
+
+
+#endif /* PGF_PRIVATE_H_ */
diff --git a/src/runtime/c/pgf/edsl.h b/src/runtime/c/pgf/edsl.h
new file mode 100644
index 000000000..af21e6c15
--- /dev/null
+++ b/src/runtime/c/pgf/edsl.h
@@ -0,0 +1,20 @@
+#ifndef PGF_EDSL_H_
+#define PGF_EDSL_H_
+
+#include <pgf/expr.h>
+
+#define APP(f, a) \
+	gu_new_variant_i(PGF_EDSL_POOL, PGF_EXPR_APP, PgfExprApp, f, a)
+#define APP2(f, a1, a2) APP(APP(f, a1), a2)
+#define APP3(f, a1, a2, a3) APP2(APP(f, a1), a2, a3)
+
+#define VAR(s) \
+	gu_new_variant_i(PGF_EDSL_POOL, PGF_EXPR_FUN, PgfExprFun, gu_cstring(#s))
+
+#define APPV(s, a) APP(VAR(s), a)
+#define APPV2(s, a1, a2) APP2(VAR(s), a1, a2)
+#define APPV3(s, a1, a2, a3) APP3(VAR(s), a1, a2)
+
+
+
+#endif // PGF_EDSL_H_
diff --git a/src/runtime/c/pgf/expr.c b/src/runtime/c/pgf/expr.c
new file mode 100644
index 000000000..cd5d69928
--- /dev/null
+++ b/src/runtime/c/pgf/expr.c
@@ -0,0 +1,334 @@
+#include "expr.h"
+#include <gu/intern.h>
+#include <gu/assert.h>
+#include <ctype.h>
+
+
+PgfExpr
+pgf_expr_unwrap(PgfExpr expr)
+{
+	while (true) {
+		GuVariantInfo i = gu_variant_open(expr);
+		switch (i.tag) {
+		case PGF_EXPR_IMPL_ARG: {
+			PgfExprImplArg* eimpl = i.data;
+			expr = eimpl->expr;
+			break;
+		}
+		case PGF_EXPR_TYPED: {
+			PgfExprTyped* etyped = i.data;
+			expr = etyped->expr;
+			break;
+		}
+		default:
+			return expr;
+		}
+	}
+}
+
+int
+pgf_expr_arity(PgfExpr expr)
+{
+	int n = 0;
+	while (true) {
+		PgfExpr e = pgf_expr_unwrap(expr);
+		GuVariantInfo i = gu_variant_open(e);
+		switch (i.tag) {
+		case PGF_EXPR_APP: {
+			PgfExprApp* app = i.data;
+			expr = app->fun;
+			n = n + 1;
+			break;
+		}
+		case PGF_EXPR_FUN:
+			return n;
+		default:
+			return -1;
+		}
+	}
+}
+
+PgfApplication*
+pgf_expr_unapply(PgfExpr expr, GuPool* pool)
+{
+	int arity = pgf_expr_arity(expr);
+	if (arity < 0) {
+		return NULL;
+	}
+	PgfApplication* appl = gu_new_flex(pool, PgfApplication, args, arity);
+	appl->n_args = arity;
+	for (int n = arity - 1; n >= 0; n--) {
+		PgfExpr e = pgf_expr_unwrap(expr);
+		gu_assert(gu_variant_tag(e) == PGF_EXPR_APP);
+		PgfExprApp* app = gu_variant_data(e);
+		appl->args[n] = app->arg;
+		expr = app->fun;
+	}
+	PgfExpr e = pgf_expr_unwrap(expr);
+	gu_assert(gu_variant_tag(e) == PGF_EXPR_FUN);
+	PgfExprFun* fun = gu_variant_data(e);
+	appl->fun = fun->fun;
+	return appl;
+}
+
+GU_DEFINE_TYPE(PgfBindType, enum,
+	       GU_ENUM_C(PgfBindType, PGF_BIND_TYPE_EXPLICIT),
+	       GU_ENUM_C(PgfBindType, PGF_BIND_TYPE_IMPLICIT));
+
+GU_DEFINE_TYPE(PgfLiteral, GuVariant,
+	       GU_CONSTRUCTOR_S(PGF_LITERAL_STR, PgfLiteralStr,
+				GU_MEMBER(PgfLiteralStr, val, GuString)),
+	       GU_CONSTRUCTOR_S(PGF_LITERAL_INT, PgfLiteralInt,
+				GU_MEMBER(PgfLiteralInt, val, int)),
+	       GU_CONSTRUCTOR_S(PGF_LITERAL_FLT, PgfLiteralFlt,
+				GU_MEMBER(PgfLiteralFlt, val, double)));
+
+GU_DECLARE_TYPE(PgfType, struct);
+
+GU_DEFINE_TYPE(PgfHypo, struct,
+	       GU_MEMBER(PgfHypo, bindtype, PgfBindType),
+	       GU_MEMBER(PgfHypo, cid, PgfCId),
+	       GU_MEMBER_P(PgfHypo, type, PgfType));
+
+GU_DEFINE_TYPE(PgfHypos, GuSeq, gu_type(PgfHypo));
+
+GU_DEFINE_TYPE(PgfType, struct,
+	       GU_MEMBER(PgfType, hypos, PgfHypos),
+	       GU_MEMBER(PgfType, cid, PgfCId),
+	       GU_MEMBER(PgfType, n_exprs, GuLength),
+	       GU_FLEX_MEMBER(PgfType, exprs, PgfExpr));
+
+GU_DEFINE_TYPE(
+	PgfExpr, GuVariant,
+	GU_CONSTRUCTOR_S(
+		PGF_EXPR_ABS, PgfExprAbs,
+		GU_MEMBER(PgfExprAbs, bind_type, PgfBindType),
+		GU_MEMBER(PgfExprAbs, id, GuStr),
+		GU_MEMBER(PgfExprAbs, body, PgfExpr)),
+	GU_CONSTRUCTOR_S(
+		PGF_EXPR_APP, PgfExprApp,
+		GU_MEMBER(PgfExprApp, fun, PgfExpr),
+		GU_MEMBER(PgfExprApp, arg, PgfExpr)),
+	GU_CONSTRUCTOR_S(
+		PGF_EXPR_LIT, PgfExprLit, 
+		GU_MEMBER(PgfExprLit, lit, PgfLiteral)),
+	GU_CONSTRUCTOR_S(
+		PGF_EXPR_META, PgfExprMeta,
+		GU_MEMBER(PgfExprMeta, id, int)),
+	GU_CONSTRUCTOR_S(
+		PGF_EXPR_FUN, PgfExprFun,
+		GU_MEMBER(PgfExprFun, fun, GuStr)),
+	GU_CONSTRUCTOR_S(
+		PGF_EXPR_VAR, PgfExprVar,
+		GU_MEMBER(PgfExprVar, var, int)),
+	GU_CONSTRUCTOR_S(
+		PGF_EXPR_TYPED, PgfExprTyped,
+		GU_MEMBER(PgfExprTyped, expr, PgfExpr),
+		GU_MEMBER_P(PgfExprTyped, type, PgfType)),
+	GU_CONSTRUCTOR_S(
+		PGF_EXPR_IMPL_ARG, PgfExprImplArg,
+		GU_MEMBER(PgfExprImplArg, expr, PgfExpr)));
+
+
+typedef struct PgfExprParser PgfExprParser;
+
+struct PgfExprParser {
+	GuReader* rdr;
+	GuIntern* intern;
+	GuExn* err;
+	GuPool* expr_pool;
+	const char* lookahead;
+	int next_char;
+};
+
+
+static const char pgf_expr_lpar[] = "(";
+static const char pgf_expr_rpar[] = ")";
+static const char pgf_expr_semic[] = ";";
+
+static char
+pgf_expr_parser_next(PgfExprParser* parser)
+{
+	if (parser->next_char >= 0) {
+		char ret = (char) parser->next_char;
+		parser->next_char = -1;
+		return ret;
+	}
+	return gu_getc(parser->rdr, parser->err);
+}
+
+static const char*
+pgf_expr_parser_lookahead(PgfExprParser* parser)
+{
+	if (parser->lookahead != NULL) {
+		return parser->lookahead;
+	}
+	const char* str = NULL;
+	char c;
+	do {
+		c = pgf_expr_parser_next(parser);
+		if (!gu_ok(parser->err)) {
+			return NULL;
+		}
+	} while (isspace(c));
+	switch (c) {
+	case '(':
+		str = pgf_expr_lpar;
+		break;
+	case ')':
+		str = pgf_expr_rpar;
+		break;
+	case ';':
+		str = pgf_expr_semic;
+		break;
+	default:
+		if (isalpha(c)) {
+			GuPool* tmp_pool = gu_new_pool();
+			GuCharBuf* chars = gu_new_buf(char, tmp_pool);
+			while (isalnum(c) || c == '_') {
+				gu_buf_push(chars, char, c);
+				c = pgf_expr_parser_next(parser);
+				if (!gu_ok(parser->err)) {
+					return NULL;
+				}
+			}
+			parser->next_char = (unsigned char) c;
+			char* tmp_str = gu_chars_str(gu_buf_seq(chars),
+						     tmp_pool);
+			str = gu_intern_str(parser->intern, tmp_str);
+			gu_pool_free(tmp_pool);
+		}
+	}
+	parser->lookahead = str;
+	return str;
+}
+
+static bool
+pgf_expr_parser_token_is_id(const char* str)
+{
+	if (str == NULL || !str[0]) {
+		return false;
+	}
+	char c = str[0];
+	return (isalpha(c) || c == '_');
+}
+
+static void
+pgf_expr_parser_consume(PgfExprParser* parser)
+{
+	pgf_expr_parser_lookahead(parser);
+	parser->lookahead = NULL;
+}
+
+static PgfExpr
+pgf_expr_parser_expr(PgfExprParser* parser);
+
+static PgfExpr
+pgf_expr_parser_term(PgfExprParser* parser)
+{
+	const char* la = pgf_expr_parser_lookahead(parser);
+
+	if (la == pgf_expr_lpar) {
+		pgf_expr_parser_consume(parser);
+		PgfExpr expr = pgf_expr_parser_expr(parser);
+		la = pgf_expr_parser_lookahead(parser);
+		if (la == pgf_expr_rpar) {
+			pgf_expr_parser_consume(parser);
+			return expr;
+		}
+	} else if (pgf_expr_parser_token_is_id(la)) {
+		pgf_expr_parser_consume(parser);
+		GuString s = gu_str_string(la, parser->expr_pool);
+		return gu_new_variant_i(parser->expr_pool,
+					PGF_EXPR_FUN,
+					PgfExprFun,
+					s);
+	}
+	return gu_null_variant;
+}
+
+static PgfExpr
+pgf_expr_parser_expr(PgfExprParser* parser)
+{
+	PgfExpr expr = pgf_expr_parser_term(parser);
+	if (gu_variant_is_null(expr))
+	{
+		return expr;
+	}
+	while (true) {
+		PgfExpr arg = pgf_expr_parser_term(parser);
+		if (gu_variant_is_null(arg)) {
+			return expr;
+		}
+		expr = gu_new_variant_i(parser->expr_pool,
+					PGF_EXPR_APP,
+					PgfExprApp,
+					expr, arg);
+	}
+}
+
+
+
+PgfExpr
+pgf_read_expr(GuReader* rdr, GuPool* pool, GuExn* err)
+{
+	GuPool* tmp_pool = gu_new_pool();
+	PgfExprParser* parser = gu_new(PgfExprParser, tmp_pool);
+	parser->rdr = rdr;
+	parser->intern = gu_new_intern(pool, tmp_pool);
+	parser->expr_pool = pool;
+	parser->err = err;
+	parser->lookahead = NULL;
+	parser->next_char = -1;
+	PgfExpr expr = pgf_expr_parser_expr(parser);
+	const char* la = pgf_expr_parser_lookahead(parser);
+	if (la == pgf_expr_semic) {
+		pgf_expr_parser_consume(parser);
+	} else {
+		expr = gu_null_variant;
+	}
+	gu_pool_free(tmp_pool);
+	return expr;
+}
+
+static void
+pgf_expr_print_with_paren(PgfExpr expr, bool need_paren,
+			  GuWriter* wtr, GuExn* err)
+{
+	GuVariantInfo ei = gu_variant_open(expr);
+	switch (ei.tag) {
+	case PGF_EXPR_FUN: {
+		PgfExprFun* fun = ei.data;
+		gu_string_write(fun->fun, wtr, err);
+		break;
+	}
+	case PGF_EXPR_APP: {
+		PgfExprApp* app = ei.data;
+		if (need_paren) {
+			gu_puts("(", wtr, err);
+		}
+		pgf_expr_print_with_paren(app->fun, false, wtr, err);
+		gu_puts(" ", wtr, err);
+		pgf_expr_print_with_paren(app->arg, true, wtr, err);
+		if (need_paren) {
+			gu_puts(")", wtr, err);
+		}
+		break;
+	}
+	case PGF_EXPR_ABS:
+	case PGF_EXPR_LIT:
+	case PGF_EXPR_META:
+	case PGF_EXPR_VAR:
+	case PGF_EXPR_TYPED:
+	case PGF_EXPR_IMPL_ARG:
+		gu_impossible();
+		break;
+	default:
+		gu_impossible();
+	}
+}
+
+void
+pgf_expr_print(PgfExpr expr, GuWriter* wtr, GuExn* err) {
+	pgf_expr_print_with_paren(expr, false, wtr, err);
+}
diff --git a/src/runtime/c/pgf/expr.h b/src/runtime/c/pgf/expr.h
index d4d2aaea2..7ecca30bd 100644
--- a/src/runtime/c/pgf/expr.h
+++ b/src/runtime/c/pgf/expr.h
@@ -1,144 +1,152 @@
-#ifndef PGF_EXPR_H
-#define PGF_EXPR_H
+#ifndef EXPR_H_
+#define EXPR_H_
 
-#define LIT_STR   0
-#define LIT_INT   1
-#define LIT_FLOAT 2
+#include <gu/read.h>
+#include <gu/write.h>
+#include <gu/variant.h>
+#include <gu/seq.h>
+#include <pgf/pgf.h>
 
-struct _Literal {
-  int tag;
+/// Abstract syntax trees
+/// @file
+
+/// An abstract syntax tree
+typedef GuVariant PgfExpr;
+
+GU_DECLARE_TYPE(PgfExpr, GuVariant);
+
+typedef GuList(PgfExpr) PgfExprs;
+
+typedef struct PgfHypo PgfHypo;
+typedef struct PgfType PgfType;
+
+typedef int PgfMetaId;
+
+typedef enum {
+	PGF_BIND_TYPE_EXPLICIT,
+	PGF_BIND_TYPE_IMPLICIT
+} PgfBindType;
+
+// PgfLiteral
+
+typedef GuVariant PgfLiteral;
+
+
+typedef enum {
+	PGF_LITERAL_STR,
+	PGF_LITERAL_INT,
+	PGF_LITERAL_FLT,
+	PGF_LITERAL_NUM_TAGS
+} PgfLiteralTag;
+
+typedef struct {
+	GuStr val;
+} PgfLiteralStr;
+
+typedef struct {
+	int val;
+} PgfLiteralInt;
+
+typedef struct {
+	double val;
+} PgfLiteralFlt;
+
+
+
+struct PgfHypo {
+	PgfBindType bindtype;
+
+	PgfCId cid;
+	/**< Locally scoped name for the parameter if dependent types
+	 * are used. "_" for normal parameters. */
+
+	PgfType* type;
+};
+
+typedef GuSeq PgfHypos;
+extern GU_DECLARE_TYPE(PgfHypos, GuSeq);
+
+struct PgfType {
+	PgfHypos hypos;
+	PgfCId cid; /// XXX: resolve to PgfCat*?
+	int n_exprs;
+	PgfExpr exprs[];
 };
 
-typedef struct _LiteralStr {
-  struct _Literal _;
-  String val;
-} *LiteralStr;
-
-typedef struct _LiteralInt {
-  struct _Literal _;
-  int val;
-} *LiteralInt;
-
-typedef struct _LiteralFloat {
-  struct _Literal _;
-  double val;
-} *LiteralFloat;
-
-#define TAG_ABS 0
-#define TAG_APP 1
-#define TAG_LIT 2
-#define TAG_MET 3
-#define TAG_FUN 4
-#define TAG_VAR 5
-#define TAG_TYP 6
-#define TAG_IMP 7
-
-struct _Expr {
-  int tag;
+			
+typedef enum {
+	PGF_EXPR_ABS,
+	PGF_EXPR_APP,
+	PGF_EXPR_LIT,
+	PGF_EXPR_META,
+	PGF_EXPR_FUN,
+	PGF_EXPR_VAR,
+	PGF_EXPR_TYPED,
+	PGF_EXPR_IMPL_ARG,
+	PGF_EXPR_NUM_TAGS
+} PgfExprTag;
+
+typedef struct {
+	PgfBindType bind_type;
+	PgfCId id; // 
+	PgfExpr body;
+} PgfExprAbs;
+		
+typedef struct {
+	PgfExpr fun;
+	PgfExpr arg;
+} PgfExprApp;
+
+typedef struct {
+	PgfLiteral lit;
+} PgfExprLit;
+
+typedef struct {
+	PgfMetaId id;
+} PgfExprMeta;
+
+typedef struct {
+	PgfCId fun;
+} PgfExprFun;
+
+typedef struct {
+	int var;
+} PgfExprVar;
+
+/**< A variable. The value is a de Bruijn index to the environment,
+ * beginning from the innermost variable. */
+
+typedef struct {
+	PgfExpr expr;
+	PgfType* type;
+} PgfExprTyped;
+
+typedef struct {
+	PgfExpr expr;
+} PgfExprImplArg;
+
+int
+pgf_expr_arity(PgfExpr expr);
+
+PgfExpr
+pgf_expr_unwrap(PgfExpr expr);
+
+typedef struct PgfApplication PgfApplication;
+
+struct PgfApplication {
+	PgfCId fun;
+	int n_args;
+	PgfExpr args[];
 };
 
-typedef struct _ExprAbs {
-  struct _Expr _;
-  BindType bt;
-  CId var;
-  Expr body;
-} *ExprAbs;
-
-typedef struct _ExprApp {
-  struct _Expr _;
-  Expr left, right;
-} *ExprApp;
-
-typedef struct _ExprLit {
-  struct _Expr _;
-  Literal lit;
-} *ExprLit;
-
-typedef struct _ExprMeta {
-  struct _Expr _;
-  int id;
-} *ExprMeta;
-
-typedef struct _ExprFun {
-  struct _Expr _;
-  CId fun;
-} *ExprFun;
-
-typedef struct _ExprVar {
-  struct _Expr _;
-  int index;
-} *ExprVar;
-
-typedef struct _ExprTyped {
-  struct _Expr _;
-  Expr e;
-  Type ty;
-} *ExprTyped;
-
-typedef struct _ExprImplArg {
-  struct _Expr _;
-  Expr e;
-} *ExprImplArg;
-
-#define TAG_PAPP   0
-#define TAG_PVAR   1
-#define TAG_PAT    2
-#define TAG_PWILD  3
-#define TAG_PLIT   4
-#define TAG_PIMP   5
-#define TAG_PTILDE 6
-
-typedef struct _Patt {
-  int tag;
-} *Patt;
-
-typedef struct _Patts {
-  int count;
-  Patt pats[];
-} *Patts;
-
-typedef struct _PattApp {
-  struct _Patt _;
-  CId fun;
-  struct _Patts args;
-} *PattApp;
-
-typedef struct _PattVar {
-  struct _Patt _;
-  CId var;
-} *PattVar;
-
-typedef struct _PattAt {
-  struct _Patt _;
-  CId  var;
-  Patt pat;
-} *PattAt;
-
-typedef struct _PattWild {
-  struct _Patt _;
-} *PattWild;
-
-typedef struct _PattLit {
-  struct _Patt _;
-  Literal lit;
-} *PattLit;
-
-typedef struct _PattImplArg {
-  struct _Patt _;
-  Patt pat;
-} *PattImplArg;
-
-typedef struct _PattTilde {
-  struct _Patt _;
-  Expr e;
-} *PattTilde;
-
-typedef struct _Equations {
-  int count;
-  struct _Equation {
-    Patts lhs;
-    Expr  rhs;
-  } equs[];
-} *Equations;
-
-#endif
+PgfApplication*
+pgf_expr_unapply(PgfExpr expr, GuPool* pool);
+
+
+PgfExpr
+pgf_read_expr(GuReader* rdr, GuPool* pool, GuExn* err);
+
+void
+pgf_expr_print(PgfExpr expr, GuWriter* wtr, GuExn* err);
+
+#endif /* EXPR_H_ */
diff --git a/src/runtime/c/pgf/linearize.c b/src/runtime/c/pgf/linearize.c
new file mode 100644
index 000000000..ce1b99b5b
--- /dev/null
+++ b/src/runtime/c/pgf/linearize.c
@@ -0,0 +1,613 @@
+/* 
+ * 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/>.
+ */
+
+#include "data.h"
+#include "linearize.h"
+#include <gu/map.h>
+#include <gu/fun.h>
+#include <gu/log.h>
+#include <gu/choice.h>
+#include <gu/seq.h>
+#include <gu/string.h>
+#include <gu/assert.h>
+#include <pgf/expr.h>
+
+typedef GuStringMap PgfLinInfer;
+typedef GuSeq PgfProdSeq;
+
+static GU_DEFINE_TYPE(PgfProdSeq, GuSeq, gu_type(PgfProduction));
+
+typedef struct PgfLinInferEntry PgfLinInferEntry;
+
+struct PgfLinInferEntry {
+	PgfCCat* cat;
+	PgfCncFun* fun;
+};
+
+static GU_DEFINE_TYPE(
+	PgfLinInferEntry, struct,
+	GU_MEMBER_P(PgfLinInferEntry, cat, PgfCCat)
+	// ,GU_MEMBER(PgfLinInferEntry, fun, ...)
+	);
+
+typedef GuBuf PgfLinInfers;
+static GU_DEFINE_TYPE(PgfLinInfers, GuBuf, gu_type(PgfLinInferEntry));
+
+typedef GuIntMap PgfCncProds;
+static GU_DEFINE_TYPE(PgfCncProds, GuIntMap, gu_type(PgfProdSeq),
+		      &gu_null_seq);
+
+typedef GuStringMap PgfLinProds;
+static GU_DEFINE_TYPE(PgfLinProds, GuStringMap, gu_ptr_type(PgfCncProds),
+		      &gu_null_struct);
+
+
+static GuHash
+pgf_lzr_cats_hash_fn(GuHasher* self, const void* p)
+{
+	(void) self;
+	PgfCCatIds* cats = *(PgfCCatIds* const*)p;
+	size_t len = gu_list_length(cats);
+	uintptr_t h = 0;
+	for (size_t i = 0; i < len; i++) {
+		h = 101 * h + (uintptr_t) gu_list_index(cats, i);
+	}
+	return h;
+}
+
+static bool
+pgf_lzr_cats_eq_fn(GuEquality* self, const void* p1, const void* p2)
+{
+	(void) self;
+	PgfCCatIds* cats1 = *(PgfCCatIds* const*) p1;
+	PgfCCatIds* cats2 = *(PgfCCatIds* const*) p2;
+	int len = gu_list_length(cats1);
+	if (gu_list_length(cats2) != len) {
+		return false;
+	}
+	for (int i = 0; i < len; i++) {
+		PgfCCat* cat1 = gu_list_index(cats1, i);
+		PgfCCat* cat2 = gu_list_index(cats2, i);
+		if (cat1 != cat2) {
+			return false;
+		}
+	}
+	return true;
+}
+
+static GuHasher
+pgf_lzr_cats_hasher[1] = {
+	{
+		.eq = { pgf_lzr_cats_eq_fn },
+		.hash = pgf_lzr_cats_hash_fn
+	}
+};
+
+typedef GuMap PgfInferMap;
+static GU_DEFINE_TYPE(PgfInferMap, GuMap,
+		      gu_ptr_type(PgfCCatIds), pgf_lzr_cats_hasher,
+		      gu_ptr_type(PgfLinInfers), &gu_null_struct);
+
+typedef GuStringMap PgfFunIndices;
+static GU_DEFINE_TYPE(PgfFunIndices, GuStringMap, gu_ptr_type(PgfInferMap),
+		      &gu_null_struct);
+
+typedef GuBuf PgfCCatBuf;
+static GU_DEFINE_TYPE(PgfCCatBuf, GuBuf, gu_ptr_type(PgfCCat));
+
+typedef GuMap PgfCoerceIdx;
+static GU_DEFINE_TYPE(PgfCoerceIdx, GuMap,
+		      gu_type(PgfCCat), NULL,
+		      gu_ptr_type(PgfCCatBuf), &gu_null_struct);
+
+struct PgfLzr {
+	PgfConcr* cnc;
+	GuPool* pool;
+	PgfFunIndices* fun_indices;
+	PgfCoerceIdx* coerce_idx;
+};
+
+GU_DEFINE_TYPE(
+	PgfLzr, struct,
+	GU_MEMBER_P(PgfLzr, cnc, PgfConcr),
+	GU_MEMBER_P(PgfLzr, fun_indices, PgfFunIndices),
+	GU_MEMBER_P(PgfLzr, coerce_idx, PgfCoerceIdx));
+
+
+
+
+static void
+pgf_lzr_add_infer_entry(PgfLzr* lzr,
+			PgfInferMap* infer_table,
+			PgfCCat* cat,
+			PgfProductionApply* papply)
+{
+	PgfPArgs args = papply->args;
+	size_t n_args = gu_seq_length(args);
+	PgfCCatIds* arg_cats = gu_new_list(PgfCCatIds, lzr->pool, n_args);
+	for (size_t i = 0; i < n_args; i++) {
+		// XXX: What about the hypos in the args?
+		gu_list_index(arg_cats, i) = gu_seq_get(args, PgfPArg, i).ccat;
+	}
+	gu_debug("%d,%d,%d -> %d, %s",
+		 n_args > 0 ? gu_list_index(arg_cats, 0)->fid : -1,
+		 n_args > 1 ? gu_list_index(arg_cats, 1)->fid : -1,
+		 n_args > 2 ? gu_list_index(arg_cats, 2)->fid : -1,
+		 cat->fid, papply->fun->fun);
+	PgfLinInfers* entries =
+		gu_map_get(infer_table, &arg_cats, PgfLinInfers*);
+	if (!entries) {
+		entries = gu_new_buf(PgfLinInferEntry, lzr->pool);
+		gu_map_put(infer_table, &arg_cats, PgfLinInfers*, entries);
+	} else {
+		// XXX: arg_cats is duplicate, we ought to free it
+		// Display warning?
+	}
+
+	PgfLinInferEntry entry = {
+		.cat = cat,
+		.fun = papply->fun
+	};
+	gu_buf_push(entries, PgfLinInferEntry, entry);
+}
+			
+
+static void
+pgf_lzr_index(PgfLzr* lzr, PgfCCat* cat, PgfProduction prod)
+{
+	void* data = gu_variant_data(prod);
+	switch (gu_variant_tag(prod)) {
+	case PGF_PRODUCTION_APPLY: {
+		PgfProductionApply* papply = data;
+		PgfInferMap* infer =
+			gu_map_get(lzr->fun_indices, &papply->fun->fun,
+				   PgfInferMap*);
+		gu_debug("index: %s -> %d", papply->fun->fun, cat->fid);
+		if (!infer) {
+			infer = gu_map_type_new(PgfInferMap, lzr->pool);
+			gu_map_put(lzr->fun_indices,
+				   &papply->fun->fun, PgfInferMap*, infer);
+		}
+		pgf_lzr_add_infer_entry(lzr, infer, cat, papply);
+		break;
+	}
+	case PGF_PRODUCTION_COERCE: {
+		PgfProductionCoerce* pcoerce = data;
+		PgfCCatBuf* cats = gu_map_get(lzr->coerce_idx, pcoerce->coerce,
+					      PgfCCatBuf*);
+		if (!cats) {
+			cats = gu_new_buf(PgfCCat*, lzr->pool);
+			gu_map_put(lzr->coerce_idx, 
+				   pcoerce->coerce, PgfCCatBuf*, cats);
+		}
+		gu_debug("coerce_idx: %d -> %d", pcoerce->coerce->fid, cat->fid);
+		gu_buf_push(cats, PgfCCat*, cat);
+		break;
+	}
+	default:
+		// Display warning?
+		break;
+	}
+}
+
+static void
+pgf_lzr_index_ccat(PgfLzr* lzr, PgfCCat* cat)
+{
+	gu_debug("ccat: %d", cat->fid);
+	if (gu_seq_is_null(cat->prods)) {
+		return;
+	}
+	size_t n_prods = gu_seq_length(cat->prods);
+	for (size_t i = 0; i < n_prods; i++) {
+		PgfProduction prod = gu_seq_get(cat->prods, PgfProduction, i);
+		pgf_lzr_index(lzr, cat, prod);
+	}
+}
+
+typedef struct {
+	GuMapItor fn;
+	PgfLzr* lzr;
+} PgfLzrIndexFn;
+
+static void
+pgf_lzr_index_cnccat_cb(GuMapItor* fn, const void* key, void* value,
+			GuExn* err)
+{
+	(void) (key && err);
+	PgfLzrIndexFn* clo = (PgfLzrIndexFn*) fn;
+	PgfCncCat** cnccatp = value;
+	PgfCncCat* cnccat = *cnccatp;
+	gu_enter("-> cnccat: %s", cnccat->cid);
+	int n_ccats = gu_list_length(cnccat->cats);
+	for (int i = 0; i < n_ccats; i++) {
+		PgfCCat* cat = gu_list_index(cnccat->cats, i);
+		if (cat) {
+			pgf_lzr_index_ccat(clo->lzr, cat);
+		}
+	}
+	gu_exit("<-");
+}
+
+
+PgfLzr*
+pgf_new_lzr(PgfConcr* cnc, GuPool* pool)
+{
+	PgfLzr* lzr = gu_new(PgfLzr, pool);
+	lzr->cnc = cnc;
+	lzr->pool = pool;
+	lzr->fun_indices = gu_map_type_new(PgfFunIndices, pool);
+	lzr->coerce_idx = gu_map_type_new(PgfCoerceIdx, pool);
+	PgfLzrIndexFn clo = { { pgf_lzr_index_cnccat_cb }, lzr };
+	gu_map_iter(cnc->cnccats, &clo.fn, NULL);
+	size_t n_extras = gu_seq_length(cnc->extra_ccats);
+	for (size_t i = 0; i < n_extras; i++) {
+		PgfCCat* cat = gu_seq_get(cnc->extra_ccats, PgfCCat*, i);
+		pgf_lzr_index_ccat(lzr, cat);
+	}
+	// TODO: prune productions with zero linearizations
+	return lzr;
+}
+
+typedef struct PgfLzn PgfLzn;
+
+struct PgfLzn {
+	PgfLzr* lzr;
+	GuChoice* ch;
+	PgfExpr expr;
+	GuEnum en;
+};
+
+
+//
+// PgfCncTree
+//
+
+typedef enum {
+	PGF_CNC_TREE_APP,
+	PGF_CNC_TREE_LIT,
+} PgfCncTreeTag;
+
+typedef struct PgfCncTreeApp PgfCncTreeApp;
+struct PgfCncTreeApp {
+	PgfCncFun* fun;
+	GuLength n_args;
+	PgfCncTree args[];
+};
+
+typedef struct PgfCncTreeLit PgfCncTreeLit;
+struct PgfCncTreeLit {
+	PgfLiteral lit;
+};
+
+
+static PgfCCat*
+pgf_lzn_pick_supercat(PgfLzn* lzn, PgfCCat* cat)
+{
+	gu_enter("->");
+	while (true) {
+		PgfCCatBuf* supers =
+			gu_map_get(lzn->lzr->coerce_idx, cat, PgfCCatBuf*);
+		if (!supers) {
+			break;
+		}
+		gu_debug("n_supers: %d", gu_buf_length(supers));
+		int ch = gu_choice_next(lzn->ch, gu_buf_length(supers) + 1);
+		gu_debug("choice: %d", ch);
+		if (ch == 0) {
+			break;
+		}
+		cat = gu_buf_get(supers, PgfCCat*, ch - 1);
+	}
+	gu_exit("<- %d", cat->fid);
+	return cat;
+}
+
+static PgfCCat*
+pgf_lzn_infer(PgfLzn* lzn, PgfExpr expr, GuPool* pool, PgfCncTree* ctree_out);
+
+static PgfCCat*
+pgf_lzn_infer_apply_try(PgfLzn* lzn, PgfApplication* appl,
+			PgfInferMap* infer, GuChoiceMark* marks,
+			PgfCCatIds* arg_cats, int* ip, int n_args, 
+			GuPool* pool, PgfCncTreeApp* app_out)
+{
+	gu_enter("f: %s, *ip: %d, n_args: %d", appl->fun, *ip, n_args);
+	PgfCCat* ret = NULL;
+	while (*ip < n_args) {
+		PgfCncTree* arg_treep = 
+			(app_out == NULL ? NULL : &app_out->args[*ip]);
+		PgfCCat* arg_i = 
+			pgf_lzn_infer(lzn, appl->args[*ip], pool, arg_treep);
+		if (arg_i == NULL) {
+			goto finish;
+		}
+		arg_i = pgf_lzn_pick_supercat(lzn, arg_i);
+		gu_list_index(arg_cats, *ip) = arg_i;
+		marks[++*ip] = gu_choice_mark(lzn->ch);
+	}
+	PgfLinInfers* entries = gu_map_get(infer, &arg_cats, PgfLinInfers*);
+	if (!entries) {
+		goto finish;
+	}
+	size_t n_entries = gu_buf_length(entries);
+	int e = gu_choice_next(lzn->ch, n_entries);
+	gu_debug("entry %d of %d", e, n_entries);
+	if (e < 0) {
+		goto finish;
+	}
+	PgfLinInferEntry* entry = gu_buf_index(entries, PgfLinInferEntry, e);
+	if (app_out != NULL) {
+		app_out->fun = entry->fun;
+	}
+	ret = entry->cat;
+finish:
+	gu_exit("fid: %d", ret ? ret->fid : -1);
+	return ret;
+}
+typedef GuList(GuChoiceMark) PgfChoiceMarks;
+
+static PgfCCat*
+pgf_lzn_infer_application(PgfLzn* lzn, PgfApplication* appl, 
+			  GuPool* pool, PgfCncTree* ctree_out)
+{
+	PgfInferMap* infer =
+		gu_map_get(lzn->lzr->fun_indices, &appl->fun, PgfInferMap*);
+	gu_enter("-> f: %s, n_args: %d", appl->fun, appl->n_args);
+	if (infer == NULL) {
+		gu_exit("<- couldn't find f");
+		return NULL;
+	}
+	GuPool* tmp_pool = gu_new_pool();
+	PgfCCat* ret = NULL;
+	int n = appl->n_args;
+	PgfCCatIds* arg_cats = gu_new_list(PgfCCatIds, tmp_pool, n);
+
+	PgfCncTreeApp* appt = NULL;
+	if (ctree_out) {
+		appt = gu_new_flex_variant(PGF_CNC_TREE_APP, PgfCncTreeApp, 
+					   args, n, ctree_out, pool);
+		appt->n_args = n;
+	}
+
+	PgfChoiceMarks* marksl = gu_new_list(PgfChoiceMarks, tmp_pool, n + 1);
+	GuChoiceMark* marks = gu_list_elems(marksl);
+	int i = 0;
+	marks[i] = gu_choice_mark(lzn->ch);
+	while (true) {
+		ret = pgf_lzn_infer_apply_try(lzn, appl, infer,
+					      marks, arg_cats,
+					      &i, n, pool, appt);
+		if (ret != NULL) {
+			break;
+		}
+
+		do {
+			--i;
+			if (i < 0) {
+				goto finish;
+			}
+			gu_choice_reset(lzn->ch, marks[i]);
+		} while (!gu_choice_advance(lzn->ch));
+	}
+finish:
+	gu_pool_free(tmp_pool);
+	gu_exit("<- fid: %d", ret ? ret->fid : -1);
+	return ret;
+}
+
+static PgfCCat*
+pgf_lzn_infer(PgfLzn* lzn, PgfExpr expr, GuPool* pool, PgfCncTree* ctree_out)
+{
+	PgfCCat* ret = NULL;
+	GuPool* tmp_pool = gu_new_pool();
+	PgfApplication* appl = pgf_expr_unapply(expr, tmp_pool);
+	if (appl != NULL) {
+		ret = pgf_lzn_infer_application(lzn, appl, pool, ctree_out);
+	} else {
+		GuVariantInfo i = gu_variant_open(pgf_expr_unwrap(expr));
+		switch (i.tag) {
+		case PGF_EXPR_LIT: {
+			PgfExprLit* elit = i.data;
+			if (pool != NULL) {
+				*ctree_out = gu_new_variant_i(
+					pool, PGF_CNC_TREE_LIT,
+					PgfCncTreeLit,
+					.lit = elit->lit);
+			}
+			ret = pgf_literal_cat(elit->lit);
+		}
+		default:
+			// XXX: should we do something here?
+			break;
+		}
+	}
+	gu_pool_free(tmp_pool);
+	return ret;
+}
+
+
+static PgfCncTree
+pgf_lzn_next(PgfLzn* lzn, GuPool* pool)
+{
+	// XXX: rewrite this whole mess
+	PgfCncTree ctree = gu_null_variant;
+	if (gu_variant_is_null(lzn->expr)) {
+		return ctree;
+	}
+	PgfCCat* cat = NULL;
+	GuChoiceMark mark = gu_choice_mark(lzn->ch);
+	do {
+		cat = pgf_lzn_infer(lzn, lzn->expr, NULL, NULL);
+		gu_choice_reset(lzn->ch, mark);
+	} while (!cat && gu_choice_advance(lzn->ch));
+
+	if (cat) {
+		PgfCCat* cat2 = pgf_lzn_infer(lzn, lzn->expr, pool, &ctree);
+		gu_assert(cat == cat2);
+		gu_debug("fid: %d", cat->fid);
+		gu_choice_reset(lzn->ch, mark);
+		if (!gu_choice_advance(lzn->ch)) {
+			lzn->expr = gu_null_variant;
+		}
+	}
+	return ctree;
+}
+
+static void
+pgf_cnc_tree_enum_next(GuEnum* self, void* to, GuPool* pool)
+{
+	PgfLzn* lzn = gu_container(self, PgfLzn, en);
+	PgfCncTree* toc = to;
+	*toc = pgf_lzn_next(lzn, pool);
+}
+
+PgfCncTreeEnum*
+pgf_lzr_concretize(PgfLzr* lzr, PgfExpr expr, GuPool* pool)
+{
+	PgfLzn* lzn = gu_new(PgfLzn, pool);
+	lzn->lzr = lzr;
+	lzn->expr = expr;
+	lzn->ch = gu_new_choice(pool);
+	lzn->en.next = pgf_cnc_tree_enum_next;
+	return &lzn->en;
+}
+
+
+int
+pgf_cnc_tree_dimension(PgfCncTree ctree)
+{
+	GuVariantInfo cti = gu_variant_open(ctree);
+	switch (cti.tag) {
+	case PGF_CNC_TREE_LIT: 
+		return 1;
+	case PGF_CNC_TREE_APP: {
+		PgfCncTreeApp* fapp = cti.data;
+		return fapp->fun->n_lins;
+	}
+	default:
+		gu_impossible();
+		return 0;
+	}
+}
+
+void
+pgf_lzr_linearize(PgfLzr* lzr, PgfCncTree ctree, size_t lin_idx, PgfLinFuncs** fnsp)
+{
+	PgfLinFuncs* fns = *fnsp;
+	GuVariantInfo cti = gu_variant_open(ctree);
+
+	switch (cti.tag) {
+	case PGF_CNC_TREE_LIT: {
+		gu_require(lin_idx == 0);
+		PgfCncTreeLit* flit = cti.data;
+		if (fns->expr_literal) {
+			fns->expr_literal(fnsp, flit->lit);
+		}
+		break;
+	}
+	case PGF_CNC_TREE_APP: {
+		PgfCncTreeApp* fapp = cti.data;
+		PgfCncFun* fun = fapp->fun;
+		if (fns->expr_apply) {
+			fns->expr_apply(fnsp, fun->fun, fapp->n_args);
+		}
+		gu_require(lin_idx < fun->n_lins);
+		PgfSequence seq = fun->lins[lin_idx];
+		size_t nsyms = gu_seq_length(seq);
+		PgfSymbol* syms = gu_seq_data(seq);
+		for (size_t i = 0; i < nsyms; i++) {
+			PgfSymbol sym = syms[i];
+			GuVariantInfo sym_i = gu_variant_open(sym);
+			switch (sym_i.tag) {
+			case PGF_SYMBOL_CAT:
+			case PGF_SYMBOL_VAR:
+			case PGF_SYMBOL_LIT: {
+				PgfSymbolIdx* sidx = sym_i.data;
+				gu_assert((unsigned) sidx->d < fapp->n_args);
+				PgfCncTree argf = fapp->args[sidx->d];
+				pgf_lzr_linearize(lzr, argf, sidx->r, fnsp);
+				break;
+			}
+			case PGF_SYMBOL_KS: {
+				PgfSymbolKS* ks = sym_i.data;
+				if (fns->symbol_tokens) {
+					fns->symbol_tokens(fnsp, ks->tokens);
+				}
+				break;
+			}
+			case PGF_SYMBOL_KP: {
+				// TODO: correct prefix-dependencies
+				PgfSymbolKP* kp = sym_i.data;
+				if (fns->symbol_tokens) {
+					fns->symbol_tokens(fnsp,
+							   kp->default_form);
+				}
+				break;
+			}
+			default:
+				gu_impossible(); 
+			}
+		}
+		break;
+	} // case PGF_CNC_TREE_APP
+	default:
+		gu_impossible();
+	}
+}
+
+
+
+typedef struct PgfSimpleLin PgfSimpleLin;
+
+struct PgfSimpleLin {
+	PgfLinFuncs* funcs;
+	GuWriter* wtr;
+	GuExn* err;
+};
+
+static void
+pgf_file_lzn_symbol_tokens(PgfLinFuncs** funcs, PgfTokens toks)
+{
+	PgfSimpleLin* flin = gu_container(funcs, PgfSimpleLin, funcs);
+	if (!gu_ok(flin->err)) {
+		return;
+	}
+	size_t len = gu_seq_length(toks);
+	for (size_t i = 0; i < len; i++) {
+		PgfToken tok = gu_seq_get(toks, PgfToken, i);
+		gu_string_write(tok, flin->wtr, flin->err);
+		gu_putc(' ', flin->wtr, flin->err);
+	}
+}
+
+static PgfLinFuncs pgf_file_lin_funcs = {
+	.symbol_tokens = pgf_file_lzn_symbol_tokens
+};
+
+void
+pgf_lzr_linearize_simple(PgfLzr* lzr, PgfCncTree ctree,
+			 size_t lin_idx, GuWriter* wtr, GuExn* err)
+{
+	PgfSimpleLin flin = {
+		.funcs = &pgf_file_lin_funcs,
+		.wtr = wtr,
+		.err = err
+	};
+	pgf_lzr_linearize(lzr, ctree, lin_idx, &flin.funcs);
+}
diff --git a/src/runtime/c/pgf/linearize.h b/src/runtime/c/pgf/linearize.h
new file mode 100644
index 000000000..db36343f2
--- /dev/null
+++ b/src/runtime/c/pgf/linearize.h
@@ -0,0 +1,156 @@
+/* 
+ * Copyright 2010-2011 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/>.
+ */
+
+#include <gu/type.h>
+#include <gu/dump.h>
+#include <gu/enum.h>
+#include <pgf/data.h>
+
+/// Linearization of abstract syntax trees.
+/// @file
+
+/** @name Linearizers
+ *
+ * Linearization begins by choosing a concrete category (#PgfConcr) for some
+ * grammar, and creating a new linearizer (#PgfLzr) which can then be used to
+ * linearize abstract syntax trees (#PgfExpr) of that grammar into the given
+ * concrete category.
+ *
+ * @{
+ */
+
+
+/// A linearizer.
+typedef struct PgfLzr PgfLzr;
+/**<
+ *
+ * A #PgfLzr object transforms abstract syntax trees of a PGF grammar
+ * into sequences of token events for a single concrete category of
+ * that grammar.
+ * 
+ */
+GU_DECLARE_TYPE(PgfLzr, struct);
+
+
+/// Create a new linearizer.
+PgfLzr*
+pgf_new_lzr(PgfConcr* cnc, GuPool* pool);
+/**<
+ * @param cnc The concrete category to linearize to. 
+ *
+ * @pool
+ *
+ * @return A new linearizer.
+ */
+
+/** @}
+ *
+ * @name Enumerating concrete syntax trees
+ *
+ * Because of the \c variants construct in GF, there may be several
+ * possible concrete syntax trees that correspond to a given abstract
+ * syntax tree. These can be enumerated with #pgf_lzr_concretize and
+ * #pgf_cnc_trees_next.
+ *
+ * @{
+ */
+
+
+/// A concrete syntax tree
+typedef GuVariant PgfCncTree;
+
+/// An enumeration of #PgfCncTree trees.
+typedef GuEnum PgfCncTreeEnum;
+
+/// Begin enumerating concrete syntax variants.
+PgfCncTreeEnum*
+pgf_lzr_concretize(PgfLzr* lzr, PgfExpr expr, GuPool* pool);
+
+/** @}
+ *
+ * @name Linearizing concrete syntax trees
+ *
+ * An individual concrete syntax tree has several different
+ * linearizations, corresponding to the various fields and cases of
+ * corresponding GF values. The number of these linearizations, called
+ * the \e dimension of the tree, can be retrieved with
+ * #pgf_cnc_tree_dimension.
+ *  
+ * A single linearization of a concrete syntax tree is performed by
+ * #pgf_lzr_linearize. The linearization is realized as a sequence of
+ * events that are notified by calling the functions of a #PgfLinFuncs
+ * structure that the client provides.
+ *
+ * @{
+ */
+
+/// Callback functions for linearization.
+typedef struct PgfLinFuncs PgfLinFuncs;
+
+struct PgfLinFuncs
+{
+	/// Output tokens
+	void (*symbol_tokens)(PgfLinFuncs** self, PgfTokens toks);
+
+	void (*symbol_expr)(PgfLinFuncs** self, 
+			    int argno, PgfExpr expr, int lin_idx);
+
+	/// Begin application
+	void (*expr_apply)(PgfLinFuncs** self, PgfCId cid, int n_args);
+
+	/// Output literal
+	void (*expr_literal)(PgfLinFuncs** self, PgfLiteral lit);
+
+	void (*abort)(PgfLinFuncs** self);
+	void (*finish)(PgfLinFuncs** self);
+};
+
+
+
+
+
+/// Linearize a concrete syntax tree.
+void
+pgf_lzr_linearize(PgfLzr* lzr, PgfCncTree ctree, size_t lin_idx,
+		  PgfLinFuncs** fnsp);
+
+
+/// Linearize a concrete syntax tree as space-separated tokens.
+void
+pgf_lzr_linearize_simple(PgfLzr* lzr, PgfCncTree ctree,
+			 size_t lin_idx, GuWriter* wtr, GuExn* err);
+
+
+/// Return the dimension of a concrete syntax tree.
+int
+pgf_cnc_tree_dimension(PgfCncTree ctree);
+/**<
+ * @param ctree A concrete syntax tree.
+ *
+ * @return The dimension of the tree, i.e. the number of different
+ * linearizations the tree has.
+ */
+
+//@}
+
+
+
+extern GuTypeTable
+pgf_linearize_dump_table;
+
diff --git a/src/runtime/c/pgf/loader.c b/src/runtime/c/pgf/loader.c
deleted file mode 100644
index 0d2f40661..000000000
--- a/src/runtime/c/pgf/loader.c
+++ /dev/null
@@ -1,396 +0,0 @@
-#include "../pgf.h"
-#include "data.h"
-#include "panic.h"
-#include <stdio.h>
-#include <stdlib.h>
-
-static int readTag(FILE *f) {
-  return getc(f);
-}
-
-static int readInt16(FILE *f) {
-  int x = getc(f);
-  int y = getc(f);
-  return ((x << 8) | y);
-}
-
-static int readInt(FILE *f) {
-  unsigned int x = (unsigned int) getc(f);
-  if (x <= 0x7f)
-    return (int) x;
-  else {
-    unsigned int y = (unsigned int) readInt(f);
-    return (int) ((y << 7) | (x & 0x7f)) ;
-  }
-}
-
-static double readFloat(FILE *f) {
-  double d;
-  fread(&d, sizeof(d), 1, f);
-  return d;
-}
-
-static String readString(FILE *f) {
-  int len = readInt(f);
-  String str = (String) malloc(sizeof(struct _CId)+len*sizeof(unsigned int));
-  str->len = len;
-  
-  int i;
-  for (i = 0; i < len; i++) {
-    int c = fgetc(f);
-    str->chars[i] = c;
-  }
-  
-  return str;
-}
-
-static CId readCId(FILE *f) {
-  int len = readInt(f);
-  CId cid = (CId) malloc(sizeof(struct _CId)+len*sizeof(char));
-  cid->len = len;
-  fread(&cid->chars, sizeof(char), len, f);
-  return cid;
-}
-
-static CIdList readCIdList(FILE *f) {
-  int i;
-  int count = readInt(f);
-  CIdList list = (CIdList) malloc(sizeof(struct _CIdList)+count*sizeof(CId));
-  
-  list->count = count;
-  for (i = 0; i < count; i++) {
-    list->names[i]  = readCId(f);
-  }
-
-  return list;
-}
-
-static Literal readLiteral(FILE *f) {
-  int tag = readTag(f);
-  switch (tag) {
-    case LIT_STR:
-      { 
-	LiteralStr lit = (LiteralStr) malloc(sizeof(struct _LiteralStr));
-        lit->_.tag = tag;
-        lit->val   = readString(f);
-        return ((Literal) lit);
-      }
-    case LIT_INT:
-      { 
-	LiteralInt lit = (LiteralInt) malloc(sizeof(struct _LiteralInt));
-        lit->_.tag = tag;
-        lit->val   = readInt(f);
-        return ((Literal) lit);
-      }
-    case LIT_FLOAT:
-      {
-        LiteralFloat lit = (LiteralFloat) malloc(sizeof(struct _LiteralFloat));
-        lit->_.tag = tag;
-        lit->val   = readFloat(f);
-        return ((Literal) lit);
-      }
-    default:
-      __pgf_panic("Unknown literal tag");
-  }
-}
-
-static Flags readFlags(FILE *f) {
-  int i;
-  int count = readInt(f);
-  Flags flags = (Flags) malloc(sizeof(struct _Flags)+count*sizeof(struct _Flag));
-  
-  flags->count = count;
-  for (i = 0; i < count; i++) {
-    flags->values[i].name  = readCId(f);
-    flags->values[i].value = readLiteral(f);
-  }
-
-  return flags;
-}
-
-static Context readContext(FILE *f);
-static Type readType(FILE *f);
-
-static Expr readExpr(FILE *f) {
-  int tag = readTag(f);
-  
-  switch (tag) {
-  case TAG_ABS:
-    {
-        ExprAbs e = (ExprAbs) malloc(sizeof(struct _ExprAbs));
-        e->_.tag = tag;
-        e->bt    = readTag(f);
-        e->var   = readCId(f);
-        e->body  = readExpr(f);
-        return ((Expr) e);
-    }
-  case TAG_APP:
-    {
-        ExprApp e = (ExprApp) malloc(sizeof(struct _ExprApp));
-        e->_.tag = tag;
-        e->left  = readExpr(f);
-        e->right = readExpr(f);
-        return ((Expr) e);
-    }
-  case TAG_LIT:
-    {
-        ExprLit e = (ExprLit) malloc(sizeof(struct _ExprLit));
-        e->_.tag = tag;
-        e->lit   = readLiteral(f);
-        return ((Expr) e);
-    }
-  case TAG_MET:
-    {
-        ExprMeta e = (ExprMeta) malloc(sizeof(struct _ExprMeta));
-        e->_.tag = tag;
-        e->id    = readInt(f);
-        return ((Expr) e);
-    }
-  case TAG_FUN:
-    {
-        ExprFun e = (ExprFun) malloc(sizeof(struct _ExprFun));
-        e->_.tag = tag;
-        e->fun   = readCId(f);
-        return ((Expr) e);
-    }
-  case TAG_VAR:
-    {
-        ExprVar e = (ExprVar) malloc(sizeof(struct _ExprVar));
-        e->_.tag = tag;
-        e->index = readInt(f);
-        return ((Expr) e);
-    }
-  case TAG_TYP:
-    {
-        ExprTyped e = (ExprTyped) malloc(sizeof(struct _ExprTyped));
-        e->_.tag = tag;
-        e->e     = readExpr(f);
-        e->ty    = readType(f);
-        return ((Expr) e);
-    }
-  case TAG_IMP:
-    {
-        ExprImplArg e = (ExprImplArg) malloc(sizeof(struct _ExprImplArg));
-        e->_.tag = tag;
-        e->e     = readExpr(f);
-        return ((Expr) e);
-    }
-  default:
-    __pgf_panic("Unknown expression tag");
-  }
-}
-	
-static Type readType(FILE *f) {
-  Context hypos = readContext(f);
-  CId     cat   = readCId(f);
-  
-  int i;
-  int count = readInt(f);
-  Type ty = (Type) malloc(sizeof(struct _Type)+count*sizeof(Expr));
-  
-  ty->hypos = hypos;
-  ty->cat   = cat;
-  ty->nArgs = count;
-  for (i = 0; i < count; i++) {
-    ty->args[i]  = readExpr(f);
-  }
-  
-  return ty;
-}
-
-static void readHypo(FILE *f, Hypo h) {
-  h->bt  = readTag(f);
-  h->var = readCId(f);
-  h->ty  = readType(f);
-}
-
-static Context readContext(FILE *f) {
-  int i;
-  int size = readInt(f);
-  Context ctxt = (Context) malloc(sizeof(struct _Context)+size*sizeof(struct _Hypo));
-  
-  ctxt->size = size;
-  for (i = 0; i < size; i++) {
-    readHypo(f, &ctxt->hypos[i]);
-  }
-  
-  return ctxt;
-}
-
-static Patt readPatt(FILE *f) {
-  int tag = readTag(f);
-
-  switch (tag) {
-  case TAG_PAPP:
-    {
-       CId fun = readCId(f);
-       
-       int i;
-       int count = readInt(f);
-       PattApp p = (PattApp) malloc(sizeof(struct _PattApp)+count*sizeof(Patt));
-  
-       p->_.tag      = tag;
-       p->fun        = fun;
-       p->args.count = count;
-       for (i = 0; i < count; i++) {
-         p->args.pats[i] = readPatt(f);
-       }
-       
-       return ((Patt) p);
-    }
-  case TAG_PVAR:
-    {
-        PattVar p = (PattVar) malloc(sizeof(struct _PattVar));
-        p->_.tag = tag;
-        p->var   = readCId(f);
-        return ((Patt) p);
-    }
-  case TAG_PAT:
-    {
-        PattAt p = (PattAt) malloc(sizeof(struct _PattAt));
-        p->_.tag = tag;
-        p->var   = readCId(f);
-        p->pat   = readPatt(f);
-        return ((Patt) p);
-    }
-  case TAG_PWILD:
-    {
-        PattWild p = (PattWild) malloc(sizeof(struct _PattWild));
-        p->_.tag = tag;
-        return ((Patt) p);
-    }
-  case TAG_PLIT:
-    {
-        PattLit p = (PattLit) malloc(sizeof(struct _PattLit));
-        p->_.tag = tag;
-        p->lit   = readLiteral(f);
-        return ((Patt) p);
-    }
-  case TAG_PIMP:
-    {
-        PattImplArg p = (PattImplArg) malloc(sizeof(struct _PattImplArg));
-        p->_.tag = tag;
-        p->pat   = readPatt(f);
-        return ((Patt) p);
-    }
-  case TAG_PTILDE:
-    {
-        PattTilde p = (PattTilde) malloc(sizeof(struct _PattTilde));
-        p->_.tag = tag;
-        p->e     = readExpr(f);
-        return ((Patt) p);
-    }
-  default:
-    __pgf_panic("Unknown pattern tag");
-  }  
-}
-
-static Patts readPatts(FILE *f) {
-  int i;
-  int count = readInt(f);
-  Patts pats = (Patts) malloc(sizeof(struct _Patts)+count*sizeof(Patt));
-  
-  pats->count = count;
-  for (i = 0; i < count; i++) {
-    pats->pats[i] = readPatt(f);
-  }
-
-  return pats;
-}
-
-static Equations readEquations(FILE *f) {
-  int i;
-  int count = readInt(f);
-  Equations equs = (Equations) malloc(sizeof(struct _Equations)+count*sizeof(struct _Equation));
-  
-  equs->count = count;
-  for (i = 0; i < count; i++) {
-    equs->equs[i].lhs = readPatts(f);
-    equs->equs[i].rhs = readExpr(f);
-  }
-
-  return equs;
-}
-
-static void readAbsFun(FILE *f, AbsFun fun) {
-  fun->name   = readCId(f);
-  fun->ty     = readType(f);
-  fun->arrity = readInt(f);
-  if (readTag(f) != 0)
-    fun->equs   = readEquations(f);
-  else
-    fun->equs   = NULL;
-}
-
-static AbsFuns readAbsFuns(FILE *f) {
-  int i;
-  int count = readInt(f);
-  AbsFuns funs = (AbsFuns) malloc(sizeof(struct _AbsFuns)+count*sizeof(struct _AbsFun));
-  
-  funs->count = count;
-  for (i = 0; i < count; i++) {
-    readAbsFun(f, &funs->lst[i]);
-  }
-  
-  return funs;
-}
-
-static void readAbsCat(FILE *f, AbsCat cat) {
-  cat->name  = readCId(f);
-  cat->hypos = readContext(f);
-  cat->funs  = readCIdList(f);
-}
-
-static AbsCats readAbsCats(FILE *f) {
-  int i;
-  int count = readInt(f);
-  AbsCats cats = (AbsCats) malloc(sizeof(struct _AbsCats)+count*sizeof(struct _AbsCat));
-  
-  cats->count = count;
-  for (i = 0; i < count; i++) {
-    readAbsCat(f, &cats->lst[i]);
-  }
-  
-  return cats;
-}
-
-static void readAbstr(FILE *f, Abstract abstr) {
-  abstr->name  = readCId(f);
-  abstr->flags = readFlags(f);
-  abstr->funs  = readAbsFuns(f);
-  abstr->cats  = readAbsCats(f);
-}
-
-static void readConcr(FILE *f, Concrete concr) {
-  concr->name  = readCId(f);
-  concr->flags = readFlags(f);
-}
-
-PGF readPGF(char *filename) {
-  FILE *f = fopen(filename, "rb");
-  if (f == NULL)
-    return NULL;
-    
-  int maj_ver = readInt16(f);
-  int min_ver = readInt16(f);
-  
-  Flags flags = readFlags(f);
-  
-  struct _Abstract abstr;
-  readAbstr(f, &abstr);
-  
-  int nConcr = readInt(f);
-  PGF pgf = (PGF) malloc(sizeof(struct _PGF)+sizeof(Concrete)*nConcr);
-  
-  pgf->flags    = flags;
-  pgf->abstract = abstr;
-  pgf->nConcr   = nConcr;
-  
-  int i;
-//  for (i = 0; i < nConcr; i++) {
-//    readConcr(f, &pgf->concretes[i]);
-//  }
-
-  fclose(f);
-  return pgf;
-}
diff --git a/src/runtime/c/pgf/panic.c b/src/runtime/c/pgf/panic.c
deleted file mode 100644
index 2a8553a83..000000000
--- a/src/runtime/c/pgf/panic.c
+++ /dev/null
@@ -1,8 +0,0 @@
-#include "panic.h"
-#include <stdio.h>
-
-void __pgf_panic(char *msg) {
-  printf("%s\n",msg);
-  fflush(stdout);
-  exit(1);
-}
diff --git a/src/runtime/c/pgf/panic.h b/src/runtime/c/pgf/panic.h
deleted file mode 100644
index 00ace7533..000000000
--- a/src/runtime/c/pgf/panic.h
+++ /dev/null
@@ -1,6 +0,0 @@
-#ifndef PGF_PANIC_H
-#define PGF_PANIC_H
-
-void __pgf_panic(char *msg);
-
-#endif
diff --git a/src/runtime/c/pgf/parser.c b/src/runtime/c/pgf/parser.c
new file mode 100644
index 000000000..59ee66182
--- /dev/null
+++ b/src/runtime/c/pgf/parser.c
@@ -0,0 +1,697 @@
+#include <pgf/parser.h>
+#include <gu/choice.h>
+#include <gu/seq.h>
+#include <gu/assert.h>
+#include <gu/log.h>
+
+typedef struct PgfItem PgfItem;
+
+enum {
+	PGF_FID_SYNTHETIC = -999
+};
+
+typedef GuBuf PgfItemBuf;
+typedef GuList(PgfItemBuf*) PgfItemBufs;
+
+
+
+// GuString -> PgfItemBuf*			 
+typedef GuMap PgfTransitions;			 
+
+typedef GuBuf PgfCCatBuf;
+
+struct PgfParser {
+	PgfConcr* concr;
+};
+
+struct PgfParse {
+	PgfParser* parser;
+	PgfTransitions* transitions;
+	PgfCCatBuf* completed;
+};
+
+typedef struct PgfParseResult PgfParseResult;
+
+struct PgfParseResult {
+	PgfCCatBuf* completed;
+	GuChoice* choice;
+	PgfExprEnum en;
+};
+
+typedef struct PgfItemBase PgfItemBase;
+
+struct PgfItemBase {
+	PgfItemBuf* conts;
+	PgfCCat* ccat;
+	PgfProduction prod;
+	unsigned short lin_idx;
+};
+
+struct PgfItem {
+	PgfItemBase* base;
+	PgfPArgs args;
+	PgfSymbol curr_sym;
+	uint16_t seq_idx;
+	uint8_t tok_idx;
+	uint8_t alt;
+};
+
+typedef GuMap PgfContsMap;
+
+
+static GU_DEFINE_TYPE(PgfItemBuf, abstract, _);
+static GU_DEFINE_TYPE(PgfItemBufs, abstract, _);
+static GU_DEFINE_TYPE(PgfContsMap, GuMap,
+		      gu_type(PgfCCat), NULL,
+		      gu_ptr_type(PgfItemBufs), &gu_null_struct);
+
+static GU_DEFINE_TYPE(PgfGenCatMap, GuMap,
+		      gu_type(PgfItemBuf), NULL,
+		      gu_ptr_type(PgfCCat), &gu_null_struct);
+
+static GU_DEFINE_TYPE(PgfTransitions, GuStringMap,
+		      gu_ptr_type(PgfItemBuf), &gu_null_struct);
+
+typedef GuMap PgfGenCatMap;
+
+typedef struct PgfParsing PgfParsing;
+
+struct PgfParsing {
+	PgfParse* parse;
+	GuPool* pool;
+	PgfContsMap* conts_map;
+	PgfGenCatMap* generated_cats;
+};
+
+static void
+pgf_parsing_add_transition(PgfParsing* parsing, PgfToken tok, PgfItem* item)
+{
+	gu_debug("%s -> %p", tok, item);
+	PgfTransitions* tmap = parsing->parse->transitions;
+	PgfItemBuf* items = gu_map_get(tmap, &tok, PgfItemBuf*);
+	if (!items) {
+		items = gu_new_buf(PgfItem*, parsing->pool);
+		gu_map_put(tmap, &tok, PgfItemBuf*, items);
+	}
+	gu_buf_push(items, PgfItem*, item);
+}
+
+static PgfItemBufs*
+pgf_parsing_get_contss(PgfParsing* parsing, PgfCCat* cat)
+{
+	PgfItemBufs* contss = gu_map_get(parsing->conts_map, cat, PgfItemBufs*);
+	if (!contss) {
+		size_t n_lins = cat->cnccat->n_lins;
+		contss = gu_new_list(PgfItemBufs, parsing->pool, n_lins);
+		for (size_t i = 0; i < n_lins; i++) {
+			gu_list_index(contss, i) = NULL;
+		}
+		gu_map_put(parsing->conts_map, cat, PgfItemBufs*, contss);
+	}
+	return contss;
+}
+
+
+static PgfItemBuf*
+pgf_parsing_get_conts(PgfParsing* parsing, PgfCCat* cat, size_t lin_idx)
+{
+	gu_require(lin_idx < cat->cnccat->n_lins);
+	PgfItemBufs* contss = pgf_parsing_get_contss(parsing, cat);
+	PgfItemBuf* conts = gu_list_index(contss, lin_idx);
+	if (!conts) {
+		conts = gu_new_buf(PgfItem*, parsing->pool);
+		gu_list_index(contss, lin_idx) = conts;
+	}
+	return conts;
+}
+
+static PgfCCat*
+pgf_parsing_create_completed(PgfParsing* parsing, PgfItemBuf* conts, 
+			     PgfCncCat* cnccat)
+{
+	PgfCCat* cat = gu_new(PgfCCat, parsing->pool);
+	cat->cnccat = cnccat;
+	cat->fid = PGF_FID_SYNTHETIC;
+	cat->prods = gu_buf_seq(gu_new_buf(PgfProduction, parsing->pool));
+	gu_map_put(parsing->generated_cats, conts, PgfCCat*, cat);
+	return cat;
+}
+
+static PgfCCat*
+pgf_parsing_get_completed(PgfParsing* parsing, PgfItemBuf* conts)
+{
+	return gu_map_get(parsing->generated_cats, conts, PgfCCat*);
+}
+
+static PgfSymbol
+pgf_item_base_symbol(PgfItemBase* ibase, size_t seq_idx, GuPool* pool)
+{
+	GuVariantInfo i = gu_variant_open(ibase->prod);
+	switch (i.tag) {
+	case PGF_PRODUCTION_APPLY: {
+		PgfProductionApply* papp = i.data;
+		PgfCncFun* fun = papp->fun;
+		gu_assert(ibase->lin_idx < fun->n_lins);
+		PgfSequence seq = fun->lins[ibase->lin_idx];
+		gu_assert(seq_idx <= gu_seq_length(seq));
+		if (seq_idx == gu_seq_length(seq)) {
+			return gu_null_variant;
+		} else {
+			return gu_seq_get(seq, PgfSymbol, seq_idx);
+		}
+		break;
+	}
+	case PGF_PRODUCTION_COERCE: {
+		gu_assert(seq_idx <= 1);
+		if (seq_idx == 1) {
+			return gu_null_variant;
+		} else {
+			return gu_new_variant_i(pool, PGF_SYMBOL_CAT,
+						PgfSymbolCat,
+						.d = 0, .r = ibase->lin_idx);
+		}
+		break;
+	}
+	default:
+		gu_impossible();
+	}
+	return gu_null_variant;
+}
+
+static PgfItem*
+pgf_new_item(PgfItemBase* base, GuPool* pool)
+{
+	PgfItem* item = gu_new(PgfItem, pool);
+	GuVariantInfo pi = gu_variant_open(base->prod);
+	switch (pi.tag) {
+	case PGF_PRODUCTION_APPLY: {
+		PgfProductionApply* papp = pi.data;
+		item->args = papp->args;
+		break;
+	}
+	case PGF_PRODUCTION_COERCE: {
+		PgfProductionCoerce* pcoerce = pi.data;
+		item->args = gu_new_seq(PgfPArg, 1, pool);
+		PgfPArg* parg = gu_seq_index(item->args, PgfPArg, 0);
+		parg->hypos = NULL;
+		parg->ccat = pcoerce->coerce;
+		break;
+	}
+	default:
+		gu_impossible();
+	}
+	item->base = base;
+	item->curr_sym = pgf_item_base_symbol(item->base, 0, pool);
+	item->seq_idx = 0;
+	item->tok_idx = 0;
+	item->alt = 0;
+	return item;
+}
+
+static PgfItem*
+pgf_item_copy(PgfItem* item, GuPool* pool)
+{
+	PgfItem* copy = gu_new(PgfItem, pool);
+	memcpy(copy, item, sizeof(PgfItem));
+	return copy;
+}
+
+static void
+pgf_item_advance(PgfItem* item, GuPool* pool)
+{
+	item->seq_idx++;
+	item->curr_sym = pgf_item_base_symbol(item->base, item->seq_idx, pool);
+}
+
+static void
+pgf_parsing_item(PgfParsing* parsing, PgfItem* item);
+
+static void
+pgf_parsing_combine(PgfParsing* parsing, PgfItem* cont, PgfCCat* cat)
+{
+	if (cont == NULL) {
+		gu_buf_push(parsing->parse->completed, PgfCCat*, cat);
+		return;
+	}
+	PgfItem* item = pgf_item_copy(cont, parsing->pool);
+	size_t nargs = gu_seq_length(cont->args);
+	item->args = gu_new_seq(PgfPArg, nargs, parsing->pool);
+	memcpy(gu_seq_data(item->args), gu_seq_data(cont->args),
+	       nargs * sizeof(PgfPArg));
+	gu_assert(gu_variant_tag(item->curr_sym) == PGF_SYMBOL_CAT);
+	PgfSymbolCat* pcat = gu_variant_data(cont->curr_sym);
+	gu_seq_set(item->args, PgfPArg, pcat->d,
+		   ((PgfPArg) { .hypos = NULL, .ccat = cat }));
+	pgf_item_advance(item, parsing->pool);
+	pgf_parsing_item(parsing, item);
+}
+
+static void
+pgf_parsing_production(PgfParsing* parsing, PgfCCat* cat, size_t lin_idx,
+		       PgfProduction prod, PgfItemBuf* conts)
+{
+	PgfItemBase* base = gu_new(PgfItemBase, parsing->pool);
+	base->ccat = cat;
+	base->lin_idx = lin_idx;
+	base->prod = prod;
+	base->conts = conts;
+	PgfItem* item = pgf_new_item(base, parsing->pool);
+	pgf_parsing_item(parsing, item);
+}
+
+static void
+pgf_parsing_complete(PgfParsing* parsing, PgfItem* item)
+{
+	GuVariantInfo i = gu_variant_open(item->base->prod);
+	PgfProduction prod = gu_null_variant;
+	switch (i.tag) {
+	case PGF_PRODUCTION_APPLY: {
+		PgfProductionApply* papp = i.data;
+		PgfProductionApply* new_papp = 
+			gu_new_variant(PGF_PRODUCTION_APPLY,
+				       PgfProductionApply,
+				       &prod, parsing->pool);
+		new_papp->fun = papp->fun;
+		new_papp->args = item->args;
+		break;
+	}
+	case PGF_PRODUCTION_COERCE: {
+		PgfProductionCoerce* new_pcoerce =
+			gu_new_variant(PGF_PRODUCTION_COERCE,
+				       PgfProductionCoerce,
+				       &prod, parsing->pool);
+		PgfPArg* parg = gu_seq_index(item->args, PgfPArg, 0);
+		gu_assert(!parg->hypos || !parg->hypos->len);
+		new_pcoerce->coerce = parg->ccat;
+		break;
+	}
+	default:
+		gu_impossible();
+	}
+	PgfItemBuf* conts = item->base->conts;
+	PgfCCat* cat = pgf_parsing_get_completed(parsing, conts);
+	if (cat != NULL) {
+		// The category has already been created. If it has also been
+		// predicted already, then process a new item for this production.
+		PgfItemBufs* contss = pgf_parsing_get_contss(parsing, cat);
+		size_t n_contss = gu_list_length(contss);
+		for (size_t i = 0; i < n_contss; i++) {
+			PgfItemBuf* conts2 = gu_list_index(contss, i);
+			/* If there are continuations for
+			 * linearization index i, then (cat, i) has
+			 * already been predicted. Add the new
+			 * production immediately to the agenda,
+			 * i.e. process it. */
+			if (conts2) {
+				pgf_parsing_production(parsing, cat, i,
+						       prod, conts2);
+			}
+		}
+	} else {
+		cat = pgf_parsing_create_completed(parsing, conts,
+						   item->base->ccat->cnccat);
+		size_t n_conts = gu_buf_length(conts);
+		for (size_t i = 0; i < n_conts; i++) {
+			PgfItem* cont = gu_buf_get(conts, PgfItem*, i);
+			pgf_parsing_combine(parsing, cont, cat);
+		}
+	}
+	GuBuf* prodbuf = gu_seq_buf(cat->prods);
+	gu_buf_push(prodbuf, PgfProduction, prod);
+}
+
+
+static void
+pgf_parsing_predict(PgfParsing* parsing, PgfItem* item, 
+		    PgfCCat* cat, size_t lin_idx)
+{
+	gu_enter("-> cat: %d", cat->fid);
+	if (gu_seq_is_null(cat->prods)) {
+		// Empty category
+		return;
+	}
+	PgfItemBuf* conts = pgf_parsing_get_conts(parsing, cat, lin_idx);
+	gu_buf_push(conts, PgfItem*, item);
+	if (gu_buf_length(conts) == 1) {
+		/* First time we encounter this linearization
+		 * of this category at the current position,
+		 * so predict it. */
+		PgfProductionSeq prods = cat->prods;
+		size_t n_prods = gu_seq_length(prods);
+		for (size_t i = 0; i < n_prods; i++) {
+			PgfProduction prod =
+				gu_seq_get(prods, PgfProduction, i);
+			pgf_parsing_production(parsing, cat, lin_idx, 
+					       prod, conts);
+		}
+	} else {
+		/* If it has already been completed, combine. */
+		PgfCCat* completed = 
+			pgf_parsing_get_completed(parsing, conts);
+		if (completed) {
+			pgf_parsing_combine(parsing, item, completed);
+		}
+	}
+	gu_exit(NULL);
+}
+
+static void
+pgf_parsing_symbol(PgfParsing* parsing, PgfItem* item, PgfSymbol sym) {
+	switch (gu_variant_tag(sym)) {
+	case PGF_SYMBOL_CAT: {
+		PgfSymbolCat* scat = gu_variant_data(sym);
+		PgfPArg* parg = gu_seq_index(item->args, PgfPArg, scat->d);
+		gu_assert(!parg->hypos || !parg->hypos->len);
+		pgf_parsing_predict(parsing, item, parg->ccat, scat->r);
+		break;
+	}
+	case PGF_SYMBOL_KS: {
+		PgfSymbolKS* sks = gu_variant_data(sym);
+		gu_assert(item->tok_idx < gu_seq_length(sks->tokens));
+		PgfToken tok = 
+			gu_seq_get(sks->tokens, PgfToken, item->tok_idx);
+		pgf_parsing_add_transition(parsing, tok, item);
+		break;
+	}
+	case PGF_SYMBOL_KP: {
+		PgfSymbolKP* skp = gu_variant_data(sym);
+		size_t idx = item->tok_idx;
+		uint8_t alt = item->alt;
+		gu_assert(idx < gu_seq_length(skp->default_form));
+		if (idx == 0) {
+			PgfToken tok = gu_seq_get(skp->default_form, PgfToken, 0);
+			pgf_parsing_add_transition(parsing, tok, item);
+			for (size_t i = 0; i < skp->n_forms; i++) {
+				PgfTokens toks = skp->forms[i].form;
+				PgfTokens toks2 = skp->default_form;
+				// XXX: do nubbing properly
+				bool skip = pgf_tokens_equal(toks, toks2);
+				for (size_t j = 0; j < i; j++) {
+					PgfTokens toks2 = skp->forms[j].form;
+					skip |= pgf_tokens_equal(toks, toks2);
+				}
+				if (skip) {
+					continue;
+				}
+				PgfToken tok = gu_seq_get(toks, PgfToken, 0);
+				pgf_parsing_add_transition(parsing, tok, item);
+			}
+		} else if (alt == 0) {
+			PgfToken tok = 
+				gu_seq_get(skp->default_form, PgfToken, idx);
+			pgf_parsing_add_transition(parsing, tok, item);
+		} else {
+			gu_assert(alt <= skp->n_forms);
+			PgfToken tok = gu_seq_get(skp->forms[alt - 1].form, 
+						  PgfToken, idx);
+			pgf_parsing_add_transition(parsing, tok, item);
+		}
+		break;
+	}
+	case PGF_SYMBOL_LIT:
+		// XXX TODO proper support
+		break;
+	case PGF_SYMBOL_VAR:
+		// XXX TODO proper support
+		break;
+	default:
+		gu_impossible();
+	}
+}
+
+static void
+pgf_parsing_item(PgfParsing* parsing, PgfItem* item)
+{
+	GuVariantInfo i = gu_variant_open(item->base->prod);
+	switch (i.tag) {
+	case PGF_PRODUCTION_APPLY: {
+		PgfProductionApply* papp = i.data;
+		PgfCncFun* fun = papp->fun;
+		PgfSequence seq = fun->lins[item->base->lin_idx];
+		if (item->seq_idx == gu_seq_length(seq)) {
+			pgf_parsing_complete(parsing, item);
+		} else  {
+			PgfSymbol sym = 
+				gu_seq_get(seq, PgfSymbol, item->seq_idx);
+			pgf_parsing_symbol(parsing, item, sym);
+		}
+		break;
+	}
+	case PGF_PRODUCTION_COERCE: {
+		PgfProductionCoerce* pcoerce = i.data;
+		switch (item->seq_idx) {
+		case 0:
+			pgf_parsing_predict(parsing, item, 
+					    pcoerce->coerce,
+					    item->base->lin_idx);
+			break;
+		case 1:
+			pgf_parsing_complete(parsing, item);
+			break;
+		default:
+			gu_impossible();
+		}
+		break;
+	}
+	default:
+		gu_impossible();
+	}
+}
+
+static bool
+pgf_parsing_scan_toks(PgfParsing* parsing, PgfItem* old_item, 
+		      PgfToken tok, int alt, PgfTokens toks)
+{
+	gu_assert(old_item->tok_idx < gu_seq_length(toks));
+	if (!gu_string_eq(gu_seq_get(toks, PgfToken, old_item->tok_idx), 
+			  tok)) {
+		return false;
+	}
+	PgfItem* item = pgf_item_copy(old_item, parsing->pool);
+	item->tok_idx++;
+	item->alt = alt;
+	if (item->tok_idx == gu_seq_length(toks)) {
+		item->tok_idx = 0;
+		pgf_item_advance(item, parsing->pool);
+	}
+	pgf_parsing_item(parsing, item);
+	return true;
+}
+
+static void
+pgf_parsing_scan(PgfParsing* parsing, PgfItem* item, PgfToken tok)
+{
+	bool succ = false;
+	GuVariantInfo i = gu_variant_open(item->curr_sym);
+	switch (i.tag) {
+	case PGF_SYMBOL_KS: {
+		PgfSymbolKS* ks = i.data;
+		succ = pgf_parsing_scan_toks(parsing, item, tok, 0, 
+					     ks->tokens);
+		break;
+	}
+	case PGF_SYMBOL_KP: {
+		PgfSymbolKP* kp = i.data;
+		size_t alt = item->alt;
+		if (item->tok_idx == 0) {
+			succ = pgf_parsing_scan_toks(parsing, item, tok, 0, 
+						      kp->default_form);
+			for (size_t i = 0; i < kp->n_forms; i++) {
+				// XXX: do nubbing properly
+				PgfTokens toks = kp->forms[i].form;
+				PgfTokens toks2 = kp->default_form;
+				bool skip = pgf_tokens_equal(toks, toks2);
+				for (size_t j = 0; j < i; j++) {
+					PgfTokens toks2 = kp->forms[j].form;
+					skip |= pgf_tokens_equal(toks, toks2);
+				}
+				if (!skip) {
+					succ |= pgf_parsing_scan_toks(
+						parsing, item, tok, i + 1,
+						kp->forms[i].form);
+				}
+			}
+		} else if (alt == 0) {
+			succ = pgf_parsing_scan_toks(parsing, item, tok, 0, 
+						      kp->default_form);
+		} else {
+			gu_assert(alt <= kp->n_forms);
+			succ = pgf_parsing_scan_toks(parsing, item, tok, 
+						     alt, kp->forms[alt - 1].form);
+		}
+		break;
+	}
+	default:
+		gu_impossible();
+	}
+	gu_assert(succ);
+}
+
+
+static PgfParsing*
+pgf_new_parsing(PgfParse* parse, GuPool* parse_pool, GuPool* out_pool)
+{
+	PgfParsing* parsing = gu_new(PgfParsing, out_pool);
+	parsing->parse = parse;
+	parsing->generated_cats = gu_map_type_new(PgfGenCatMap, out_pool);
+	parsing->conts_map = gu_map_type_new(PgfContsMap, out_pool);
+	parsing->pool = parse_pool;
+	return parsing;
+}
+
+static PgfParse*
+pgf_new_parse(PgfParser* parser, GuPool* pool)
+{
+	PgfParse* parse = gu_new(PgfParse, pool);
+	parse->parser = parser;
+	parse->transitions = gu_map_type_new(PgfTransitions, pool);
+	parse->completed = gu_new_buf(PgfCCat*, pool);
+	return parse;
+}
+
+PgfParse*
+pgf_parse_token(PgfParse* parse, PgfToken tok, GuPool* pool)
+{
+	PgfItemBuf* agenda =
+		gu_map_get(parse->transitions, &tok, PgfItemBuf*);
+	if (!agenda) {
+		return NULL;
+	}
+	PgfParse* next_parse = pgf_new_parse(parse->parser, pool);
+	GuPool* tmp_pool = gu_new_pool();
+	PgfParsing* parsing = pgf_new_parsing(next_parse, pool, tmp_pool);
+	size_t n_items = gu_buf_length(agenda);
+	for (size_t i = 0; i < n_items; i++) {
+		PgfItem* item = gu_buf_get(agenda, PgfItem*, i);
+		pgf_parsing_scan(parsing, item, tok);
+	}
+	gu_pool_free(tmp_pool);
+	return next_parse;
+}
+
+static PgfExpr
+pgf_cat_to_expr(PgfCCat* cat, GuChoice* choice, GuPool* pool);
+
+static PgfExpr
+pgf_production_to_expr(PgfProduction prod, GuChoice* choice, GuPool* pool)
+{
+	GuVariantInfo pi = gu_variant_open(prod);
+	switch (pi.tag) {
+	case PGF_PRODUCTION_APPLY: {
+		PgfProductionApply* papp = pi.data;
+		PgfExpr expr = gu_new_variant_i(pool, PGF_EXPR_FUN,
+						PgfExprFun,
+						.fun = papp->fun->fun);
+		size_t n_args = gu_seq_length(papp->args);
+		for (size_t i = 0; i < n_args; i++) {
+			PgfPArg* parg = gu_seq_index(papp->args, PgfPArg, i);
+			gu_assert(!parg->hypos || !parg->hypos->len);
+			PgfExpr earg = pgf_cat_to_expr(parg->ccat, choice, pool);
+			expr = gu_new_variant_i(pool, PGF_EXPR_APP,
+						PgfExprApp,
+						.fun = expr, .arg = earg);
+		}
+		return expr;
+	}
+	case PGF_PRODUCTION_COERCE: {
+		PgfProductionCoerce* pcoerce = pi.data;
+		return pgf_cat_to_expr(pcoerce->coerce, choice, pool);
+	}
+	default:
+		gu_impossible();
+	}
+	return gu_null_variant;
+}
+
+
+static PgfExpr
+pgf_cat_to_expr(PgfCCat* cat, GuChoice* choice, GuPool* pool)
+{
+	if (cat->fid != PGF_FID_SYNTHETIC) {
+		// XXX: What should the PgfMetaId be?
+		return gu_new_variant_i(pool, PGF_EXPR_META,
+					PgfExprMeta, 
+					.id = 0);
+	}
+	size_t n_prods = gu_seq_length(cat->prods);
+	int i = gu_choice_next(choice, n_prods);
+	if (i == -1) {
+		return gu_null_variant;
+	}
+	PgfProduction prod = gu_seq_get(cat->prods, PgfProduction, i);
+	return pgf_production_to_expr(prod, choice, pool);
+}
+
+
+static PgfExpr
+pgf_parse_result_next(PgfParseResult* pr, GuPool* pool)
+{
+	if (pr->choice == NULL) {
+		return gu_null_variant;
+	}
+	size_t n_results = gu_buf_length(pr->completed);
+ 	GuChoiceMark mark = gu_choice_mark(pr->choice);
+	int i = gu_choice_next(pr->choice, n_results);
+	if (i == -1) {
+		return gu_null_variant;
+	}
+	PgfCCat* cat = gu_buf_get(pr->completed, PgfCCat*, i);
+	PgfExpr ret = pgf_cat_to_expr(cat, pr->choice, pool);
+	gu_choice_reset(pr->choice, mark);
+	if (!gu_choice_advance(pr->choice)) {
+		pr->choice = NULL;
+	};
+	return ret;
+}
+
+static void
+pgf_parse_result_enum_next(GuEnum* self, void* to, GuPool* pool)
+{
+	PgfParseResult* pr = gu_container(self, PgfParseResult, en);
+	*(PgfExpr*)to = pgf_parse_result_next(pr, pool);
+}
+
+PgfExprEnum*
+pgf_parse_result(PgfParse* parse, GuPool* pool)
+{
+	return &gu_new_i(pool, PgfParseResult,
+			 .completed = parse->completed,
+			 .choice = gu_new_choice(pool),
+			 .en.next = pgf_parse_result_enum_next)->en;
+}
+
+
+
+// TODO: s/CId/Cat, add the cid to Cat, make Cat the key to CncCat
+PgfParse*
+pgf_parser_parse(PgfParser* parser, PgfCId cat, size_t lin_idx, GuPool* pool)
+{
+	PgfParse* parse = pgf_new_parse(parser, pool);
+	GuPool* tmp_pool = gu_new_pool();
+	PgfParsing* parsing = pgf_new_parsing(parse, pool, tmp_pool);
+	PgfCncCat* cnccat =
+		gu_map_get(parser->concr->cnccats, &cat, PgfCncCat*);
+	if (!cnccat) {
+		// error ...
+		gu_impossible();
+	}
+	gu_assert(lin_idx < cnccat->n_lins);
+	size_t n_ccats = gu_list_length(cnccat->cats);
+	for (size_t i = 0; i < n_ccats; i++) {
+		PgfCCat* ccat = gu_list_index(cnccat->cats, i);
+		if (ccat != NULL) {
+			pgf_parsing_predict(parsing, NULL, ccat, lin_idx);
+		}
+	}
+	gu_pool_free(tmp_pool);
+	return parse;
+}
+
+PgfParser* 
+pgf_new_parser(PgfConcr* concr, GuPool* pool)
+{
+	gu_require(concr != NULL);
+	PgfParser* parser = gu_new(PgfParser, pool);
+	parser->concr = concr;
+	return parser;
+}
diff --git a/src/runtime/c/pgf/parser.h b/src/runtime/c/pgf/parser.h
new file mode 100644
index 000000000..127bed5dc
--- /dev/null
+++ b/src/runtime/c/pgf/parser.h
@@ -0,0 +1,127 @@
+#ifndef PGF_PARSER_H_
+#define PGF_PARSER_H_
+
+#include <gu/enum.h>
+#include <pgf/data.h>
+#include <pgf/expr.h>
+
+/// Parsing
+/** @file
+ *
+ *  @todo Querying the parser for expected continuations
+ *
+ *  @todo Literals and custom categories
+ *  
+ *  @todo HOAS, dependent types...
+ */
+
+typedef struct PgfParse PgfParse;
+
+/** @name Creating a new parser
+ *
+ * A #PgfParser object can parse sentences of a single concrete category into
+ * abstract syntax trees (#PgfExpr). The parser is created with
+ * #pgf_new_parser.
+ *
+ * @{ 
+ */
+
+/// A parser for a single concrete category
+typedef struct PgfParser PgfParser;
+    
+
+/// Create a new parser
+PgfParser*
+pgf_new_parser(PgfConcr* concr, GuPool* pool);
+/**<
+ * @param concr The concrete category whose sentences are to be parsed
+ *
+ * @pool
+ *
+ * @return A newly created parser for the concrete category \p concr
+ */ 
+
+/** @}
+ * 
+ * @name Parsing a sentence
+ *
+ * The progress of parsing is controlled by the client code. Firstly, the
+ * parsing of a sentence is initiated with #pgf_parser_parse. This returns an
+ * initial #PgfParse object, which represents the state of the parsing. A new
+ * parse state is obtained by feeding a token with #pgf_parse_token. The old
+ * parse state is unaffected by this, so backtracking - and even branching -
+ * can be accomplished by retaining the earlier #PgfParse objects.
+ *
+ * @{
+ */
+
+/// Begin parsing
+PgfParse*
+pgf_parser_parse(PgfParser* parser, PgfCId cat, size_t lin_idx, GuPool* pool);
+/**<
+ * @param parser The parser to use
+ *
+ * @param cat The identifier of the abstract category to parse
+ *
+ * @param lin_idx The index of the field of the concrete category to parse
+ *
+ * @pool
+ *
+ * @return An initial parsing state.
+*/
+
+
+/// Feed a token to the parser
+PgfParse*
+pgf_parse_token(PgfParse* parse, PgfToken tok, GuPool* pool);
+/**<
+ * @param parse The current parse state
+ *
+ * @param tok The token to feed
+ *
+ * @pool
+ *
+ * @return A new parse state obtained by feeding \p tok as an input to \p
+ * parse, or \c NULL if the token was unexpected.
+ *
+ * @note The new parse state partially depends on the old one, so it doesn't
+ * make sense to use a \p pool argument with a longer lifetime than that of
+ * the pool used to create \parse.
+ */
+
+
+/** @}
+ * @name Retrieving abstract syntax trees
+ *
+ * After the desired tokens have been fed to the parser, the resulting parse
+ * state can be queried for completed results. The #pgf_parse_result function
+ * returns an enumeration (#GuEnum) of possible abstract syntax trees whose
+ * linearization is the sequence of tokens fed so far.
+ *
+ * @{
+ */
+
+
+/// An enumeration of #PgfExpr elements.
+typedef GuEnum PgfExprEnum;
+
+
+/// Retrieve the current parses from the parse state.
+PgfExprEnum*
+pgf_parse_result(PgfParse* parse, GuPool* pool);
+/**<
+ * @param parse A parse state
+ *
+ * @pool
+ * 
+ * @return An enumeration of #PgfExpr elements representing the abstract
+ * syntax trees that would linearize to the sequence of tokens fed to produce
+ * \p parse. The enumeration may yield zero, one or more abstract syntax
+ * trees, depending on whether the parse was unsuccesful, unambiguously
+ * succesful, or ambiguously successful.
+ */
+
+
+/** @} */
+
+#endif // PGF_PARSER_H_
diff --git a/src/runtime/c/pgf/pgf.h b/src/runtime/c/pgf/pgf.h
new file mode 100644
index 000000000..8ee26aadd
--- /dev/null
+++ b/src/runtime/c/pgf/pgf.h
@@ -0,0 +1,78 @@
+/* 
+ * 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/>.
+ */
+
+/** @file
+ *
+ * The public libpgf API.
+ */
+
+#ifndef PGF_H_
+#define PGF_H_
+
+#include <gu/exn.h>
+#include <gu/mem.h>
+#include <gu/in.h>
+#include <gu/string.h>
+
+
+typedef GuString PgfCId;
+extern GU_DECLARE_TYPE(PgfCId, typedef);
+
+
+/// A single lexical token			      
+typedef GuString PgfToken;			      
+
+/// @name PGF Grammar objects
+/// @{
+
+typedef struct PgfPGF PgfPGF;
+
+/**< A representation of a PGF grammar. 
+ */
+
+
+PgfPGF*
+pgf_read(GuIn* in, GuPool* pool, GuExn* err); 
+
+/**< Read a grammar from a PGF file.
+ *
+ * @param from  PGF input stream.
+ * The stream must be positioned in the beginning of a binary
+ * PGF representation. After a succesful invocation, the stream is
+ * still open and positioned at the end of the representation.
+ *
+ * @param[out] err_out  Raised error.
+ * If non-\c NULL, \c *err_out should be \c NULL. Then, upon
+ * failure, \c *err_out is set to point to a newly allocated
+ * error object, which the caller must free with #g_exn_free
+ * or #g_exn_propagate.
+ *
+ * @return A new PGF object, or \c NULL upon failure. The returned
+ * object must later be freed with #pgf_free.
+ *
+ */
+
+
+#include <gu/type.h>
+GU_DECLARE_TYPE(PgfPGF, struct);
+
+/// @}
+
+
+#endif // PGF_H_
diff --git a/src/runtime/c/pgf/reader.c b/src/runtime/c/pgf/reader.c
new file mode 100644
index 000000000..6aa07e6b7
--- /dev/null
+++ b/src/runtime/c/pgf/reader.c
@@ -0,0 +1,843 @@
+/* 
+ * 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/>.
+ */
+
+#include "data.h"
+#include "expr.h"
+#include <gu/defs.h>
+#include <gu/map.h>
+#include <gu/seq.h>
+#include <gu/assert.h>
+#include <gu/intern.h>
+#include <gu/in.h>
+#include <gu/bits.h>
+#include <gu/exn.h>
+#include <gu/utf8.h>
+
+#define GU_LOG_ENABLE
+#include <gu/log.h>
+
+typedef struct PgfIdContext PgfIdContext;
+
+//
+// PgfReader
+// 
+
+typedef struct PgfReader PgfReader;
+
+struct PgfReader {
+	GuIn* in;
+	GuExn* err;
+	GuPool* opool;
+	GuPool* pool;
+	GuSymTable* symtab;
+	PgfSequences* curr_sequences;
+	PgfCncFuns* curr_cncfuns;
+	GuMap* curr_ccats;
+	GuMap* ccat_locs;
+	GuMap* curr_lindefs;
+	GuMap* curr_coercions;
+	GuTypeMap* read_to_map;
+	GuTypeMap* read_new_map;
+	void* curr_key;
+	GuPool* curr_pool;
+};
+
+typedef struct PgfReadTagExn PgfReadTagExn;
+
+struct PgfReadTagExn {
+	GuType* type;
+	int tag;
+};
+
+static GU_DEFINE_TYPE(PgfReadTagExn, abstract, _);
+
+static GU_DEFINE_TYPE(PgfReadExn, abstract, _);
+
+static uint8_t
+pgf_read_u8(PgfReader* rdr)
+{
+	uint8_t u = gu_in_u8(rdr->in, rdr->err);
+	gu_debug("u8: %u", u);
+	return u;
+}
+
+static uint32_t
+pgf_read_uint(PgfReader* rdr)
+{
+	uint32_t u = 0;
+	int shift = 0;
+	uint8_t b = 0;
+	do {
+		b = pgf_read_u8(rdr);
+		gu_return_on_exn(rdr->err, 0);
+		u |= (b & ~0x80) << shift;
+		shift += 7;
+	} while (b & 0x80);
+	gu_debug("uint: %u", u);
+	return u;
+}
+
+static int32_t
+pgf_read_int(PgfReader* rdr)
+{
+	uint32_t u = pgf_read_uint(rdr);
+	return gu_decode_2c32(u, rdr->err);
+}
+
+static GuLength
+pgf_read_len(PgfReader* rdr)
+{
+	int32_t len = pgf_read_int(rdr);
+	// It's crucial that we return 0 on failure, so the
+	// caller can proceed without checking for error
+	// immediately.
+	gu_return_on_exn(rdr->err, 0);
+	if (len < 0) {
+		gu_raise_i(rdr->err, PgfReadTagExn,
+			   .type = gu_type(GuLength), .tag = len);
+		return 0;
+	}
+	return (GuLength) len;
+}
+
+typedef const struct PgfReadToFn PgfReadToFn;
+
+struct PgfReadToFn {
+	void (*fn)(GuType* type, PgfReader* rdr, void* to);
+};
+
+static void 
+pgf_read_to(PgfReader* rdr, GuType* type, void* to) {
+	PgfReadToFn* fn = gu_type_map_get(rdr->read_to_map, type);
+	fn->fn(type, rdr, to);
+}
+
+typedef const struct PgfReadNewFn PgfReadNewFn;
+struct PgfReadNewFn {
+	void* (*fn)(GuType* type, PgfReader* rdr, GuPool* pool, 
+		    size_t* size_out);
+};
+
+static void*
+pgf_read_new(PgfReader* rdr, GuType* type, GuPool* pool, size_t* size_out)
+{
+	size_t size = 0;
+	PgfReadNewFn* fn = gu_type_map_get(rdr->read_new_map, type);
+	return fn->fn(type, rdr, pool, size_out ? size_out : &size);
+}
+
+static void*
+pgf_read_new_type(GuType* type, PgfReader* rdr, GuPool* pool, 
+		  size_t* size_out)
+{
+	GuTypeRepr* repr = gu_type_repr(type);
+	void* to = gu_malloc_aligned(pool, repr->size, repr->align);
+	pgf_read_to(rdr, type, to);
+	*size_out = repr->size;
+	return to;
+}
+
+static void*
+pgf_read_struct(GuStructRepr* stype, PgfReader* rdr, void* to, 
+		GuPool* pool, size_t* size_out)
+{
+	GuTypeRepr* repr = gu_type_cast((GuType*)stype, repr);
+	size_t size = repr->size;
+	GuLength length = 0;
+	bool have_length = false;
+	uint8_t* p = NULL;
+	uint8_t* bto = to;
+	gu_enter("-> struct %s", stype->name);
+
+	for (int i = 0; i < stype->members.len; i++) {
+		const GuMember* m = &stype->members.elems[i];
+		gu_enter("-> %s.%s", stype->name, m->name);
+		if (m->is_flex) {
+			gu_assert(have_length && p == NULL && pool != NULL);
+			size_t m_size = gu_type_size(m->type);
+			size = gu_flex_size(size, m->offset,
+					    length, m_size);
+			p = gu_malloc_aligned(pool, size, repr->align);
+			for (size_t j = 0; j < length; j++) {
+				pgf_read_to(rdr, m->type, 
+					    &p[m->offset + j * m_size]);
+				gu_return_on_exn(rdr->err, NULL);
+			}
+		} else {
+			pgf_read_to(rdr, m->type, &bto[m->offset]);
+			gu_return_on_exn(rdr->err, NULL);
+		}
+		if (m->type == gu_type(GuLength)) {
+			gu_assert(!have_length);
+			have_length = true;
+			length = gu_member(GuLength, to, m->offset);
+		}
+		gu_exit("<- %s.%s", stype->name, m->name);
+	}
+	if (p) {
+		memcpy(p, to, repr->size);
+	}
+	if (size_out) {
+		*size_out = size;
+	}
+	gu_exit("<- struct %s", stype->name);
+	return p;
+}
+
+static void
+pgf_read_to_struct(GuType* type, PgfReader* rdr, void* to)
+{
+	GuStructRepr* stype = gu_type_cast(type, struct);
+	pgf_read_struct(stype, rdr, to, NULL, NULL);
+}
+
+static void*
+pgf_read_new_struct(GuType* type, PgfReader* rdr, 
+		    GuPool* pool, size_t* size_out)
+{
+	GuStructRepr* stype = gu_type_cast(type, struct);
+	if (gu_struct_has_flex(stype)) {
+		GuPool* tmp_pool = gu_new_pool();
+		void* to = gu_type_malloc(type, tmp_pool);
+		void* p = pgf_read_struct(stype, rdr, to, pool, size_out);
+		gu_pool_free(tmp_pool);
+		gu_assert(p);
+		return p;
+	} else {
+		void* to = gu_type_malloc(type, pool);
+		pgf_read_struct(stype, rdr, to, NULL, NULL);
+		return to;
+	}
+}
+
+
+static void
+pgf_read_to_pointer(GuType* type, PgfReader* rdr, void* to)
+{
+	GuPointerType* ptype = (GuPointerType*) type;
+	GuType* pointed = ptype->pointed_type;
+	gu_require(gu_type_has_kind(pointed, gu_kind(struct)) ||
+		   gu_type_has_kind(pointed, gu_kind(abstract)));
+	GuStruct** sto = to;
+	*sto = pgf_read_new(rdr, pointed, rdr->opool, NULL);
+}
+
+static void
+pgf_read_to_GuVariant(GuType* type, PgfReader* rdr, void* to)
+{
+	GuVariantType* vtype = (GuVariantType*) type;
+	GuVariant* vto = to;
+
+	uint8_t btag = pgf_read_u8(rdr);
+	gu_return_on_exn(rdr->err,);
+	if (btag >= vtype->ctors.len) {
+		gu_raise_i(rdr->err, PgfReadTagExn, 
+			   .type = type, .tag = btag);
+		return;
+	}
+	GuConstructor* ctor = &vtype->ctors.elems[btag];
+	gu_enter("-> variant %s", ctor->c_name);
+	GuPool* tmp_pool = gu_new_pool();
+	GuTypeRepr* repr = gu_type_repr(ctor->type);
+	size_t size = repr->size;
+	void* init = pgf_read_new(rdr, ctor->type, tmp_pool, &size);
+	*vto = gu_make_variant(btag, size, repr->align, init, rdr->opool);
+	gu_pool_free(tmp_pool);
+	gu_exit("<- variant %s", ctor->c_name);
+}
+
+static void
+pgf_read_to_enum(GuType* type, PgfReader* rdr, void* to)
+{
+	// For now, assume that enum values are encoded in a single octet
+	GuEnumType* etype = (GuEnumType*) type;
+	uint8_t tag = pgf_read_u8(rdr);
+	gu_return_on_exn(rdr->err,);
+	if (tag >= etype->constants.len) {
+		gu_raise_i(rdr->err, PgfReadTagExn, 
+			   .type = type, .tag = tag);
+		return;
+	}
+	GuEnumConstant* econ = &etype->constants.elems[tag];
+	size_t size = gu_type_size(type);
+	if (size == sizeof(int8_t)) {
+		*((int8_t*) to) = econ->value;
+	} else if (size == sizeof(int16_t)) {
+		*((int16_t*) to) = econ->value;
+	} else if (size == sizeof(int32_t)) {
+		*((int32_t*) to) = econ->value;
+	} else if (size == sizeof(int64_t)) {
+		*((int64_t*) to) = econ->value;
+	} else {
+		gu_impossible();
+	}
+}
+
+static void
+pgf_read_to_void(GuType* info, PgfReader* rdr, void* to)
+{
+	(void) (info && rdr && to);
+}
+
+
+static void
+pgf_read_to_int(GuType* type, PgfReader* rdr, void* to) 
+{
+	(void) type;
+	*(int*) to = pgf_read_int(rdr);
+}
+
+static void
+pgf_read_to_uint16_t(GuType* type, PgfReader* rdr, void* to)
+{
+	(void) type;
+	*(uint16_t*) to = gu_in_u16be(rdr->in, rdr->err);
+}
+
+static void
+pgf_read_to_GuLength(GuType* type, PgfReader* rdr, void* to)
+{
+	(void) type;
+	*(GuLength*) to = pgf_read_len(rdr);
+}
+
+static void
+pgf_read_to_double(GuType* type, PgfReader* rdr, void* to)
+{
+	(void) type;
+	*(double*) to = gu_in_f64be(rdr->in, rdr->err);
+}
+
+static void
+pgf_read_to_alias(GuType* type, PgfReader* rdr, void* to)
+{
+	GuTypeAlias* atype = gu_type_cast(type, alias);
+	pgf_read_to(rdr, atype->type, to);
+}
+
+static void
+pgf_read_into_map(GuMapType* mtype, PgfReader* rdr, GuMap* map, GuPool* pool)
+{
+	/* The parameter pool is the temporary pool used to store the
+	   map. But the actual values need to be more persistent so we
+	   store them in rdr->opool. */
+	(void) pool;
+	GuPool* tmp_pool = gu_new_pool();
+	void* key = NULL;
+	GuLength len = pgf_read_len(rdr);
+	gu_return_on_exn(rdr->err, );
+	if (mtype->hasher) {
+		key = gu_type_malloc(mtype->key_type, tmp_pool);
+	}
+	for (size_t i = 0; i < len; i++) {
+		if (mtype->hasher) {
+			pgf_read_to(rdr, mtype->key_type, key);
+		} else {
+			key = pgf_read_new(rdr, mtype->key_type, 
+					   rdr->opool, NULL);
+		}
+		gu_return_on_exn(rdr->err, );
+		rdr->curr_key = key;
+		/* If an old value already exists, read into
+		   it. This allows us to create the value
+		   object and point into it before we read the
+		   content. */
+		void* valp = gu_map_insert(map, key);
+		pgf_read_to(rdr, mtype->value_type, valp);
+		gu_return_on_exn(rdr->err, );
+	}
+	gu_pool_free(tmp_pool);
+}
+
+static void*
+pgf_read_new_GuMap(GuType* type, PgfReader* rdr, GuPool* pool, size_t* size_out)
+{
+	(void) size_out;
+	GuMapType* mtype = (GuMapType*) type;
+	GuMap* map = gu_map_type_make(mtype, pool);
+	pgf_read_into_map(mtype, rdr, map, pool);
+	gu_return_on_exn(rdr->err, NULL);
+	return map;
+}
+
+static void
+pgf_read_to_GuString(GuType* type, PgfReader* rdr, void* to)
+{
+	(void) (type);
+	gu_enter("-> GuString");
+	GuString* sp = to;
+	
+	GuPool* tmp_pool = gu_new_pool();
+	GuStringBuf* sbuf = gu_string_buf(tmp_pool);
+	GuWriter* wtr = gu_string_buf_writer(sbuf);
+
+	GuLength len = pgf_read_len(rdr);
+
+	for (size_t i = 0; i < len; i++) {
+		GuUCS ucs = gu_in_utf8(rdr->in, rdr->err);
+		gu_ucs_write(ucs, wtr, rdr->err);
+	}
+	GuString str = gu_string_buf_freeze(sbuf, tmp_pool);
+	GuSymbol sym = gu_symtable_intern(rdr->symtab, str);
+	gu_pool_free(tmp_pool);
+
+	gu_exit("<- GuString");
+	*sp = sym;
+}
+
+static void
+pgf_read_to_PgfCId(GuType* type, PgfReader* rdr, void* to)
+{
+	(void) (type);
+	gu_enter("-> PgfCId");
+	PgfCId* sp = to;
+	
+	GuPool* tmp_pool = gu_new_pool();
+	GuStringBuf* sbuf = gu_string_buf(tmp_pool);
+	GuWriter* wtr = gu_string_buf_writer(sbuf);
+
+	GuLength len = pgf_read_len(rdr);
+
+	for (size_t i = 0; i < len; i++) {
+		// CIds are in latin-1
+		GuUCS ucs = gu_in_u8(rdr->in, rdr->err);
+		gu_ucs_write(ucs, wtr, rdr->err);
+	}
+	GuString str = gu_string_buf_freeze(sbuf, tmp_pool);
+	GuSymbol sym = gu_symtable_intern(rdr->symtab, str);
+	gu_pool_free(tmp_pool);
+
+	gu_exit("<- PgfCId");
+	*sp = sym;
+}
+
+static void
+pgf_read_to_PgfCCatId(GuType* type, PgfReader* rdr, void* to)
+{
+	(void) (type);
+	PgfCCat** pto = to;
+	int fid = pgf_read_int(rdr);
+	gu_return_on_exn(rdr->err,);
+	PgfCCat* ccat = gu_map_get(rdr->curr_ccats, &fid, PgfCCat*);
+	if (ccat) {
+		*pto = ccat;
+		return;
+	}
+	GuBuf* locs = gu_map_get(rdr->ccat_locs, &fid, GuBuf*);
+	if (!locs) {
+		locs = gu_new_buf(PgfCCat**, rdr->pool);
+		gu_map_put(rdr->ccat_locs, &fid, GuBuf*, locs);
+	}
+	gu_buf_push(locs, PgfCCat**, pto);
+}
+
+static void
+pgf_read_to_PgfCCat(GuType* type, PgfReader* rdr, void* to)
+{
+	(void) type;
+	gu_enter("->");
+	PgfCCat* cat = to;
+	cat->cnccat = NULL;
+	pgf_read_to(rdr, gu_type(PgfProductionSeq), &cat->prods);
+	int* fidp = rdr->curr_key;
+	cat->fid = *fidp;
+	GuBuf* locs_buf = gu_map_get(rdr->ccat_locs, fidp, GuBuf*);
+	if (locs_buf) {
+		size_t len = gu_buf_length(locs_buf);
+		PgfCCat*** locs = gu_buf_data(locs_buf);
+		for (size_t n = 0; n < len; n++) {
+			*(locs[n]) = cat;
+		}
+	}
+	gu_exit("<-");
+}
+
+// This is only needed because new_struct would otherwise override.
+// TODO: get rid of new_struct and all the FAM mess
+static void*
+pgf_read_new_PgfCCat(GuType* type, PgfReader* rdr, GuPool* pool,
+		     size_t* size_out)
+{
+	PgfCCat* ccat = gu_new(PgfCCat, pool);
+	pgf_read_to_PgfCCat(type, rdr, ccat);
+	*size_out = sizeof(PgfCCat);
+	return ccat;
+}
+
+static void*
+pgf_read_new_GuList(GuType* type, PgfReader* rdr, GuPool* pool, size_t* size_out)
+{
+	GuListType* ltype = gu_type_cast(type, GuList);
+	GuLength length = pgf_read_len(rdr);
+	gu_return_on_exn(rdr->err, NULL);
+	void* list = gu_list_type_alloc(ltype, length, pool);
+	for (size_t i = 0; i < length; i++) {
+		void* elem = gu_list_type_index(ltype, list, i);
+		pgf_read_to(rdr, ltype->elem_type, elem);
+		gu_return_on_exn(rdr->err, NULL);
+	}
+	*size_out = gu_flex_size(ltype->size, ltype->elems_offset,
+				 length, 
+				 gu_type_size(ltype->elem_type));
+	return list;
+}
+
+static void
+pgf_read_to_GuSeq(GuType* type, PgfReader* rdr, void* to)
+{
+	gu_enter("->");
+	GuSeqType* stype = gu_type_cast(type, GuSeq);
+	GuLength length = pgf_read_len(rdr);
+	GuTypeRepr* repr = gu_type_repr(stype->elem_type);
+	gu_return_on_exn(rdr->err, );
+	GuSeq seq = gu_make_seq(repr->size, length, rdr->opool);
+	uint8_t* data = gu_seq_data(seq);
+	for (size_t i = 0; i < length; i++) {
+		void* elem = &data[i * repr->size];
+		pgf_read_to(rdr, stype->elem_type, elem);
+		gu_return_on_exn(rdr->err, );
+	}
+	GuSeq* sto = to;
+	*sto = seq;
+	gu_exit("<-");
+}
+
+static void
+pgf_read_to_maybe_seq(GuType* type, PgfReader* rdr, void* to)
+{
+	GuSeq* sto = to;
+	uint8_t tag = pgf_read_u8(rdr);
+	gu_return_on_exn(rdr->err,);
+	switch (tag) {
+	case 0:
+		*sto = gu_null_seq;
+		break;
+	case 1:
+		pgf_read_to_GuSeq(type, rdr, to);
+		break;
+	default:
+		gu_raise_i(rdr->err, PgfReadTagExn,
+			   .type = type, .tag = tag);
+		break;
+	}
+}
+
+
+static void*
+pgf_read_new_idarray(GuType* type, PgfReader* rdr, GuPool* pool,
+		     size_t* size_out)
+{
+	(void) type;
+	void* list = pgf_read_new_GuList(type, rdr, rdr->curr_pool, size_out);
+	if (type == gu_type(PgfSequences)) {
+		rdr->curr_sequences = list;
+	} else if (type == gu_type(PgfCncFuns)) {
+		rdr->curr_cncfuns = list;
+	} else {
+		gu_impossible();
+	}
+	return list;
+}
+
+static void
+pgf_read_to_PgfSeqId(GuType* type, PgfReader* rdr, void* to)
+{
+	(void) type;
+	int32_t id = pgf_read_int(rdr);
+	gu_return_on_exn(rdr->err,);
+	if (id < 0 || id >= gu_list_length(rdr->curr_sequences)) {
+		gu_raise(rdr->err, PgfReadExn);
+		return;
+	}
+	*(PgfSeqId*) to = gu_list_elems(rdr->curr_sequences)[id];
+}
+
+
+static void
+pgf_read_to_PgfFunId(GuType* type, PgfReader* rdr, void* to)
+{
+	(void) type;
+	int32_t id = pgf_read_int(rdr);
+	gu_return_on_exn(rdr->err,);
+	if (id < 0 || id >= gu_list_length(rdr->curr_cncfuns)) {
+		gu_raise(rdr->err, PgfReadExn);
+		return;
+	}
+	*(PgfFunId*) to = gu_list_elems(rdr->curr_cncfuns)[id];
+}
+
+static GU_DEFINE_TYPE(PgfLinDefs, GuIntMap, gu_ptr_type(PgfFunIds),
+		      &gu_null_struct);
+typedef PgfCCat PgfCCatData;
+static GU_DEFINE_TYPE(PgfCCatData, typedef, gu_type(PgfCCat));
+
+static GU_DEFINE_TYPE(PgfCCatMap, GuIntMap, gu_ptr_type(PgfCCat),
+		      &gu_null_struct);
+
+static GU_DEFINE_TYPE(PgfCncCatMap, GuStringMap, gu_ptr_type(PgfCncCat),
+		      &gu_null_struct);
+
+typedef struct {
+	GuMapItor fn;
+	GuBuf* seq;
+} PgfCCatCbCtx;
+
+static PgfCncCat*
+pgf_ccat_set_cnccat(PgfCCat* ccat, GuBuf* newly_set)
+{
+	if (!ccat->cnccat) {
+		size_t n_prods = gu_seq_length(ccat->prods);
+		for (size_t i = 0; i < n_prods; i++) {
+			PgfProduction prod = 
+				gu_seq_get(ccat->prods, PgfProduction, i);
+			GuVariantInfo i = gu_variant_open(prod);
+			switch (i.tag) {
+			case PGF_PRODUCTION_COERCE: {
+				PgfProductionCoerce* pcoerce = i.data;
+				PgfCncCat* cnccat = 
+					pgf_ccat_set_cnccat(pcoerce->coerce,
+							    newly_set);
+				if (!ccat->cnccat) {
+					ccat->cnccat = cnccat;
+				} else if (ccat->cnccat != cnccat) {
+					// XXX: real error
+					gu_impossible();
+				}
+ 				break;
+			}
+			case PGF_PRODUCTION_APPLY:
+				// Shouldn't happen with current PGF.
+				// XXX: real error
+				gu_impossible();
+				break;
+			default:
+				gu_impossible();
+			}
+		}
+		gu_buf_push(newly_set, PgfCCat*, ccat);
+	}
+	return ccat->cnccat;
+}
+
+
+static void
+pgf_read_ccat_cb(GuMapItor* fn, const void* key, void* value, GuExn* err)
+{
+	(void) (key && err);
+	PgfCCatCbCtx* ctx = (PgfCCatCbCtx*) fn;
+	PgfCCat** ccatp = value;
+	pgf_ccat_set_cnccat(*ccatp, ctx->seq);
+}
+
+static void*
+pgf_read_new_PgfConcr(GuType* type, PgfReader* rdr, GuPool* pool,
+		       size_t* size_out)
+{
+	(void) (type && size_out);
+	/* We allocate indices from a temporary pool. The actual data
+	 * is allocated from rdr->opool. Once everything is resolved
+	 * and indices aren't needed, the temporary pool can be
+	 * freed. */
+	GuPool* tmp_pool = gu_new_pool();
+	rdr->curr_pool = tmp_pool;
+	PgfConcr* concr = gu_new(PgfConcr, pool);;
+	concr->cflags = 
+		pgf_read_new(rdr, gu_type(PgfFlags), pool, NULL);
+	concr->printnames = 
+		pgf_read_new(rdr, gu_type(PgfPrintNames), pool, NULL);
+	rdr->curr_sequences = 
+		pgf_read_new(rdr, gu_type(PgfSequences), pool, NULL);
+	rdr->curr_cncfuns =
+		pgf_read_new(rdr, gu_type(PgfCncFuns), pool, NULL);
+	GuMapType* lindefs_t = gu_type_cast(gu_type(PgfLinDefs), GuMap);
+	rdr->curr_lindefs = gu_map_type_make(lindefs_t, tmp_pool);
+	pgf_read_into_map(lindefs_t, rdr, rdr->curr_lindefs, rdr->opool);
+	GuMapType* ccats_t = gu_type_cast(gu_type(PgfCCatMap), GuMap);
+	rdr->curr_ccats =
+		gu_new_int_map(PgfCCat*, &gu_null_struct, tmp_pool);
+	rdr->ccat_locs =
+		gu_new_int_map(GuBuf*, &gu_null_struct, tmp_pool);
+	pgf_read_into_map(ccats_t, rdr, rdr->curr_ccats, rdr->opool);
+	concr->cnccats = pgf_read_new(rdr, gu_type(PgfCncCatMap), 
+				      rdr->opool, NULL);
+
+	GuBuf* extra_ccats = gu_new_buf(PgfCCat*, tmp_pool);
+	PgfCCatCbCtx ctx = { { pgf_read_ccat_cb }, extra_ccats };
+	gu_map_iter(rdr->curr_ccats, &ctx.fn, NULL);
+	concr->extra_ccats = gu_buf_freeze(extra_ccats, rdr->opool);
+	(void) pgf_read_int(rdr); // totalcats
+	gu_pool_free(tmp_pool);
+	return concr;
+}
+
+static bool
+pgf_ccat_n_lins(PgfCCat* cat, int* n_lins) {
+	if (gu_seq_is_null(cat->prods)) {
+		return true;
+	}
+	size_t n_prods = gu_seq_length(cat->prods);
+	for (size_t j = 0; j < n_prods; j++) {
+		PgfProduction prod =
+			gu_seq_get(cat->prods, PgfProduction, j);
+		GuVariantInfo i = gu_variant_open(prod);
+		switch (i.tag) {
+		case PGF_PRODUCTION_APPLY: {
+			PgfProductionApply* papp = i.data;
+			if (*n_lins == -1) {
+				*n_lins = (int) papp->fun->n_lins;
+			} else if (*n_lins != (int) papp->fun->n_lins) {
+				// Inconsistent n_lins for different productions!
+				return false;
+			}
+			break;
+		}
+		case PGF_PRODUCTION_COERCE: {
+			PgfProductionCoerce* pcoerce = i.data;
+			bool succ = pgf_ccat_n_lins(pcoerce->coerce, n_lins);
+			if (!succ) {
+				return false;
+			}
+			break;
+		}
+		default:
+			gu_impossible();
+		}
+	}
+	return true;
+}
+
+static void*
+pgf_read_new_PgfCncCat(GuType* type, PgfReader* rdr, GuPool* pool,
+		       size_t* size_out)
+{
+	PgfCId cid = *(PgfCId*) rdr->curr_key;
+	gu_enter("-> cid");
+	(void) (type && size_out);
+	PgfCncCat* cnccat = gu_new(PgfCncCat, pool);
+	cnccat->cid = cid;
+	int first = pgf_read_int(rdr);
+	int last = pgf_read_int(rdr);
+	int len = last + 1 - first;
+	PgfCCatIds* cats = gu_new_list(PgfCCatIds, pool, len);
+	int n_lins = -1;
+	for (int i = 0; i < len; i++) {
+		int n = first + i;
+		PgfCCat* ccat = gu_map_get(rdr->curr_ccats, &n, PgfCCat*);
+		/* ccat can be NULL if the PGF is optimized and the
+		 * category has been erased as useless */
+		gu_list_index(cats, i) = ccat;
+		if (ccat != NULL) {
+			// TODO: error if overlap
+			ccat->cnccat = cnccat;
+			if (!pgf_ccat_n_lins(ccat, &n_lins)) {
+				gu_raise(rdr->err, PgfReadExn);
+				goto fail;
+			}
+			
+		}
+		gu_debug("range[%d] = %d", i, ccat ? ccat->fid : -1);
+	}
+	cnccat->n_lins = n_lins == -1 ? 0 : (size_t) n_lins;
+	cnccat->cats = cats;
+	cnccat->lindefs = gu_map_get(rdr->curr_lindefs, &first, PgfFunIds*);
+	cnccat->labels = pgf_read_new(rdr, gu_type(GuStringL), 
+				      pool, NULL);
+	gu_exit("<-");
+	return cnccat;
+fail:
+	gu_exit("<- fail");
+	return NULL;
+}
+
+#define PGF_READ_TO_FN(k_, fn_)					\
+	{ gu_kind(k_), (void*) &(PgfReadToFn){ fn_ } }
+
+#define PGF_READ_TO(k_)				\
+	PGF_READ_TO_FN(k_, pgf_read_to_##k_)
+
+
+static GuTypeTable
+pgf_read_to_table = GU_TYPETABLE(
+	GU_SLIST_0,
+	PGF_READ_TO(struct),
+	PGF_READ_TO(GuVariant),
+	PGF_READ_TO(enum),
+	PGF_READ_TO(void),
+	PGF_READ_TO(int),
+	PGF_READ_TO(uint16_t),
+	PGF_READ_TO(GuLength),
+	PGF_READ_TO(PgfCId),
+	PGF_READ_TO(GuString),
+	PGF_READ_TO(double),
+	PGF_READ_TO(pointer),
+	PGF_READ_TO_FN(PgfEquationsM, pgf_read_to_maybe_seq),
+	PGF_READ_TO(GuSeq),
+	PGF_READ_TO(PgfCCatId),
+	PGF_READ_TO(PgfCCat),
+	PGF_READ_TO(PgfSeqId),
+	PGF_READ_TO(PgfFunId),
+	PGF_READ_TO(alias));
+
+#define PGF_READ_NEW_FN(k_, fn_)		\
+	{ gu_kind(k_), (void*) &(PgfReadNewFn){ fn_ } }
+
+#define PGF_READ_NEW(k_)			\
+	PGF_READ_NEW_FN(k_, pgf_read_new_##k_)
+
+static GuTypeTable
+pgf_read_new_table = GU_TYPETABLE(
+	GU_SLIST_0,
+	PGF_READ_NEW(type),
+	PGF_READ_NEW(struct),
+	PGF_READ_NEW(GuMap),
+	PGF_READ_NEW(GuList),
+	PGF_READ_NEW(PgfCCat),
+	PGF_READ_NEW(PgfCncCat),
+	PGF_READ_NEW(PgfConcr),
+	PGF_READ_NEW_FN(PgfSequences, pgf_read_new_idarray),
+	PGF_READ_NEW_FN(PgfCncFuns, pgf_read_new_idarray)
+	);
+
+static PgfReader*
+pgf_new_reader(GuIn* in, GuPool* opool, GuPool* pool, GuExn* err)
+{
+	PgfReader* rdr = gu_new(PgfReader, pool);
+	rdr->opool = opool;
+	rdr->symtab = gu_new_symtable(opool, pool);
+	rdr->err = err;
+	rdr->in = in;
+	rdr->curr_sequences = NULL;
+	rdr->curr_cncfuns = NULL;
+	rdr->read_to_map = gu_new_type_map(&pgf_read_to_table, pool);
+	rdr->read_new_map = gu_new_type_map(&pgf_read_new_table, pool);
+	rdr->pool = pool;
+	return rdr;
+}
+
+
+PgfPGF*
+pgf_read(GuIn* in, GuPool* pool, GuExn* err)
+{
+	GuPool* tmp_pool = gu_new_pool();
+	PgfReader* rdr = pgf_new_reader(in, pool, tmp_pool, err);
+	PgfPGF* pgf = pgf_read_new(rdr, gu_type(PgfPGF), pool, NULL);
+	gu_pool_free(tmp_pool);
+	gu_return_on_exn(err, NULL);
+	return pgf;
+}
diff --git a/src/runtime/c/pgf/type.h b/src/runtime/c/pgf/type.h
deleted file mode 100644
index 7de9dea20..000000000
--- a/src/runtime/c/pgf/type.h
+++ /dev/null
@@ -1,22 +0,0 @@
-#ifndef PGF_TYPE_H
-#define PGF_TYPE_H
-
-typedef struct _Hypo {
-  BindType bt;
-  CId var;
-  Type ty;
-} *Hypo;
-
-typedef struct _Context {
-  int  size;
-  struct _Hypo hypos[];
-} *Context;
-
-struct _Type {
-  Context hypos;
-  CId  cat;
-  int  nArgs;
-  Expr args[];
-};
-
-#endif
diff --git a/src/runtime/c/pgf/unloader.c b/src/runtime/c/pgf/unloader.c
deleted file mode 100644
index 6a1b0d41d..000000000
--- a/src/runtime/c/pgf/unloader.c
+++ /dev/null
@@ -1,248 +0,0 @@
-#include "../pgf.h"
-#include "data.h"
-#include "panic.h"
-#include <stdlib.h>
-
-static void freeCId(CId id) {
-  free(id);
-}
-
-static void freeCIdList(CIdList ids) {
-  int i;
-  for (i = 0; i < ids->count; i++) {
-    freeCId(ids->names[i]);
-  }
-  free(ids);
-}
-
-static void freeString(String str) {
-  free(str);
-}
-
-static void freeLiteral(Literal lit) {
-  switch (lit->tag) {
-  case LIT_STR:
-    freeString (((LiteralStr) lit)->val);
-    break;
-  }
-  free(lit);
-}
-
-static void freeFlags(Flags flags) {
-  int i;
-  for (i = 0; i < flags->count; i++) {
-    freeCId(flags->values[i].name);
-    freeLiteral(flags->values[i].value);
-  }  
-  free(flags);
-}
-
-static void freeContext(Context ctxt);
-static void freeType(Type ty);
-
-static void freeExpr(Expr e0) {
-	
-  switch (e0->tag) {
-  case TAG_ABS:
-    {
-        ExprAbs e = (ExprAbs) e0;
-        freeCId(e->var);
-        freeExpr(e->body);
-    }
-    break;
-  case TAG_APP:
-    {
-        ExprApp e = (ExprApp) e0;
-        freeExpr(e->left);
-        freeExpr(e->right);
-    }
-    break;
-  case TAG_LIT:
-    {
-        ExprLit e = (ExprLit) e0;
-        freeLiteral(e->lit);
-    }
-    break;
-  case TAG_MET:
-    {
-        ExprMeta e = (ExprMeta) e0;
-    }
-    break;
-  case TAG_FUN:
-    {
-        ExprFun e = (ExprFun) e0;
-        freeCId(e->fun);
-    }
-    break;
-  case TAG_VAR:
-    {
-        ExprVar e = (ExprVar) e0;
-    }
-    break;
-  case TAG_TYP:
-    {
-        ExprTyped e = (ExprTyped) e0;
-        freeExpr(e->e);
-        freeType(e->ty);
-    }
-    break;
-  case TAG_IMP:
-    {
-        ExprImplArg e = (ExprImplArg) e0;
-        freeExpr(e->e);
-    }
-    break;
-  default:
-    __pgf_panic("Unknown expression tag");
-  }
-  
-  free(e0);
-}
-
-static void freeType(Type ty) {
-  freeContext(ty->hypos);
-  freeCId(ty->cat);
-   
-  int i;
-  for (i = 0; i < ty->nArgs; i++) {
-    freeExpr(ty->args[i]);
-  }
-  
-  free(ty);
-}
-
-static void freeHypo(Hypo hypo) {
-  freeCId(hypo->var);
-  freeType(hypo->ty);
-}
-
-static void freeContext(Context ctxt) {
-  int i;
-  for (i = 0; i < ctxt->size; i++) {
-    freeHypo(&ctxt->hypos[i]);
-  }  
-  free(ctxt);
-}
-
-static void freePatt(Patt p0) {
-  switch (p0->tag) {
-  case TAG_PAPP:
-    {
-       int i;
-       PattApp p = (PattApp) p0;
-  
-       freeCId(p->fun);
-       for (i = 0; i < p->args.count; i++) {
-         freePatt(p->args.pats[i]);
-       }
-    }
-    break;
-  case TAG_PVAR:
-    {
-        PattVar p = (PattVar) p0;
-        freeCId(p->var);
-    }
-    break;
-  case TAG_PAT:
-    {
-        PattAt p = (PattAt) p0;
-        freeCId(p->var);
-        freePatt(p->pat);
-    }
-    break;
-  case TAG_PWILD:
-    {
-        PattWild p = (PattWild) p0;
-    }
-    break;
-  case TAG_PLIT:
-    {
-        PattLit p = (PattLit) p0;
-        freeLiteral(p->lit);
-    }
-    break;
-  case TAG_PIMP:
-    {
-        PattImplArg p = (PattImplArg) p0;
-        freePatt(p->pat);
-    }
-    break;
-  case TAG_PTILDE:
-    {
-        PattTilde p = (PattTilde) p0;
-        freeExpr(p->e);
-    }
-    break;
-  default:
-    __pgf_panic("Unknown pattern tag");
-  }
-  
-  free(p0);
-}
-
-static void freePatts(Patts pats) {
-  int i;
-  for (i = 0; i < pats->count; i++) {
-    freePatt(pats->pats[i]);
-  }
-  free(pats);
-}
-
-static void freeEquations(Equations equs) {
-  int i;
-  for (i = 0; i < equs->count; i++) {
-    freePatts(equs->equs[i].lhs);
-    freeExpr(equs->equs[i].rhs);
-  }
-  free(equs);
-}
-
-static void freeAbsFun(AbsFun fun) {
-  freeCId(fun->name);
-  freeType(fun->ty);
-  freeEquations(fun->equs);
-}
-
-static void freeAbsFuns(AbsFuns funs) {
-  int i;
-  for (i = 0; i < funs->count; i++) {
-    freeAbsFun(&funs->lst[i]);
-  }  
-  free(funs);
-}
-
-static void freeAbsCat(AbsCat cat) {
-  freeCId(cat->name);
-  freeContext(cat->hypos);
-  freeCIdList(cat->funs);
-}
-
-static void freeAbsCats(AbsCats cats) {
-  int i;
-  for (i = 0; i < cats->count; i++) {
-    freeAbsCat(&cats->lst[i]);
-  }  
-  free(cats);
-}
-
-static void freeAbstract(Abstract abstr) {
-  freeCId(abstr->name);
-  freeFlags(abstr->flags);
-  freeAbsFuns(abstr->funs);
-  freeAbsCats(abstr->cats);
-}
-
-static void freeConcrete(Concrete concr) {
-//  freeCId(concr->name);
-//  freeFlags(concr->flags);
-}
-
-void freePGF(PGF pgf) {
-  int i;
-  
-  freeFlags(pgf->flags);
-  freeAbstract(&pgf->abstract);
-  for (i = 0; i < pgf->nConcr; i++)
-    freeConcrete(&pgf->concretes[i]);
-  free(pgf);
-}