summaryrefslogtreecommitdiff
path: root/src/GF/Compile
diff options
context:
space:
mode:
Diffstat (limited to 'src/GF/Compile')
-rw-r--r--src/GF/Compile/BackOpt.hs6
-rw-r--r--src/GF/Compile/CheckGrammar.hs62
-rw-r--r--src/GF/Compile/Coding.hs6
-rw-r--r--src/GF/Compile/Extend.hs140
-rw-r--r--src/GF/Compile/GrammarToGFCC.hs38
-rw-r--r--src/GF/Compile/Optimize.hs41
-rw-r--r--src/GF/Compile/OptimizeGF.hs26
-rw-r--r--src/GF/Compile/Rebuild.hs101
-rw-r--r--src/GF/Compile/Refresh.hs12
-rw-r--r--src/GF/Compile/Rename.hs16
-rw-r--r--src/GF/Compile/Update.hs270
11 files changed, 277 insertions, 441 deletions
diff --git a/src/GF/Compile/BackOpt.hs b/src/GF/Compile/BackOpt.hs
index 484b1f1f0..529a74334 100644
--- a/src/GF/Compile/BackOpt.hs
+++ b/src/GF/Compile/BackOpt.hs
@@ -36,9 +36,9 @@ shareModule :: OptSpec -> SourceModule -> SourceModule
shareModule opt (i,mo) = (i,M.replaceJudgements mo (mapTree (shareInfo opt) (M.jments mo)))
shareInfo :: OptSpec -> (Ident, Info) -> Info
-shareInfo opt (c, CncCat ty (Yes t) m) = CncCat ty (Yes (shareOptim opt c t)) m
-shareInfo opt (c, CncFun kxs (Yes t) m) = CncFun kxs (Yes (shareOptim opt c t)) m
-shareInfo opt (c, ResOper ty (Yes t)) = ResOper ty (Yes (shareOptim opt c t))
+shareInfo opt (c, CncCat ty (Just t) m) = CncCat ty (Just (shareOptim opt c t)) m
+shareInfo opt (c, CncFun kxs (Just t) m) = CncFun kxs (Just (shareOptim opt c t)) m
+shareInfo opt (c, ResOper ty (Just t)) = ResOper ty (Just (shareOptim opt c t))
shareInfo _ (_,i) = i
-- the function putting together optimizations
diff --git a/src/GF/Compile/CheckGrammar.hs b/src/GF/Compile/CheckGrammar.hs
index 43b186a7c..552bd4177 100644
--- a/src/GF/Compile/CheckGrammar.hs
+++ b/src/GF/Compile/CheckGrammar.hs
@@ -121,19 +121,19 @@ checkAbsInfo ::
checkAbsInfo st m mo (c,info) = do
---- checkReservedId c
case info of
- AbsCat (Yes cont) _ -> mkCheck "category" $
+ AbsCat (Just cont) _ -> mkCheck "category" $
checkContext st cont ---- also cstrs
- AbsFun (Yes typ0) md -> do
+ AbsFun (Just typ0) md -> do
typ <- compAbsTyp [] typ0 -- to calculate let definitions
mkCheck "type of function" $ checkTyp st typ
md' <- case md of
- Yes d -> do
+ Just d -> do
let d' = elimTables d
---- mkCheckWarn "definition of function" $ checkEquation st (m,c) d'
mkCheck "definition of function" $ checkEquation st (m,c) d'
- return $ Yes d'
+ return $ Just d'
_ -> return md
- return $ (c,AbsFun (Yes typ) md')
+ return $ (c,AbsFun (Just typ) md')
_ -> return (c,info)
where
mkCheck cat ss = case ss of
@@ -195,27 +195,27 @@ checkCompleteGrammar abs cnc = do
CncCat _ _ _ -> True
_ -> False
checkOne js i@(c,info) = case info of
- AbsFun (Yes _) _ -> case lookupIdent c js of
+ AbsFun (Just _) _ -> case lookupIdent c js of
Ok _ -> return js
_ -> do
checkWarn $ "WARNING: no linearization of" +++ prt c
return js
- AbsCat (Yes _) _ -> case lookupIdent c js of
+ AbsCat (Just _) _ -> case lookupIdent c js of
Ok (AnyInd _ _) -> return js
- Ok (CncCat (Yes _) _ _) -> return js
+ Ok (CncCat (Just _) _ _) -> return js
Ok (CncCat _ mt mp) -> do
checkWarn $
"Warning: no linearization type for" +++ prt c ++
", inserting default {s : Str}"
- return $ updateTree (c,CncCat (Yes defLinType) mt mp) js
+ return $ updateTree (c,CncCat (Just defLinType) mt mp) js
_ -> do
checkWarn $
"Warning: no linearization type for" +++ prt c ++
", inserting default {s : Str}"
- return $ updateTree (c,CncCat (Yes defLinType) nope nope) js
+ return $ updateTree (c,CncCat (Just defLinType) Nothing Nothing) js
_ -> return js
--- | General Principle: only Yes-values are checked.
+-- | General Principle: only Just-values are checked.
-- A May-value has always been checked in its origin module.
checkResInfo :: SourceGrammar -> Ident -> SourceModInfo -> (Ident,Info) -> Check (Ident,Info)
checkResInfo gr mo mm (c,info) = do
@@ -223,17 +223,15 @@ checkResInfo gr mo mm (c,info) = do
case info of
ResOper pty pde -> chIn "operation" $ do
(pty', pde') <- case (pty,pde) of
- (Yes ty, Yes de) -> do
+ (Just ty, Just de) -> do
ty' <- check ty typeType >>= comp . fst
(de',_) <- check de ty'
- return (Yes ty', Yes de')
- (_, Yes de) -> do
+ return (Just ty', Just de')
+ (_ , Just de) -> do
(de',ty') <- infer de
- return (Yes ty', Yes de')
- (_,Nope) -> do
+ return (Just ty', Just de')
+ (_ , Nothing) -> do
raise "No definition given to oper"
- --return (pty,pde)
- _ -> return (pty, pde) --- other cases are uninteresting
return (c, ResOper pty' pde')
ResOverload os tysts -> chIn "overloading" $ do
@@ -248,11 +246,11 @@ checkResInfo gr mo mm (c,info) = do
sort [t : map snd xs | (x,_) <- tysts2, Ok (xs,t) <- [typeFormCnc x]]
return (c,ResOverload os [(y,x) | (x,y) <- tysts'])
- ResParam (Yes (pcs,_)) -> chIn "parameter type" $ do
+ ResParam (Just (pcs,_)) -> chIn "parameter type" $ do
---- mapM ((mapM (computeLType gr . snd)) . snd) pcs
mapM_ ((mapM_ (checkIfParType gr . snd)) . snd) pcs
ts <- checkErr $ lookupParamValues gr mo c
- return (c,ResParam (Yes (pcs, Just ts)))
+ return (c,ResParam (Just (pcs, Just ts)))
_ -> return (c,info)
where
@@ -277,26 +275,26 @@ checkCncInfo gr m mo (a,abs) (c,info) = do
checkReservedId c
case info of
- CncFun _ (Yes trm) mpr -> chIn "linearization of" $ do
+ CncFun _ (Just trm) mpr -> chIn "linearization of" $ do
typ <- checkErr $ lookupFunType gr a c
cat0 <- checkErr $ valCat typ
(cont,val) <- linTypeOfType gr m typ -- creates arg vars
(trm',_) <- check trm (mkFunType (map snd cont) val) -- erases arg vars
checkPrintname gr mpr
cat <- return $ snd cat0
- return (c, CncFun (Just (cat,(cont,val))) (Yes trm') mpr)
+ return (c, CncFun (Just (cat,(cont,val))) (Just trm') mpr)
-- cat for cf, typ for pe
- CncCat (Yes typ) mdef mpr -> chIn "linearization type of" $ do
+ CncCat (Just typ) mdef mpr -> chIn "linearization type of" $ do
checkErr $ lookupCatContext gr a c
typ' <- checkIfLinType gr typ
mdef' <- case mdef of
- Yes def -> do
+ Just def -> do
(def',_) <- checkLType gr def (mkFunType [typeStr] typ)
- return $ Yes def'
+ return $ Just def'
_ -> return mdef
checkPrintname gr mpr
- return (c,CncCat (Yes typ') mdef' mpr)
+ return (c,CncCat (Just typ') mdef' mpr)
_ -> checkResInfo gr m mo (c,info)
@@ -400,9 +398,9 @@ computeLType gr t = do
_ -> composOp comp ty
-checkPrintname :: SourceGrammar -> Perh Term -> Check ()
-checkPrintname st (Yes t) = checkLType st t typeStr >> return ()
-checkPrintname _ _ = return ()
+checkPrintname :: SourceGrammar -> Maybe Term -> Check ()
+checkPrintname st (Just t) = checkLType st t typeStr >> return ()
+checkPrintname _ _ = return ()
-- | for grammars obtained otherwise than by parsing ---- update!!
checkReservedId :: Ident -> Check ()
@@ -1105,15 +1103,15 @@ allDependencies ism b =
Q n c | ism n -> [c]
QC n c | ism n -> [c]
_ -> collectOp opersIn t
- opty (Yes ty) = opersIn ty
+ opty (Just ty) = opersIn ty
opty _ = []
pts i = case i of
ResOper pty pt -> [pty,pt]
- ResParam (Yes (ps,_)) -> [Yes t | (_,cont) <- ps, (_,t) <- cont]
+ ResParam (Just (ps,_)) -> [Just t | (_,cont) <- ps, (_,t) <- cont]
CncCat pty _ _ -> [pty]
CncFun _ pt _ -> [pt] ---- (Maybe (Ident,(Context,Type))
AbsFun pty ptr -> [pty] --- ptr is def, which can be mutual
- AbsCat (Yes co) _ -> [Yes ty | (_,ty) <- co]
+ AbsCat (Just co) _ -> [Just ty | (_,ty) <- co]
_ -> []
topoSortOpers :: [(Ident,[Ident])] -> Err [Ident]
diff --git a/src/GF/Compile/Coding.hs b/src/GF/Compile/Coding.hs
index 088f7b8e8..511ceddef 100644
--- a/src/GF/Compile/Coding.hs
+++ b/src/GF/Compile/Coding.hs
@@ -24,10 +24,10 @@ codeSourceModule :: (String -> String) -> SourceModule -> SourceModule
codeSourceModule co (id,mo) = (id,replaceJudgements mo (mapTree codj (jments mo)))
where
codj (c,info) = case info of
- ResOper pty pt -> ResOper (mapP codt pty) (mapP codt pt)
+ ResOper pty pt -> ResOper (fmap codt pty) (fmap codt pt)
ResOverload es tyts -> ResOverload es [(codt ty,codt t) | (ty,t) <- tyts]
- CncCat pty pt mpr -> CncCat pty (mapP codt pt) (mapP codt mpr)
- CncFun mty pt mpr -> CncFun mty (mapP codt pt) (mapP codt mpr)
+ CncCat pty pt mpr -> CncCat pty (fmap codt pt) (fmap codt mpr)
+ CncFun mty pt mpr -> CncFun mty (fmap codt pt) (fmap codt mpr)
_ -> info
codt t = case t of
K s -> K (co s)
diff --git a/src/GF/Compile/Extend.hs b/src/GF/Compile/Extend.hs
deleted file mode 100644
index bb9310041..000000000
--- a/src/GF/Compile/Extend.hs
+++ /dev/null
@@ -1,140 +0,0 @@
-----------------------------------------------------------------------
--- |
--- Module : Extend
--- Maintainer : AR
--- Stability : (stable)
--- Portability : (portable)
---
--- > CVS $Date: 2005/05/30 21:08:14 $
--- > CVS $Author: aarne $
--- > CVS $Revision: 1.18 $
---
--- AR 14\/5\/2003 -- 11\/11
---
--- The top-level function 'extendModule'
--- extends a module symbol table by indirections to the module it extends
------------------------------------------------------------------------------
-
-module GF.Compile.Extend (extendModule, extendMod
- ) where
-
-import GF.Grammar.Grammar
-import GF.Infra.Ident
-import GF.Grammar.PrGrammar
-import GF.Infra.Modules
-import GF.Compile.Update
-import GF.Grammar.Macros
-import GF.Data.Operations
-
-import Control.Monad
-import Data.List(nub)
-
-extendModule :: [SourceModule] -> SourceModule -> Err SourceModule
-extendModule ms (name,m)
- ---- Just to allow inheritance in incomplete concrete (which are not
- ---- compiled anyway), extensions are not built for them.
- ---- Should be replaced by real control. AR 4/2/2005
- | mstatus m == MSIncomplete && isModCnc m = return (name,m)
- | otherwise = do m' <- foldM extOne m (extend m)
- return (name,m')
- where
- extOne mo (n,cond) = do
- m0 <- lookupModule (MGrammar ms) n
-
- -- test that the module types match, and find out if the old is complete
- testErr (sameMType (mtype m) (mtype mo))
- ("illegal extension type to module" +++ prt name)
-
- let isCompl = isCompleteModule m0
-
- -- build extension in a way depending on whether the old module is complete
- js1 <- extendMod isCompl (n, isInherited cond) name (jments m0) (jments mo)
-
- -- if incomplete, throw away extension information
- return $
- if isCompl
- then mo {jments = js1}
- else mo {extend = filter ((/=n) . fst) (extend mo)
- ,mexdeps= nub (n : mexdeps mo)
- ,jments = js1
- }
-
--- | When extending a complete module: new information is inserted,
--- and the process is interrupted if unification fails.
--- If the extended module is incomplete, its judgements are just copied.
-extendMod :: Bool -> (Ident,Ident -> Bool) -> Ident ->
- BinTree Ident Info -> BinTree Ident Info ->
- Err (BinTree Ident Info)
-extendMod isCompl (name,cond) base old new = foldM try new $ tree2list old where
- try t i@(c,_) | not (cond c) = return t
- try t i@(c,_) = errIn ("constant" +++ prt c) $
- tryInsert (extendAnyInfo isCompl name base) indirIf t i
- indirIf = if isCompl then indirInfo name else id
-
-indirInfo :: Ident -> Info -> Info
-indirInfo n info = AnyInd b n' where
- (b,n') = case info of
- ResValue _ -> (True,n)
- ResParam _ -> (True,n)
- AbsFun _ (Yes EData) -> (True,n)
- AnyInd b k -> (b,k)
- _ -> (False,n) ---- canonical in Abs
-
-perhIndir :: Ident -> Perh a -> Perh a
-perhIndir n p = case p of
- Yes _ -> May n
- _ -> p
-
-extendAnyInfo :: Bool -> Ident -> Ident -> Info -> Info -> Err Info
-extendAnyInfo isc n o i j =
- errIn ("building extension for" +++ prt n +++ "in" +++ prt o) $ case (i,j) of
- (AbsCat mc1 mf1, AbsCat mc2 mf2) ->
- liftM2 AbsCat (updn isc n mc1 mc2) (updn isc n mf1 mf2) --- add cstrs
- (AbsFun mt1 md1, AbsFun mt2 md2) ->
- liftM2 AbsFun (updn isc n mt1 mt2) (updn isc n md1 md2) --- add defs
- (ResParam mt1, ResParam mt2) ->
- liftM ResParam $ updn isc n mt1 mt2
- (ResValue mt1, ResValue mt2) ->
- liftM ResValue $ updn isc n mt1 mt2
- (_, ResOverload ms t) | elem n ms ->
- return $ ResOverload ms t
- (ResOper mt1 m1, ResOper mt2 m2) -> ---- extendResOper n mt1 m1 mt2 m2
- liftM2 ResOper (updn isc n mt1 mt2) (updn isc n m1 m2)
- (CncCat mc1 mf1 mp1, CncCat mc2 mf2 mp2) ->
- liftM3 CncCat (updn isc n mc1 mc2) (updn isc n mf1 mf2) (updn isc n mp1 mp2)
- (CncFun m mt1 md1, CncFun _ mt2 md2) ->
- liftM2 (CncFun m) (updn isc n mt1 mt2) (updn isc n md1 md2)
-
----- (AnyInd _ _, ResOper _ _) -> return j ----
-
- (AnyInd b1 m1, AnyInd b2 m2) -> do
- testErr (b1 == b2) "inconsistent indirection status"
----- commented out as work-around for a spurious problem in
----- TestResourceFre; should look at building of completion. 17/11/2004
- testErr (m1 == m2) $
- "different sources of indirection: " +++ show m1 +++ show m2
- return i
-
- _ -> Bad $ "cannot unify information in" ++++ show i ++++ "and" ++++ show j
-
---- where
-
-updn isc n = if isc then (updatePerhaps n) else (updatePerhapsHard n)
-updc isc n = if True then (updatePerhaps n) else (updatePerhapsHard n)
-
-
-
-{- ---- no more needed: this is done in Rebuild
--- opers declared in an interface and defined in an instance are a special case
-
-extendResOper n mt1 m1 mt2 m2 = case (m1,m2) of
- (Nope,_) -> return $ ResOper (strip mt1) m2
- _ -> liftM2 ResOper (updatePerhaps n mt1 mt2) (updatePerhaps n m1 m2)
- where
- strip (Yes t) = Yes $ strp t
- strip m = m
- strp t = case t of
- Q _ c -> Vr c
- QC _ c -> Vr c
- _ -> composSafeOp strp t
--}
diff --git a/src/GF/Compile/GrammarToGFCC.hs b/src/GF/Compile/GrammarToGFCC.hs
index e57191de2..272692be7 100644
--- a/src/GF/Compile/GrammarToGFCC.hs
+++ b/src/GF/Compile/GrammarToGFCC.hs
@@ -69,15 +69,15 @@ canon2gfcc opts pars cgr@(M.MGrammar ((a,abm):cms)) =
gflags = Map.empty
aflags = Map.fromList [(mkCId f,x) | (f,x) <- optionsPGF (M.flags abm)]
mkDef pty = case pty of
- Yes t -> mkExp t
- _ -> CM.primNotion
+ Just t -> mkExp t
+ _ -> CM.primNotion
-- concretes
lfuns = [(f', (mkType ty, mkDef pty)) |
- (f,AbsFun (Yes ty) pty) <- tree2list (M.jments abm), let f' = i2i f]
+ (f,AbsFun (Just ty) pty) <- tree2list (M.jments abm), let f' = i2i f]
funs = Map.fromAscList lfuns
lcats = [(i2i c, mkContext cont) |
- (c,AbsCat (Yes cont) _) <- tree2list (M.jments abm)]
+ (c,AbsCat (Just cont) _) <- tree2list (M.jments abm)]
cats = Map.fromAscList lcats
catfuns = Map.fromList
[(cat,[f | (f, (C.DTyp _ c _,_)) <- lfuns, c==cat]) | (cat,_) <- lcats]
@@ -95,18 +95,18 @@ canon2gfcc opts pars cgr@(M.MGrammar ((a,abm):cms)) =
---- then (trace "decode" D.convertStringsInTerm decodeUTF8) else id
umkTerm = utf . mkTerm
lins = Map.fromAscList
- [(f', umkTerm tr) | (f,CncFun _ (Yes tr) _) <- js,
+ [(f', umkTerm tr) | (f,CncFun _ (Just tr) _) <- js,
let f' = i2i f, exists f'] -- eliminating lins without fun
-- needed even here because of restricted inheritance
lincats = Map.fromAscList
- [(i2i c, mkCType ty) | (c,CncCat (Yes ty) _ _) <- js]
+ [(i2i c, mkCType ty) | (c,CncCat (Just ty) _ _) <- js]
lindefs = Map.fromAscList
- [(i2i c, umkTerm tr) | (c,CncCat _ (Yes tr) _) <- js]
+ [(i2i c, umkTerm tr) | (c,CncCat _ (Just tr) _) <- js]
printnames = Map.union
- (Map.fromAscList [(i2i f, umkTerm tr) | (f,CncFun _ _ (Yes tr)) <- js])
- (Map.fromAscList [(i2i f, umkTerm tr) | (f,CncCat _ _ (Yes tr)) <- js])
+ (Map.fromAscList [(i2i f, umkTerm tr) | (f,CncFun _ _ (Just tr)) <- js])
+ (Map.fromAscList [(i2i f, umkTerm tr) | (f,CncCat _ _ (Just tr)) <- js])
params = Map.fromAscList
- [(i2i c, pars lang0 c) | (c,CncCat (Yes ty) _ _) <- js]
+ [(i2i c, pars lang0 c) | (c,CncCat (Just ty) _ _) <- js]
fcfg = Nothing
exists f = Map.member f funs
@@ -232,7 +232,7 @@ reorder abs cg = M.MGrammar $
adefs = sorted2tree $ sortIds $
predefADefs ++ Look.allOrigInfos cg abs
predefADefs =
- [(c, AbsCat (Yes []) Nope) | c <- [cFloat,cInt,cString]]
+ [(c, AbsCat (Just []) Nothing) | c <- [cFloat,cInt,cString]]
aflags =
concatOptions [M.flags mo | (_,mo) <- M.modules cg, M.isModAbs mo]
@@ -246,7 +246,7 @@ reorder abs cg = M.MGrammar $
Just r <- [lookup i (M.allExtendSpecs cg la)]]
predefCDefs =
- [(c, CncCat (Yes GM.defLinType) Nope Nope) | c <- [cInt,cFloat,cString]]
+ [(c, CncCat (Just GM.defLinType) Nothing Nothing) | c <- [cInt,cFloat,cString]]
sortIds = sortBy (\ (f,_) (g,_) -> compare f g)
@@ -279,8 +279,8 @@ canon2canon opts abs cg0 =
j2j cg (f,j) =
let debug = if verbAtLeast opts Verbose then trace ("+ " ++ prt f) else id in
case j of
- CncFun x (Yes tr) z -> CncFun x (Yes (debug (t2t tr))) z
- CncCat (Yes ty) (Yes x) y -> CncCat (Yes (ty2ty ty)) (Yes (t2t x)) y
+ CncFun x (Just tr) z -> CncFun x (Just (debug (t2t tr))) z
+ CncCat (Just ty) (Just x) y -> CncCat (Just (ty2ty ty)) (Just (t2t x)) y
_ -> j
where
cg1 = cg
@@ -290,8 +290,8 @@ canon2canon opts abs cg0 =
-- flatten record arguments of param constructors
p2p (f,j) = case j of
- ResParam (Yes (ps,v)) ->
- ResParam (Yes ([(c,concatMap unRec cont) | (c,cont) <- ps],Nothing))
+ ResParam (Just (ps,v)) ->
+ ResParam (Just ([(c,concatMap unRec cont) | (c,cont) <- ps],Nothing))
_ -> j
unRec (x,ty) = case ty of
RecType fs -> [ity | (_,typ) <- fs, ity <- unRec (identW,typ)]
@@ -333,13 +333,13 @@ paramValues cgr = (labels,untyps,typs) where
partyps = nub $
--- [App (Q (IC "Predef") (IC "Ints")) (EInt i) | i <- [1,9]] ---linTypeInt
[ty |
- (_,(_,CncCat (Yes ty0) _ _)) <- jments,
+ (_,(_,CncCat (Just ty0) _ _)) <- jments,
ty <- typsFrom ty0
] ++ [
Q m ty |
(m,(ty,ResParam _)) <- jments
] ++ [ty |
- (_,(_,CncFun _ (Yes tr) _)) <- jments,
+ (_,(_,CncFun _ (Just tr) _)) <- jments,
ty <- err (const []) snd $ appSTM (typsFromTrm tr) []
]
params = [(ty, errVal (traceD ("UNKNOWN PARAM TYPE" +++ show ty) []) $
@@ -381,7 +381,7 @@ paramValues cgr = (labels,untyps,typs) where
[(cat,[f | let RecType fs = GM.defLinType, f <- fs]) | cat <- [cInt,cFloat, cString]] ++
reverse ---- TODO: really those lincats that are reached
---- reverse is enough to expel overshadowed ones...
- [(cat,ls) | (_,(cat,CncCat (Yes ty) _ _)) <- jments,
+ [(cat,ls) | (_,(cat,CncCat (Just ty) _ _)) <- jments,
RecType ls <- [unlockTy ty]]
labels = Map.fromList $ concat
[((cat,[lab]),(typ,i)):
diff --git a/src/GF/Compile/Optimize.hs b/src/GF/Compile/Optimize.hs
index 177e5bf70..7f6e451c7 100644
--- a/src/GF/Compile/Optimize.hs
+++ b/src/GF/Compile/Optimize.hs
@@ -85,6 +85,13 @@ evalModule oopts (ms,eenv) mo@(name,m0)
info' <- evalResInfo oopts gr (i,info)
return $ updateRes g name i info'
+-- | update a resource module by adding a new or changing an old definition
+updateRes :: SourceGrammar -> Ident -> Ident -> Info -> SourceGrammar
+updateRes gr@(MGrammar ms) m i info = MGrammar $ map upd ms where
+ upd (n,mo)
+ | n /= m = (n,mo)
+ | n == m = (n,updateModule mo i info)
+
-- | only operations need be compiled in a resource, and this is local to each
-- definition since the module is traversed in topological order
evalResInfo :: Options -> SourceGrammar -> (Ident,Info) -> Err Info
@@ -92,8 +99,8 @@ evalResInfo oopts gr (c,info) = case info of
ResOper pty pde -> eIn "operation" $ do
pde' <- case pde of
- Yes de | optres -> liftM yes $ comp de
- _ -> return pde
+ Just de | optres -> liftM Just $ comp de
+ _ -> return pde
return $ ResOper pty pde'
_ -> return info
@@ -114,26 +121,22 @@ evalCncInfo opts gr cnc abs (c,info) = do
CncCat ptyp pde ppr -> do
pde' <- case (ptyp,pde) of
- (Yes typ, Yes de) ->
- liftM yes $ pEval ([(varStr, typeStr)], typ) de
- (Yes typ, Nope) ->
- liftM yes $ mkLinDefault gr typ >>= partEval noOptions gr ([(varStr, typeStr)],typ)
- (May b, Nope) ->
- return $ May b
+ (Just typ, Just de) ->
+ liftM Just $ pEval ([(varStr, typeStr)], typ) de
+ (Just typ, Nothing) ->
+ liftM Just $ mkLinDefault gr typ >>= partEval noOptions gr ([(varStr, typeStr)],typ)
_ -> return pde -- indirection
- ppr' <- liftM yes $ evalPrintname gr c ppr (yes $ K $ prt c)
+ ppr' <- liftM Just $ evalPrintname gr c ppr (Just $ K $ prt c)
return (CncCat ptyp pde' ppr')
CncFun (mt@(Just (_,ty@(cont,val)))) pde ppr -> --trace (prt c) $
eIn ("linearization in type" +++ prt (mkProd (cont,val,[])) ++++ "of function") $ do
pde' <- case pde of
- Yes de -> do
- liftM yes $ pEval ty de
-
- _ -> return pde
- ppr' <- liftM yes $ evalPrintname gr c ppr pde'
+ Just de -> liftM Just $ pEval ty de
+ Nothing -> return pde
+ ppr' <- liftM Just $ evalPrintname gr c ppr pde'
return $ CncFun mt pde' ppr' -- only cat in type actually needed
_ -> return info
@@ -202,13 +205,13 @@ mkLinDefault gr typ = do
-- lin for functions, cat name for cats (dispatch made in evalCncDef above).
--- We cannot use linearization at this stage, since we do not know the
--- defaults we would need for question marks - and we're not yet in canon.
-evalPrintname :: SourceGrammar -> Ident -> MPr -> Perh Term -> Err Term
+evalPrintname :: SourceGrammar -> Ident -> Maybe Term -> Maybe Term -> Err Term
evalPrintname gr c ppr lin =
case ppr of
- Yes pr -> comp pr
- _ -> case lin of
- Yes t -> return $ K $ clean $ prt $ oneBranch t ---- stringFromTerm
- _ -> return $ K $ prt c ----
+ Just pr -> comp pr
+ Nothing -> case lin of
+ Just t -> return $ K $ clean $ prt $ oneBranch t ---- stringFromTerm
+ Nothing -> return $ K $ prt c ----
where
comp = computeConcrete gr
diff --git a/src/GF/Compile/OptimizeGF.hs b/src/GF/Compile/OptimizeGF.hs
index 27627b137..8f7a0efef 100644
--- a/src/GF/Compile/OptimizeGF.hs
+++ b/src/GF/Compile/OptimizeGF.hs
@@ -48,9 +48,9 @@ processModule :: (Ident -> Term -> Term) -> SourceModule -> SourceModule
processModule opt (i,mo) = (i,M.replaceJudgements mo (mapTree (shareInfo opt) (M.jments mo)))
shareInfo :: (Ident -> Term -> Term) -> (Ident,Info) -> Info
-shareInfo opt (c, CncCat ty (Yes t) m) = CncCat ty (Yes (opt c t)) m
-shareInfo opt (c, CncFun kxs (Yes t) m) = CncFun kxs (Yes (opt c t)) m
-shareInfo opt (c, ResOper ty (Yes t)) = ResOper ty (Yes (opt c t))
+shareInfo opt (c, CncCat ty (Just t) m) = CncCat ty (Just (opt c t)) m
+shareInfo opt (c, CncFun kxs (Just t) m) = CncFun kxs (Just (opt c t)) m
+shareInfo opt (c, ResOper ty (Just t)) = ResOper ty (Just (opt c t))
shareInfo _ (_,i) = i
-- the function putting together optimizations
@@ -181,9 +181,9 @@ unsubexpModule sm@(i,mo)
-- perform this iff the module has opers
hasSub ljs = not $ null [c | (c,ResOper _ _) <- ljs]
unparInfo (c,info) = case info of
- CncFun xs (Yes t) m -> [(c, CncFun xs (Yes (unparTerm t)) m)]
- ResOper (Yes (EInt 8)) _ -> [] -- subexp-generated opers
- ResOper pty (Yes t) -> [(c, ResOper pty (Yes (unparTerm t)))]
+ CncFun xs (Just t) m -> [(c, CncFun xs (Just (unparTerm t)) m)]
+ ResOper (Just (EInt 8)) _ -> [] -- subexp-generated opers
+ ResOper pty (Just t) -> [(c, ResOper pty (Just (unparTerm t)))]
_ -> [(c,info)]
unparTerm t = case t of
Q m c | isOperIdent c -> --- name convention of subexp opers
@@ -205,12 +205,12 @@ addSubexpConsts mo tree lins = do
where
mkOne (f,def) = case def of
- CncFun xs (Yes trm) pn -> do
+ CncFun xs (Just trm) pn -> do
trm' <- recomp f trm
- return (f,CncFun xs (Yes trm') pn)
- ResOper ty (Yes trm) -> do
+ return (f,CncFun xs (Just trm') pn)
+ ResOper ty (Just trm) -> do
trm' <- recomp f trm
- return (f,ResOper ty (Yes trm'))
+ return (f,ResOper ty (Just trm'))
_ -> return (f,def)
recomp f t = case Map.lookup t tree of
Just (_,id) | operIdent id /= f -> return $ Q mo (operIdent id)
@@ -218,7 +218,7 @@ addSubexpConsts mo tree lins = do
list = Map.toList tree
- oper id trm = (operIdent id, ResOper (Yes (EInt 8)) (Yes trm))
+ oper id trm = (operIdent id, ResOper (Just (EInt 8)) (Just trm))
--- impossible type encoding generated opers
getSubtermsMod :: Ident -> [(Ident,Info)] -> TermM (Map Term (Int,Int))
@@ -228,10 +228,10 @@ getSubtermsMod mo js = do
return $ Map.filter (\ (nu,_) -> nu > 1) tree0
where
getInfo get fi@(f,i) = case i of
- CncFun xs (Yes trm) pn -> do
+ CncFun xs (Just trm) pn -> do
get trm
return $ fi
- ResOper ty (Yes trm) -> do
+ ResOper ty (Just trm) -> do
get trm
return $ fi
_ -> return fi
diff --git a/src/GF/Compile/Rebuild.hs b/src/GF/Compile/Rebuild.hs
deleted file mode 100644
index 8adf81824..000000000
--- a/src/GF/Compile/Rebuild.hs
+++ /dev/null
@@ -1,101 +0,0 @@
-----------------------------------------------------------------------
--- |
--- Module : Rebuild
--- Maintainer : AR
--- Stability : (stable)
--- Portability : (portable)
---
--- > CVS $Date: 2005/05/30 21:08:14 $
--- > CVS $Author: aarne $
--- > CVS $Revision: 1.14 $
---
--- Rebuild a source module from incomplete and its with-instance.
------------------------------------------------------------------------------
-
-module GF.Compile.Rebuild (rebuildModule) where
-
-import GF.Grammar.Grammar
-import GF.Compile.ModDeps
-import GF.Grammar.PrGrammar
-import GF.Grammar.Lookup
-import GF.Compile.Extend
-import GF.Grammar.Macros
-
-import GF.Infra.Ident
-import GF.Infra.Modules
-import GF.Infra.Option
-import GF.Data.Operations
-
-import Data.List (nub)
-import Data.Maybe (isNothing)
-
--- | rebuilding instance + interface, and "with" modules, prior to renaming.
--- AR 24/10/2003
-rebuildModule :: [SourceModule] -> SourceModule -> Err SourceModule
-rebuildModule ms mo@(i,mi@(ModInfo mt stat fs_ me mw ops_ med_ js_ ps_)) = do
- let gr = MGrammar ms
----- deps <- moduleDeps ms
----- is <- openInterfaces deps i
- let is = [] ---- the method above is buggy: try "i -src" for two grs. AR 8/3/2005
- mi' <- case mw of
-
- -- add the information given in interface into an instance module
- Nothing -> do
- testErr (null is || mstatus mi == MSIncomplete)
- ("module" +++ prt i +++
- "has open interfaces and must therefore be declared incomplete")
- case mt of
- MTInstance i0 -> do
- m1 <- lookupModule gr i0
- testErr (isModRes m1) ("interface expected instead of" +++ prt i0)
- js' <- extendMod False (i0,const True) i (jments m1) (jments mi)
- --- to avoid double inclusions, in instance I of I0 = J0 ** ...
- case extends mi of
- [] -> return $ replaceJudgements mi js'
- j0s -> do
- m0s <- mapM (lookupModule gr) j0s
- let notInM0 c _ = all (not . isInBinTree c . jments) m0s
- let js2 = filterBinTree notInM0 js'
- return $ (replaceJudgements mi js2)
- {positions =
- buildTree (tree2list (positions m1) ++
- tree2list (positions mi))}
- _ -> return mi
-
- -- add the instance opens to an incomplete module "with" instances
- Just (ext,incl,ops) -> do
- let (infs,insts) = unzip ops
- let stat' = ifNull MSComplete (const MSIncomplete)
- [i | i <- is, notElem i infs]
- testErr (stat' == MSComplete || stat == MSIncomplete)
- ("module" +++ prt i +++ "remains incomplete")
- ModInfo mt0 _ fs me' _ ops0 _ js ps0 <- lookupModule gr ext
- let ops1 = nub $
- ops_ ++ -- N.B. js has been name-resolved already
- [OQualif i j | (i,j) <- ops] ++
- [o | o <- ops0, notElem (openedModule o) infs] ++
- [OQualif i i | i <- insts] ++
- [OSimple i | i <- insts]
-
- --- check if me is incomplete
- let fs1 = fs `addOptions` fs_ -- new flags have priority
- let js0 = [ci | ci@(c,_) <- tree2list js, isInherited incl c]
- let js1 = buildTree (tree2list js_ ++ js0)
- let ps1 = buildTree (tree2list ps_ ++ tree2list ps0)
- let med1= nub (ext : infs ++ insts ++ med_)
- return $ ModInfo mt0 stat' fs1 me Nothing ops1 med1 js1 ps1
-
- return (i,mi')
-
-checkCompleteInstance :: SourceModInfo -> SourceModInfo -> Err ()
-checkCompleteInstance abs cnc = ifNull (return ()) (Bad . unlines) $
- checkComplete [f | (f, ResOper (Yes _) _) <- abs'] cnc'
- where
- abs' = tree2list $ jments abs
- cnc' = jments cnc
- checkComplete sought given = foldr ckOne [] sought
- where
- ckOne f = if isInBinTree f given
- then id
- else (("Error: no definition given to" +++ prt f):)
-
diff --git a/src/GF/Compile/Refresh.hs b/src/GF/Compile/Refresh.hs
index d446008d0..ba6142ddd 100644
--- a/src/GF/Compile/Refresh.hs
+++ b/src/GF/Compile/Refresh.hs
@@ -116,18 +116,18 @@ refreshModule (k,ms) mi@(i,mo)
| otherwise = return (k, mi:ms)
where
refreshRes (k,cs) ci@(c,info) = case info of
- ResOper ptyp (Yes trm) -> do ---- refresh ptyp
+ ResOper ptyp (Just trm) -> do ---- refresh ptyp
(k',trm') <- refreshTermKN k trm
- return $ (k', (c, ResOper ptyp (Yes trm')):cs)
+ return $ (k', (c, ResOper ptyp (Just trm')):cs)
ResOverload os tyts -> do
(k',tyts') <- liftM (\ (t,(_,i)) -> (i,t)) $
appSTM (mapPairsM refresh tyts) (initIdStateN k)
return $ (k', (c, ResOverload os tyts'):cs)
- CncCat mt (Yes trm) pn -> do ---- refresh mt, pn
+ CncCat mt (Just trm) pn -> do ---- refresh mt, pn
(k',trm') <- refreshTermKN k trm
- return $ (k', (c, CncCat mt (Yes trm') pn):cs)
- CncFun mt (Yes trm) pn -> do ---- refresh pn
+ return $ (k', (c, CncCat mt (Just trm') pn):cs)
+ CncFun mt (Just trm) pn -> do ---- refresh pn
(k',trm') <- refreshTermKN k trm
- return $ (k', (c, CncFun mt (Yes trm') pn):cs)
+ return $ (k', (c, CncFun mt (Just trm') pn):cs)
_ -> return (k, ci:cs)
diff --git a/src/GF/Compile/Rename.hs b/src/GF/Compile/Rename.hs
index ba14cb02e..05ccfdb2c 100644
--- a/src/GF/Compile/Rename.hs
+++ b/src/GF/Compile/Rename.hs
@@ -36,7 +36,6 @@ import GF.Grammar.Macros
import GF.Grammar.PrGrammar
import GF.Grammar.AppPredefined
import GF.Grammar.Lookup
-import GF.Compile.Extend
import GF.Data.Operations
import Control.Monad
@@ -115,7 +114,7 @@ renameIdentPatt env p = do
info2status :: Maybe Ident -> (Ident,Info) -> StatusInfo
info2status mq (c,i) = case i of
- AbsFun _ (Yes EData) -> maybe Con QC mq
+ AbsFun _ (Just EData) -> maybe Con QC mq
ResValue _ -> maybe Con QC mq
ResParam _ -> maybe Con QC mq
AnyInd True m -> maybe Con (const (QC m)) mq
@@ -161,12 +160,12 @@ renameInfo mo status (i,info) = errIn
ResOverload os tysts ->
liftM (ResOverload os) (mapM (pairM rent) tysts)
- ResParam (Yes (pp,m)) -> do
+ ResParam (Just (pp,m)) -> do
pp' <- mapM (renameParam status) pp
- return $ ResParam $ Yes (pp',m)
- ResValue (Yes (t,m)) -> do
+ return $ ResParam $ Just (pp',m)
+ ResValue (Just (t,m)) -> do
t' <- rent t
- return $ ResValue $ Yes (t',m)
+ return $ ResValue $ Just (t',m)
CncCat pty ptr ppr -> liftM3 CncCat (ren pty) (ren ptr) (ren ppr)
CncFun mt ptr ppr -> liftM2 (CncFun mt) (ren ptr) (ren ppr)
_ -> return info
@@ -174,9 +173,8 @@ renameInfo mo status (i,info) = errIn
ren = renPerh rent
rent = renameTerm status []
-renPerh ren pt = case pt of
- Yes t -> liftM Yes $ ren t
- _ -> return pt
+renPerh ren (Just t) = liftM Just $ ren t
+renPerh ren Nothing = return Nothing
renameTerm :: Status -> [Ident] -> Term -> Err Term
renameTerm env vars = ren vars where
diff --git a/src/GF/Compile/Update.hs b/src/GF/Compile/Update.hs
index a0aefeea5..4bcea0db2 100644
--- a/src/GF/Compile/Update.hs
+++ b/src/GF/Compile/Update.hs
@@ -12,122 +12,200 @@
-- (Description of the module)
-----------------------------------------------------------------------------
-module GF.Compile.Update (updateRes, buildAnyTree, combineAnyInfos, unifyAnyInfo,
- -- * these auxiliaries should be somewhere else
- -- since they don't use the info types
- groupInfos, sortInfos, combineInfos, unifyInfos,
- tryInsert, unifAbsDefs, unifConstrs
- ) where
+module GF.Compile.Update (buildAnyTree, extendModule, rebuildModule) where
import GF.Infra.Ident
import GF.Grammar.Grammar
-import GF.Grammar.PrGrammar
+import GF.Grammar.Printer
import GF.Infra.Modules
+import GF.Infra.Option
import GF.Data.Operations
import Data.List
+import qualified Data.Map as Map
import Control.Monad
-
--- | update a resource module by adding a new or changing an old definition
-updateRes :: SourceGrammar -> Ident -> Ident -> Info -> SourceGrammar
-updateRes gr@(MGrammar ms) m i info = MGrammar $ map upd ms where
- upd (n,mo)
- | n /= m = (n,mo)
- | n == m = (n,updateModule mo i info)
+import Text.PrettyPrint
-- | combine a list of definitions into a balanced binary search tree
-buildAnyTree :: [(Ident,Info)] -> Err (BinTree Ident Info)
-buildAnyTree ias = do
- ias' <- combineAnyInfos ias
- return $ buildTree ias'
-
-
--- | unifying information for abstract, resource, and concrete
-combineAnyInfos :: [(Ident,Info)] -> Err [(Ident,Info)]
-combineAnyInfos = combineInfos unifyAnyInfo
+buildAnyTree :: Ident -> [(Ident,Info)] -> Err (BinTree Ident Info)
+buildAnyTree m = go Map.empty
+ where
+ go map [] = return map
+ go map ((c,j):is) = do
+ case Map.lookup c map of
+ Just i -> case unifyAnyInfo c i j of
+ Ok k -> go (Map.insert c k map) is
+ Bad _ -> fail $ render (text "cannot unify the informations" $$
+ nest 4 (ppJudgement (c,i)) $$
+ text "and" $+$
+ nest 4 (ppJudgement (c,j)) $$
+ text "in module" <+> ppIdent m)
+ Nothing -> go (Map.insert c j map) is
+
+extendModule :: [SourceModule] -> SourceModule -> Err SourceModule
+extendModule ms (name,m)
+ ---- Just to allow inheritance in incomplete concrete (which are not
+ ---- compiled anyway), extensions are not built for them.
+ ---- Should be replaced by real control. AR 4/2/2005
+ | mstatus m == MSIncomplete && isModCnc m = return (name,m)
+ | otherwise = do m' <- foldM extOne m (extend m)
+ return (name,m')
+ where
+ extOne mo (n,cond) = do
+ m0 <- lookupModule (MGrammar ms) n
+
+ -- test that the module types match, and find out if the old is complete
+ testErr (sameMType (mtype m) (mtype mo))
+ ("illegal extension type to module" +++ prIdent name)
+
+ let isCompl = isCompleteModule m0
+
+ -- build extension in a way depending on whether the old module is complete
+ js1 <- extendMod isCompl (n, isInherited cond) name (jments m0) (jments mo)
+
+ -- if incomplete, throw away extension information
+ return $
+ if isCompl
+ then mo {jments = js1}
+ else mo {extend = filter ((/=n) . fst) (extend mo)
+ ,mexdeps= nub (n : mexdeps mo)
+ ,jments = js1
+ }
+
+-- | rebuilding instance + interface, and "with" modules, prior to renaming.
+-- AR 24/10/2003
+rebuildModule :: [SourceModule] -> SourceModule -> Err SourceModule
+rebuildModule ms mo@(i,mi@(ModInfo mt stat fs_ me mw ops_ med_ js_ ps_)) = do
+ let gr = MGrammar ms
+---- deps <- moduleDeps ms
+---- is <- openInterfaces deps i
+ let is = [] ---- the method above is buggy: try "i -src" for two grs. AR 8/3/2005
+ mi' <- case mw of
+
+ -- add the information given in interface into an instance module
+ Nothing -> do
+ testErr (null is || mstatus mi == MSIncomplete)
+ ("module" +++ prIdent i +++
+ "has open interfaces and must therefore be declared incomplete")
+ case mt of
+ MTInstance i0 -> do
+ m1 <- lookupModule gr i0
+ testErr (isModRes m1) ("interface expected instead of" +++ prIdent i0)
+ js' <- extendMod False (i0,const True) i (jments m1) (jments mi)
+ --- to avoid double inclusions, in instance I of I0 = J0 ** ...
+ case extends mi of
+ [] -> return $ replaceJudgements mi js'
+ j0s -> do
+ m0s <- mapM (lookupModule gr) j0s
+ let notInM0 c _ = all (not . isInBinTree c . jments) m0s
+ let js2 = filterBinTree notInM0 js'
+ return $ (replaceJudgements mi js2)
+ {positions = Map.union (positions m1) (positions mi)}
+ _ -> return mi
+
+ -- add the instance opens to an incomplete module "with" instances
+ Just (ext,incl,ops) -> do
+ let (infs,insts) = unzip ops
+ let stat' = ifNull MSComplete (const MSIncomplete)
+ [i | i <- is, notElem i infs]
+ testErr (stat' == MSComplete || stat == MSIncomplete)
+ ("module" +++ prIdent i +++ "remains incomplete")
+ ModInfo mt0 _ fs me' _ ops0 _ js ps0 <- lookupModule gr ext
+ let ops1 = nub $
+ ops_ ++ -- N.B. js has been name-resolved already
+ [OQualif i j | (i,j) <- ops] ++
+ [o | o <- ops0, notElem (openedModule o) infs] ++
+ [OQualif i i | i <- insts] ++
+ [OSimple i | i <- insts]
+
+ --- check if me is incomplete
+ let fs1 = fs `addOptions` fs_ -- new flags have priority
+ let js0 = [ci | ci@(c,_) <- tree2list js, isInherited incl c]
+ let js1 = buildTree (tree2list js_ ++ js0)
+ let ps1 = Map.union ps_ ps0
+ let med1= nub (ext : infs ++ insts ++ med_)
+ return $ ModInfo mt0 stat' fs1 me Nothing ops1 med1 js1 ps1
+
+ return (i,mi')
+
+-- | When extending a complete module: new information is inserted,
+-- and the process is interrupted if unification fails.
+-- If the extended module is incomplete, its judgements are just copied.
+extendMod :: Bool -> (Ident,Ident -> Bool) -> Ident ->
+ BinTree Ident Info -> BinTree Ident Info ->
+ Err (BinTree Ident Info)
+extendMod isCompl (name,cond) base old new = foldM try new $ Map.toList old
+ where
+ try new (c,i)
+ | not (cond c) = return new
+ | otherwise = case Map.lookup c new of
+ Just j -> case unifyAnyInfo c i j of
+ Ok k -> return $ updateTree (c,k) new
+ Bad _ -> fail $ render (text "cannot unify the information" $$
+ nest 4 (ppJudgement (c,i)) $$
+ text "in module" <+> ppIdent name <+> text "with" $$
+ nest 4 (ppJudgement (c,j)) $$
+ text "in module" <+> ppIdent base)
+ Nothing -> if isCompl
+ then return $ updateTree (c,indirInfo name i) new
+ else return $ updateTree (c,i) new
+
+ indirInfo :: Ident -> Info -> Info
+ indirInfo n info = AnyInd b n' where
+ (b,n') = case info of
+ ResValue _ -> (True,n)
+ ResParam _ -> (True,n)
+ AbsFun _ (Just EData) -> (True,n)
+ AnyInd b k -> (b,k)
+ _ -> (False,n) ---- canonical in Abs
unifyAnyInfo :: Ident -> Info -> Info -> Err Info
-unifyAnyInfo c i j = errIn ("combining information for" +++ prt c) $ case (i,j) of
+unifyAnyInfo c i j = case (i,j) of
(AbsCat mc1 mf1, AbsCat mc2 mf2) ->
- liftM2 AbsCat (unifPerhaps mc1 mc2) (unifConstrs mf1 mf2) -- adding constrs
+ liftM2 AbsCat (unifMaybe mc1 mc2) (unifConstrs mf1 mf2) -- adding constrs
(AbsFun mt1 md1, AbsFun mt2 md2) ->
- liftM2 AbsFun (unifPerhaps mt1 mt2) (unifAbsDefs md1 md2) -- adding defs
+ liftM2 AbsFun (unifMaybe mt1 mt2) (unifAbsDefs md1 md2) -- adding defs
- (ResParam mt1, ResParam mt2) -> liftM ResParam $ unifPerhaps mt1 mt2
+ (ResParam mt1, ResParam mt2) -> liftM ResParam $ unifMaybe mt1 mt2
+ (ResValue mt1, ResValue mt2) ->
+ liftM ResValue $ unifMaybe mt1 mt2
+ (_, ResOverload ms t) | elem c ms ->
+ return $ ResOverload ms t
(ResOper mt1 m1, ResOper mt2 m2) ->
- liftM2 ResOper (unifPerhaps mt1 mt2) (unifPerhaps m1 m2)
+ liftM2 ResOper (unifMaybe mt1 mt2) (unifMaybe m1 m2)
(CncCat mc1 mf1 mp1, CncCat mc2 mf2 mp2) ->
- liftM3 CncCat (unifPerhaps mc1 mc2) (unifPerhaps mf1 mf2) (unifPerhaps mp1 mp2)
+ liftM3 CncCat (unifMaybe mc1 mc2) (unifMaybe mf1 mf2) (unifMaybe mp1 mp2)
(CncFun m mt1 md1, CncFun _ mt2 md2) ->
- liftM2 (CncFun m) (unifPerhaps mt1 mt2) (unifPerhaps md1 md2) ---- adding defs
--- for bw compatibility with unspecified printnames in old GF
- (CncFun Nothing Nope (Yes pr),_) ->
- unifyAnyInfo c (CncCat Nope Nope (Yes pr)) j
- (_,CncFun Nothing Nope (Yes pr)) ->
- unifyAnyInfo c i (CncCat Nope Nope (Yes pr))
-
- _ -> Bad $ "cannot unify informations in" ++++ show i ++++ "and" ++++ show j
-
---- these auxiliaries should be somewhere else since they don't use the info types
-
-groupInfos :: Eq a => [(a,b)] -> [[(a,b)]]
-groupInfos = groupBy (\i j -> fst i == fst j)
-
-sortInfos :: Ord a => [(a,b)] -> [(a,b)]
-sortInfos = sortBy (\i j -> compare (fst i) (fst j))
-
-combineInfos :: Ord a => (a -> b -> b -> Err b) -> [(a,b)] -> Err [(a,b)]
-combineInfos f ris = do
- let riss = groupInfos $ sortInfos ris
- mapM (unifyInfos f) riss
-
-unifyInfos :: (a -> b -> b -> Err b) -> [(a,b)] -> Err (a,b)
-unifyInfos _ [] = Bad "empty info list"
-unifyInfos unif ris = do
- let c = fst $ head ris
- let infos = map snd ris
- let ([i],is) = splitAt 1 infos
- info <- foldM (unif c) i is
- return (c,info)
-
-
-tryInsert :: Ord a => (b -> b -> Err b) -> (b -> b) ->
- BinTree a b -> (a,b) -> Err (BinTree a b)
-tryInsert unif indir tree z@(x, info) = case justLookupTree x tree of
- Ok info0 -> do
- info1 <- unif info info0
- return $ updateTree (x,info1) tree
- _ -> return $ updateTree (x,indir info) tree
-
-{- ----
-case tree of
- NT -> return $ BT (x, indir info) NT NT
- BT c@(a,info0) left right
- | x < a -> do
- left' <- tryInsert unif indir left z
- return $ BT c left' right
- | x > a -> do
- right' <- tryInsert unif indir right z
- return $ BT c left right'
- | x == a -> do
- info' <- unif info info0
- return $ BT (x,info') left right
--}
-
---- addToMaybeList m c = maybe (return c) (\old -> return (c ++ old)) m
-
-unifAbsDefs :: Perh Term -> Perh Term -> Err (Perh Term)
+ liftM2 (CncFun m) (unifMaybe mt1 mt2) (unifMaybe md1 md2) ---- adding defs
+
+ (AnyInd b1 m1, AnyInd b2 m2) -> do
+ testErr (b1 == b2) $ "indirection status"
+ testErr (m1 == m2) $ "different sources of indirection"
+ return i
+
+ _ -> fail "informations"
+
+-- | this is what happens when matching two values in the same module
+unifMaybe :: Eq a => Maybe a -> Maybe a -> Err (Maybe a)
+unifMaybe Nothing Nothing = return Nothing
+unifMaybe (Just p1) Nothing = return (Just p1)
+unifMaybe Nothing (Just p2) = return (Just p2)
+unifMaybe (Just p1) (Just p2)
+ | p1==p2 = return (Just p1)
+ | otherwise = fail ""
+
+unifAbsDefs :: Maybe Term -> Maybe Term -> Err (Maybe Term)
unifAbsDefs p1 p2 = case (p1,p2) of
- (Nope, _) -> return p2
- (_, Nope) -> return p1
- (Yes (Eqs bs), Yes (Eqs ds)) -> return $ yes $ Eqs $ bs ++ ds --- order!
- _ -> Bad "update conflict for definitions"
+ (Nothing, _) -> return p2
+ (_, Nothing) -> return p1
+ (Just (Eqs bs), Just (Eqs ds))
+ -> return $ Just $ Eqs $ bs ++ ds --- order!
+ _ -> fail "definitions"
-unifConstrs :: Perh [Term] -> Perh [Term] -> Err (Perh [Term])
+unifConstrs :: Maybe [Term] -> Maybe [Term] -> Err (Maybe [Term])
unifConstrs p1 p2 = case (p1,p2) of
- (Nope, _) -> return p2
- (_, Nope) -> return p1
- (Yes bs, Yes ds) -> return $ yes $ bs ++ ds
- _ -> Bad "update conflict for constructors"
+ (Nothing, _) -> return p2
+ (_, Nothing) -> return p1
+ (Just bs, Just ds) -> return $ Just $ bs ++ ds
generated by cgit v1.2.3 (git 2.39.1) at 2026-05-20 17:43:38 +0000