mirror of
https://github.com/GrammaticalFramework/gf-core.git
synced 2026-04-29 06:22:51 -06:00
initial import of the C runtime
This commit is contained in:
kr.angelov
697
src/runtime/c/pgf/parser.c
Normal file
697
src/runtime/c/pgf/parser.c
Normal file
@@ -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;
|
||||
}
|
||||
Reference in New Issue
Block a user