From ce63d4627ba724cf47356f47e7ed44540b3c9e6f Mon Sep 17 00:00:00 2001 From: Krasimir Angelov Date: Wed, 14 Jan 2026 16:42:04 +0100 Subject: [PATCH] variables in rules are finally renamed --- src/compiler/api/GF/Compile/GeneratePMCFG.hs | 165 ++++++++++--------- src/compiler/api/GF/Grammar/Printer.hs | 2 +- src/runtime/c/pgf/data.cxx | 9 +- src/runtime/c/pgf/data.h | 9 +- src/runtime/c/pgf/linearizer.cxx | 45 ++--- src/runtime/c/pgf/linearizer.h | 4 +- src/runtime/c/pgf/parser.cxx | 118 +++++-------- src/runtime/c/pgf/parser.h | 6 +- src/runtime/c/pgf/pgf.cxx | 28 ++-- src/runtime/c/pgf/pgf.h | 4 +- src/runtime/c/pgf/phrasetable.h | 2 +- src/runtime/c/pgf/printer.cxx | 16 +- src/runtime/c/pgf/printer.h | 2 +- src/runtime/c/pgf/reader.cxx | 36 +--- src/runtime/c/pgf/reader.h | 4 +- src/runtime/c/pgf/writer.cxx | 7 +- src/runtime/c/pgf/writer.h | 2 +- src/runtime/haskell/PGF2/Transactions.hsc | 6 +- 18 files changed, 184 insertions(+), 281 deletions(-) diff --git a/src/compiler/api/GF/Compile/GeneratePMCFG.hs b/src/compiler/api/GF/Compile/GeneratePMCFG.hs index 4cf1ba725..c2d360927 100644 --- a/src/compiler/api/GF/Compile/GeneratePMCFG.hs +++ b/src/compiler/api/GF/Compile/GeneratePMCFG.hs @@ -21,7 +21,7 @@ import Control.Applicative import Control.Monad (foldM,zipWithM,liftM,liftM2,forM,MonadPlus(..)) import Control.Monad.Fix import Data.Maybe -import Data.List(mapAccumL,sortBy,intersperse) +import Data.List(mapAccumL,sortBy,sortOn,intersperse) import Data.Containers.ListUtils(nubOrd) import Prelude hiding ((<>)) @@ -76,22 +76,21 @@ pmcfgForm g t ctxt ty = do (ms,_,_,fn) <- breakDown g ms unit 0 [] v ty (return []) empty fmap nubOrd $ runGenM g ms [] $ do (r,rs,v,res_params) <- fn - arg_params <- mapM params2int arg_params - res_params <- params2int res_params - lin_idx <- params2int' r rs - seq <- flatten v - qs <- quantifiers (arg_params++[res_params,lin_idx]) + (subst,arg_params) <- mapAccumM params2int Map.empty arg_params + (subst,res_params) <- params2int subst res_params + (subst,lin_idx) <- params2int' subst r rs + (subst,seq) <- flatten subst v + qs <- quantifiers (Map.toList subst) return (Rule qs res_params arg_params lin_idx seq) where Gl sgr _ = g - quantifiers params = GenM (\(Gl sgr _) k svs ms -> - k ((Set.toList . Set.fromList) - [(variable,boundsOf sgr ms variable) | LParam _ terms <- params, (factor,variable) <- terms]) + quantifiers vars = GenM (\(Gl sgr _) k svs ms -> + k [boundsOf sgr ms variable | (variable,v) <- sortOn snd vars] svs ms) where boundsOf sgr ms i = - case Map.lookup (i+1) ms of + case Map.lookup i ms of Just (Narrowing _ pty) -> case countParamValues sgr pty of Ok c -> c Bad msg -> error msg @@ -299,24 +298,26 @@ force (VFV c vs) = do force v = compileError ("Cannot evaluate" <+> ppValue Unqualified 0 v) -flatten (VStr s) = return [SymKS s] -flatten (VSymCat d r rs) = do - lin_index <- params2int' r rs - return [SymCat d lin_index] -flatten (VApp _ (m,id) []) - | m == cPredef && id == cBIND = return [SymBIND] - | m == cPredef && id == cSOFT_BIND = return [SymSOFT_BIND] - | m == cPredef && id == cSOFT_SPACE = return [SymSOFT_SPACE] - | m == cPredef && id == cNonExist = return [SymNE] - | m == cPredef && id == cCAPIT = return [SymCAPIT] - | m == cPredef && id == cALL_CAPIT = return [SymALL_CAPIT] -flatten v0@(VAlts def alts) = do - def <- flatten def - alts <- forM alts $ \(alt,ps) -> do - alt <- flatten alt - ps <- to_strs ps - return (alt,ps) - return [SymKP def alts] +flatten subst (VStr s) = return (subst,[SymKS s]) +flatten subst (VSymCat d r rs) = do + (subst,lin_index) <- params2int' subst r rs + return (subst,[SymCat d lin_index]) +flatten subst (VApp _ (m,id) []) + | m == cPredef && id == cBIND = return (subst,[SymBIND]) + | m == cPredef && id == cSOFT_BIND = return (subst,[SymSOFT_BIND]) + | m == cPredef && id == cSOFT_SPACE = return (subst,[SymSOFT_SPACE]) + | m == cPredef && id == cNonExist = return (subst,[SymNE]) + | m == cPredef && id == cCAPIT = return (subst,[SymCAPIT]) + | m == cPredef && id == cALL_CAPIT = return (subst,[SymALL_CAPIT]) +flatten subst v0@(VAlts def alts) = do + (subst,def) <- flatten subst def + (subst,alts) <- mapAccumM (\subst (alt,ps) -> do + (subst,alt) <- flatten subst alt + ps <- to_strs ps + return (subst,(alt,ps))) + subst + alts + return (subst,[SymKP def alts]) where to_strs (VStrs vs) = mapM to_str vs to_strs (VPatt _ _ p) = from_patt p @@ -332,12 +333,12 @@ flatten v0@(VAlts def alts) = do from_patt _ = fail fail = compileError ("Complex patterns are not supported in:" $$ nest 2 (ppValue Unqualified 0 v0)) -flatten VEmpty = return [] -flatten (VC v1 v2) = do - s1 <- flatten v1 - s2 <- flatten v2 - return (s1++s2) -flatten (VSusp i k vs) = do +flatten subst VEmpty = return (subst,[]) +flatten subst (VC v1 v2) = do + (subst,s1) <- flatten subst v1 + (subst,s2) <- flatten subst v2 + return (subst,s1++s2) +flatten subst (VSusp i k vs) = do st <- getMeta i v <- case st of Narrowing c ty -> do v <- chooseMetaValue c ty @@ -345,62 +346,66 @@ flatten (VSusp i k vs) = do return v Bound _ v -> return v g <- globals - flatten (apply g (k v) vs) -flatten (VFV c vs) = do + flatten subst (apply g (k v) vs) +flatten subst (VFV c vs) = do v <- variants c (unvariants vs) - flatten v -flatten v = compileError ("Cannot evaluate" <+> ppValue Unqualified 0 v <+> "to a string") + flatten subst v +flatten subst v = compileError ("Cannot evaluate" <+> ppValue Unqualified 0 v <+> "to a string") -params2int rs = do - (r,rs,_) <- compute rs - return (LParam r (order rs)) +params2int subst rs = do + (subst,r,rs,_) <- compute subst rs + return (subst,LParam r (order rs)) where - compute [] = return (0,[],1) - compute ((v,ty):params) = do - (r, rs, cnt ) <- param2int v ty - (r',rs',cnt') <- compute params - return (r*cnt'+r',combine cnt' rs rs',cnt*cnt') + compute subst [] = return (subst,0,[],1) + compute subst ((v,ty):params) = do + (subst, r, rs, cnt ) <- param2int subst v ty + (subst, r',rs',cnt') <- compute subst params + return (subst, r*cnt'+r',combine cnt' rs rs',cnt*cnt') -params2int' r0 rs = do - (r,rs) <- compute rs - return (LParam (r0+r) (order rs)) +params2int' subst r0 rs = do + (subst,r,rs) <- compute subst rs + return (subst,LParam (r0+r) (order rs)) where - compute [] = return (0,[]) - compute ((cnt',(v,ty)):params) = do - (r, rs, cnt) <- param2int v ty - (r',rs') <- compute params - return (r*cnt'+r',combine cnt' rs rs') + compute subst [] = return (subst,0,[]) + compute subst ((cnt',(v,ty)):params) = do + (subst, r, rs, cnt) <- param2int subst v ty + (subst, r',rs') <- compute subst params + return (subst,r*cnt'+r',combine cnt' rs rs') -param2int (VR as) (RecType lbls) = compute lbls +param2int subst (VR as) (RecType lbls) = compute subst lbls where - compute [] = return (0,[],1) - compute ((lbl,_,ty):lbls) = do + compute subst [] = return (subst,0,[],1) + compute subst ((lbl,_,ty):lbls) = do case lookup lbl as of - Just v -> do (r, rs ,cnt ) <- param2int v ty - (r',rs',cnt') <- compute lbls - return (r*cnt'+r',combine' cnt rs cnt' rs',cnt*cnt') + Just v -> do (subst, r, rs ,cnt ) <- param2int subst v ty + (subst, r',rs',cnt') <- compute subst lbls + return (subst,r*cnt'+r',combine' cnt rs cnt' rs',cnt*cnt') Nothing -> compileError ("Missing value for label" <+> pp lbl $$ "among" <+> hsep (punctuate (pp ',') (map fst as))) -param2int (VApp _ q vs) ty = do - (r , ctxt,cnt ) <- getIdxCnt q - (r',rs', cnt') <- compute ctxt vs - return (r+r',rs',cnt) +param2int subst (VApp _ q vs) ty = do + ( r , ctxt,cnt ) <- getIdxCnt q + (subst,r',rs', cnt') <- compute subst ctxt vs + return (subst,r+r',rs',cnt) where - compute [] [] = return (0,[],1) - compute ((_,_,ty):ctxt) (v:vs) = do - (r, rs ,cnt ) <- param2int v ty - (r',rs',cnt') <- compute ctxt vs - return (r*cnt'+r',combine' cnt rs cnt' rs',cnt*cnt') -param2int (VInt n) ty - | Just max <- isTypeInts ty= return (fromIntegral n,[],fromIntegral max+1) -param2int (VMeta i _) ty = do + compute subst [] [] = return (subst,0,[],1) + compute subst ((_,_,ty):ctxt) (v:vs) = do + (subst, r, rs ,cnt ) <- param2int subst v ty + (subst, r',rs',cnt') <- compute subst ctxt vs + return (subst,r*cnt'+r',combine' cnt rs cnt' rs',cnt*cnt') +param2int subst (VInt n) ty + | Just max <- isTypeInts ty= return (subst,fromIntegral n,[],fromIntegral max+1) +param2int subst (VMeta i _) ty = do st <- getMeta i case st of Narrowing c ty -> do count <- getCnt ty - return (0,[(1,i-1)],count) - Bound _ v -> param2int v ty -param2int (VSusp i k vs) ty = do + case Map.lookup i subst of + Just v -> return (subst,0,[(1,v)],count) + Nothing -> let v = Map.size subst + subst' = Map.insert i v subst + in return (subst',0,[(1,v)],count) + Bound _ v -> param2int subst v ty +param2int subst (VSusp i k vs) ty = do st <- getMeta i v <- case st of Narrowing c ty -> do v <- chooseMetaValue c ty @@ -408,12 +413,12 @@ param2int (VSusp i k vs) ty = do return v Bound _ v -> return v g <- globals - param2int (apply g (k v) vs) ty -param2int (VFV c vs) ty = do + param2int subst (apply g (k v) vs) ty +param2int subst (VFV c vs) ty = do v <- variants c (unvariants vs) - param2int v ty -param2int v ty = compileError ("the parameter:" <+> ppValue Unqualified 0 v $$ - "cannot be evaluated at compile time.") + param2int subst v ty +param2int subst v ty = compileError ("the parameter:" <+> ppValue Unqualified 0 v $$ + "cannot be evaluated at compile time.") combine' 1 rs 1 rs' = [] combine' 1 rs cnt' rs' = rs' diff --git a/src/compiler/api/GF/Grammar/Printer.hs b/src/compiler/api/GF/Grammar/Printer.hs index 33442db89..0b38ffcda 100644 --- a/src/compiler/api/GF/Grammar/Printer.hs +++ b/src/compiler/api/GF/Grammar/Printer.hs @@ -171,7 +171,7 @@ ppPmcfgCat :: Ident -> LParam -> Doc ppPmcfgCat cat p = pp cat <> parens (ppLParam p) ppPmcfgRule id arg_cats res_cat (Rule quantifiers res args lin_idx seq) = - ppQuantifiers quantifiers <+> + ppQuantifiers (zip [0..] quantifiers) <+> ppCat res_cat res <+> "->" <+> pp id <> brackets (hcat (punctuate ',' (zipWith ppCat arg_cats args))) <> ';' <+> ppLParam lin_idx <+> ':' <+> hsep (map ppSymbol seq) where ppCat id value = pp id <> parens (ppLParam value) diff --git a/src/runtime/c/pgf/data.cxx b/src/runtime/c/pgf/data.cxx index 0799b8a32..0b15e9f8b 100644 --- a/src/runtime/c/pgf/data.cxx +++ b/src/runtime/c/pgf/data.cxx @@ -64,13 +64,6 @@ void PgfLParam::release(ref param) PgfDB::free(param, param->n_terms*sizeof(param->terms[0])); } -void PgfPResult::release(ref res) -{ - if (res->vars != 0) - vector::release(res->vars); - PgfDB::free(res, res->param.n_terms*sizeof(res->param.terms[0])); -} - static void symbols_release(vector syms) { for (PgfSymbol sym : syms) { @@ -122,7 +115,7 @@ static void symbols_release(vector syms) void PgfConcrRule::release(ref rule) { - vector::release(rule->vars); + vector::release(rule->ranges); PgfLParam::release(rule->res); diff --git a/src/runtime/c/pgf/data.h b/src/runtime/c/pgf/data.h index 70657ccb5..05c5c3f96 100644 --- a/src/runtime/c/pgf/data.h +++ b/src/runtime/c/pgf/data.h @@ -146,13 +146,6 @@ struct PGF_INTERNAL_DECL PgfPArg { ref param; }; -struct PGF_INTERNAL_DECL PgfPResult { - vector vars; - PgfLParam param; - - static void release(ref res); -}; - typedef object PgfSymbol; struct PGF_INTERNAL_DECL PgfSequenceBackref { @@ -222,7 +215,7 @@ struct PGF_INTERNAL_DECL PgfSymbolALLCAPIT { }; struct PGF_INTERNAL_DECL PgfConcrRule { - vector vars; + vector ranges; ref res; object container; vector> args; diff --git a/src/runtime/c/pgf/linearizer.cxx b/src/runtime/c/pgf/linearizer.cxx index 4657272a7..6626676cb 100644 --- a/src/runtime/c/pgf/linearizer.cxx +++ b/src/runtime/c/pgf/linearizer.cxx @@ -10,31 +10,21 @@ bool PgfLinearizer::Item::instantiate(ref lparam,size_t value) for (size_t j = 0; j < lparam->n_terms; j++) { term t = lparam->terms[j]; - for (size_t k = 0; k < vars.size(); k++) { - if (rule->vars[k].var == t.var) { - if (vars[k] > 0) { - if (value < vars[k]-1) - return false; - value -= vars[k]-1; - } - break; - } + if (vars[t.var] > 0) { + if (value < vars[t.var]-1) + return false; + value -= vars[t.var]-1; } } for (size_t j = 0; j < lparam->n_terms; j++) { term t = lparam->terms[j]; - for (size_t k = 0; k < vars.size(); k++) { - if (rule->vars[k].var == t.var) { - if (vars[k] == 0) { - size_t v_val = value / t.factor; - if (v_val >= rule->vars[k].range) - return false; - vars[k] = v_val + 1; - value %= t.factor; - } - break; - } + if (vars[t.var] == 0) { + size_t v_val = value / t.factor; + if (v_val >= rule->ranges[t.var]) + return false; + vars[t.var] = v_val + 1; + value %= t.factor; } } @@ -45,12 +35,7 @@ size_t PgfLinearizer::Item::eval(ref lparam) { size_t value = lparam->i0; for (size_t i = 0; i < lparam->n_terms; i++) { - for (size_t j = 0; j < rule->vars.size(); j++) { - if (lparam->terms[i].var == rule->vars[j].var) { - value += lparam->terms[i].factor * (vars[j]-1); - break; - } - } + value += lparam->terms[i].factor * (vars[lparam->terms[i].var]-1); } return value; } @@ -252,7 +237,7 @@ bool PgfLinearizer::TreeLinNode::resolve(PgfLinearizer *linearizer) size_t max_value = 1; for (size_t i = 0; i < item->vars.size(); i++) { if (item->vars[i] == 0) - max_value *= item->rule->vars[i].range; + max_value *= item->rule->ranges[i]; } for (size_t value = 0; value < max_value; value++) { @@ -261,7 +246,7 @@ bool PgfLinearizer::TreeLinNode::resolve(PgfLinearizer *linearizer) size_t v = value; for (size_t i = 0; i < new_item->vars.size(); i++) { if (new_item->vars[i] == 0) { - size_t range = new_item->rule->vars[i].range; + size_t range = new_item->rule->ranges[i]; new_item->vars[i] = (v % range)+1; v = v / range; } @@ -519,14 +504,14 @@ bool PgfLinearizer::TreeLinrefNode::resolve(PgfLinearizer *linearizer) size_t max_value = 1; for (size_t i = 0; i < item->vars.size(); i++) { if (item->vars[i] == 0) - max_value *= item->rule->vars[i].range; + max_value *= item->rule->ranges[i]; } for (size_t value = 0; value < max_value; value++) { size_t v = value; for (size_t i = 0; i < item->vars.size(); i++) { if (item->vars[i] == 0) { - size_t range = item->rule->vars[i].range; + size_t range = item->rule->ranges[i]; item->vars[i] = v % range; v = v / range; } diff --git a/src/runtime/c/pgf/linearizer.h b/src/runtime/c/pgf/linearizer.h index 8552b61d6..2c6185259 100644 --- a/src/runtime/c/pgf/linearizer.h +++ b/src/runtime/c/pgf/linearizer.h @@ -36,13 +36,13 @@ class PGF_INTERNAL_DECL PgfLinearizer : public PgfUnmarshaller { } size_t size() { Item *item = containerof(Item,vars,this); - return item->rule->vars.size(); + return item->rule->ranges.size(); } } vars; void *operator new(size_t sz, ref rule) { - size_t sz2 = rule->vars.size()*sizeof(size_t); + size_t sz2 = rule->ranges.size()*sizeof(size_t); Item *new_item = (Item *) malloc(sz+sz2); memset(new_item, 0, sz+sz2); return new_item; diff --git a/src/runtime/c/pgf/parser.cxx b/src/runtime/c/pgf/parser.cxx index 3236a2d43..a41e4ed6a 100644 --- a/src/runtime/c/pgf/parser.cxx +++ b/src/runtime/c/pgf/parser.cxx @@ -332,17 +332,12 @@ interval_t PgfAbstractParser::Item::interval(ref lparam) const interval.second = interval.first; for (size_t i = 0; i < lparam->n_terms; i++) { size_t var = lparam->terms[i].var; - for (size_t j = 0; j < vars.size(); j++) { - if (rule->vars[j].var == var) { - if (vars[j] == 0) { - interval.second += lparam->terms[i].factor * (rule->vars[j].range-1); - } else { - size_t value = lparam->terms[i].factor * (vars[j]-1); - interval.first += value; - interval.second += value; - } - break; - } + if (vars[var] == 0) { + interval.second += lparam->terms[i].factor * (rule->ranges[var]-1); + } else { + size_t value = lparam->terms[i].factor * (vars[var]-1); + interval.first += value; + interval.second += value; } } return interval; @@ -353,25 +348,15 @@ bool PgfAbstractParser::Item::instantiate(ref lparam1, { size_t i01 = lparam1->i0; for (size_t i = 0; i < lparam1->n_terms; i++) { - for (size_t k = 0; k < this->vars.size(); k++) { - if (this->rule->vars[k].var == lparam1->terms[i].var) { - if (this->vars[k] > 0) { - i01 += lparam1->terms[i].factor * (this->vars[k]-1); - } - break; - } + if (this->vars[lparam1->terms[i].var] > 0) { + i01 += lparam1->terms[i].factor * (this->vars[lparam1->terms[i].var]-1); } } size_t i02 = lparam2->i0; for (size_t i = 0; i < lparam2->n_terms; i++) { - for (size_t k = 0; k < rule->vars.size(); k++) { - if (rule->vars[k].var == lparam2->terms[i].var) { - if (values[k] > 0) { - i02 += lparam2->terms[i].factor * (values[k]-1); - } - break; - } + if (values[lparam2->terms[i].var] > 0) { + i02 += lparam2->terms[i].factor * (values[lparam2->terms[i].var]-1); } } @@ -386,103 +371,77 @@ bool PgfAbstractParser::Item::instantiate(ref lparam1, size_t i1 = 0, i2 = 0; while (i1 < lparam1->n_terms || i2 < lparam2->n_terms) { size_t scale1 = 0; - size_t factor1 = 0; - size_t var1 = 0; - size_t k1 = 0; + term t1 = {0,0}; if (i1 < lparam1->n_terms) { - factor1 = lparam1->terms[i1].factor; - var1 = lparam1->terms[i1].var; - for (k1 = 0; k1 < this->vars.size(); k1++) { - if (this->rule->vars[k1].var == var1) - break; - } - if (this->vars[k1] > 0) { + t1 = lparam1->terms[i1]; + if (this->vars[t1.var] > 0) { i1++; continue; } - scale1 = factor1 * this->rule->vars[k1].range; + scale1 = t1.factor * this->rule->ranges[t1.var]; } size_t scale2 = 0; - size_t factor2 = 0; - size_t var2 = 0; - size_t k2 = 0; + term t2 = {0,0}; if (i2 < lparam2->n_terms) { - factor2 = lparam2->terms[i2].factor; - var2 = lparam2->terms[i2].var; - for (k2 = 0; k2 < rule->vars.size(); k2++) { - if (rule->vars[k2].var == var2) - break; - } - if (values[k2] > 0) { + t2 = lparam2->terms[i2]; + if (values[t2.var] > 0) { i2++; continue; } - scale2 = factor2 * rule->vars[k2].range; + scale2 = t2.factor * rule->ranges[t2.var]; } if (scale1 > scale2) { - size_t min = (i02 / factor1); + size_t min = (i02 / t1.factor); size_t max = min; while (i2 < lparam2->n_terms) { - factor2 = lparam2->terms[i2].factor; - size_t f = factor2 / factor1; + t2 = lparam2->terms[i2]; + size_t f = t2.factor / t1.factor; if (f == 0) break; - var2 = lparam2->terms[i2].var; - for (k2 = 0; k2 < rule->vars.size(); k2++) { - if (rule->vars[k2].var == var2) { - if (values[k2] == 0) { - max += f * (rule->vars[k2].range-1); - } - break; - } + if (values[t2.var] == 0) { + max += f * (rule->ranges[t2.var]-1); } i2++; } - i02 %= factor1; + i02 %= t1.factor; - if (min >= this->rule->vars[k1].range) + if (min >= this->rule->ranges[t1.var]) return false; if (min == max) { - if (this->vars[k1] == 0) - this->vars[k1] = min+1; - else if (this->vars[k1] != min+1) + if (this->vars[t1.var] == 0) + this->vars[t1.var] = min+1; + else if (this->vars[t1.var] != min+1) return false; } i1++; } else { - size_t min = (i01 / factor2); + size_t min = (i01 / t2.factor); size_t max = min; while (i1 < lparam1->n_terms) { - factor1 = lparam1->terms[i1].factor; - size_t f = factor1 / factor2; + t1 = lparam1->terms[i1]; + size_t f = t1.factor / t2.factor; if (f == 0) break; - var1 = lparam1->terms[i1].var; - for (k1 = 0; k1 < rule->vars.size(); k1++) { - if (rule->vars[k1].var == var1) { - if (values[k1] == 0) { - max += f * (rule->vars[k1].range-1); - } - break; - } + if (values[t1.var] == 0) { + max += f * (rule->ranges[t1.var]-1); } i1++; } - i01 %= factor2; + i01 %= t2.factor; - if (min >= rule->vars[k2].range) + if (min >= rule->ranges[t2.var]) return false; if (min == max) { - if (values[k2] == 0) { + if (values[t2.var] == 0) { // we don't update the production; - } else if (values[k2] != min+1) + } else if (values[t2.var] != min+1) return false; } @@ -881,6 +840,9 @@ void PgfParser::bu_predict(PgfPhrasetable phrasetable, bu_predict(phrasetable->left,state,min,len); if (len > 0) { + //if (*current.ptr != ' ' && *current.ptr != 0) + // return; + for (size_t i = 0; i < phrasetable->n_items; i++) { std::map, bool> visited; //if (!td_reachable(state, phrasetable->items[i], visited)) diff --git a/src/runtime/c/pgf/parser.h b/src/runtime/c/pgf/parser.h index 486f50738..d735e57c3 100644 --- a/src/runtime/c/pgf/parser.h +++ b/src/runtime/c/pgf/parser.h @@ -26,7 +26,7 @@ protected: } size_t size() const { Production *prod = containerof(Production,vars,this); - return prod->rule->vars.size(); + return prod->rule->ranges.size(); } } vars; @@ -131,7 +131,7 @@ protected: } size_t size() const { Item *item = containerof(Item,vars,this); - return item->rule->vars.size(); + return item->rule->ranges.size(); } } vars; @@ -149,7 +149,7 @@ protected: void *operator new(size_t sz, ref rule) { size_t sz2 = rule->args.size()*sizeof(CCat*) - + rule->vars.size()*sizeof(size_t); + + rule->ranges.size()*sizeof(size_t); Item *new_item = (Item *) malloc(sz+sz2); memset(new_item+1, 0, sz2); return new_item; diff --git a/src/runtime/c/pgf/pgf.cxx b/src/runtime/c/pgf/pgf.cxx index 21245fe75..82bc65a5e 100644 --- a/src/runtime/c/pgf/pgf.cxx +++ b/src/runtime/c/pgf/pgf.cxx @@ -1121,8 +1121,8 @@ PgfText *pgf_print_lindef_internal(object o, size_t i) PgfPrinter printer(NULL,0,&m); ref rule = lincat->rules[i]; - if (rule->vars != 0) { - printer.lvar_ranges(rule->vars, NULL); + if (rule->ranges != 0) { + printer.lvar_ranges(rule->ranges, NULL); printer.puts(" "); } printer.efun(&lincat->name); @@ -1147,8 +1147,8 @@ PgfText *pgf_print_linref_internal(object o, size_t i) ref rule = lincat->rules[lincat->n_lindefs+i]; - if (rule->vars != 0) { - printer.lvar_ranges(rule->vars, NULL); + if (rule->ranges != 0) { + printer.lvar_ranges(rule->ranges, NULL); printer.puts(" "); } @@ -1178,8 +1178,8 @@ PgfText *pgf_print_lin_internal(object o, size_t i) ref rule = lin->rules[i]; ref ty = lin->absfun->type; - if (rule->vars != 0) { - printer.lvar_ranges(rule->vars, NULL); + if (rule->ranges != 0) { + printer.lvar_ranges(rule->ranges, NULL); printer.puts(" "); } @@ -1867,13 +1867,13 @@ public: if (rule_index >= rules.size()) throw pgf_error(builder_error_msg); - vector vars = - (n_vars > 0) ? vector::alloc(n_vars) : 0; + vector ranges = + (n_vars > 0) ? vector::alloc(n_vars) : 0; vector> args = (n_args > 0) ? vector>::alloc(n_args) : 0; ref rule = inline_vector::alloc(&PgfConcrRule::syms, n_syms); - rule->vars = vars; + rule->ranges = ranges; rule->res = 0; rule->container = container; rule->args = args; @@ -1956,7 +1956,7 @@ public: } PGF_API_END } - void add_variable(size_t var, size_t range, PgfExn *err) + void add_variable(size_t range, PgfExn *err) { if (err->type != PGF_EXN_NONE) return; @@ -1967,14 +1967,10 @@ public: ref rule = rules[rule_index]; - if (rule->vars == 0 || var_index >= rule->vars.size()) + if (rule->ranges == 0 || var_index >= rule->ranges.size()) throw pgf_error(builder_error_msg); - ref var_range = - rule->vars.elem(var_index); - var_range->var = var; - var_range->range = range; - + rule->ranges[var_index] = range; var_index++; } PGF_API_END } diff --git a/src/runtime/c/pgf/pgf.h b/src/runtime/c/pgf/pgf.h index 8bc2ddede..d4360dcc0 100644 --- a/src/runtime/c/pgf/pgf.h +++ b/src/runtime/c/pgf/pgf.h @@ -631,7 +631,7 @@ struct PgfLinBuilderIface { virtual void add_argument(size_t i0, size_t n_terms, size_t *terms, PgfExn *err)=0; virtual void set_result(size_t i0, size_t n_terms, size_t *terms, PgfExn *err)=0; virtual void set_lin_idx(size_t i0, size_t n_terms, size_t *terms, PgfExn *err)=0; - virtual void add_variable(size_t var, size_t range, PgfExn *err)=0; + virtual void add_variable(size_t range, PgfExn *err)=0; virtual void add_symcat(size_t d, size_t i0, size_t n_terms, size_t *terms, PgfExn *err)=0; virtual void add_symlit(size_t d, size_t i0, size_t n_terms, size_t *terms, PgfExn *err)=0; virtual void add_symvar(size_t d, size_t r, PgfExn *err)=0; @@ -660,7 +660,7 @@ typedef struct { void (*add_argument)(PgfLinBuilderIface *this, size_t i0, size_t n_terms, size_t *terms, PgfExn *err); void (*set_result)(PgfLinBuilderIface *this, size_t i0, size_t n_terms, size_t *terms, PgfExn *err); void (*set_lin_idx)(PgfLinBuilderIface *this, size_t i0, size_t n_terms, size_t *terms, PgfExn *err); - void (*add_variable)(PgfLinBuilderIface *this, size_t var, size_t range, PgfExn *err); + void (*add_variable)(PgfLinBuilderIface *this, size_t range, PgfExn *err); void (*add_symcat)(PgfLinBuilderIface *this, size_t d, size_t i0, size_t n_terms, size_t *terms, PgfExn *err); void (*add_symlit)(PgfLinBuilderIface *this, size_t d, size_t i0, size_t n_terms, size_t *terms, PgfExn *err); void (*add_symvar)(PgfLinBuilderIface *this, size_t d, size_t r, PgfExn *err); diff --git a/src/runtime/c/pgf/phrasetable.h b/src/runtime/c/pgf/phrasetable.h index fc0e9c544..f54b61bb2 100644 --- a/src/runtime/c/pgf/phrasetable.h +++ b/src/runtime/c/pgf/phrasetable.h @@ -17,7 +17,7 @@ struct PGF_INTERNAL_DECL PgfItem { } size_t size() { PgfItem *item = containerof(PgfItem,vars,this); - return (item->rule->vars != 0) ? item->rule->vars.size() : 0; + return (item->rule->ranges != 0) ? item->rule->ranges.size() : 0; } } vars; diff --git a/src/runtime/c/pgf/printer.cxx b/src/runtime/c/pgf/printer.cxx index dc927a5e2..8b740c5ac 100644 --- a/src/runtime/c/pgf/printer.cxx +++ b/src/runtime/c/pgf/printer.cxx @@ -499,15 +499,15 @@ void PgfPrinter::lparam(ref lparam) } } -void PgfPrinter::lvar_ranges(vector vars, size_t *values) +void PgfPrinter::lvar_ranges(vector ranges, size_t *values) { puts("{"); - for (size_t i = 0; i < vars.size(); i++) { + for (size_t i = 0; i < ranges.size(); i++) { if (i > 0) puts(", "); - lvar(vars[i].var); + lvar(i); if (values == NULL || values[i] == 0) - nprintf(32,"<%ld",vars[i].range); + nprintf(32,"<%ld",ranges[i]); else nprintf(32,"=%ld",values[i]-1); } @@ -611,8 +611,8 @@ void PgfPrinter::item(ref item) case PgfConcrLincat::tag: { ref lincat = ref::untagged(item->rule->container); - if (item->rule->vars != 0) { - lvar_ranges(item->rule->vars, &item->vars[0]); + if (item->rule->ranges != 0) { + lvar_ranges(item->rule->ranges, &item->vars[0]); puts(" "); } @@ -632,8 +632,8 @@ void PgfPrinter::item(ref item) ref lin = ref::untagged(item->rule->container); ref ty = lin->absfun->type; - if (item->rule->vars != 0) { - lvar_ranges(item->rule->vars, &item->vars[0]); + if (item->rule->ranges != 0) { + lvar_ranges(item->rule->ranges, &item->vars[0]); puts(" "); } diff --git a/src/runtime/c/pgf/printer.h b/src/runtime/c/pgf/printer.h index 54bcfd753..e637132b9 100644 --- a/src/runtime/c/pgf/printer.h +++ b/src/runtime/c/pgf/printer.h @@ -78,7 +78,7 @@ public: void parg(ref ty, ref parg); void lvar(size_t var); void lparam(ref lparam); - void lvar_ranges(vector vars, size_t *values); + void lvar_ranges(vector ranges, size_t *values); void symbol(PgfSymbol sym); void symbols(vector syms); void item(ref item); diff --git a/src/runtime/c/pgf/reader.cxx b/src/runtime/c/pgf/reader.cxx index 16ddef87b..cb1e5199a 100644 --- a/src/runtime/c/pgf/reader.cxx +++ b/src/runtime/c/pgf/reader.cxx @@ -497,10 +497,9 @@ ref PgfReader::read_lparam() return lparam; } -void PgfReader::read_variable_range(ref var_info) +void PgfReader::read_variable_range(ref var_range) { - var_info->var = read_int(); - var_info->range = read_int(); + *var_range = read_int(); } void PgfReader::read_parg(ref parg) @@ -508,33 +507,6 @@ void PgfReader::read_parg(ref parg) auto param = read_lparam(); parg->param = param; } -ref PgfReader::read_presult() -{ - vector vars = 0; - size_t n_vars = read_len(); - if (n_vars > 0) { - vars = vector::alloc(n_vars); - for (size_t i = 0; i < n_vars; i++) { - read_variable_range(vars.elem(i)); - } - } - - size_t i0 = read_int(); - size_t n_terms = read_len(); - ref res = - PgfDB::malloc(n_terms*sizeof(PgfLParam::terms[0])); - res->vars = vars; - res->param.i0 = i0; - res->param.n_terms = n_terms; - - for (size_t i = 0; i < n_terms; i++) { - res->param.terms[i].factor = read_int(); - res->param.terms[i].var = read_int(); - } - - return res; -} - template ref PgfReader::read_symbol_idx() { @@ -637,12 +609,12 @@ ref PgfReader::read_rule() size_t n_syms = read_len(); ref rule = inline_vector::alloc(&PgfConcrRule::syms, n_syms); - vector vars = read_null_vector(&PgfReader::read_variable_range); + vector ranges = read_null_vector(&PgfReader::read_variable_range); ref res = read_lparam(); vector> args = read_null_vector(&PgfReader::read_lparam); ref lin_idx = read_lparam(); - rule->vars = vars; + rule->ranges = ranges; rule->res = res; rule->container = container; rule->args = args; diff --git a/src/runtime/c/pgf/reader.h b/src/runtime/c/pgf/reader.h index 2167e7214..49a3a6310 100644 --- a/src/runtime/c/pgf/reader.h +++ b/src/runtime/c/pgf/reader.h @@ -77,9 +77,8 @@ public: ref read_lincat(); vector> read_lincat_fields(ref lincat); ref read_lparam(); - void read_variable_range(ref var_info); + void read_variable_range(ref var_range); void read_parg(ref parg); - ref read_presult(); PgfSymbol read_symbol(); ref read_lin(); ref read_printname(); @@ -103,7 +102,6 @@ private: void read_text2(ref> r) { auto text = read_text(); *r = text; } void read_lparam(ref> r) { auto lparam = read_lparam(); *r = lparam; } - void read_presult2(ref> r) { auto res = read_presult(); *r = res; } void read_rule2(ref> r) { auto rule = read_rule(); *r = rule; } void read_symbol2(ref r) { auto sym = read_symbol(); *r = sym; } diff --git a/src/runtime/c/pgf/writer.cxx b/src/runtime/c/pgf/writer.cxx index cfc05b1d6..f35ca4d75 100644 --- a/src/runtime/c/pgf/writer.cxx +++ b/src/runtime/c/pgf/writer.cxx @@ -290,10 +290,9 @@ void PgfWriter::write_abstract(ref abstract) this->abstract = 0; } -void PgfWriter::write_variable_range(ref var) +void PgfWriter::write_variable_range(ref var_range) { - write_int(var->var); - write_int(var->range); + write_int(*var_range); } void PgfWriter::write_lparam(ref lparam) @@ -310,7 +309,7 @@ void PgfWriter::write_rule(ref rule) { write_len(rule->syms.size()); - write_null_vector(rule->vars, &PgfWriter::write_variable_range); + write_null_vector(rule->ranges, &PgfWriter::write_variable_range); write_lparam(rule->res); write_null_vector(rule->args, &PgfWriter::write_lparam); diff --git a/src/runtime/c/pgf/writer.h b/src/runtime/c/pgf/writer.h index 5bb8bb881..aa7a96443 100644 --- a/src/runtime/c/pgf/writer.h +++ b/src/runtime/c/pgf/writer.h @@ -42,7 +42,7 @@ public: void write_lincat(ref lincat); void write_lincat_field(ref> field); - void write_variable_range(ref var); + void write_variable_range(ref var_range); void write_lparam(ref lparam); void write_symbol(PgfSymbol sym); void write_lin(ref lin); diff --git a/src/runtime/haskell/PGF2/Transactions.hsc b/src/runtime/haskell/PGF2/Transactions.hsc index 67f9e03d4..8b1c8a8a7 100644 --- a/src/runtime/haskell/PGF2/Transactions.hsc +++ b/src/runtime/haskell/PGF2/Transactions.hsc @@ -250,7 +250,7 @@ data Symbol | SymALL_CAPIT -- the special ALL_CAPIT token deriving (Eq,Ord,Show) -type Quantifiers = [(LVar,Int)] +type Quantifiers = [Int] data Rule = Rule Quantifiers LParam [LParam] LParam [Symbol] deriving (Eq,Ord,Show) @@ -320,8 +320,8 @@ withBuildLinIface rules f = do fun <- (#peek PgfLinBuilderIfaceVtbl, set_lin_idx) vtbl callLParam (callLinBuilder3 fun c_builder) lin_idx c_exn fun <- (#peek PgfLinBuilderIfaceVtbl, add_variable) vtbl - forM_ vars c_exn $ \(v,r) -> - callLinBuilder2 fun c_builder (fromIntegral v) (fromIntegral r) c_exn + forM_ vars c_exn $ \r -> + callLinBuilder1 fun c_builder (fromIntegral r) c_exn forM_ seq c_exn (addSymbol c_builder vtbl c_exn) fun <- (#peek PgfLinBuilderIfaceVtbl, end_rule) vtbl callLinBuilder0 fun c_builder c_exn