mirror of
https://github.com/GrammaticalFramework/gf-core.git
synced 2026-05-05 09:12:51 -06:00
rename linearize.{h/c} to linearizer.{h/c} which follows the convention used in parser.c and reasoner.c
This commit is contained in:
kr.angelov
539
src/runtime/c/pgf/linearizer.c
Normal file
539
src/runtime/c/pgf/linearizer.c
Normal file
@@ -0,0 +1,539 @@
|
||||
#include "data.h"
|
||||
#include "linearizer.h"
|
||||
#include <gu/map.h>
|
||||
#include <gu/fun.h>
|
||||
#include <gu/log.h>
|
||||
#include <gu/choice.h>
|
||||
#include <gu/seq.h>
|
||||
#include <gu/file.h>
|
||||
#include <gu/string.h>
|
||||
#include <gu/assert.h>
|
||||
#include <pgf/expr.h>
|
||||
#include <pgf/literals.h>
|
||||
#include <stdio.h>
|
||||
|
||||
//#define PGF_LINEARIZER_DEBUG
|
||||
|
||||
GU_DEFINE_TYPE(PgfCncOverloadMap, GuMap,
|
||||
gu_type(PgfCCat), NULL,
|
||||
gu_ptr_type(GuBuf), &gu_null_struct);
|
||||
|
||||
GU_DEFINE_TYPE(PgfCncFunOverloadMap, GuStringMap, gu_ptr_type(PgfCncOverloadMap),
|
||||
&gu_null_struct);
|
||||
|
||||
static void
|
||||
pgf_lzr_add_overl_entry(PgfCncOverloadMap* overl_table,
|
||||
PgfCCat* ccat, void* entry,
|
||||
GuPool *pool)
|
||||
{
|
||||
GuBuf* entries =
|
||||
gu_map_get(overl_table, ccat, GuBuf*);
|
||||
if (entries == NULL) {
|
||||
entries = gu_new_buf(void*, pool);
|
||||
gu_map_put(overl_table, ccat, GuBuf*, entries);
|
||||
}
|
||||
|
||||
gu_buf_push(entries, void*, entry);
|
||||
}
|
||||
|
||||
typedef struct {
|
||||
GuMapItor fn;
|
||||
PgfConcr* concr;
|
||||
GuPool* pool;
|
||||
} PgfLzrIndexFn;
|
||||
|
||||
static void
|
||||
pgf_lzr_index_itor(GuMapItor* fn, const void* key, void* value, GuExn* err)
|
||||
{
|
||||
(void) (key && err);
|
||||
|
||||
PgfLzrIndexFn* clo = (PgfLzrIndexFn*) fn;
|
||||
PgfCCat* ccat = *((PgfCCat**) value);
|
||||
PgfConcr *concr = clo->concr;
|
||||
GuPool *pool = clo->pool;
|
||||
|
||||
if (gu_seq_is_null(ccat->prods))
|
||||
return;
|
||||
|
||||
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);
|
||||
|
||||
void* data = gu_variant_data(prod);
|
||||
switch (gu_variant_tag(prod)) {
|
||||
case PGF_PRODUCTION_APPLY: {
|
||||
PgfProductionApply* papply = data;
|
||||
PgfCncOverloadMap* overl_table =
|
||||
gu_map_get(concr->fun_indices, &papply->fun->name,
|
||||
PgfCncOverloadMap*);
|
||||
if (!overl_table) {
|
||||
overl_table = gu_map_type_new(PgfCncOverloadMap, pool);
|
||||
gu_map_put(concr->fun_indices,
|
||||
&papply->fun->name, PgfCncOverloadMap*, overl_table);
|
||||
}
|
||||
pgf_lzr_add_overl_entry(overl_table, ccat, papply, pool);
|
||||
break;
|
||||
}
|
||||
case PGF_PRODUCTION_COERCE: {
|
||||
PgfProductionCoerce* pcoerce = data;
|
||||
pgf_lzr_add_overl_entry(concr->coerce_idx, ccat, pcoerce, pool);
|
||||
break;
|
||||
}
|
||||
default:
|
||||
gu_impossible();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
pgf_lzr_index(PgfConcr* concr, GuPool *pool)
|
||||
{
|
||||
PgfLzrIndexFn clo = { { pgf_lzr_index_itor }, concr, pool };
|
||||
gu_map_iter(concr->ccats, &clo.fn, NULL);
|
||||
}
|
||||
|
||||
typedef struct PgfLzn PgfLzn;
|
||||
|
||||
struct PgfLzn {
|
||||
PgfConcr* concr;
|
||||
GuChoice* ch;
|
||||
PgfExpr expr;
|
||||
GuEnum en;
|
||||
};
|
||||
|
||||
|
||||
//
|
||||
// PgfCncTree
|
||||
//
|
||||
|
||||
typedef enum {
|
||||
PGF_CNC_TREE_APP,
|
||||
PGF_CNC_TREE_LIT,
|
||||
} PgfCncTreeTag;
|
||||
|
||||
typedef struct {
|
||||
PgfCncFun* fun;
|
||||
GuLength n_args;
|
||||
PgfCncTree args[];
|
||||
} PgfCncTreeApp;
|
||||
|
||||
typedef struct {
|
||||
PgfLiteral lit;
|
||||
} PgfCncTreeLit;
|
||||
|
||||
#ifdef PGF_LINEARIZER_DEBUG
|
||||
void
|
||||
pgf_print_cnc_tree(PgfCncTree ctree, GuWriter* wtr, GuExn* err)
|
||||
{
|
||||
GuVariantInfo ti = gu_variant_open(ctree);
|
||||
switch (ti.tag) {
|
||||
case PGF_CNC_TREE_LIT: {
|
||||
PgfCncTreeLit* clit = ti.data;
|
||||
pgf_print_literal(clit->lit, wtr, err);
|
||||
break;
|
||||
}
|
||||
case PGF_CNC_TREE_APP: {
|
||||
PgfCncTreeApp* capp = ti.data;
|
||||
if (capp->n_args > 0) gu_putc('(', wtr, err);
|
||||
gu_printf(wtr, err, "F%d", capp->fun->funid);
|
||||
for (size_t i = 0; i < capp->n_args; i++) {
|
||||
gu_putc(' ', wtr, err);
|
||||
pgf_print_cnc_tree(capp->args[i], wtr, err);
|
||||
}
|
||||
if (capp->n_args > 0) gu_putc(')', wtr, err);
|
||||
break;
|
||||
}
|
||||
default:
|
||||
gu_impossible();
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
static PgfCncTree
|
||||
pgf_lzn_resolve(PgfLzn* lzn, PgfExpr expr, PgfCCat* ccat, GuPool* pool);
|
||||
|
||||
static PgfCncTree
|
||||
pgf_lzn_resolve_app(PgfLzn* lzn, GuBuf* buf, GuBuf* args, GuPool* pool)
|
||||
{
|
||||
GuChoiceMark mark = gu_choice_mark(lzn->ch);
|
||||
|
||||
redo:;
|
||||
int index = gu_choice_next(lzn->ch, gu_buf_length(buf));
|
||||
if (index < 0) {
|
||||
return gu_null_variant;
|
||||
}
|
||||
|
||||
size_t n_args = gu_buf_length(args);
|
||||
|
||||
PgfProductionApply* papply =
|
||||
gu_buf_get(buf, PgfProductionApply*, index);
|
||||
gu_assert(n_args == gu_seq_length(papply->args));
|
||||
|
||||
PgfCncTree ret = gu_null_variant;
|
||||
PgfCncTreeApp* capp =
|
||||
gu_new_flex_variant(PGF_CNC_TREE_APP,
|
||||
PgfCncTreeApp,
|
||||
args, n_args, &ret, pool);
|
||||
capp->fun = papply->fun;
|
||||
capp->n_args = n_args;
|
||||
|
||||
for (size_t i = 0; i < n_args; i++) {
|
||||
PgfPArg* parg = gu_seq_index(papply->args, PgfPArg, i);
|
||||
PgfExpr earg = gu_buf_get(args, PgfExpr, n_args-i-1);
|
||||
|
||||
PgfCCat* ccat = NULL;
|
||||
GuBuf* coercions =
|
||||
gu_map_get(lzn->concr->coerce_idx, parg->ccat, GuBuf*);
|
||||
if (coercions == NULL) {
|
||||
ccat = parg->ccat;
|
||||
} else {
|
||||
int index = gu_choice_next(lzn->ch, gu_buf_length(coercions));
|
||||
gu_choice_advance(lzn->ch);
|
||||
PgfProductionCoerce* pcoerce =
|
||||
gu_buf_get(coercions, PgfProductionCoerce*, index);
|
||||
ccat = pcoerce->coerce;
|
||||
}
|
||||
|
||||
capp->args[i] =
|
||||
pgf_lzn_resolve(lzn, earg, ccat, pool);
|
||||
if (gu_variant_is_null(capp->args[i])) {
|
||||
gu_choice_reset(lzn->ch, mark);
|
||||
if (!gu_choice_advance(lzn->ch))
|
||||
return gu_null_variant;
|
||||
goto redo;
|
||||
}
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static PgfCncTree
|
||||
pgf_lzn_resolve_def(PgfLzn* lzn, PgfFunIds* lindefs, GuString s, GuPool* pool)
|
||||
{
|
||||
PgfCncTree ret = gu_null_variant;
|
||||
|
||||
int index =
|
||||
gu_choice_next(lzn->ch, gu_list_length(lindefs));
|
||||
if (index < 0) {
|
||||
return ret;
|
||||
}
|
||||
PgfCncTreeApp* capp =
|
||||
gu_new_flex_variant(PGF_CNC_TREE_APP,
|
||||
PgfCncTreeApp,
|
||||
args, 1, &ret, pool);
|
||||
capp->fun = gu_list_index(lindefs, index);
|
||||
capp->n_args = 1;
|
||||
|
||||
PgfCncTreeLit* clit =
|
||||
gu_new_variant(PGF_CNC_TREE_LIT,
|
||||
PgfCncTreeLit,
|
||||
&capp->args[0], pool);
|
||||
clit->lit =
|
||||
gu_new_variant_i(pool,
|
||||
PGF_LITERAL_STR,
|
||||
PgfLiteralStr,
|
||||
s);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
typedef struct {
|
||||
GuMapItor fn;
|
||||
PgfLzn* lzn;
|
||||
GuBuf* args;
|
||||
GuPool* pool;
|
||||
PgfCncTree ctree;
|
||||
} PgfLznItor;
|
||||
|
||||
static void
|
||||
pgf_lzn_cat_resolve_itor(GuMapItor* fn, const void* key, void* value, GuExn* err)
|
||||
{
|
||||
PgfLznItor* clo = (PgfLznItor*) fn;
|
||||
GuBuf* buf = *((GuBuf**) value);
|
||||
|
||||
if (gu_variant_is_null(clo->ctree))
|
||||
clo->ctree = pgf_lzn_resolve_app(clo->lzn, buf, clo->args, clo->pool);
|
||||
}
|
||||
|
||||
static PgfCncTree
|
||||
pgf_lzn_resolve(PgfLzn* lzn, PgfExpr expr, PgfCCat* ccat, GuPool* pool)
|
||||
{
|
||||
PgfCncTree ret = gu_null_variant;
|
||||
GuPool* tmp_pool = gu_new_pool();
|
||||
GuBuf* args = gu_new_buf(PgfExpr, tmp_pool);
|
||||
|
||||
for (;;) {
|
||||
GuVariantInfo i = gu_variant_open(expr);
|
||||
switch (i.tag) {
|
||||
case PGF_EXPR_APP: {
|
||||
PgfExprApp* eapp = i.data;
|
||||
gu_buf_push(args, PgfExpr, eapp->arg);
|
||||
expr = eapp->fun;
|
||||
break;
|
||||
}
|
||||
case PGF_EXPR_LIT: {
|
||||
PgfExprLit* elit = i.data;
|
||||
PgfCncTreeLit* clit =
|
||||
gu_new_variant(PGF_CNC_TREE_LIT,
|
||||
PgfCncTreeLit,
|
||||
&ret, pool);
|
||||
clit->lit = elit->lit;
|
||||
goto done;
|
||||
}
|
||||
case PGF_EXPR_META: {
|
||||
if (ccat->lindefs == NULL)
|
||||
goto done;
|
||||
|
||||
GuString s = gu_str_string("?", pool);
|
||||
|
||||
ret = pgf_lzn_resolve_def(lzn, ccat->lindefs, s, pool);
|
||||
goto done;
|
||||
}
|
||||
case PGF_EXPR_FUN: {
|
||||
PgfExprFun* efun = i.data;
|
||||
|
||||
PgfCncOverloadMap* overl_table =
|
||||
gu_map_get(lzn->concr->fun_indices, &efun->fun, PgfCncOverloadMap*);
|
||||
if (overl_table == NULL) {
|
||||
if (ccat->lindefs == NULL)
|
||||
goto done;
|
||||
|
||||
GuPool* tmp_pool = gu_local_pool();
|
||||
GuExn* err = gu_new_exn(NULL, gu_kind(type), tmp_pool);
|
||||
GuStringBuf* sbuf = gu_string_buf(tmp_pool);
|
||||
GuWriter* wtr = gu_string_buf_writer(sbuf);
|
||||
|
||||
gu_putc('[', wtr, err);
|
||||
gu_string_write(efun->fun, wtr, err);
|
||||
gu_putc(']', wtr, err);
|
||||
GuString s = gu_string_buf_freeze(sbuf, tmp_pool);
|
||||
|
||||
ret = pgf_lzn_resolve_def(lzn, ccat->lindefs, s,
|
||||
pool);
|
||||
|
||||
gu_pool_free(tmp_pool);
|
||||
goto done;
|
||||
}
|
||||
|
||||
if (ccat == NULL) {
|
||||
PgfLznItor clo = { { pgf_lzn_cat_resolve_itor }, lzn, args, pool, gu_null_variant };
|
||||
gu_map_iter(overl_table, &clo.fn, NULL);
|
||||
ret = clo.ctree;
|
||||
} else {
|
||||
GuBuf* buf =
|
||||
gu_map_get(overl_table, ccat, GuBuf*);
|
||||
if (buf == NULL) {
|
||||
goto done;
|
||||
}
|
||||
|
||||
ret = pgf_lzn_resolve_app(lzn, buf, args, pool);
|
||||
}
|
||||
goto done;
|
||||
}
|
||||
case PGF_EXPR_TYPED: {
|
||||
PgfExprTyped* etyped = i.data;
|
||||
expr = etyped->expr;
|
||||
break;
|
||||
}
|
||||
case PGF_EXPR_IMPL_ARG: {
|
||||
PgfExprImplArg* eimpl = i.data;
|
||||
expr = eimpl->expr;
|
||||
break;
|
||||
}
|
||||
default:
|
||||
gu_impossible();
|
||||
}
|
||||
}
|
||||
|
||||
done:
|
||||
gu_pool_free(tmp_pool);
|
||||
return ret;
|
||||
}
|
||||
|
||||
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_resolve(lzn, lzn->expr, NULL, pool);
|
||||
|
||||
#ifdef PGF_LINEARIZER_DEBUG
|
||||
GuPool* tmp_pool = gu_new_pool();
|
||||
GuOut* out = gu_file_out(stderr, tmp_pool);
|
||||
GuWriter* wtr = gu_new_utf8_writer(out, tmp_pool);
|
||||
GuExn* err = gu_exn(NULL, type, tmp_pool);
|
||||
if (gu_variant_is_null(*toc))
|
||||
gu_puts("*nil*\n", wtr, err);
|
||||
else {
|
||||
pgf_print_cnc_tree(*toc, wtr, err);
|
||||
gu_puts("\n", wtr, err);
|
||||
}
|
||||
gu_pool_free(tmp_pool);
|
||||
#endif
|
||||
}
|
||||
|
||||
PgfCncTreeEnum*
|
||||
pgf_lzr_concretize(PgfConcr* concr, PgfExpr expr, GuPool* pool)
|
||||
{
|
||||
PgfLzn* lzn = gu_new(PgfLzn, pool);
|
||||
lzn->concr = concr;
|
||||
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(PgfConcr* concr, 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->name, 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(concr, 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 void
|
||||
pgf_file_lzn_expr_literal(PgfLinFuncs** funcs, PgfLiteral lit)
|
||||
{
|
||||
PgfSimpleLin* flin = gu_container(funcs, PgfSimpleLin, funcs);
|
||||
if (!gu_ok(flin->err)) {
|
||||
return;
|
||||
}
|
||||
|
||||
GuVariantInfo i = gu_variant_open(lit);
|
||||
switch (i.tag) {
|
||||
case PGF_LITERAL_STR: {
|
||||
PgfLiteralStr* lstr = i.data;
|
||||
gu_string_write(lstr->val, flin->wtr, flin->err);
|
||||
gu_putc(' ', flin->wtr, flin->err);
|
||||
break;
|
||||
}
|
||||
case PGF_LITERAL_INT: {
|
||||
PgfLiteralInt* lint = i.data;
|
||||
gu_printf(flin->wtr, flin->err, "%d ", lint->val);
|
||||
break;
|
||||
}
|
||||
case PGF_LITERAL_FLT: {
|
||||
PgfLiteralFlt* lflt = i.data;
|
||||
gu_printf(flin->wtr, flin->err, "%lf ", lflt->val);
|
||||
break;
|
||||
}
|
||||
default:
|
||||
gu_impossible();
|
||||
}
|
||||
}
|
||||
|
||||
static PgfLinFuncs pgf_file_lin_funcs = {
|
||||
.symbol_tokens = pgf_file_lzn_symbol_tokens,
|
||||
.expr_literal = pgf_file_lzn_expr_literal
|
||||
};
|
||||
|
||||
void
|
||||
pgf_lzr_linearize_simple(PgfConcr* concr, PgfCncTree ctree,
|
||||
size_t lin_idx, GuWriter* wtr, GuExn* err)
|
||||
{
|
||||
PgfSimpleLin flin = {
|
||||
.funcs = &pgf_file_lin_funcs,
|
||||
.wtr = wtr,
|
||||
.err = err
|
||||
};
|
||||
pgf_lzr_linearize(concr, ctree, lin_idx, &flin.funcs);
|
||||
}
|
||||
Reference in New Issue
Block a user