variables in rules are finally renamed

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
+    (subst,arg_params) <- mapAccumM params2int Map.empty arg_params
-    res_params <- params2int res_params
+    (subst,res_params) <- params2int subst res_params
-    lin_idx    <- params2int' r rs
+    (subst,lin_idx)    <- params2int' subst r rs
-    seq        <- flatten v
+    (subst,seq)        <- flatten subst v
-    qs <- quantifiers (arg_params++[res_params,lin_idx])
+    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 ->
+    quantifiers vars = GenM (\(Gl sgr _) k svs ms ->
-      k ((Set.toList . Set.fromList)
+      k [boundsOf sgr ms variable | (variable,v) <- sortOn snd vars]
-            [(variable,boundsOf sgr ms variable) | LParam _ terms <- params, (factor,variable) <- terms])
         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 subst (VStr s) = return (subst,[SymKS s])
-flatten (VSymCat d r rs) = do
+flatten subst (VSymCat d r rs) = do
-  lin_index <- params2int' r rs
+  (subst,lin_index) <- params2int' subst r rs
-  return [SymCat d lin_index]
+  return (subst,[SymCat d lin_index])
-flatten (VApp _ (m,id) [])
+flatten subst (VApp _ (m,id) [])
-  | m == cPredef && id == cBIND       = return [SymBIND]
+  | m == cPredef && id == cBIND       = return (subst,[SymBIND])
-  | m == cPredef && id == cSOFT_BIND  = return [SymSOFT_BIND]
+  | m == cPredef && id == cSOFT_BIND  = return (subst,[SymSOFT_BIND])
-  | m == cPredef && id == cSOFT_SPACE = return [SymSOFT_SPACE]
+  | m == cPredef && id == cSOFT_SPACE = return (subst,[SymSOFT_SPACE])
-  | m == cPredef && id == cNonExist   = return [SymNE]
+  | m == cPredef && id == cNonExist   = return (subst,[SymNE])
-  | m == cPredef && id == cCAPIT      = return [SymCAPIT]
+  | m == cPredef && id == cCAPIT      = return (subst,[SymCAPIT])
-  | m == cPredef && id == cALL_CAPIT  = return [SymALL_CAPIT]
+  | m == cPredef && id == cALL_CAPIT  = return (subst,[SymALL_CAPIT])
-flatten v0@(VAlts def alts) = do
+flatten subst v0@(VAlts def alts) = do
-  def <- flatten def
+  (subst,def) <- flatten subst def
-  alts <- forM alts $ \(alt,ps) -> do
+  (subst,alts) <- mapAccumM (\subst (alt,ps) -> do
-    alt <- flatten alt
+                                (subst,alt) <- flatten subst alt
-    ps  <- to_strs ps
+                                ps  <- to_strs ps
-    return (alt,ps)
+                                return (subst,(alt,ps)))
-  return [SymKP def alts]
+                            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 subst VEmpty     = return (subst,[])
-flatten (VC v1 v2) = do
+flatten subst (VC v1 v2) = do
-  s1 <- flatten v1
+  (subst,s1) <- flatten subst v1
-  s2 <- flatten v2
+  (subst,s2) <- flatten subst v2
-  return (s1++s2)
+  return (subst,s1++s2)
-flatten (VSusp i k vs) = do
+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 subst (apply g (k v) vs)
-flatten (VFV c vs) = do
+flatten subst (VFV c vs) = do
   v <- variants c (unvariants vs)
-  flatten v
+  flatten subst v
-flatten v = compileError ("Cannot evaluate" <+> ppValue Unqualified 0 v  <+> "to a string")
+flatten subst v = compileError ("Cannot evaluate" <+> ppValue Unqualified 0 v  <+> "to a string")
 
 
-params2int rs = do
+params2int subst rs = do
-  (r,rs,_) <- compute rs
+  (subst,r,rs,_) <- compute subst rs
-  return (LParam r (order rs))
+  return (subst,LParam r (order rs))
   where
-    compute []              = return (0,[],1)
+    compute subst []              = return (subst,0,[],1)
-    compute ((v,ty):params) = do
+    compute subst ((v,ty):params) = do
-      (r, rs, cnt ) <- param2int v ty
+      (subst, r, rs, cnt ) <- param2int subst v ty
-      (r',rs',cnt') <- compute params
+      (subst, r',rs',cnt') <- compute subst params
-      return (r*cnt'+r',combine cnt' rs rs',cnt*cnt')
+      return (subst, r*cnt'+r',combine cnt' rs rs',cnt*cnt')
 
-params2int' r0 rs = do
+params2int' subst r0 rs = do
-  (r,rs) <- compute rs
+  (subst,r,rs) <- compute subst rs
-  return (LParam (r0+r) (order rs))
+  return (subst,LParam (r0+r) (order rs))
   where
-    compute []                     = return (0,[])
+    compute subst []                     = return (subst,0,[])
-    compute ((cnt',(v,ty)):params) = do
+    compute subst ((cnt',(v,ty)):params) = do
-      (r, rs, cnt) <- param2int v ty
+      (subst, r, rs, cnt) <- param2int subst v ty
-      (r',rs')     <- compute params
+      (subst, r',rs')     <- compute subst params
-      return (r*cnt'+r',combine cnt' rs rs')
+      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 subst []                = return (subst,0,[],1)
-    compute ((lbl,_,ty):lbls) = do
+    compute subst ((lbl,_,ty):lbls) = do
       case lookup lbl as of
-        Just v   -> do (r, rs ,cnt ) <- param2int v ty
+        Just v   -> do (subst, r, rs ,cnt ) <- param2int subst v ty
-                       (r',rs',cnt') <- compute lbls
+                       (subst, r',rs',cnt') <- compute subst lbls
-                       return (r*cnt'+r',combine' cnt rs cnt' rs',cnt*cnt')
+                       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
+param2int subst (VApp _ q vs) ty = do
-  (r ,    ctxt,cnt ) <- getIdxCnt q
+  (      r ,    ctxt,cnt ) <- getIdxCnt q
-  (r',rs',     cnt') <- compute ctxt vs
+  (subst,r',rs',     cnt') <- compute subst ctxt vs
-  return (r+r',rs',cnt)
+  return (subst,r+r',rs',cnt)
   where
-    compute []              []     = return (0,[],1)
+    compute subst []              []     = return (subst,0,[],1)
-    compute ((_,_,ty):ctxt) (v:vs) = do
+    compute subst ((_,_,ty):ctxt) (v:vs) = do
-      (r, rs ,cnt ) <- param2int v ty
+      (subst, r, rs ,cnt ) <- param2int subst v ty
-      (r',rs',cnt') <- compute ctxt vs
+      (subst, r',rs',cnt') <- compute subst ctxt vs
-      return (r*cnt'+r',combine' cnt rs cnt' rs',cnt*cnt')
+      return (subst,r*cnt'+r',combine' cnt rs cnt' rs',cnt*cnt')
-param2int (VInt n) ty
+param2int subst (VInt n) ty
-  | Just max <- isTypeInts ty= return (fromIntegral n,[],fromIntegral max+1)
+  | Just max <- isTypeInts ty= return (subst,fromIntegral n,[],fromIntegral max+1)
-param2int (VMeta i _) ty = do
+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)
+                         case Map.lookup i subst of
-    Bound _ v      -> param2int v ty
+                           Just v  -> return (subst,0,[(1,v)],count)
-param2int (VSusp i k vs) ty = do
+                           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 subst (apply g (k v) vs) ty
-param2int (VFV c vs) ty = do
+param2int subst (VFV c vs) ty = do
   v <- variants c (unvariants vs)
-  param2int v ty
+  param2int subst v ty
-param2int v ty = compileError ("the parameter:" <+> ppValue Unqualified 0 v $$
+param2int subst v ty = compileError ("the parameter:" <+> ppValue Unqualified 0 v $$
-                               "cannot be evaluated at compile time.")
+                                     "cannot be evaluated at compile time.")
 
 combine' 1   rs 1    rs' = []
 combine' 1   rs cnt' rs' = rs'

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)

src/runtime/c/pgf/data.cxx

@@ -64,13 +64,6 @@ void PgfLParam::release(ref<PgfLParam> param)
     PgfDB::free(param, param->n_terms*sizeof(param->terms[0]));
 }
 
-void PgfPResult::release(ref<PgfPResult> res)
-{
-    if (res->vars != 0)
-        vector<PgfVariableRange>::release(res->vars);
-    PgfDB::free(res, res->param.n_terms*sizeof(res->param.terms[0]));
-}
-
 static void symbols_release(vector<PgfSymbol> syms)
 {
 	for (PgfSymbol sym : syms) {
@@ -122,7 +115,7 @@ static void symbols_release(vector<PgfSymbol> syms)
 
 void PgfConcrRule::release(ref<PgfConcrRule> rule)
 {
-    vector<PgfVariableRange>::release(rule->vars);
+    vector<size_t>::release(rule->ranges);
 
     PgfLParam::release(rule->res);
 

src/runtime/c/pgf/data.h

@@ -146,13 +146,6 @@ struct PGF_INTERNAL_DECL PgfPArg {
     ref<PgfLParam> param;
 };
 
-struct PGF_INTERNAL_DECL PgfPResult {
-    vector<PgfVariableRange> vars; 
-    PgfLParam param;
-
-    static void release(ref<PgfPResult> res);
-};
-
 typedef object PgfSymbol;
 
 struct PGF_INTERNAL_DECL PgfSequenceBackref {
@@ -222,7 +215,7 @@ struct PGF_INTERNAL_DECL PgfSymbolALLCAPIT {
 };
 
 struct PGF_INTERNAL_DECL PgfConcrRule {
-    vector<PgfVariableRange> vars;
+    vector<size_t> ranges;
     ref<PgfLParam> res;
     object container;
     vector<ref<PgfLParam>> args;

src/runtime/c/pgf/linearizer.cxx

@@ -10,31 +10,21 @@ bool PgfLinearizer::Item::instantiate(ref<PgfLParam> 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 (vars[t.var] > 0) {
-            if (rule->vars[k].var == t.var) {
+            if (value < vars[t.var]-1)
-                if (vars[k] > 0) {
+                return false;
-                    if (value < vars[k]-1)
+            value -= vars[t.var]-1;
-                        return false;
-                    value -= vars[k]-1;
-                }
-                break;
-            }
         }
     }
 
     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 (vars[t.var] == 0) {
-            if (rule->vars[k].var == t.var) {
+            size_t v_val = value / t.factor;
-                if (vars[k] == 0) {
+            if (v_val >= rule->ranges[t.var])
-                    size_t v_val = value / t.factor;
+                return false;
-                    if (v_val >= rule->vars[k].range)
+            vars[t.var] = v_val + 1;
-                        return false;
+            value %= t.factor;
-                    vars[k] = v_val + 1;
-                    value %= t.factor;
-                }
-                break;
-            }
         }
     }
 
@@ -45,12 +35,7 @@ size_t PgfLinearizer::Item::eval(ref<PgfLParam> 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++) {
+        value += lparam->terms[i].factor * (vars[lparam->terms[i].var]-1);
-            if (lparam->terms[i].var == rule->vars[j].var) {
-                value += lparam->terms[i].factor * (vars[j]-1);
-                break;
-            }
-        }
     }
     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;
                 }

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<PgfConcrRule> 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;

src/runtime/c/pgf/parser.cxx

@@ -332,17 +332,12 @@ interval_t PgfAbstractParser::Item::interval(ref<PgfLParam> 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 (vars[var] == 0) {
-            if (rule->vars[j].var == var) {
+            interval.second += lparam->terms[i].factor * (rule->ranges[var]-1);
-                if (vars[j] == 0) {
+        } else {
-                    interval.second += lparam->terms[i].factor * (rule->vars[j].range-1);
+            size_t value = lparam->terms[i].factor * (vars[var]-1);
-                } else {
+            interval.first  += value;
-                    size_t value = lparam->terms[i].factor * (vars[j]-1);
+            interval.second += value;
-                    interval.first  += value;
-                    interval.second += value;
-                }
-                break;
-            }
         }
     }
     return interval;
@@ -353,25 +348,15 @@ bool PgfAbstractParser::Item::instantiate(ref<PgfLParam> 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->vars[lparam1->terms[i].var] > 0) {
-            if (this->rule->vars[k].var == lparam1->terms[i].var) {
+            i01 += lparam1->terms[i].factor * (this->vars[lparam1->terms[i].var]-1);
-                if (this->vars[k] > 0) {
-                    i01 += lparam1->terms[i].factor * (this->vars[k]-1);
-                }
-                break;
-            }
         }
     }
 
     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 (values[lparam2->terms[i].var] > 0) {
-            if (rule->vars[k].var == lparam2->terms[i].var) {
+            i02 += lparam2->terms[i].factor * (values[lparam2->terms[i].var]-1);
-                if (values[k] > 0) {
-                    i02 += lparam2->terms[i].factor * (values[k]-1);
-                }
-                break;
-            }
         }
     }
 
@@ -386,103 +371,77 @@ bool PgfAbstractParser::Item::instantiate(ref<PgfLParam> lparam1,
     size_t i1 = 0, i2 = 0;
     while (i1 < lparam1->n_terms || i2 < lparam2->n_terms) {
         size_t scale1  = 0;
-        size_t factor1 = 0;
+        term t1 = {0,0};
-        size_t var1    = 0;
-        size_t k1      = 0;
         if (i1 < lparam1->n_terms) {
-            factor1 = lparam1->terms[i1].factor;
+            t1 = lparam1->terms[i1];
-            var1    = lparam1->terms[i1].var;
+            if (this->vars[t1.var] > 0) {
-            for (k1 = 0; k1 < this->vars.size(); k1++) {
-                if (this->rule->vars[k1].var == var1)
-                    break;
-            }
-            if (this->vars[k1] > 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;
+        term t2 = {0,0};
-        size_t var2    = 0;
-        size_t k2      = 0;
         if (i2 < lparam2->n_terms) {
-            factor2 = lparam2->terms[i2].factor;
+            t2 = lparam2->terms[i2];
-            var2    = lparam2->terms[i2].var;
+            if (values[t2.var] > 0) {
-            for (k2 = 0; k2 < rule->vars.size(); k2++) {
-                if (rule->vars[k2].var == var2)
-                    break;
-            }
-            if (values[k2] > 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;
+                t2 = lparam2->terms[i2];
-                size_t f = factor2 / factor1;
+                size_t f = t2.factor / t1.factor;
                 if (f == 0)
                     break;
 
-                var2 = lparam2->terms[i2].var;
+                if (values[t2.var] == 0) {
-                for (k2 = 0; k2 < rule->vars.size(); k2++) {
+                    max += f * (rule->ranges[t2.var]-1);
-                    if (rule->vars[k2].var == var2) {
-                        if (values[k2] == 0) {
-                            max += f * (rule->vars[k2].range-1);
-                        }
-                        break;
-                    }
                 }
                 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)
+                if (this->vars[t1.var] == 0)
-                    this->vars[k1] = min+1;
+                    this->vars[t1.var] = min+1;
-                else if (this->vars[k1] != 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;
+                t1 = lparam1->terms[i1];
-                size_t f = factor1 / factor2;
+                size_t f = t1.factor / t2.factor;
                 if (f == 0)
                     break;
 
-                var1 = lparam1->terms[i1].var;
+                if (values[t1.var] == 0) {
-                for (k1 = 0; k1 < rule->vars.size(); k1++) {
+                    max += f * (rule->ranges[t1.var]-1);
-                    if (rule->vars[k1].var == var1) {
-                        if (values[k1] == 0) {
-                            max += f * (rule->vars[k1].range-1);
-                        }
-                        break;
-                    }
                 }
                 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<ref<PgfConcrLincat>, bool> visited;
                 //if (!td_reachable(state, phrasetable->items[i], visited))

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<PgfConcrRule> 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;

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<PgfConcrRule> rule = lincat->rules[i];
-    if (rule->vars != 0) {
+    if (rule->ranges != 0) {
-        printer.lvar_ranges(rule->vars, NULL);
+        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<PgfConcrRule> rule = lincat->rules[lincat->n_lindefs+i];
 
-    if (rule->vars != 0) {
+    if (rule->ranges != 0) {
-        printer.lvar_ranges(rule->vars, NULL);
+        printer.lvar_ranges(rule->ranges, NULL);
         printer.puts(" ");
     }
 
@@ -1178,8 +1178,8 @@ PgfText *pgf_print_lin_internal(object o, size_t i)
     ref<PgfConcrRule> rule = lin->rules[i];
     ref<PgfDTyp> ty = lin->absfun->type;
 
-    if (rule->vars != 0) {
+    if (rule->ranges != 0) {
-        printer.lvar_ranges(rule->vars, NULL);
+        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<PgfVariableRange> vars = 
+            vector<size_t> ranges = 
-                (n_vars > 0) ? vector<PgfVariableRange>::alloc(n_vars) : 0;
+                (n_vars > 0) ? vector<size_t>::alloc(n_vars) : 0;
             vector<ref<PgfLParam>> args =
                 (n_args > 0) ? vector<ref<PgfLParam>>::alloc(n_args) : 0;
 
             ref<PgfConcrRule> rule = inline_vector<PgfSymbol>::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<PgfConcrRule> 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<PgfVariableRange> var_range =
+            rule->ranges[var_index] = range;
-                rule->vars.elem(var_index);
-            var_range->var   = var;
-            var_range->range = range;
-
             var_index++;
         } PGF_API_END
     }

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);

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;
 

src/runtime/c/pgf/printer.cxx

@@ -499,15 +499,15 @@ void PgfPrinter::lparam(ref<PgfLParam> lparam)
     }
 }
 
-void PgfPrinter::lvar_ranges(vector<PgfVariableRange> vars, size_t *values)
+void PgfPrinter::lvar_ranges(vector<size_t> 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<PgfItem> item)
     case PgfConcrLincat::tag: {
         ref<PgfConcrLincat> lincat = ref<PgfConcrLincat>::untagged(item->rule->container);
 
-        if (item->rule->vars != 0) {
+        if (item->rule->ranges != 0) {
-            lvar_ranges(item->rule->vars, &item->vars[0]);
+            lvar_ranges(item->rule->ranges, &item->vars[0]);
             puts(" ");
         }
 
@@ -632,8 +632,8 @@ void PgfPrinter::item(ref<PgfItem> item)
         ref<PgfConcrLin> lin = ref<PgfConcrLin>::untagged(item->rule->container);
         ref<PgfDTyp> ty = lin->absfun->type;
 
-        if (item->rule->vars != 0) {
+        if (item->rule->ranges != 0) {
-            lvar_ranges(item->rule->vars, &item->vars[0]);
+            lvar_ranges(item->rule->ranges, &item->vars[0]);
             puts(" ");
         }
 

src/runtime/c/pgf/printer.h

@@ -78,7 +78,7 @@ public:
     void parg(ref<PgfDTyp> ty, ref<PgfPArg> parg);
     void lvar(size_t var);
     void lparam(ref<PgfLParam> lparam);
-    void lvar_ranges(vector<PgfVariableRange> vars, size_t *values);
+    void lvar_ranges(vector<size_t> ranges, size_t *values);
     void symbol(PgfSymbol sym);
     void symbols(vector<PgfSymbol> syms);
     void item(ref<PgfItem> item);

src/runtime/c/pgf/reader.cxx

@@ -497,10 +497,9 @@ ref<PgfLParam> PgfReader::read_lparam()
     return lparam;
 }
 
-void PgfReader::read_variable_range(ref<PgfVariableRange> var_info)
+void PgfReader::read_variable_range(ref<size_t> var_range)
 {
-    var_info->var   = read_int();
+    *var_range = read_int();
-    var_info->range = read_int();
 }
 
 void PgfReader::read_parg(ref<PgfPArg> parg)
@@ -508,33 +507,6 @@ void PgfReader::read_parg(ref<PgfPArg> parg)
     auto param = read_lparam(); parg->param = param;
 }
 
-ref<PgfPResult> PgfReader::read_presult()
-{
-    vector<PgfVariableRange> vars = 0;
-    size_t n_vars = read_len();
-    if (n_vars > 0) {
-        vars = vector<PgfVariableRange>::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<PgfPResult> res =
-        PgfDB::malloc<PgfPResult>(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<class I>
 ref<I> PgfReader::read_symbol_idx()
 {
@@ -637,12 +609,12 @@ ref<PgfConcrRule> PgfReader::read_rule()
     size_t n_syms = read_len();
     ref<PgfConcrRule> rule = inline_vector<PgfSymbol>::alloc(&PgfConcrRule::syms, n_syms);
 
-    vector<PgfVariableRange> vars = read_null_vector(&PgfReader::read_variable_range);
+    vector<size_t> ranges = read_null_vector(&PgfReader::read_variable_range);
     ref<PgfLParam> res = read_lparam();
     vector<ref<PgfLParam>> args = read_null_vector(&PgfReader::read_lparam);
     ref<PgfLParam> lin_idx = read_lparam();
 
-    rule->vars = vars;
+    rule->ranges = ranges;
     rule->res  = res;
     rule->container = container;
     rule->args = args;

src/runtime/c/pgf/reader.h

@@ -77,9 +77,8 @@ public:
     ref<PgfConcrLincat> read_lincat();
     vector<ref<PgfText>> read_lincat_fields(ref<PgfConcrLincat> lincat);
     ref<PgfLParam> read_lparam();
-    void read_variable_range(ref<PgfVariableRange> var_info);
+    void read_variable_range(ref<size_t> var_range);
     void read_parg(ref<PgfPArg> parg);
-    ref<PgfPResult> read_presult();
     PgfSymbol read_symbol();
     ref<PgfConcrLin> read_lin();
     ref<PgfConcrPrintname> read_printname();
@@ -103,7 +102,6 @@ private:
 
     void read_text2(ref<ref<PgfText>> r) { auto text = read_text(); *r = text; }
     void read_lparam(ref<ref<PgfLParam>> r) { auto lparam = read_lparam(); *r = lparam; }
-    void read_presult2(ref<ref<PgfPResult>> r) { auto res = read_presult(); *r = res; }
     void read_rule2(ref<ref<PgfConcrRule>> r) { auto rule = read_rule(); *r = rule; }
     void read_symbol2(ref<PgfSymbol> r) { auto sym = read_symbol(); *r = sym; }
 

src/runtime/c/pgf/writer.cxx

@@ -290,10 +290,9 @@ void PgfWriter::write_abstract(ref<PgfAbstr> abstract)
     this->abstract = 0;
 }
 
-void PgfWriter::write_variable_range(ref<PgfVariableRange> var)
+void PgfWriter::write_variable_range(ref<size_t> var_range)
 {
-    write_int(var->var);
+    write_int(*var_range);
-    write_int(var->range);
 }
 
 void PgfWriter::write_lparam(ref<PgfLParam> lparam)
@@ -310,7 +309,7 @@ void PgfWriter::write_rule(ref<PgfConcrRule> 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);
 

src/runtime/c/pgf/writer.h

@@ -42,7 +42,7 @@ public:
 
     void write_lincat(ref<PgfConcrLincat> lincat);
     void write_lincat_field(ref<ref<PgfText>> field);
-    void write_variable_range(ref<PgfVariableRange> var);
+    void write_variable_range(ref<size_t> var_range);
     void write_lparam(ref<PgfLParam> lparam);
     void write_symbol(PgfSymbol sym);
     void write_lin(ref<PgfConcrLin> lin);

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) ->
+        forM_ vars c_exn $ \r ->
-          callLinBuilder2 fun c_builder (fromIntegral v) (fromIntegral r) c_exn
+          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