-- UUAGC 0.9.26 (Transform.ag) module Transform where {-# LINE 8 "Transform.ag" #-} import Control.Monad(mplus,mzero) import List (partition, elem, nub,intersperse) import Data.Maybe import qualified Data.Map as Map import Data.Map (Map) import Data.Set as Set (Set, member, union, toList, fromList, empty, singleton, member, unions, size, fold, intersection, difference, insert) import qualified Data.Sequence as Seq import Data.Sequence(Seq, empty, (><),fromList) import Data.Foldable(toList) import UU.Scanner.Position(noPos) import ConcreteSyntax import AbstractSyntax import ErrorMessages import Patterns (Patterns(..),Pattern(..)) import Expression (Expression(..)) import HsToken import Options import CommonTypes {-# LINE 28 "../src-derived/Transform.hs" #-} {-# LINE 2 "./ConcreteSyntax.ag" #-} import UU.Scanner.Position (Pos) import Patterns (Pattern) import Expression (Expression) import CommonTypes {-# LINE 36 "../src-derived/Transform.hs" #-} {-# LINE 2 "./Patterns.ag" #-} -- Patterns.ag imports import UU.Scanner.Position(Pos) import CommonTypes (ConstructorIdent,Identifier) {-# LINE 43 "../src-derived/Transform.hs" #-} {-# LINE 99 "Transform.ag" #-} type DefinedSets = Map Identifier (Set NontermIdent) {-# LINE 46 "../src-derived/Transform.hs" #-} {-# LINE 119 "Transform.ag" #-} type FieldMap = [(Identifier, Type)] {-# LINE 50 "../src-derived/Transform.hs" #-} {-# LINE 120 "Transform.ag" #-} type DataTypes = Map.Map NontermIdent (Map.Map ConstructorIdent FieldMap) {-# LINE 54 "../src-derived/Transform.hs" #-} {-# LINE 140 "Transform.ag" #-} type AttrName = (Identifier,Identifier) {-# LINE 58 "../src-derived/Transform.hs" #-} {-# LINE 141 "Transform.ag" #-} type RuleInfo = (Maybe Identifier, [AttrName]->Pattern, Expression, [AttrName], Bool, String) {-# LINE 62 "../src-derived/Transform.hs" #-} {-# LINE 142 "Transform.ag" #-} type SigInfo = (Identifier,Type) {-# LINE 66 "../src-derived/Transform.hs" #-} {-# LINE 143 "Transform.ag" #-} type UniqueInfo = (Identifier,Identifier) {-# LINE 70 "../src-derived/Transform.hs" #-} {-# LINE 144 "Transform.ag" #-} type AugmentInfo = (Identifier,Expression) {-# LINE 74 "../src-derived/Transform.hs" #-} {-# LINE 145 "Transform.ag" #-} type AroundInfo = (Identifier,Expression) {-# LINE 78 "../src-derived/Transform.hs" #-} {-# LINE 192 "Transform.ag" #-} checkDuplicate :: (Identifier -> Identifier -> Error) -> Identifier -> val -> Map Identifier val -> (Map Identifier val,Seq Error) checkDuplicate dupError key val m = case Map.lookupIndex key m of Just ix -> let (key',_) = Map.elemAt ix m in (m,Seq.singleton (dupError key key')) Nothing -> (Map.insert key val m,Seq.empty) checkDuplicates :: (Identifier -> Identifier -> Error) -> [(Identifier, val)] -> Map Identifier val -> (Map Identifier val,Seq Error) checkDuplicates dupError new m = foldErrors check m new where check = uncurry (checkDuplicate dupError) foldErrors f e xs = foldl g (e,Seq.empty) xs where g ~(e,es) x = let (e',es') = f x e in (e', es >< es') checkForDuplicates :: (Identifier -> Identifier -> Error) -> [Identifier] -> [Error] checkForDuplicates err [] = [] checkForDuplicates err (x:xs) = let (same,other) = List.partition (equalId x) xs in map (err x) same ++ checkForDuplicates err other equalId :: Identifier -> Identifier -> Bool equalId x y = getName x == getName y {-# LINE 109 "../src-derived/Transform.hs" #-} {-# LINE 321 "Transform.ag" #-} type RulesAndErrors = ([Rule], Seq Error) type SigsAndErrors = ([TypeSig], Seq Error) type InstsAndErrors = ([(Identifier, Type)], Seq Error) type UniquesAndErrors = (Map Identifier Identifier, Seq Error) type AugmentsAndErrors = (Map Identifier [Expression], Seq Error) type AroundsAndErrors = (Map Identifier [Expression], Seq Error) type AttrOverwrite = Map AttrName Bool type AccumRuleCheck = (RulesAndErrors, AttrOverwrite) type AccumDefiCheck = (Seq Error, AttrOverwrite, [AttrName], [AttrName]) checkRules :: Map NontermIdent (Attributes, Attributes) -> Map NontermIdent (Map ConstructorIdent FieldMap) -> Map NontermIdent (Map ConstructorIdent [Identifier]) -> Map NontermIdent (Map ConstructorIdent [SigInfo]) -> NontermIdent -> ConstructorIdent -> [RuleInfo] -> RulesAndErrors checkRules attributes fields allinsts allsigs nt con rs = let fieldmap :: FieldMap fieldmap = (_LHS,NT nt undefined) : (_LOC,NT undefined undefined) : (_INST, NT undefined undefined) : (_FIRST, NT undefined undefined) : (_LAST, NT undefined undefined) : Map.findWithDefault [] con (Map.findWithDefault Map.empty nt fields) ++ mapMaybe (\instNm -> lookup instNm sigs >>= \tp -> return (instNm, tp)) (Map.findWithDefault [] con (Map.findWithDefault Map.empty nt allinsts)) sigs = Map.findWithDefault [] con (Map.findWithDefault Map.empty nt allsigs) hasAttrib f tp attr = Map.member attr (f (Map.findWithDefault (Map.empty,Map.empty) tp attributes)) checkRule :: RuleInfo -> AccumRuleCheck -> AccumRuleCheck checkRule (mbNm, pat,exp,as,owrt,str) ((r1,e1),m1) = let (e2,m2,u2,b2) = foldr (checkDefi owrt) (e1,m1,[],[]) as in ( (Rule mbNm (pat u2) exp owrt str True : r1, e2), m2) checkDefi :: Bool -> AttrName -> AccumDefiCheck -> AccumDefiCheck checkDefi owrt fa@(field,attr) (e,m,u,bs) = case lookup field fieldmap of Just (NT tp _) -> let tp' = maybe tp id (deforestedNt tp) in if field == _LOC || field == _INST || field == _FIRST || field == _LAST || hasAttrib (if getName field==getName _LHS then snd else fst) tp' attr then case Map.lookupIndex fa m of Just ix -> let ((_,attr2),b) = Map.elemAt ix m in if b && not (fa `elem` bs) then ( e, Map.insert fa owrt m, fa:u, fa:bs) else (((Seq.<|)) (DupRule nt con field attr2 attr) e, m, fa:u, bs) Nothing -> ( e, Map.insert fa owrt m, u, fa:bs) else (((Seq.<|)) (SuperfluousRule nt con field attr) e, m, fa:u, bs) _ -> (((Seq.<|)) (UndefChild nt con field) e, m, fa:u, bs ) in fst (foldr checkRule (([],Seq.empty),Map.empty) rs) checkRuleNames :: NontermIdent -> ConstructorIdent -> [RuleInfo] -> Seq Error checkRuleNames nt con = fst . foldr checkRule (Seq.empty, Set.empty) where checkRule (Just nm,_,_,_,_,_) (errs, nms) | nm `Set.member` nms = (DupRuleName nt con nm Seq.<| errs, nms) | otherwise = (errs, Set.insert nm nms) checkRule (Nothing,_,_,_,_,_) inp = inp checkSigs :: NontermIdent -> ConstructorIdent -> [SigInfo] -> SigsAndErrors checkSigs nt con sis = let checkSig (ide,typ) (sigs,errs) = if ide `elem` map (\(TypeSig n t)-> n) sigs then (sigs, ((Seq.<|)) (DupSig nt con ide) errs) -- else if not (ide `elem` locattrdefs) -- then (sigs, ((Seq.<|)) (SupSig nt con ide) errs) else (TypeSig ide typ:sigs, errs) in foldr checkSig ([],Seq.empty) sis checkInsts :: Set NontermIdent -> Map NontermIdent (Map ConstructorIdent [SigInfo]) -> Map NontermIdent (Map ConstructorIdent [(Identifier, Type)]) -> NontermIdent -> ConstructorIdent -> [Identifier] -> InstsAndErrors checkInsts allNts sigMap fieldMap nt con = foldr (\inst (insts, errs) -> maybe (insts, Seq.singleton (MissingInstSig nt con inst) >< errs) (\info@(k, NT nm _) -> case findInst k insts of Just k' -> (insts, Seq.singleton (DupChild nt con k k') >< errs) Nothing -> case nm `Set.member` allNts of True -> (info : insts, errs) False | take 2 (getName nm) == "T_" -> let nm' = Ident (drop 2 (getName nm)) (getPos nm) in case nm' `Set.member` allNts of True -> (info : insts, errs) False -> (insts, Seq.singleton (UndefNont nm') >< errs) | otherwise -> (insts, Seq.singleton (UndefNont nm) >< errs) ) $ findSig inst ) ([], Seq.empty) where sigs = Map.findWithDefault [] con (Map.findWithDefault Map.empty nt sigMap) findSig name = do tp@(NT _ _) <- lookup name sigs return (name, tp) findInst _ [] = Nothing findInst k ((k', _): r) | k == k' = Just k' | otherwise = findInst k r checkUniques :: Map NontermIdent (Attributes, Attributes) -> NontermIdent -> ConstructorIdent -> [UniqueInfo] -> UniquesAndErrors checkUniques allAttrs nt con uniques = let checkUnique (ident,ref) (us,errs) = if ident `Map.member` us then (us, ((Seq.<|)) (DupUnique nt con ident) errs) else if Map.member ref inhs && Map.member ref syns then (Map.insert ident ref us, errs) else (us, ((Seq.<|)) (MissingUnique nt ref) errs) (inhs,syns) = Map.findWithDefault (Map.empty,Map.empty) nt allAttrs in foldr checkUnique (Map.empty, Seq.empty) uniques checkAugments :: Map NontermIdent (Attributes, Attributes) -> NontermIdent -> ConstructorIdent -> [AugmentInfo] -> AugmentsAndErrors checkAugments allAttrs nt con augments = let checkAugment (ident,expr) (as,errs) = if ident `Map.member` as then (Map.update (\vs -> Just (vs ++ [expr])) ident as, errs) else if Map.member ident syns then (Map.insert ident [expr] as, errs) else (as, ((Seq.<|)) (MissingSyn nt ident) errs) (inhs,syns) = Map.findWithDefault (Map.empty,Map.empty) nt allAttrs in foldr checkAugment (Map.empty, Seq.empty) augments checkArounds :: Map NontermIdent (Map ConstructorIdent [(Identifier, Type)]) -> NontermIdent -> ConstructorIdent -> [AroundInfo] -> AroundsAndErrors checkArounds fieldMap nt con arounds = let checkAround (ident,expr) (as,errs) = if ident `Map.member` as then (Map.update (\vs -> Just (vs ++ [expr])) ident as, errs) else case lookup ident fields of Just (NT _ _) -> (Map.insert ident [expr] as, errs) _ -> (as, ((Seq.<|)) (UndefChild nt con ident) errs) fields = Map.findWithDefault [] con (Map.findWithDefault Map.empty nt fieldMap) in foldr checkAround (Map.empty, Seq.empty) arounds unionunionplusplus = Map.unionWith (Map.unionWith (++)) {-# LINE 243 "../src-derived/Transform.hs" #-} {-# LINE 455 "Transform.ag" #-} mkUniqueRules :: Options -> Map NontermIdent (Map ConstructorIdent [(Identifier, Type)]) -> Map NontermIdent (Attributes,Attributes) -> NontermIdent -> ConstructorIdent -> Map Identifier Identifier -> [Rule] mkUniqueRules opts allFields allAttrDecls nt con usMap = map apply groups where fields = Map.findWithDefault [] con (Map.findWithDefault Map.empty nt allFields) groups = Map.assocs $ Map.foldWithKey (\i r m -> Map.insertWith (++) r [i] m) Map.empty usMap apply (ref,us) = mkRule ref (findOutField ref) us findOutField ref = case [ chld | (chld,NT tp _) <- fields, tp `hasSyn` ref] of [] -> _LHS (x:_) -> x hasSyn tp ref = Map.member ref $ snd $ Map.findWithDefault (Map.empty,Map.empty) tp allAttrDecls mkRule ref outFld locAttrs = let pat = Product noPos (attr outFld ref : [attr _LOC u | u <- locAttrs ]) rhs = Expression noPos $ wrap ref $ foldr gencase (finalout locAttrs) locAttrs -- [HsToken ("mkUniques" ++ show (length locAttrs) ++ " ") noPos, AGField _LHS ref noPos Nothing] in Rule Nothing pat rhs False "-- generated by the unique rule mechanism." False attr fld a = Alias fld a (Underscore noPos) [] gencase nm outp = h ("case " ++ uniqueDispenser opts ++ " __cont of { (__cont, " ++ getName nm ++ ") -> ") ++ outp ++ h "}" h s = [HsToken s noPos] finalout us = h ("(__cont, " ++ concat (intersperse "," (map getName us)) ++ ")") wrap ref inp = h "case " ++ [AGField _LHS ref noPos Nothing] ++ h " of { __cont | __cont `seq` True -> " ++ inp ++ h "}" {-# LINE 270 "../src-derived/Transform.hs" #-} {-# LINE 625 "Transform.ag" #-} flattenDatas :: DataTypes -> Map NontermIdent (Set NontermIdent) flattenDatas ds = Map.map flatten ds where flatten cs = Set.fromList [ nt | (_,NT nt _) <- concatMap snd (Map.toList cs)] reachableFrom :: Map NontermIdent (Set NontermIdent) -> Set NontermIdent -> Set NontermIdent reachableFrom table nts = reach nts where reach nts = let nts' = Set.unions (nts : [ ns | nt <- Set.toList nts , let ns = Map.findWithDefault Set.empty nt table ]) in if Set.size nts' > Set.size nts then reach nts' else nts invert :: Map NontermIdent (Set NontermIdent) -> Map NontermIdent (Set NontermIdent) invert m = foldr inv Map.empty (Map.toList m) where inv (x,ns) m = fold (\n m -> Map.insertWith Set.union n (Set.singleton x) m) m ns path :: Map NontermIdent (Set NontermIdent) -> NontermIdent -> NontermIdent -> Set NontermIdent path table from to = let children = Map.findWithDefault Set.empty from table forward = reachableFrom table children backward = reachableFrom (invert table) (Set.singleton to) in Set.intersection forward backward {-# LINE 295 "../src-derived/Transform.hs" #-} {-# LINE 733 "Transform.ag" #-} pragmaMapUnion :: PragmaMap -> PragmaMap -> PragmaMap pragmaMapUnion = Map.unionWith (Map.unionWith Set.union) pragmaMapSingle :: NontermIdent -> ConstructorIdent -> Set Identifier -> PragmaMap pragmaMapSingle nt con nms = Map.singleton nt (Map.singleton con nms) {-# LINE 304 "../src-derived/Transform.hs" #-} {-# LINE 765 "Transform.ag" #-} orderMapUnion :: AttrOrderMap -> AttrOrderMap -> AttrOrderMap orderMapUnion = Map.unionWith (Map.unionWith Set.union) orderMapSingle :: NontermIdent -> ConstructorIdent -> Set Dependency -> AttrOrderMap orderMapSingle nt con deps = Map.singleton nt (Map.singleton con deps) {-# LINE 313 "../src-derived/Transform.hs" #-} {-# LINE 791 "Transform.ag" #-} mergeParams :: ParamMap -> ParamMap -> ParamMap mergeParams = Map.unionWith (++) {-# LINE 319 "../src-derived/Transform.hs" #-} {-# LINE 814 "Transform.ag" #-} mergeCtx :: ContextMap -> ContextMap -> ContextMap mergeCtx = Map.unionWith nubconcat where nubconcat a b = nub (a ++ b) {-# LINE 327 "../src-derived/Transform.hs" #-} {-# LINE 827 "Transform.ag" #-} mergeDerivings m1 m2 = foldr (\(n,cs) m -> Map.insertWith Set.union n cs m) m2 (Map.toList m1) {-# LINE 332 "../src-derived/Transform.hs" #-} {-# LINE 838 "Transform.ag" #-} merge x y = foldr f y (Map.toList x) where f ~(k,v) m = Map.insertWith (Map.union) k v m {-# LINE 338 "../src-derived/Transform.hs" #-} {-# LINE 865 "Transform.ag" #-} checkAttrs allFields nts inherited synthesized decls = foldErrors check decls nts where check nt decls | not (nt `Map.member` allFields) = (decls,Seq.singleton(UndefNont nt)) | otherwise = let (inh,syn) = Map.findWithDefault (Map.empty,Map.empty) nt decls (inh',einh) = checkDuplicates (DupInhAttr nt) inherited inh (syn',esyn) = checkDuplicates (DupSynAttr nt) synthesized syn in (Map.insert nt (inh',syn') decls,einh >< esyn) {-# LINE 348 "../src-derived/Transform.hs" #-} {-# LINE 876 "Transform.ag" #-} addSelf name atMap = let (eInh,eSyn) = Map.findWithDefault(Map.empty,Map.empty) name atMap in Map.insert name (eInh, Map.insert (Ident "self" noPos) (NT _SELF []) eSyn)atMap {-# LINE 354 "../src-derived/Transform.hs" #-} {-# LINE 1006 "Transform.ag" #-} makeType :: Set NontermIdent -> Type -> Type makeType nts tp@(NT x _) | x == _SELF = tp | Set.member x nts = tp | otherwise = Haskell (typeToHaskellString Nothing [] tp) makeType _ tp = tp {-# LINE 363 "../src-derived/Transform.hs" #-} {-# LINE 1013 "Transform.ag" #-} constructGrammar :: Set NontermIdent -> ParamMap -> DataTypes -> Map NontermIdent (Attributes, Attributes) -> Map NontermIdent (Map Identifier (String, String, String)) -> Derivings -> Set NontermIdent -> Map NontermIdent (Map ConstructorIdent [Rule]) -> Map NontermIdent (Map ConstructorIdent [TypeSig]) -> Map NontermIdent (Map ConstructorIdent [(Identifier, Type)]) -> TypeSyns -> PragmaMap -> AttrOrderMap -> ContextMap -> UniqueMap -> Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression])) -> Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression])) -> Grammar constructGrammar nts ntParams gram attrs uses derivings wrappers allrules tsigs allinsts tsyns pragmaMap orderMap contextMap uniqueMap augmentsMap aroundsMap = let gr = [ (nt,Map.toList alts) | (nt,alts) <- Map.toList gram] nonts = map nont gr nont (nt,alts) = let (inh,syn) = Map.findWithDefault (Map.empty,Map.empty) nt attrs rmap = Map.findWithDefault Map.empty nt allrules tsmap = Map.findWithDefault Map.empty nt tsigs instsmap = Map.findWithDefault Map.empty nt allinsts params = Map.findWithDefault [] nt ntParams alt (con,flds) = let rules = maybe [] id (Map.lookup con rmap) tsigs = maybe [] id (Map.lookup con tsmap) insts = maybe [] id (Map.lookup con instsmap) -- important: keep order of children cldrn = map child (flds ++ filter (not . existsAsField) insts) child (nm, tp) = let tpI = if existsAsInst nm then fromJust $ lookup nm insts else tp (inh,syn) = case tpI of NT nt _ -> let nt' = maybe nt id (deforestedNt nt) in Map.findWithDefault (Map.empty,Map.empty) nt' attrs _ -> (Map.empty,Map.empty) virt = if existsAsInst nm then case lookup nm flds of Just tp' -> Just (Just tp') Nothing -> Just Nothing else Nothing in Child nm tpI inh syn virt existsAsInst nm = maybe False (const True) (lookup nm insts) existsAsField (nm,_) = maybe False (const True) (lookup nm flds) in Production con cldrn rules tsigs in Nonterminal nt params inh syn (map alt alts) in Grammar tsyns uses derivings wrappers nonts pragmaMap orderMap ntParams contextMap uniqueMap augmentsMap aroundsMap {-# LINE 420 "../src-derived/Transform.hs" #-} {-# LINE 1069 "Transform.ag" #-} mapUnionWithSetUnion = Map.unionWith Set.union mapUnionWithPlusPlus = Map.unionWith (++) {-# LINE 426 "../src-derived/Transform.hs" #-} -- AG ---------------------------------------------------------- {- visit 0: inherited attribute: options : Options synthesized attributes: blocks : Blocks errors : Seq Error moduleDecl : Maybe (String,String,String) output : Grammar pragmas : Options -> Options alternatives: alternative AG: child elems : Elems visit 0: local allFields : _ local allConstrs : _ local allRules : _ local allSigs : _ local allInsts : _ local allUniques : _ local allAugments : _ local allArounds : _ local augmentSigs : _ local allRulesErrs : _ local allNamesErrs : _ local allSigsErrs : _ local allInstsErrs : _ local allUniquesErrs : _ local allAugmentErrs : _ local allAroundsErrs : _ local checkedRulesPre : _ local checkedSigs : _ local checkedInsts : _ local checkedUniques : _ local checkedAugments : _ local checkedArounds : _ local checkedRules : _ local errs1 : _ local errs2 : _ local errs3 : _ local errs4 : _ local errs5 : _ local errs6 : _ local errs7 : _ local errs8 : _ local errs9 : _ local errs10 : _ local allNonterminals : _ local allAttrDecls : _ -} -- cata sem_AG :: AG -> T_AG sem_AG (AG _elems ) = (sem_AG_AG (sem_Elems _elems ) ) -- semantic domain newtype T_AG = T_AG (Options -> ( Blocks,(Seq Error),(Maybe (String,String,String)),Grammar,(Options -> Options))) data Inh_AG = Inh_AG {options_Inh_AG :: !(Options)} data Syn_AG = Syn_AG {blocks_Syn_AG :: !(Blocks),errors_Syn_AG :: !((Seq Error)),moduleDecl_Syn_AG :: !((Maybe (String,String,String))),output_Syn_AG :: !(Grammar),pragmas_Syn_AG :: !((Options -> Options))} wrap_AG :: T_AG -> Inh_AG -> Syn_AG wrap_AG (T_AG sem ) (Inh_AG _lhsIoptions ) = (let ( _lhsOblocks,_lhsOerrors,_lhsOmoduleDecl,_lhsOoutput,_lhsOpragmas) = (sem _lhsIoptions ) in (Syn_AG _lhsOblocks _lhsOerrors _lhsOmoduleDecl _lhsOoutput _lhsOpragmas )) sem_AG_AG :: T_Elems -> T_AG sem_AG_AG (T_Elems elems_ ) = (T_AG (\ _lhsIoptions -> (let _lhsOoutput :: Grammar _lhsOerrors :: (Seq Error) _elemsOallConstructors :: (Map NontermIdent (Set ConstructorIdent)) _elemsOdefSets :: (Map Identifier (Set NontermIdent,Set Identifier)) _elemsOdefinedSets :: DefinedSets _elemsOattrDecls :: (Map NontermIdent (Attributes, Attributes)) _lhsOblocks :: Blocks _lhsOmoduleDecl :: (Maybe (String,String,String)) _lhsOpragmas :: (Options -> Options) _elemsOallAttrDecls :: (Map NontermIdent (Attributes, Attributes)) _elemsOallFields :: DataTypes _elemsOallNonterminals :: (Set NontermIdent) _elemsIattrDecls :: (Map NontermIdent (Attributes, Attributes)) _elemsIattrOrderCollect :: AttrOrderMap _elemsIblocks :: Blocks _elemsIcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ]) _elemsIcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ]) _elemsIcollectedConstructorsMap :: (Map NontermIdent (Set ConstructorIdent)) _elemsIcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)]) _elemsIcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ]) _elemsIcollectedNames :: (Set Identifier) _elemsIcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)]) _elemsIcollectedSetNames :: (Set Identifier) _elemsIcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ]) _elemsIcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ]) _elemsIctxCollect :: ContextMap _elemsIdefSets :: (Map Identifier (Set NontermIdent,Set Identifier)) _elemsIderivings :: Derivings _elemsIerrors :: (Seq Error) _elemsImoduleDecl :: (Maybe (String,String,String)) _elemsIparamsCollect :: ParamMap _elemsIpragmas :: (Options -> Options) _elemsIsemPragmasCollect :: PragmaMap _elemsItypeSyns :: TypeSyns _elemsIuseMap :: (Map NontermIdent (Map Identifier (String,String,String))) _elemsIwrappers :: (Set NontermIdent) -- "Transform.ag"(line 51, column 8) _lhsOoutput = ({-# LINE 51 "Transform.ag" #-} constructGrammar _allNonterminals _elemsIparamsCollect _allFields _allAttrDecls _elemsIuseMap _elemsIderivings (if wrappers _lhsIoptions then _allNonterminals else _elemsIwrappers) _checkedRules _checkedSigs _checkedInsts _elemsItypeSyns _elemsIsemPragmasCollect _elemsIattrOrderCollect _elemsIctxCollect _checkedUniques _checkedAugments _checkedArounds {-# LINE 555 "Transform.hs" #-}) -- "Transform.ag"(line 243, column 10) _allFields = ({-# LINE 243 "Transform.ag" #-} let f (nt,con,fm) = Map.insertWith (Map.unionWith (++)) nt (Map.singleton con fm) in foldr f (Map.empty) _elemsIcollectedFields {-# LINE 561 "Transform.hs" #-}) -- "Transform.ag"(line 246, column 10) _allConstrs = ({-# LINE 246 "Transform.ag" #-} let f (nt,con,_) = Map.insertWith (++) nt [con] in foldr f (Map.empty) _elemsIcollectedFields {-# LINE 567 "Transform.hs" #-}) -- "Transform.ag"(line 249, column 10) _allRules = ({-# LINE 249 "Transform.ag" #-} let f (nt,con,r) = Map.insertWith (Map.unionWith (++)) nt (Map.singleton con [r]) in foldr f (Map.empty) _elemsIcollectedRules {-# LINE 573 "Transform.hs" #-}) -- "Transform.ag"(line 252, column 10) _allSigs = ({-# LINE 252 "Transform.ag" #-} let f (nt,con,t) = Map.insertWith (Map.unionWith (++)) nt (Map.singleton con [t]) typeof nt r = Map.findWithDefault (Haskell "") r $ fst $ Map.findWithDefault (Map.empty,Map.empty) nt _allAttrDecls in foldr f (Map.empty) ( _elemsIcollectedSigs ++ [ (nt, con, (ident,typeof nt ref)) | (nt, con, us) <- _elemsIcollectedUniques, (ident,ref) <- us ] ) {-# LINE 582 "Transform.hs" #-}) -- "Transform.ag"(line 258, column 10) _allInsts = ({-# LINE 258 "Transform.ag" #-} let f (nt,con,is) = Map.insertWith (Map.unionWith (++)) nt (Map.singleton con is) in foldr f (Map.empty) _elemsIcollectedInsts {-# LINE 588 "Transform.hs" #-}) -- "Transform.ag"(line 261, column 10) _allUniques = ({-# LINE 261 "Transform.ag" #-} let f (nt,con,us) = Map.insertWith (Map.unionWith (++)) nt (Map.singleton con us) in foldr f (Map.empty) _elemsIcollectedUniques {-# LINE 594 "Transform.hs" #-}) -- "Transform.ag"(line 263, column 10) _allAugments = ({-# LINE 263 "Transform.ag" #-} let f (nt,con,as) = Map.insertWith (Map.unionWith (++)) nt (Map.singleton con as) in foldr f Map.empty _elemsIcollectedAugments {-# LINE 600 "Transform.hs" #-}) -- "Transform.ag"(line 265, column 10) _allArounds = ({-# LINE 265 "Transform.ag" #-} let f (nt,con,as) = Map.insertWith (Map.unionWith (++)) nt (Map.singleton con as) in foldr f Map.empty _elemsIcollectedArounds {-# LINE 606 "Transform.hs" #-}) -- "Transform.ag"(line 268, column 10) _augmentSigs = ({-# LINE 268 "Transform.ag" #-} let gen mp = [] in Map.map (Map.map gen) _allAugments {-# LINE 612 "Transform.hs" #-}) -- "Transform.ag"(line 271, column 10) _allRulesErrs = ({-# LINE 271 "Transform.ag" #-} Map.mapWithKey (Map.mapWithKey . (checkRules _allAttrDecls _allFields _allInsts _allSigs )) _allRules {-# LINE 617 "Transform.hs" #-}) -- "Transform.ag"(line 272, column 10) _allNamesErrs = ({-# LINE 272 "Transform.ag" #-} Map.mapWithKey (Map.mapWithKey . checkRuleNames) _allRules {-# LINE 622 "Transform.hs" #-}) -- "Transform.ag"(line 273, column 10) _allSigsErrs = ({-# LINE 273 "Transform.ag" #-} Map.mapWithKey (Map.mapWithKey . (checkSigs )) _allSigs {-# LINE 627 "Transform.hs" #-}) -- "Transform.ag"(line 274, column 10) _allInstsErrs = ({-# LINE 274 "Transform.ag" #-} Map.mapWithKey (Map.mapWithKey . (checkInsts _allNonterminals _allSigs _allFields )) _allInsts {-# LINE 632 "Transform.hs" #-}) -- "Transform.ag"(line 275, column 10) _allUniquesErrs = ({-# LINE 275 "Transform.ag" #-} Map.mapWithKey (Map.mapWithKey . (checkUniques _allAttrDecls )) _allUniques {-# LINE 637 "Transform.hs" #-}) -- "Transform.ag"(line 276, column 10) _allAugmentErrs = ({-# LINE 276 "Transform.ag" #-} Map.mapWithKey (Map.mapWithKey . (checkAugments _allAttrDecls )) _allAugments {-# LINE 642 "Transform.hs" #-}) -- "Transform.ag"(line 277, column 10) _allAroundsErrs = ({-# LINE 277 "Transform.ag" #-} Map.mapWithKey (Map.mapWithKey . (checkArounds _allFields )) _allArounds {-# LINE 647 "Transform.hs" #-}) -- "Transform.ag"(line 279, column 10) _checkedRulesPre = ({-# LINE 279 "Transform.ag" #-} Map.map (Map.map fst) _allRulesErrs {-# LINE 652 "Transform.hs" #-}) -- "Transform.ag"(line 280, column 10) _checkedSigs = ({-# LINE 280 "Transform.ag" #-} Map.map (Map.map fst) _allSigsErrs `unionunionplusplus` _augmentSigs {-# LINE 657 "Transform.hs" #-}) -- "Transform.ag"(line 281, column 10) _checkedInsts = ({-# LINE 281 "Transform.ag" #-} Map.map (Map.map fst) _allInstsErrs {-# LINE 662 "Transform.hs" #-}) -- "Transform.ag"(line 282, column 10) _checkedUniques = ({-# LINE 282 "Transform.ag" #-} Map.map (Map.map fst) _allUniquesErrs {-# LINE 667 "Transform.hs" #-}) -- "Transform.ag"(line 283, column 10) _checkedAugments = ({-# LINE 283 "Transform.ag" #-} Map.map (Map.map fst) _allAugmentErrs {-# LINE 672 "Transform.hs" #-}) -- "Transform.ag"(line 284, column 10) _checkedArounds = ({-# LINE 284 "Transform.ag" #-} Map.map (Map.map fst) _allAroundsErrs {-# LINE 677 "Transform.hs" #-}) -- "Transform.ag"(line 285, column 10) _checkedRules = ({-# LINE 285 "Transform.ag" #-} Map.unionWith (Map.unionWith (++)) _checkedRulesPre (Map.mapWithKey (Map.mapWithKey . (mkUniqueRules _lhsIoptions _allFields _allAttrDecls )) _checkedUniques ) {-# LINE 682 "Transform.hs" #-}) -- "Transform.ag"(line 287, column 10) _errs1 = ({-# LINE 287 "Transform.ag" #-} let f = checkForDuplicates (DupSynonym) in Seq.fromList . f . map fst $ _elemsItypeSyns {-# LINE 688 "Transform.hs" #-}) -- "Transform.ag"(line 290, column 10) _errs2 = ({-# LINE 290 "Transform.ag" #-} let g nt (con,fm) = checkForDuplicates (DupChild nt con) (map fst fm) f (nt,cfm) = concat . map (g nt) . Map.toList $ cfm in Seq.fromList . concat . map f . Map.toList $ _allFields {-# LINE 695 "Transform.hs" #-}) -- "Transform.ag"(line 294, column 10) _errs3 = ({-# LINE 294 "Transform.ag" #-} let f (nt,cons) = checkForDuplicates (DupAlt nt) cons in Seq.empty {-# LINE 701 "Transform.hs" #-}) -- "Transform.ag"(line 298, column 10) _errs4 = ({-# LINE 298 "Transform.ag" #-} let f m s = Map.fold ((><) . snd) s m in Map.fold f Seq.empty _allRulesErrs {-# LINE 707 "Transform.hs" #-}) -- "Transform.ag"(line 301, column 10) _errs5 = ({-# LINE 301 "Transform.ag" #-} let f m s = Map.fold ((><) . snd) s m in Map.fold f Seq.empty _allSigsErrs {-# LINE 713 "Transform.hs" #-}) -- "Transform.ag"(line 304, column 10) _errs6 = ({-# LINE 304 "Transform.ag" #-} let f m s = Map.fold ((><) . snd) s m in Map.fold f Seq.empty _allInstsErrs {-# LINE 719 "Transform.hs" #-}) -- "Transform.ag"(line 307, column 10) _errs7 = ({-# LINE 307 "Transform.ag" #-} let f m s = Map.fold ((><) . snd) s m in Map.fold f Seq.empty _allUniquesErrs {-# LINE 725 "Transform.hs" #-}) -- "Transform.ag"(line 310, column 10) _errs8 = ({-# LINE 310 "Transform.ag" #-} let f m s = Map.fold ((><) . snd) s m in Map.fold f Seq.empty _allAugmentErrs {-# LINE 731 "Transform.hs" #-}) -- "Transform.ag"(line 313, column 10) _errs9 = ({-# LINE 313 "Transform.ag" #-} let f m s = Map.fold ((><) . snd) s m in Map.fold f Seq.empty _allAroundsErrs {-# LINE 737 "Transform.hs" #-}) -- "Transform.ag"(line 316, column 10) _errs10 = ({-# LINE 316 "Transform.ag" #-} let f m s = Map.fold ((><)) s m in Map.fold f Seq.empty _allNamesErrs {-# LINE 743 "Transform.hs" #-}) -- "Transform.ag"(line 319, column 10) _lhsOerrors = ({-# LINE 319 "Transform.ag" #-} _elemsIerrors >< _errs1 >< _errs2 >< _errs3 >< _errs4 >< _errs5 >< _errs6 >< _errs7 >< _errs8 >< _errs9 >< _errs10 {-# LINE 748 "Transform.hs" #-}) -- "Transform.ag"(line 498, column 10) _allNonterminals = ({-# LINE 498 "Transform.ag" #-} _elemsIcollectedNames `Set.difference` _elemsIcollectedSetNames {-# LINE 753 "Transform.hs" #-}) -- "Transform.ag"(line 518, column 8) _elemsOallConstructors = ({-# LINE 518 "Transform.ag" #-} _elemsIcollectedConstructorsMap {-# LINE 758 "Transform.hs" #-}) -- "Transform.ag"(line 591, column 8) _elemsOdefSets = ({-# LINE 591 "Transform.ag" #-} Map.fromList (map (\x->(x,(Set.singleton x, Set.empty))) (Set.toList _allNonterminals )) {-# LINE 763 "Transform.hs" #-}) -- "Transform.ag"(line 592, column 8) _elemsOdefinedSets = ({-# LINE 592 "Transform.ag" #-} Map.map fst _elemsIdefSets {-# LINE 768 "Transform.hs" #-}) -- "Transform.ag"(line 844, column 8) _elemsOattrDecls = ({-# LINE 844 "Transform.ag" #-} Map.empty {-# LINE 773 "Transform.hs" #-}) -- "Transform.ag"(line 883, column 9) _allAttrDecls = ({-# LINE 883 "Transform.ag" #-} if withSelf _lhsIoptions then foldr addSelf _elemsIattrDecls (Set.toList _allNonterminals ) else _elemsIattrDecls {-# LINE 780 "Transform.hs" #-}) -- use rule "Transform.ag"(line 44, column 19) _lhsOblocks = ({-# LINE 44 "Transform.ag" #-} _elemsIblocks {-# LINE 785 "Transform.hs" #-}) -- use rule "Transform.ag"(line 996, column 37) _lhsOmoduleDecl = ({-# LINE 996 "Transform.ag" #-} _elemsImoduleDecl {-# LINE 790 "Transform.hs" #-}) -- use rule "Transform.ag"(line 673, column 34) _lhsOpragmas = ({-# LINE 673 "Transform.ag" #-} _elemsIpragmas {-# LINE 795 "Transform.hs" #-}) -- copy rule (from local) _elemsOallAttrDecls = ({-# LINE 746 "Transform.ag" #-} _allAttrDecls {-# LINE 800 "Transform.hs" #-}) -- copy rule (from local) _elemsOallFields = ({-# LINE 126 "Transform.ag" #-} _allFields {-# LINE 805 "Transform.hs" #-}) -- copy rule (from local) _elemsOallNonterminals = ({-# LINE 86 "Transform.ag" #-} _allNonterminals {-# LINE 810 "Transform.hs" #-}) ( _elemsIattrDecls,_elemsIattrOrderCollect,_elemsIblocks,_elemsIcollectedArounds,_elemsIcollectedAugments,_elemsIcollectedConstructorsMap,_elemsIcollectedFields,_elemsIcollectedInsts,_elemsIcollectedNames,_elemsIcollectedRules,_elemsIcollectedSetNames,_elemsIcollectedSigs,_elemsIcollectedUniques,_elemsIctxCollect,_elemsIdefSets,_elemsIderivings,_elemsIerrors,_elemsImoduleDecl,_elemsIparamsCollect,_elemsIpragmas,_elemsIsemPragmasCollect,_elemsItypeSyns,_elemsIuseMap,_elemsIwrappers) = (elems_ _elemsOallAttrDecls _elemsOallConstructors _elemsOallFields _elemsOallNonterminals _elemsOattrDecls _elemsOdefSets _elemsOdefinedSets ) in ( _lhsOblocks,_lhsOerrors,_lhsOmoduleDecl,_lhsOoutput,_lhsOpragmas))) ) -- Alt --------------------------------------------------------- {- visit 0: inherited attributes: allConstructors : Map NontermIdent (Set ConstructorIdent) allNonterminals : Set NontermIdent nts : Set NontermIdent synthesized attributes: collectedConstructorNames : Set ConstructorIdent collectedFields : [(NontermIdent, ConstructorIdent, FieldMap)] alternatives: alternative Alt: child pos : {Pos} child names : ConstructorSet child fields : {Fields} -} -- cata sem_Alt :: Alt -> T_Alt sem_Alt (Alt _pos _names _fields ) = (sem_Alt_Alt _pos (sem_ConstructorSet _names ) _fields ) -- semantic domain newtype T_Alt = T_Alt ((Map NontermIdent (Set ConstructorIdent)) -> (Set NontermIdent) -> (Set NontermIdent) -> ( (Set ConstructorIdent),([(NontermIdent, ConstructorIdent, FieldMap)]))) data Inh_Alt = Inh_Alt {allConstructors_Inh_Alt :: !((Map NontermIdent (Set ConstructorIdent))),allNonterminals_Inh_Alt :: !((Set NontermIdent)),nts_Inh_Alt :: !((Set NontermIdent))} data Syn_Alt = Syn_Alt {collectedConstructorNames_Syn_Alt :: !((Set ConstructorIdent)),collectedFields_Syn_Alt :: !(([(NontermIdent, ConstructorIdent, FieldMap)]))} wrap_Alt :: T_Alt -> Inh_Alt -> Syn_Alt wrap_Alt (T_Alt sem ) (Inh_Alt _lhsIallConstructors _lhsIallNonterminals _lhsInts ) = (let ( _lhsOcollectedConstructorNames,_lhsOcollectedFields) = (sem _lhsIallConstructors _lhsIallNonterminals _lhsInts ) in (Syn_Alt _lhsOcollectedConstructorNames _lhsOcollectedFields )) sem_Alt_Alt :: Pos -> T_ConstructorSet -> Fields -> T_Alt sem_Alt_Alt pos_ (T_ConstructorSet names_ ) fields_ = (T_Alt (\ _lhsIallConstructors _lhsIallNonterminals _lhsInts -> (let _lhsOcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)]) _lhsOcollectedConstructorNames :: (Set ConstructorIdent) _namesIcollectedConstructorNames :: (Set ConstructorIdent) _namesIconstructors :: ((Set ConstructorIdent->Set ConstructorIdent)) _namesIerrors :: (Seq Error) -- "Transform.ag"(line 228, column 10) _lhsOcollectedFields = ({-# LINE 228 "Transform.ag" #-} let fieldTable = [ (attr, makeType _lhsIallNonterminals tp) | (attr, tp) <- fields_ ] in [ (nt, con, fieldTable) | nt <- Set.toList _lhsInts , con <- Set.toList (_namesIconstructors (Map.findWithDefault Set.empty nt _lhsIallConstructors)) ] {-# LINE 873 "Transform.hs" #-}) -- use rule "Transform.ag"(line 91, column 62) _lhsOcollectedConstructorNames = ({-# LINE 91 "Transform.ag" #-} _namesIcollectedConstructorNames {-# LINE 878 "Transform.hs" #-}) ( _namesIcollectedConstructorNames,_namesIconstructors,_namesIerrors) = (names_ ) in ( _lhsOcollectedConstructorNames,_lhsOcollectedFields))) ) -- Alts -------------------------------------------------------- {- visit 0: inherited attributes: allConstructors : Map NontermIdent (Set ConstructorIdent) allNonterminals : Set NontermIdent nts : Set NontermIdent synthesized attributes: collectedConstructorNames : Set ConstructorIdent collectedFields : [(NontermIdent, ConstructorIdent, FieldMap)] alternatives: alternative Cons: child hd : Alt child tl : Alts alternative Nil: -} -- cata sem_Alts :: Alts -> T_Alts sem_Alts list = (Prelude.foldr sem_Alts_Cons sem_Alts_Nil (Prelude.map sem_Alt list) ) -- semantic domain newtype T_Alts = T_Alts ((Map NontermIdent (Set ConstructorIdent)) -> (Set NontermIdent) -> (Set NontermIdent) -> ( (Set ConstructorIdent),([(NontermIdent, ConstructorIdent, FieldMap)]))) data Inh_Alts = Inh_Alts {allConstructors_Inh_Alts :: !((Map NontermIdent (Set ConstructorIdent))),allNonterminals_Inh_Alts :: !((Set NontermIdent)),nts_Inh_Alts :: !((Set NontermIdent))} data Syn_Alts = Syn_Alts {collectedConstructorNames_Syn_Alts :: !((Set ConstructorIdent)),collectedFields_Syn_Alts :: !(([(NontermIdent, ConstructorIdent, FieldMap)]))} wrap_Alts :: T_Alts -> Inh_Alts -> Syn_Alts wrap_Alts (T_Alts sem ) (Inh_Alts _lhsIallConstructors _lhsIallNonterminals _lhsInts ) = (let ( _lhsOcollectedConstructorNames,_lhsOcollectedFields) = (sem _lhsIallConstructors _lhsIallNonterminals _lhsInts ) in (Syn_Alts _lhsOcollectedConstructorNames _lhsOcollectedFields )) sem_Alts_Cons :: T_Alt -> T_Alts -> T_Alts sem_Alts_Cons (T_Alt hd_ ) (T_Alts tl_ ) = (T_Alts (\ _lhsIallConstructors _lhsIallNonterminals _lhsInts -> (let _lhsOcollectedConstructorNames :: (Set ConstructorIdent) _lhsOcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)]) _hdOallConstructors :: (Map NontermIdent (Set ConstructorIdent)) _hdOallNonterminals :: (Set NontermIdent) _hdOnts :: (Set NontermIdent) _tlOallConstructors :: (Map NontermIdent (Set ConstructorIdent)) _tlOallNonterminals :: (Set NontermIdent) _tlOnts :: (Set NontermIdent) _hdIcollectedConstructorNames :: (Set ConstructorIdent) _hdIcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)]) _tlIcollectedConstructorNames :: (Set ConstructorIdent) _tlIcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)]) -- use rule "Transform.ag"(line 91, column 62) _lhsOcollectedConstructorNames = ({-# LINE 91 "Transform.ag" #-} _hdIcollectedConstructorNames `Set.union` _tlIcollectedConstructorNames {-# LINE 940 "Transform.hs" #-}) -- use rule "Transform.ag"(line 123, column 28) _lhsOcollectedFields = ({-# LINE 123 "Transform.ag" #-} _hdIcollectedFields ++ _tlIcollectedFields {-# LINE 945 "Transform.hs" #-}) -- copy rule (down) _hdOallConstructors = ({-# LINE 94 "Transform.ag" #-} _lhsIallConstructors {-# LINE 950 "Transform.hs" #-}) -- copy rule (down) _hdOallNonterminals = ({-# LINE 86 "Transform.ag" #-} _lhsIallNonterminals {-# LINE 955 "Transform.hs" #-}) -- copy rule (down) _hdOnts = ({-# LINE 163 "Transform.ag" #-} _lhsInts {-# LINE 960 "Transform.hs" #-}) -- copy rule (down) _tlOallConstructors = ({-# LINE 94 "Transform.ag" #-} _lhsIallConstructors {-# LINE 965 "Transform.hs" #-}) -- copy rule (down) _tlOallNonterminals = ({-# LINE 86 "Transform.ag" #-} _lhsIallNonterminals {-# LINE 970 "Transform.hs" #-}) -- copy rule (down) _tlOnts = ({-# LINE 163 "Transform.ag" #-} _lhsInts {-# LINE 975 "Transform.hs" #-}) ( _hdIcollectedConstructorNames,_hdIcollectedFields) = (hd_ _hdOallConstructors _hdOallNonterminals _hdOnts ) ( _tlIcollectedConstructorNames,_tlIcollectedFields) = (tl_ _tlOallConstructors _tlOallNonterminals _tlOnts ) in ( _lhsOcollectedConstructorNames,_lhsOcollectedFields))) ) sem_Alts_Nil :: T_Alts sem_Alts_Nil = (T_Alts (\ _lhsIallConstructors _lhsIallNonterminals _lhsInts -> (let _lhsOcollectedConstructorNames :: (Set ConstructorIdent) _lhsOcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)]) -- use rule "Transform.ag"(line 91, column 62) _lhsOcollectedConstructorNames = ({-# LINE 91 "Transform.ag" #-} Set.empty {-# LINE 992 "Transform.hs" #-}) -- use rule "Transform.ag"(line 123, column 28) _lhsOcollectedFields = ({-# LINE 123 "Transform.ag" #-} [] {-# LINE 997 "Transform.hs" #-}) in ( _lhsOcollectedConstructorNames,_lhsOcollectedFields))) ) -- Attrs ------------------------------------------------------- {- visit 0: inherited attributes: allFields : DataTypes allNonterminals : Set NontermIdent nts : Set NontermIdent chained attribute: attrDecls : Map NontermIdent (Attributes, Attributes) synthesized attributes: errors : Seq Error useMap : Map NontermIdent (Map Identifier (String,String,String)) alternatives: alternative Attrs: child pos : {Pos} child inh : {AttrNames} child chn : {AttrNames} child syn : {AttrNames} visit 0: local _tup1 : _ local attrDecls : _ local errors : _ local _tup2 : _ local inherited : _ local synthesized : _ local useMap : _ -} -- cata sem_Attrs :: Attrs -> T_Attrs sem_Attrs (Attrs _pos _inh _chn _syn ) = (sem_Attrs_Attrs _pos _inh _chn _syn ) -- semantic domain newtype T_Attrs = T_Attrs (DataTypes -> (Set NontermIdent) -> (Map NontermIdent (Attributes, Attributes)) -> (Set NontermIdent) -> ( (Map NontermIdent (Attributes, Attributes)),(Seq Error),(Map NontermIdent (Map Identifier (String,String,String))))) data Inh_Attrs = Inh_Attrs {allFields_Inh_Attrs :: !(DataTypes),allNonterminals_Inh_Attrs :: !((Set NontermIdent)),attrDecls_Inh_Attrs :: !((Map NontermIdent (Attributes, Attributes))),nts_Inh_Attrs :: !((Set NontermIdent))} data Syn_Attrs = Syn_Attrs {attrDecls_Syn_Attrs :: !((Map NontermIdent (Attributes, Attributes))),errors_Syn_Attrs :: !((Seq Error)),useMap_Syn_Attrs :: !((Map NontermIdent (Map Identifier (String,String,String))))} wrap_Attrs :: T_Attrs -> Inh_Attrs -> Syn_Attrs wrap_Attrs (T_Attrs sem ) (Inh_Attrs _lhsIallFields _lhsIallNonterminals _lhsIattrDecls _lhsInts ) = (let ( _lhsOattrDecls,_lhsOerrors,_lhsOuseMap) = (sem _lhsIallFields _lhsIallNonterminals _lhsIattrDecls _lhsInts ) in (Syn_Attrs _lhsOattrDecls _lhsOerrors _lhsOuseMap )) sem_Attrs_Attrs :: Pos -> AttrNames -> AttrNames -> AttrNames -> T_Attrs sem_Attrs_Attrs pos_ inh_ chn_ syn_ = (T_Attrs (\ _lhsIallFields _lhsIallNonterminals _lhsIattrDecls _lhsInts -> (let _lhsOuseMap :: (Map NontermIdent (Map Identifier (String,String,String))) _lhsOerrors :: (Seq Error) _lhsOattrDecls :: (Map NontermIdent (Attributes, Attributes)) -- "Transform.ag"(line 852, column 15) __tup1 = ({-# LINE 852 "Transform.ag" #-} checkAttrs _lhsIallFields (Set.toList _lhsInts) _inherited _synthesized _lhsIattrDecls {-# LINE 1063 "Transform.hs" #-}) -- "Transform.ag"(line 852, column 15) (_attrDecls,_) = ({-# LINE 852 "Transform.ag" #-} __tup1 {-# LINE 1068 "Transform.hs" #-}) -- "Transform.ag"(line 852, column 15) (_,_errors) = ({-# LINE 852 "Transform.ag" #-} __tup1 {-# LINE 1073 "Transform.hs" #-}) -- "Transform.ag"(line 854, column 15) __tup2 = ({-# LINE 854 "Transform.ag" #-} let splitAttrs xs = unzip [ ((n,makeType _lhsIallNonterminals t),(n,ud)) | (n,t,ud) <- xs ] (inh,_) = splitAttrs inh_ (chn,uses1) = splitAttrs chn_ (syn,uses2) = splitAttrs syn_ isUse (n,(e1,e2,_)) = not (null e1 || null e2) in (inh++chn,chn++syn, Map.fromList (Prelude.filter isUse (uses1++uses2))) {-# LINE 1085 "Transform.hs" #-}) -- "Transform.ag"(line 854, column 15) (_inherited,_,_) = ({-# LINE 854 "Transform.ag" #-} __tup2 {-# LINE 1090 "Transform.hs" #-}) -- "Transform.ag"(line 854, column 15) (_,_synthesized,_) = ({-# LINE 854 "Transform.ag" #-} __tup2 {-# LINE 1095 "Transform.hs" #-}) -- "Transform.ag"(line 854, column 15) (_,_,_useMap) = ({-# LINE 854 "Transform.ag" #-} __tup2 {-# LINE 1100 "Transform.hs" #-}) -- "Transform.ag"(line 862, column 11) _lhsOuseMap = ({-# LINE 862 "Transform.ag" #-} Map.fromList (zip (Set.toList _lhsInts) (repeat _useMap)) {-# LINE 1105 "Transform.hs" #-}) -- use rule "Transform.ag"(line 42, column 19) _lhsOerrors = ({-# LINE 42 "Transform.ag" #-} _errors {-# LINE 1110 "Transform.hs" #-}) -- copy rule (from local) _lhsOattrDecls = ({-# LINE 134 "Transform.ag" #-} _attrDecls {-# LINE 1115 "Transform.hs" #-}) in ( _lhsOattrDecls,_lhsOerrors,_lhsOuseMap))) ) -- ConstructorSet ---------------------------------------------- {- visit 0: synthesized attributes: collectedConstructorNames : Set ConstructorIdent constructors : (Set ConstructorIdent->Set ConstructorIdent) errors : Seq Error alternatives: alternative CAll: alternative CDifference: child set1 : ConstructorSet child set2 : ConstructorSet alternative CName: child name : {ConstructorIdent} alternative CUnion: child set1 : ConstructorSet child set2 : ConstructorSet -} -- cata sem_ConstructorSet :: ConstructorSet -> T_ConstructorSet sem_ConstructorSet (CAll ) = (sem_ConstructorSet_CAll ) sem_ConstructorSet (CDifference _set1 _set2 ) = (sem_ConstructorSet_CDifference (sem_ConstructorSet _set1 ) (sem_ConstructorSet _set2 ) ) sem_ConstructorSet (CName _name ) = (sem_ConstructorSet_CName _name ) sem_ConstructorSet (CUnion _set1 _set2 ) = (sem_ConstructorSet_CUnion (sem_ConstructorSet _set1 ) (sem_ConstructorSet _set2 ) ) -- semantic domain newtype T_ConstructorSet = T_ConstructorSet (( (Set ConstructorIdent),((Set ConstructorIdent->Set ConstructorIdent)),(Seq Error))) data Inh_ConstructorSet = Inh_ConstructorSet {} data Syn_ConstructorSet = Syn_ConstructorSet {collectedConstructorNames_Syn_ConstructorSet :: !((Set ConstructorIdent)),constructors_Syn_ConstructorSet :: !(((Set ConstructorIdent->Set ConstructorIdent))),errors_Syn_ConstructorSet :: !((Seq Error))} wrap_ConstructorSet :: T_ConstructorSet -> Inh_ConstructorSet -> Syn_ConstructorSet wrap_ConstructorSet (T_ConstructorSet sem ) (Inh_ConstructorSet ) = (let ( _lhsOcollectedConstructorNames,_lhsOconstructors,_lhsOerrors) = (sem ) in (Syn_ConstructorSet _lhsOcollectedConstructorNames _lhsOconstructors _lhsOerrors )) sem_ConstructorSet_CAll :: T_ConstructorSet sem_ConstructorSet_CAll = (T_ConstructorSet (let _lhsOconstructors :: ((Set ConstructorIdent->Set ConstructorIdent)) _lhsOcollectedConstructorNames :: (Set ConstructorIdent) _lhsOerrors :: (Seq Error) -- "Transform.ag"(line 658, column 17) _lhsOconstructors = ({-# LINE 658 "Transform.ag" #-} \ds -> ds {-# LINE 1166 "Transform.hs" #-}) -- use rule "Transform.ag"(line 91, column 62) _lhsOcollectedConstructorNames = ({-# LINE 91 "Transform.ag" #-} Set.empty {-# LINE 1171 "Transform.hs" #-}) -- use rule "Transform.ag"(line 42, column 19) _lhsOerrors = ({-# LINE 42 "Transform.ag" #-} Seq.empty {-# LINE 1176 "Transform.hs" #-}) in ( _lhsOcollectedConstructorNames,_lhsOconstructors,_lhsOerrors)) ) sem_ConstructorSet_CDifference :: T_ConstructorSet -> T_ConstructorSet -> T_ConstructorSet sem_ConstructorSet_CDifference (T_ConstructorSet set1_ ) (T_ConstructorSet set2_ ) = (T_ConstructorSet (let _lhsOconstructors :: ((Set ConstructorIdent->Set ConstructorIdent)) _lhsOcollectedConstructorNames :: (Set ConstructorIdent) _lhsOerrors :: (Seq Error) _set1IcollectedConstructorNames :: (Set ConstructorIdent) _set1Iconstructors :: ((Set ConstructorIdent->Set ConstructorIdent)) _set1Ierrors :: (Seq Error) _set2IcollectedConstructorNames :: (Set ConstructorIdent) _set2Iconstructors :: ((Set ConstructorIdent->Set ConstructorIdent)) _set2Ierrors :: (Seq Error) -- "Transform.ag"(line 657, column 17) _lhsOconstructors = ({-# LINE 657 "Transform.ag" #-} \ds -> _set1Iconstructors ds `Set.difference` _set2Iconstructors ds {-# LINE 1195 "Transform.hs" #-}) -- use rule "Transform.ag"(line 91, column 62) _lhsOcollectedConstructorNames = ({-# LINE 91 "Transform.ag" #-} _set1IcollectedConstructorNames `Set.union` _set2IcollectedConstructorNames {-# LINE 1200 "Transform.hs" #-}) -- use rule "Transform.ag"(line 42, column 19) _lhsOerrors = ({-# LINE 42 "Transform.ag" #-} _set1Ierrors Seq.>< _set2Ierrors {-# LINE 1205 "Transform.hs" #-}) ( _set1IcollectedConstructorNames,_set1Iconstructors,_set1Ierrors) = (set1_ ) ( _set2IcollectedConstructorNames,_set2Iconstructors,_set2Ierrors) = (set2_ ) in ( _lhsOcollectedConstructorNames,_lhsOconstructors,_lhsOerrors)) ) sem_ConstructorSet_CName :: ConstructorIdent -> T_ConstructorSet sem_ConstructorSet_CName name_ = (T_ConstructorSet (let _lhsOcollectedConstructorNames :: (Set ConstructorIdent) _lhsOconstructors :: ((Set ConstructorIdent->Set ConstructorIdent)) _lhsOerrors :: (Seq Error) -- "Transform.ag"(line 506, column 11) _lhsOcollectedConstructorNames = ({-# LINE 506 "Transform.ag" #-} Set.singleton name_ {-# LINE 1221 "Transform.hs" #-}) -- "Transform.ag"(line 655, column 17) _lhsOconstructors = ({-# LINE 655 "Transform.ag" #-} \ds -> Set.singleton name_ {-# LINE 1226 "Transform.hs" #-}) -- use rule "Transform.ag"(line 42, column 19) _lhsOerrors = ({-# LINE 42 "Transform.ag" #-} Seq.empty {-# LINE 1231 "Transform.hs" #-}) in ( _lhsOcollectedConstructorNames,_lhsOconstructors,_lhsOerrors)) ) sem_ConstructorSet_CUnion :: T_ConstructorSet -> T_ConstructorSet -> T_ConstructorSet sem_ConstructorSet_CUnion (T_ConstructorSet set1_ ) (T_ConstructorSet set2_ ) = (T_ConstructorSet (let _lhsOconstructors :: ((Set ConstructorIdent->Set ConstructorIdent)) _lhsOcollectedConstructorNames :: (Set ConstructorIdent) _lhsOerrors :: (Seq Error) _set1IcollectedConstructorNames :: (Set ConstructorIdent) _set1Iconstructors :: ((Set ConstructorIdent->Set ConstructorIdent)) _set1Ierrors :: (Seq Error) _set2IcollectedConstructorNames :: (Set ConstructorIdent) _set2Iconstructors :: ((Set ConstructorIdent->Set ConstructorIdent)) _set2Ierrors :: (Seq Error) -- "Transform.ag"(line 656, column 17) _lhsOconstructors = ({-# LINE 656 "Transform.ag" #-} \ds -> _set1Iconstructors ds `Set.union` _set2Iconstructors ds {-# LINE 1250 "Transform.hs" #-}) -- use rule "Transform.ag"(line 91, column 62) _lhsOcollectedConstructorNames = ({-# LINE 91 "Transform.ag" #-} _set1IcollectedConstructorNames `Set.union` _set2IcollectedConstructorNames {-# LINE 1255 "Transform.hs" #-}) -- use rule "Transform.ag"(line 42, column 19) _lhsOerrors = ({-# LINE 42 "Transform.ag" #-} _set1Ierrors Seq.>< _set2Ierrors {-# LINE 1260 "Transform.hs" #-}) ( _set1IcollectedConstructorNames,_set1Iconstructors,_set1Ierrors) = (set1_ ) ( _set2IcollectedConstructorNames,_set2Iconstructors,_set2Ierrors) = (set2_ ) in ( _lhsOcollectedConstructorNames,_lhsOconstructors,_lhsOerrors)) ) -- Elem -------------------------------------------------------- {- visit 0: inherited attributes: allAttrDecls : Map NontermIdent (Attributes, Attributes) allConstructors : Map NontermIdent (Set ConstructorIdent) allFields : DataTypes allNonterminals : Set NontermIdent definedSets : DefinedSets chained attributes: attrDecls : Map NontermIdent (Attributes, Attributes) defSets : Map Identifier (Set NontermIdent,Set Identifier) synthesized attributes: attrOrderCollect : AttrOrderMap blocks : Blocks collectedArounds : [ (NontermIdent, ConstructorIdent, [AroundInfo]) ] collectedAugments : [ (NontermIdent, ConstructorIdent, [AugmentInfo]) ] collectedConstructorsMap : Map NontermIdent (Set ConstructorIdent) collectedFields : [(NontermIdent, ConstructorIdent, FieldMap)] collectedInsts : [ (NontermIdent, ConstructorIdent, [Identifier]) ] collectedNames : Set Identifier collectedRules : [ (NontermIdent, ConstructorIdent, RuleInfo)] collectedSetNames : Set Identifier collectedSigs : [ (NontermIdent, ConstructorIdent, SigInfo) ] collectedUniques : [ (NontermIdent, ConstructorIdent, [UniqueInfo]) ] ctxCollect : ContextMap derivings : Derivings errors : Seq Error moduleDecl : Maybe (String,String,String) paramsCollect : ParamMap pragmas : Options -> Options semPragmasCollect : PragmaMap typeSyns : TypeSyns useMap : Map NontermIdent (Map Identifier (String,String,String)) wrappers : Set NontermIdent alternatives: alternative Attr: child pos : {Pos} child ctx : {ClassContext} child names : NontSet child attrs : Attrs alternative Data: child pos : {Pos} child ctx : {ClassContext} child names : NontSet child params : {[Identifier]} child attrs : Attrs child alts : Alts child ext : {Bool} alternative Deriving: child pos : {Pos} child set : NontSet child classes : {[NontermIdent]} alternative Module: child pos : {Pos} child name : {String} child exports : {String} child imports : {String} alternative Pragma: child pos : {Pos} child names : {[NontermIdent]} alternative Sem: child pos : {Pos} child ctx : {ClassContext} child names : NontSet child attrs : Attrs child alts : SemAlts alternative Set: child pos : {Pos} child name : {NontermIdent} child set : NontSet visit 0: local _tup3 : _ local defSets2 : _ local errs : _ alternative Txt: child pos : {Pos} child name : {Identifier} child mbNt : {Maybe NontermIdent} child lines : {[String]} visit 0: local blockInfo : _ local blockValue : _ alternative Type: child pos : {Pos} child ctx : {ClassContext} child name : {NontermIdent} child params : {[Identifier]} child type : {ComplexType} visit 0: local expanded : _ local argType : _ alternative Wrapper: child pos : {Pos} child set : NontSet -} -- cata sem_Elem :: Elem -> T_Elem sem_Elem (Attr _pos _ctx _names _attrs ) = (sem_Elem_Attr _pos _ctx (sem_NontSet _names ) (sem_Attrs _attrs ) ) sem_Elem (Data _pos _ctx _names _params _attrs _alts _ext ) = (sem_Elem_Data _pos _ctx (sem_NontSet _names ) _params (sem_Attrs _attrs ) (sem_Alts _alts ) _ext ) sem_Elem (Deriving _pos _set _classes ) = (sem_Elem_Deriving _pos (sem_NontSet _set ) _classes ) sem_Elem (Module _pos _name _exports _imports ) = (sem_Elem_Module _pos _name _exports _imports ) sem_Elem (Pragma _pos _names ) = (sem_Elem_Pragma _pos _names ) sem_Elem (Sem _pos _ctx _names _attrs _alts ) = (sem_Elem_Sem _pos _ctx (sem_NontSet _names ) (sem_Attrs _attrs ) (sem_SemAlts _alts ) ) sem_Elem (Set _pos _name _set ) = (sem_Elem_Set _pos _name (sem_NontSet _set ) ) sem_Elem (Txt _pos _name _mbNt _lines ) = (sem_Elem_Txt _pos _name _mbNt _lines ) sem_Elem (Type _pos _ctx _name _params _type ) = (sem_Elem_Type _pos _ctx _name _params _type ) sem_Elem (Wrapper _pos _set ) = (sem_Elem_Wrapper _pos (sem_NontSet _set ) ) -- semantic domain newtype T_Elem = T_Elem ((Map NontermIdent (Attributes, Attributes)) -> (Map NontermIdent (Set ConstructorIdent)) -> DataTypes -> (Set NontermIdent) -> (Map NontermIdent (Attributes, Attributes)) -> (Map Identifier (Set NontermIdent,Set Identifier)) -> DefinedSets -> ( (Map NontermIdent (Attributes, Attributes)),AttrOrderMap,Blocks,([ (NontermIdent, ConstructorIdent, [AroundInfo]) ]),([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ]),(Map NontermIdent (Set ConstructorIdent)),([(NontermIdent, ConstructorIdent, FieldMap)]),([ (NontermIdent, ConstructorIdent, [Identifier]) ]),(Set Identifier),([ (NontermIdent, ConstructorIdent, RuleInfo)]),(Set Identifier),([ (NontermIdent, ConstructorIdent, SigInfo) ]),([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ]),ContextMap,(Map Identifier (Set NontermIdent,Set Identifier)),Derivings,(Seq Error),(Maybe (String,String,String)),ParamMap,(Options -> Options),PragmaMap,TypeSyns,(Map NontermIdent (Map Identifier (String,String,String))),(Set NontermIdent))) data Inh_Elem = Inh_Elem {allAttrDecls_Inh_Elem :: !((Map NontermIdent (Attributes, Attributes))),allConstructors_Inh_Elem :: !((Map NontermIdent (Set ConstructorIdent))),allFields_Inh_Elem :: !(DataTypes),allNonterminals_Inh_Elem :: !((Set NontermIdent)),attrDecls_Inh_Elem :: !((Map NontermIdent (Attributes, Attributes))),defSets_Inh_Elem :: !((Map Identifier (Set NontermIdent,Set Identifier))),definedSets_Inh_Elem :: !(DefinedSets)} data Syn_Elem = Syn_Elem {attrDecls_Syn_Elem :: !((Map NontermIdent (Attributes, Attributes))),attrOrderCollect_Syn_Elem :: !(AttrOrderMap),blocks_Syn_Elem :: !(Blocks),collectedArounds_Syn_Elem :: !(([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])),collectedAugments_Syn_Elem :: !(([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])),collectedConstructorsMap_Syn_Elem :: !((Map NontermIdent (Set ConstructorIdent))),collectedFields_Syn_Elem :: !(([(NontermIdent, ConstructorIdent, FieldMap)])),collectedInsts_Syn_Elem :: !(([ (NontermIdent, ConstructorIdent, [Identifier]) ])),collectedNames_Syn_Elem :: !((Set Identifier)),collectedRules_Syn_Elem :: !(([ (NontermIdent, ConstructorIdent, RuleInfo)])),collectedSetNames_Syn_Elem :: !((Set Identifier)),collectedSigs_Syn_Elem :: !(([ (NontermIdent, ConstructorIdent, SigInfo) ])),collectedUniques_Syn_Elem :: !(([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])),ctxCollect_Syn_Elem :: !(ContextMap),defSets_Syn_Elem :: !((Map Identifier (Set NontermIdent,Set Identifier))),derivings_Syn_Elem :: !(Derivings),errors_Syn_Elem :: !((Seq Error)),moduleDecl_Syn_Elem :: !((Maybe (String,String,String))),paramsCollect_Syn_Elem :: !(ParamMap),pragmas_Syn_Elem :: !((Options -> Options)),semPragmasCollect_Syn_Elem :: !(PragmaMap),typeSyns_Syn_Elem :: !(TypeSyns),useMap_Syn_Elem :: !((Map NontermIdent (Map Identifier (String,String,String)))),wrappers_Syn_Elem :: !((Set NontermIdent))} wrap_Elem :: T_Elem -> Inh_Elem -> Syn_Elem wrap_Elem (T_Elem sem ) (Inh_Elem _lhsIallAttrDecls _lhsIallConstructors _lhsIallFields _lhsIallNonterminals _lhsIattrDecls _lhsIdefSets _lhsIdefinedSets ) = (let ( _lhsOattrDecls,_lhsOattrOrderCollect,_lhsOblocks,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedConstructorsMap,_lhsOcollectedFields,_lhsOcollectedInsts,_lhsOcollectedNames,_lhsOcollectedRules,_lhsOcollectedSetNames,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOctxCollect,_lhsOdefSets,_lhsOderivings,_lhsOerrors,_lhsOmoduleDecl,_lhsOparamsCollect,_lhsOpragmas,_lhsOsemPragmasCollect,_lhsOtypeSyns,_lhsOuseMap,_lhsOwrappers) = (sem _lhsIallAttrDecls _lhsIallConstructors _lhsIallFields _lhsIallNonterminals _lhsIattrDecls _lhsIdefSets _lhsIdefinedSets ) in (Syn_Elem _lhsOattrDecls _lhsOattrOrderCollect _lhsOblocks _lhsOcollectedArounds _lhsOcollectedAugments _lhsOcollectedConstructorsMap _lhsOcollectedFields _lhsOcollectedInsts _lhsOcollectedNames _lhsOcollectedRules _lhsOcollectedSetNames _lhsOcollectedSigs _lhsOcollectedUniques _lhsOctxCollect _lhsOdefSets _lhsOderivings _lhsOerrors _lhsOmoduleDecl _lhsOparamsCollect _lhsOpragmas _lhsOsemPragmasCollect _lhsOtypeSyns _lhsOuseMap _lhsOwrappers )) sem_Elem_Attr :: Pos -> ClassContext -> T_NontSet -> T_Attrs -> T_Elem sem_Elem_Attr pos_ ctx_ (T_NontSet names_ ) (T_Attrs attrs_ ) = (T_Elem (\ _lhsIallAttrDecls _lhsIallConstructors _lhsIallFields _lhsIallNonterminals _lhsIattrDecls _lhsIdefSets _lhsIdefinedSets -> (let _lhsOctxCollect :: ContextMap _attrsOnts :: (Set NontermIdent) _lhsOattrOrderCollect :: AttrOrderMap _lhsOblocks :: Blocks _lhsOcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ]) _lhsOcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ]) _lhsOcollectedConstructorsMap :: (Map NontermIdent (Set ConstructorIdent)) _lhsOcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)]) _lhsOcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ]) _lhsOcollectedNames :: (Set Identifier) _lhsOcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)]) _lhsOcollectedSetNames :: (Set Identifier) _lhsOcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ]) _lhsOcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ]) _lhsOderivings :: Derivings _lhsOerrors :: (Seq Error) _lhsOmoduleDecl :: (Maybe (String,String,String)) _lhsOparamsCollect :: ParamMap _lhsOpragmas :: (Options -> Options) _lhsOsemPragmasCollect :: PragmaMap _lhsOtypeSyns :: TypeSyns _lhsOuseMap :: (Map NontermIdent (Map Identifier (String,String,String))) _lhsOwrappers :: (Set NontermIdent) _lhsOattrDecls :: (Map NontermIdent (Attributes, Attributes)) _lhsOdefSets :: (Map Identifier (Set NontermIdent,Set Identifier)) _namesOallFields :: DataTypes _namesOallNonterminals :: (Set NontermIdent) _namesOdefinedSets :: DefinedSets _attrsOallFields :: DataTypes _attrsOallNonterminals :: (Set NontermIdent) _attrsOattrDecls :: (Map NontermIdent (Attributes, Attributes)) _namesIcollectedNames :: (Set Identifier) _namesIerrors :: (Seq Error) _namesInontSet :: (Set NontermIdent) _attrsIattrDecls :: (Map NontermIdent (Attributes, Attributes)) _attrsIerrors :: (Seq Error) _attrsIuseMap :: (Map NontermIdent (Map Identifier (String,String,String))) -- "Transform.ag"(line 804, column 7) _lhsOctxCollect = ({-# LINE 804 "Transform.ag" #-} if null ctx_ then Map.empty else Map.fromList [(nt, ctx_) | nt <- Set.toList _namesInontSet] {-# LINE 1459 "Transform.hs" #-}) -- "Transform.ag"(line 848, column 10) _attrsOnts = ({-# LINE 848 "Transform.ag" #-} _namesInontSet {-# LINE 1464 "Transform.hs" #-}) -- use rule "Transform.ag"(line 745, column 55) _lhsOattrOrderCollect = ({-# LINE 745 "Transform.ag" #-} Map.empty {-# LINE 1469 "Transform.hs" #-}) -- use rule "Transform.ag"(line 44, column 19) _lhsOblocks = ({-# LINE 44 "Transform.ag" #-} Map.empty {-# LINE 1474 "Transform.hs" #-}) -- use rule "Transform.ag"(line 153, column 32) _lhsOcollectedArounds = ({-# LINE 153 "Transform.ag" #-} [] {-# LINE 1479 "Transform.hs" #-}) -- use rule "Transform.ag"(line 152, column 32) _lhsOcollectedAugments = ({-# LINE 152 "Transform.ag" #-} [] {-# LINE 1484 "Transform.hs" #-}) -- use rule "Transform.ag"(line 92, column 48) _lhsOcollectedConstructorsMap = ({-# LINE 92 "Transform.ag" #-} Map.empty {-# LINE 1489 "Transform.hs" #-}) -- use rule "Transform.ag"(line 123, column 28) _lhsOcollectedFields = ({-# LINE 123 "Transform.ag" #-} [] {-# LINE 1494 "Transform.hs" #-}) -- use rule "Transform.ag"(line 150, column 32) _lhsOcollectedInsts = ({-# LINE 150 "Transform.ag" #-} [] {-# LINE 1499 "Transform.hs" #-}) -- use rule "Transform.ag"(line 84, column 50) _lhsOcollectedNames = ({-# LINE 84 "Transform.ag" #-} _namesIcollectedNames {-# LINE 1504 "Transform.hs" #-}) -- use rule "Transform.ag"(line 148, column 32) _lhsOcollectedRules = ({-# LINE 148 "Transform.ag" #-} [] {-# LINE 1509 "Transform.hs" #-}) -- use rule "Transform.ag"(line 83, column 50) _lhsOcollectedSetNames = ({-# LINE 83 "Transform.ag" #-} Set.empty {-# LINE 1514 "Transform.hs" #-}) -- use rule "Transform.ag"(line 149, column 32) _lhsOcollectedSigs = ({-# LINE 149 "Transform.ag" #-} [] {-# LINE 1519 "Transform.hs" #-}) -- use rule "Transform.ag"(line 151, column 32) _lhsOcollectedUniques = ({-# LINE 151 "Transform.ag" #-} [] {-# LINE 1524 "Transform.hs" #-}) -- use rule "Transform.ag"(line 825, column 33) _lhsOderivings = ({-# LINE 825 "Transform.ag" #-} Map.empty {-# LINE 1529 "Transform.hs" #-}) -- use rule "Transform.ag"(line 42, column 19) _lhsOerrors = ({-# LINE 42 "Transform.ag" #-} _namesIerrors Seq.>< _attrsIerrors {-# LINE 1534 "Transform.hs" #-}) -- use rule "Transform.ag"(line 996, column 37) _lhsOmoduleDecl = ({-# LINE 996 "Transform.ag" #-} mzero {-# LINE 1539 "Transform.hs" #-}) -- use rule "Transform.ag"(line 777, column 37) _lhsOparamsCollect = ({-# LINE 777 "Transform.ag" #-} Map.empty {-# LINE 1544 "Transform.hs" #-}) -- use rule "Transform.ag"(line 673, column 34) _lhsOpragmas = ({-# LINE 673 "Transform.ag" #-} id {-# LINE 1549 "Transform.hs" #-}) -- use rule "Transform.ag"(line 717, column 56) _lhsOsemPragmasCollect = ({-# LINE 717 "Transform.ag" #-} Map.empty {-# LINE 1554 "Transform.hs" #-}) -- use rule "Transform.ag"(line 533, column 32) _lhsOtypeSyns = ({-# LINE 533 "Transform.ag" #-} [] {-# LINE 1559 "Transform.hs" #-}) -- use rule "Transform.ag"(line 135, column 15) _lhsOuseMap = ({-# LINE 135 "Transform.ag" #-} _attrsIuseMap {-# LINE 1564 "Transform.hs" #-}) -- use rule "Transform.ag"(line 664, column 32) _lhsOwrappers = ({-# LINE 664 "Transform.ag" #-} Set.empty {-# LINE 1569 "Transform.hs" #-}) -- copy rule (up) _lhsOattrDecls = ({-# LINE 134 "Transform.ag" #-} _attrsIattrDecls {-# LINE 1574 "Transform.hs" #-}) -- copy rule (chain) _lhsOdefSets = ({-# LINE 102 "Transform.ag" #-} _lhsIdefSets {-# LINE 1579 "Transform.hs" #-}) -- copy rule (down) _namesOallFields = ({-# LINE 126 "Transform.ag" #-} _lhsIallFields {-# LINE 1584 "Transform.hs" #-}) -- copy rule (down) _namesOallNonterminals = ({-# LINE 86 "Transform.ag" #-} _lhsIallNonterminals {-# LINE 1589 "Transform.hs" #-}) -- copy rule (down) _namesOdefinedSets = ({-# LINE 105 "Transform.ag" #-} _lhsIdefinedSets {-# LINE 1594 "Transform.hs" #-}) -- copy rule (down) _attrsOallFields = ({-# LINE 126 "Transform.ag" #-} _lhsIallFields {-# LINE 1599 "Transform.hs" #-}) -- copy rule (down) _attrsOallNonterminals = ({-# LINE 86 "Transform.ag" #-} _lhsIallNonterminals {-# LINE 1604 "Transform.hs" #-}) -- copy rule (down) _attrsOattrDecls = ({-# LINE 134 "Transform.ag" #-} _lhsIattrDecls {-# LINE 1609 "Transform.hs" #-}) ( _namesIcollectedNames,_namesIerrors,_namesInontSet) = (names_ _namesOallFields _namesOallNonterminals _namesOdefinedSets ) ( _attrsIattrDecls,_attrsIerrors,_attrsIuseMap) = (attrs_ _attrsOallFields _attrsOallNonterminals _attrsOattrDecls _attrsOnts ) in ( _lhsOattrDecls,_lhsOattrOrderCollect,_lhsOblocks,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedConstructorsMap,_lhsOcollectedFields,_lhsOcollectedInsts,_lhsOcollectedNames,_lhsOcollectedRules,_lhsOcollectedSetNames,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOctxCollect,_lhsOdefSets,_lhsOderivings,_lhsOerrors,_lhsOmoduleDecl,_lhsOparamsCollect,_lhsOpragmas,_lhsOsemPragmasCollect,_lhsOtypeSyns,_lhsOuseMap,_lhsOwrappers))) ) sem_Elem_Data :: Pos -> ClassContext -> T_NontSet -> ([Identifier]) -> T_Attrs -> T_Alts -> Bool -> T_Elem sem_Elem_Data pos_ ctx_ (T_NontSet names_ ) params_ (T_Attrs attrs_ ) (T_Alts alts_ ) ext_ = (T_Elem (\ _lhsIallAttrDecls _lhsIallConstructors _lhsIallFields _lhsIallNonterminals _lhsIattrDecls _lhsIdefSets _lhsIdefinedSets -> (let _altsOnts :: (Set NontermIdent) _lhsOcollectedConstructorsMap :: (Map NontermIdent (Set ConstructorIdent)) _lhsOparamsCollect :: ParamMap _lhsOctxCollect :: ContextMap _attrsOnts :: (Set NontermIdent) _lhsOattrOrderCollect :: AttrOrderMap _lhsOblocks :: Blocks _lhsOcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ]) _lhsOcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ]) _lhsOcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)]) _lhsOcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ]) _lhsOcollectedNames :: (Set Identifier) _lhsOcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)]) _lhsOcollectedSetNames :: (Set Identifier) _lhsOcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ]) _lhsOcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ]) _lhsOderivings :: Derivings _lhsOerrors :: (Seq Error) _lhsOmoduleDecl :: (Maybe (String,String,String)) _lhsOpragmas :: (Options -> Options) _lhsOsemPragmasCollect :: PragmaMap _lhsOtypeSyns :: TypeSyns _lhsOuseMap :: (Map NontermIdent (Map Identifier (String,String,String))) _lhsOwrappers :: (Set NontermIdent) _lhsOattrDecls :: (Map NontermIdent (Attributes, Attributes)) _lhsOdefSets :: (Map Identifier (Set NontermIdent,Set Identifier)) _namesOallFields :: DataTypes _namesOallNonterminals :: (Set NontermIdent) _namesOdefinedSets :: DefinedSets _attrsOallFields :: DataTypes _attrsOallNonterminals :: (Set NontermIdent) _attrsOattrDecls :: (Map NontermIdent (Attributes, Attributes)) _altsOallConstructors :: (Map NontermIdent (Set ConstructorIdent)) _altsOallNonterminals :: (Set NontermIdent) _namesIcollectedNames :: (Set Identifier) _namesIerrors :: (Seq Error) _namesInontSet :: (Set NontermIdent) _attrsIattrDecls :: (Map NontermIdent (Attributes, Attributes)) _attrsIerrors :: (Seq Error) _attrsIuseMap :: (Map NontermIdent (Map Identifier (String,String,String))) _altsIcollectedConstructorNames :: (Set ConstructorIdent) _altsIcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)]) -- "Transform.ag"(line 166, column 10) _altsOnts = ({-# LINE 166 "Transform.ag" #-} _namesInontSet {-# LINE 1677 "Transform.hs" #-}) -- "Transform.ag"(line 512, column 11) _lhsOcollectedConstructorsMap = ({-# LINE 512 "Transform.ag" #-} Map.fromList [ (n, _altsIcollectedConstructorNames) | n <- Set.toList _namesInontSet ] {-# LINE 1685 "Transform.hs" #-}) -- "Transform.ag"(line 781, column 7) _lhsOparamsCollect = ({-# LINE 781 "Transform.ag" #-} if null params_ then Map.empty else Map.fromList [(nt, params_) | nt <- Set.toList _namesInontSet] {-# LINE 1692 "Transform.hs" #-}) -- "Transform.ag"(line 804, column 7) _lhsOctxCollect = ({-# LINE 804 "Transform.ag" #-} if null ctx_ then Map.empty else Map.fromList [(nt, ctx_) | nt <- Set.toList _namesInontSet] {-# LINE 1699 "Transform.hs" #-}) -- "Transform.ag"(line 847, column 10) _attrsOnts = ({-# LINE 847 "Transform.ag" #-} _namesInontSet {-# LINE 1704 "Transform.hs" #-}) -- use rule "Transform.ag"(line 745, column 55) _lhsOattrOrderCollect = ({-# LINE 745 "Transform.ag" #-} Map.empty {-# LINE 1709 "Transform.hs" #-}) -- use rule "Transform.ag"(line 44, column 19) _lhsOblocks = ({-# LINE 44 "Transform.ag" #-} Map.empty {-# LINE 1714 "Transform.hs" #-}) -- use rule "Transform.ag"(line 153, column 32) _lhsOcollectedArounds = ({-# LINE 153 "Transform.ag" #-} [] {-# LINE 1719 "Transform.hs" #-}) -- use rule "Transform.ag"(line 152, column 32) _lhsOcollectedAugments = ({-# LINE 152 "Transform.ag" #-} [] {-# LINE 1724 "Transform.hs" #-}) -- use rule "Transform.ag"(line 123, column 28) _lhsOcollectedFields = ({-# LINE 123 "Transform.ag" #-} _altsIcollectedFields {-# LINE 1729 "Transform.hs" #-}) -- use rule "Transform.ag"(line 150, column 32) _lhsOcollectedInsts = ({-# LINE 150 "Transform.ag" #-} [] {-# LINE 1734 "Transform.hs" #-}) -- use rule "Transform.ag"(line 84, column 50) _lhsOcollectedNames = ({-# LINE 84 "Transform.ag" #-} _namesIcollectedNames {-# LINE 1739 "Transform.hs" #-}) -- use rule "Transform.ag"(line 148, column 32) _lhsOcollectedRules = ({-# LINE 148 "Transform.ag" #-} [] {-# LINE 1744 "Transform.hs" #-}) -- use rule "Transform.ag"(line 83, column 50) _lhsOcollectedSetNames = ({-# LINE 83 "Transform.ag" #-} Set.empty {-# LINE 1749 "Transform.hs" #-}) -- use rule "Transform.ag"(line 149, column 32) _lhsOcollectedSigs = ({-# LINE 149 "Transform.ag" #-} [] {-# LINE 1754 "Transform.hs" #-}) -- use rule "Transform.ag"(line 151, column 32) _lhsOcollectedUniques = ({-# LINE 151 "Transform.ag" #-} [] {-# LINE 1759 "Transform.hs" #-}) -- use rule "Transform.ag"(line 825, column 33) _lhsOderivings = ({-# LINE 825 "Transform.ag" #-} Map.empty {-# LINE 1764 "Transform.hs" #-}) -- use rule "Transform.ag"(line 42, column 19) _lhsOerrors = ({-# LINE 42 "Transform.ag" #-} _namesIerrors Seq.>< _attrsIerrors {-# LINE 1769 "Transform.hs" #-}) -- use rule "Transform.ag"(line 996, column 37) _lhsOmoduleDecl = ({-# LINE 996 "Transform.ag" #-} mzero {-# LINE 1774 "Transform.hs" #-}) -- use rule "Transform.ag"(line 673, column 34) _lhsOpragmas = ({-# LINE 673 "Transform.ag" #-} id {-# LINE 1779 "Transform.hs" #-}) -- use rule "Transform.ag"(line 717, column 56) _lhsOsemPragmasCollect = ({-# LINE 717 "Transform.ag" #-} Map.empty {-# LINE 1784 "Transform.hs" #-}) -- use rule "Transform.ag"(line 533, column 32) _lhsOtypeSyns = ({-# LINE 533 "Transform.ag" #-} [] {-# LINE 1789 "Transform.hs" #-}) -- use rule "Transform.ag"(line 135, column 15) _lhsOuseMap = ({-# LINE 135 "Transform.ag" #-} _attrsIuseMap {-# LINE 1794 "Transform.hs" #-}) -- use rule "Transform.ag"(line 664, column 32) _lhsOwrappers = ({-# LINE 664 "Transform.ag" #-} Set.empty {-# LINE 1799 "Transform.hs" #-}) -- copy rule (up) _lhsOattrDecls = ({-# LINE 134 "Transform.ag" #-} _attrsIattrDecls {-# LINE 1804 "Transform.hs" #-}) -- copy rule (chain) _lhsOdefSets = ({-# LINE 102 "Transform.ag" #-} _lhsIdefSets {-# LINE 1809 "Transform.hs" #-}) -- copy rule (down) _namesOallFields = ({-# LINE 126 "Transform.ag" #-} _lhsIallFields {-# LINE 1814 "Transform.hs" #-}) -- copy rule (down) _namesOallNonterminals = ({-# LINE 86 "Transform.ag" #-} _lhsIallNonterminals {-# LINE 1819 "Transform.hs" #-}) -- copy rule (down) _namesOdefinedSets = ({-# LINE 105 "Transform.ag" #-} _lhsIdefinedSets {-# LINE 1824 "Transform.hs" #-}) -- copy rule (down) _attrsOallFields = ({-# LINE 126 "Transform.ag" #-} _lhsIallFields {-# LINE 1829 "Transform.hs" #-}) -- copy rule (down) _attrsOallNonterminals = ({-# LINE 86 "Transform.ag" #-} _lhsIallNonterminals {-# LINE 1834 "Transform.hs" #-}) -- copy rule (down) _attrsOattrDecls = ({-# LINE 134 "Transform.ag" #-} _lhsIattrDecls {-# LINE 1839 "Transform.hs" #-}) -- copy rule (down) _altsOallConstructors = ({-# LINE 94 "Transform.ag" #-} _lhsIallConstructors {-# LINE 1844 "Transform.hs" #-}) -- copy rule (down) _altsOallNonterminals = ({-# LINE 86 "Transform.ag" #-} _lhsIallNonterminals {-# LINE 1849 "Transform.hs" #-}) ( _namesIcollectedNames,_namesIerrors,_namesInontSet) = (names_ _namesOallFields _namesOallNonterminals _namesOdefinedSets ) ( _attrsIattrDecls,_attrsIerrors,_attrsIuseMap) = (attrs_ _attrsOallFields _attrsOallNonterminals _attrsOattrDecls _attrsOnts ) ( _altsIcollectedConstructorNames,_altsIcollectedFields) = (alts_ _altsOallConstructors _altsOallNonterminals _altsOnts ) in ( _lhsOattrDecls,_lhsOattrOrderCollect,_lhsOblocks,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedConstructorsMap,_lhsOcollectedFields,_lhsOcollectedInsts,_lhsOcollectedNames,_lhsOcollectedRules,_lhsOcollectedSetNames,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOctxCollect,_lhsOdefSets,_lhsOderivings,_lhsOerrors,_lhsOmoduleDecl,_lhsOparamsCollect,_lhsOpragmas,_lhsOsemPragmasCollect,_lhsOtypeSyns,_lhsOuseMap,_lhsOwrappers))) ) sem_Elem_Deriving :: Pos -> T_NontSet -> ([NontermIdent]) -> T_Elem sem_Elem_Deriving pos_ (T_NontSet set_ ) classes_ = (T_Elem (\ _lhsIallAttrDecls _lhsIallConstructors _lhsIallFields _lhsIallNonterminals _lhsIattrDecls _lhsIdefSets _lhsIdefinedSets -> (let _lhsOderivings :: Derivings _lhsOattrOrderCollect :: AttrOrderMap _lhsOblocks :: Blocks _lhsOcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ]) _lhsOcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ]) _lhsOcollectedConstructorsMap :: (Map NontermIdent (Set ConstructorIdent)) _lhsOcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)]) _lhsOcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ]) _lhsOcollectedNames :: (Set Identifier) _lhsOcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)]) _lhsOcollectedSetNames :: (Set Identifier) _lhsOcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ]) _lhsOcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ]) _lhsOctxCollect :: ContextMap _lhsOerrors :: (Seq Error) _lhsOmoduleDecl :: (Maybe (String,String,String)) _lhsOparamsCollect :: ParamMap _lhsOpragmas :: (Options -> Options) _lhsOsemPragmasCollect :: PragmaMap _lhsOtypeSyns :: TypeSyns _lhsOuseMap :: (Map NontermIdent (Map Identifier (String,String,String))) _lhsOwrappers :: (Set NontermIdent) _lhsOattrDecls :: (Map NontermIdent (Attributes, Attributes)) _lhsOdefSets :: (Map Identifier (Set NontermIdent,Set Identifier)) _setOallFields :: DataTypes _setOallNonterminals :: (Set NontermIdent) _setOdefinedSets :: DefinedSets _setIcollectedNames :: (Set Identifier) _setIerrors :: (Seq Error) _setInontSet :: (Set NontermIdent) -- "Transform.ag"(line 832, column 14) _lhsOderivings = ({-# LINE 832 "Transform.ag" #-} Map.fromList [(nt,Set.fromList classes_) | nt <- Set.toList _setInontSet] {-# LINE 1903 "Transform.hs" #-}) -- use rule "Transform.ag"(line 745, column 55) _lhsOattrOrderCollect = ({-# LINE 745 "Transform.ag" #-} Map.empty {-# LINE 1908 "Transform.hs" #-}) -- use rule "Transform.ag"(line 44, column 19) _lhsOblocks = ({-# LINE 44 "Transform.ag" #-} Map.empty {-# LINE 1913 "Transform.hs" #-}) -- use rule "Transform.ag"(line 153, column 32) _lhsOcollectedArounds = ({-# LINE 153 "Transform.ag" #-} [] {-# LINE 1918 "Transform.hs" #-}) -- use rule "Transform.ag"(line 152, column 32) _lhsOcollectedAugments = ({-# LINE 152 "Transform.ag" #-} [] {-# LINE 1923 "Transform.hs" #-}) -- use rule "Transform.ag"(line 92, column 48) _lhsOcollectedConstructorsMap = ({-# LINE 92 "Transform.ag" #-} Map.empty {-# LINE 1928 "Transform.hs" #-}) -- use rule "Transform.ag"(line 123, column 28) _lhsOcollectedFields = ({-# LINE 123 "Transform.ag" #-} [] {-# LINE 1933 "Transform.hs" #-}) -- use rule "Transform.ag"(line 150, column 32) _lhsOcollectedInsts = ({-# LINE 150 "Transform.ag" #-} [] {-# LINE 1938 "Transform.hs" #-}) -- use rule "Transform.ag"(line 84, column 50) _lhsOcollectedNames = ({-# LINE 84 "Transform.ag" #-} _setIcollectedNames {-# LINE 1943 "Transform.hs" #-}) -- use rule "Transform.ag"(line 148, column 32) _lhsOcollectedRules = ({-# LINE 148 "Transform.ag" #-} [] {-# LINE 1948 "Transform.hs" #-}) -- use rule "Transform.ag"(line 83, column 50) _lhsOcollectedSetNames = ({-# LINE 83 "Transform.ag" #-} Set.empty {-# LINE 1953 "Transform.hs" #-}) -- use rule "Transform.ag"(line 149, column 32) _lhsOcollectedSigs = ({-# LINE 149 "Transform.ag" #-} [] {-# LINE 1958 "Transform.hs" #-}) -- use rule "Transform.ag"(line 151, column 32) _lhsOcollectedUniques = ({-# LINE 151 "Transform.ag" #-} [] {-# LINE 1963 "Transform.hs" #-}) -- use rule "Transform.ag"(line 800, column 34) _lhsOctxCollect = ({-# LINE 800 "Transform.ag" #-} Map.empty {-# LINE 1968 "Transform.hs" #-}) -- use rule "Transform.ag"(line 42, column 19) _lhsOerrors = ({-# LINE 42 "Transform.ag" #-} _setIerrors {-# LINE 1973 "Transform.hs" #-}) -- use rule "Transform.ag"(line 996, column 37) _lhsOmoduleDecl = ({-# LINE 996 "Transform.ag" #-} mzero {-# LINE 1978 "Transform.hs" #-}) -- use rule "Transform.ag"(line 777, column 37) _lhsOparamsCollect = ({-# LINE 777 "Transform.ag" #-} Map.empty {-# LINE 1983 "Transform.hs" #-}) -- use rule "Transform.ag"(line 673, column 34) _lhsOpragmas = ({-# LINE 673 "Transform.ag" #-} id {-# LINE 1988 "Transform.hs" #-}) -- use rule "Transform.ag"(line 717, column 56) _lhsOsemPragmasCollect = ({-# LINE 717 "Transform.ag" #-} Map.empty {-# LINE 1993 "Transform.hs" #-}) -- use rule "Transform.ag"(line 533, column 32) _lhsOtypeSyns = ({-# LINE 533 "Transform.ag" #-} [] {-# LINE 1998 "Transform.hs" #-}) -- use rule "Transform.ag"(line 135, column 15) _lhsOuseMap = ({-# LINE 135 "Transform.ag" #-} Map.empty {-# LINE 2003 "Transform.hs" #-}) -- use rule "Transform.ag"(line 664, column 32) _lhsOwrappers = ({-# LINE 664 "Transform.ag" #-} Set.empty {-# LINE 2008 "Transform.hs" #-}) -- copy rule (chain) _lhsOattrDecls = ({-# LINE 134 "Transform.ag" #-} _lhsIattrDecls {-# LINE 2013 "Transform.hs" #-}) -- copy rule (chain) _lhsOdefSets = ({-# LINE 102 "Transform.ag" #-} _lhsIdefSets {-# LINE 2018 "Transform.hs" #-}) -- copy rule (down) _setOallFields = ({-# LINE 126 "Transform.ag" #-} _lhsIallFields {-# LINE 2023 "Transform.hs" #-}) -- copy rule (down) _setOallNonterminals = ({-# LINE 86 "Transform.ag" #-} _lhsIallNonterminals {-# LINE 2028 "Transform.hs" #-}) -- copy rule (down) _setOdefinedSets = ({-# LINE 105 "Transform.ag" #-} _lhsIdefinedSets {-# LINE 2033 "Transform.hs" #-}) ( _setIcollectedNames,_setIerrors,_setInontSet) = (set_ _setOallFields _setOallNonterminals _setOdefinedSets ) in ( _lhsOattrDecls,_lhsOattrOrderCollect,_lhsOblocks,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedConstructorsMap,_lhsOcollectedFields,_lhsOcollectedInsts,_lhsOcollectedNames,_lhsOcollectedRules,_lhsOcollectedSetNames,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOctxCollect,_lhsOdefSets,_lhsOderivings,_lhsOerrors,_lhsOmoduleDecl,_lhsOparamsCollect,_lhsOpragmas,_lhsOsemPragmasCollect,_lhsOtypeSyns,_lhsOuseMap,_lhsOwrappers))) ) sem_Elem_Module :: Pos -> String -> String -> String -> T_Elem sem_Elem_Module pos_ name_ exports_ imports_ = (T_Elem (\ _lhsIallAttrDecls _lhsIallConstructors _lhsIallFields _lhsIallNonterminals _lhsIattrDecls _lhsIdefSets _lhsIdefinedSets -> (let _lhsOmoduleDecl :: (Maybe (String,String,String)) _lhsOattrOrderCollect :: AttrOrderMap _lhsOblocks :: Blocks _lhsOcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ]) _lhsOcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ]) _lhsOcollectedConstructorsMap :: (Map NontermIdent (Set ConstructorIdent)) _lhsOcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)]) _lhsOcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ]) _lhsOcollectedNames :: (Set Identifier) _lhsOcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)]) _lhsOcollectedSetNames :: (Set Identifier) _lhsOcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ]) _lhsOcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ]) _lhsOctxCollect :: ContextMap _lhsOderivings :: Derivings _lhsOerrors :: (Seq Error) _lhsOparamsCollect :: ParamMap _lhsOpragmas :: (Options -> Options) _lhsOsemPragmasCollect :: PragmaMap _lhsOtypeSyns :: TypeSyns _lhsOuseMap :: (Map NontermIdent (Map Identifier (String,String,String))) _lhsOwrappers :: (Set NontermIdent) _lhsOattrDecls :: (Map NontermIdent (Attributes, Attributes)) _lhsOdefSets :: (Map Identifier (Set NontermIdent,Set Identifier)) -- "Transform.ag"(line 1000, column 7) _lhsOmoduleDecl = ({-# LINE 1000 "Transform.ag" #-} Just (name_, exports_, imports_) {-# LINE 2078 "Transform.hs" #-}) -- use rule "Transform.ag"(line 745, column 55) _lhsOattrOrderCollect = ({-# LINE 745 "Transform.ag" #-} Map.empty {-# LINE 2083 "Transform.hs" #-}) -- use rule "Transform.ag"(line 44, column 19) _lhsOblocks = ({-# LINE 44 "Transform.ag" #-} Map.empty {-# LINE 2088 "Transform.hs" #-}) -- use rule "Transform.ag"(line 153, column 32) _lhsOcollectedArounds = ({-# LINE 153 "Transform.ag" #-} [] {-# LINE 2093 "Transform.hs" #-}) -- use rule "Transform.ag"(line 152, column 32) _lhsOcollectedAugments = ({-# LINE 152 "Transform.ag" #-} [] {-# LINE 2098 "Transform.hs" #-}) -- use rule "Transform.ag"(line 92, column 48) _lhsOcollectedConstructorsMap = ({-# LINE 92 "Transform.ag" #-} Map.empty {-# LINE 2103 "Transform.hs" #-}) -- use rule "Transform.ag"(line 123, column 28) _lhsOcollectedFields = ({-# LINE 123 "Transform.ag" #-} [] {-# LINE 2108 "Transform.hs" #-}) -- use rule "Transform.ag"(line 150, column 32) _lhsOcollectedInsts = ({-# LINE 150 "Transform.ag" #-} [] {-# LINE 2113 "Transform.hs" #-}) -- use rule "Transform.ag"(line 84, column 50) _lhsOcollectedNames = ({-# LINE 84 "Transform.ag" #-} Set.empty {-# LINE 2118 "Transform.hs" #-}) -- use rule "Transform.ag"(line 148, column 32) _lhsOcollectedRules = ({-# LINE 148 "Transform.ag" #-} [] {-# LINE 2123 "Transform.hs" #-}) -- use rule "Transform.ag"(line 83, column 50) _lhsOcollectedSetNames = ({-# LINE 83 "Transform.ag" #-} Set.empty {-# LINE 2128 "Transform.hs" #-}) -- use rule "Transform.ag"(line 149, column 32) _lhsOcollectedSigs = ({-# LINE 149 "Transform.ag" #-} [] {-# LINE 2133 "Transform.hs" #-}) -- use rule "Transform.ag"(line 151, column 32) _lhsOcollectedUniques = ({-# LINE 151 "Transform.ag" #-} [] {-# LINE 2138 "Transform.hs" #-}) -- use rule "Transform.ag"(line 800, column 34) _lhsOctxCollect = ({-# LINE 800 "Transform.ag" #-} Map.empty {-# LINE 2143 "Transform.hs" #-}) -- use rule "Transform.ag"(line 825, column 33) _lhsOderivings = ({-# LINE 825 "Transform.ag" #-} Map.empty {-# LINE 2148 "Transform.hs" #-}) -- use rule "Transform.ag"(line 42, column 19) _lhsOerrors = ({-# LINE 42 "Transform.ag" #-} Seq.empty {-# LINE 2153 "Transform.hs" #-}) -- use rule "Transform.ag"(line 777, column 37) _lhsOparamsCollect = ({-# LINE 777 "Transform.ag" #-} Map.empty {-# LINE 2158 "Transform.hs" #-}) -- use rule "Transform.ag"(line 673, column 34) _lhsOpragmas = ({-# LINE 673 "Transform.ag" #-} id {-# LINE 2163 "Transform.hs" #-}) -- use rule "Transform.ag"(line 717, column 56) _lhsOsemPragmasCollect = ({-# LINE 717 "Transform.ag" #-} Map.empty {-# LINE 2168 "Transform.hs" #-}) -- use rule "Transform.ag"(line 533, column 32) _lhsOtypeSyns = ({-# LINE 533 "Transform.ag" #-} [] {-# LINE 2173 "Transform.hs" #-}) -- use rule "Transform.ag"(line 135, column 15) _lhsOuseMap = ({-# LINE 135 "Transform.ag" #-} Map.empty {-# LINE 2178 "Transform.hs" #-}) -- use rule "Transform.ag"(line 664, column 32) _lhsOwrappers = ({-# LINE 664 "Transform.ag" #-} Set.empty {-# LINE 2183 "Transform.hs" #-}) -- copy rule (chain) _lhsOattrDecls = ({-# LINE 134 "Transform.ag" #-} _lhsIattrDecls {-# LINE 2188 "Transform.hs" #-}) -- copy rule (chain) _lhsOdefSets = ({-# LINE 102 "Transform.ag" #-} _lhsIdefSets {-# LINE 2193 "Transform.hs" #-}) in ( _lhsOattrDecls,_lhsOattrOrderCollect,_lhsOblocks,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedConstructorsMap,_lhsOcollectedFields,_lhsOcollectedInsts,_lhsOcollectedNames,_lhsOcollectedRules,_lhsOcollectedSetNames,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOctxCollect,_lhsOdefSets,_lhsOderivings,_lhsOerrors,_lhsOmoduleDecl,_lhsOparamsCollect,_lhsOpragmas,_lhsOsemPragmasCollect,_lhsOtypeSyns,_lhsOuseMap,_lhsOwrappers))) ) sem_Elem_Pragma :: Pos -> ([NontermIdent]) -> T_Elem sem_Elem_Pragma pos_ names_ = (T_Elem (\ _lhsIallAttrDecls _lhsIallConstructors _lhsIallFields _lhsIallNonterminals _lhsIattrDecls _lhsIdefSets _lhsIdefinedSets -> (let _lhsOpragmas :: (Options -> Options) _lhsOattrOrderCollect :: AttrOrderMap _lhsOblocks :: Blocks _lhsOcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ]) _lhsOcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ]) _lhsOcollectedConstructorsMap :: (Map NontermIdent (Set ConstructorIdent)) _lhsOcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)]) _lhsOcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ]) _lhsOcollectedNames :: (Set Identifier) _lhsOcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)]) _lhsOcollectedSetNames :: (Set Identifier) _lhsOcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ]) _lhsOcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ]) _lhsOctxCollect :: ContextMap _lhsOderivings :: Derivings _lhsOerrors :: (Seq Error) _lhsOmoduleDecl :: (Maybe (String,String,String)) _lhsOparamsCollect :: ParamMap _lhsOsemPragmasCollect :: PragmaMap _lhsOtypeSyns :: TypeSyns _lhsOuseMap :: (Map NontermIdent (Map Identifier (String,String,String))) _lhsOwrappers :: (Set NontermIdent) _lhsOattrDecls :: (Map NontermIdent (Attributes, Attributes)) _lhsOdefSets :: (Map Identifier (Set NontermIdent,Set Identifier)) -- "Transform.ag"(line 676, column 13) _lhsOpragmas = ({-# LINE 676 "Transform.ag" #-} let mk n o = case getName n of "gencatas" -> o { folds = True } "nogencatas" -> o { folds = False } "gendatas" -> o { dataTypes = True } "nogendatas" -> o { dataTypes = False } "gensems" -> o { semfuns = True } "nogensems" -> o { semfuns = False } "gentypesigs" -> o { typeSigs = True } "nogentypesigs"-> o { typeSigs = False } "nocycle" -> o { withCycle = False } "cycle" -> o { withCycle = True } "nostrictdata" -> o { strictData = False } "strictdata" -> o { strictData = True } "nostrictcase" -> o { strictCases = False } "strictcase" -> o { strictCases = True } "strictercase" -> o { strictCases = True, stricterCases = True } "nostrictwrap" -> o { strictWrap = False } "strictwrap" -> o { strictWrap = True } "novisit" -> o { visit = False } "visit" -> o { visit = True } "nocase" -> o { cases = False } "case" -> o { cases = True } "noseq" -> o { withSeq = False } "seq" -> o { withSeq = True } "nounbox" -> o { unbox = False } "unbox" -> o { unbox = True } "bangpats" -> o { bangpats = True } "nooptimize" -> o { cases = False , visit = False } "optimize" -> o { cases = True , visit = True } "strictsem" -> o { strictSems = True } "gentraces" -> o { genTraces = True } "genusetraces" -> o { genUseTraces = True } "splitsems" -> o { splitSems = True } "gencostcentres" -> o { genCostCentres = True } "sepsemmods" -> o { sepSemMods = True } "genlinepragmas" -> o { genLinePragmas = True } "newtypes" -> o { newtypes = True } "nonewtypes" -> o { newtypes = False } _ -> o in \o -> foldr mk o names_ {-# LINE 2273 "Transform.hs" #-}) -- use rule "Transform.ag"(line 745, column 55) _lhsOattrOrderCollect = ({-# LINE 745 "Transform.ag" #-} Map.empty {-# LINE 2278 "Transform.hs" #-}) -- use rule "Transform.ag"(line 44, column 19) _lhsOblocks = ({-# LINE 44 "Transform.ag" #-} Map.empty {-# LINE 2283 "Transform.hs" #-}) -- use rule "Transform.ag"(line 153, column 32) _lhsOcollectedArounds = ({-# LINE 153 "Transform.ag" #-} [] {-# LINE 2288 "Transform.hs" #-}) -- use rule "Transform.ag"(line 152, column 32) _lhsOcollectedAugments = ({-# LINE 152 "Transform.ag" #-} [] {-# LINE 2293 "Transform.hs" #-}) -- use rule "Transform.ag"(line 92, column 48) _lhsOcollectedConstructorsMap = ({-# LINE 92 "Transform.ag" #-} Map.empty {-# LINE 2298 "Transform.hs" #-}) -- use rule "Transform.ag"(line 123, column 28) _lhsOcollectedFields = ({-# LINE 123 "Transform.ag" #-} [] {-# LINE 2303 "Transform.hs" #-}) -- use rule "Transform.ag"(line 150, column 32) _lhsOcollectedInsts = ({-# LINE 150 "Transform.ag" #-} [] {-# LINE 2308 "Transform.hs" #-}) -- use rule "Transform.ag"(line 84, column 50) _lhsOcollectedNames = ({-# LINE 84 "Transform.ag" #-} Set.empty {-# LINE 2313 "Transform.hs" #-}) -- use rule "Transform.ag"(line 148, column 32) _lhsOcollectedRules = ({-# LINE 148 "Transform.ag" #-} [] {-# LINE 2318 "Transform.hs" #-}) -- use rule "Transform.ag"(line 83, column 50) _lhsOcollectedSetNames = ({-# LINE 83 "Transform.ag" #-} Set.empty {-# LINE 2323 "Transform.hs" #-}) -- use rule "Transform.ag"(line 149, column 32) _lhsOcollectedSigs = ({-# LINE 149 "Transform.ag" #-} [] {-# LINE 2328 "Transform.hs" #-}) -- use rule "Transform.ag"(line 151, column 32) _lhsOcollectedUniques = ({-# LINE 151 "Transform.ag" #-} [] {-# LINE 2333 "Transform.hs" #-}) -- use rule "Transform.ag"(line 800, column 34) _lhsOctxCollect = ({-# LINE 800 "Transform.ag" #-} Map.empty {-# LINE 2338 "Transform.hs" #-}) -- use rule "Transform.ag"(line 825, column 33) _lhsOderivings = ({-# LINE 825 "Transform.ag" #-} Map.empty {-# LINE 2343 "Transform.hs" #-}) -- use rule "Transform.ag"(line 42, column 19) _lhsOerrors = ({-# LINE 42 "Transform.ag" #-} Seq.empty {-# LINE 2348 "Transform.hs" #-}) -- use rule "Transform.ag"(line 996, column 37) _lhsOmoduleDecl = ({-# LINE 996 "Transform.ag" #-} mzero {-# LINE 2353 "Transform.hs" #-}) -- use rule "Transform.ag"(line 777, column 37) _lhsOparamsCollect = ({-# LINE 777 "Transform.ag" #-} Map.empty {-# LINE 2358 "Transform.hs" #-}) -- use rule "Transform.ag"(line 717, column 56) _lhsOsemPragmasCollect = ({-# LINE 717 "Transform.ag" #-} Map.empty {-# LINE 2363 "Transform.hs" #-}) -- use rule "Transform.ag"(line 533, column 32) _lhsOtypeSyns = ({-# LINE 533 "Transform.ag" #-} [] {-# LINE 2368 "Transform.hs" #-}) -- use rule "Transform.ag"(line 135, column 15) _lhsOuseMap = ({-# LINE 135 "Transform.ag" #-} Map.empty {-# LINE 2373 "Transform.hs" #-}) -- use rule "Transform.ag"(line 664, column 32) _lhsOwrappers = ({-# LINE 664 "Transform.ag" #-} Set.empty {-# LINE 2378 "Transform.hs" #-}) -- copy rule (chain) _lhsOattrDecls = ({-# LINE 134 "Transform.ag" #-} _lhsIattrDecls {-# LINE 2383 "Transform.hs" #-}) -- copy rule (chain) _lhsOdefSets = ({-# LINE 102 "Transform.ag" #-} _lhsIdefSets {-# LINE 2388 "Transform.hs" #-}) in ( _lhsOattrDecls,_lhsOattrOrderCollect,_lhsOblocks,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedConstructorsMap,_lhsOcollectedFields,_lhsOcollectedInsts,_lhsOcollectedNames,_lhsOcollectedRules,_lhsOcollectedSetNames,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOctxCollect,_lhsOdefSets,_lhsOderivings,_lhsOerrors,_lhsOmoduleDecl,_lhsOparamsCollect,_lhsOpragmas,_lhsOsemPragmasCollect,_lhsOtypeSyns,_lhsOuseMap,_lhsOwrappers))) ) sem_Elem_Sem :: Pos -> ClassContext -> T_NontSet -> T_Attrs -> T_SemAlts -> T_Elem sem_Elem_Sem pos_ ctx_ (T_NontSet names_ ) (T_Attrs attrs_ ) (T_SemAlts alts_ ) = (T_Elem (\ _lhsIallAttrDecls _lhsIallConstructors _lhsIallFields _lhsIallNonterminals _lhsIattrDecls _lhsIdefSets _lhsIdefinedSets -> (let _altsOnts :: (Set NontermIdent) _lhsOctxCollect :: ContextMap _attrsOnts :: (Set NontermIdent) _lhsOattrOrderCollect :: AttrOrderMap _lhsOblocks :: Blocks _lhsOcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ]) _lhsOcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ]) _lhsOcollectedConstructorsMap :: (Map NontermIdent (Set ConstructorIdent)) _lhsOcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)]) _lhsOcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ]) _lhsOcollectedNames :: (Set Identifier) _lhsOcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)]) _lhsOcollectedSetNames :: (Set Identifier) _lhsOcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ]) _lhsOcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ]) _lhsOderivings :: Derivings _lhsOerrors :: (Seq Error) _lhsOmoduleDecl :: (Maybe (String,String,String)) _lhsOparamsCollect :: ParamMap _lhsOpragmas :: (Options -> Options) _lhsOsemPragmasCollect :: PragmaMap _lhsOtypeSyns :: TypeSyns _lhsOuseMap :: (Map NontermIdent (Map Identifier (String,String,String))) _lhsOwrappers :: (Set NontermIdent) _lhsOattrDecls :: (Map NontermIdent (Attributes, Attributes)) _lhsOdefSets :: (Map Identifier (Set NontermIdent,Set Identifier)) _namesOallFields :: DataTypes _namesOallNonterminals :: (Set NontermIdent) _namesOdefinedSets :: DefinedSets _attrsOallFields :: DataTypes _attrsOallNonterminals :: (Set NontermIdent) _attrsOattrDecls :: (Map NontermIdent (Attributes, Attributes)) _altsOallAttrDecls :: (Map NontermIdent (Attributes, Attributes)) _altsOallFields :: DataTypes _namesIcollectedNames :: (Set Identifier) _namesIerrors :: (Seq Error) _namesInontSet :: (Set NontermIdent) _attrsIattrDecls :: (Map NontermIdent (Attributes, Attributes)) _attrsIerrors :: (Seq Error) _attrsIuseMap :: (Map NontermIdent (Map Identifier (String,String,String))) _altsIattrOrderCollect :: AttrOrderMap _altsIcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ]) _altsIcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ]) _altsIcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ]) _altsIcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)]) _altsIcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ]) _altsIcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ]) _altsIerrors :: (Seq Error) _altsIsemPragmasCollect :: PragmaMap -- "Transform.ag"(line 167, column 10) _altsOnts = ({-# LINE 167 "Transform.ag" #-} _namesInontSet {-# LINE 2457 "Transform.hs" #-}) -- "Transform.ag"(line 804, column 7) _lhsOctxCollect = ({-# LINE 804 "Transform.ag" #-} if null ctx_ then Map.empty else Map.fromList [(nt, ctx_) | nt <- Set.toList _namesInontSet] {-# LINE 2464 "Transform.hs" #-}) -- "Transform.ag"(line 849, column 10) _attrsOnts = ({-# LINE 849 "Transform.ag" #-} _namesInontSet {-# LINE 2469 "Transform.hs" #-}) -- use rule "Transform.ag"(line 745, column 55) _lhsOattrOrderCollect = ({-# LINE 745 "Transform.ag" #-} _altsIattrOrderCollect {-# LINE 2474 "Transform.hs" #-}) -- use rule "Transform.ag"(line 44, column 19) _lhsOblocks = ({-# LINE 44 "Transform.ag" #-} Map.empty {-# LINE 2479 "Transform.hs" #-}) -- use rule "Transform.ag"(line 153, column 32) _lhsOcollectedArounds = ({-# LINE 153 "Transform.ag" #-} _altsIcollectedArounds {-# LINE 2484 "Transform.hs" #-}) -- use rule "Transform.ag"(line 152, column 32) _lhsOcollectedAugments = ({-# LINE 152 "Transform.ag" #-} _altsIcollectedAugments {-# LINE 2489 "Transform.hs" #-}) -- use rule "Transform.ag"(line 92, column 48) _lhsOcollectedConstructorsMap = ({-# LINE 92 "Transform.ag" #-} Map.empty {-# LINE 2494 "Transform.hs" #-}) -- use rule "Transform.ag"(line 123, column 28) _lhsOcollectedFields = ({-# LINE 123 "Transform.ag" #-} [] {-# LINE 2499 "Transform.hs" #-}) -- use rule "Transform.ag"(line 150, column 32) _lhsOcollectedInsts = ({-# LINE 150 "Transform.ag" #-} _altsIcollectedInsts {-# LINE 2504 "Transform.hs" #-}) -- use rule "Transform.ag"(line 84, column 50) _lhsOcollectedNames = ({-# LINE 84 "Transform.ag" #-} _namesIcollectedNames {-# LINE 2509 "Transform.hs" #-}) -- use rule "Transform.ag"(line 148, column 32) _lhsOcollectedRules = ({-# LINE 148 "Transform.ag" #-} _altsIcollectedRules {-# LINE 2514 "Transform.hs" #-}) -- use rule "Transform.ag"(line 83, column 50) _lhsOcollectedSetNames = ({-# LINE 83 "Transform.ag" #-} Set.empty {-# LINE 2519 "Transform.hs" #-}) -- use rule "Transform.ag"(line 149, column 32) _lhsOcollectedSigs = ({-# LINE 149 "Transform.ag" #-} _altsIcollectedSigs {-# LINE 2524 "Transform.hs" #-}) -- use rule "Transform.ag"(line 151, column 32) _lhsOcollectedUniques = ({-# LINE 151 "Transform.ag" #-} _altsIcollectedUniques {-# LINE 2529 "Transform.hs" #-}) -- use rule "Transform.ag"(line 825, column 33) _lhsOderivings = ({-# LINE 825 "Transform.ag" #-} Map.empty {-# LINE 2534 "Transform.hs" #-}) -- use rule "Transform.ag"(line 42, column 19) _lhsOerrors = ({-# LINE 42 "Transform.ag" #-} _namesIerrors Seq.>< _attrsIerrors Seq.>< _altsIerrors {-# LINE 2539 "Transform.hs" #-}) -- use rule "Transform.ag"(line 996, column 37) _lhsOmoduleDecl = ({-# LINE 996 "Transform.ag" #-} mzero {-# LINE 2544 "Transform.hs" #-}) -- use rule "Transform.ag"(line 777, column 37) _lhsOparamsCollect = ({-# LINE 777 "Transform.ag" #-} Map.empty {-# LINE 2549 "Transform.hs" #-}) -- use rule "Transform.ag"(line 673, column 34) _lhsOpragmas = ({-# LINE 673 "Transform.ag" #-} id {-# LINE 2554 "Transform.hs" #-}) -- use rule "Transform.ag"(line 717, column 56) _lhsOsemPragmasCollect = ({-# LINE 717 "Transform.ag" #-} _altsIsemPragmasCollect {-# LINE 2559 "Transform.hs" #-}) -- use rule "Transform.ag"(line 533, column 32) _lhsOtypeSyns = ({-# LINE 533 "Transform.ag" #-} [] {-# LINE 2564 "Transform.hs" #-}) -- use rule "Transform.ag"(line 135, column 15) _lhsOuseMap = ({-# LINE 135 "Transform.ag" #-} _attrsIuseMap {-# LINE 2569 "Transform.hs" #-}) -- use rule "Transform.ag"(line 664, column 32) _lhsOwrappers = ({-# LINE 664 "Transform.ag" #-} Set.empty {-# LINE 2574 "Transform.hs" #-}) -- copy rule (up) _lhsOattrDecls = ({-# LINE 134 "Transform.ag" #-} _attrsIattrDecls {-# LINE 2579 "Transform.hs" #-}) -- copy rule (chain) _lhsOdefSets = ({-# LINE 102 "Transform.ag" #-} _lhsIdefSets {-# LINE 2584 "Transform.hs" #-}) -- copy rule (down) _namesOallFields = ({-# LINE 126 "Transform.ag" #-} _lhsIallFields {-# LINE 2589 "Transform.hs" #-}) -- copy rule (down) _namesOallNonterminals = ({-# LINE 86 "Transform.ag" #-} _lhsIallNonterminals {-# LINE 2594 "Transform.hs" #-}) -- copy rule (down) _namesOdefinedSets = ({-# LINE 105 "Transform.ag" #-} _lhsIdefinedSets {-# LINE 2599 "Transform.hs" #-}) -- copy rule (down) _attrsOallFields = ({-# LINE 126 "Transform.ag" #-} _lhsIallFields {-# LINE 2604 "Transform.hs" #-}) -- copy rule (down) _attrsOallNonterminals = ({-# LINE 86 "Transform.ag" #-} _lhsIallNonterminals {-# LINE 2609 "Transform.hs" #-}) -- copy rule (down) _attrsOattrDecls = ({-# LINE 134 "Transform.ag" #-} _lhsIattrDecls {-# LINE 2614 "Transform.hs" #-}) -- copy rule (down) _altsOallAttrDecls = ({-# LINE 746 "Transform.ag" #-} _lhsIallAttrDecls {-# LINE 2619 "Transform.hs" #-}) -- copy rule (down) _altsOallFields = ({-# LINE 126 "Transform.ag" #-} _lhsIallFields {-# LINE 2624 "Transform.hs" #-}) ( _namesIcollectedNames,_namesIerrors,_namesInontSet) = (names_ _namesOallFields _namesOallNonterminals _namesOdefinedSets ) ( _attrsIattrDecls,_attrsIerrors,_attrsIuseMap) = (attrs_ _attrsOallFields _attrsOallNonterminals _attrsOattrDecls _attrsOnts ) ( _altsIattrOrderCollect,_altsIcollectedArounds,_altsIcollectedAugments,_altsIcollectedInsts,_altsIcollectedRules,_altsIcollectedSigs,_altsIcollectedUniques,_altsIerrors,_altsIsemPragmasCollect) = (alts_ _altsOallAttrDecls _altsOallFields _altsOnts ) in ( _lhsOattrDecls,_lhsOattrOrderCollect,_lhsOblocks,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedConstructorsMap,_lhsOcollectedFields,_lhsOcollectedInsts,_lhsOcollectedNames,_lhsOcollectedRules,_lhsOcollectedSetNames,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOctxCollect,_lhsOdefSets,_lhsOderivings,_lhsOerrors,_lhsOmoduleDecl,_lhsOparamsCollect,_lhsOpragmas,_lhsOsemPragmasCollect,_lhsOtypeSyns,_lhsOuseMap,_lhsOwrappers))) ) sem_Elem_Set :: Pos -> NontermIdent -> T_NontSet -> T_Elem sem_Elem_Set pos_ name_ (T_NontSet set_ ) = (T_Elem (\ _lhsIallAttrDecls _lhsIallConstructors _lhsIallFields _lhsIallNonterminals _lhsIattrDecls _lhsIdefSets _lhsIdefinedSets -> (let _lhsOcollectedSetNames :: (Set Identifier) _lhsOdefSets :: (Map Identifier (Set NontermIdent,Set Identifier)) _lhsOerrors :: (Seq Error) _lhsOattrOrderCollect :: AttrOrderMap _lhsOblocks :: Blocks _lhsOcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ]) _lhsOcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ]) _lhsOcollectedConstructorsMap :: (Map NontermIdent (Set ConstructorIdent)) _lhsOcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)]) _lhsOcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ]) _lhsOcollectedNames :: (Set Identifier) _lhsOcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)]) _lhsOcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ]) _lhsOcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ]) _lhsOctxCollect :: ContextMap _lhsOderivings :: Derivings _lhsOmoduleDecl :: (Maybe (String,String,String)) _lhsOparamsCollect :: ParamMap _lhsOpragmas :: (Options -> Options) _lhsOsemPragmasCollect :: PragmaMap _lhsOtypeSyns :: TypeSyns _lhsOuseMap :: (Map NontermIdent (Map Identifier (String,String,String))) _lhsOwrappers :: (Set NontermIdent) _lhsOattrDecls :: (Map NontermIdent (Attributes, Attributes)) _setOallFields :: DataTypes _setOallNonterminals :: (Set NontermIdent) _setOdefinedSets :: DefinedSets _setIcollectedNames :: (Set Identifier) _setIerrors :: (Seq Error) _setInontSet :: (Set NontermIdent) -- "Transform.ag"(line 489, column 10) _lhsOcollectedSetNames = ({-# LINE 489 "Transform.ag" #-} Set.singleton name_ {-# LINE 2678 "Transform.hs" #-}) -- "Transform.ag"(line 596, column 13) __tup3 = ({-# LINE 596 "Transform.ag" #-} let allUsedNames = Set.unions [ maybe (Set.singleton n) snd (Map.lookup n _lhsIdefSets) | n <- Set.toList _setIcollectedNames ] (nontSet,e1) | Set.member name_ allUsedNames = (Set.empty, Seq.singleton(CyclicSet name_)) | otherwise = (_setInontSet, Seq.empty) (res, e2) = checkDuplicate DupSet name_ (nontSet,Set.insert name_ allUsedNames) _lhsIdefSets in (res, e1 Seq.>< e2) {-# LINE 2692 "Transform.hs" #-}) -- "Transform.ag"(line 596, column 13) (_defSets2,_) = ({-# LINE 596 "Transform.ag" #-} __tup3 {-# LINE 2697 "Transform.hs" #-}) -- "Transform.ag"(line 596, column 13) (_,_errs) = ({-# LINE 596 "Transform.ag" #-} __tup3 {-# LINE 2702 "Transform.hs" #-}) -- "Transform.ag"(line 606, column 9) _lhsOdefSets = ({-# LINE 606 "Transform.ag" #-} _defSets2 {-# LINE 2707 "Transform.hs" #-}) -- "Transform.ag"(line 606, column 9) _lhsOerrors = ({-# LINE 607 "Transform.ag" #-} _errs >< _setIerrors {-# LINE 2712 "Transform.hs" #-}) -- use rule "Transform.ag"(line 745, column 55) _lhsOattrOrderCollect = ({-# LINE 745 "Transform.ag" #-} Map.empty {-# LINE 2717 "Transform.hs" #-}) -- use rule "Transform.ag"(line 44, column 19) _lhsOblocks = ({-# LINE 44 "Transform.ag" #-} Map.empty {-# LINE 2722 "Transform.hs" #-}) -- use rule "Transform.ag"(line 153, column 32) _lhsOcollectedArounds = ({-# LINE 153 "Transform.ag" #-} [] {-# LINE 2727 "Transform.hs" #-}) -- use rule "Transform.ag"(line 152, column 32) _lhsOcollectedAugments = ({-# LINE 152 "Transform.ag" #-} [] {-# LINE 2732 "Transform.hs" #-}) -- use rule "Transform.ag"(line 92, column 48) _lhsOcollectedConstructorsMap = ({-# LINE 92 "Transform.ag" #-} Map.empty {-# LINE 2737 "Transform.hs" #-}) -- use rule "Transform.ag"(line 123, column 28) _lhsOcollectedFields = ({-# LINE 123 "Transform.ag" #-} [] {-# LINE 2742 "Transform.hs" #-}) -- use rule "Transform.ag"(line 150, column 32) _lhsOcollectedInsts = ({-# LINE 150 "Transform.ag" #-} [] {-# LINE 2747 "Transform.hs" #-}) -- use rule "Transform.ag"(line 84, column 50) _lhsOcollectedNames = ({-# LINE 84 "Transform.ag" #-} _setIcollectedNames {-# LINE 2752 "Transform.hs" #-}) -- use rule "Transform.ag"(line 148, column 32) _lhsOcollectedRules = ({-# LINE 148 "Transform.ag" #-} [] {-# LINE 2757 "Transform.hs" #-}) -- use rule "Transform.ag"(line 149, column 32) _lhsOcollectedSigs = ({-# LINE 149 "Transform.ag" #-} [] {-# LINE 2762 "Transform.hs" #-}) -- use rule "Transform.ag"(line 151, column 32) _lhsOcollectedUniques = ({-# LINE 151 "Transform.ag" #-} [] {-# LINE 2767 "Transform.hs" #-}) -- use rule "Transform.ag"(line 800, column 34) _lhsOctxCollect = ({-# LINE 800 "Transform.ag" #-} Map.empty {-# LINE 2772 "Transform.hs" #-}) -- use rule "Transform.ag"(line 825, column 33) _lhsOderivings = ({-# LINE 825 "Transform.ag" #-} Map.empty {-# LINE 2777 "Transform.hs" #-}) -- use rule "Transform.ag"(line 996, column 37) _lhsOmoduleDecl = ({-# LINE 996 "Transform.ag" #-} mzero {-# LINE 2782 "Transform.hs" #-}) -- use rule "Transform.ag"(line 777, column 37) _lhsOparamsCollect = ({-# LINE 777 "Transform.ag" #-} Map.empty {-# LINE 2787 "Transform.hs" #-}) -- use rule "Transform.ag"(line 673, column 34) _lhsOpragmas = ({-# LINE 673 "Transform.ag" #-} id {-# LINE 2792 "Transform.hs" #-}) -- use rule "Transform.ag"(line 717, column 56) _lhsOsemPragmasCollect = ({-# LINE 717 "Transform.ag" #-} Map.empty {-# LINE 2797 "Transform.hs" #-}) -- use rule "Transform.ag"(line 533, column 32) _lhsOtypeSyns = ({-# LINE 533 "Transform.ag" #-} [] {-# LINE 2802 "Transform.hs" #-}) -- use rule "Transform.ag"(line 135, column 15) _lhsOuseMap = ({-# LINE 135 "Transform.ag" #-} Map.empty {-# LINE 2807 "Transform.hs" #-}) -- use rule "Transform.ag"(line 664, column 32) _lhsOwrappers = ({-# LINE 664 "Transform.ag" #-} Set.empty {-# LINE 2812 "Transform.hs" #-}) -- copy rule (chain) _lhsOattrDecls = ({-# LINE 134 "Transform.ag" #-} _lhsIattrDecls {-# LINE 2817 "Transform.hs" #-}) -- copy rule (down) _setOallFields = ({-# LINE 126 "Transform.ag" #-} _lhsIallFields {-# LINE 2822 "Transform.hs" #-}) -- copy rule (down) _setOallNonterminals = ({-# LINE 86 "Transform.ag" #-} _lhsIallNonterminals {-# LINE 2827 "Transform.hs" #-}) -- copy rule (down) _setOdefinedSets = ({-# LINE 105 "Transform.ag" #-} _lhsIdefinedSets {-# LINE 2832 "Transform.hs" #-}) ( _setIcollectedNames,_setIerrors,_setInontSet) = (set_ _setOallFields _setOallNonterminals _setOdefinedSets ) in ( _lhsOattrDecls,_lhsOattrOrderCollect,_lhsOblocks,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedConstructorsMap,_lhsOcollectedFields,_lhsOcollectedInsts,_lhsOcollectedNames,_lhsOcollectedRules,_lhsOcollectedSetNames,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOctxCollect,_lhsOdefSets,_lhsOderivings,_lhsOerrors,_lhsOmoduleDecl,_lhsOparamsCollect,_lhsOpragmas,_lhsOsemPragmasCollect,_lhsOtypeSyns,_lhsOuseMap,_lhsOwrappers))) ) sem_Elem_Txt :: Pos -> Identifier -> (Maybe NontermIdent) -> ([String]) -> T_Elem sem_Elem_Txt pos_ name_ mbNt_ lines_ = (T_Elem (\ _lhsIallAttrDecls _lhsIallConstructors _lhsIallFields _lhsIallNonterminals _lhsIattrDecls _lhsIdefSets _lhsIdefinedSets -> (let _lhsOblocks :: Blocks _lhsOattrOrderCollect :: AttrOrderMap _lhsOcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ]) _lhsOcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ]) _lhsOcollectedConstructorsMap :: (Map NontermIdent (Set ConstructorIdent)) _lhsOcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)]) _lhsOcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ]) _lhsOcollectedNames :: (Set Identifier) _lhsOcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)]) _lhsOcollectedSetNames :: (Set Identifier) _lhsOcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ]) _lhsOcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ]) _lhsOctxCollect :: ContextMap _lhsOderivings :: Derivings _lhsOerrors :: (Seq Error) _lhsOmoduleDecl :: (Maybe (String,String,String)) _lhsOparamsCollect :: ParamMap _lhsOpragmas :: (Options -> Options) _lhsOsemPragmasCollect :: PragmaMap _lhsOtypeSyns :: TypeSyns _lhsOuseMap :: (Map NontermIdent (Map Identifier (String,String,String))) _lhsOwrappers :: (Set NontermIdent) _lhsOattrDecls :: (Map NontermIdent (Attributes, Attributes)) _lhsOdefSets :: (Map Identifier (Set NontermIdent,Set Identifier)) -- "Transform.ag"(line 176, column 10) _blockInfo = ({-# LINE 176 "Transform.ag" #-} ( let nm = getName name_ in if nm == "imports" then BlockImport else if nm == "optpragmas" then BlockPragma else BlockOther , mbNt_ ) {-# LINE 2884 "Transform.hs" #-}) -- "Transform.ag"(line 184, column 10) _blockValue = ({-# LINE 184 "Transform.ag" #-} [(lines_, pos_)] {-# LINE 2889 "Transform.hs" #-}) -- "Transform.ag"(line 185, column 10) _lhsOblocks = ({-# LINE 185 "Transform.ag" #-} Map.singleton _blockInfo _blockValue {-# LINE 2894 "Transform.hs" #-}) -- use rule "Transform.ag"(line 745, column 55) _lhsOattrOrderCollect = ({-# LINE 745 "Transform.ag" #-} Map.empty {-# LINE 2899 "Transform.hs" #-}) -- use rule "Transform.ag"(line 153, column 32) _lhsOcollectedArounds = ({-# LINE 153 "Transform.ag" #-} [] {-# LINE 2904 "Transform.hs" #-}) -- use rule "Transform.ag"(line 152, column 32) _lhsOcollectedAugments = ({-# LINE 152 "Transform.ag" #-} [] {-# LINE 2909 "Transform.hs" #-}) -- use rule "Transform.ag"(line 92, column 48) _lhsOcollectedConstructorsMap = ({-# LINE 92 "Transform.ag" #-} Map.empty {-# LINE 2914 "Transform.hs" #-}) -- use rule "Transform.ag"(line 123, column 28) _lhsOcollectedFields = ({-# LINE 123 "Transform.ag" #-} [] {-# LINE 2919 "Transform.hs" #-}) -- use rule "Transform.ag"(line 150, column 32) _lhsOcollectedInsts = ({-# LINE 150 "Transform.ag" #-} [] {-# LINE 2924 "Transform.hs" #-}) -- use rule "Transform.ag"(line 84, column 50) _lhsOcollectedNames = ({-# LINE 84 "Transform.ag" #-} Set.empty {-# LINE 2929 "Transform.hs" #-}) -- use rule "Transform.ag"(line 148, column 32) _lhsOcollectedRules = ({-# LINE 148 "Transform.ag" #-} [] {-# LINE 2934 "Transform.hs" #-}) -- use rule "Transform.ag"(line 83, column 50) _lhsOcollectedSetNames = ({-# LINE 83 "Transform.ag" #-} Set.empty {-# LINE 2939 "Transform.hs" #-}) -- use rule "Transform.ag"(line 149, column 32) _lhsOcollectedSigs = ({-# LINE 149 "Transform.ag" #-} [] {-# LINE 2944 "Transform.hs" #-}) -- use rule "Transform.ag"(line 151, column 32) _lhsOcollectedUniques = ({-# LINE 151 "Transform.ag" #-} [] {-# LINE 2949 "Transform.hs" #-}) -- use rule "Transform.ag"(line 800, column 34) _lhsOctxCollect = ({-# LINE 800 "Transform.ag" #-} Map.empty {-# LINE 2954 "Transform.hs" #-}) -- use rule "Transform.ag"(line 825, column 33) _lhsOderivings = ({-# LINE 825 "Transform.ag" #-} Map.empty {-# LINE 2959 "Transform.hs" #-}) -- use rule "Transform.ag"(line 42, column 19) _lhsOerrors = ({-# LINE 42 "Transform.ag" #-} Seq.empty {-# LINE 2964 "Transform.hs" #-}) -- use rule "Transform.ag"(line 996, column 37) _lhsOmoduleDecl = ({-# LINE 996 "Transform.ag" #-} mzero {-# LINE 2969 "Transform.hs" #-}) -- use rule "Transform.ag"(line 777, column 37) _lhsOparamsCollect = ({-# LINE 777 "Transform.ag" #-} Map.empty {-# LINE 2974 "Transform.hs" #-}) -- use rule "Transform.ag"(line 673, column 34) _lhsOpragmas = ({-# LINE 673 "Transform.ag" #-} id {-# LINE 2979 "Transform.hs" #-}) -- use rule "Transform.ag"(line 717, column 56) _lhsOsemPragmasCollect = ({-# LINE 717 "Transform.ag" #-} Map.empty {-# LINE 2984 "Transform.hs" #-}) -- use rule "Transform.ag"(line 533, column 32) _lhsOtypeSyns = ({-# LINE 533 "Transform.ag" #-} [] {-# LINE 2989 "Transform.hs" #-}) -- use rule "Transform.ag"(line 135, column 15) _lhsOuseMap = ({-# LINE 135 "Transform.ag" #-} Map.empty {-# LINE 2994 "Transform.hs" #-}) -- use rule "Transform.ag"(line 664, column 32) _lhsOwrappers = ({-# LINE 664 "Transform.ag" #-} Set.empty {-# LINE 2999 "Transform.hs" #-}) -- copy rule (chain) _lhsOattrDecls = ({-# LINE 134 "Transform.ag" #-} _lhsIattrDecls {-# LINE 3004 "Transform.hs" #-}) -- copy rule (chain) _lhsOdefSets = ({-# LINE 102 "Transform.ag" #-} _lhsIdefSets {-# LINE 3009 "Transform.hs" #-}) in ( _lhsOattrDecls,_lhsOattrOrderCollect,_lhsOblocks,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedConstructorsMap,_lhsOcollectedFields,_lhsOcollectedInsts,_lhsOcollectedNames,_lhsOcollectedRules,_lhsOcollectedSetNames,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOctxCollect,_lhsOdefSets,_lhsOderivings,_lhsOerrors,_lhsOmoduleDecl,_lhsOparamsCollect,_lhsOpragmas,_lhsOsemPragmasCollect,_lhsOtypeSyns,_lhsOuseMap,_lhsOwrappers))) ) sem_Elem_Type :: Pos -> ClassContext -> NontermIdent -> ([Identifier]) -> ComplexType -> T_Elem sem_Elem_Type pos_ ctx_ name_ params_ type_ = (T_Elem (\ _lhsIallAttrDecls _lhsIallConstructors _lhsIallFields _lhsIallNonterminals _lhsIattrDecls _lhsIdefSets _lhsIdefinedSets -> (let _lhsOcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)]) _lhsOcollectedNames :: (Set Identifier) _lhsOtypeSyns :: TypeSyns _lhsOparamsCollect :: ParamMap _lhsOctxCollect :: ContextMap _lhsOattrOrderCollect :: AttrOrderMap _lhsOblocks :: Blocks _lhsOcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ]) _lhsOcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ]) _lhsOcollectedConstructorsMap :: (Map NontermIdent (Set ConstructorIdent)) _lhsOcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ]) _lhsOcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)]) _lhsOcollectedSetNames :: (Set Identifier) _lhsOcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ]) _lhsOcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ]) _lhsOderivings :: Derivings _lhsOerrors :: (Seq Error) _lhsOmoduleDecl :: (Maybe (String,String,String)) _lhsOpragmas :: (Options -> Options) _lhsOsemPragmasCollect :: PragmaMap _lhsOuseMap :: (Map NontermIdent (Map Identifier (String,String,String))) _lhsOwrappers :: (Set NontermIdent) _lhsOattrDecls :: (Map NontermIdent (Attributes, Attributes)) _lhsOdefSets :: (Map Identifier (Set NontermIdent,Set Identifier)) -- "Transform.ag"(line 238, column 10) _lhsOcollectedFields = ({-# LINE 238 "Transform.ag" #-} map (\(x,y)->(name_, x, y)) _expanded {-# LINE 3053 "Transform.hs" #-}) -- "Transform.ag"(line 492, column 11) _lhsOcollectedNames = ({-# LINE 492 "Transform.ag" #-} Set.singleton name_ {-# LINE 3058 "Transform.hs" #-}) -- "Transform.ag"(line 546, column 11) _expanded = ({-# LINE 546 "Transform.ag" #-} case _argType of List tp -> [(Ident "Cons" pos_, [(Ident "hd" pos_, tp) ,(Ident "tl" pos_, NT name_ (map getName params_)) ] ) ,(Ident "Nil" pos_, []) ] Maybe tp -> [(Ident "Just" pos_, [(Ident "just" pos_, tp) ] ) ,(Ident "Nothing" pos_, []) ] Either tp1 tp2 -> [ (Ident "Left" pos_, [(Ident "left" pos_, tp1) ]) , (Ident "Right" pos_, [(Ident "right" pos_, tp2) ]) ] Map tp1 tp2 -> [ (Ident "Entry" pos_, [ (Ident "key" pos_, tp1) , (Ident "val" pos_, tp2) , (Ident "tl" pos_, NT name_ (map getName params_)) ]) , (Ident "Nil" pos_, []) ] IntMap tp -> [ (Ident "Entry" pos_, [ (Ident "key" pos_, Haskell "Int") , (Ident "val" pos_, tp) , (Ident "tl" pos_, NT name_ (map getName params_)) ]) , (Ident "Nil" pos_, []) ] Tuple xs -> [(Ident "Tuple" pos_, xs)] {-# LINE 3091 "Transform.hs" #-}) -- "Transform.ag"(line 575, column 11) _argType = ({-# LINE 575 "Transform.ag" #-} case type_ of Maybe tp -> Maybe ( makeType _lhsIallNonterminals tp) Either tp1 tp2 -> Either ( makeType _lhsIallNonterminals tp1) (makeType _lhsIallNonterminals tp2) List tp -> List ( makeType _lhsIallNonterminals tp) Tuple xs -> Tuple [(f,makeType _lhsIallNonterminals tp) | (f,tp) <- xs] Map tp1 tp2 -> Map ( makeType _lhsIallNonterminals tp1) (makeType _lhsIallNonterminals tp2) IntMap tp -> IntMap ( makeType _lhsIallNonterminals tp) {-# LINE 3102 "Transform.hs" #-}) -- "Transform.ag"(line 582, column 11) _lhsOtypeSyns = ({-# LINE 582 "Transform.ag" #-} [(name_,_argType)] {-# LINE 3107 "Transform.hs" #-}) -- "Transform.ag"(line 787, column 7) _lhsOparamsCollect = ({-# LINE 787 "Transform.ag" #-} if null params_ then Map.empty else Map.singleton name_ params_ {-# LINE 3114 "Transform.hs" #-}) -- "Transform.ag"(line 810, column 7) _lhsOctxCollect = ({-# LINE 810 "Transform.ag" #-} if null ctx_ then Map.empty else Map.singleton name_ ctx_ {-# LINE 3121 "Transform.hs" #-}) -- use rule "Transform.ag"(line 745, column 55) _lhsOattrOrderCollect = ({-# LINE 745 "Transform.ag" #-} Map.empty {-# LINE 3126 "Transform.hs" #-}) -- use rule "Transform.ag"(line 44, column 19) _lhsOblocks = ({-# LINE 44 "Transform.ag" #-} Map.empty {-# LINE 3131 "Transform.hs" #-}) -- use rule "Transform.ag"(line 153, column 32) _lhsOcollectedArounds = ({-# LINE 153 "Transform.ag" #-} [] {-# LINE 3136 "Transform.hs" #-}) -- use rule "Transform.ag"(line 152, column 32) _lhsOcollectedAugments = ({-# LINE 152 "Transform.ag" #-} [] {-# LINE 3141 "Transform.hs" #-}) -- use rule "Transform.ag"(line 92, column 48) _lhsOcollectedConstructorsMap = ({-# LINE 92 "Transform.ag" #-} Map.empty {-# LINE 3146 "Transform.hs" #-}) -- use rule "Transform.ag"(line 150, column 32) _lhsOcollectedInsts = ({-# LINE 150 "Transform.ag" #-} [] {-# LINE 3151 "Transform.hs" #-}) -- use rule "Transform.ag"(line 148, column 32) _lhsOcollectedRules = ({-# LINE 148 "Transform.ag" #-} [] {-# LINE 3156 "Transform.hs" #-}) -- use rule "Transform.ag"(line 83, column 50) _lhsOcollectedSetNames = ({-# LINE 83 "Transform.ag" #-} Set.empty {-# LINE 3161 "Transform.hs" #-}) -- use rule "Transform.ag"(line 149, column 32) _lhsOcollectedSigs = ({-# LINE 149 "Transform.ag" #-} [] {-# LINE 3166 "Transform.hs" #-}) -- use rule "Transform.ag"(line 151, column 32) _lhsOcollectedUniques = ({-# LINE 151 "Transform.ag" #-} [] {-# LINE 3171 "Transform.hs" #-}) -- use rule "Transform.ag"(line 825, column 33) _lhsOderivings = ({-# LINE 825 "Transform.ag" #-} Map.empty {-# LINE 3176 "Transform.hs" #-}) -- use rule "Transform.ag"(line 42, column 19) _lhsOerrors = ({-# LINE 42 "Transform.ag" #-} Seq.empty {-# LINE 3181 "Transform.hs" #-}) -- use rule "Transform.ag"(line 996, column 37) _lhsOmoduleDecl = ({-# LINE 996 "Transform.ag" #-} mzero {-# LINE 3186 "Transform.hs" #-}) -- use rule "Transform.ag"(line 673, column 34) _lhsOpragmas = ({-# LINE 673 "Transform.ag" #-} id {-# LINE 3191 "Transform.hs" #-}) -- use rule "Transform.ag"(line 717, column 56) _lhsOsemPragmasCollect = ({-# LINE 717 "Transform.ag" #-} Map.empty {-# LINE 3196 "Transform.hs" #-}) -- use rule "Transform.ag"(line 135, column 15) _lhsOuseMap = ({-# LINE 135 "Transform.ag" #-} Map.empty {-# LINE 3201 "Transform.hs" #-}) -- use rule "Transform.ag"(line 664, column 32) _lhsOwrappers = ({-# LINE 664 "Transform.ag" #-} Set.empty {-# LINE 3206 "Transform.hs" #-}) -- copy rule (chain) _lhsOattrDecls = ({-# LINE 134 "Transform.ag" #-} _lhsIattrDecls {-# LINE 3211 "Transform.hs" #-}) -- copy rule (chain) _lhsOdefSets = ({-# LINE 102 "Transform.ag" #-} _lhsIdefSets {-# LINE 3216 "Transform.hs" #-}) in ( _lhsOattrDecls,_lhsOattrOrderCollect,_lhsOblocks,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedConstructorsMap,_lhsOcollectedFields,_lhsOcollectedInsts,_lhsOcollectedNames,_lhsOcollectedRules,_lhsOcollectedSetNames,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOctxCollect,_lhsOdefSets,_lhsOderivings,_lhsOerrors,_lhsOmoduleDecl,_lhsOparamsCollect,_lhsOpragmas,_lhsOsemPragmasCollect,_lhsOtypeSyns,_lhsOuseMap,_lhsOwrappers))) ) sem_Elem_Wrapper :: Pos -> T_NontSet -> T_Elem sem_Elem_Wrapper pos_ (T_NontSet set_ ) = (T_Elem (\ _lhsIallAttrDecls _lhsIallConstructors _lhsIallFields _lhsIallNonterminals _lhsIattrDecls _lhsIdefSets _lhsIdefinedSets -> (let _lhsOwrappers :: (Set NontermIdent) _lhsOattrOrderCollect :: AttrOrderMap _lhsOblocks :: Blocks _lhsOcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ]) _lhsOcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ]) _lhsOcollectedConstructorsMap :: (Map NontermIdent (Set ConstructorIdent)) _lhsOcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)]) _lhsOcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ]) _lhsOcollectedNames :: (Set Identifier) _lhsOcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)]) _lhsOcollectedSetNames :: (Set Identifier) _lhsOcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ]) _lhsOcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ]) _lhsOctxCollect :: ContextMap _lhsOderivings :: Derivings _lhsOerrors :: (Seq Error) _lhsOmoduleDecl :: (Maybe (String,String,String)) _lhsOparamsCollect :: ParamMap _lhsOpragmas :: (Options -> Options) _lhsOsemPragmasCollect :: PragmaMap _lhsOtypeSyns :: TypeSyns _lhsOuseMap :: (Map NontermIdent (Map Identifier (String,String,String))) _lhsOattrDecls :: (Map NontermIdent (Attributes, Attributes)) _lhsOdefSets :: (Map Identifier (Set NontermIdent,Set Identifier)) _setOallFields :: DataTypes _setOallNonterminals :: (Set NontermIdent) _setOdefinedSets :: DefinedSets _setIcollectedNames :: (Set Identifier) _setIerrors :: (Seq Error) _setInontSet :: (Set NontermIdent) -- "Transform.ag"(line 667, column 13) _lhsOwrappers = ({-# LINE 667 "Transform.ag" #-} _setInontSet {-# LINE 3263 "Transform.hs" #-}) -- use rule "Transform.ag"(line 745, column 55) _lhsOattrOrderCollect = ({-# LINE 745 "Transform.ag" #-} Map.empty {-# LINE 3268 "Transform.hs" #-}) -- use rule "Transform.ag"(line 44, column 19) _lhsOblocks = ({-# LINE 44 "Transform.ag" #-} Map.empty {-# LINE 3273 "Transform.hs" #-}) -- use rule "Transform.ag"(line 153, column 32) _lhsOcollectedArounds = ({-# LINE 153 "Transform.ag" #-} [] {-# LINE 3278 "Transform.hs" #-}) -- use rule "Transform.ag"(line 152, column 32) _lhsOcollectedAugments = ({-# LINE 152 "Transform.ag" #-} [] {-# LINE 3283 "Transform.hs" #-}) -- use rule "Transform.ag"(line 92, column 48) _lhsOcollectedConstructorsMap = ({-# LINE 92 "Transform.ag" #-} Map.empty {-# LINE 3288 "Transform.hs" #-}) -- use rule "Transform.ag"(line 123, column 28) _lhsOcollectedFields = ({-# LINE 123 "Transform.ag" #-} [] {-# LINE 3293 "Transform.hs" #-}) -- use rule "Transform.ag"(line 150, column 32) _lhsOcollectedInsts = ({-# LINE 150 "Transform.ag" #-} [] {-# LINE 3298 "Transform.hs" #-}) -- use rule "Transform.ag"(line 84, column 50) _lhsOcollectedNames = ({-# LINE 84 "Transform.ag" #-} _setIcollectedNames {-# LINE 3303 "Transform.hs" #-}) -- use rule "Transform.ag"(line 148, column 32) _lhsOcollectedRules = ({-# LINE 148 "Transform.ag" #-} [] {-# LINE 3308 "Transform.hs" #-}) -- use rule "Transform.ag"(line 83, column 50) _lhsOcollectedSetNames = ({-# LINE 83 "Transform.ag" #-} Set.empty {-# LINE 3313 "Transform.hs" #-}) -- use rule "Transform.ag"(line 149, column 32) _lhsOcollectedSigs = ({-# LINE 149 "Transform.ag" #-} [] {-# LINE 3318 "Transform.hs" #-}) -- use rule "Transform.ag"(line 151, column 32) _lhsOcollectedUniques = ({-# LINE 151 "Transform.ag" #-} [] {-# LINE 3323 "Transform.hs" #-}) -- use rule "Transform.ag"(line 800, column 34) _lhsOctxCollect = ({-# LINE 800 "Transform.ag" #-} Map.empty {-# LINE 3328 "Transform.hs" #-}) -- use rule "Transform.ag"(line 825, column 33) _lhsOderivings = ({-# LINE 825 "Transform.ag" #-} Map.empty {-# LINE 3333 "Transform.hs" #-}) -- use rule "Transform.ag"(line 42, column 19) _lhsOerrors = ({-# LINE 42 "Transform.ag" #-} _setIerrors {-# LINE 3338 "Transform.hs" #-}) -- use rule "Transform.ag"(line 996, column 37) _lhsOmoduleDecl = ({-# LINE 996 "Transform.ag" #-} mzero {-# LINE 3343 "Transform.hs" #-}) -- use rule "Transform.ag"(line 777, column 37) _lhsOparamsCollect = ({-# LINE 777 "Transform.ag" #-} Map.empty {-# LINE 3348 "Transform.hs" #-}) -- use rule "Transform.ag"(line 673, column 34) _lhsOpragmas = ({-# LINE 673 "Transform.ag" #-} id {-# LINE 3353 "Transform.hs" #-}) -- use rule "Transform.ag"(line 717, column 56) _lhsOsemPragmasCollect = ({-# LINE 717 "Transform.ag" #-} Map.empty {-# LINE 3358 "Transform.hs" #-}) -- use rule "Transform.ag"(line 533, column 32) _lhsOtypeSyns = ({-# LINE 533 "Transform.ag" #-} [] {-# LINE 3363 "Transform.hs" #-}) -- use rule "Transform.ag"(line 135, column 15) _lhsOuseMap = ({-# LINE 135 "Transform.ag" #-} Map.empty {-# LINE 3368 "Transform.hs" #-}) -- copy rule (chain) _lhsOattrDecls = ({-# LINE 134 "Transform.ag" #-} _lhsIattrDecls {-# LINE 3373 "Transform.hs" #-}) -- copy rule (chain) _lhsOdefSets = ({-# LINE 102 "Transform.ag" #-} _lhsIdefSets {-# LINE 3378 "Transform.hs" #-}) -- copy rule (down) _setOallFields = ({-# LINE 126 "Transform.ag" #-} _lhsIallFields {-# LINE 3383 "Transform.hs" #-}) -- copy rule (down) _setOallNonterminals = ({-# LINE 86 "Transform.ag" #-} _lhsIallNonterminals {-# LINE 3388 "Transform.hs" #-}) -- copy rule (down) _setOdefinedSets = ({-# LINE 105 "Transform.ag" #-} _lhsIdefinedSets {-# LINE 3393 "Transform.hs" #-}) ( _setIcollectedNames,_setIerrors,_setInontSet) = (set_ _setOallFields _setOallNonterminals _setOdefinedSets ) in ( _lhsOattrDecls,_lhsOattrOrderCollect,_lhsOblocks,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedConstructorsMap,_lhsOcollectedFields,_lhsOcollectedInsts,_lhsOcollectedNames,_lhsOcollectedRules,_lhsOcollectedSetNames,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOctxCollect,_lhsOdefSets,_lhsOderivings,_lhsOerrors,_lhsOmoduleDecl,_lhsOparamsCollect,_lhsOpragmas,_lhsOsemPragmasCollect,_lhsOtypeSyns,_lhsOuseMap,_lhsOwrappers))) ) -- Elems ------------------------------------------------------- {- visit 0: inherited attributes: allAttrDecls : Map NontermIdent (Attributes, Attributes) allConstructors : Map NontermIdent (Set ConstructorIdent) allFields : DataTypes allNonterminals : Set NontermIdent definedSets : DefinedSets chained attributes: attrDecls : Map NontermIdent (Attributes, Attributes) defSets : Map Identifier (Set NontermIdent,Set Identifier) synthesized attributes: attrOrderCollect : AttrOrderMap blocks : Blocks collectedArounds : [ (NontermIdent, ConstructorIdent, [AroundInfo]) ] collectedAugments : [ (NontermIdent, ConstructorIdent, [AugmentInfo]) ] collectedConstructorsMap : Map NontermIdent (Set ConstructorIdent) collectedFields : [(NontermIdent, ConstructorIdent, FieldMap)] collectedInsts : [ (NontermIdent, ConstructorIdent, [Identifier]) ] collectedNames : Set Identifier collectedRules : [ (NontermIdent, ConstructorIdent, RuleInfo)] collectedSetNames : Set Identifier collectedSigs : [ (NontermIdent, ConstructorIdent, SigInfo) ] collectedUniques : [ (NontermIdent, ConstructorIdent, [UniqueInfo]) ] ctxCollect : ContextMap derivings : Derivings errors : Seq Error moduleDecl : Maybe (String,String,String) paramsCollect : ParamMap pragmas : Options -> Options semPragmasCollect : PragmaMap typeSyns : TypeSyns useMap : Map NontermIdent (Map Identifier (String,String,String)) wrappers : Set NontermIdent alternatives: alternative Cons: child hd : Elem child tl : Elems alternative Nil: -} -- cata sem_Elems :: Elems -> T_Elems sem_Elems list = (Prelude.foldr sem_Elems_Cons sem_Elems_Nil (Prelude.map sem_Elem list) ) -- semantic domain newtype T_Elems = T_Elems ((Map NontermIdent (Attributes, Attributes)) -> (Map NontermIdent (Set ConstructorIdent)) -> DataTypes -> (Set NontermIdent) -> (Map NontermIdent (Attributes, Attributes)) -> (Map Identifier (Set NontermIdent,Set Identifier)) -> DefinedSets -> ( (Map NontermIdent (Attributes, Attributes)),AttrOrderMap,Blocks,([ (NontermIdent, ConstructorIdent, [AroundInfo]) ]),([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ]),(Map NontermIdent (Set ConstructorIdent)),([(NontermIdent, ConstructorIdent, FieldMap)]),([ (NontermIdent, ConstructorIdent, [Identifier]) ]),(Set Identifier),([ (NontermIdent, ConstructorIdent, RuleInfo)]),(Set Identifier),([ (NontermIdent, ConstructorIdent, SigInfo) ]),([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ]),ContextMap,(Map Identifier (Set NontermIdent,Set Identifier)),Derivings,(Seq Error),(Maybe (String,String,String)),ParamMap,(Options -> Options),PragmaMap,TypeSyns,(Map NontermIdent (Map Identifier (String,String,String))),(Set NontermIdent))) data Inh_Elems = Inh_Elems {allAttrDecls_Inh_Elems :: !((Map NontermIdent (Attributes, Attributes))),allConstructors_Inh_Elems :: !((Map NontermIdent (Set ConstructorIdent))),allFields_Inh_Elems :: !(DataTypes),allNonterminals_Inh_Elems :: !((Set NontermIdent)),attrDecls_Inh_Elems :: !((Map NontermIdent (Attributes, Attributes))),defSets_Inh_Elems :: !((Map Identifier (Set NontermIdent,Set Identifier))),definedSets_Inh_Elems :: !(DefinedSets)} data Syn_Elems = Syn_Elems {attrDecls_Syn_Elems :: !((Map NontermIdent (Attributes, Attributes))),attrOrderCollect_Syn_Elems :: !(AttrOrderMap),blocks_Syn_Elems :: !(Blocks),collectedArounds_Syn_Elems :: !(([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])),collectedAugments_Syn_Elems :: !(([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])),collectedConstructorsMap_Syn_Elems :: !((Map NontermIdent (Set ConstructorIdent))),collectedFields_Syn_Elems :: !(([(NontermIdent, ConstructorIdent, FieldMap)])),collectedInsts_Syn_Elems :: !(([ (NontermIdent, ConstructorIdent, [Identifier]) ])),collectedNames_Syn_Elems :: !((Set Identifier)),collectedRules_Syn_Elems :: !(([ (NontermIdent, ConstructorIdent, RuleInfo)])),collectedSetNames_Syn_Elems :: !((Set Identifier)),collectedSigs_Syn_Elems :: !(([ (NontermIdent, ConstructorIdent, SigInfo) ])),collectedUniques_Syn_Elems :: !(([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])),ctxCollect_Syn_Elems :: !(ContextMap),defSets_Syn_Elems :: !((Map Identifier (Set NontermIdent,Set Identifier))),derivings_Syn_Elems :: !(Derivings),errors_Syn_Elems :: !((Seq Error)),moduleDecl_Syn_Elems :: !((Maybe (String,String,String))),paramsCollect_Syn_Elems :: !(ParamMap),pragmas_Syn_Elems :: !((Options -> Options)),semPragmasCollect_Syn_Elems :: !(PragmaMap),typeSyns_Syn_Elems :: !(TypeSyns),useMap_Syn_Elems :: !((Map NontermIdent (Map Identifier (String,String,String)))),wrappers_Syn_Elems :: !((Set NontermIdent))} wrap_Elems :: T_Elems -> Inh_Elems -> Syn_Elems wrap_Elems (T_Elems sem ) (Inh_Elems _lhsIallAttrDecls _lhsIallConstructors _lhsIallFields _lhsIallNonterminals _lhsIattrDecls _lhsIdefSets _lhsIdefinedSets ) = (let ( _lhsOattrDecls,_lhsOattrOrderCollect,_lhsOblocks,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedConstructorsMap,_lhsOcollectedFields,_lhsOcollectedInsts,_lhsOcollectedNames,_lhsOcollectedRules,_lhsOcollectedSetNames,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOctxCollect,_lhsOdefSets,_lhsOderivings,_lhsOerrors,_lhsOmoduleDecl,_lhsOparamsCollect,_lhsOpragmas,_lhsOsemPragmasCollect,_lhsOtypeSyns,_lhsOuseMap,_lhsOwrappers) = (sem _lhsIallAttrDecls _lhsIallConstructors _lhsIallFields _lhsIallNonterminals _lhsIattrDecls _lhsIdefSets _lhsIdefinedSets ) in (Syn_Elems _lhsOattrDecls _lhsOattrOrderCollect _lhsOblocks _lhsOcollectedArounds _lhsOcollectedAugments _lhsOcollectedConstructorsMap _lhsOcollectedFields _lhsOcollectedInsts _lhsOcollectedNames _lhsOcollectedRules _lhsOcollectedSetNames _lhsOcollectedSigs _lhsOcollectedUniques _lhsOctxCollect _lhsOdefSets _lhsOderivings _lhsOerrors _lhsOmoduleDecl _lhsOparamsCollect _lhsOpragmas _lhsOsemPragmasCollect _lhsOtypeSyns _lhsOuseMap _lhsOwrappers )) sem_Elems_Cons :: T_Elem -> T_Elems -> T_Elems sem_Elems_Cons (T_Elem hd_ ) (T_Elems tl_ ) = (T_Elems (\ _lhsIallAttrDecls _lhsIallConstructors _lhsIallFields _lhsIallNonterminals _lhsIattrDecls _lhsIdefSets _lhsIdefinedSets -> (let _lhsOattrOrderCollect :: AttrOrderMap _lhsOblocks :: Blocks _lhsOcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ]) _lhsOcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ]) _lhsOcollectedConstructorsMap :: (Map NontermIdent (Set ConstructorIdent)) _lhsOcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)]) _lhsOcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ]) _lhsOcollectedNames :: (Set Identifier) _lhsOcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)]) _lhsOcollectedSetNames :: (Set Identifier) _lhsOcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ]) _lhsOcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ]) _lhsOctxCollect :: ContextMap _lhsOderivings :: Derivings _lhsOerrors :: (Seq Error) _lhsOmoduleDecl :: (Maybe (String,String,String)) _lhsOparamsCollect :: ParamMap _lhsOpragmas :: (Options -> Options) _lhsOsemPragmasCollect :: PragmaMap _lhsOtypeSyns :: TypeSyns _lhsOuseMap :: (Map NontermIdent (Map Identifier (String,String,String))) _lhsOwrappers :: (Set NontermIdent) _lhsOattrDecls :: (Map NontermIdent (Attributes, Attributes)) _lhsOdefSets :: (Map Identifier (Set NontermIdent,Set Identifier)) _hdOallAttrDecls :: (Map NontermIdent (Attributes, Attributes)) _hdOallConstructors :: (Map NontermIdent (Set ConstructorIdent)) _hdOallFields :: DataTypes _hdOallNonterminals :: (Set NontermIdent) _hdOattrDecls :: (Map NontermIdent (Attributes, Attributes)) _hdOdefSets :: (Map Identifier (Set NontermIdent,Set Identifier)) _hdOdefinedSets :: DefinedSets _tlOallAttrDecls :: (Map NontermIdent (Attributes, Attributes)) _tlOallConstructors :: (Map NontermIdent (Set ConstructorIdent)) _tlOallFields :: DataTypes _tlOallNonterminals :: (Set NontermIdent) _tlOattrDecls :: (Map NontermIdent (Attributes, Attributes)) _tlOdefSets :: (Map Identifier (Set NontermIdent,Set Identifier)) _tlOdefinedSets :: DefinedSets _hdIattrDecls :: (Map NontermIdent (Attributes, Attributes)) _hdIattrOrderCollect :: AttrOrderMap _hdIblocks :: Blocks _hdIcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ]) _hdIcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ]) _hdIcollectedConstructorsMap :: (Map NontermIdent (Set ConstructorIdent)) _hdIcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)]) _hdIcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ]) _hdIcollectedNames :: (Set Identifier) _hdIcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)]) _hdIcollectedSetNames :: (Set Identifier) _hdIcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ]) _hdIcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ]) _hdIctxCollect :: ContextMap _hdIdefSets :: (Map Identifier (Set NontermIdent,Set Identifier)) _hdIderivings :: Derivings _hdIerrors :: (Seq Error) _hdImoduleDecl :: (Maybe (String,String,String)) _hdIparamsCollect :: ParamMap _hdIpragmas :: (Options -> Options) _hdIsemPragmasCollect :: PragmaMap _hdItypeSyns :: TypeSyns _hdIuseMap :: (Map NontermIdent (Map Identifier (String,String,String))) _hdIwrappers :: (Set NontermIdent) _tlIattrDecls :: (Map NontermIdent (Attributes, Attributes)) _tlIattrOrderCollect :: AttrOrderMap _tlIblocks :: Blocks _tlIcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ]) _tlIcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ]) _tlIcollectedConstructorsMap :: (Map NontermIdent (Set ConstructorIdent)) _tlIcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)]) _tlIcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ]) _tlIcollectedNames :: (Set Identifier) _tlIcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)]) _tlIcollectedSetNames :: (Set Identifier) _tlIcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ]) _tlIcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ]) _tlIctxCollect :: ContextMap _tlIdefSets :: (Map Identifier (Set NontermIdent,Set Identifier)) _tlIderivings :: Derivings _tlIerrors :: (Seq Error) _tlImoduleDecl :: (Maybe (String,String,String)) _tlIparamsCollect :: ParamMap _tlIpragmas :: (Options -> Options) _tlIsemPragmasCollect :: PragmaMap _tlItypeSyns :: TypeSyns _tlIuseMap :: (Map NontermIdent (Map Identifier (String,String,String))) _tlIwrappers :: (Set NontermIdent) -- use rule "Transform.ag"(line 745, column 55) _lhsOattrOrderCollect = ({-# LINE 745 "Transform.ag" #-} _hdIattrOrderCollect `orderMapUnion` _tlIattrOrderCollect {-# LINE 3562 "Transform.hs" #-}) -- use rule "Transform.ag"(line 44, column 19) _lhsOblocks = ({-# LINE 44 "Transform.ag" #-} _hdIblocks `mapUnionWithPlusPlus` _tlIblocks {-# LINE 3567 "Transform.hs" #-}) -- use rule "Transform.ag"(line 153, column 32) _lhsOcollectedArounds = ({-# LINE 153 "Transform.ag" #-} _hdIcollectedArounds ++ _tlIcollectedArounds {-# LINE 3572 "Transform.hs" #-}) -- use rule "Transform.ag"(line 152, column 32) _lhsOcollectedAugments = ({-# LINE 152 "Transform.ag" #-} _hdIcollectedAugments ++ _tlIcollectedAugments {-# LINE 3577 "Transform.hs" #-}) -- use rule "Transform.ag"(line 92, column 48) _lhsOcollectedConstructorsMap = ({-# LINE 92 "Transform.ag" #-} _hdIcollectedConstructorsMap `mapUnionWithSetUnion` _tlIcollectedConstructorsMap {-# LINE 3582 "Transform.hs" #-}) -- use rule "Transform.ag"(line 123, column 28) _lhsOcollectedFields = ({-# LINE 123 "Transform.ag" #-} _hdIcollectedFields ++ _tlIcollectedFields {-# LINE 3587 "Transform.hs" #-}) -- use rule "Transform.ag"(line 150, column 32) _lhsOcollectedInsts = ({-# LINE 150 "Transform.ag" #-} _hdIcollectedInsts ++ _tlIcollectedInsts {-# LINE 3592 "Transform.hs" #-}) -- use rule "Transform.ag"(line 84, column 50) _lhsOcollectedNames = ({-# LINE 84 "Transform.ag" #-} _hdIcollectedNames `Set.union` _tlIcollectedNames {-# LINE 3597 "Transform.hs" #-}) -- use rule "Transform.ag"(line 148, column 32) _lhsOcollectedRules = ({-# LINE 148 "Transform.ag" #-} _hdIcollectedRules ++ _tlIcollectedRules {-# LINE 3602 "Transform.hs" #-}) -- use rule "Transform.ag"(line 83, column 50) _lhsOcollectedSetNames = ({-# LINE 83 "Transform.ag" #-} _hdIcollectedSetNames `Set.union` _tlIcollectedSetNames {-# LINE 3607 "Transform.hs" #-}) -- use rule "Transform.ag"(line 149, column 32) _lhsOcollectedSigs = ({-# LINE 149 "Transform.ag" #-} _hdIcollectedSigs ++ _tlIcollectedSigs {-# LINE 3612 "Transform.hs" #-}) -- use rule "Transform.ag"(line 151, column 32) _lhsOcollectedUniques = ({-# LINE 151 "Transform.ag" #-} _hdIcollectedUniques ++ _tlIcollectedUniques {-# LINE 3617 "Transform.hs" #-}) -- use rule "Transform.ag"(line 800, column 34) _lhsOctxCollect = ({-# LINE 800 "Transform.ag" #-} _hdIctxCollect `mergeCtx` _tlIctxCollect {-# LINE 3622 "Transform.hs" #-}) -- use rule "Transform.ag"(line 825, column 33) _lhsOderivings = ({-# LINE 825 "Transform.ag" #-} _hdIderivings `mergeDerivings` _tlIderivings {-# LINE 3627 "Transform.hs" #-}) -- use rule "Transform.ag"(line 42, column 19) _lhsOerrors = ({-# LINE 42 "Transform.ag" #-} _hdIerrors Seq.>< _tlIerrors {-# LINE 3632 "Transform.hs" #-}) -- use rule "Transform.ag"(line 996, column 37) _lhsOmoduleDecl = ({-# LINE 996 "Transform.ag" #-} _hdImoduleDecl `mplus` _tlImoduleDecl {-# LINE 3637 "Transform.hs" #-}) -- use rule "Transform.ag"(line 777, column 37) _lhsOparamsCollect = ({-# LINE 777 "Transform.ag" #-} _hdIparamsCollect `mergeParams` _tlIparamsCollect {-# LINE 3642 "Transform.hs" #-}) -- use rule "Transform.ag"(line 673, column 34) _lhsOpragmas = ({-# LINE 673 "Transform.ag" #-} _hdIpragmas . _tlIpragmas {-# LINE 3647 "Transform.hs" #-}) -- use rule "Transform.ag"(line 717, column 56) _lhsOsemPragmasCollect = ({-# LINE 717 "Transform.ag" #-} _hdIsemPragmasCollect `pragmaMapUnion` _tlIsemPragmasCollect {-# LINE 3652 "Transform.hs" #-}) -- use rule "Transform.ag"(line 533, column 32) _lhsOtypeSyns = ({-# LINE 533 "Transform.ag" #-} _hdItypeSyns ++ _tlItypeSyns {-# LINE 3657 "Transform.hs" #-}) -- use rule "Transform.ag"(line 135, column 15) _lhsOuseMap = ({-# LINE 135 "Transform.ag" #-} _hdIuseMap `merge` _tlIuseMap {-# LINE 3662 "Transform.hs" #-}) -- use rule "Transform.ag"(line 664, column 32) _lhsOwrappers = ({-# LINE 664 "Transform.ag" #-} _hdIwrappers `Set.union` _tlIwrappers {-# LINE 3667 "Transform.hs" #-}) -- copy rule (up) _lhsOattrDecls = ({-# LINE 134 "Transform.ag" #-} _tlIattrDecls {-# LINE 3672 "Transform.hs" #-}) -- copy rule (up) _lhsOdefSets = ({-# LINE 102 "Transform.ag" #-} _tlIdefSets {-# LINE 3677 "Transform.hs" #-}) -- copy rule (down) _hdOallAttrDecls = ({-# LINE 746 "Transform.ag" #-} _lhsIallAttrDecls {-# LINE 3682 "Transform.hs" #-}) -- copy rule (down) _hdOallConstructors = ({-# LINE 94 "Transform.ag" #-} _lhsIallConstructors {-# LINE 3687 "Transform.hs" #-}) -- copy rule (down) _hdOallFields = ({-# LINE 126 "Transform.ag" #-} _lhsIallFields {-# LINE 3692 "Transform.hs" #-}) -- copy rule (down) _hdOallNonterminals = ({-# LINE 86 "Transform.ag" #-} _lhsIallNonterminals {-# LINE 3697 "Transform.hs" #-}) -- copy rule (down) _hdOattrDecls = ({-# LINE 134 "Transform.ag" #-} _lhsIattrDecls {-# LINE 3702 "Transform.hs" #-}) -- copy rule (down) _hdOdefSets = ({-# LINE 102 "Transform.ag" #-} _lhsIdefSets {-# LINE 3707 "Transform.hs" #-}) -- copy rule (down) _hdOdefinedSets = ({-# LINE 105 "Transform.ag" #-} _lhsIdefinedSets {-# LINE 3712 "Transform.hs" #-}) -- copy rule (down) _tlOallAttrDecls = ({-# LINE 746 "Transform.ag" #-} _lhsIallAttrDecls {-# LINE 3717 "Transform.hs" #-}) -- copy rule (down) _tlOallConstructors = ({-# LINE 94 "Transform.ag" #-} _lhsIallConstructors {-# LINE 3722 "Transform.hs" #-}) -- copy rule (down) _tlOallFields = ({-# LINE 126 "Transform.ag" #-} _lhsIallFields {-# LINE 3727 "Transform.hs" #-}) -- copy rule (down) _tlOallNonterminals = ({-# LINE 86 "Transform.ag" #-} _lhsIallNonterminals {-# LINE 3732 "Transform.hs" #-}) -- copy rule (chain) _tlOattrDecls = ({-# LINE 134 "Transform.ag" #-} _hdIattrDecls {-# LINE 3737 "Transform.hs" #-}) -- copy rule (chain) _tlOdefSets = ({-# LINE 102 "Transform.ag" #-} _hdIdefSets {-# LINE 3742 "Transform.hs" #-}) -- copy rule (down) _tlOdefinedSets = ({-# LINE 105 "Transform.ag" #-} _lhsIdefinedSets {-# LINE 3747 "Transform.hs" #-}) ( _hdIattrDecls,_hdIattrOrderCollect,_hdIblocks,_hdIcollectedArounds,_hdIcollectedAugments,_hdIcollectedConstructorsMap,_hdIcollectedFields,_hdIcollectedInsts,_hdIcollectedNames,_hdIcollectedRules,_hdIcollectedSetNames,_hdIcollectedSigs,_hdIcollectedUniques,_hdIctxCollect,_hdIdefSets,_hdIderivings,_hdIerrors,_hdImoduleDecl,_hdIparamsCollect,_hdIpragmas,_hdIsemPragmasCollect,_hdItypeSyns,_hdIuseMap,_hdIwrappers) = (hd_ _hdOallAttrDecls _hdOallConstructors _hdOallFields _hdOallNonterminals _hdOattrDecls _hdOdefSets _hdOdefinedSets ) ( _tlIattrDecls,_tlIattrOrderCollect,_tlIblocks,_tlIcollectedArounds,_tlIcollectedAugments,_tlIcollectedConstructorsMap,_tlIcollectedFields,_tlIcollectedInsts,_tlIcollectedNames,_tlIcollectedRules,_tlIcollectedSetNames,_tlIcollectedSigs,_tlIcollectedUniques,_tlIctxCollect,_tlIdefSets,_tlIderivings,_tlIerrors,_tlImoduleDecl,_tlIparamsCollect,_tlIpragmas,_tlIsemPragmasCollect,_tlItypeSyns,_tlIuseMap,_tlIwrappers) = (tl_ _tlOallAttrDecls _tlOallConstructors _tlOallFields _tlOallNonterminals _tlOattrDecls _tlOdefSets _tlOdefinedSets ) in ( _lhsOattrDecls,_lhsOattrOrderCollect,_lhsOblocks,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedConstructorsMap,_lhsOcollectedFields,_lhsOcollectedInsts,_lhsOcollectedNames,_lhsOcollectedRules,_lhsOcollectedSetNames,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOctxCollect,_lhsOdefSets,_lhsOderivings,_lhsOerrors,_lhsOmoduleDecl,_lhsOparamsCollect,_lhsOpragmas,_lhsOsemPragmasCollect,_lhsOtypeSyns,_lhsOuseMap,_lhsOwrappers))) ) sem_Elems_Nil :: T_Elems sem_Elems_Nil = (T_Elems (\ _lhsIallAttrDecls _lhsIallConstructors _lhsIallFields _lhsIallNonterminals _lhsIattrDecls _lhsIdefSets _lhsIdefinedSets -> (let _lhsOattrOrderCollect :: AttrOrderMap _lhsOblocks :: Blocks _lhsOcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ]) _lhsOcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ]) _lhsOcollectedConstructorsMap :: (Map NontermIdent (Set ConstructorIdent)) _lhsOcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)]) _lhsOcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ]) _lhsOcollectedNames :: (Set Identifier) _lhsOcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)]) _lhsOcollectedSetNames :: (Set Identifier) _lhsOcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ]) _lhsOcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ]) _lhsOctxCollect :: ContextMap _lhsOderivings :: Derivings _lhsOerrors :: (Seq Error) _lhsOmoduleDecl :: (Maybe (String,String,String)) _lhsOparamsCollect :: ParamMap _lhsOpragmas :: (Options -> Options) _lhsOsemPragmasCollect :: PragmaMap _lhsOtypeSyns :: TypeSyns _lhsOuseMap :: (Map NontermIdent (Map Identifier (String,String,String))) _lhsOwrappers :: (Set NontermIdent) _lhsOattrDecls :: (Map NontermIdent (Attributes, Attributes)) _lhsOdefSets :: (Map Identifier (Set NontermIdent,Set Identifier)) -- use rule "Transform.ag"(line 745, column 55) _lhsOattrOrderCollect = ({-# LINE 745 "Transform.ag" #-} Map.empty {-# LINE 3790 "Transform.hs" #-}) -- use rule "Transform.ag"(line 44, column 19) _lhsOblocks = ({-# LINE 44 "Transform.ag" #-} Map.empty {-# LINE 3795 "Transform.hs" #-}) -- use rule "Transform.ag"(line 153, column 32) _lhsOcollectedArounds = ({-# LINE 153 "Transform.ag" #-} [] {-# LINE 3800 "Transform.hs" #-}) -- use rule "Transform.ag"(line 152, column 32) _lhsOcollectedAugments = ({-# LINE 152 "Transform.ag" #-} [] {-# LINE 3805 "Transform.hs" #-}) -- use rule "Transform.ag"(line 92, column 48) _lhsOcollectedConstructorsMap = ({-# LINE 92 "Transform.ag" #-} Map.empty {-# LINE 3810 "Transform.hs" #-}) -- use rule "Transform.ag"(line 123, column 28) _lhsOcollectedFields = ({-# LINE 123 "Transform.ag" #-} [] {-# LINE 3815 "Transform.hs" #-}) -- use rule "Transform.ag"(line 150, column 32) _lhsOcollectedInsts = ({-# LINE 150 "Transform.ag" #-} [] {-# LINE 3820 "Transform.hs" #-}) -- use rule "Transform.ag"(line 84, column 50) _lhsOcollectedNames = ({-# LINE 84 "Transform.ag" #-} Set.empty {-# LINE 3825 "Transform.hs" #-}) -- use rule "Transform.ag"(line 148, column 32) _lhsOcollectedRules = ({-# LINE 148 "Transform.ag" #-} [] {-# LINE 3830 "Transform.hs" #-}) -- use rule "Transform.ag"(line 83, column 50) _lhsOcollectedSetNames = ({-# LINE 83 "Transform.ag" #-} Set.empty {-# LINE 3835 "Transform.hs" #-}) -- use rule "Transform.ag"(line 149, column 32) _lhsOcollectedSigs = ({-# LINE 149 "Transform.ag" #-} [] {-# LINE 3840 "Transform.hs" #-}) -- use rule "Transform.ag"(line 151, column 32) _lhsOcollectedUniques = ({-# LINE 151 "Transform.ag" #-} [] {-# LINE 3845 "Transform.hs" #-}) -- use rule "Transform.ag"(line 800, column 34) _lhsOctxCollect = ({-# LINE 800 "Transform.ag" #-} Map.empty {-# LINE 3850 "Transform.hs" #-}) -- use rule "Transform.ag"(line 825, column 33) _lhsOderivings = ({-# LINE 825 "Transform.ag" #-} Map.empty {-# LINE 3855 "Transform.hs" #-}) -- use rule "Transform.ag"(line 42, column 19) _lhsOerrors = ({-# LINE 42 "Transform.ag" #-} Seq.empty {-# LINE 3860 "Transform.hs" #-}) -- use rule "Transform.ag"(line 996, column 37) _lhsOmoduleDecl = ({-# LINE 996 "Transform.ag" #-} mzero {-# LINE 3865 "Transform.hs" #-}) -- use rule "Transform.ag"(line 777, column 37) _lhsOparamsCollect = ({-# LINE 777 "Transform.ag" #-} Map.empty {-# LINE 3870 "Transform.hs" #-}) -- use rule "Transform.ag"(line 673, column 34) _lhsOpragmas = ({-# LINE 673 "Transform.ag" #-} id {-# LINE 3875 "Transform.hs" #-}) -- use rule "Transform.ag"(line 717, column 56) _lhsOsemPragmasCollect = ({-# LINE 717 "Transform.ag" #-} Map.empty {-# LINE 3880 "Transform.hs" #-}) -- use rule "Transform.ag"(line 533, column 32) _lhsOtypeSyns = ({-# LINE 533 "Transform.ag" #-} [] {-# LINE 3885 "Transform.hs" #-}) -- use rule "Transform.ag"(line 135, column 15) _lhsOuseMap = ({-# LINE 135 "Transform.ag" #-} Map.empty {-# LINE 3890 "Transform.hs" #-}) -- use rule "Transform.ag"(line 664, column 32) _lhsOwrappers = ({-# LINE 664 "Transform.ag" #-} Set.empty {-# LINE 3895 "Transform.hs" #-}) -- copy rule (chain) _lhsOattrDecls = ({-# LINE 134 "Transform.ag" #-} _lhsIattrDecls {-# LINE 3900 "Transform.hs" #-}) -- copy rule (chain) _lhsOdefSets = ({-# LINE 102 "Transform.ag" #-} _lhsIdefSets {-# LINE 3905 "Transform.hs" #-}) in ( _lhsOattrDecls,_lhsOattrOrderCollect,_lhsOblocks,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedConstructorsMap,_lhsOcollectedFields,_lhsOcollectedInsts,_lhsOcollectedNames,_lhsOcollectedRules,_lhsOcollectedSetNames,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOctxCollect,_lhsOdefSets,_lhsOderivings,_lhsOerrors,_lhsOmoduleDecl,_lhsOparamsCollect,_lhsOpragmas,_lhsOsemPragmasCollect,_lhsOtypeSyns,_lhsOuseMap,_lhsOwrappers))) ) -- NontSet ----------------------------------------------------- {- visit 0: inherited attributes: allFields : DataTypes allNonterminals : Set NontermIdent definedSets : DefinedSets synthesized attributes: collectedNames : Set Identifier errors : Seq Error nontSet : Set NontermIdent alternatives: alternative All: alternative Difference: child set1 : NontSet child set2 : NontSet alternative Intersect: child set1 : NontSet child set2 : NontSet alternative NamedSet: child name : {NontermIdent} visit 0: local _tup4 : _ local nontSet : _ local errors : _ alternative Path: child from : {NontermIdent} child to : {NontermIdent} alternative Union: child set1 : NontSet child set2 : NontSet -} -- cata sem_NontSet :: NontSet -> T_NontSet sem_NontSet (All ) = (sem_NontSet_All ) sem_NontSet (Difference _set1 _set2 ) = (sem_NontSet_Difference (sem_NontSet _set1 ) (sem_NontSet _set2 ) ) sem_NontSet (Intersect _set1 _set2 ) = (sem_NontSet_Intersect (sem_NontSet _set1 ) (sem_NontSet _set2 ) ) sem_NontSet (NamedSet _name ) = (sem_NontSet_NamedSet _name ) sem_NontSet (Path _from _to ) = (sem_NontSet_Path _from _to ) sem_NontSet (Union _set1 _set2 ) = (sem_NontSet_Union (sem_NontSet _set1 ) (sem_NontSet _set2 ) ) -- semantic domain newtype T_NontSet = T_NontSet (DataTypes -> (Set NontermIdent) -> DefinedSets -> ( (Set Identifier),(Seq Error),(Set NontermIdent))) data Inh_NontSet = Inh_NontSet {allFields_Inh_NontSet :: !(DataTypes),allNonterminals_Inh_NontSet :: !((Set NontermIdent)),definedSets_Inh_NontSet :: !(DefinedSets)} data Syn_NontSet = Syn_NontSet {collectedNames_Syn_NontSet :: !((Set Identifier)),errors_Syn_NontSet :: !((Seq Error)),nontSet_Syn_NontSet :: !((Set NontermIdent))} wrap_NontSet :: T_NontSet -> Inh_NontSet -> Syn_NontSet wrap_NontSet (T_NontSet sem ) (Inh_NontSet _lhsIallFields _lhsIallNonterminals _lhsIdefinedSets ) = (let ( _lhsOcollectedNames,_lhsOerrors,_lhsOnontSet) = (sem _lhsIallFields _lhsIallNonterminals _lhsIdefinedSets ) in (Syn_NontSet _lhsOcollectedNames _lhsOerrors _lhsOnontSet )) sem_NontSet_All :: T_NontSet sem_NontSet_All = (T_NontSet (\ _lhsIallFields _lhsIallNonterminals _lhsIdefinedSets -> (let _lhsOnontSet :: (Set NontermIdent) _lhsOcollectedNames :: (Set Identifier) _lhsOerrors :: (Seq Error) -- "Transform.ag"(line 610, column 16) _lhsOnontSet = ({-# LINE 610 "Transform.ag" #-} _lhsIallNonterminals {-# LINE 3980 "Transform.hs" #-}) -- use rule "Transform.ag"(line 84, column 50) _lhsOcollectedNames = ({-# LINE 84 "Transform.ag" #-} Set.empty {-# LINE 3985 "Transform.hs" #-}) -- use rule "Transform.ag"(line 42, column 19) _lhsOerrors = ({-# LINE 42 "Transform.ag" #-} Seq.empty {-# LINE 3990 "Transform.hs" #-}) in ( _lhsOcollectedNames,_lhsOerrors,_lhsOnontSet))) ) sem_NontSet_Difference :: T_NontSet -> T_NontSet -> T_NontSet sem_NontSet_Difference (T_NontSet set1_ ) (T_NontSet set2_ ) = (T_NontSet (\ _lhsIallFields _lhsIallNonterminals _lhsIdefinedSets -> (let _lhsOnontSet :: (Set NontermIdent) _lhsOcollectedNames :: (Set Identifier) _lhsOerrors :: (Seq Error) _set1OallFields :: DataTypes _set1OallNonterminals :: (Set NontermIdent) _set1OdefinedSets :: DefinedSets _set2OallFields :: DataTypes _set2OallNonterminals :: (Set NontermIdent) _set2OdefinedSets :: DefinedSets _set1IcollectedNames :: (Set Identifier) _set1Ierrors :: (Seq Error) _set1InontSet :: (Set NontermIdent) _set2IcollectedNames :: (Set Identifier) _set2Ierrors :: (Seq Error) _set2InontSet :: (Set NontermIdent) -- "Transform.ag"(line 616, column 16) _lhsOnontSet = ({-# LINE 616 "Transform.ag" #-} Set.difference _set1InontSet _set2InontSet {-# LINE 4018 "Transform.hs" #-}) -- use rule "Transform.ag"(line 84, column 50) _lhsOcollectedNames = ({-# LINE 84 "Transform.ag" #-} _set1IcollectedNames `Set.union` _set2IcollectedNames {-# LINE 4023 "Transform.hs" #-}) -- use rule "Transform.ag"(line 42, column 19) _lhsOerrors = ({-# LINE 42 "Transform.ag" #-} _set1Ierrors Seq.>< _set2Ierrors {-# LINE 4028 "Transform.hs" #-}) -- copy rule (down) _set1OallFields = ({-# LINE 126 "Transform.ag" #-} _lhsIallFields {-# LINE 4033 "Transform.hs" #-}) -- copy rule (down) _set1OallNonterminals = ({-# LINE 86 "Transform.ag" #-} _lhsIallNonterminals {-# LINE 4038 "Transform.hs" #-}) -- copy rule (down) _set1OdefinedSets = ({-# LINE 105 "Transform.ag" #-} _lhsIdefinedSets {-# LINE 4043 "Transform.hs" #-}) -- copy rule (down) _set2OallFields = ({-# LINE 126 "Transform.ag" #-} _lhsIallFields {-# LINE 4048 "Transform.hs" #-}) -- copy rule (down) _set2OallNonterminals = ({-# LINE 86 "Transform.ag" #-} _lhsIallNonterminals {-# LINE 4053 "Transform.hs" #-}) -- copy rule (down) _set2OdefinedSets = ({-# LINE 105 "Transform.ag" #-} _lhsIdefinedSets {-# LINE 4058 "Transform.hs" #-}) ( _set1IcollectedNames,_set1Ierrors,_set1InontSet) = (set1_ _set1OallFields _set1OallNonterminals _set1OdefinedSets ) ( _set2IcollectedNames,_set2Ierrors,_set2InontSet) = (set2_ _set2OallFields _set2OallNonterminals _set2OdefinedSets ) in ( _lhsOcollectedNames,_lhsOerrors,_lhsOnontSet))) ) sem_NontSet_Intersect :: T_NontSet -> T_NontSet -> T_NontSet sem_NontSet_Intersect (T_NontSet set1_ ) (T_NontSet set2_ ) = (T_NontSet (\ _lhsIallFields _lhsIallNonterminals _lhsIdefinedSets -> (let _lhsOnontSet :: (Set NontermIdent) _lhsOcollectedNames :: (Set Identifier) _lhsOerrors :: (Seq Error) _set1OallFields :: DataTypes _set1OallNonterminals :: (Set NontermIdent) _set1OdefinedSets :: DefinedSets _set2OallFields :: DataTypes _set2OallNonterminals :: (Set NontermIdent) _set2OdefinedSets :: DefinedSets _set1IcollectedNames :: (Set Identifier) _set1Ierrors :: (Seq Error) _set1InontSet :: (Set NontermIdent) _set2IcollectedNames :: (Set Identifier) _set2Ierrors :: (Seq Error) _set2InontSet :: (Set NontermIdent) -- "Transform.ag"(line 615, column 16) _lhsOnontSet = ({-# LINE 615 "Transform.ag" #-} Set.intersection _set1InontSet _set2InontSet {-# LINE 4090 "Transform.hs" #-}) -- use rule "Transform.ag"(line 84, column 50) _lhsOcollectedNames = ({-# LINE 84 "Transform.ag" #-} _set1IcollectedNames `Set.union` _set2IcollectedNames {-# LINE 4095 "Transform.hs" #-}) -- use rule "Transform.ag"(line 42, column 19) _lhsOerrors = ({-# LINE 42 "Transform.ag" #-} _set1Ierrors Seq.>< _set2Ierrors {-# LINE 4100 "Transform.hs" #-}) -- copy rule (down) _set1OallFields = ({-# LINE 126 "Transform.ag" #-} _lhsIallFields {-# LINE 4105 "Transform.hs" #-}) -- copy rule (down) _set1OallNonterminals = ({-# LINE 86 "Transform.ag" #-} _lhsIallNonterminals {-# LINE 4110 "Transform.hs" #-}) -- copy rule (down) _set1OdefinedSets = ({-# LINE 105 "Transform.ag" #-} _lhsIdefinedSets {-# LINE 4115 "Transform.hs" #-}) -- copy rule (down) _set2OallFields = ({-# LINE 126 "Transform.ag" #-} _lhsIallFields {-# LINE 4120 "Transform.hs" #-}) -- copy rule (down) _set2OallNonterminals = ({-# LINE 86 "Transform.ag" #-} _lhsIallNonterminals {-# LINE 4125 "Transform.hs" #-}) -- copy rule (down) _set2OdefinedSets = ({-# LINE 105 "Transform.ag" #-} _lhsIdefinedSets {-# LINE 4130 "Transform.hs" #-}) ( _set1IcollectedNames,_set1Ierrors,_set1InontSet) = (set1_ _set1OallFields _set1OallNonterminals _set1OdefinedSets ) ( _set2IcollectedNames,_set2Ierrors,_set2InontSet) = (set2_ _set2OallFields _set2OallNonterminals _set2OdefinedSets ) in ( _lhsOcollectedNames,_lhsOerrors,_lhsOnontSet))) ) sem_NontSet_NamedSet :: NontermIdent -> T_NontSet sem_NontSet_NamedSet name_ = (T_NontSet (\ _lhsIallFields _lhsIallNonterminals _lhsIdefinedSets -> (let _lhsOcollectedNames :: (Set Identifier) _lhsOerrors :: (Seq Error) _lhsOnontSet :: (Set NontermIdent) -- "Transform.ag"(line 495, column 14) _lhsOcollectedNames = ({-# LINE 495 "Transform.ag" #-} Set.singleton name_ {-# LINE 4149 "Transform.hs" #-}) -- "Transform.ag"(line 611, column 20) __tup4 = ({-# LINE 611 "Transform.ag" #-} case Map.lookup name_ _lhsIdefinedSets of Nothing -> (Set.empty, Seq.singleton (UndefNont name_)) Just set -> (set, Seq.empty) {-# LINE 4156 "Transform.hs" #-}) -- "Transform.ag"(line 611, column 20) (_nontSet,_) = ({-# LINE 611 "Transform.ag" #-} __tup4 {-# LINE 4161 "Transform.hs" #-}) -- "Transform.ag"(line 611, column 20) (_,_errors) = ({-# LINE 611 "Transform.ag" #-} __tup4 {-# LINE 4166 "Transform.hs" #-}) -- use rule "Transform.ag"(line 42, column 19) _lhsOerrors = ({-# LINE 42 "Transform.ag" #-} _errors {-# LINE 4171 "Transform.hs" #-}) -- copy rule (from local) _lhsOnontSet = ({-# LINE 110 "Transform.ag" #-} _nontSet {-# LINE 4176 "Transform.hs" #-}) in ( _lhsOcollectedNames,_lhsOerrors,_lhsOnontSet))) ) sem_NontSet_Path :: NontermIdent -> NontermIdent -> T_NontSet sem_NontSet_Path from_ to_ = (T_NontSet (\ _lhsIallFields _lhsIallNonterminals _lhsIdefinedSets -> (let _lhsOnontSet :: (Set NontermIdent) _lhsOerrors :: (Seq Error) _lhsOcollectedNames :: (Set Identifier) -- "Transform.ag"(line 617, column 16) _lhsOnontSet = ({-# LINE 617 "Transform.ag" #-} let table = flattenDatas _lhsIallFields in path table from_ to_ {-# LINE 4193 "Transform.hs" #-}) -- "Transform.ag"(line 619, column 16) _lhsOerrors = ({-# LINE 619 "Transform.ag" #-} let check name | Set.member name _lhsIallNonterminals = Seq.empty | otherwise = Seq.singleton (UndefNont name) in check from_ >< check to_ {-# LINE 4201 "Transform.hs" #-}) -- use rule "Transform.ag"(line 84, column 50) _lhsOcollectedNames = ({-# LINE 84 "Transform.ag" #-} Set.empty {-# LINE 4206 "Transform.hs" #-}) in ( _lhsOcollectedNames,_lhsOerrors,_lhsOnontSet))) ) sem_NontSet_Union :: T_NontSet -> T_NontSet -> T_NontSet sem_NontSet_Union (T_NontSet set1_ ) (T_NontSet set2_ ) = (T_NontSet (\ _lhsIallFields _lhsIallNonterminals _lhsIdefinedSets -> (let _lhsOnontSet :: (Set NontermIdent) _lhsOcollectedNames :: (Set Identifier) _lhsOerrors :: (Seq Error) _set1OallFields :: DataTypes _set1OallNonterminals :: (Set NontermIdent) _set1OdefinedSets :: DefinedSets _set2OallFields :: DataTypes _set2OallNonterminals :: (Set NontermIdent) _set2OdefinedSets :: DefinedSets _set1IcollectedNames :: (Set Identifier) _set1Ierrors :: (Seq Error) _set1InontSet :: (Set NontermIdent) _set2IcollectedNames :: (Set Identifier) _set2Ierrors :: (Seq Error) _set2InontSet :: (Set NontermIdent) -- "Transform.ag"(line 614, column 16) _lhsOnontSet = ({-# LINE 614 "Transform.ag" #-} Set.union _set1InontSet _set2InontSet {-# LINE 4234 "Transform.hs" #-}) -- use rule "Transform.ag"(line 84, column 50) _lhsOcollectedNames = ({-# LINE 84 "Transform.ag" #-} _set1IcollectedNames `Set.union` _set2IcollectedNames {-# LINE 4239 "Transform.hs" #-}) -- use rule "Transform.ag"(line 42, column 19) _lhsOerrors = ({-# LINE 42 "Transform.ag" #-} _set1Ierrors Seq.>< _set2Ierrors {-# LINE 4244 "Transform.hs" #-}) -- copy rule (down) _set1OallFields = ({-# LINE 126 "Transform.ag" #-} _lhsIallFields {-# LINE 4249 "Transform.hs" #-}) -- copy rule (down) _set1OallNonterminals = ({-# LINE 86 "Transform.ag" #-} _lhsIallNonterminals {-# LINE 4254 "Transform.hs" #-}) -- copy rule (down) _set1OdefinedSets = ({-# LINE 105 "Transform.ag" #-} _lhsIdefinedSets {-# LINE 4259 "Transform.hs" #-}) -- copy rule (down) _set2OallFields = ({-# LINE 126 "Transform.ag" #-} _lhsIallFields {-# LINE 4264 "Transform.hs" #-}) -- copy rule (down) _set2OallNonterminals = ({-# LINE 86 "Transform.ag" #-} _lhsIallNonterminals {-# LINE 4269 "Transform.hs" #-}) -- copy rule (down) _set2OdefinedSets = ({-# LINE 105 "Transform.ag" #-} _lhsIdefinedSets {-# LINE 4274 "Transform.hs" #-}) ( _set1IcollectedNames,_set1Ierrors,_set1InontSet) = (set1_ _set1OallFields _set1OallNonterminals _set1OdefinedSets ) ( _set2IcollectedNames,_set2Ierrors,_set2InontSet) = (set2_ _set2OallFields _set2OallNonterminals _set2OdefinedSets ) in ( _lhsOcollectedNames,_lhsOerrors,_lhsOnontSet))) ) -- Pattern ----------------------------------------------------- {- visit 0: synthesized attributes: copy : SELF definedAttrs : [AttrName] definedInsts : [Identifier] patunder : [AttrName]->Pattern stpos : Pos alternatives: alternative Alias: child field : {Identifier} child attr : {Identifier} child pat : Pattern child parts : Patterns visit 0: local copy : _ alternative Constr: child name : {ConstructorIdent} child pats : Patterns visit 0: local copy : _ alternative Irrefutable: child pat : Pattern visit 0: local copy : _ alternative Product: child pos : {Pos} child pats : Patterns visit 0: local copy : _ alternative Underscore: child pos : {Pos} visit 0: local copy : _ -} -- cata sem_Pattern :: Pattern -> T_Pattern sem_Pattern (Alias _field _attr _pat _parts ) = (sem_Pattern_Alias _field _attr (sem_Pattern _pat ) (sem_Patterns _parts ) ) sem_Pattern (Constr _name _pats ) = (sem_Pattern_Constr _name (sem_Patterns _pats ) ) sem_Pattern (Irrefutable _pat ) = (sem_Pattern_Irrefutable (sem_Pattern _pat ) ) sem_Pattern (Product _pos _pats ) = (sem_Pattern_Product _pos (sem_Patterns _pats ) ) sem_Pattern (Underscore _pos ) = (sem_Pattern_Underscore _pos ) -- semantic domain newtype T_Pattern = T_Pattern (( Pattern ,([AttrName]),([Identifier]),([AttrName]->Pattern),Pos)) data Inh_Pattern = Inh_Pattern {} data Syn_Pattern = Syn_Pattern {copy_Syn_Pattern :: !(Pattern ),definedAttrs_Syn_Pattern :: !(([AttrName])),definedInsts_Syn_Pattern :: !(([Identifier])),patunder_Syn_Pattern :: !(([AttrName]->Pattern)),stpos_Syn_Pattern :: !(Pos)} wrap_Pattern :: T_Pattern -> Inh_Pattern -> Syn_Pattern wrap_Pattern (T_Pattern sem ) (Inh_Pattern ) = (let ( _lhsOcopy,_lhsOdefinedAttrs,_lhsOdefinedInsts,_lhsOpatunder,_lhsOstpos) = (sem ) in (Syn_Pattern _lhsOcopy _lhsOdefinedAttrs _lhsOdefinedInsts _lhsOpatunder _lhsOstpos )) sem_Pattern_Alias :: Identifier -> Identifier -> T_Pattern -> T_Patterns -> T_Pattern sem_Pattern_Alias field_ attr_ (T_Pattern pat_ ) (T_Patterns parts_ ) = (T_Pattern (let _lhsOdefinedAttrs :: ([AttrName]) _lhsOpatunder :: ([AttrName]->Pattern) _lhsOdefinedInsts :: ([Identifier]) _lhsOstpos :: Pos _lhsOcopy :: Pattern _patIcopy :: Pattern _patIdefinedAttrs :: ([AttrName]) _patIdefinedInsts :: ([Identifier]) _patIpatunder :: ([AttrName]->Pattern) _patIstpos :: Pos _partsIcopy :: Patterns _partsIdefinedAttrs :: ([AttrName]) _partsIdefinedInsts :: ([Identifier]) _partsIpatunder :: ([AttrName]->Patterns) -- "Transform.ag"(line 972, column 11) _lhsOdefinedAttrs = ({-# LINE 972 "Transform.ag" #-} (field_, attr_) : _patIdefinedAttrs {-# LINE 4364 "Transform.hs" #-}) -- "Transform.ag"(line 973, column 11) _lhsOpatunder = ({-# LINE 973 "Transform.ag" #-} \us -> if ((field_,attr_) `elem` us) then Underscore noPos else _copy {-# LINE 4369 "Transform.hs" #-}) -- "Transform.ag"(line 974, column 11) _lhsOdefinedInsts = ({-# LINE 974 "Transform.ag" #-} (if field_ == _INST then [attr_] else []) ++ _patIdefinedInsts {-# LINE 4374 "Transform.hs" #-}) -- "Transform.ag"(line 989, column 16) _lhsOstpos = ({-# LINE 989 "Transform.ag" #-} getPos field_ {-# LINE 4379 "Transform.hs" #-}) -- self rule _copy = ({-# LINE 23 "./Patterns.ag" #-} Alias field_ attr_ _patIcopy _partsIcopy {-# LINE 4384 "Transform.hs" #-}) -- self rule _lhsOcopy = ({-# LINE 23 "./Patterns.ag" #-} _copy {-# LINE 4389 "Transform.hs" #-}) ( _patIcopy,_patIdefinedAttrs,_patIdefinedInsts,_patIpatunder,_patIstpos) = (pat_ ) ( _partsIcopy,_partsIdefinedAttrs,_partsIdefinedInsts,_partsIpatunder) = (parts_ ) in ( _lhsOcopy,_lhsOdefinedAttrs,_lhsOdefinedInsts,_lhsOpatunder,_lhsOstpos)) ) sem_Pattern_Constr :: ConstructorIdent -> T_Patterns -> T_Pattern sem_Pattern_Constr name_ (T_Patterns pats_ ) = (T_Pattern (let _lhsOpatunder :: ([AttrName]->Pattern) _lhsOstpos :: Pos _lhsOdefinedAttrs :: ([AttrName]) _lhsOdefinedInsts :: ([Identifier]) _lhsOcopy :: Pattern _patsIcopy :: Patterns _patsIdefinedAttrs :: ([AttrName]) _patsIdefinedInsts :: ([Identifier]) _patsIpatunder :: ([AttrName]->Patterns) -- "Transform.ag"(line 976, column 12) _lhsOpatunder = ({-# LINE 976 "Transform.ag" #-} \us -> Constr name_ (_patsIpatunder us) {-# LINE 4412 "Transform.hs" #-}) -- "Transform.ag"(line 987, column 16) _lhsOstpos = ({-# LINE 987 "Transform.ag" #-} getPos name_ {-# LINE 4417 "Transform.hs" #-}) -- use rule "Transform.ag"(line 967, column 42) _lhsOdefinedAttrs = ({-# LINE 967 "Transform.ag" #-} _patsIdefinedAttrs {-# LINE 4422 "Transform.hs" #-}) -- use rule "Transform.ag"(line 966, column 55) _lhsOdefinedInsts = ({-# LINE 966 "Transform.ag" #-} _patsIdefinedInsts {-# LINE 4427 "Transform.hs" #-}) -- self rule _copy = ({-# LINE 23 "./Patterns.ag" #-} Constr name_ _patsIcopy {-# LINE 4432 "Transform.hs" #-}) -- self rule _lhsOcopy = ({-# LINE 23 "./Patterns.ag" #-} _copy {-# LINE 4437 "Transform.hs" #-}) ( _patsIcopy,_patsIdefinedAttrs,_patsIdefinedInsts,_patsIpatunder) = (pats_ ) in ( _lhsOcopy,_lhsOdefinedAttrs,_lhsOdefinedInsts,_lhsOpatunder,_lhsOstpos)) ) sem_Pattern_Irrefutable :: T_Pattern -> T_Pattern sem_Pattern_Irrefutable (T_Pattern pat_ ) = (T_Pattern (let _lhsOpatunder :: ([AttrName]->Pattern) _lhsOdefinedAttrs :: ([AttrName]) _lhsOdefinedInsts :: ([Identifier]) _lhsOcopy :: Pattern _lhsOstpos :: Pos _patIcopy :: Pattern _patIdefinedAttrs :: ([AttrName]) _patIdefinedInsts :: ([Identifier]) _patIpatunder :: ([AttrName]->Pattern) _patIstpos :: Pos -- "Transform.ag"(line 978, column 17) _lhsOpatunder = ({-# LINE 978 "Transform.ag" #-} \us -> Irrefutable (_patIpatunder us) {-# LINE 4458 "Transform.hs" #-}) -- use rule "Transform.ag"(line 967, column 42) _lhsOdefinedAttrs = ({-# LINE 967 "Transform.ag" #-} _patIdefinedAttrs {-# LINE 4463 "Transform.hs" #-}) -- use rule "Transform.ag"(line 966, column 55) _lhsOdefinedInsts = ({-# LINE 966 "Transform.ag" #-} _patIdefinedInsts {-# LINE 4468 "Transform.hs" #-}) -- self rule _copy = ({-# LINE 23 "./Patterns.ag" #-} Irrefutable _patIcopy {-# LINE 4473 "Transform.hs" #-}) -- self rule _lhsOcopy = ({-# LINE 23 "./Patterns.ag" #-} _copy {-# LINE 4478 "Transform.hs" #-}) -- copy rule (up) _lhsOstpos = ({-# LINE 984 "Transform.ag" #-} _patIstpos {-# LINE 4483 "Transform.hs" #-}) ( _patIcopy,_patIdefinedAttrs,_patIdefinedInsts,_patIpatunder,_patIstpos) = (pat_ ) in ( _lhsOcopy,_lhsOdefinedAttrs,_lhsOdefinedInsts,_lhsOpatunder,_lhsOstpos)) ) sem_Pattern_Product :: Pos -> T_Patterns -> T_Pattern sem_Pattern_Product pos_ (T_Patterns pats_ ) = (T_Pattern (let _lhsOpatunder :: ([AttrName]->Pattern) _lhsOstpos :: Pos _lhsOdefinedAttrs :: ([AttrName]) _lhsOdefinedInsts :: ([Identifier]) _lhsOcopy :: Pattern _patsIcopy :: Patterns _patsIdefinedAttrs :: ([AttrName]) _patsIdefinedInsts :: ([Identifier]) _patsIpatunder :: ([AttrName]->Patterns) -- "Transform.ag"(line 977, column 13) _lhsOpatunder = ({-# LINE 977 "Transform.ag" #-} \us -> Product pos_ (_patsIpatunder us) {-# LINE 4504 "Transform.hs" #-}) -- "Transform.ag"(line 988, column 16) _lhsOstpos = ({-# LINE 988 "Transform.ag" #-} pos_ {-# LINE 4509 "Transform.hs" #-}) -- use rule "Transform.ag"(line 967, column 42) _lhsOdefinedAttrs = ({-# LINE 967 "Transform.ag" #-} _patsIdefinedAttrs {-# LINE 4514 "Transform.hs" #-}) -- use rule "Transform.ag"(line 966, column 55) _lhsOdefinedInsts = ({-# LINE 966 "Transform.ag" #-} _patsIdefinedInsts {-# LINE 4519 "Transform.hs" #-}) -- self rule _copy = ({-# LINE 23 "./Patterns.ag" #-} Product pos_ _patsIcopy {-# LINE 4524 "Transform.hs" #-}) -- self rule _lhsOcopy = ({-# LINE 23 "./Patterns.ag" #-} _copy {-# LINE 4529 "Transform.hs" #-}) ( _patsIcopy,_patsIdefinedAttrs,_patsIdefinedInsts,_patsIpatunder) = (pats_ ) in ( _lhsOcopy,_lhsOdefinedAttrs,_lhsOdefinedInsts,_lhsOpatunder,_lhsOstpos)) ) sem_Pattern_Underscore :: Pos -> T_Pattern sem_Pattern_Underscore pos_ = (T_Pattern (let _lhsOpatunder :: ([AttrName]->Pattern) _lhsOstpos :: Pos _lhsOdefinedAttrs :: ([AttrName]) _lhsOdefinedInsts :: ([Identifier]) _lhsOcopy :: Pattern -- "Transform.ag"(line 975, column 16) _lhsOpatunder = ({-# LINE 975 "Transform.ag" #-} \us -> _copy {-# LINE 4545 "Transform.hs" #-}) -- "Transform.ag"(line 990, column 16) _lhsOstpos = ({-# LINE 990 "Transform.ag" #-} pos_ {-# LINE 4550 "Transform.hs" #-}) -- use rule "Transform.ag"(line 967, column 42) _lhsOdefinedAttrs = ({-# LINE 967 "Transform.ag" #-} [] {-# LINE 4555 "Transform.hs" #-}) -- use rule "Transform.ag"(line 966, column 55) _lhsOdefinedInsts = ({-# LINE 966 "Transform.ag" #-} [] {-# LINE 4560 "Transform.hs" #-}) -- self rule _copy = ({-# LINE 23 "./Patterns.ag" #-} Underscore pos_ {-# LINE 4565 "Transform.hs" #-}) -- self rule _lhsOcopy = ({-# LINE 23 "./Patterns.ag" #-} _copy {-# LINE 4570 "Transform.hs" #-}) in ( _lhsOcopy,_lhsOdefinedAttrs,_lhsOdefinedInsts,_lhsOpatunder,_lhsOstpos)) ) -- Patterns ---------------------------------------------------- {- visit 0: synthesized attributes: copy : SELF definedAttrs : [AttrName] definedInsts : [Identifier] patunder : [AttrName]->Patterns alternatives: alternative Cons: child hd : Pattern child tl : Patterns visit 0: local copy : _ alternative Nil: visit 0: local copy : _ -} -- cata sem_Patterns :: Patterns -> T_Patterns sem_Patterns list = (Prelude.foldr sem_Patterns_Cons sem_Patterns_Nil (Prelude.map sem_Pattern list) ) -- semantic domain newtype T_Patterns = T_Patterns (( Patterns ,([AttrName]),([Identifier]),([AttrName]->Patterns))) data Inh_Patterns = Inh_Patterns {} data Syn_Patterns = Syn_Patterns {copy_Syn_Patterns :: !(Patterns ),definedAttrs_Syn_Patterns :: !(([AttrName])),definedInsts_Syn_Patterns :: !(([Identifier])),patunder_Syn_Patterns :: !(([AttrName]->Patterns))} wrap_Patterns :: T_Patterns -> Inh_Patterns -> Syn_Patterns wrap_Patterns (T_Patterns sem ) (Inh_Patterns ) = (let ( _lhsOcopy,_lhsOdefinedAttrs,_lhsOdefinedInsts,_lhsOpatunder) = (sem ) in (Syn_Patterns _lhsOcopy _lhsOdefinedAttrs _lhsOdefinedInsts _lhsOpatunder )) sem_Patterns_Cons :: T_Pattern -> T_Patterns -> T_Patterns sem_Patterns_Cons (T_Pattern hd_ ) (T_Patterns tl_ ) = (T_Patterns (let _lhsOpatunder :: ([AttrName]->Patterns) _lhsOdefinedAttrs :: ([AttrName]) _lhsOdefinedInsts :: ([Identifier]) _lhsOcopy :: Patterns _hdIcopy :: Pattern _hdIdefinedAttrs :: ([AttrName]) _hdIdefinedInsts :: ([Identifier]) _hdIpatunder :: ([AttrName]->Pattern) _hdIstpos :: Pos _tlIcopy :: Patterns _tlIdefinedAttrs :: ([AttrName]) _tlIdefinedInsts :: ([Identifier]) _tlIpatunder :: ([AttrName]->Patterns) -- "Transform.ag"(line 982, column 10) _lhsOpatunder = ({-# LINE 982 "Transform.ag" #-} \us -> (_hdIpatunder us) : (_tlIpatunder us) {-# LINE 4627 "Transform.hs" #-}) -- use rule "Transform.ag"(line 967, column 42) _lhsOdefinedAttrs = ({-# LINE 967 "Transform.ag" #-} _hdIdefinedAttrs ++ _tlIdefinedAttrs {-# LINE 4632 "Transform.hs" #-}) -- use rule "Transform.ag"(line 966, column 55) _lhsOdefinedInsts = ({-# LINE 966 "Transform.ag" #-} _hdIdefinedInsts ++ _tlIdefinedInsts {-# LINE 4637 "Transform.hs" #-}) -- self rule _copy = ({-# LINE 23 "./Patterns.ag" #-} (:) _hdIcopy _tlIcopy {-# LINE 4642 "Transform.hs" #-}) -- self rule _lhsOcopy = ({-# LINE 23 "./Patterns.ag" #-} _copy {-# LINE 4647 "Transform.hs" #-}) ( _hdIcopy,_hdIdefinedAttrs,_hdIdefinedInsts,_hdIpatunder,_hdIstpos) = (hd_ ) ( _tlIcopy,_tlIdefinedAttrs,_tlIdefinedInsts,_tlIpatunder) = (tl_ ) in ( _lhsOcopy,_lhsOdefinedAttrs,_lhsOdefinedInsts,_lhsOpatunder)) ) sem_Patterns_Nil :: T_Patterns sem_Patterns_Nil = (T_Patterns (let _lhsOpatunder :: ([AttrName]->Patterns) _lhsOdefinedAttrs :: ([AttrName]) _lhsOdefinedInsts :: ([Identifier]) _lhsOcopy :: Patterns -- "Transform.ag"(line 981, column 9) _lhsOpatunder = ({-# LINE 981 "Transform.ag" #-} \us -> [] {-# LINE 4663 "Transform.hs" #-}) -- use rule "Transform.ag"(line 967, column 42) _lhsOdefinedAttrs = ({-# LINE 967 "Transform.ag" #-} [] {-# LINE 4668 "Transform.hs" #-}) -- use rule "Transform.ag"(line 966, column 55) _lhsOdefinedInsts = ({-# LINE 966 "Transform.ag" #-} [] {-# LINE 4673 "Transform.hs" #-}) -- self rule _copy = ({-# LINE 23 "./Patterns.ag" #-} [] {-# LINE 4678 "Transform.hs" #-}) -- self rule _lhsOcopy = ({-# LINE 23 "./Patterns.ag" #-} _copy {-# LINE 4683 "Transform.hs" #-}) in ( _lhsOcopy,_lhsOdefinedAttrs,_lhsOdefinedInsts,_lhsOpatunder)) ) -- SemAlt ------------------------------------------------------ {- visit 0: inherited attributes: allAttrDecls : Map NontermIdent (Attributes, Attributes) allFields : DataTypes nts : Set NontermIdent synthesized attributes: attrOrderCollect : AttrOrderMap collectedArounds : [ (NontermIdent, ConstructorIdent, [AroundInfo]) ] collectedAugments : [ (NontermIdent, ConstructorIdent, [AugmentInfo]) ] collectedInsts : [ (NontermIdent, ConstructorIdent, [Identifier]) ] collectedRules : [ (NontermIdent, ConstructorIdent, RuleInfo)] collectedSigs : [ (NontermIdent, ConstructorIdent, SigInfo) ] collectedUniques : [ (NontermIdent, ConstructorIdent, [UniqueInfo]) ] errors : Seq Error semPragmasCollect : PragmaMap alternatives: alternative SemAlt: child pos : {Pos} child constructorSet : ConstructorSet child rules : SemDefs visit 0: local pragmaNames : _ local attrOrders : _ local coninfo : _ -} -- cata sem_SemAlt :: SemAlt -> T_SemAlt sem_SemAlt (SemAlt _pos _constructorSet _rules ) = (sem_SemAlt_SemAlt _pos (sem_ConstructorSet _constructorSet ) (sem_SemDefs _rules ) ) -- semantic domain newtype T_SemAlt = T_SemAlt ((Map NontermIdent (Attributes, Attributes)) -> DataTypes -> (Set NontermIdent) -> ( AttrOrderMap,([ (NontermIdent, ConstructorIdent, [AroundInfo]) ]),([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ]),([ (NontermIdent, ConstructorIdent, [Identifier]) ]),([ (NontermIdent, ConstructorIdent, RuleInfo)]),([ (NontermIdent, ConstructorIdent, SigInfo) ]),([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ]),(Seq Error),PragmaMap)) data Inh_SemAlt = Inh_SemAlt {allAttrDecls_Inh_SemAlt :: !((Map NontermIdent (Attributes, Attributes))),allFields_Inh_SemAlt :: !(DataTypes),nts_Inh_SemAlt :: !((Set NontermIdent))} data Syn_SemAlt = Syn_SemAlt {attrOrderCollect_Syn_SemAlt :: !(AttrOrderMap),collectedArounds_Syn_SemAlt :: !(([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])),collectedAugments_Syn_SemAlt :: !(([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])),collectedInsts_Syn_SemAlt :: !(([ (NontermIdent, ConstructorIdent, [Identifier]) ])),collectedRules_Syn_SemAlt :: !(([ (NontermIdent, ConstructorIdent, RuleInfo)])),collectedSigs_Syn_SemAlt :: !(([ (NontermIdent, ConstructorIdent, SigInfo) ])),collectedUniques_Syn_SemAlt :: !(([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])),errors_Syn_SemAlt :: !((Seq Error)),semPragmasCollect_Syn_SemAlt :: !(PragmaMap)} wrap_SemAlt :: T_SemAlt -> Inh_SemAlt -> Syn_SemAlt wrap_SemAlt (T_SemAlt sem ) (Inh_SemAlt _lhsIallAttrDecls _lhsIallFields _lhsInts ) = (let ( _lhsOattrOrderCollect,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedInsts,_lhsOcollectedRules,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOerrors,_lhsOsemPragmasCollect) = (sem _lhsIallAttrDecls _lhsIallFields _lhsInts ) in (Syn_SemAlt _lhsOattrOrderCollect _lhsOcollectedArounds _lhsOcollectedAugments _lhsOcollectedInsts _lhsOcollectedRules _lhsOcollectedSigs _lhsOcollectedUniques _lhsOerrors _lhsOsemPragmasCollect )) sem_SemAlt_SemAlt :: Pos -> T_ConstructorSet -> T_SemDefs -> T_SemAlt sem_SemAlt_SemAlt pos_ (T_ConstructorSet constructorSet_ ) (T_SemDefs rules_ ) = (T_SemAlt (\ _lhsIallAttrDecls _lhsIallFields _lhsInts -> (let _lhsOsemPragmasCollect :: PragmaMap _lhsOattrOrderCollect :: AttrOrderMap _lhsOerrors :: (Seq Error) _lhsOcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)]) _lhsOcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ]) _lhsOcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ]) _lhsOcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ]) _lhsOcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ]) _lhsOcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ]) _constructorSetIcollectedConstructorNames :: (Set ConstructorIdent) _constructorSetIconstructors :: ((Set ConstructorIdent->Set ConstructorIdent)) _constructorSetIerrors :: (Seq Error) _rulesIaroundInfos :: ([AroundInfo]) _rulesIaugmentInfos :: ([AugmentInfo]) _rulesIdefinedInsts :: ([Identifier]) _rulesIorderDepsCollect :: (Set Dependency) _rulesIpragmaNamesCollect :: ([Identifier]) _rulesIruleInfos :: ([RuleInfo]) _rulesIsigInfos :: ([SigInfo]) _rulesIuniqueInfos :: ([UniqueInfo]) -- "Transform.ag"(line 721, column 7) _pragmaNames = ({-# LINE 721 "Transform.ag" #-} Set.fromList _rulesIpragmaNamesCollect {-# LINE 4763 "Transform.hs" #-}) -- "Transform.ag"(line 722, column 7) _lhsOsemPragmasCollect = ({-# LINE 722 "Transform.ag" #-} foldr pragmaMapUnion Map.empty [ pragmaMapSingle nt con _pragmaNames | (nt, conset, _) <- _coninfo , con <- Set.toList conset ] {-# LINE 4771 "Transform.hs" #-}) -- "Transform.ag"(line 750, column 7) _attrOrders = ({-# LINE 750 "Transform.ag" #-} [ orderMapSingle nt con _rulesIorderDepsCollect | (nt, conset, _) <- _coninfo , con <- Set.toList conset ] {-# LINE 4779 "Transform.hs" #-}) -- "Transform.ag"(line 756, column 7) _lhsOattrOrderCollect = ({-# LINE 756 "Transform.ag" #-} foldr orderMapUnion Map.empty _attrOrders {-# LINE 4784 "Transform.hs" #-}) -- "Transform.ag"(line 901, column 12) _coninfo = ({-# LINE 901 "Transform.ag" #-} [ (nt, conset, conkeys) | nt <- Set.toList _lhsInts , let conmap = Map.findWithDefault Map.empty nt _lhsIallFields , let conkeys = Set.fromList (Map.keys conmap) , let conset = _constructorSetIconstructors conkeys ] {-# LINE 4794 "Transform.hs" #-}) -- "Transform.ag"(line 908, column 12) _lhsOerrors = ({-# LINE 908 "Transform.ag" #-} Seq.fromList [ UndefAlt nt con | (nt, conset, conkeys) <- _coninfo , con <- Set.toList (Set.difference conset conkeys) ] {-# LINE 4803 "Transform.hs" #-}) -- "Transform.ag"(line 913, column 12) _lhsOcollectedRules = ({-# LINE 913 "Transform.ag" #-} [ (nt,con,r) | (nt, conset, _) <- _coninfo , con <- Set.toList conset , r <- _rulesIruleInfos ] {-# LINE 4812 "Transform.hs" #-}) -- "Transform.ag"(line 919, column 12) _lhsOcollectedSigs = ({-# LINE 919 "Transform.ag" #-} [ (nt,con,ts) | (nt, conset, _) <- _coninfo , con <- Set.toList conset , ts <- _rulesIsigInfos ] {-# LINE 4821 "Transform.hs" #-}) -- "Transform.ag"(line 926, column 12) _lhsOcollectedInsts = ({-# LINE 926 "Transform.ag" #-} [ (nt,con,_rulesIdefinedInsts) | (nt, conset, _) <- _coninfo , con <- Set.toList conset ] {-# LINE 4829 "Transform.hs" #-}) -- "Transform.ag"(line 932, column 12) _lhsOcollectedUniques = ({-# LINE 932 "Transform.ag" #-} [ (nt,con,_rulesIuniqueInfos) | (nt, conset, _) <- _coninfo , con <- Set.toList conset ] {-# LINE 4837 "Transform.hs" #-}) -- "Transform.ag"(line 938, column 12) _lhsOcollectedAugments = ({-# LINE 938 "Transform.ag" #-} [ (nt, con, _rulesIaugmentInfos) | (nt, conset, _) <- _coninfo , con <- Set.toList conset ] {-# LINE 4845 "Transform.hs" #-}) -- "Transform.ag"(line 944, column 12) _lhsOcollectedArounds = ({-# LINE 944 "Transform.ag" #-} [ (nt, con, _rulesIaroundInfos) | (nt, conset, _) <- _coninfo , con <- Set.toList conset ] {-# LINE 4853 "Transform.hs" #-}) ( _constructorSetIcollectedConstructorNames,_constructorSetIconstructors,_constructorSetIerrors) = (constructorSet_ ) ( _rulesIaroundInfos,_rulesIaugmentInfos,_rulesIdefinedInsts,_rulesIorderDepsCollect,_rulesIpragmaNamesCollect,_rulesIruleInfos,_rulesIsigInfos,_rulesIuniqueInfos) = (rules_ ) in ( _lhsOattrOrderCollect,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedInsts,_lhsOcollectedRules,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOerrors,_lhsOsemPragmasCollect))) ) -- SemAlts ----------------------------------------------------- {- visit 0: inherited attributes: allAttrDecls : Map NontermIdent (Attributes, Attributes) allFields : DataTypes nts : Set NontermIdent synthesized attributes: attrOrderCollect : AttrOrderMap collectedArounds : [ (NontermIdent, ConstructorIdent, [AroundInfo]) ] collectedAugments : [ (NontermIdent, ConstructorIdent, [AugmentInfo]) ] collectedInsts : [ (NontermIdent, ConstructorIdent, [Identifier]) ] collectedRules : [ (NontermIdent, ConstructorIdent, RuleInfo)] collectedSigs : [ (NontermIdent, ConstructorIdent, SigInfo) ] collectedUniques : [ (NontermIdent, ConstructorIdent, [UniqueInfo]) ] errors : Seq Error semPragmasCollect : PragmaMap alternatives: alternative Cons: child hd : SemAlt child tl : SemAlts alternative Nil: -} -- cata sem_SemAlts :: SemAlts -> T_SemAlts sem_SemAlts list = (Prelude.foldr sem_SemAlts_Cons sem_SemAlts_Nil (Prelude.map sem_SemAlt list) ) -- semantic domain newtype T_SemAlts = T_SemAlts ((Map NontermIdent (Attributes, Attributes)) -> DataTypes -> (Set NontermIdent) -> ( AttrOrderMap,([ (NontermIdent, ConstructorIdent, [AroundInfo]) ]),([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ]),([ (NontermIdent, ConstructorIdent, [Identifier]) ]),([ (NontermIdent, ConstructorIdent, RuleInfo)]),([ (NontermIdent, ConstructorIdent, SigInfo) ]),([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ]),(Seq Error),PragmaMap)) data Inh_SemAlts = Inh_SemAlts {allAttrDecls_Inh_SemAlts :: !((Map NontermIdent (Attributes, Attributes))),allFields_Inh_SemAlts :: !(DataTypes),nts_Inh_SemAlts :: !((Set NontermIdent))} data Syn_SemAlts = Syn_SemAlts {attrOrderCollect_Syn_SemAlts :: !(AttrOrderMap),collectedArounds_Syn_SemAlts :: !(([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])),collectedAugments_Syn_SemAlts :: !(([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])),collectedInsts_Syn_SemAlts :: !(([ (NontermIdent, ConstructorIdent, [Identifier]) ])),collectedRules_Syn_SemAlts :: !(([ (NontermIdent, ConstructorIdent, RuleInfo)])),collectedSigs_Syn_SemAlts :: !(([ (NontermIdent, ConstructorIdent, SigInfo) ])),collectedUniques_Syn_SemAlts :: !(([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])),errors_Syn_SemAlts :: !((Seq Error)),semPragmasCollect_Syn_SemAlts :: !(PragmaMap)} wrap_SemAlts :: T_SemAlts -> Inh_SemAlts -> Syn_SemAlts wrap_SemAlts (T_SemAlts sem ) (Inh_SemAlts _lhsIallAttrDecls _lhsIallFields _lhsInts ) = (let ( _lhsOattrOrderCollect,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedInsts,_lhsOcollectedRules,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOerrors,_lhsOsemPragmasCollect) = (sem _lhsIallAttrDecls _lhsIallFields _lhsInts ) in (Syn_SemAlts _lhsOattrOrderCollect _lhsOcollectedArounds _lhsOcollectedAugments _lhsOcollectedInsts _lhsOcollectedRules _lhsOcollectedSigs _lhsOcollectedUniques _lhsOerrors _lhsOsemPragmasCollect )) sem_SemAlts_Cons :: T_SemAlt -> T_SemAlts -> T_SemAlts sem_SemAlts_Cons (T_SemAlt hd_ ) (T_SemAlts tl_ ) = (T_SemAlts (\ _lhsIallAttrDecls _lhsIallFields _lhsInts -> (let _lhsOattrOrderCollect :: AttrOrderMap _lhsOcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ]) _lhsOcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ]) _lhsOcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ]) _lhsOcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)]) _lhsOcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ]) _lhsOcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ]) _lhsOerrors :: (Seq Error) _lhsOsemPragmasCollect :: PragmaMap _hdOallAttrDecls :: (Map NontermIdent (Attributes, Attributes)) _hdOallFields :: DataTypes _hdOnts :: (Set NontermIdent) _tlOallAttrDecls :: (Map NontermIdent (Attributes, Attributes)) _tlOallFields :: DataTypes _tlOnts :: (Set NontermIdent) _hdIattrOrderCollect :: AttrOrderMap _hdIcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ]) _hdIcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ]) _hdIcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ]) _hdIcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)]) _hdIcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ]) _hdIcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ]) _hdIerrors :: (Seq Error) _hdIsemPragmasCollect :: PragmaMap _tlIattrOrderCollect :: AttrOrderMap _tlIcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ]) _tlIcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ]) _tlIcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ]) _tlIcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)]) _tlIcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ]) _tlIcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ]) _tlIerrors :: (Seq Error) _tlIsemPragmasCollect :: PragmaMap -- use rule "Transform.ag"(line 745, column 55) _lhsOattrOrderCollect = ({-# LINE 745 "Transform.ag" #-} _hdIattrOrderCollect `orderMapUnion` _tlIattrOrderCollect {-# LINE 4945 "Transform.hs" #-}) -- use rule "Transform.ag"(line 153, column 32) _lhsOcollectedArounds = ({-# LINE 153 "Transform.ag" #-} _hdIcollectedArounds ++ _tlIcollectedArounds {-# LINE 4950 "Transform.hs" #-}) -- use rule "Transform.ag"(line 152, column 32) _lhsOcollectedAugments = ({-# LINE 152 "Transform.ag" #-} _hdIcollectedAugments ++ _tlIcollectedAugments {-# LINE 4955 "Transform.hs" #-}) -- use rule "Transform.ag"(line 150, column 32) _lhsOcollectedInsts = ({-# LINE 150 "Transform.ag" #-} _hdIcollectedInsts ++ _tlIcollectedInsts {-# LINE 4960 "Transform.hs" #-}) -- use rule "Transform.ag"(line 148, column 32) _lhsOcollectedRules = ({-# LINE 148 "Transform.ag" #-} _hdIcollectedRules ++ _tlIcollectedRules {-# LINE 4965 "Transform.hs" #-}) -- use rule "Transform.ag"(line 149, column 32) _lhsOcollectedSigs = ({-# LINE 149 "Transform.ag" #-} _hdIcollectedSigs ++ _tlIcollectedSigs {-# LINE 4970 "Transform.hs" #-}) -- use rule "Transform.ag"(line 151, column 32) _lhsOcollectedUniques = ({-# LINE 151 "Transform.ag" #-} _hdIcollectedUniques ++ _tlIcollectedUniques {-# LINE 4975 "Transform.hs" #-}) -- use rule "Transform.ag"(line 42, column 19) _lhsOerrors = ({-# LINE 42 "Transform.ag" #-} _hdIerrors Seq.>< _tlIerrors {-# LINE 4980 "Transform.hs" #-}) -- use rule "Transform.ag"(line 717, column 56) _lhsOsemPragmasCollect = ({-# LINE 717 "Transform.ag" #-} _hdIsemPragmasCollect `pragmaMapUnion` _tlIsemPragmasCollect {-# LINE 4985 "Transform.hs" #-}) -- copy rule (down) _hdOallAttrDecls = ({-# LINE 746 "Transform.ag" #-} _lhsIallAttrDecls {-# LINE 4990 "Transform.hs" #-}) -- copy rule (down) _hdOallFields = ({-# LINE 126 "Transform.ag" #-} _lhsIallFields {-# LINE 4995 "Transform.hs" #-}) -- copy rule (down) _hdOnts = ({-# LINE 163 "Transform.ag" #-} _lhsInts {-# LINE 5000 "Transform.hs" #-}) -- copy rule (down) _tlOallAttrDecls = ({-# LINE 746 "Transform.ag" #-} _lhsIallAttrDecls {-# LINE 5005 "Transform.hs" #-}) -- copy rule (down) _tlOallFields = ({-# LINE 126 "Transform.ag" #-} _lhsIallFields {-# LINE 5010 "Transform.hs" #-}) -- copy rule (down) _tlOnts = ({-# LINE 163 "Transform.ag" #-} _lhsInts {-# LINE 5015 "Transform.hs" #-}) ( _hdIattrOrderCollect,_hdIcollectedArounds,_hdIcollectedAugments,_hdIcollectedInsts,_hdIcollectedRules,_hdIcollectedSigs,_hdIcollectedUniques,_hdIerrors,_hdIsemPragmasCollect) = (hd_ _hdOallAttrDecls _hdOallFields _hdOnts ) ( _tlIattrOrderCollect,_tlIcollectedArounds,_tlIcollectedAugments,_tlIcollectedInsts,_tlIcollectedRules,_tlIcollectedSigs,_tlIcollectedUniques,_tlIerrors,_tlIsemPragmasCollect) = (tl_ _tlOallAttrDecls _tlOallFields _tlOnts ) in ( _lhsOattrOrderCollect,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedInsts,_lhsOcollectedRules,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOerrors,_lhsOsemPragmasCollect))) ) sem_SemAlts_Nil :: T_SemAlts sem_SemAlts_Nil = (T_SemAlts (\ _lhsIallAttrDecls _lhsIallFields _lhsInts -> (let _lhsOattrOrderCollect :: AttrOrderMap _lhsOcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ]) _lhsOcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ]) _lhsOcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ]) _lhsOcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)]) _lhsOcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ]) _lhsOcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ]) _lhsOerrors :: (Seq Error) _lhsOsemPragmasCollect :: PragmaMap -- use rule "Transform.ag"(line 745, column 55) _lhsOattrOrderCollect = ({-# LINE 745 "Transform.ag" #-} Map.empty {-# LINE 5039 "Transform.hs" #-}) -- use rule "Transform.ag"(line 153, column 32) _lhsOcollectedArounds = ({-# LINE 153 "Transform.ag" #-} [] {-# LINE 5044 "Transform.hs" #-}) -- use rule "Transform.ag"(line 152, column 32) _lhsOcollectedAugments = ({-# LINE 152 "Transform.ag" #-} [] {-# LINE 5049 "Transform.hs" #-}) -- use rule "Transform.ag"(line 150, column 32) _lhsOcollectedInsts = ({-# LINE 150 "Transform.ag" #-} [] {-# LINE 5054 "Transform.hs" #-}) -- use rule "Transform.ag"(line 148, column 32) _lhsOcollectedRules = ({-# LINE 148 "Transform.ag" #-} [] {-# LINE 5059 "Transform.hs" #-}) -- use rule "Transform.ag"(line 149, column 32) _lhsOcollectedSigs = ({-# LINE 149 "Transform.ag" #-} [] {-# LINE 5064 "Transform.hs" #-}) -- use rule "Transform.ag"(line 151, column 32) _lhsOcollectedUniques = ({-# LINE 151 "Transform.ag" #-} [] {-# LINE 5069 "Transform.hs" #-}) -- use rule "Transform.ag"(line 42, column 19) _lhsOerrors = ({-# LINE 42 "Transform.ag" #-} Seq.empty {-# LINE 5074 "Transform.hs" #-}) -- use rule "Transform.ag"(line 717, column 56) _lhsOsemPragmasCollect = ({-# LINE 717 "Transform.ag" #-} Map.empty {-# LINE 5079 "Transform.hs" #-}) in ( _lhsOattrOrderCollect,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedInsts,_lhsOcollectedRules,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOerrors,_lhsOsemPragmasCollect))) ) -- SemDef ------------------------------------------------------ {- visit 0: synthesized attributes: aroundInfos : [AroundInfo] augmentInfos : [AugmentInfo] definedInsts : [Identifier] orderDepsCollect : Set Dependency pragmaNamesCollect : [Identifier] ruleInfos : [RuleInfo] sigInfos : [SigInfo] uniqueInfos : [UniqueInfo] alternatives: alternative AroundDef: child ident : {Identifier} child rhs : {Expression} alternative AttrOrderBefore: child before : {[Occurrence]} child after : {[Occurrence]} visit 0: local dependency : _ alternative AugmentDef: child ident : {Identifier} child rhs : {Expression} alternative Def: child pos : {Pos} child mbName : {Maybe Identifier} child pattern : Pattern child rhs : {Expression} child owrt : {Bool} alternative SemPragma: child names : {[NontermIdent]} alternative TypeDef: child ident : {Identifier} child tp : {Type} alternative UniqueDef: child ident : {Identifier} child ref : {Identifier} -} -- cata sem_SemDef :: SemDef -> T_SemDef sem_SemDef (AroundDef _ident _rhs ) = (sem_SemDef_AroundDef _ident _rhs ) sem_SemDef (AttrOrderBefore _before _after ) = (sem_SemDef_AttrOrderBefore _before _after ) sem_SemDef (AugmentDef _ident _rhs ) = (sem_SemDef_AugmentDef _ident _rhs ) sem_SemDef (Def _pos _mbName _pattern _rhs _owrt ) = (sem_SemDef_Def _pos _mbName (sem_Pattern _pattern ) _rhs _owrt ) sem_SemDef (SemPragma _names ) = (sem_SemDef_SemPragma _names ) sem_SemDef (TypeDef _ident _tp ) = (sem_SemDef_TypeDef _ident _tp ) sem_SemDef (UniqueDef _ident _ref ) = (sem_SemDef_UniqueDef _ident _ref ) -- semantic domain newtype T_SemDef = T_SemDef (( ([AroundInfo]),([AugmentInfo]),([Identifier]),(Set Dependency),([Identifier]),([RuleInfo]),([SigInfo]),([UniqueInfo]))) data Inh_SemDef = Inh_SemDef {} data Syn_SemDef = Syn_SemDef {aroundInfos_Syn_SemDef :: !(([AroundInfo])),augmentInfos_Syn_SemDef :: !(([AugmentInfo])),definedInsts_Syn_SemDef :: !(([Identifier])),orderDepsCollect_Syn_SemDef :: !((Set Dependency)),pragmaNamesCollect_Syn_SemDef :: !(([Identifier])),ruleInfos_Syn_SemDef :: !(([RuleInfo])),sigInfos_Syn_SemDef :: !(([SigInfo])),uniqueInfos_Syn_SemDef :: !(([UniqueInfo]))} wrap_SemDef :: T_SemDef -> Inh_SemDef -> Syn_SemDef wrap_SemDef (T_SemDef sem ) (Inh_SemDef ) = (let ( _lhsOaroundInfos,_lhsOaugmentInfos,_lhsOdefinedInsts,_lhsOorderDepsCollect,_lhsOpragmaNamesCollect,_lhsOruleInfos,_lhsOsigInfos,_lhsOuniqueInfos) = (sem ) in (Syn_SemDef _lhsOaroundInfos _lhsOaugmentInfos _lhsOdefinedInsts _lhsOorderDepsCollect _lhsOpragmaNamesCollect _lhsOruleInfos _lhsOsigInfos _lhsOuniqueInfos )) sem_SemDef_AroundDef :: Identifier -> Expression -> T_SemDef sem_SemDef_AroundDef ident_ rhs_ = (T_SemDef (let _lhsOaroundInfos :: ([AroundInfo]) _lhsOaugmentInfos :: ([AugmentInfo]) _lhsOdefinedInsts :: ([Identifier]) _lhsOorderDepsCollect :: (Set Dependency) _lhsOpragmaNamesCollect :: ([Identifier]) _lhsOruleInfos :: ([RuleInfo]) _lhsOsigInfos :: ([SigInfo]) _lhsOuniqueInfos :: ([UniqueInfo]) -- "Transform.ag"(line 963, column 17) _lhsOaroundInfos = ({-# LINE 963 "Transform.ag" #-} [ (ident_, rhs_) ] {-# LINE 5164 "Transform.hs" #-}) -- use rule "Transform.ag"(line 895, column 40) _lhsOaugmentInfos = ({-# LINE 895 "Transform.ag" #-} [] {-# LINE 5169 "Transform.hs" #-}) -- use rule "Transform.ag"(line 966, column 55) _lhsOdefinedInsts = ({-# LINE 966 "Transform.ag" #-} [] {-# LINE 5174 "Transform.hs" #-}) -- use rule "Transform.ag"(line 758, column 44) _lhsOorderDepsCollect = ({-# LINE 758 "Transform.ag" #-} Set.empty {-# LINE 5179 "Transform.hs" #-}) -- use rule "Transform.ag"(line 727, column 46) _lhsOpragmaNamesCollect = ({-# LINE 727 "Transform.ag" #-} [] {-# LINE 5184 "Transform.hs" #-}) -- use rule "Transform.ag"(line 892, column 40) _lhsOruleInfos = ({-# LINE 892 "Transform.ag" #-} [] {-# LINE 5189 "Transform.hs" #-}) -- use rule "Transform.ag"(line 893, column 40) _lhsOsigInfos = ({-# LINE 893 "Transform.ag" #-} [] {-# LINE 5194 "Transform.hs" #-}) -- use rule "Transform.ag"(line 894, column 40) _lhsOuniqueInfos = ({-# LINE 894 "Transform.ag" #-} [] {-# LINE 5199 "Transform.hs" #-}) in ( _lhsOaroundInfos,_lhsOaugmentInfos,_lhsOdefinedInsts,_lhsOorderDepsCollect,_lhsOpragmaNamesCollect,_lhsOruleInfos,_lhsOsigInfos,_lhsOuniqueInfos)) ) sem_SemDef_AttrOrderBefore :: ([Occurrence]) -> ([Occurrence]) -> T_SemDef sem_SemDef_AttrOrderBefore before_ after_ = (T_SemDef (let _lhsOorderDepsCollect :: (Set Dependency) _lhsOaroundInfos :: ([AroundInfo]) _lhsOaugmentInfos :: ([AugmentInfo]) _lhsOdefinedInsts :: ([Identifier]) _lhsOpragmaNamesCollect :: ([Identifier]) _lhsOruleInfos :: ([RuleInfo]) _lhsOsigInfos :: ([SigInfo]) _lhsOuniqueInfos :: ([UniqueInfo]) -- "Transform.ag"(line 762, column 7) _dependency = ({-# LINE 762 "Transform.ag" #-} [ Dependency b a | b <- before_, a <- after_ ] {-# LINE 5217 "Transform.hs" #-}) -- "Transform.ag"(line 763, column 7) _lhsOorderDepsCollect = ({-# LINE 763 "Transform.ag" #-} Set.fromList _dependency {-# LINE 5222 "Transform.hs" #-}) -- use rule "Transform.ag"(line 896, column 40) _lhsOaroundInfos = ({-# LINE 896 "Transform.ag" #-} [] {-# LINE 5227 "Transform.hs" #-}) -- use rule "Transform.ag"(line 895, column 40) _lhsOaugmentInfos = ({-# LINE 895 "Transform.ag" #-} [] {-# LINE 5232 "Transform.hs" #-}) -- use rule "Transform.ag"(line 966, column 55) _lhsOdefinedInsts = ({-# LINE 966 "Transform.ag" #-} [] {-# LINE 5237 "Transform.hs" #-}) -- use rule "Transform.ag"(line 727, column 46) _lhsOpragmaNamesCollect = ({-# LINE 727 "Transform.ag" #-} [] {-# LINE 5242 "Transform.hs" #-}) -- use rule "Transform.ag"(line 892, column 40) _lhsOruleInfos = ({-# LINE 892 "Transform.ag" #-} [] {-# LINE 5247 "Transform.hs" #-}) -- use rule "Transform.ag"(line 893, column 40) _lhsOsigInfos = ({-# LINE 893 "Transform.ag" #-} [] {-# LINE 5252 "Transform.hs" #-}) -- use rule "Transform.ag"(line 894, column 40) _lhsOuniqueInfos = ({-# LINE 894 "Transform.ag" #-} [] {-# LINE 5257 "Transform.hs" #-}) in ( _lhsOaroundInfos,_lhsOaugmentInfos,_lhsOdefinedInsts,_lhsOorderDepsCollect,_lhsOpragmaNamesCollect,_lhsOruleInfos,_lhsOsigInfos,_lhsOuniqueInfos)) ) sem_SemDef_AugmentDef :: Identifier -> Expression -> T_SemDef sem_SemDef_AugmentDef ident_ rhs_ = (T_SemDef (let _lhsOaugmentInfos :: ([AugmentInfo]) _lhsOaroundInfos :: ([AroundInfo]) _lhsOdefinedInsts :: ([Identifier]) _lhsOorderDepsCollect :: (Set Dependency) _lhsOpragmaNamesCollect :: ([Identifier]) _lhsOruleInfos :: ([RuleInfo]) _lhsOsigInfos :: ([SigInfo]) _lhsOuniqueInfos :: ([UniqueInfo]) -- "Transform.ag"(line 960, column 17) _lhsOaugmentInfos = ({-# LINE 960 "Transform.ag" #-} [ (ident_, rhs_) ] {-# LINE 5275 "Transform.hs" #-}) -- use rule "Transform.ag"(line 896, column 40) _lhsOaroundInfos = ({-# LINE 896 "Transform.ag" #-} [] {-# LINE 5280 "Transform.hs" #-}) -- use rule "Transform.ag"(line 966, column 55) _lhsOdefinedInsts = ({-# LINE 966 "Transform.ag" #-} [] {-# LINE 5285 "Transform.hs" #-}) -- use rule "Transform.ag"(line 758, column 44) _lhsOorderDepsCollect = ({-# LINE 758 "Transform.ag" #-} Set.empty {-# LINE 5290 "Transform.hs" #-}) -- use rule "Transform.ag"(line 727, column 46) _lhsOpragmaNamesCollect = ({-# LINE 727 "Transform.ag" #-} [] {-# LINE 5295 "Transform.hs" #-}) -- use rule "Transform.ag"(line 892, column 40) _lhsOruleInfos = ({-# LINE 892 "Transform.ag" #-} [] {-# LINE 5300 "Transform.hs" #-}) -- use rule "Transform.ag"(line 893, column 40) _lhsOsigInfos = ({-# LINE 893 "Transform.ag" #-} [] {-# LINE 5305 "Transform.hs" #-}) -- use rule "Transform.ag"(line 894, column 40) _lhsOuniqueInfos = ({-# LINE 894 "Transform.ag" #-} [] {-# LINE 5310 "Transform.hs" #-}) in ( _lhsOaroundInfos,_lhsOaugmentInfos,_lhsOdefinedInsts,_lhsOorderDepsCollect,_lhsOpragmaNamesCollect,_lhsOruleInfos,_lhsOsigInfos,_lhsOuniqueInfos)) ) sem_SemDef_Def :: Pos -> (Maybe Identifier) -> T_Pattern -> Expression -> Bool -> T_SemDef sem_SemDef_Def pos_ mbName_ (T_Pattern pattern_ ) rhs_ owrt_ = (T_SemDef (let _lhsOruleInfos :: ([RuleInfo]) _lhsOaroundInfos :: ([AroundInfo]) _lhsOaugmentInfos :: ([AugmentInfo]) _lhsOdefinedInsts :: ([Identifier]) _lhsOorderDepsCollect :: (Set Dependency) _lhsOpragmaNamesCollect :: ([Identifier]) _lhsOsigInfos :: ([SigInfo]) _lhsOuniqueInfos :: ([UniqueInfo]) _patternIcopy :: Pattern _patternIdefinedAttrs :: ([AttrName]) _patternIdefinedInsts :: ([Identifier]) _patternIpatunder :: ([AttrName]->Pattern) _patternIstpos :: Pos -- "Transform.ag"(line 951, column 10) _lhsOruleInfos = ({-# LINE 951 "Transform.ag" #-} [ (mbName_, _patternIpatunder, rhs_, _patternIdefinedAttrs, owrt_, show _patternIstpos) ] {-# LINE 5336 "Transform.hs" #-}) -- use rule "Transform.ag"(line 896, column 40) _lhsOaroundInfos = ({-# LINE 896 "Transform.ag" #-} [] {-# LINE 5341 "Transform.hs" #-}) -- use rule "Transform.ag"(line 895, column 40) _lhsOaugmentInfos = ({-# LINE 895 "Transform.ag" #-} [] {-# LINE 5346 "Transform.hs" #-}) -- use rule "Transform.ag"(line 966, column 55) _lhsOdefinedInsts = ({-# LINE 966 "Transform.ag" #-} _patternIdefinedInsts {-# LINE 5351 "Transform.hs" #-}) -- use rule "Transform.ag"(line 758, column 44) _lhsOorderDepsCollect = ({-# LINE 758 "Transform.ag" #-} Set.empty {-# LINE 5356 "Transform.hs" #-}) -- use rule "Transform.ag"(line 727, column 46) _lhsOpragmaNamesCollect = ({-# LINE 727 "Transform.ag" #-} [] {-# LINE 5361 "Transform.hs" #-}) -- use rule "Transform.ag"(line 893, column 40) _lhsOsigInfos = ({-# LINE 893 "Transform.ag" #-} [] {-# LINE 5366 "Transform.hs" #-}) -- use rule "Transform.ag"(line 894, column 40) _lhsOuniqueInfos = ({-# LINE 894 "Transform.ag" #-} [] {-# LINE 5371 "Transform.hs" #-}) ( _patternIcopy,_patternIdefinedAttrs,_patternIdefinedInsts,_patternIpatunder,_patternIstpos) = (pattern_ ) in ( _lhsOaroundInfos,_lhsOaugmentInfos,_lhsOdefinedInsts,_lhsOorderDepsCollect,_lhsOpragmaNamesCollect,_lhsOruleInfos,_lhsOsigInfos,_lhsOuniqueInfos)) ) sem_SemDef_SemPragma :: ([NontermIdent]) -> T_SemDef sem_SemDef_SemPragma names_ = (T_SemDef (let _lhsOpragmaNamesCollect :: ([Identifier]) _lhsOaroundInfos :: ([AroundInfo]) _lhsOaugmentInfos :: ([AugmentInfo]) _lhsOdefinedInsts :: ([Identifier]) _lhsOorderDepsCollect :: (Set Dependency) _lhsOruleInfos :: ([RuleInfo]) _lhsOsigInfos :: ([SigInfo]) _lhsOuniqueInfos :: ([UniqueInfo]) -- "Transform.ag"(line 731, column 7) _lhsOpragmaNamesCollect = ({-# LINE 731 "Transform.ag" #-} names_ {-# LINE 5390 "Transform.hs" #-}) -- use rule "Transform.ag"(line 896, column 40) _lhsOaroundInfos = ({-# LINE 896 "Transform.ag" #-} [] {-# LINE 5395 "Transform.hs" #-}) -- use rule "Transform.ag"(line 895, column 40) _lhsOaugmentInfos = ({-# LINE 895 "Transform.ag" #-} [] {-# LINE 5400 "Transform.hs" #-}) -- use rule "Transform.ag"(line 966, column 55) _lhsOdefinedInsts = ({-# LINE 966 "Transform.ag" #-} [] {-# LINE 5405 "Transform.hs" #-}) -- use rule "Transform.ag"(line 758, column 44) _lhsOorderDepsCollect = ({-# LINE 758 "Transform.ag" #-} Set.empty {-# LINE 5410 "Transform.hs" #-}) -- use rule "Transform.ag"(line 892, column 40) _lhsOruleInfos = ({-# LINE 892 "Transform.ag" #-} [] {-# LINE 5415 "Transform.hs" #-}) -- use rule "Transform.ag"(line 893, column 40) _lhsOsigInfos = ({-# LINE 893 "Transform.ag" #-} [] {-# LINE 5420 "Transform.hs" #-}) -- use rule "Transform.ag"(line 894, column 40) _lhsOuniqueInfos = ({-# LINE 894 "Transform.ag" #-} [] {-# LINE 5425 "Transform.hs" #-}) in ( _lhsOaroundInfos,_lhsOaugmentInfos,_lhsOdefinedInsts,_lhsOorderDepsCollect,_lhsOpragmaNamesCollect,_lhsOruleInfos,_lhsOsigInfos,_lhsOuniqueInfos)) ) sem_SemDef_TypeDef :: Identifier -> Type -> T_SemDef sem_SemDef_TypeDef ident_ tp_ = (T_SemDef (let _lhsOsigInfos :: ([SigInfo]) _lhsOaroundInfos :: ([AroundInfo]) _lhsOaugmentInfos :: ([AugmentInfo]) _lhsOdefinedInsts :: ([Identifier]) _lhsOorderDepsCollect :: (Set Dependency) _lhsOpragmaNamesCollect :: ([Identifier]) _lhsOruleInfos :: ([RuleInfo]) _lhsOuniqueInfos :: ([UniqueInfo]) -- "Transform.ag"(line 954, column 14) _lhsOsigInfos = ({-# LINE 954 "Transform.ag" #-} [ (ident_, tp_) ] {-# LINE 5443 "Transform.hs" #-}) -- use rule "Transform.ag"(line 896, column 40) _lhsOaroundInfos = ({-# LINE 896 "Transform.ag" #-} [] {-# LINE 5448 "Transform.hs" #-}) -- use rule "Transform.ag"(line 895, column 40) _lhsOaugmentInfos = ({-# LINE 895 "Transform.ag" #-} [] {-# LINE 5453 "Transform.hs" #-}) -- use rule "Transform.ag"(line 966, column 55) _lhsOdefinedInsts = ({-# LINE 966 "Transform.ag" #-} [] {-# LINE 5458 "Transform.hs" #-}) -- use rule "Transform.ag"(line 758, column 44) _lhsOorderDepsCollect = ({-# LINE 758 "Transform.ag" #-} Set.empty {-# LINE 5463 "Transform.hs" #-}) -- use rule "Transform.ag"(line 727, column 46) _lhsOpragmaNamesCollect = ({-# LINE 727 "Transform.ag" #-} [] {-# LINE 5468 "Transform.hs" #-}) -- use rule "Transform.ag"(line 892, column 40) _lhsOruleInfos = ({-# LINE 892 "Transform.ag" #-} [] {-# LINE 5473 "Transform.hs" #-}) -- use rule "Transform.ag"(line 894, column 40) _lhsOuniqueInfos = ({-# LINE 894 "Transform.ag" #-} [] {-# LINE 5478 "Transform.hs" #-}) in ( _lhsOaroundInfos,_lhsOaugmentInfos,_lhsOdefinedInsts,_lhsOorderDepsCollect,_lhsOpragmaNamesCollect,_lhsOruleInfos,_lhsOsigInfos,_lhsOuniqueInfos)) ) sem_SemDef_UniqueDef :: Identifier -> Identifier -> T_SemDef sem_SemDef_UniqueDef ident_ ref_ = (T_SemDef (let _lhsOuniqueInfos :: ([UniqueInfo]) _lhsOaroundInfos :: ([AroundInfo]) _lhsOaugmentInfos :: ([AugmentInfo]) _lhsOdefinedInsts :: ([Identifier]) _lhsOorderDepsCollect :: (Set Dependency) _lhsOpragmaNamesCollect :: ([Identifier]) _lhsOruleInfos :: ([RuleInfo]) _lhsOsigInfos :: ([SigInfo]) -- "Transform.ag"(line 957, column 16) _lhsOuniqueInfos = ({-# LINE 957 "Transform.ag" #-} [ (ident_, ref_) ] {-# LINE 5496 "Transform.hs" #-}) -- use rule "Transform.ag"(line 896, column 40) _lhsOaroundInfos = ({-# LINE 896 "Transform.ag" #-} [] {-# LINE 5501 "Transform.hs" #-}) -- use rule "Transform.ag"(line 895, column 40) _lhsOaugmentInfos = ({-# LINE 895 "Transform.ag" #-} [] {-# LINE 5506 "Transform.hs" #-}) -- use rule "Transform.ag"(line 966, column 55) _lhsOdefinedInsts = ({-# LINE 966 "Transform.ag" #-} [] {-# LINE 5511 "Transform.hs" #-}) -- use rule "Transform.ag"(line 758, column 44) _lhsOorderDepsCollect = ({-# LINE 758 "Transform.ag" #-} Set.empty {-# LINE 5516 "Transform.hs" #-}) -- use rule "Transform.ag"(line 727, column 46) _lhsOpragmaNamesCollect = ({-# LINE 727 "Transform.ag" #-} [] {-# LINE 5521 "Transform.hs" #-}) -- use rule "Transform.ag"(line 892, column 40) _lhsOruleInfos = ({-# LINE 892 "Transform.ag" #-} [] {-# LINE 5526 "Transform.hs" #-}) -- use rule "Transform.ag"(line 893, column 40) _lhsOsigInfos = ({-# LINE 893 "Transform.ag" #-} [] {-# LINE 5531 "Transform.hs" #-}) in ( _lhsOaroundInfos,_lhsOaugmentInfos,_lhsOdefinedInsts,_lhsOorderDepsCollect,_lhsOpragmaNamesCollect,_lhsOruleInfos,_lhsOsigInfos,_lhsOuniqueInfos)) ) -- SemDefs ----------------------------------------------------- {- visit 0: synthesized attributes: aroundInfos : [AroundInfo] augmentInfos : [AugmentInfo] definedInsts : [Identifier] orderDepsCollect : Set Dependency pragmaNamesCollect : [Identifier] ruleInfos : [RuleInfo] sigInfos : [SigInfo] uniqueInfos : [UniqueInfo] alternatives: alternative Cons: child hd : SemDef child tl : SemDefs alternative Nil: -} -- cata sem_SemDefs :: SemDefs -> T_SemDefs sem_SemDefs list = (Prelude.foldr sem_SemDefs_Cons sem_SemDefs_Nil (Prelude.map sem_SemDef list) ) -- semantic domain newtype T_SemDefs = T_SemDefs (( ([AroundInfo]),([AugmentInfo]),([Identifier]),(Set Dependency),([Identifier]),([RuleInfo]),([SigInfo]),([UniqueInfo]))) data Inh_SemDefs = Inh_SemDefs {} data Syn_SemDefs = Syn_SemDefs {aroundInfos_Syn_SemDefs :: !(([AroundInfo])),augmentInfos_Syn_SemDefs :: !(([AugmentInfo])),definedInsts_Syn_SemDefs :: !(([Identifier])),orderDepsCollect_Syn_SemDefs :: !((Set Dependency)),pragmaNamesCollect_Syn_SemDefs :: !(([Identifier])),ruleInfos_Syn_SemDefs :: !(([RuleInfo])),sigInfos_Syn_SemDefs :: !(([SigInfo])),uniqueInfos_Syn_SemDefs :: !(([UniqueInfo]))} wrap_SemDefs :: T_SemDefs -> Inh_SemDefs -> Syn_SemDefs wrap_SemDefs (T_SemDefs sem ) (Inh_SemDefs ) = (let ( _lhsOaroundInfos,_lhsOaugmentInfos,_lhsOdefinedInsts,_lhsOorderDepsCollect,_lhsOpragmaNamesCollect,_lhsOruleInfos,_lhsOsigInfos,_lhsOuniqueInfos) = (sem ) in (Syn_SemDefs _lhsOaroundInfos _lhsOaugmentInfos _lhsOdefinedInsts _lhsOorderDepsCollect _lhsOpragmaNamesCollect _lhsOruleInfos _lhsOsigInfos _lhsOuniqueInfos )) sem_SemDefs_Cons :: T_SemDef -> T_SemDefs -> T_SemDefs sem_SemDefs_Cons (T_SemDef hd_ ) (T_SemDefs tl_ ) = (T_SemDefs (let _lhsOaroundInfos :: ([AroundInfo]) _lhsOaugmentInfos :: ([AugmentInfo]) _lhsOdefinedInsts :: ([Identifier]) _lhsOorderDepsCollect :: (Set Dependency) _lhsOpragmaNamesCollect :: ([Identifier]) _lhsOruleInfos :: ([RuleInfo]) _lhsOsigInfos :: ([SigInfo]) _lhsOuniqueInfos :: ([UniqueInfo]) _hdIaroundInfos :: ([AroundInfo]) _hdIaugmentInfos :: ([AugmentInfo]) _hdIdefinedInsts :: ([Identifier]) _hdIorderDepsCollect :: (Set Dependency) _hdIpragmaNamesCollect :: ([Identifier]) _hdIruleInfos :: ([RuleInfo]) _hdIsigInfos :: ([SigInfo]) _hdIuniqueInfos :: ([UniqueInfo]) _tlIaroundInfos :: ([AroundInfo]) _tlIaugmentInfos :: ([AugmentInfo]) _tlIdefinedInsts :: ([Identifier]) _tlIorderDepsCollect :: (Set Dependency) _tlIpragmaNamesCollect :: ([Identifier]) _tlIruleInfos :: ([RuleInfo]) _tlIsigInfos :: ([SigInfo]) _tlIuniqueInfos :: ([UniqueInfo]) -- use rule "Transform.ag"(line 896, column 40) _lhsOaroundInfos = ({-# LINE 896 "Transform.ag" #-} _hdIaroundInfos ++ _tlIaroundInfos {-# LINE 5599 "Transform.hs" #-}) -- use rule "Transform.ag"(line 895, column 40) _lhsOaugmentInfos = ({-# LINE 895 "Transform.ag" #-} _hdIaugmentInfos ++ _tlIaugmentInfos {-# LINE 5604 "Transform.hs" #-}) -- use rule "Transform.ag"(line 966, column 55) _lhsOdefinedInsts = ({-# LINE 966 "Transform.ag" #-} _hdIdefinedInsts ++ _tlIdefinedInsts {-# LINE 5609 "Transform.hs" #-}) -- use rule "Transform.ag"(line 758, column 44) _lhsOorderDepsCollect = ({-# LINE 758 "Transform.ag" #-} _hdIorderDepsCollect `Set.union` _tlIorderDepsCollect {-# LINE 5614 "Transform.hs" #-}) -- use rule "Transform.ag"(line 727, column 46) _lhsOpragmaNamesCollect = ({-# LINE 727 "Transform.ag" #-} _hdIpragmaNamesCollect ++ _tlIpragmaNamesCollect {-# LINE 5619 "Transform.hs" #-}) -- use rule "Transform.ag"(line 892, column 40) _lhsOruleInfos = ({-# LINE 892 "Transform.ag" #-} _hdIruleInfos ++ _tlIruleInfos {-# LINE 5624 "Transform.hs" #-}) -- use rule "Transform.ag"(line 893, column 40) _lhsOsigInfos = ({-# LINE 893 "Transform.ag" #-} _hdIsigInfos ++ _tlIsigInfos {-# LINE 5629 "Transform.hs" #-}) -- use rule "Transform.ag"(line 894, column 40) _lhsOuniqueInfos = ({-# LINE 894 "Transform.ag" #-} _hdIuniqueInfos ++ _tlIuniqueInfos {-# LINE 5634 "Transform.hs" #-}) ( _hdIaroundInfos,_hdIaugmentInfos,_hdIdefinedInsts,_hdIorderDepsCollect,_hdIpragmaNamesCollect,_hdIruleInfos,_hdIsigInfos,_hdIuniqueInfos) = (hd_ ) ( _tlIaroundInfos,_tlIaugmentInfos,_tlIdefinedInsts,_tlIorderDepsCollect,_tlIpragmaNamesCollect,_tlIruleInfos,_tlIsigInfos,_tlIuniqueInfos) = (tl_ ) in ( _lhsOaroundInfos,_lhsOaugmentInfos,_lhsOdefinedInsts,_lhsOorderDepsCollect,_lhsOpragmaNamesCollect,_lhsOruleInfos,_lhsOsigInfos,_lhsOuniqueInfos)) ) sem_SemDefs_Nil :: T_SemDefs sem_SemDefs_Nil = (T_SemDefs (let _lhsOaroundInfos :: ([AroundInfo]) _lhsOaugmentInfos :: ([AugmentInfo]) _lhsOdefinedInsts :: ([Identifier]) _lhsOorderDepsCollect :: (Set Dependency) _lhsOpragmaNamesCollect :: ([Identifier]) _lhsOruleInfos :: ([RuleInfo]) _lhsOsigInfos :: ([SigInfo]) _lhsOuniqueInfos :: ([UniqueInfo]) -- use rule "Transform.ag"(line 896, column 40) _lhsOaroundInfos = ({-# LINE 896 "Transform.ag" #-} [] {-# LINE 5654 "Transform.hs" #-}) -- use rule "Transform.ag"(line 895, column 40) _lhsOaugmentInfos = ({-# LINE 895 "Transform.ag" #-} [] {-# LINE 5659 "Transform.hs" #-}) -- use rule "Transform.ag"(line 966, column 55) _lhsOdefinedInsts = ({-# LINE 966 "Transform.ag" #-} [] {-# LINE 5664 "Transform.hs" #-}) -- use rule "Transform.ag"(line 758, column 44) _lhsOorderDepsCollect = ({-# LINE 758 "Transform.ag" #-} Set.empty {-# LINE 5669 "Transform.hs" #-}) -- use rule "Transform.ag"(line 727, column 46) _lhsOpragmaNamesCollect = ({-# LINE 727 "Transform.ag" #-} [] {-# LINE 5674 "Transform.hs" #-}) -- use rule "Transform.ag"(line 892, column 40) _lhsOruleInfos = ({-# LINE 892 "Transform.ag" #-} [] {-# LINE 5679 "Transform.hs" #-}) -- use rule "Transform.ag"(line 893, column 40) _lhsOsigInfos = ({-# LINE 893 "Transform.ag" #-} [] {-# LINE 5684 "Transform.hs" #-}) -- use rule "Transform.ag"(line 894, column 40) _lhsOuniqueInfos = ({-# LINE 894 "Transform.ag" #-} [] {-# LINE 5689 "Transform.hs" #-}) in ( _lhsOaroundInfos,_lhsOaugmentInfos,_lhsOdefinedInsts,_lhsOorderDepsCollect,_lhsOpragmaNamesCollect,_lhsOruleInfos,_lhsOsigInfos,_lhsOuniqueInfos)) )