-- UUAGC 0.9.14 (Order.ag) module Order where {-# LINE 9 "Order.ag" #-} -- From uuagc import CommonTypes import Patterns import ErrorMessages import AbstractSyntax import Code hiding (Type) import qualified Code import Expression import Options import SequentialComputation import SequentialTypes import CodeSyntax import GrammarInfo import HsToken(HsTokensRoot(HsTokensRoot)) import HsTokenScanner(lexTokens) import SemHsTokens(sem_HsTokensRoot,wrap_HsTokensRoot, Syn_HsTokensRoot(..),Inh_HsTokensRoot(..)) -- From uulib import qualified Data.Map as Map import qualified Data.Set as Set import qualified Data.Sequence as Seq import Data.Map(Map) import Data.Set(Set) import Data.Sequence(Seq, (><)) import UU.Util.Utils import UU.Scanner.Position(Pos(..),initPos) import Data.Foldable(toList) -- From haskell libraries import Control.Monad(liftM) import qualified Data.Array as Array import Data.Array((!),bounds,inRange) import Data.List(elemIndex,partition,sort,mapAccumL,find,nubBy,intersperse,groupBy,transpose) import qualified Data.Tree as Tree import Maybe {-# LINE 42 "../src-derived/Order.hs" #-} {-# LINE 2 "./Patterns.ag" #-} -- Patterns.ag imports import UU.Scanner.Position(Pos) import CommonTypes (ConstructorIdent,Identifier) {-# LINE 49 "../src-derived/Order.hs" #-} {-# LINE 2 "./Expression.ag" #-} import UU.Scanner.Position(Pos) import HsToken {-# LINE 55 "../src-derived/Order.hs" #-} {-# LINE 2 "./AbstractSyntax.ag" #-} -- AbstractSyntax.ag imports import Data.Set(Set) import Data.Map(Map) import Patterns (Pattern(..),Patterns) import Expression (Expression(..)) import CommonTypes {-# LINE 65 "../src-derived/Order.hs" #-} {-# LINE 46 "Order.ag" #-} -- Terminates with an error if the key is not in the map findWithErr1 :: (Ord k, Show k) => String -> k -> Map k a -> a findWithErr1 s k = Map.findWithDefault (error ("findWithErr1 " ++ s ++ ": key " ++ show k ++ " not in map.")) k findWithErr2 :: (Ord k, Show k, Show a) => k -> Map k a -> a findWithErr2 k m = Map.findWithDefault (error ("findWithErr2: key " ++ show k ++ " not in map: " ++ show m)) k m {-# LINE 76 "../src-derived/Order.hs" #-} {-# LINE 118 "Order.ag" #-} getNtName :: Type -> NontermIdent getNtName (NT nt _) = maybe nt id (deforestedNt nt) getNtName _ = nullIdent {-# LINE 83 "../src-derived/Order.hs" #-} {-# LINE 146 "Order.ag" #-} data AltAttr = AltAttr Identifier Identifier Bool deriving (Eq, Ord, Show) {-# LINE 89 "../src-derived/Order.hs" #-} {-# LINE 218 "Order.ag" #-} substSelf nt tp = case tp of NT n tps | n == _SELF -> NT nt tps _ -> tp haskellTupel :: [Type] -> Maybe Type haskellTupel ts = Just ( Haskell ( '(' : (concat (intersperse "," (map show ts))) ++ ")" )) {-# LINE 100 "../src-derived/Order.hs" #-} {-# LINE 278 "Order.ag" #-} lookupVertices :: Identifier -> Identifier -> Map AltAttr Int -> [Int] lookupVertices fld nm attrs = catMaybes ( [Map.lookup (AltAttr fld nm False) attrs] -- look for all "out" attributes ++ if fld == _LOC then [Map.lookup (AltAttr fld nm True) attrs] else [] ) {-# LINE 111 "../src-derived/Order.hs" #-} {-# LINE 614 "Order.ag" #-} swap (a,b) = (b,a) showPath :: Table CRule -> [Vertex] -> [String] showPath ruleTable path = let look a | inRange (bounds ruleTable) a = [showOrigin (ruleTable ! a)] | otherwise = ["Vertex " ++ show a] showOrigin cr | getHasCode cr && getName (getAttr cr) /= "self" = prettyCRule cr ++ " (" ++ show (getPos (getAttr cr)) ++ ")" | otherwise = prettyCRule cr in concatMap look path showPathLocal :: Table CRule -> [Vertex] -> [String] showPathLocal _ [] = [] showPathLocal ruleTable xs = showP (xs++[-1]) where showP [] = [] showP (v1:v2:vs) = let line = step v1 v2 lines = showP vs in line:lines step v1 v2 = " - " ++ a1 where r1 = ruleTable ! v1 a1 = show (getAttr r1) limitTo :: Int -> [String] -> [String] limitTo _ [] = [] limitTo 0 _ = ["....etcetera, etcetera...."] limitTo n (x:xs) = x : limitTo (n-1) xs showPathNice :: Table CRule -> [Vertex] -> [String] showPathNice _ [] = [] showPathNice ruleTable xs = limitTo 100 (showP ((-1):xs++[-1])) where [maxf, maxa, maxn, maxc] = maxWidths ruleTable (take 100 xs) showP [] = [] showP (v1:v2:vs) = let line = step v1 v2 lines = showP vs in if null line then lines else line:lines step v1 v2 | last && first = induced | last && isSyn r1 = "pass up " ++ alignR maxf "" ++ " " ++ alignL maxa a1 ++ " in " ++ alignR maxn n1 ++ "|" ++ c1 ++ induced | first&& not(isSyn r2) = "get from above " ++ alignR maxf "" ++ " " ++ alignL maxa a2 ++ " in " ++ alignR maxn n2 ++ "|" ++ c2 | last = "pass down " ++ alignR maxf f1 ++ "." ++ a1 ++ induced | isSyn r2 = "get from below " ++ alignR maxf f2 ++ "." ++ alignL maxa a2 ++ " in " ++ alignR maxn n2 ++ "|" ++ c2 | isLocal r1 = if head a1 == '_' then "" else "calculate " ++ alignR maxf "loc" ++ "." ++ a1 | otherwise = "pass down " ++ alignR maxf f1 ++ "." ++ alignL maxa a1 ++ " to " ++ alignR maxn n2 ++ "|" ++ c2 where first = v1<0 last = v2<0 r1 = ruleTable ! v1 r2 = ruleTable ! v2 a1 = show (getAttr r1) a2 = show (getAttr r2) f1 = show (getField r1) f2 = show (getField r2) n1 = show (getLhsNt r1) n2 = show (getLhsNt r2) c1 = show (getCon r1) c2 = show (getCon r2) induced | v2== -2 = " INDUCED dependency to " | otherwise = "" maxWidths ruleTable vs = map maximum (transpose (map getWidth vs)) where getWidth v | v<0 = [0,0,0,0] | otherwise = map (length . show . ($ (ruleTable!v))) [getField, getAttr, getLhsNt, getCon] alignL n xs | k Bool -> Route -> Error localCycleErr ruleTable o_visit (s:path) = let cr = ruleTable ! s attr = getAttr cr nt = getLhsNt cr con = getCon cr in LocalCirc nt con attr o_visit (showPathLocal ruleTable path) instCycleErr :: Table CRule -> Bool -> Route -> Error instCycleErr ruleTable o_visit (s:path) = let cr = ruleTable ! s attr = getAttr cr nt = getLhsNt cr con = getCon cr in InstCirc nt con attr o_visit (showPathLocal ruleTable path) directCycleErrs :: Table NTAttr -> Table CRule -> Bool -> [EdgeRoutes] -> [Error] directCycleErrs attrTable ruleTable o_visit xs = let getNont v = case attrTable ! v of NTASyn nt _ _ -> nt NTAInh nt _ _ -> nt getAttr v = case attrTable ! v of NTASyn _ a _ -> a NTAInh _ a _ -> a sameNont ((v1,_),_,_) ((v2,_),_,_) = getNont v1 == getNont v2 procCycle ((v1,v2),p1,p2) = ((getAttr v1, getAttr v2), showPathNice ruleTable p1, showPathNice ruleTable p2) wrapGroup gr@(((v1,_),_,_):_) = DirectCirc (getNont v1) o_visit (map procCycle gr) in map wrapGroup (groupBy sameNont xs) inducedCycleErrs :: Table NTAttr -> Table CRule -> CInterfaceMap -> [EdgeRoutes] -> [Error] inducedCycleErrs attrTable ruleTable cim xs = let getNont v = case attrTable ! v of NTASyn nt _ _ -> nt NTAInh nt _ _ -> nt getAttr v = case attrTable ! v of NTASyn _ a _ -> a NTAInh _ a _ -> a sameNont ((v1,_),_,_) ((v2,_),_,_) = getNont v1 == getNont v2 procCycle ((v1,v2),p1,p2) = ((getAttr v1, getAttr v2), showPathNice ruleTable p1, showPathNice ruleTable p2) wrapGroup gr@(((v1,_),_,_):_) = InducedCirc (getNont v1) (findWithErr1 "inducedCycleErr.cinter" (getNont v1) cim) (map procCycle gr) in map wrapGroup (groupBy sameNont xs) {-# LINE 231 "../src-derived/Order.hs" #-} -- Child ------------------------------------------------------- {- visit 0: inherited attributes: allfields : [(Identifier,Type,Bool)] allnts : [Identifier] attrs : [(Identifier,Identifier)] con : Identifier inh : Attributes nt : Identifier o_unbox : Bool syn : Attributes synthesized attributes: attributes : [(Identifier,Attributes,Attributes)] collectChildrenInhs : Map Identifier Attributes collectChildrenSyns : Map Identifier Attributes errors : Seq Error field : (Identifier,Type,Bool) gathAltAttrs : [AltAttr] gathRules : Seq CRule inhs : Seq (Identifier,Attributes) nts : Seq (Identifier,NontermIdent) singlevisits : [CRule] terminals : [Identifier] alternatives: alternative Child: child name : {Identifier} child tp : {Type} child inh : {Attributes} child syn : {Attributes} child higherOrder : {Bool} visit 0: local maptolocal : _ local gathRules : _ -} -- cata sem_Child :: Child -> T_Child sem_Child (Child _name _tp _inh _syn _higherOrder ) = (sem_Child_Child _name _tp _inh _syn _higherOrder ) -- semantic domain newtype T_Child = T_Child (([(Identifier,Type,Bool)]) -> ([Identifier]) -> ([(Identifier,Identifier)]) -> Identifier -> Attributes -> Identifier -> Bool -> Attributes -> ( ([(Identifier,Attributes,Attributes)]),(Map Identifier Attributes ),(Map Identifier Attributes ),(Seq Error),((Identifier,Type,Bool)),([AltAttr]),(Seq CRule),(Seq (Identifier,Attributes)),(Seq (Identifier,NontermIdent)),([CRule]),([Identifier]))) data Inh_Child = Inh_Child {allfields_Inh_Child :: !([(Identifier,Type,Bool)]),allnts_Inh_Child :: !([Identifier]),attrs_Inh_Child :: !([(Identifier,Identifier)]),con_Inh_Child :: !(Identifier),inh_Inh_Child :: !(Attributes),nt_Inh_Child :: !(Identifier),o_unbox_Inh_Child :: !(Bool),syn_Inh_Child :: !(Attributes)} data Syn_Child = Syn_Child {attributes_Syn_Child :: !([(Identifier,Attributes,Attributes)]),collectChildrenInhs_Syn_Child :: !(Map Identifier Attributes ),collectChildrenSyns_Syn_Child :: !(Map Identifier Attributes ),errors_Syn_Child :: !(Seq Error),field_Syn_Child :: !((Identifier,Type,Bool)),gathAltAttrs_Syn_Child :: !([AltAttr]),gathRules_Syn_Child :: !(Seq CRule),inhs_Syn_Child :: !(Seq (Identifier,Attributes)),nts_Syn_Child :: !(Seq (Identifier,NontermIdent)),singlevisits_Syn_Child :: !([CRule]),terminals_Syn_Child :: !([Identifier])} wrap_Child :: T_Child -> Inh_Child -> Syn_Child wrap_Child (T_Child sem ) (Inh_Child _lhsIallfields _lhsIallnts _lhsIattrs _lhsIcon _lhsIinh _lhsInt _lhsIo_unbox _lhsIsyn ) = (let ( _lhsOattributes,_lhsOcollectChildrenInhs,_lhsOcollectChildrenSyns,_lhsOerrors,_lhsOfield,_lhsOgathAltAttrs,_lhsOgathRules,_lhsOinhs,_lhsOnts,_lhsOsinglevisits,_lhsOterminals) = (sem _lhsIallfields _lhsIallnts _lhsIattrs _lhsIcon _lhsIinh _lhsInt _lhsIo_unbox _lhsIsyn ) in (Syn_Child _lhsOattributes _lhsOcollectChildrenInhs _lhsOcollectChildrenSyns _lhsOerrors _lhsOfield _lhsOgathAltAttrs _lhsOgathRules _lhsOinhs _lhsOnts _lhsOsinglevisits _lhsOterminals )) sem_Child_Child :: Identifier -> Type -> Attributes -> Attributes -> Bool -> T_Child sem_Child_Child name_ tp_ inh_ syn_ higherOrder_ = (T_Child (\ _lhsIallfields _lhsIallnts _lhsIattrs _lhsIcon _lhsIinh _lhsInt _lhsIo_unbox _lhsIsyn -> (let _lhsOgathAltAttrs :: ([AltAttr]) _lhsOnts :: (Seq (Identifier,NontermIdent)) _lhsOinhs :: (Seq (Identifier,Attributes)) _lhsOcollectChildrenSyns :: (Map Identifier Attributes ) _lhsOcollectChildrenInhs :: (Map Identifier Attributes ) _lhsOsinglevisits :: ([CRule]) _lhsOterminals :: ([Identifier]) _lhsOattributes :: ([(Identifier,Attributes,Attributes)]) _lhsOfield :: ((Identifier,Type,Bool)) _lhsOerrors :: (Seq Error) _lhsOgathRules :: (Seq CRule) -- "Order.ag"(line 157, column 13) _maptolocal = {-# LINE 157 "Order.ag" #-} case tp_ of NT nt _ -> Map.null syn_ _ -> True {-# LINE 323 "Order.hs" #-} -- "Order.ag"(line 160, column 13) _lhsOgathAltAttrs = {-# LINE 160 "Order.ag" #-} if _maptolocal then [ AltAttr _LOC name_ True ] else [ AltAttr name_ syn True | syn <- Map.keys syn_ ] {-# LINE 330 "Order.hs" #-} -- "Order.ag"(line 175, column 13) _lhsOnts = {-# LINE 175 "Order.ag" #-} Seq.singleton (name_,getNtName tp_) {-# LINE 335 "Order.hs" #-} -- "Order.ag"(line 176, column 13) _lhsOinhs = {-# LINE 176 "Order.ag" #-} Seq.singleton (name_,inh_) {-# LINE 340 "Order.hs" #-} -- "Order.ag"(line 192, column 13) _gathRules = {-# LINE 192 "Order.ag" #-} if _maptolocal then Seq.singleton (cRuleTerminal name_ _lhsInt _lhsIcon tp_) else Seq.fromList [ cRuleRhsSyn syn _lhsInt _lhsIcon tp name_ (getNtName tp_) | (syn,tp) <- Map.assocs syn_] {-# LINE 347 "Order.hs" #-} -- "Order.ag"(line 330, column 12) _lhsOcollectChildrenSyns = {-# LINE 330 "Order.ag" #-} Map.singleton name_ syn_ {-# LINE 352 "Order.hs" #-} -- "Order.ag"(line 331, column 12) _lhsOcollectChildrenInhs = {-# LINE 331 "Order.ag" #-} Map.singleton name_ inh_ {-# LINE 357 "Order.hs" #-} -- "Order.ag"(line 541, column 11) _lhsOsinglevisits = {-# LINE 541 "Order.ag" #-} if _maptolocal then [] else [CChildVisit name_ (getNtName tp_) 0 inh_ syn_ True] {-# LINE 364 "Order.hs" #-} -- "Order.ag"(line 565, column 11) _lhsOterminals = {-# LINE 565 "Order.ag" #-} if _maptolocal then [name_] else [] {-# LINE 371 "Order.hs" #-} -- "Order.ag"(line 594, column 11) _lhsOattributes = {-# LINE 594 "Order.ag" #-} [(name_, inh_, syn_)] {-# LINE 376 "Order.hs" #-} -- "Order.ag"(line 598, column 11) _lhsOfield = {-# LINE 598 "Order.ag" #-} (name_, tp_, higherOrder_) {-# LINE 381 "Order.hs" #-} -- use rule "Order.ag"(line 64, column 70) _lhsOerrors = {-# LINE 64 "Order.ag" #-} Seq.empty {-# LINE 386 "Order.hs" #-} -- use rule "Order.ag"(line 186, column 23) _lhsOgathRules = {-# LINE 186 "Order.ag" #-} _gathRules {-# LINE 391 "Order.hs" #-} in ( _lhsOattributes,_lhsOcollectChildrenInhs,_lhsOcollectChildrenSyns,_lhsOerrors,_lhsOfield,_lhsOgathAltAttrs,_lhsOgathRules,_lhsOinhs,_lhsOnts,_lhsOsinglevisits,_lhsOterminals))) ) -- Children ---------------------------------------------------- {- visit 0: inherited attributes: allfields : [(Identifier,Type,Bool)] allnts : [Identifier] attrs : [(Identifier,Identifier)] con : Identifier inh : Attributes nt : Identifier o_unbox : Bool syn : Attributes synthesized attributes: attributes : [(Identifier,Attributes,Attributes)] collectChildrenInhs : Map Identifier Attributes collectChildrenSyns : Map Identifier Attributes errors : Seq Error fields : [(Identifier,Type,Bool)] gathAltAttrs : [AltAttr] gathRules : Seq CRule inhs : Seq (Identifier,Attributes) nts : Seq (Identifier,NontermIdent) singlevisits : [CRule] terminals : [Identifier] alternatives: alternative Cons: child hd : Child child tl : Children alternative Nil: -} -- cata sem_Children :: Children -> T_Children sem_Children list = (Prelude.foldr sem_Children_Cons sem_Children_Nil (Prelude.map sem_Child list) ) -- semantic domain newtype T_Children = T_Children (([(Identifier,Type,Bool)]) -> ([Identifier]) -> ([(Identifier,Identifier)]) -> Identifier -> Attributes -> Identifier -> Bool -> Attributes -> ( ([(Identifier,Attributes,Attributes)]),(Map Identifier Attributes ),(Map Identifier Attributes ),(Seq Error),([(Identifier,Type,Bool)]),([AltAttr]),(Seq CRule),(Seq (Identifier,Attributes)),(Seq (Identifier,NontermIdent)),([CRule]),([Identifier]))) data Inh_Children = Inh_Children {allfields_Inh_Children :: !([(Identifier,Type,Bool)]),allnts_Inh_Children :: !([Identifier]),attrs_Inh_Children :: !([(Identifier,Identifier)]),con_Inh_Children :: !(Identifier),inh_Inh_Children :: !(Attributes),nt_Inh_Children :: !(Identifier),o_unbox_Inh_Children :: !(Bool),syn_Inh_Children :: !(Attributes)} data Syn_Children = Syn_Children {attributes_Syn_Children :: !([(Identifier,Attributes,Attributes)]),collectChildrenInhs_Syn_Children :: !(Map Identifier Attributes ),collectChildrenSyns_Syn_Children :: !(Map Identifier Attributes ),errors_Syn_Children :: !(Seq Error),fields_Syn_Children :: !([(Identifier,Type,Bool)]),gathAltAttrs_Syn_Children :: !([AltAttr]),gathRules_Syn_Children :: !(Seq CRule),inhs_Syn_Children :: !(Seq (Identifier,Attributes)),nts_Syn_Children :: !(Seq (Identifier,NontermIdent)),singlevisits_Syn_Children :: !([CRule]),terminals_Syn_Children :: !([Identifier])} wrap_Children :: T_Children -> Inh_Children -> Syn_Children wrap_Children (T_Children sem ) (Inh_Children _lhsIallfields _lhsIallnts _lhsIattrs _lhsIcon _lhsIinh _lhsInt _lhsIo_unbox _lhsIsyn ) = (let ( _lhsOattributes,_lhsOcollectChildrenInhs,_lhsOcollectChildrenSyns,_lhsOerrors,_lhsOfields,_lhsOgathAltAttrs,_lhsOgathRules,_lhsOinhs,_lhsOnts,_lhsOsinglevisits,_lhsOterminals) = (sem _lhsIallfields _lhsIallnts _lhsIattrs _lhsIcon _lhsIinh _lhsInt _lhsIo_unbox _lhsIsyn ) in (Syn_Children _lhsOattributes _lhsOcollectChildrenInhs _lhsOcollectChildrenSyns _lhsOerrors _lhsOfields _lhsOgathAltAttrs _lhsOgathRules _lhsOinhs _lhsOnts _lhsOsinglevisits _lhsOterminals )) sem_Children_Cons :: T_Child -> T_Children -> T_Children sem_Children_Cons (T_Child hd_ ) (T_Children tl_ ) = (T_Children (\ _lhsIallfields _lhsIallnts _lhsIattrs _lhsIcon _lhsIinh _lhsInt _lhsIo_unbox _lhsIsyn -> (let _lhsOfields :: ([(Identifier,Type,Bool)]) _lhsOattributes :: ([(Identifier,Attributes,Attributes)]) _lhsOcollectChildrenInhs :: (Map Identifier Attributes ) _lhsOcollectChildrenSyns :: (Map Identifier Attributes ) _lhsOerrors :: (Seq Error) _lhsOgathAltAttrs :: ([AltAttr]) _lhsOgathRules :: (Seq CRule) _lhsOinhs :: (Seq (Identifier,Attributes)) _lhsOnts :: (Seq (Identifier,NontermIdent)) _lhsOsinglevisits :: ([CRule]) _lhsOterminals :: ([Identifier]) _hdOallfields :: ([(Identifier,Type,Bool)]) _hdOallnts :: ([Identifier]) _hdOattrs :: ([(Identifier,Identifier)]) _hdOcon :: Identifier _hdOinh :: Attributes _hdOnt :: Identifier _hdOo_unbox :: Bool _hdOsyn :: Attributes _tlOallfields :: ([(Identifier,Type,Bool)]) _tlOallnts :: ([Identifier]) _tlOattrs :: ([(Identifier,Identifier)]) _tlOcon :: Identifier _tlOinh :: Attributes _tlOnt :: Identifier _tlOo_unbox :: Bool _tlOsyn :: Attributes _hdIattributes :: ([(Identifier,Attributes,Attributes)]) _hdIcollectChildrenInhs :: (Map Identifier Attributes ) _hdIcollectChildrenSyns :: (Map Identifier Attributes ) _hdIerrors :: (Seq Error) _hdIfield :: ((Identifier,Type,Bool)) _hdIgathAltAttrs :: ([AltAttr]) _hdIgathRules :: (Seq CRule) _hdIinhs :: (Seq (Identifier,Attributes)) _hdInts :: (Seq (Identifier,NontermIdent)) _hdIsinglevisits :: ([CRule]) _hdIterminals :: ([Identifier]) _tlIattributes :: ([(Identifier,Attributes,Attributes)]) _tlIcollectChildrenInhs :: (Map Identifier Attributes ) _tlIcollectChildrenSyns :: (Map Identifier Attributes ) _tlIerrors :: (Seq Error) _tlIfields :: ([(Identifier,Type,Bool)]) _tlIgathAltAttrs :: ([AltAttr]) _tlIgathRules :: (Seq CRule) _tlIinhs :: (Seq (Identifier,Attributes)) _tlInts :: (Seq (Identifier,NontermIdent)) _tlIsinglevisits :: ([CRule]) _tlIterminals :: ([Identifier]) -- "Order.ag"(line 601, column 11) _lhsOfields = {-# LINE 601 "Order.ag" #-} _hdIfield : _tlIfields {-# LINE 512 "Order.hs" #-} -- use rule "Order.ag"(line 592, column 32) _lhsOattributes = {-# LINE 592 "Order.ag" #-} _hdIattributes ++ _tlIattributes {-# LINE 517 "Order.hs" #-} -- use rule "Order.ag"(line 328, column 68) _lhsOcollectChildrenInhs = {-# LINE 328 "Order.ag" #-} _hdIcollectChildrenInhs `Map.union` _tlIcollectChildrenInhs {-# LINE 522 "Order.hs" #-} -- use rule "Order.ag"(line 328, column 68) _lhsOcollectChildrenSyns = {-# LINE 328 "Order.ag" #-} _hdIcollectChildrenSyns `Map.union` _tlIcollectChildrenSyns {-# LINE 527 "Order.hs" #-} -- use rule "Order.ag"(line 64, column 70) _lhsOerrors = {-# LINE 64 "Order.ag" #-} _hdIerrors Seq.>< _tlIerrors {-# LINE 532 "Order.hs" #-} -- use rule "Order.ag"(line 150, column 68) _lhsOgathAltAttrs = {-# LINE 150 "Order.ag" #-} _hdIgathAltAttrs ++ _tlIgathAltAttrs {-# LINE 537 "Order.hs" #-} -- use rule "Order.ag"(line 186, column 23) _lhsOgathRules = {-# LINE 186 "Order.ag" #-} _hdIgathRules Seq.>< _tlIgathRules {-# LINE 542 "Order.hs" #-} -- use rule "Order.ag"(line 173, column 20) _lhsOinhs = {-# LINE 173 "Order.ag" #-} _hdIinhs Seq.>< _tlIinhs {-# LINE 547 "Order.hs" #-} -- use rule "Order.ag"(line 172, column 19) _lhsOnts = {-# LINE 172 "Order.ag" #-} _hdInts Seq.>< _tlInts {-# LINE 552 "Order.hs" #-} -- use rule "Order.ag"(line 539, column 40) _lhsOsinglevisits = {-# LINE 539 "Order.ag" #-} _hdIsinglevisits ++ _tlIsinglevisits {-# LINE 557 "Order.hs" #-} -- use rule "Order.ag"(line 563, column 38) _lhsOterminals = {-# LINE 563 "Order.ag" #-} _hdIterminals ++ _tlIterminals {-# LINE 562 "Order.hs" #-} -- copy rule (down) _hdOallfields = {-# LINE 581 "Order.ag" #-} _lhsIallfields {-# LINE 567 "Order.hs" #-} -- copy rule (down) _hdOallnts = {-# LINE 574 "Order.ag" #-} _lhsIallnts {-# LINE 572 "Order.hs" #-} -- copy rule (down) _hdOattrs = {-# LINE 581 "Order.ag" #-} _lhsIattrs {-# LINE 577 "Order.hs" #-} -- copy rule (down) _hdOcon = {-# LINE 70 "Order.ag" #-} _lhsIcon {-# LINE 582 "Order.hs" #-} -- copy rule (down) _hdOinh = {-# LINE 69 "Order.ag" #-} _lhsIinh {-# LINE 587 "Order.hs" #-} -- copy rule (down) _hdOnt = {-# LINE 69 "Order.ag" #-} _lhsInt {-# LINE 592 "Order.hs" #-} -- copy rule (down) _hdOo_unbox = {-# LINE 99 "Order.ag" #-} _lhsIo_unbox {-# LINE 597 "Order.hs" #-} -- copy rule (down) _hdOsyn = {-# LINE 69 "Order.ag" #-} _lhsIsyn {-# LINE 602 "Order.hs" #-} -- copy rule (down) _tlOallfields = {-# LINE 581 "Order.ag" #-} _lhsIallfields {-# LINE 607 "Order.hs" #-} -- copy rule (down) _tlOallnts = {-# LINE 574 "Order.ag" #-} _lhsIallnts {-# LINE 612 "Order.hs" #-} -- copy rule (down) _tlOattrs = {-# LINE 581 "Order.ag" #-} _lhsIattrs {-# LINE 617 "Order.hs" #-} -- copy rule (down) _tlOcon = {-# LINE 70 "Order.ag" #-} _lhsIcon {-# LINE 622 "Order.hs" #-} -- copy rule (down) _tlOinh = {-# LINE 69 "Order.ag" #-} _lhsIinh {-# LINE 627 "Order.hs" #-} -- copy rule (down) _tlOnt = {-# LINE 69 "Order.ag" #-} _lhsInt {-# LINE 632 "Order.hs" #-} -- copy rule (down) _tlOo_unbox = {-# LINE 99 "Order.ag" #-} _lhsIo_unbox {-# LINE 637 "Order.hs" #-} -- copy rule (down) _tlOsyn = {-# LINE 69 "Order.ag" #-} _lhsIsyn {-# LINE 642 "Order.hs" #-} ( _hdIattributes,_hdIcollectChildrenInhs,_hdIcollectChildrenSyns,_hdIerrors,_hdIfield,_hdIgathAltAttrs,_hdIgathRules,_hdIinhs,_hdInts,_hdIsinglevisits,_hdIterminals) = (hd_ _hdOallfields _hdOallnts _hdOattrs _hdOcon _hdOinh _hdOnt _hdOo_unbox _hdOsyn ) ( _tlIattributes,_tlIcollectChildrenInhs,_tlIcollectChildrenSyns,_tlIerrors,_tlIfields,_tlIgathAltAttrs,_tlIgathRules,_tlIinhs,_tlInts,_tlIsinglevisits,_tlIterminals) = (tl_ _tlOallfields _tlOallnts _tlOattrs _tlOcon _tlOinh _tlOnt _tlOo_unbox _tlOsyn ) in ( _lhsOattributes,_lhsOcollectChildrenInhs,_lhsOcollectChildrenSyns,_lhsOerrors,_lhsOfields,_lhsOgathAltAttrs,_lhsOgathRules,_lhsOinhs,_lhsOnts,_lhsOsinglevisits,_lhsOterminals))) ) sem_Children_Nil :: T_Children sem_Children_Nil = (T_Children (\ _lhsIallfields _lhsIallnts _lhsIattrs _lhsIcon _lhsIinh _lhsInt _lhsIo_unbox _lhsIsyn -> (let _lhsOfields :: ([(Identifier,Type,Bool)]) _lhsOattributes :: ([(Identifier,Attributes,Attributes)]) _lhsOcollectChildrenInhs :: (Map Identifier Attributes ) _lhsOcollectChildrenSyns :: (Map Identifier Attributes ) _lhsOerrors :: (Seq Error) _lhsOgathAltAttrs :: ([AltAttr]) _lhsOgathRules :: (Seq CRule) _lhsOinhs :: (Seq (Identifier,Attributes)) _lhsOnts :: (Seq (Identifier,NontermIdent)) _lhsOsinglevisits :: ([CRule]) _lhsOterminals :: ([Identifier]) -- "Order.ag"(line 602, column 11) _lhsOfields = {-# LINE 602 "Order.ag" #-} [] {-# LINE 673 "Order.hs" #-} -- use rule "Order.ag"(line 592, column 32) _lhsOattributes = {-# LINE 592 "Order.ag" #-} [] {-# LINE 678 "Order.hs" #-} -- use rule "Order.ag"(line 328, column 68) _lhsOcollectChildrenInhs = {-# LINE 328 "Order.ag" #-} Map.empty {-# LINE 683 "Order.hs" #-} -- use rule "Order.ag"(line 328, column 68) _lhsOcollectChildrenSyns = {-# LINE 328 "Order.ag" #-} Map.empty {-# LINE 688 "Order.hs" #-} -- use rule "Order.ag"(line 64, column 70) _lhsOerrors = {-# LINE 64 "Order.ag" #-} Seq.empty {-# LINE 693 "Order.hs" #-} -- use rule "Order.ag"(line 150, column 68) _lhsOgathAltAttrs = {-# LINE 150 "Order.ag" #-} [] {-# LINE 698 "Order.hs" #-} -- use rule "Order.ag"(line 186, column 23) _lhsOgathRules = {-# LINE 186 "Order.ag" #-} Seq.empty {-# LINE 703 "Order.hs" #-} -- use rule "Order.ag"(line 173, column 20) _lhsOinhs = {-# LINE 173 "Order.ag" #-} Seq.empty {-# LINE 708 "Order.hs" #-} -- use rule "Order.ag"(line 172, column 19) _lhsOnts = {-# LINE 172 "Order.ag" #-} Seq.empty {-# LINE 713 "Order.hs" #-} -- use rule "Order.ag"(line 539, column 40) _lhsOsinglevisits = {-# LINE 539 "Order.ag" #-} [] {-# LINE 718 "Order.hs" #-} -- use rule "Order.ag"(line 563, column 38) _lhsOterminals = {-# LINE 563 "Order.ag" #-} [] {-# LINE 723 "Order.hs" #-} in ( _lhsOattributes,_lhsOcollectChildrenInhs,_lhsOcollectChildrenSyns,_lhsOerrors,_lhsOfields,_lhsOgathAltAttrs,_lhsOgathRules,_lhsOinhs,_lhsOnts,_lhsOsinglevisits,_lhsOterminals))) ) -- Expression -------------------------------------------------- {- visit 0: inherited attributes: allfields : [(Identifier,Type,Bool)] allnts : [Identifier] attrs : [(Identifier,Identifier)] con : Identifier nt : Identifier synthesized attributes: allRhsVars : Set (Identifier,Identifier) copy : SELF errors : Seq Error textLines : [String] usedAttrs : [(Identifier,Identifier)] usedFields : [Identifier] usedLocals : [Identifier] alternatives: alternative Expression: child pos : {Pos} child tks : {[HsToken]} visit 0: local _tup1 : _ local errors : _ local textLines : _ local usedAttrs : _ local usedLocals : _ local usedFields : _ local copy : _ -} -- cata sem_Expression :: Expression -> T_Expression sem_Expression (Expression _pos _tks ) = (sem_Expression_Expression _pos _tks ) -- semantic domain newtype T_Expression = T_Expression (([(Identifier,Type,Bool)]) -> ([Identifier]) -> ([(Identifier,Identifier)]) -> Identifier -> Identifier -> ( (Set (Identifier,Identifier)),Expression,(Seq Error),([String]),([(Identifier,Identifier)]),([Identifier]),([Identifier]))) data Inh_Expression = Inh_Expression {allfields_Inh_Expression :: !([(Identifier,Type,Bool)]),allnts_Inh_Expression :: !([Identifier]),attrs_Inh_Expression :: !([(Identifier,Identifier)]),con_Inh_Expression :: !(Identifier),nt_Inh_Expression :: !(Identifier)} data Syn_Expression = Syn_Expression {allRhsVars_Syn_Expression :: !(Set (Identifier,Identifier)),copy_Syn_Expression :: !(Expression),errors_Syn_Expression :: !(Seq Error),textLines_Syn_Expression :: !([String]),usedAttrs_Syn_Expression :: !([(Identifier,Identifier)]),usedFields_Syn_Expression :: !([Identifier]),usedLocals_Syn_Expression :: !([Identifier])} wrap_Expression :: T_Expression -> Inh_Expression -> Syn_Expression wrap_Expression (T_Expression sem ) (Inh_Expression _lhsIallfields _lhsIallnts _lhsIattrs _lhsIcon _lhsInt ) = (let ( _lhsOallRhsVars,_lhsOcopy,_lhsOerrors,_lhsOtextLines,_lhsOusedAttrs,_lhsOusedFields,_lhsOusedLocals) = (sem _lhsIallfields _lhsIallnts _lhsIattrs _lhsIcon _lhsInt ) in (Syn_Expression _lhsOallRhsVars _lhsOcopy _lhsOerrors _lhsOtextLines _lhsOusedAttrs _lhsOusedFields _lhsOusedLocals )) sem_Expression_Expression :: Pos -> ([HsToken]) -> T_Expression sem_Expression_Expression pos_ tks_ = (T_Expression (\ _lhsIallfields _lhsIallnts _lhsIattrs _lhsIcon _lhsInt -> (let _lhsOallRhsVars :: (Set (Identifier,Identifier)) _lhsOcopy :: Expression _lhsOerrors :: (Seq Error) _lhsOtextLines :: ([String]) _lhsOusedAttrs :: ([(Identifier,Identifier)]) _lhsOusedFields :: ([Identifier]) _lhsOusedLocals :: ([Identifier]) -- "Order.ag"(line 400, column 21) __tup1 = {-# LINE 400 "Order.ag" #-} let inherited = Inh_HsTokensRoot { attrs_Inh_HsTokensRoot = _lhsIattrs , con_Inh_HsTokensRoot = _lhsIcon , allfields_Inh_HsTokensRoot = _lhsIallfields , allnts_Inh_HsTokensRoot = _lhsIallnts , nt_Inh_HsTokensRoot = _lhsInt } synthesized = wrap_HsTokensRoot (sem_HsTokensRoot (HsTokensRoot tks_)) inherited in case synthesized of Syn_HsTokensRoot { errors_Syn_HsTokensRoot = errors , textLines_Syn_HsTokensRoot = textLines , usedAttrs_Syn_HsTokensRoot = usedAttrs , usedLocals_Syn_HsTokensRoot = usedLocals , usedFields_Syn_HsTokensRoot = usedFields } -> (errors,textLines,usedAttrs,usedLocals,usedFields) {-# LINE 811 "Order.hs" #-} -- "Order.ag"(line 400, column 21) (_errors,_,_,_,_) = {-# LINE 400 "Order.ag" #-} __tup1 {-# LINE 816 "Order.hs" #-} -- "Order.ag"(line 400, column 21) (_,_textLines,_,_,_) = {-# LINE 400 "Order.ag" #-} __tup1 {-# LINE 821 "Order.hs" #-} -- "Order.ag"(line 400, column 21) (_,_,_usedAttrs,_,_) = {-# LINE 400 "Order.ag" #-} __tup1 {-# LINE 826 "Order.hs" #-} -- "Order.ag"(line 400, column 21) (_,_,_,_usedLocals,_) = {-# LINE 400 "Order.ag" #-} __tup1 {-# LINE 831 "Order.hs" #-} -- "Order.ag"(line 400, column 21) (_,_,_,_,_usedFields) = {-# LINE 400 "Order.ag" #-} __tup1 {-# LINE 836 "Order.hs" #-} -- "Order.ag"(line 418, column 17) _lhsOallRhsVars = {-# LINE 418 "Order.ag" #-} Set.fromList _usedAttrs `Set.union` Set.fromList [ (_LOC, l) | l <- _usedLocals ] `Set.union` Set.fromList [ (_FIELD, fld) | fld <- _usedFields ] {-# LINE 845 "Order.hs" #-} -- self rule _copy = {-# LINE 395 "Order.ag" #-} Expression pos_ tks_ {-# LINE 850 "Order.hs" #-} -- self rule _lhsOcopy = {-# LINE 395 "Order.ag" #-} _copy {-# LINE 855 "Order.hs" #-} -- copy rule (from local) _lhsOerrors = {-# LINE 390 "Order.ag" #-} _errors {-# LINE 860 "Order.hs" #-} -- copy rule (from local) _lhsOtextLines = {-# LINE 394 "Order.ag" #-} _textLines {-# LINE 865 "Order.hs" #-} -- copy rule (from local) _lhsOusedAttrs = {-# LINE 392 "Order.ag" #-} _usedAttrs {-# LINE 870 "Order.hs" #-} -- copy rule (from local) _lhsOusedFields = {-# LINE 393 "Order.ag" #-} _usedFields {-# LINE 875 "Order.hs" #-} -- copy rule (from local) _lhsOusedLocals = {-# LINE 391 "Order.ag" #-} _usedLocals {-# LINE 880 "Order.hs" #-} in ( _lhsOallRhsVars,_lhsOcopy,_lhsOerrors,_lhsOtextLines,_lhsOusedAttrs,_lhsOusedFields,_lhsOusedLocals))) ) -- Grammar ----------------------------------------------------- {- visit 0: inherited attribute: options : Options synthesized attributes: errors : Seq Error output : CGrammar alternatives: alternative Grammar: child typeSyns : {TypeSyns} child useMap : {UseMap} child derivings : {Derivings} child wrappers : {Set NontermIdent} child nonts : Nonterminals child pragmas : {PragmaMap} child manualAttrOrderMap : {AttrOrderMap} child paramMap : {ParamMap} child contextMap : {ContextMap} child uniqueMap : {UniqueMap} child augmentsMap : {Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))} child aroundsMap : {Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))} visit 0: local ruleTable : _ local attrTable : _ local attrVertex : _ local tdpToTds : _ local tdsToTdp : _ local directDep : _ local instDep : _ local aroundDep : _ local info : _ local _tup2 : _ local cInterfaceMap : _ local cVisitsMap : _ local cyclesErrors : _ local aroundMap : _ -} -- cata sem_Grammar :: Grammar -> T_Grammar sem_Grammar (Grammar _typeSyns _useMap _derivings _wrappers _nonts _pragmas _manualAttrOrderMap _paramMap _contextMap _uniqueMap _augmentsMap _aroundsMap ) = (sem_Grammar_Grammar _typeSyns _useMap _derivings _wrappers (sem_Nonterminals _nonts ) _pragmas _manualAttrOrderMap _paramMap _contextMap _uniqueMap _augmentsMap _aroundsMap ) -- semantic domain newtype T_Grammar = T_Grammar (Options -> ( (Seq Error),CGrammar)) data Inh_Grammar = Inh_Grammar {options_Inh_Grammar :: !(Options)} data Syn_Grammar = Syn_Grammar {errors_Syn_Grammar :: !(Seq Error),output_Syn_Grammar :: !(CGrammar)} wrap_Grammar :: T_Grammar -> Inh_Grammar -> Syn_Grammar wrap_Grammar (T_Grammar sem ) (Inh_Grammar _lhsIoptions ) = (let ( _lhsOerrors,_lhsOoutput) = (sem _lhsIoptions ) in (Syn_Grammar _lhsOerrors _lhsOoutput )) sem_Grammar_Grammar :: TypeSyns -> UseMap -> Derivings -> (Set NontermIdent) -> T_Nonterminals -> PragmaMap -> AttrOrderMap -> ParamMap -> ContextMap -> UniqueMap -> (Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))) -> (Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))) -> T_Grammar sem_Grammar_Grammar typeSyns_ useMap_ derivings_ wrappers_ (T_Nonterminals nonts_ ) pragmas_ manualAttrOrderMap_ paramMap_ contextMap_ uniqueMap_ augmentsMap_ aroundsMap_ = (T_Grammar (\ _lhsIoptions -> (let _nontsOo_cata :: Bool _nontsOo_data :: Bool _nontsOo_sig :: Bool _nontsOo_sem :: Bool _nontsOo_rename :: Bool _nontsOo_newtypes :: Bool _nontsOo_wantvisit :: Bool _nontsOo_dovisit :: Bool _nontsOo_unbox :: Bool _nontsOo_case :: Bool _nontsOprefix :: String _nontsOvcount :: Int _nontsOmanualAttrDepMap :: AttrOrderMap _nontsOaroundMap :: (Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))) _nontsOacount :: Int _lhsOerrors :: (Seq Error) _lhsOoutput :: CGrammar _nontsOallnts :: ([Identifier]) _nontsOcInterfaceMap :: CInterfaceMap _nontsOcVisitsMap :: CVisitsMap _nontsIacount :: Int _nontsIadditionalDep :: (Seq Edge) _nontsIaranges :: (Seq (Int,Int,Int)) _nontsIaroundDep :: (Seq Edge) _nontsIcNonterminals :: CNonterminals _nontsIdirectDep :: (Seq Edge) _nontsIerrors :: (Seq Error) _nontsIinstDep :: (Seq Edge) _nontsInonts :: ([(NontermIdent,[ConstructorIdent])]) _nontsIntattrs :: (Seq (Vertex,NTAttr)) _nontsIrules :: (Seq (Vertex,CRule)) _nontsIvcount :: Int -- "Order.ag"(line 103, column 17) _nontsOo_cata = {-# LINE 103 "Order.ag" #-} folds _lhsIoptions {-# LINE 988 "Order.hs" #-} -- "Order.ag"(line 103, column 17) _nontsOo_data = {-# LINE 104 "Order.ag" #-} dataTypes _lhsIoptions {-# LINE 993 "Order.hs" #-} -- "Order.ag"(line 103, column 17) _nontsOo_sig = {-# LINE 105 "Order.ag" #-} typeSigs _lhsIoptions {-# LINE 998 "Order.hs" #-} -- "Order.ag"(line 103, column 17) _nontsOo_sem = {-# LINE 106 "Order.ag" #-} semfuns _lhsIoptions {-# LINE 1003 "Order.hs" #-} -- "Order.ag"(line 103, column 17) _nontsOo_rename = {-# LINE 107 "Order.ag" #-} rename _lhsIoptions {-# LINE 1008 "Order.hs" #-} -- "Order.ag"(line 103, column 17) _nontsOo_newtypes = {-# LINE 108 "Order.ag" #-} newtypes _lhsIoptions {-# LINE 1013 "Order.hs" #-} -- "Order.ag"(line 103, column 17) _nontsOo_wantvisit = {-# LINE 109 "Order.ag" #-} visit _lhsIoptions {-# LINE 1018 "Order.hs" #-} -- "Order.ag"(line 103, column 17) _nontsOo_dovisit = {-# LINE 110 "Order.ag" #-} visit _lhsIoptions && null _cyclesErrors {-# LINE 1023 "Order.hs" #-} -- "Order.ag"(line 103, column 17) _nontsOo_unbox = {-# LINE 111 "Order.ag" #-} unbox _lhsIoptions {-# LINE 1028 "Order.hs" #-} -- "Order.ag"(line 103, column 17) _nontsOo_case = {-# LINE 112 "Order.ag" #-} cases _lhsIoptions {-# LINE 1033 "Order.hs" #-} -- "Order.ag"(line 103, column 17) _nontsOprefix = {-# LINE 113 "Order.ag" #-} prefix _lhsIoptions {-# LINE 1038 "Order.hs" #-} -- "Order.ag"(line 241, column 15) _nontsOvcount = {-# LINE 241 "Order.ag" #-} 0 {-# LINE 1043 "Order.hs" #-} -- "Order.ag"(line 266, column 7) _nontsOmanualAttrDepMap = {-# LINE 266 "Order.ag" #-} manualAttrOrderMap_ {-# LINE 1048 "Order.hs" #-} -- "Order.ag"(line 354, column 14) _nontsOaroundMap = {-# LINE 354 "Order.ag" #-} aroundsMap_ {-# LINE 1053 "Order.hs" #-} -- "Order.ag"(line 432, column 13) _nontsOacount = {-# LINE 432 "Order.ag" #-} 0 {-# LINE 1058 "Order.hs" #-} -- "Order.ag"(line 470, column 13) _ruleTable = {-# LINE 470 "Order.ag" #-} Array.array (0,_nontsIvcount-1) (toList _nontsIrules) {-# LINE 1063 "Order.hs" #-} -- "Order.ag"(line 471, column 13) _attrTable = {-# LINE 471 "Order.ag" #-} Array.array (0,_nontsIacount-1) (toList _nontsIntattrs) {-# LINE 1068 "Order.hs" #-} -- "Order.ag"(line 472, column 13) _attrVertex = {-# LINE 472 "Order.ag" #-} Map.fromList (map swap (toList _nontsIntattrs)) {-# LINE 1073 "Order.hs" #-} -- "Order.ag"(line 473, column 13) _tdpToTds = {-# LINE 473 "Order.ag" #-} [ (s, maybe (-1) (\v -> findWithErr1 "Grammar.tdpToTds" v _attrVertex) (ntattr cr)) | (s,cr) <- toList _nontsIrules] {-# LINE 1079 "Order.hs" #-} -- "Order.ag"(line 475, column 13) _tdsToTdp = {-# LINE 475 "Order.ag" #-} let eq (_,v) (_,v') = v == v' conv ((s,v):svs) | v == -1 = Nothing | otherwise = Just (v,s:map fst svs) in mapMaybe conv (eqClasses eq _tdpToTds) {-# LINE 1087 "Order.hs" #-} -- "Order.ag"(line 479, column 13) _directDep = {-# LINE 479 "Order.ag" #-} toList (_nontsIdirectDep Seq.>< _nontsIadditionalDep) {-# LINE 1092 "Order.hs" #-} -- "Order.ag"(line 480, column 13) _instDep = {-# LINE 480 "Order.ag" #-} toList _nontsIinstDep {-# LINE 1097 "Order.hs" #-} -- "Order.ag"(line 481, column 13) _aroundDep = {-# LINE 481 "Order.ag" #-} toList _nontsIaroundDep {-# LINE 1102 "Order.hs" #-} -- "Order.ag"(line 482, column 13) _info = {-# LINE 482 "Order.ag" #-} let def [] = -1 def (v:vs) = v in Info { tdsToTdp = Array.array (0,_nontsIacount-1) _tdsToTdp , tdpToTds = Array.array (0,_nontsIvcount-1) _tdpToTds , attrTable = _attrTable , ruleTable = _ruleTable , lmh = toList _nontsIaranges , nonts = _nontsInonts , wraps = wrappers_ } {-# LINE 1116 "Order.hs" #-} -- "Order.ag"(line 493, column 17) __tup2 = {-# LINE 493 "Order.ag" #-} case computeSequential _info _directDep (_instDep ++ _aroundDep) of CycleFree cim cvm -> ( cim , cvm , [] ) LocalCycle errs -> ( error "No interfaces for AG with local cycles" , error "No visit sub-sequences for AG with local cycles" , map (localCycleErr _ruleTable (visit _lhsIoptions)) errs ) InstCycle errs -> ( error "No interfaces for AG with cycles through insts" , error "No visit sub-sequences for AG with cycles through insts" , map (instCycleErr _ruleTable (visit _lhsIoptions)) errs ) DirectCycle errs -> ( error "No interfaces for AG with direct cycles" , error "No visit sub-sequences for AG with direct cycles" , directCycleErrs _attrTable _ruleTable (visit _lhsIoptions) errs ) InducedCycle cim errs -> ( cim , error "No visit sub-sequences for AG with induced cycles" , inducedCycleErrs _attrTable _ruleTable cim errs ) {-# LINE 1141 "Order.hs" #-} -- "Order.ag"(line 493, column 17) (_cInterfaceMap,_,_) = {-# LINE 493 "Order.ag" #-} __tup2 {-# LINE 1146 "Order.hs" #-} -- "Order.ag"(line 493, column 17) (_,_cVisitsMap,_) = {-# LINE 493 "Order.ag" #-} __tup2 {-# LINE 1151 "Order.hs" #-} -- "Order.ag"(line 493, column 17) (_,_,_cyclesErrors) = {-# LINE 493 "Order.ag" #-} __tup2 {-# LINE 1156 "Order.hs" #-} -- "Order.ag"(line 515, column 13) _lhsOerrors = {-# LINE 515 "Order.ag" #-} (if withCycle _lhsIoptions then Seq.fromList _cyclesErrors else Seq.empty) Seq.>< _nontsIerrors {-# LINE 1162 "Order.hs" #-} -- "Order.ag"(line 547, column 15) _lhsOoutput = {-# LINE 547 "Order.ag" #-} CGrammar typeSyns_ derivings_ wrappers_ _nontsIcNonterminals pragmas_ paramMap_ contextMap_ _aroundMap {-# LINE 1167 "Order.hs" #-} -- "Order.ag"(line 560, column 14) _aroundMap = {-# LINE 560 "Order.ag" #-} Map.map (Map.map Map.keysSet) aroundsMap_ {-# LINE 1172 "Order.hs" #-} -- "Order.ag"(line 577, column 13) _nontsOallnts = {-# LINE 577 "Order.ag" #-} map fst (_nontsInonts) {-# LINE 1177 "Order.hs" #-} -- copy rule (from local) _nontsOcInterfaceMap = {-# LINE 522 "Order.ag" #-} _cInterfaceMap {-# LINE 1182 "Order.hs" #-} -- copy rule (from local) _nontsOcVisitsMap = {-# LINE 529 "Order.ag" #-} _cVisitsMap {-# LINE 1187 "Order.hs" #-} ( _nontsIacount,_nontsIadditionalDep,_nontsIaranges,_nontsIaroundDep,_nontsIcNonterminals,_nontsIdirectDep,_nontsIerrors,_nontsIinstDep,_nontsInonts,_nontsIntattrs,_nontsIrules,_nontsIvcount) = (nonts_ _nontsOacount _nontsOallnts _nontsOaroundMap _nontsOcInterfaceMap _nontsOcVisitsMap _nontsOmanualAttrDepMap _nontsOo_case _nontsOo_cata _nontsOo_data _nontsOo_dovisit _nontsOo_newtypes _nontsOo_rename _nontsOo_sem _nontsOo_sig _nontsOo_unbox _nontsOo_wantvisit _nontsOprefix _nontsOvcount ) in ( _lhsOerrors,_lhsOoutput))) ) -- Nonterminal ------------------------------------------------- {- visit 0: inherited attributes: allnts : [Identifier] aroundMap : Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression])) cInterfaceMap : CInterfaceMap cVisitsMap : CVisitsMap manualAttrDepMap : AttrOrderMap o_case : Bool o_cata : Bool o_data : Bool o_dovisit : Bool o_newtypes : Bool o_rename : Bool o_sem : Bool o_sig : Bool o_unbox : Bool o_wantvisit : Bool prefix : String chained attributes: acount : Int vcount : Int synthesized attributes: additionalDep : Seq Edge aranges : Seq (Int,Int,Int) aroundDep : Seq Edge cNonterminal : CNonterminal directDep : Seq Edge errors : Seq Error instDep : Seq Edge nonts : [(NontermIdent,[ConstructorIdent])] ntattrs : Seq (Vertex,NTAttr) rules : Seq (Vertex,CRule) alternatives: alternative Nonterminal: child nt : {NontermIdent} child params : {[Identifier]} child inh : {Attributes} child syn : {Attributes} child prods : Productions visit 0: local aroundMap : _ local ntattrs : _ local cInter : _ -} -- cata sem_Nonterminal :: Nonterminal -> T_Nonterminal sem_Nonterminal (Nonterminal _nt _params _inh _syn _prods ) = (sem_Nonterminal_Nonterminal _nt _params _inh _syn (sem_Productions _prods ) ) -- semantic domain newtype T_Nonterminal = T_Nonterminal (Int -> ([Identifier]) -> (Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))) -> CInterfaceMap -> CVisitsMap -> AttrOrderMap -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> String -> Int -> ( Int,(Seq Edge),(Seq (Int,Int,Int)),(Seq Edge),CNonterminal,(Seq Edge),(Seq Error),(Seq Edge),([(NontermIdent,[ConstructorIdent])]),(Seq (Vertex,NTAttr)),(Seq (Vertex,CRule)),Int)) data Inh_Nonterminal = Inh_Nonterminal {acount_Inh_Nonterminal :: !(Int),allnts_Inh_Nonterminal :: !([Identifier]),aroundMap_Inh_Nonterminal :: !(Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))),cInterfaceMap_Inh_Nonterminal :: !(CInterfaceMap),cVisitsMap_Inh_Nonterminal :: !(CVisitsMap),manualAttrDepMap_Inh_Nonterminal :: !(AttrOrderMap),o_case_Inh_Nonterminal :: !(Bool),o_cata_Inh_Nonterminal :: !(Bool),o_data_Inh_Nonterminal :: !(Bool),o_dovisit_Inh_Nonterminal :: !(Bool),o_newtypes_Inh_Nonterminal :: !(Bool),o_rename_Inh_Nonterminal :: !(Bool),o_sem_Inh_Nonterminal :: !(Bool),o_sig_Inh_Nonterminal :: !(Bool),o_unbox_Inh_Nonterminal :: !(Bool),o_wantvisit_Inh_Nonterminal :: !(Bool),prefix_Inh_Nonterminal :: !(String),vcount_Inh_Nonterminal :: !(Int)} data Syn_Nonterminal = Syn_Nonterminal {acount_Syn_Nonterminal :: !(Int),additionalDep_Syn_Nonterminal :: !(Seq Edge),aranges_Syn_Nonterminal :: !(Seq (Int,Int,Int)),aroundDep_Syn_Nonterminal :: !(Seq Edge),cNonterminal_Syn_Nonterminal :: !(CNonterminal),directDep_Syn_Nonterminal :: !(Seq Edge),errors_Syn_Nonterminal :: !(Seq Error),instDep_Syn_Nonterminal :: !(Seq Edge),nonts_Syn_Nonterminal :: !([(NontermIdent,[ConstructorIdent])]),ntattrs_Syn_Nonterminal :: !(Seq (Vertex,NTAttr)),rules_Syn_Nonterminal :: !(Seq (Vertex,CRule)),vcount_Syn_Nonterminal :: !(Int)} wrap_Nonterminal :: T_Nonterminal -> Inh_Nonterminal -> Syn_Nonterminal wrap_Nonterminal (T_Nonterminal sem ) (Inh_Nonterminal _lhsIacount _lhsIallnts _lhsIaroundMap _lhsIcInterfaceMap _lhsIcVisitsMap _lhsImanualAttrDepMap _lhsIo_case _lhsIo_cata _lhsIo_data _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_unbox _lhsIo_wantvisit _lhsIprefix _lhsIvcount ) = (let ( _lhsOacount,_lhsOadditionalDep,_lhsOaranges,_lhsOaroundDep,_lhsOcNonterminal,_lhsOdirectDep,_lhsOerrors,_lhsOinstDep,_lhsOnonts,_lhsOntattrs,_lhsOrules,_lhsOvcount) = (sem _lhsIacount _lhsIallnts _lhsIaroundMap _lhsIcInterfaceMap _lhsIcVisitsMap _lhsImanualAttrDepMap _lhsIo_case _lhsIo_cata _lhsIo_data _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_unbox _lhsIo_wantvisit _lhsIprefix _lhsIvcount ) in (Syn_Nonterminal _lhsOacount _lhsOadditionalDep _lhsOaranges _lhsOaroundDep _lhsOcNonterminal _lhsOdirectDep _lhsOerrors _lhsOinstDep _lhsOnonts _lhsOntattrs _lhsOrules _lhsOvcount )) sem_Nonterminal_Nonterminal :: NontermIdent -> ([Identifier]) -> Attributes -> Attributes -> T_Productions -> T_Nonterminal sem_Nonterminal_Nonterminal nt_ params_ inh_ syn_ (T_Productions prods_ ) = (T_Nonterminal (\ _lhsIacount _lhsIallnts _lhsIaroundMap _lhsIcInterfaceMap _lhsIcVisitsMap _lhsImanualAttrDepMap _lhsIo_case _lhsIo_cata _lhsIo_data _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_unbox _lhsIo_wantvisit _lhsIprefix _lhsIvcount -> (let _prodsOnt :: Identifier _prodsOinh :: Attributes _prodsOsyn :: Attributes _lhsOntattrs :: (Seq (Vertex,NTAttr)) _lhsOacount :: Int _lhsOaranges :: (Seq (Int,Int,Int)) _lhsOnonts :: ([(NontermIdent,[ConstructorIdent])]) _lhsOcNonterminal :: CNonterminal _lhsOadditionalDep :: (Seq Edge) _lhsOaroundDep :: (Seq Edge) _lhsOdirectDep :: (Seq Edge) _lhsOerrors :: (Seq Error) _lhsOinstDep :: (Seq Edge) _lhsOrules :: (Seq (Vertex,CRule)) _lhsOvcount :: Int _prodsOallnts :: ([Identifier]) _prodsOaroundMap :: (Map ConstructorIdent (Map Identifier [Expression])) _prodsOcVisitsMap :: CVisitsMap _prodsOmanualAttrDepMap :: AttrOrderMap _prodsOo_case :: Bool _prodsOo_cata :: Bool _prodsOo_dovisit :: Bool _prodsOo_newtypes :: Bool _prodsOo_rename :: Bool _prodsOo_sem :: Bool _prodsOo_sig :: Bool _prodsOo_unbox :: Bool _prodsOo_wantvisit :: Bool _prodsOprefix :: String _prodsOvcount :: Int _prodsIadditionalDep :: (Seq Edge) _prodsIaroundDep :: (Seq Edge) _prodsIcProductions :: CProductions _prodsIcons :: ([ConstructorIdent]) _prodsIdirectDep :: (Seq Edge) _prodsIerrors :: (Seq Error) _prodsIinstDep :: (Seq Edge) _prodsIrules :: (Seq (Vertex,CRule)) _prodsIvcount :: Int -- "Order.ag"(line 77, column 17) _prodsOnt = {-# LINE 77 "Order.ag" #-} nt_ {-# LINE 1339 "Order.hs" #-} -- "Order.ag"(line 80, column 17) _prodsOinh = {-# LINE 80 "Order.ag" #-} inh_ {-# LINE 1344 "Order.hs" #-} -- "Order.ag"(line 81, column 17) _prodsOsyn = {-# LINE 81 "Order.ag" #-} syn_ {-# LINE 1349 "Order.hs" #-} -- "Order.ag"(line 350, column 32) _aroundMap = {-# LINE 350 "Order.ag" #-} Map.findWithDefault Map.empty nt_ _lhsIaroundMap {-# LINE 1354 "Order.hs" #-} -- "Order.ag"(line 435, column 17) _ntattrs = {-# LINE 435 "Order.ag" #-} [ NTAInh nt_ inh tp | (inh,tp) <- Map.assocs inh_ ] ++ [NTASyn nt_ syn tp | (syn,tp) <- Map.assocs syn_ ] {-# LINE 1360 "Order.hs" #-} -- "Order.ag"(line 437, column 17) _lhsOntattrs = {-# LINE 437 "Order.ag" #-} Seq.fromList (zip [_lhsIacount ..] _ntattrs) {-# LINE 1365 "Order.hs" #-} -- "Order.ag"(line 438, column 17) _lhsOacount = {-# LINE 438 "Order.ag" #-} _lhsIacount + Map.size inh_ + Map.size syn_ {-# LINE 1370 "Order.hs" #-} -- "Order.ag"(line 439, column 17) _lhsOaranges = {-# LINE 439 "Order.ag" #-} Seq.singleton (_lhsIacount ,_lhsIacount + Map.size inh_ ,_lhsIacount + Map.size syn_ + Map.size inh_ - 1) {-# LINE 1378 "Order.hs" #-} -- "Order.ag"(line 448, column 19) _lhsOnonts = {-# LINE 448 "Order.ag" #-} [(nt_,_prodsIcons)] {-# LINE 1383 "Order.hs" #-} -- "Order.ag"(line 524, column 19) _cInter = {-# LINE 524 "Order.ag" #-} if _lhsIo_dovisit then findWithErr1 "Nonterminal.cInter" nt_ _lhsIcInterfaceMap else CInterface [CSegment inh_ syn_] {-# LINE 1390 "Order.hs" #-} -- "Order.ag"(line 552, column 19) _lhsOcNonterminal = {-# LINE 552 "Order.ag" #-} CNonterminal nt_ params_ inh_ syn_ _prodsIcProductions _cInter {-# LINE 1395 "Order.hs" #-} -- use rule "Order.ag"(line 263, column 71) _lhsOadditionalDep = {-# LINE 263 "Order.ag" #-} _prodsIadditionalDep {-# LINE 1400 "Order.hs" #-} -- use rule "Order.ag"(line 342, column 24) _lhsOaroundDep = {-# LINE 342 "Order.ag" #-} _prodsIaroundDep {-# LINE 1405 "Order.hs" #-} -- use rule "Order.ag"(line 249, column 33) _lhsOdirectDep = {-# LINE 249 "Order.ag" #-} _prodsIdirectDep {-# LINE 1410 "Order.hs" #-} -- use rule "Order.ag"(line 64, column 70) _lhsOerrors = {-# LINE 64 "Order.ag" #-} _prodsIerrors {-# LINE 1415 "Order.hs" #-} -- use rule "Order.ag"(line 296, column 31) _lhsOinstDep = {-# LINE 296 "Order.ag" #-} _prodsIinstDep {-# LINE 1420 "Order.hs" #-} -- use rule "Order.ag"(line 239, column 18) _lhsOrules = {-# LINE 239 "Order.ag" #-} _prodsIrules {-# LINE 1425 "Order.hs" #-} -- copy rule (up) _lhsOvcount = {-# LINE 238 "Order.ag" #-} _prodsIvcount {-# LINE 1430 "Order.hs" #-} -- copy rule (down) _prodsOallnts = {-# LINE 574 "Order.ag" #-} _lhsIallnts {-# LINE 1435 "Order.hs" #-} -- copy rule (from local) _prodsOaroundMap = {-# LINE 348 "Order.ag" #-} _aroundMap {-# LINE 1440 "Order.hs" #-} -- copy rule (down) _prodsOcVisitsMap = {-# LINE 529 "Order.ag" #-} _lhsIcVisitsMap {-# LINE 1445 "Order.hs" #-} -- copy rule (down) _prodsOmanualAttrDepMap = {-# LINE 263 "Order.ag" #-} _lhsImanualAttrDepMap {-# LINE 1450 "Order.hs" #-} -- copy rule (down) _prodsOo_case = {-# LINE 97 "Order.ag" #-} _lhsIo_case {-# LINE 1455 "Order.hs" #-} -- copy rule (down) _prodsOo_cata = {-# LINE 91 "Order.ag" #-} _lhsIo_cata {-# LINE 1460 "Order.hs" #-} -- copy rule (down) _prodsOo_dovisit = {-# LINE 96 "Order.ag" #-} _lhsIo_dovisit {-# LINE 1465 "Order.hs" #-} -- copy rule (down) _prodsOo_newtypes = {-# LINE 90 "Order.ag" #-} _lhsIo_newtypes {-# LINE 1470 "Order.hs" #-} -- copy rule (down) _prodsOo_rename = {-# LINE 94 "Order.ag" #-} _lhsIo_rename {-# LINE 1475 "Order.hs" #-} -- copy rule (down) _prodsOo_sem = {-# LINE 93 "Order.ag" #-} _lhsIo_sem {-# LINE 1480 "Order.hs" #-} -- copy rule (down) _prodsOo_sig = {-# LINE 92 "Order.ag" #-} _lhsIo_sig {-# LINE 1485 "Order.hs" #-} -- copy rule (down) _prodsOo_unbox = {-# LINE 99 "Order.ag" #-} _lhsIo_unbox {-# LINE 1490 "Order.hs" #-} -- copy rule (down) _prodsOo_wantvisit = {-# LINE 95 "Order.ag" #-} _lhsIo_wantvisit {-# LINE 1495 "Order.hs" #-} -- copy rule (down) _prodsOprefix = {-# LINE 98 "Order.ag" #-} _lhsIprefix {-# LINE 1500 "Order.hs" #-} -- copy rule (down) _prodsOvcount = {-# LINE 238 "Order.ag" #-} _lhsIvcount {-# LINE 1505 "Order.hs" #-} ( _prodsIadditionalDep,_prodsIaroundDep,_prodsIcProductions,_prodsIcons,_prodsIdirectDep,_prodsIerrors,_prodsIinstDep,_prodsIrules,_prodsIvcount) = (prods_ _prodsOallnts _prodsOaroundMap _prodsOcVisitsMap _prodsOinh _prodsOmanualAttrDepMap _prodsOnt _prodsOo_case _prodsOo_cata _prodsOo_dovisit _prodsOo_newtypes _prodsOo_rename _prodsOo_sem _prodsOo_sig _prodsOo_unbox _prodsOo_wantvisit _prodsOprefix _prodsOsyn _prodsOvcount ) in ( _lhsOacount,_lhsOadditionalDep,_lhsOaranges,_lhsOaroundDep,_lhsOcNonterminal,_lhsOdirectDep,_lhsOerrors,_lhsOinstDep,_lhsOnonts,_lhsOntattrs,_lhsOrules,_lhsOvcount))) ) -- Nonterminals ------------------------------------------------ {- visit 0: inherited attributes: allnts : [Identifier] aroundMap : Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression])) cInterfaceMap : CInterfaceMap cVisitsMap : CVisitsMap manualAttrDepMap : AttrOrderMap o_case : Bool o_cata : Bool o_data : Bool o_dovisit : Bool o_newtypes : Bool o_rename : Bool o_sem : Bool o_sig : Bool o_unbox : Bool o_wantvisit : Bool prefix : String chained attributes: acount : Int vcount : Int synthesized attributes: additionalDep : Seq Edge aranges : Seq (Int,Int,Int) aroundDep : Seq Edge cNonterminals : CNonterminals directDep : Seq Edge errors : Seq Error instDep : Seq Edge nonts : [(NontermIdent,[ConstructorIdent])] ntattrs : Seq (Vertex,NTAttr) rules : Seq (Vertex,CRule) alternatives: alternative Cons: child hd : Nonterminal child tl : Nonterminals alternative Nil: -} -- cata sem_Nonterminals :: Nonterminals -> T_Nonterminals sem_Nonterminals list = (Prelude.foldr sem_Nonterminals_Cons sem_Nonterminals_Nil (Prelude.map sem_Nonterminal list) ) -- semantic domain newtype T_Nonterminals = T_Nonterminals (Int -> ([Identifier]) -> (Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))) -> CInterfaceMap -> CVisitsMap -> AttrOrderMap -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> String -> Int -> ( Int,(Seq Edge),(Seq (Int,Int,Int)),(Seq Edge),CNonterminals,(Seq Edge),(Seq Error),(Seq Edge),([(NontermIdent,[ConstructorIdent])]),(Seq (Vertex,NTAttr)),(Seq (Vertex,CRule)),Int)) data Inh_Nonterminals = Inh_Nonterminals {acount_Inh_Nonterminals :: !(Int),allnts_Inh_Nonterminals :: !([Identifier]),aroundMap_Inh_Nonterminals :: !(Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))),cInterfaceMap_Inh_Nonterminals :: !(CInterfaceMap),cVisitsMap_Inh_Nonterminals :: !(CVisitsMap),manualAttrDepMap_Inh_Nonterminals :: !(AttrOrderMap),o_case_Inh_Nonterminals :: !(Bool),o_cata_Inh_Nonterminals :: !(Bool),o_data_Inh_Nonterminals :: !(Bool),o_dovisit_Inh_Nonterminals :: !(Bool),o_newtypes_Inh_Nonterminals :: !(Bool),o_rename_Inh_Nonterminals :: !(Bool),o_sem_Inh_Nonterminals :: !(Bool),o_sig_Inh_Nonterminals :: !(Bool),o_unbox_Inh_Nonterminals :: !(Bool),o_wantvisit_Inh_Nonterminals :: !(Bool),prefix_Inh_Nonterminals :: !(String),vcount_Inh_Nonterminals :: !(Int)} data Syn_Nonterminals = Syn_Nonterminals {acount_Syn_Nonterminals :: !(Int),additionalDep_Syn_Nonterminals :: !(Seq Edge),aranges_Syn_Nonterminals :: !(Seq (Int,Int,Int)),aroundDep_Syn_Nonterminals :: !(Seq Edge),cNonterminals_Syn_Nonterminals :: !(CNonterminals),directDep_Syn_Nonterminals :: !(Seq Edge),errors_Syn_Nonterminals :: !(Seq Error),instDep_Syn_Nonterminals :: !(Seq Edge),nonts_Syn_Nonterminals :: !([(NontermIdent,[ConstructorIdent])]),ntattrs_Syn_Nonterminals :: !(Seq (Vertex,NTAttr)),rules_Syn_Nonterminals :: !(Seq (Vertex,CRule)),vcount_Syn_Nonterminals :: !(Int)} wrap_Nonterminals :: T_Nonterminals -> Inh_Nonterminals -> Syn_Nonterminals wrap_Nonterminals (T_Nonterminals sem ) (Inh_Nonterminals _lhsIacount _lhsIallnts _lhsIaroundMap _lhsIcInterfaceMap _lhsIcVisitsMap _lhsImanualAttrDepMap _lhsIo_case _lhsIo_cata _lhsIo_data _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_unbox _lhsIo_wantvisit _lhsIprefix _lhsIvcount ) = (let ( _lhsOacount,_lhsOadditionalDep,_lhsOaranges,_lhsOaroundDep,_lhsOcNonterminals,_lhsOdirectDep,_lhsOerrors,_lhsOinstDep,_lhsOnonts,_lhsOntattrs,_lhsOrules,_lhsOvcount) = (sem _lhsIacount _lhsIallnts _lhsIaroundMap _lhsIcInterfaceMap _lhsIcVisitsMap _lhsImanualAttrDepMap _lhsIo_case _lhsIo_cata _lhsIo_data _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_unbox _lhsIo_wantvisit _lhsIprefix _lhsIvcount ) in (Syn_Nonterminals _lhsOacount _lhsOadditionalDep _lhsOaranges _lhsOaroundDep _lhsOcNonterminals _lhsOdirectDep _lhsOerrors _lhsOinstDep _lhsOnonts _lhsOntattrs _lhsOrules _lhsOvcount )) sem_Nonterminals_Cons :: T_Nonterminal -> T_Nonterminals -> T_Nonterminals sem_Nonterminals_Cons (T_Nonterminal hd_ ) (T_Nonterminals tl_ ) = (T_Nonterminals (\ _lhsIacount _lhsIallnts _lhsIaroundMap _lhsIcInterfaceMap _lhsIcVisitsMap _lhsImanualAttrDepMap _lhsIo_case _lhsIo_cata _lhsIo_data _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_unbox _lhsIo_wantvisit _lhsIprefix _lhsIvcount -> (let _lhsOcNonterminals :: CNonterminals _lhsOadditionalDep :: (Seq Edge) _lhsOaranges :: (Seq (Int,Int,Int)) _lhsOaroundDep :: (Seq Edge) _lhsOdirectDep :: (Seq Edge) _lhsOerrors :: (Seq Error) _lhsOinstDep :: (Seq Edge) _lhsOnonts :: ([(NontermIdent,[ConstructorIdent])]) _lhsOntattrs :: (Seq (Vertex,NTAttr)) _lhsOrules :: (Seq (Vertex,CRule)) _lhsOacount :: Int _lhsOvcount :: Int _hdOacount :: Int _hdOallnts :: ([Identifier]) _hdOaroundMap :: (Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))) _hdOcInterfaceMap :: CInterfaceMap _hdOcVisitsMap :: CVisitsMap _hdOmanualAttrDepMap :: AttrOrderMap _hdOo_case :: Bool _hdOo_cata :: Bool _hdOo_data :: Bool _hdOo_dovisit :: Bool _hdOo_newtypes :: Bool _hdOo_rename :: Bool _hdOo_sem :: Bool _hdOo_sig :: Bool _hdOo_unbox :: Bool _hdOo_wantvisit :: Bool _hdOprefix :: String _hdOvcount :: Int _tlOacount :: Int _tlOallnts :: ([Identifier]) _tlOaroundMap :: (Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))) _tlOcInterfaceMap :: CInterfaceMap _tlOcVisitsMap :: CVisitsMap _tlOmanualAttrDepMap :: AttrOrderMap _tlOo_case :: Bool _tlOo_cata :: Bool _tlOo_data :: Bool _tlOo_dovisit :: Bool _tlOo_newtypes :: Bool _tlOo_rename :: Bool _tlOo_sem :: Bool _tlOo_sig :: Bool _tlOo_unbox :: Bool _tlOo_wantvisit :: Bool _tlOprefix :: String _tlOvcount :: Int _hdIacount :: Int _hdIadditionalDep :: (Seq Edge) _hdIaranges :: (Seq (Int,Int,Int)) _hdIaroundDep :: (Seq Edge) _hdIcNonterminal :: CNonterminal _hdIdirectDep :: (Seq Edge) _hdIerrors :: (Seq Error) _hdIinstDep :: (Seq Edge) _hdInonts :: ([(NontermIdent,[ConstructorIdent])]) _hdIntattrs :: (Seq (Vertex,NTAttr)) _hdIrules :: (Seq (Vertex,CRule)) _hdIvcount :: Int _tlIacount :: Int _tlIadditionalDep :: (Seq Edge) _tlIaranges :: (Seq (Int,Int,Int)) _tlIaroundDep :: (Seq Edge) _tlIcNonterminals :: CNonterminals _tlIdirectDep :: (Seq Edge) _tlIerrors :: (Seq Error) _tlIinstDep :: (Seq Edge) _tlInonts :: ([(NontermIdent,[ConstructorIdent])]) _tlIntattrs :: (Seq (Vertex,NTAttr)) _tlIrules :: (Seq (Vertex,CRule)) _tlIvcount :: Int -- "Order.ag"(line 549, column 12) _lhsOcNonterminals = {-# LINE 549 "Order.ag" #-} _hdIcNonterminal : _tlIcNonterminals {-# LINE 1681 "Order.hs" #-} -- use rule "Order.ag"(line 263, column 71) _lhsOadditionalDep = {-# LINE 263 "Order.ag" #-} _hdIadditionalDep Seq.>< _tlIadditionalDep {-# LINE 1686 "Order.hs" #-} -- use rule "Order.ag"(line 429, column 36) _lhsOaranges = {-# LINE 429 "Order.ag" #-} _hdIaranges Seq.>< _tlIaranges {-# LINE 1691 "Order.hs" #-} -- use rule "Order.ag"(line 342, column 24) _lhsOaroundDep = {-# LINE 342 "Order.ag" #-} _hdIaroundDep Seq.>< _tlIaroundDep {-# LINE 1696 "Order.hs" #-} -- use rule "Order.ag"(line 249, column 33) _lhsOdirectDep = {-# LINE 249 "Order.ag" #-} _hdIdirectDep Seq.>< _tlIdirectDep {-# LINE 1701 "Order.hs" #-} -- use rule "Order.ag"(line 64, column 70) _lhsOerrors = {-# LINE 64 "Order.ag" #-} _hdIerrors Seq.>< _tlIerrors {-# LINE 1706 "Order.hs" #-} -- use rule "Order.ag"(line 296, column 31) _lhsOinstDep = {-# LINE 296 "Order.ag" #-} _hdIinstDep Seq.>< _tlIinstDep {-# LINE 1711 "Order.hs" #-} -- use rule "Order.ag"(line 446, column 43) _lhsOnonts = {-# LINE 446 "Order.ag" #-} _hdInonts ++ _tlInonts {-# LINE 1716 "Order.hs" #-} -- use rule "Order.ag"(line 428, column 35) _lhsOntattrs = {-# LINE 428 "Order.ag" #-} _hdIntattrs Seq.>< _tlIntattrs {-# LINE 1721 "Order.hs" #-} -- use rule "Order.ag"(line 239, column 18) _lhsOrules = {-# LINE 239 "Order.ag" #-} _hdIrules Seq.>< _tlIrules {-# LINE 1726 "Order.hs" #-} -- copy rule (up) _lhsOacount = {-# LINE 428 "Order.ag" #-} _tlIacount {-# LINE 1731 "Order.hs" #-} -- copy rule (up) _lhsOvcount = {-# LINE 238 "Order.ag" #-} _tlIvcount {-# LINE 1736 "Order.hs" #-} -- copy rule (down) _hdOacount = {-# LINE 428 "Order.ag" #-} _lhsIacount {-# LINE 1741 "Order.hs" #-} -- copy rule (down) _hdOallnts = {-# LINE 574 "Order.ag" #-} _lhsIallnts {-# LINE 1746 "Order.hs" #-} -- copy rule (down) _hdOaroundMap = {-# LINE 345 "Order.ag" #-} _lhsIaroundMap {-# LINE 1751 "Order.hs" #-} -- copy rule (down) _hdOcInterfaceMap = {-# LINE 522 "Order.ag" #-} _lhsIcInterfaceMap {-# LINE 1756 "Order.hs" #-} -- copy rule (down) _hdOcVisitsMap = {-# LINE 529 "Order.ag" #-} _lhsIcVisitsMap {-# LINE 1761 "Order.hs" #-} -- copy rule (down) _hdOmanualAttrDepMap = {-# LINE 263 "Order.ag" #-} _lhsImanualAttrDepMap {-# LINE 1766 "Order.hs" #-} -- copy rule (down) _hdOo_case = {-# LINE 97 "Order.ag" #-} _lhsIo_case {-# LINE 1771 "Order.hs" #-} -- copy rule (down) _hdOo_cata = {-# LINE 91 "Order.ag" #-} _lhsIo_cata {-# LINE 1776 "Order.hs" #-} -- copy rule (down) _hdOo_data = {-# LINE 100 "Order.ag" #-} _lhsIo_data {-# LINE 1781 "Order.hs" #-} -- copy rule (down) _hdOo_dovisit = {-# LINE 96 "Order.ag" #-} _lhsIo_dovisit {-# LINE 1786 "Order.hs" #-} -- copy rule (down) _hdOo_newtypes = {-# LINE 90 "Order.ag" #-} _lhsIo_newtypes {-# LINE 1791 "Order.hs" #-} -- copy rule (down) _hdOo_rename = {-# LINE 94 "Order.ag" #-} _lhsIo_rename {-# LINE 1796 "Order.hs" #-} -- copy rule (down) _hdOo_sem = {-# LINE 93 "Order.ag" #-} _lhsIo_sem {-# LINE 1801 "Order.hs" #-} -- copy rule (down) _hdOo_sig = {-# LINE 92 "Order.ag" #-} _lhsIo_sig {-# LINE 1806 "Order.hs" #-} -- copy rule (down) _hdOo_unbox = {-# LINE 99 "Order.ag" #-} _lhsIo_unbox {-# LINE 1811 "Order.hs" #-} -- copy rule (down) _hdOo_wantvisit = {-# LINE 95 "Order.ag" #-} _lhsIo_wantvisit {-# LINE 1816 "Order.hs" #-} -- copy rule (down) _hdOprefix = {-# LINE 98 "Order.ag" #-} _lhsIprefix {-# LINE 1821 "Order.hs" #-} -- copy rule (down) _hdOvcount = {-# LINE 238 "Order.ag" #-} _lhsIvcount {-# LINE 1826 "Order.hs" #-} -- copy rule (chain) _tlOacount = {-# LINE 428 "Order.ag" #-} _hdIacount {-# LINE 1831 "Order.hs" #-} -- copy rule (down) _tlOallnts = {-# LINE 574 "Order.ag" #-} _lhsIallnts {-# LINE 1836 "Order.hs" #-} -- copy rule (down) _tlOaroundMap = {-# LINE 345 "Order.ag" #-} _lhsIaroundMap {-# LINE 1841 "Order.hs" #-} -- copy rule (down) _tlOcInterfaceMap = {-# LINE 522 "Order.ag" #-} _lhsIcInterfaceMap {-# LINE 1846 "Order.hs" #-} -- copy rule (down) _tlOcVisitsMap = {-# LINE 529 "Order.ag" #-} _lhsIcVisitsMap {-# LINE 1851 "Order.hs" #-} -- copy rule (down) _tlOmanualAttrDepMap = {-# LINE 263 "Order.ag" #-} _lhsImanualAttrDepMap {-# LINE 1856 "Order.hs" #-} -- copy rule (down) _tlOo_case = {-# LINE 97 "Order.ag" #-} _lhsIo_case {-# LINE 1861 "Order.hs" #-} -- copy rule (down) _tlOo_cata = {-# LINE 91 "Order.ag" #-} _lhsIo_cata {-# LINE 1866 "Order.hs" #-} -- copy rule (down) _tlOo_data = {-# LINE 100 "Order.ag" #-} _lhsIo_data {-# LINE 1871 "Order.hs" #-} -- copy rule (down) _tlOo_dovisit = {-# LINE 96 "Order.ag" #-} _lhsIo_dovisit {-# LINE 1876 "Order.hs" #-} -- copy rule (down) _tlOo_newtypes = {-# LINE 90 "Order.ag" #-} _lhsIo_newtypes {-# LINE 1881 "Order.hs" #-} -- copy rule (down) _tlOo_rename = {-# LINE 94 "Order.ag" #-} _lhsIo_rename {-# LINE 1886 "Order.hs" #-} -- copy rule (down) _tlOo_sem = {-# LINE 93 "Order.ag" #-} _lhsIo_sem {-# LINE 1891 "Order.hs" #-} -- copy rule (down) _tlOo_sig = {-# LINE 92 "Order.ag" #-} _lhsIo_sig {-# LINE 1896 "Order.hs" #-} -- copy rule (down) _tlOo_unbox = {-# LINE 99 "Order.ag" #-} _lhsIo_unbox {-# LINE 1901 "Order.hs" #-} -- copy rule (down) _tlOo_wantvisit = {-# LINE 95 "Order.ag" #-} _lhsIo_wantvisit {-# LINE 1906 "Order.hs" #-} -- copy rule (down) _tlOprefix = {-# LINE 98 "Order.ag" #-} _lhsIprefix {-# LINE 1911 "Order.hs" #-} -- copy rule (chain) _tlOvcount = {-# LINE 238 "Order.ag" #-} _hdIvcount {-# LINE 1916 "Order.hs" #-} ( _hdIacount,_hdIadditionalDep,_hdIaranges,_hdIaroundDep,_hdIcNonterminal,_hdIdirectDep,_hdIerrors,_hdIinstDep,_hdInonts,_hdIntattrs,_hdIrules,_hdIvcount) = (hd_ _hdOacount _hdOallnts _hdOaroundMap _hdOcInterfaceMap _hdOcVisitsMap _hdOmanualAttrDepMap _hdOo_case _hdOo_cata _hdOo_data _hdOo_dovisit _hdOo_newtypes _hdOo_rename _hdOo_sem _hdOo_sig _hdOo_unbox _hdOo_wantvisit _hdOprefix _hdOvcount ) ( _tlIacount,_tlIadditionalDep,_tlIaranges,_tlIaroundDep,_tlIcNonterminals,_tlIdirectDep,_tlIerrors,_tlIinstDep,_tlInonts,_tlIntattrs,_tlIrules,_tlIvcount) = (tl_ _tlOacount _tlOallnts _tlOaroundMap _tlOcInterfaceMap _tlOcVisitsMap _tlOmanualAttrDepMap _tlOo_case _tlOo_cata _tlOo_data _tlOo_dovisit _tlOo_newtypes _tlOo_rename _tlOo_sem _tlOo_sig _tlOo_unbox _tlOo_wantvisit _tlOprefix _tlOvcount ) in ( _lhsOacount,_lhsOadditionalDep,_lhsOaranges,_lhsOaroundDep,_lhsOcNonterminals,_lhsOdirectDep,_lhsOerrors,_lhsOinstDep,_lhsOnonts,_lhsOntattrs,_lhsOrules,_lhsOvcount))) ) sem_Nonterminals_Nil :: T_Nonterminals sem_Nonterminals_Nil = (T_Nonterminals (\ _lhsIacount _lhsIallnts _lhsIaroundMap _lhsIcInterfaceMap _lhsIcVisitsMap _lhsImanualAttrDepMap _lhsIo_case _lhsIo_cata _lhsIo_data _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_unbox _lhsIo_wantvisit _lhsIprefix _lhsIvcount -> (let _lhsOcNonterminals :: CNonterminals _lhsOadditionalDep :: (Seq Edge) _lhsOaranges :: (Seq (Int,Int,Int)) _lhsOaroundDep :: (Seq Edge) _lhsOdirectDep :: (Seq Edge) _lhsOerrors :: (Seq Error) _lhsOinstDep :: (Seq Edge) _lhsOnonts :: ([(NontermIdent,[ConstructorIdent])]) _lhsOntattrs :: (Seq (Vertex,NTAttr)) _lhsOrules :: (Seq (Vertex,CRule)) _lhsOacount :: Int _lhsOvcount :: Int -- "Order.ag"(line 550, column 12) _lhsOcNonterminals = {-# LINE 550 "Order.ag" #-} [] {-# LINE 1958 "Order.hs" #-} -- use rule "Order.ag"(line 263, column 71) _lhsOadditionalDep = {-# LINE 263 "Order.ag" #-} Seq.empty {-# LINE 1963 "Order.hs" #-} -- use rule "Order.ag"(line 429, column 36) _lhsOaranges = {-# LINE 429 "Order.ag" #-} Seq.empty {-# LINE 1968 "Order.hs" #-} -- use rule "Order.ag"(line 342, column 24) _lhsOaroundDep = {-# LINE 342 "Order.ag" #-} Seq.empty {-# LINE 1973 "Order.hs" #-} -- use rule "Order.ag"(line 249, column 33) _lhsOdirectDep = {-# LINE 249 "Order.ag" #-} Seq.empty {-# LINE 1978 "Order.hs" #-} -- use rule "Order.ag"(line 64, column 70) _lhsOerrors = {-# LINE 64 "Order.ag" #-} Seq.empty {-# LINE 1983 "Order.hs" #-} -- use rule "Order.ag"(line 296, column 31) _lhsOinstDep = {-# LINE 296 "Order.ag" #-} Seq.empty {-# LINE 1988 "Order.hs" #-} -- use rule "Order.ag"(line 446, column 43) _lhsOnonts = {-# LINE 446 "Order.ag" #-} [] {-# LINE 1993 "Order.hs" #-} -- use rule "Order.ag"(line 428, column 35) _lhsOntattrs = {-# LINE 428 "Order.ag" #-} Seq.empty {-# LINE 1998 "Order.hs" #-} -- use rule "Order.ag"(line 239, column 18) _lhsOrules = {-# LINE 239 "Order.ag" #-} Seq.empty {-# LINE 2003 "Order.hs" #-} -- copy rule (chain) _lhsOacount = {-# LINE 428 "Order.ag" #-} _lhsIacount {-# LINE 2008 "Order.hs" #-} -- copy rule (chain) _lhsOvcount = {-# LINE 238 "Order.ag" #-} _lhsIvcount {-# LINE 2013 "Order.hs" #-} in ( _lhsOacount,_lhsOadditionalDep,_lhsOaranges,_lhsOaroundDep,_lhsOcNonterminals,_lhsOdirectDep,_lhsOerrors,_lhsOinstDep,_lhsOnonts,_lhsOntattrs,_lhsOrules,_lhsOvcount))) ) -- Pattern ----------------------------------------------------- {- visit 0: inherited attributes: allTypeSigs : Map Identifier Type altAttrs : Map AltAttr Vertex con : Identifier inh : Attributes nt : Identifier syn : Attributes synthesized attributes: copy : SELF errors : Seq Error gathAltAttrs : [AltAttr] instVars : [Identifier] locVars : [Identifier] patternAttrs : [(Identifier,Identifier,Bool,Patterns)] 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 ((Map Identifier Type) -> (Map AltAttr Vertex) -> Identifier -> Attributes -> Identifier -> Attributes -> ( Pattern,(Seq Error),([AltAttr]),([Identifier]),([Identifier]),([(Identifier,Identifier,Bool,Patterns)]))) data Inh_Pattern = Inh_Pattern {allTypeSigs_Inh_Pattern :: !(Map Identifier Type),altAttrs_Inh_Pattern :: !(Map AltAttr Vertex),con_Inh_Pattern :: !(Identifier),inh_Inh_Pattern :: !(Attributes),nt_Inh_Pattern :: !(Identifier),syn_Inh_Pattern :: !(Attributes)} data Syn_Pattern = Syn_Pattern {copy_Syn_Pattern :: !(Pattern),errors_Syn_Pattern :: !(Seq Error),gathAltAttrs_Syn_Pattern :: !([AltAttr]),instVars_Syn_Pattern :: !([Identifier]),locVars_Syn_Pattern :: !([Identifier]),patternAttrs_Syn_Pattern :: !([(Identifier,Identifier,Bool,Patterns)])} wrap_Pattern :: T_Pattern -> Inh_Pattern -> Syn_Pattern wrap_Pattern (T_Pattern sem ) (Inh_Pattern _lhsIallTypeSigs _lhsIaltAttrs _lhsIcon _lhsIinh _lhsInt _lhsIsyn ) = (let ( _lhsOcopy,_lhsOerrors,_lhsOgathAltAttrs,_lhsOinstVars,_lhsOlocVars,_lhsOpatternAttrs) = (sem _lhsIallTypeSigs _lhsIaltAttrs _lhsIcon _lhsIinh _lhsInt _lhsIsyn ) in (Syn_Pattern _lhsOcopy _lhsOerrors _lhsOgathAltAttrs _lhsOinstVars _lhsOlocVars _lhsOpatternAttrs )) sem_Pattern_Alias :: Identifier -> Identifier -> T_Pattern -> T_Patterns -> T_Pattern sem_Pattern_Alias field_ attr_ (T_Pattern pat_ ) (T_Patterns parts_ ) = (T_Pattern (\ _lhsIallTypeSigs _lhsIaltAttrs _lhsIcon _lhsIinh _lhsInt _lhsIsyn -> (let _lhsOgathAltAttrs :: ([AltAttr]) _lhsOpatternAttrs :: ([(Identifier,Identifier,Bool,Patterns)]) _lhsOlocVars :: ([Identifier]) _lhsOinstVars :: ([Identifier]) _lhsOerrors :: (Seq Error) _lhsOcopy :: Pattern _patOallTypeSigs :: (Map Identifier Type) _patOaltAttrs :: (Map AltAttr Vertex) _patOcon :: Identifier _patOinh :: Attributes _patOnt :: Identifier _patOsyn :: Attributes _partsOallTypeSigs :: (Map Identifier Type) _partsOaltAttrs :: (Map AltAttr Vertex) _partsOcon :: Identifier _partsOinh :: Attributes _partsOnt :: Identifier _partsOsyn :: Attributes _patIcopy :: Pattern _patIerrors :: (Seq Error) _patIgathAltAttrs :: ([AltAttr]) _patIinstVars :: ([Identifier]) _patIlocVars :: ([Identifier]) _patIpatternAttrs :: ([(Identifier,Identifier,Bool,Patterns)]) _partsIcopy :: Patterns _partsIerrors :: (Seq Error) _partsIgathAltAttrs :: ([AltAttr]) _partsIinstVars :: ([Identifier]) _partsIlocVars :: ([Identifier]) _partsIpatternAttrs :: ([(Identifier,Identifier,Bool,Patterns)]) -- "Order.ag"(line 164, column 12) _lhsOgathAltAttrs = {-# LINE 164 "Order.ag" #-} [AltAttr field_ attr_ (field_ == _LOC || field_ == _INST)] {-# LINE 2135 "Order.hs" #-} -- "Order.ag"(line 232, column 12) _lhsOpatternAttrs = {-# LINE 232 "Order.ag" #-} [(field_,attr_,(field_ == _LOC || field_ == _INST),_partsIcopy)] {-# LINE 2140 "Order.hs" #-} -- "Order.ag"(line 607, column 14) _lhsOlocVars = {-# LINE 607 "Order.ag" #-} if field_ == _LOC then [attr_] else [] {-# LINE 2147 "Order.hs" #-} -- "Order.ag"(line 610, column 14) _lhsOinstVars = {-# LINE 610 "Order.ag" #-} if field_ == _INST then [attr_] else [] {-# LINE 2154 "Order.hs" #-} -- use rule "Order.ag"(line 64, column 70) _lhsOerrors = {-# LINE 64 "Order.ag" #-} _patIerrors Seq.>< _partsIerrors {-# LINE 2159 "Order.hs" #-} -- self rule _copy = {-# LINE 23 "./Patterns.ag" #-} Alias field_ attr_ _patIcopy _partsIcopy {-# LINE 2164 "Order.hs" #-} -- self rule _lhsOcopy = {-# LINE 23 "./Patterns.ag" #-} _copy {-# LINE 2169 "Order.hs" #-} -- copy rule (down) _patOallTypeSigs = {-# LINE 462 "Order.ag" #-} _lhsIallTypeSigs {-# LINE 2174 "Order.hs" #-} -- copy rule (down) _patOaltAttrs = {-# LINE 166 "Order.ag" #-} _lhsIaltAttrs {-# LINE 2179 "Order.hs" #-} -- copy rule (down) _patOcon = {-# LINE 70 "Order.ag" #-} _lhsIcon {-# LINE 2184 "Order.hs" #-} -- copy rule (down) _patOinh = {-# LINE 69 "Order.ag" #-} _lhsIinh {-# LINE 2189 "Order.hs" #-} -- copy rule (down) _patOnt = {-# LINE 69 "Order.ag" #-} _lhsInt {-# LINE 2194 "Order.hs" #-} -- copy rule (down) _patOsyn = {-# LINE 69 "Order.ag" #-} _lhsIsyn {-# LINE 2199 "Order.hs" #-} -- copy rule (down) _partsOallTypeSigs = {-# LINE 462 "Order.ag" #-} _lhsIallTypeSigs {-# LINE 2204 "Order.hs" #-} -- copy rule (down) _partsOaltAttrs = {-# LINE 166 "Order.ag" #-} _lhsIaltAttrs {-# LINE 2209 "Order.hs" #-} -- copy rule (down) _partsOcon = {-# LINE 70 "Order.ag" #-} _lhsIcon {-# LINE 2214 "Order.hs" #-} -- copy rule (down) _partsOinh = {-# LINE 69 "Order.ag" #-} _lhsIinh {-# LINE 2219 "Order.hs" #-} -- copy rule (down) _partsOnt = {-# LINE 69 "Order.ag" #-} _lhsInt {-# LINE 2224 "Order.hs" #-} -- copy rule (down) _partsOsyn = {-# LINE 69 "Order.ag" #-} _lhsIsyn {-# LINE 2229 "Order.hs" #-} ( _patIcopy,_patIerrors,_patIgathAltAttrs,_patIinstVars,_patIlocVars,_patIpatternAttrs) = (pat_ _patOallTypeSigs _patOaltAttrs _patOcon _patOinh _patOnt _patOsyn ) ( _partsIcopy,_partsIerrors,_partsIgathAltAttrs,_partsIinstVars,_partsIlocVars,_partsIpatternAttrs) = (parts_ _partsOallTypeSigs _partsOaltAttrs _partsOcon _partsOinh _partsOnt _partsOsyn ) in ( _lhsOcopy,_lhsOerrors,_lhsOgathAltAttrs,_lhsOinstVars,_lhsOlocVars,_lhsOpatternAttrs))) ) sem_Pattern_Constr :: ConstructorIdent -> T_Patterns -> T_Pattern sem_Pattern_Constr name_ (T_Patterns pats_ ) = (T_Pattern (\ _lhsIallTypeSigs _lhsIaltAttrs _lhsIcon _lhsIinh _lhsInt _lhsIsyn -> (let _lhsOerrors :: (Seq Error) _lhsOgathAltAttrs :: ([AltAttr]) _lhsOinstVars :: ([Identifier]) _lhsOlocVars :: ([Identifier]) _lhsOpatternAttrs :: ([(Identifier,Identifier,Bool,Patterns)]) _lhsOcopy :: Pattern _patsOallTypeSigs :: (Map Identifier Type) _patsOaltAttrs :: (Map AltAttr Vertex) _patsOcon :: Identifier _patsOinh :: Attributes _patsOnt :: Identifier _patsOsyn :: Attributes _patsIcopy :: Patterns _patsIerrors :: (Seq Error) _patsIgathAltAttrs :: ([AltAttr]) _patsIinstVars :: ([Identifier]) _patsIlocVars :: ([Identifier]) _patsIpatternAttrs :: ([(Identifier,Identifier,Bool,Patterns)]) -- use rule "Order.ag"(line 64, column 70) _lhsOerrors = {-# LINE 64 "Order.ag" #-} _patsIerrors {-# LINE 2267 "Order.hs" #-} -- use rule "Order.ag"(line 150, column 68) _lhsOgathAltAttrs = {-# LINE 150 "Order.ag" #-} _patsIgathAltAttrs {-# LINE 2272 "Order.hs" #-} -- use rule "Order.ag"(line 604, column 86) _lhsOinstVars = {-# LINE 604 "Order.ag" #-} _patsIinstVars {-# LINE 2277 "Order.hs" #-} -- use rule "Order.ag"(line 604, column 48) _lhsOlocVars = {-# LINE 604 "Order.ag" #-} _patsIlocVars {-# LINE 2282 "Order.hs" #-} -- use rule "Order.ag"(line 229, column 42) _lhsOpatternAttrs = {-# LINE 229 "Order.ag" #-} _patsIpatternAttrs {-# LINE 2287 "Order.hs" #-} -- self rule _copy = {-# LINE 23 "./Patterns.ag" #-} Constr name_ _patsIcopy {-# LINE 2292 "Order.hs" #-} -- self rule _lhsOcopy = {-# LINE 23 "./Patterns.ag" #-} _copy {-# LINE 2297 "Order.hs" #-} -- copy rule (down) _patsOallTypeSigs = {-# LINE 462 "Order.ag" #-} _lhsIallTypeSigs {-# LINE 2302 "Order.hs" #-} -- copy rule (down) _patsOaltAttrs = {-# LINE 166 "Order.ag" #-} _lhsIaltAttrs {-# LINE 2307 "Order.hs" #-} -- copy rule (down) _patsOcon = {-# LINE 70 "Order.ag" #-} _lhsIcon {-# LINE 2312 "Order.hs" #-} -- copy rule (down) _patsOinh = {-# LINE 69 "Order.ag" #-} _lhsIinh {-# LINE 2317 "Order.hs" #-} -- copy rule (down) _patsOnt = {-# LINE 69 "Order.ag" #-} _lhsInt {-# LINE 2322 "Order.hs" #-} -- copy rule (down) _patsOsyn = {-# LINE 69 "Order.ag" #-} _lhsIsyn {-# LINE 2327 "Order.hs" #-} ( _patsIcopy,_patsIerrors,_patsIgathAltAttrs,_patsIinstVars,_patsIlocVars,_patsIpatternAttrs) = (pats_ _patsOallTypeSigs _patsOaltAttrs _patsOcon _patsOinh _patsOnt _patsOsyn ) in ( _lhsOcopy,_lhsOerrors,_lhsOgathAltAttrs,_lhsOinstVars,_lhsOlocVars,_lhsOpatternAttrs))) ) sem_Pattern_Irrefutable :: T_Pattern -> T_Pattern sem_Pattern_Irrefutable (T_Pattern pat_ ) = (T_Pattern (\ _lhsIallTypeSigs _lhsIaltAttrs _lhsIcon _lhsIinh _lhsInt _lhsIsyn -> (let _lhsOerrors :: (Seq Error) _lhsOgathAltAttrs :: ([AltAttr]) _lhsOinstVars :: ([Identifier]) _lhsOlocVars :: ([Identifier]) _lhsOpatternAttrs :: ([(Identifier,Identifier,Bool,Patterns)]) _lhsOcopy :: Pattern _patOallTypeSigs :: (Map Identifier Type) _patOaltAttrs :: (Map AltAttr Vertex) _patOcon :: Identifier _patOinh :: Attributes _patOnt :: Identifier _patOsyn :: Attributes _patIcopy :: Pattern _patIerrors :: (Seq Error) _patIgathAltAttrs :: ([AltAttr]) _patIinstVars :: ([Identifier]) _patIlocVars :: ([Identifier]) _patIpatternAttrs :: ([(Identifier,Identifier,Bool,Patterns)]) -- use rule "Order.ag"(line 64, column 70) _lhsOerrors = {-# LINE 64 "Order.ag" #-} _patIerrors {-# LINE 2362 "Order.hs" #-} -- use rule "Order.ag"(line 150, column 68) _lhsOgathAltAttrs = {-# LINE 150 "Order.ag" #-} _patIgathAltAttrs {-# LINE 2367 "Order.hs" #-} -- use rule "Order.ag"(line 604, column 86) _lhsOinstVars = {-# LINE 604 "Order.ag" #-} _patIinstVars {-# LINE 2372 "Order.hs" #-} -- use rule "Order.ag"(line 604, column 48) _lhsOlocVars = {-# LINE 604 "Order.ag" #-} _patIlocVars {-# LINE 2377 "Order.hs" #-} -- use rule "Order.ag"(line 229, column 42) _lhsOpatternAttrs = {-# LINE 229 "Order.ag" #-} _patIpatternAttrs {-# LINE 2382 "Order.hs" #-} -- self rule _copy = {-# LINE 23 "./Patterns.ag" #-} Irrefutable _patIcopy {-# LINE 2387 "Order.hs" #-} -- self rule _lhsOcopy = {-# LINE 23 "./Patterns.ag" #-} _copy {-# LINE 2392 "Order.hs" #-} -- copy rule (down) _patOallTypeSigs = {-# LINE 462 "Order.ag" #-} _lhsIallTypeSigs {-# LINE 2397 "Order.hs" #-} -- copy rule (down) _patOaltAttrs = {-# LINE 166 "Order.ag" #-} _lhsIaltAttrs {-# LINE 2402 "Order.hs" #-} -- copy rule (down) _patOcon = {-# LINE 70 "Order.ag" #-} _lhsIcon {-# LINE 2407 "Order.hs" #-} -- copy rule (down) _patOinh = {-# LINE 69 "Order.ag" #-} _lhsIinh {-# LINE 2412 "Order.hs" #-} -- copy rule (down) _patOnt = {-# LINE 69 "Order.ag" #-} _lhsInt {-# LINE 2417 "Order.hs" #-} -- copy rule (down) _patOsyn = {-# LINE 69 "Order.ag" #-} _lhsIsyn {-# LINE 2422 "Order.hs" #-} ( _patIcopy,_patIerrors,_patIgathAltAttrs,_patIinstVars,_patIlocVars,_patIpatternAttrs) = (pat_ _patOallTypeSigs _patOaltAttrs _patOcon _patOinh _patOnt _patOsyn ) in ( _lhsOcopy,_lhsOerrors,_lhsOgathAltAttrs,_lhsOinstVars,_lhsOlocVars,_lhsOpatternAttrs))) ) sem_Pattern_Product :: Pos -> T_Patterns -> T_Pattern sem_Pattern_Product pos_ (T_Patterns pats_ ) = (T_Pattern (\ _lhsIallTypeSigs _lhsIaltAttrs _lhsIcon _lhsIinh _lhsInt _lhsIsyn -> (let _lhsOerrors :: (Seq Error) _lhsOgathAltAttrs :: ([AltAttr]) _lhsOinstVars :: ([Identifier]) _lhsOlocVars :: ([Identifier]) _lhsOpatternAttrs :: ([(Identifier,Identifier,Bool,Patterns)]) _lhsOcopy :: Pattern _patsOallTypeSigs :: (Map Identifier Type) _patsOaltAttrs :: (Map AltAttr Vertex) _patsOcon :: Identifier _patsOinh :: Attributes _patsOnt :: Identifier _patsOsyn :: Attributes _patsIcopy :: Patterns _patsIerrors :: (Seq Error) _patsIgathAltAttrs :: ([AltAttr]) _patsIinstVars :: ([Identifier]) _patsIlocVars :: ([Identifier]) _patsIpatternAttrs :: ([(Identifier,Identifier,Bool,Patterns)]) -- use rule "Order.ag"(line 64, column 70) _lhsOerrors = {-# LINE 64 "Order.ag" #-} _patsIerrors {-# LINE 2458 "Order.hs" #-} -- use rule "Order.ag"(line 150, column 68) _lhsOgathAltAttrs = {-# LINE 150 "Order.ag" #-} _patsIgathAltAttrs {-# LINE 2463 "Order.hs" #-} -- use rule "Order.ag"(line 604, column 86) _lhsOinstVars = {-# LINE 604 "Order.ag" #-} _patsIinstVars {-# LINE 2468 "Order.hs" #-} -- use rule "Order.ag"(line 604, column 48) _lhsOlocVars = {-# LINE 604 "Order.ag" #-} _patsIlocVars {-# LINE 2473 "Order.hs" #-} -- use rule "Order.ag"(line 229, column 42) _lhsOpatternAttrs = {-# LINE 229 "Order.ag" #-} _patsIpatternAttrs {-# LINE 2478 "Order.hs" #-} -- self rule _copy = {-# LINE 23 "./Patterns.ag" #-} Product pos_ _patsIcopy {-# LINE 2483 "Order.hs" #-} -- self rule _lhsOcopy = {-# LINE 23 "./Patterns.ag" #-} _copy {-# LINE 2488 "Order.hs" #-} -- copy rule (down) _patsOallTypeSigs = {-# LINE 462 "Order.ag" #-} _lhsIallTypeSigs {-# LINE 2493 "Order.hs" #-} -- copy rule (down) _patsOaltAttrs = {-# LINE 166 "Order.ag" #-} _lhsIaltAttrs {-# LINE 2498 "Order.hs" #-} -- copy rule (down) _patsOcon = {-# LINE 70 "Order.ag" #-} _lhsIcon {-# LINE 2503 "Order.hs" #-} -- copy rule (down) _patsOinh = {-# LINE 69 "Order.ag" #-} _lhsIinh {-# LINE 2508 "Order.hs" #-} -- copy rule (down) _patsOnt = {-# LINE 69 "Order.ag" #-} _lhsInt {-# LINE 2513 "Order.hs" #-} -- copy rule (down) _patsOsyn = {-# LINE 69 "Order.ag" #-} _lhsIsyn {-# LINE 2518 "Order.hs" #-} ( _patsIcopy,_patsIerrors,_patsIgathAltAttrs,_patsIinstVars,_patsIlocVars,_patsIpatternAttrs) = (pats_ _patsOallTypeSigs _patsOaltAttrs _patsOcon _patsOinh _patsOnt _patsOsyn ) in ( _lhsOcopy,_lhsOerrors,_lhsOgathAltAttrs,_lhsOinstVars,_lhsOlocVars,_lhsOpatternAttrs))) ) sem_Pattern_Underscore :: Pos -> T_Pattern sem_Pattern_Underscore pos_ = (T_Pattern (\ _lhsIallTypeSigs _lhsIaltAttrs _lhsIcon _lhsIinh _lhsInt _lhsIsyn -> (let _lhsOerrors :: (Seq Error) _lhsOgathAltAttrs :: ([AltAttr]) _lhsOinstVars :: ([Identifier]) _lhsOlocVars :: ([Identifier]) _lhsOpatternAttrs :: ([(Identifier,Identifier,Bool,Patterns)]) _lhsOcopy :: Pattern -- use rule "Order.ag"(line 64, column 70) _lhsOerrors = {-# LINE 64 "Order.ag" #-} Seq.empty {-# LINE 2541 "Order.hs" #-} -- use rule "Order.ag"(line 150, column 68) _lhsOgathAltAttrs = {-# LINE 150 "Order.ag" #-} [] {-# LINE 2546 "Order.hs" #-} -- use rule "Order.ag"(line 604, column 86) _lhsOinstVars = {-# LINE 604 "Order.ag" #-} [] {-# LINE 2551 "Order.hs" #-} -- use rule "Order.ag"(line 604, column 48) _lhsOlocVars = {-# LINE 604 "Order.ag" #-} [] {-# LINE 2556 "Order.hs" #-} -- use rule "Order.ag"(line 229, column 42) _lhsOpatternAttrs = {-# LINE 229 "Order.ag" #-} [] {-# LINE 2561 "Order.hs" #-} -- self rule _copy = {-# LINE 23 "./Patterns.ag" #-} Underscore pos_ {-# LINE 2566 "Order.hs" #-} -- self rule _lhsOcopy = {-# LINE 23 "./Patterns.ag" #-} _copy {-# LINE 2571 "Order.hs" #-} in ( _lhsOcopy,_lhsOerrors,_lhsOgathAltAttrs,_lhsOinstVars,_lhsOlocVars,_lhsOpatternAttrs))) ) -- Patterns ---------------------------------------------------- {- visit 0: inherited attributes: allTypeSigs : Map Identifier Type altAttrs : Map AltAttr Vertex con : Identifier inh : Attributes nt : Identifier syn : Attributes synthesized attributes: copy : SELF errors : Seq Error gathAltAttrs : [AltAttr] instVars : [Identifier] locVars : [Identifier] patternAttrs : [(Identifier,Identifier,Bool,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 ((Map Identifier Type) -> (Map AltAttr Vertex) -> Identifier -> Attributes -> Identifier -> Attributes -> ( Patterns,(Seq Error),([AltAttr]),([Identifier]),([Identifier]),([(Identifier,Identifier,Bool,Patterns)]))) data Inh_Patterns = Inh_Patterns {allTypeSigs_Inh_Patterns :: !(Map Identifier Type),altAttrs_Inh_Patterns :: !(Map AltAttr Vertex),con_Inh_Patterns :: !(Identifier),inh_Inh_Patterns :: !(Attributes),nt_Inh_Patterns :: !(Identifier),syn_Inh_Patterns :: !(Attributes)} data Syn_Patterns = Syn_Patterns {copy_Syn_Patterns :: !(Patterns),errors_Syn_Patterns :: !(Seq Error),gathAltAttrs_Syn_Patterns :: !([AltAttr]),instVars_Syn_Patterns :: !([Identifier]),locVars_Syn_Patterns :: !([Identifier]),patternAttrs_Syn_Patterns :: !([(Identifier,Identifier,Bool,Patterns)])} wrap_Patterns :: T_Patterns -> Inh_Patterns -> Syn_Patterns wrap_Patterns (T_Patterns sem ) (Inh_Patterns _lhsIallTypeSigs _lhsIaltAttrs _lhsIcon _lhsIinh _lhsInt _lhsIsyn ) = (let ( _lhsOcopy,_lhsOerrors,_lhsOgathAltAttrs,_lhsOinstVars,_lhsOlocVars,_lhsOpatternAttrs) = (sem _lhsIallTypeSigs _lhsIaltAttrs _lhsIcon _lhsIinh _lhsInt _lhsIsyn ) in (Syn_Patterns _lhsOcopy _lhsOerrors _lhsOgathAltAttrs _lhsOinstVars _lhsOlocVars _lhsOpatternAttrs )) sem_Patterns_Cons :: T_Pattern -> T_Patterns -> T_Patterns sem_Patterns_Cons (T_Pattern hd_ ) (T_Patterns tl_ ) = (T_Patterns (\ _lhsIallTypeSigs _lhsIaltAttrs _lhsIcon _lhsIinh _lhsInt _lhsIsyn -> (let _lhsOerrors :: (Seq Error) _lhsOgathAltAttrs :: ([AltAttr]) _lhsOinstVars :: ([Identifier]) _lhsOlocVars :: ([Identifier]) _lhsOpatternAttrs :: ([(Identifier,Identifier,Bool,Patterns)]) _lhsOcopy :: Patterns _hdOallTypeSigs :: (Map Identifier Type) _hdOaltAttrs :: (Map AltAttr Vertex) _hdOcon :: Identifier _hdOinh :: Attributes _hdOnt :: Identifier _hdOsyn :: Attributes _tlOallTypeSigs :: (Map Identifier Type) _tlOaltAttrs :: (Map AltAttr Vertex) _tlOcon :: Identifier _tlOinh :: Attributes _tlOnt :: Identifier _tlOsyn :: Attributes _hdIcopy :: Pattern _hdIerrors :: (Seq Error) _hdIgathAltAttrs :: ([AltAttr]) _hdIinstVars :: ([Identifier]) _hdIlocVars :: ([Identifier]) _hdIpatternAttrs :: ([(Identifier,Identifier,Bool,Patterns)]) _tlIcopy :: Patterns _tlIerrors :: (Seq Error) _tlIgathAltAttrs :: ([AltAttr]) _tlIinstVars :: ([Identifier]) _tlIlocVars :: ([Identifier]) _tlIpatternAttrs :: ([(Identifier,Identifier,Bool,Patterns)]) -- use rule "Order.ag"(line 64, column 70) _lhsOerrors = {-# LINE 64 "Order.ag" #-} _hdIerrors Seq.>< _tlIerrors {-# LINE 2666 "Order.hs" #-} -- use rule "Order.ag"(line 150, column 68) _lhsOgathAltAttrs = {-# LINE 150 "Order.ag" #-} _hdIgathAltAttrs ++ _tlIgathAltAttrs {-# LINE 2671 "Order.hs" #-} -- use rule "Order.ag"(line 604, column 86) _lhsOinstVars = {-# LINE 604 "Order.ag" #-} _hdIinstVars ++ _tlIinstVars {-# LINE 2676 "Order.hs" #-} -- use rule "Order.ag"(line 604, column 48) _lhsOlocVars = {-# LINE 604 "Order.ag" #-} _hdIlocVars ++ _tlIlocVars {-# LINE 2681 "Order.hs" #-} -- use rule "Order.ag"(line 229, column 42) _lhsOpatternAttrs = {-# LINE 229 "Order.ag" #-} _hdIpatternAttrs ++ _tlIpatternAttrs {-# LINE 2686 "Order.hs" #-} -- self rule _copy = {-# LINE 23 "./Patterns.ag" #-} (:) _hdIcopy _tlIcopy {-# LINE 2691 "Order.hs" #-} -- self rule _lhsOcopy = {-# LINE 23 "./Patterns.ag" #-} _copy {-# LINE 2696 "Order.hs" #-} -- copy rule (down) _hdOallTypeSigs = {-# LINE 462 "Order.ag" #-} _lhsIallTypeSigs {-# LINE 2701 "Order.hs" #-} -- copy rule (down) _hdOaltAttrs = {-# LINE 166 "Order.ag" #-} _lhsIaltAttrs {-# LINE 2706 "Order.hs" #-} -- copy rule (down) _hdOcon = {-# LINE 70 "Order.ag" #-} _lhsIcon {-# LINE 2711 "Order.hs" #-} -- copy rule (down) _hdOinh = {-# LINE 69 "Order.ag" #-} _lhsIinh {-# LINE 2716 "Order.hs" #-} -- copy rule (down) _hdOnt = {-# LINE 69 "Order.ag" #-} _lhsInt {-# LINE 2721 "Order.hs" #-} -- copy rule (down) _hdOsyn = {-# LINE 69 "Order.ag" #-} _lhsIsyn {-# LINE 2726 "Order.hs" #-} -- copy rule (down) _tlOallTypeSigs = {-# LINE 462 "Order.ag" #-} _lhsIallTypeSigs {-# LINE 2731 "Order.hs" #-} -- copy rule (down) _tlOaltAttrs = {-# LINE 166 "Order.ag" #-} _lhsIaltAttrs {-# LINE 2736 "Order.hs" #-} -- copy rule (down) _tlOcon = {-# LINE 70 "Order.ag" #-} _lhsIcon {-# LINE 2741 "Order.hs" #-} -- copy rule (down) _tlOinh = {-# LINE 69 "Order.ag" #-} _lhsIinh {-# LINE 2746 "Order.hs" #-} -- copy rule (down) _tlOnt = {-# LINE 69 "Order.ag" #-} _lhsInt {-# LINE 2751 "Order.hs" #-} -- copy rule (down) _tlOsyn = {-# LINE 69 "Order.ag" #-} _lhsIsyn {-# LINE 2756 "Order.hs" #-} ( _hdIcopy,_hdIerrors,_hdIgathAltAttrs,_hdIinstVars,_hdIlocVars,_hdIpatternAttrs) = (hd_ _hdOallTypeSigs _hdOaltAttrs _hdOcon _hdOinh _hdOnt _hdOsyn ) ( _tlIcopy,_tlIerrors,_tlIgathAltAttrs,_tlIinstVars,_tlIlocVars,_tlIpatternAttrs) = (tl_ _tlOallTypeSigs _tlOaltAttrs _tlOcon _tlOinh _tlOnt _tlOsyn ) in ( _lhsOcopy,_lhsOerrors,_lhsOgathAltAttrs,_lhsOinstVars,_lhsOlocVars,_lhsOpatternAttrs))) ) sem_Patterns_Nil :: T_Patterns sem_Patterns_Nil = (T_Patterns (\ _lhsIallTypeSigs _lhsIaltAttrs _lhsIcon _lhsIinh _lhsInt _lhsIsyn -> (let _lhsOerrors :: (Seq Error) _lhsOgathAltAttrs :: ([AltAttr]) _lhsOinstVars :: ([Identifier]) _lhsOlocVars :: ([Identifier]) _lhsOpatternAttrs :: ([(Identifier,Identifier,Bool,Patterns)]) _lhsOcopy :: Patterns -- use rule "Order.ag"(line 64, column 70) _lhsOerrors = {-# LINE 64 "Order.ag" #-} Seq.empty {-# LINE 2780 "Order.hs" #-} -- use rule "Order.ag"(line 150, column 68) _lhsOgathAltAttrs = {-# LINE 150 "Order.ag" #-} [] {-# LINE 2785 "Order.hs" #-} -- use rule "Order.ag"(line 604, column 86) _lhsOinstVars = {-# LINE 604 "Order.ag" #-} [] {-# LINE 2790 "Order.hs" #-} -- use rule "Order.ag"(line 604, column 48) _lhsOlocVars = {-# LINE 604 "Order.ag" #-} [] {-# LINE 2795 "Order.hs" #-} -- use rule "Order.ag"(line 229, column 42) _lhsOpatternAttrs = {-# LINE 229 "Order.ag" #-} [] {-# LINE 2800 "Order.hs" #-} -- self rule _copy = {-# LINE 23 "./Patterns.ag" #-} [] {-# LINE 2805 "Order.hs" #-} -- self rule _lhsOcopy = {-# LINE 23 "./Patterns.ag" #-} _copy {-# LINE 2810 "Order.hs" #-} in ( _lhsOcopy,_lhsOerrors,_lhsOgathAltAttrs,_lhsOinstVars,_lhsOlocVars,_lhsOpatternAttrs))) ) -- Production -------------------------------------------------- {- visit 0: inherited attributes: allnts : [Identifier] aroundMap : Map ConstructorIdent (Map Identifier [Expression]) cVisitsMap : CVisitsMap inh : Attributes manualAttrDepMap : AttrOrderMap nt : Identifier o_case : Bool o_cata : Bool o_dovisit : Bool o_newtypes : Bool o_rename : Bool o_sem : Bool o_sig : Bool o_unbox : Bool o_wantvisit : Bool prefix : String syn : Attributes chained attribute: vcount : Int synthesized attributes: additionalDep : Seq Edge aroundDep : Seq Edge cProduction : CProduction cons : [ConstructorIdent] directDep : Seq Edge errors : Seq Error instDep : Seq Edge rules : Seq (Vertex,CRule) alternatives: alternative Production: child con : {ConstructorIdent} child children : Children child rules : Rules child typeSigs : TypeSigs visit 0: local gathAltAttrs : _ local altAttrs : _ local inhRules : _ local gathRules : _ local aroundMap : _ local aroundDep1 : _ local aroundDep2 : _ local cVisits : _ local allfields : _ local attrs : _ local inhnames : _ local synnames : _ -} -- cata sem_Production :: Production -> T_Production sem_Production (Production _con _children _rules _typeSigs ) = (sem_Production_Production _con (sem_Children _children ) (sem_Rules _rules ) (sem_TypeSigs _typeSigs ) ) -- semantic domain newtype T_Production = T_Production (([Identifier]) -> (Map ConstructorIdent (Map Identifier [Expression])) -> CVisitsMap -> Attributes -> AttrOrderMap -> Identifier -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> String -> Attributes -> Int -> ( (Seq Edge),(Seq Edge),CProduction,([ConstructorIdent]),(Seq Edge),(Seq Error),(Seq Edge),(Seq (Vertex,CRule)),Int)) data Inh_Production = Inh_Production {allnts_Inh_Production :: !([Identifier]),aroundMap_Inh_Production :: !(Map ConstructorIdent (Map Identifier [Expression])),cVisitsMap_Inh_Production :: !(CVisitsMap),inh_Inh_Production :: !(Attributes),manualAttrDepMap_Inh_Production :: !(AttrOrderMap),nt_Inh_Production :: !(Identifier),o_case_Inh_Production :: !(Bool),o_cata_Inh_Production :: !(Bool),o_dovisit_Inh_Production :: !(Bool),o_newtypes_Inh_Production :: !(Bool),o_rename_Inh_Production :: !(Bool),o_sem_Inh_Production :: !(Bool),o_sig_Inh_Production :: !(Bool),o_unbox_Inh_Production :: !(Bool),o_wantvisit_Inh_Production :: !(Bool),prefix_Inh_Production :: !(String),syn_Inh_Production :: !(Attributes),vcount_Inh_Production :: !(Int)} data Syn_Production = Syn_Production {additionalDep_Syn_Production :: !(Seq Edge),aroundDep_Syn_Production :: !(Seq Edge),cProduction_Syn_Production :: !(CProduction),cons_Syn_Production :: !([ConstructorIdent]),directDep_Syn_Production :: !(Seq Edge),errors_Syn_Production :: !(Seq Error),instDep_Syn_Production :: !(Seq Edge),rules_Syn_Production :: !(Seq (Vertex,CRule)),vcount_Syn_Production :: !(Int)} wrap_Production :: T_Production -> Inh_Production -> Syn_Production wrap_Production (T_Production sem ) (Inh_Production _lhsIallnts _lhsIaroundMap _lhsIcVisitsMap _lhsIinh _lhsImanualAttrDepMap _lhsInt _lhsIo_case _lhsIo_cata _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_unbox _lhsIo_wantvisit _lhsIprefix _lhsIsyn _lhsIvcount ) = (let ( _lhsOadditionalDep,_lhsOaroundDep,_lhsOcProduction,_lhsOcons,_lhsOdirectDep,_lhsOerrors,_lhsOinstDep,_lhsOrules,_lhsOvcount) = (sem _lhsIallnts _lhsIaroundMap _lhsIcVisitsMap _lhsIinh _lhsImanualAttrDepMap _lhsInt _lhsIo_case _lhsIo_cata _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_unbox _lhsIo_wantvisit _lhsIprefix _lhsIsyn _lhsIvcount ) in (Syn_Production _lhsOadditionalDep _lhsOaroundDep _lhsOcProduction _lhsOcons _lhsOdirectDep _lhsOerrors _lhsOinstDep _lhsOrules _lhsOvcount )) sem_Production_Production :: ConstructorIdent -> T_Children -> T_Rules -> T_TypeSigs -> T_Production sem_Production_Production con_ (T_Children children_ ) (T_Rules rules_ ) (T_TypeSigs typeSigs_ ) = (T_Production (\ _lhsIallnts _lhsIaroundMap _lhsIcVisitsMap _lhsIinh _lhsImanualAttrDepMap _lhsInt _lhsIo_case _lhsIo_cata _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_unbox _lhsIo_wantvisit _lhsIprefix _lhsIsyn _lhsIvcount -> (let _childrenOcon :: Identifier _rulesOcon :: Identifier _rulesOchildNts :: (Map Identifier NontermIdent) _rulesOchildInhs :: (Map Identifier Attributes) _lhsOrules :: (Seq (Vertex,CRule)) _lhsOvcount :: Int _rulesOsynsOfChildren :: (Map Identifier Attributes) _rulesOinhsOfChildren :: (Map Identifier Attributes) _lhsOaroundDep :: (Seq Edge) _lhsOcons :: ([ConstructorIdent]) _typeSigsOtypeSigs :: (Map Identifier Type) _rulesOallTypeSigs :: (Map Identifier Type) _lhsOcProduction :: CProduction _lhsOadditionalDep :: (Seq Edge) _lhsOdirectDep :: (Seq Edge) _lhsOerrors :: (Seq Error) _lhsOinstDep :: (Seq Edge) _childrenOallfields :: ([(Identifier,Type,Bool)]) _childrenOallnts :: ([Identifier]) _childrenOattrs :: ([(Identifier,Identifier)]) _childrenOinh :: Attributes _childrenOnt :: Identifier _childrenOo_unbox :: Bool _childrenOsyn :: Attributes _rulesOallfields :: ([(Identifier,Type,Bool)]) _rulesOallnts :: ([Identifier]) _rulesOaltAttrs :: (Map AltAttr Vertex) _rulesOattrs :: ([(Identifier,Identifier)]) _rulesOinh :: Attributes _rulesOmanualAttrDepMap :: AttrOrderMap _rulesOnt :: Identifier _rulesOo_case :: Bool _rulesOo_cata :: Bool _rulesOo_dovisit :: Bool _rulesOo_newtypes :: Bool _rulesOo_rename :: Bool _rulesOo_sem :: Bool _rulesOo_sig :: Bool _rulesOo_wantvisit :: Bool _rulesOprefix :: String _rulesOsyn :: Attributes _childrenIattributes :: ([(Identifier,Attributes,Attributes)]) _childrenIcollectChildrenInhs :: (Map Identifier Attributes ) _childrenIcollectChildrenSyns :: (Map Identifier Attributes ) _childrenIerrors :: (Seq Error) _childrenIfields :: ([(Identifier,Type,Bool)]) _childrenIgathAltAttrs :: ([AltAttr]) _childrenIgathRules :: (Seq CRule) _childrenIinhs :: (Seq (Identifier,Attributes)) _childrenInts :: (Seq (Identifier,NontermIdent)) _childrenIsinglevisits :: ([CRule]) _childrenIterminals :: ([Identifier]) _rulesIadditionalDep :: (Seq Edge) _rulesIdirectDep :: (Seq Edge) _rulesIerrors :: (Seq Error) _rulesIgathAltAttrs :: ([AltAttr]) _rulesIgathRules :: (Seq CRule) _rulesIinstDep :: (Seq Edge) _rulesIinstVars :: ([Identifier]) _rulesIlocVars :: ([Identifier]) _typeSigsItypeSigs :: (Map Identifier Type) -- "Order.ag"(line 73, column 16) _childrenOcon = {-# LINE 73 "Order.ag" #-} con_ {-# LINE 2987 "Order.hs" #-} -- "Order.ag"(line 75, column 16) _rulesOcon = {-# LINE 75 "Order.ag" #-} con_ {-# LINE 2992 "Order.hs" #-} -- "Order.ag"(line 152, column 18) _gathAltAttrs = {-# LINE 152 "Order.ag" #-} [ AltAttr _LHS inh True | inh <- Map.keys _lhsIinh ] ++ _childrenIgathAltAttrs ++ _rulesIgathAltAttrs {-# LINE 2999 "Order.hs" #-} -- "Order.ag"(line 168, column 17) _altAttrs = {-# LINE 168 "Order.ag" #-} Map.fromList (zip _gathAltAttrs [_lhsIvcount..]) {-# LINE 3004 "Order.hs" #-} -- "Order.ag"(line 181, column 18) _rulesOchildNts = {-# LINE 181 "Order.ag" #-} Map.fromList (toList _childrenInts) {-# LINE 3009 "Order.hs" #-} -- "Order.ag"(line 182, column 19) _rulesOchildInhs = {-# LINE 182 "Order.ag" #-} Map.fromList (toList _childrenIinhs) {-# LINE 3014 "Order.hs" #-} -- "Order.ag"(line 188, column 18) _inhRules = {-# LINE 188 "Order.ag" #-} [ cRuleLhsInh inh _lhsInt con_ tp | (inh,tp) <- Map.assocs _lhsIinh ] {-# LINE 3019 "Order.hs" #-} -- "Order.ag"(line 189, column 19) _gathRules = {-# LINE 189 "Order.ag" #-} _inhRules ++ toList (_childrenIgathRules Seq.>< _rulesIgathRules) {-# LINE 3024 "Order.hs" #-} -- "Order.ag"(line 243, column 18) _lhsOrules = {-# LINE 243 "Order.ag" #-} Seq.fromList (zip [_lhsIvcount..] _gathRules) {-# LINE 3029 "Order.hs" #-} -- "Order.ag"(line 244, column 19) _lhsOvcount = {-# LINE 244 "Order.ag" #-} _lhsIvcount + length _gathRules {-# LINE 3034 "Order.hs" #-} -- "Order.ag"(line 325, column 17) _rulesOsynsOfChildren = {-# LINE 325 "Order.ag" #-} _childrenIcollectChildrenSyns {-# LINE 3039 "Order.hs" #-} -- "Order.ag"(line 326, column 17) _rulesOinhsOfChildren = {-# LINE 326 "Order.ag" #-} _childrenIcollectChildrenInhs {-# LINE 3044 "Order.hs" #-} -- "Order.ag"(line 351, column 32) _aroundMap = {-# LINE 351 "Order.ag" #-} Map.findWithDefault Map.empty con_ _lhsIaroundMap {-# LINE 3049 "Order.hs" #-} -- "Order.ag"(line 358, column 6) _aroundDep1 = {-# LINE 358 "Order.ag" #-} Seq.fromList $ [ (childVert, synVert) | childNm <- Map.keys _aroundMap , synNm <- Map.keys (findWithErr2 childNm _childrenIcollectChildrenSyns) , let childNm' = Ident (show childNm ++ "_around") (getPos childNm) childAttr = AltAttr _LOC childNm' True synAttr = AltAttr childNm synNm True childVert = findWithErr2 childAttr _altAttrs synVert = findWithErr2 synAttr _altAttrs ] {-# LINE 3063 "Order.hs" #-} -- "Order.ag"(line 369, column 6) _aroundDep2 = {-# LINE 369 "Order.ag" #-} Seq.fromList $ [ (childVert, inhVert) | childNm <- Map.keys _aroundMap , inhNm <- Map.keys (findWithErr2 childNm _childrenIcollectChildrenInhs) , let childNm' = Ident (show childNm ++ "_around") (getPos childNm) childAttr = AltAttr _LOC childNm' True inhAttr = AltAttr childNm inhNm False childVert = findWithErr2 childAttr _altAttrs inhVert = findWithErr2 inhAttr _altAttrs ] {-# LINE 3077 "Order.hs" #-} -- "Order.ag"(line 380, column 6) _lhsOaroundDep = {-# LINE 380 "Order.ag" #-} _aroundDep1 Seq.>< _aroundDep2 {-# LINE 3082 "Order.hs" #-} -- "Order.ag"(line 451, column 18) _lhsOcons = {-# LINE 451 "Order.ag" #-} [con_] {-# LINE 3087 "Order.hs" #-} -- "Order.ag"(line 458, column 16) _typeSigsOtypeSigs = {-# LINE 458 "Order.ag" #-} Map.empty {-# LINE 3092 "Order.hs" #-} -- "Order.ag"(line 464, column 17) _rulesOallTypeSigs = {-# LINE 464 "Order.ag" #-} _typeSigsItypeSigs {-# LINE 3097 "Order.hs" #-} -- "Order.ag"(line 531, column 17) _cVisits = {-# LINE 531 "Order.ag" #-} if _lhsIo_dovisit then let prodsVisitsMap = findWithErr1 "Production.cVisits.nt" _lhsInt _lhsIcVisitsMap visits = findWithErr1 "Production.cVisits.con" con_ prodsVisitsMap in visits else let vss = nubBy eqCRuleDefines _gathRules ++ _childrenIsinglevisits in [CVisit _lhsIinh _lhsIsyn vss [] False] {-# LINE 3107 "Order.hs" #-} -- "Order.ag"(line 557, column 18) _lhsOcProduction = {-# LINE 557 "Order.ag" #-} CProduction con_ _cVisits _childrenIfields _childrenIterminals {-# LINE 3112 "Order.hs" #-} -- "Order.ag"(line 584, column 16) _allfields = {-# LINE 584 "Order.ag" #-} _childrenIfields {-# LINE 3117 "Order.hs" #-} -- "Order.ag"(line 584, column 16) _attrs = {-# LINE 585 "Order.ag" #-} map ((,) _LOC) _rulesIlocVars ++ map ((,) _INST) _rulesIinstVars ++ map ((,) _LHS) _inhnames ++ concat [map ((,) nm) (Map.keys as) | (nm,_,as) <- _childrenIattributes] {-# LINE 3125 "Order.hs" #-} -- "Order.ag"(line 584, column 16) _inhnames = {-# LINE 589 "Order.ag" #-} Map.keys _lhsIinh {-# LINE 3130 "Order.hs" #-} -- "Order.ag"(line 584, column 16) _synnames = {-# LINE 590 "Order.ag" #-} Map.keys _lhsIsyn {-# LINE 3135 "Order.hs" #-} -- use rule "Order.ag"(line 263, column 71) _lhsOadditionalDep = {-# LINE 263 "Order.ag" #-} _rulesIadditionalDep {-# LINE 3140 "Order.hs" #-} -- use rule "Order.ag"(line 249, column 33) _lhsOdirectDep = {-# LINE 249 "Order.ag" #-} _rulesIdirectDep {-# LINE 3145 "Order.hs" #-} -- use rule "Order.ag"(line 64, column 70) _lhsOerrors = {-# LINE 64 "Order.ag" #-} _childrenIerrors Seq.>< _rulesIerrors {-# LINE 3150 "Order.hs" #-} -- use rule "Order.ag"(line 296, column 31) _lhsOinstDep = {-# LINE 296 "Order.ag" #-} _rulesIinstDep {-# LINE 3155 "Order.hs" #-} -- copy rule (from local) _childrenOallfields = {-# LINE 581 "Order.ag" #-} _allfields {-# LINE 3160 "Order.hs" #-} -- copy rule (down) _childrenOallnts = {-# LINE 574 "Order.ag" #-} _lhsIallnts {-# LINE 3165 "Order.hs" #-} -- copy rule (from local) _childrenOattrs = {-# LINE 581 "Order.ag" #-} _attrs {-# LINE 3170 "Order.hs" #-} -- copy rule (down) _childrenOinh = {-# LINE 69 "Order.ag" #-} _lhsIinh {-# LINE 3175 "Order.hs" #-} -- copy rule (down) _childrenOnt = {-# LINE 69 "Order.ag" #-} _lhsInt {-# LINE 3180 "Order.hs" #-} -- copy rule (down) _childrenOo_unbox = {-# LINE 99 "Order.ag" #-} _lhsIo_unbox {-# LINE 3185 "Order.hs" #-} -- copy rule (down) _childrenOsyn = {-# LINE 69 "Order.ag" #-} _lhsIsyn {-# LINE 3190 "Order.hs" #-} -- copy rule (from local) _rulesOallfields = {-# LINE 581 "Order.ag" #-} _allfields {-# LINE 3195 "Order.hs" #-} -- copy rule (down) _rulesOallnts = {-# LINE 574 "Order.ag" #-} _lhsIallnts {-# LINE 3200 "Order.hs" #-} -- copy rule (from local) _rulesOaltAttrs = {-# LINE 166 "Order.ag" #-} _altAttrs {-# LINE 3205 "Order.hs" #-} -- copy rule (from local) _rulesOattrs = {-# LINE 581 "Order.ag" #-} _attrs {-# LINE 3210 "Order.hs" #-} -- copy rule (down) _rulesOinh = {-# LINE 69 "Order.ag" #-} _lhsIinh {-# LINE 3215 "Order.hs" #-} -- copy rule (down) _rulesOmanualAttrDepMap = {-# LINE 263 "Order.ag" #-} _lhsImanualAttrDepMap {-# LINE 3220 "Order.hs" #-} -- copy rule (down) _rulesOnt = {-# LINE 69 "Order.ag" #-} _lhsInt {-# LINE 3225 "Order.hs" #-} -- copy rule (down) _rulesOo_case = {-# LINE 97 "Order.ag" #-} _lhsIo_case {-# LINE 3230 "Order.hs" #-} -- copy rule (down) _rulesOo_cata = {-# LINE 91 "Order.ag" #-} _lhsIo_cata {-# LINE 3235 "Order.hs" #-} -- copy rule (down) _rulesOo_dovisit = {-# LINE 96 "Order.ag" #-} _lhsIo_dovisit {-# LINE 3240 "Order.hs" #-} -- copy rule (down) _rulesOo_newtypes = {-# LINE 90 "Order.ag" #-} _lhsIo_newtypes {-# LINE 3245 "Order.hs" #-} -- copy rule (down) _rulesOo_rename = {-# LINE 94 "Order.ag" #-} _lhsIo_rename {-# LINE 3250 "Order.hs" #-} -- copy rule (down) _rulesOo_sem = {-# LINE 93 "Order.ag" #-} _lhsIo_sem {-# LINE 3255 "Order.hs" #-} -- copy rule (down) _rulesOo_sig = {-# LINE 92 "Order.ag" #-} _lhsIo_sig {-# LINE 3260 "Order.hs" #-} -- copy rule (down) _rulesOo_wantvisit = {-# LINE 95 "Order.ag" #-} _lhsIo_wantvisit {-# LINE 3265 "Order.hs" #-} -- copy rule (down) _rulesOprefix = {-# LINE 98 "Order.ag" #-} _lhsIprefix {-# LINE 3270 "Order.hs" #-} -- copy rule (down) _rulesOsyn = {-# LINE 69 "Order.ag" #-} _lhsIsyn {-# LINE 3275 "Order.hs" #-} ( _childrenIattributes,_childrenIcollectChildrenInhs,_childrenIcollectChildrenSyns,_childrenIerrors,_childrenIfields,_childrenIgathAltAttrs,_childrenIgathRules,_childrenIinhs,_childrenInts,_childrenIsinglevisits,_childrenIterminals) = (children_ _childrenOallfields _childrenOallnts _childrenOattrs _childrenOcon _childrenOinh _childrenOnt _childrenOo_unbox _childrenOsyn ) ( _rulesIadditionalDep,_rulesIdirectDep,_rulesIerrors,_rulesIgathAltAttrs,_rulesIgathRules,_rulesIinstDep,_rulesIinstVars,_rulesIlocVars) = (rules_ _rulesOallTypeSigs _rulesOallfields _rulesOallnts _rulesOaltAttrs _rulesOattrs _rulesOchildInhs _rulesOchildNts _rulesOcon _rulesOinh _rulesOinhsOfChildren _rulesOmanualAttrDepMap _rulesOnt _rulesOo_case _rulesOo_cata _rulesOo_dovisit _rulesOo_newtypes _rulesOo_rename _rulesOo_sem _rulesOo_sig _rulesOo_wantvisit _rulesOprefix _rulesOsyn _rulesOsynsOfChildren ) ( _typeSigsItypeSigs) = (typeSigs_ _typeSigsOtypeSigs ) in ( _lhsOadditionalDep,_lhsOaroundDep,_lhsOcProduction,_lhsOcons,_lhsOdirectDep,_lhsOerrors,_lhsOinstDep,_lhsOrules,_lhsOvcount))) ) -- Productions ------------------------------------------------- {- visit 0: inherited attributes: allnts : [Identifier] aroundMap : Map ConstructorIdent (Map Identifier [Expression]) cVisitsMap : CVisitsMap inh : Attributes manualAttrDepMap : AttrOrderMap nt : Identifier o_case : Bool o_cata : Bool o_dovisit : Bool o_newtypes : Bool o_rename : Bool o_sem : Bool o_sig : Bool o_unbox : Bool o_wantvisit : Bool prefix : String syn : Attributes chained attribute: vcount : Int synthesized attributes: additionalDep : Seq Edge aroundDep : Seq Edge cProductions : CProductions cons : [ConstructorIdent] directDep : Seq Edge errors : Seq Error instDep : Seq Edge rules : Seq (Vertex,CRule) alternatives: alternative Cons: child hd : Production child tl : Productions alternative Nil: -} -- cata sem_Productions :: Productions -> T_Productions sem_Productions list = (Prelude.foldr sem_Productions_Cons sem_Productions_Nil (Prelude.map sem_Production list) ) -- semantic domain newtype T_Productions = T_Productions (([Identifier]) -> (Map ConstructorIdent (Map Identifier [Expression])) -> CVisitsMap -> Attributes -> AttrOrderMap -> Identifier -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> String -> Attributes -> Int -> ( (Seq Edge),(Seq Edge),CProductions,([ConstructorIdent]),(Seq Edge),(Seq Error),(Seq Edge),(Seq (Vertex,CRule)),Int)) data Inh_Productions = Inh_Productions {allnts_Inh_Productions :: !([Identifier]),aroundMap_Inh_Productions :: !(Map ConstructorIdent (Map Identifier [Expression])),cVisitsMap_Inh_Productions :: !(CVisitsMap),inh_Inh_Productions :: !(Attributes),manualAttrDepMap_Inh_Productions :: !(AttrOrderMap),nt_Inh_Productions :: !(Identifier),o_case_Inh_Productions :: !(Bool),o_cata_Inh_Productions :: !(Bool),o_dovisit_Inh_Productions :: !(Bool),o_newtypes_Inh_Productions :: !(Bool),o_rename_Inh_Productions :: !(Bool),o_sem_Inh_Productions :: !(Bool),o_sig_Inh_Productions :: !(Bool),o_unbox_Inh_Productions :: !(Bool),o_wantvisit_Inh_Productions :: !(Bool),prefix_Inh_Productions :: !(String),syn_Inh_Productions :: !(Attributes),vcount_Inh_Productions :: !(Int)} data Syn_Productions = Syn_Productions {additionalDep_Syn_Productions :: !(Seq Edge),aroundDep_Syn_Productions :: !(Seq Edge),cProductions_Syn_Productions :: !(CProductions),cons_Syn_Productions :: !([ConstructorIdent]),directDep_Syn_Productions :: !(Seq Edge),errors_Syn_Productions :: !(Seq Error),instDep_Syn_Productions :: !(Seq Edge),rules_Syn_Productions :: !(Seq (Vertex,CRule)),vcount_Syn_Productions :: !(Int)} wrap_Productions :: T_Productions -> Inh_Productions -> Syn_Productions wrap_Productions (T_Productions sem ) (Inh_Productions _lhsIallnts _lhsIaroundMap _lhsIcVisitsMap _lhsIinh _lhsImanualAttrDepMap _lhsInt _lhsIo_case _lhsIo_cata _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_unbox _lhsIo_wantvisit _lhsIprefix _lhsIsyn _lhsIvcount ) = (let ( _lhsOadditionalDep,_lhsOaroundDep,_lhsOcProductions,_lhsOcons,_lhsOdirectDep,_lhsOerrors,_lhsOinstDep,_lhsOrules,_lhsOvcount) = (sem _lhsIallnts _lhsIaroundMap _lhsIcVisitsMap _lhsIinh _lhsImanualAttrDepMap _lhsInt _lhsIo_case _lhsIo_cata _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_unbox _lhsIo_wantvisit _lhsIprefix _lhsIsyn _lhsIvcount ) in (Syn_Productions _lhsOadditionalDep _lhsOaroundDep _lhsOcProductions _lhsOcons _lhsOdirectDep _lhsOerrors _lhsOinstDep _lhsOrules _lhsOvcount )) sem_Productions_Cons :: T_Production -> T_Productions -> T_Productions sem_Productions_Cons (T_Production hd_ ) (T_Productions tl_ ) = (T_Productions (\ _lhsIallnts _lhsIaroundMap _lhsIcVisitsMap _lhsIinh _lhsImanualAttrDepMap _lhsInt _lhsIo_case _lhsIo_cata _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_unbox _lhsIo_wantvisit _lhsIprefix _lhsIsyn _lhsIvcount -> (let _lhsOcProductions :: CProductions _lhsOadditionalDep :: (Seq Edge) _lhsOaroundDep :: (Seq Edge) _lhsOcons :: ([ConstructorIdent]) _lhsOdirectDep :: (Seq Edge) _lhsOerrors :: (Seq Error) _lhsOinstDep :: (Seq Edge) _lhsOrules :: (Seq (Vertex,CRule)) _lhsOvcount :: Int _hdOallnts :: ([Identifier]) _hdOaroundMap :: (Map ConstructorIdent (Map Identifier [Expression])) _hdOcVisitsMap :: CVisitsMap _hdOinh :: Attributes _hdOmanualAttrDepMap :: AttrOrderMap _hdOnt :: Identifier _hdOo_case :: Bool _hdOo_cata :: Bool _hdOo_dovisit :: Bool _hdOo_newtypes :: Bool _hdOo_rename :: Bool _hdOo_sem :: Bool _hdOo_sig :: Bool _hdOo_unbox :: Bool _hdOo_wantvisit :: Bool _hdOprefix :: String _hdOsyn :: Attributes _hdOvcount :: Int _tlOallnts :: ([Identifier]) _tlOaroundMap :: (Map ConstructorIdent (Map Identifier [Expression])) _tlOcVisitsMap :: CVisitsMap _tlOinh :: Attributes _tlOmanualAttrDepMap :: AttrOrderMap _tlOnt :: Identifier _tlOo_case :: Bool _tlOo_cata :: Bool _tlOo_dovisit :: Bool _tlOo_newtypes :: Bool _tlOo_rename :: Bool _tlOo_sem :: Bool _tlOo_sig :: Bool _tlOo_unbox :: Bool _tlOo_wantvisit :: Bool _tlOprefix :: String _tlOsyn :: Attributes _tlOvcount :: Int _hdIadditionalDep :: (Seq Edge) _hdIaroundDep :: (Seq Edge) _hdIcProduction :: CProduction _hdIcons :: ([ConstructorIdent]) _hdIdirectDep :: (Seq Edge) _hdIerrors :: (Seq Error) _hdIinstDep :: (Seq Edge) _hdIrules :: (Seq (Vertex,CRule)) _hdIvcount :: Int _tlIadditionalDep :: (Seq Edge) _tlIaroundDep :: (Seq Edge) _tlIcProductions :: CProductions _tlIcons :: ([ConstructorIdent]) _tlIdirectDep :: (Seq Edge) _tlIerrors :: (Seq Error) _tlIinstDep :: (Seq Edge) _tlIrules :: (Seq (Vertex,CRule)) _tlIvcount :: Int -- "Order.ag"(line 554, column 12) _lhsOcProductions = {-# LINE 554 "Order.ag" #-} _hdIcProduction : _tlIcProductions {-# LINE 3444 "Order.hs" #-} -- use rule "Order.ag"(line 263, column 71) _lhsOadditionalDep = {-# LINE 263 "Order.ag" #-} _hdIadditionalDep Seq.>< _tlIadditionalDep {-# LINE 3449 "Order.hs" #-} -- use rule "Order.ag"(line 342, column 24) _lhsOaroundDep = {-# LINE 342 "Order.ag" #-} _hdIaroundDep Seq.>< _tlIaroundDep {-# LINE 3454 "Order.hs" #-} -- use rule "Order.ag"(line 449, column 40) _lhsOcons = {-# LINE 449 "Order.ag" #-} _hdIcons ++ _tlIcons {-# LINE 3459 "Order.hs" #-} -- use rule "Order.ag"(line 249, column 33) _lhsOdirectDep = {-# LINE 249 "Order.ag" #-} _hdIdirectDep Seq.>< _tlIdirectDep {-# LINE 3464 "Order.hs" #-} -- use rule "Order.ag"(line 64, column 70) _lhsOerrors = {-# LINE 64 "Order.ag" #-} _hdIerrors Seq.>< _tlIerrors {-# LINE 3469 "Order.hs" #-} -- use rule "Order.ag"(line 296, column 31) _lhsOinstDep = {-# LINE 296 "Order.ag" #-} _hdIinstDep Seq.>< _tlIinstDep {-# LINE 3474 "Order.hs" #-} -- use rule "Order.ag"(line 239, column 18) _lhsOrules = {-# LINE 239 "Order.ag" #-} _hdIrules Seq.>< _tlIrules {-# LINE 3479 "Order.hs" #-} -- copy rule (up) _lhsOvcount = {-# LINE 238 "Order.ag" #-} _tlIvcount {-# LINE 3484 "Order.hs" #-} -- copy rule (down) _hdOallnts = {-# LINE 574 "Order.ag" #-} _lhsIallnts {-# LINE 3489 "Order.hs" #-} -- copy rule (down) _hdOaroundMap = {-# LINE 348 "Order.ag" #-} _lhsIaroundMap {-# LINE 3494 "Order.hs" #-} -- copy rule (down) _hdOcVisitsMap = {-# LINE 529 "Order.ag" #-} _lhsIcVisitsMap {-# LINE 3499 "Order.hs" #-} -- copy rule (down) _hdOinh = {-# LINE 69 "Order.ag" #-} _lhsIinh {-# LINE 3504 "Order.hs" #-} -- copy rule (down) _hdOmanualAttrDepMap = {-# LINE 263 "Order.ag" #-} _lhsImanualAttrDepMap {-# LINE 3509 "Order.hs" #-} -- copy rule (down) _hdOnt = {-# LINE 69 "Order.ag" #-} _lhsInt {-# LINE 3514 "Order.hs" #-} -- copy rule (down) _hdOo_case = {-# LINE 97 "Order.ag" #-} _lhsIo_case {-# LINE 3519 "Order.hs" #-} -- copy rule (down) _hdOo_cata = {-# LINE 91 "Order.ag" #-} _lhsIo_cata {-# LINE 3524 "Order.hs" #-} -- copy rule (down) _hdOo_dovisit = {-# LINE 96 "Order.ag" #-} _lhsIo_dovisit {-# LINE 3529 "Order.hs" #-} -- copy rule (down) _hdOo_newtypes = {-# LINE 90 "Order.ag" #-} _lhsIo_newtypes {-# LINE 3534 "Order.hs" #-} -- copy rule (down) _hdOo_rename = {-# LINE 94 "Order.ag" #-} _lhsIo_rename {-# LINE 3539 "Order.hs" #-} -- copy rule (down) _hdOo_sem = {-# LINE 93 "Order.ag" #-} _lhsIo_sem {-# LINE 3544 "Order.hs" #-} -- copy rule (down) _hdOo_sig = {-# LINE 92 "Order.ag" #-} _lhsIo_sig {-# LINE 3549 "Order.hs" #-} -- copy rule (down) _hdOo_unbox = {-# LINE 99 "Order.ag" #-} _lhsIo_unbox {-# LINE 3554 "Order.hs" #-} -- copy rule (down) _hdOo_wantvisit = {-# LINE 95 "Order.ag" #-} _lhsIo_wantvisit {-# LINE 3559 "Order.hs" #-} -- copy rule (down) _hdOprefix = {-# LINE 98 "Order.ag" #-} _lhsIprefix {-# LINE 3564 "Order.hs" #-} -- copy rule (down) _hdOsyn = {-# LINE 69 "Order.ag" #-} _lhsIsyn {-# LINE 3569 "Order.hs" #-} -- copy rule (down) _hdOvcount = {-# LINE 238 "Order.ag" #-} _lhsIvcount {-# LINE 3574 "Order.hs" #-} -- copy rule (down) _tlOallnts = {-# LINE 574 "Order.ag" #-} _lhsIallnts {-# LINE 3579 "Order.hs" #-} -- copy rule (down) _tlOaroundMap = {-# LINE 348 "Order.ag" #-} _lhsIaroundMap {-# LINE 3584 "Order.hs" #-} -- copy rule (down) _tlOcVisitsMap = {-# LINE 529 "Order.ag" #-} _lhsIcVisitsMap {-# LINE 3589 "Order.hs" #-} -- copy rule (down) _tlOinh = {-# LINE 69 "Order.ag" #-} _lhsIinh {-# LINE 3594 "Order.hs" #-} -- copy rule (down) _tlOmanualAttrDepMap = {-# LINE 263 "Order.ag" #-} _lhsImanualAttrDepMap {-# LINE 3599 "Order.hs" #-} -- copy rule (down) _tlOnt = {-# LINE 69 "Order.ag" #-} _lhsInt {-# LINE 3604 "Order.hs" #-} -- copy rule (down) _tlOo_case = {-# LINE 97 "Order.ag" #-} _lhsIo_case {-# LINE 3609 "Order.hs" #-} -- copy rule (down) _tlOo_cata = {-# LINE 91 "Order.ag" #-} _lhsIo_cata {-# LINE 3614 "Order.hs" #-} -- copy rule (down) _tlOo_dovisit = {-# LINE 96 "Order.ag" #-} _lhsIo_dovisit {-# LINE 3619 "Order.hs" #-} -- copy rule (down) _tlOo_newtypes = {-# LINE 90 "Order.ag" #-} _lhsIo_newtypes {-# LINE 3624 "Order.hs" #-} -- copy rule (down) _tlOo_rename = {-# LINE 94 "Order.ag" #-} _lhsIo_rename {-# LINE 3629 "Order.hs" #-} -- copy rule (down) _tlOo_sem = {-# LINE 93 "Order.ag" #-} _lhsIo_sem {-# LINE 3634 "Order.hs" #-} -- copy rule (down) _tlOo_sig = {-# LINE 92 "Order.ag" #-} _lhsIo_sig {-# LINE 3639 "Order.hs" #-} -- copy rule (down) _tlOo_unbox = {-# LINE 99 "Order.ag" #-} _lhsIo_unbox {-# LINE 3644 "Order.hs" #-} -- copy rule (down) _tlOo_wantvisit = {-# LINE 95 "Order.ag" #-} _lhsIo_wantvisit {-# LINE 3649 "Order.hs" #-} -- copy rule (down) _tlOprefix = {-# LINE 98 "Order.ag" #-} _lhsIprefix {-# LINE 3654 "Order.hs" #-} -- copy rule (down) _tlOsyn = {-# LINE 69 "Order.ag" #-} _lhsIsyn {-# LINE 3659 "Order.hs" #-} -- copy rule (chain) _tlOvcount = {-# LINE 238 "Order.ag" #-} _hdIvcount {-# LINE 3664 "Order.hs" #-} ( _hdIadditionalDep,_hdIaroundDep,_hdIcProduction,_hdIcons,_hdIdirectDep,_hdIerrors,_hdIinstDep,_hdIrules,_hdIvcount) = (hd_ _hdOallnts _hdOaroundMap _hdOcVisitsMap _hdOinh _hdOmanualAttrDepMap _hdOnt _hdOo_case _hdOo_cata _hdOo_dovisit _hdOo_newtypes _hdOo_rename _hdOo_sem _hdOo_sig _hdOo_unbox _hdOo_wantvisit _hdOprefix _hdOsyn _hdOvcount ) ( _tlIadditionalDep,_tlIaroundDep,_tlIcProductions,_tlIcons,_tlIdirectDep,_tlIerrors,_tlIinstDep,_tlIrules,_tlIvcount) = (tl_ _tlOallnts _tlOaroundMap _tlOcVisitsMap _tlOinh _tlOmanualAttrDepMap _tlOnt _tlOo_case _tlOo_cata _tlOo_dovisit _tlOo_newtypes _tlOo_rename _tlOo_sem _tlOo_sig _tlOo_unbox _tlOo_wantvisit _tlOprefix _tlOsyn _tlOvcount ) in ( _lhsOadditionalDep,_lhsOaroundDep,_lhsOcProductions,_lhsOcons,_lhsOdirectDep,_lhsOerrors,_lhsOinstDep,_lhsOrules,_lhsOvcount))) ) sem_Productions_Nil :: T_Productions sem_Productions_Nil = (T_Productions (\ _lhsIallnts _lhsIaroundMap _lhsIcVisitsMap _lhsIinh _lhsImanualAttrDepMap _lhsInt _lhsIo_case _lhsIo_cata _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_unbox _lhsIo_wantvisit _lhsIprefix _lhsIsyn _lhsIvcount -> (let _lhsOcProductions :: CProductions _lhsOadditionalDep :: (Seq Edge) _lhsOaroundDep :: (Seq Edge) _lhsOcons :: ([ConstructorIdent]) _lhsOdirectDep :: (Seq Edge) _lhsOerrors :: (Seq Error) _lhsOinstDep :: (Seq Edge) _lhsOrules :: (Seq (Vertex,CRule)) _lhsOvcount :: Int -- "Order.ag"(line 555, column 12) _lhsOcProductions = {-# LINE 555 "Order.ag" #-} [] {-# LINE 3703 "Order.hs" #-} -- use rule "Order.ag"(line 263, column 71) _lhsOadditionalDep = {-# LINE 263 "Order.ag" #-} Seq.empty {-# LINE 3708 "Order.hs" #-} -- use rule "Order.ag"(line 342, column 24) _lhsOaroundDep = {-# LINE 342 "Order.ag" #-} Seq.empty {-# LINE 3713 "Order.hs" #-} -- use rule "Order.ag"(line 449, column 40) _lhsOcons = {-# LINE 449 "Order.ag" #-} [] {-# LINE 3718 "Order.hs" #-} -- use rule "Order.ag"(line 249, column 33) _lhsOdirectDep = {-# LINE 249 "Order.ag" #-} Seq.empty {-# LINE 3723 "Order.hs" #-} -- use rule "Order.ag"(line 64, column 70) _lhsOerrors = {-# LINE 64 "Order.ag" #-} Seq.empty {-# LINE 3728 "Order.hs" #-} -- use rule "Order.ag"(line 296, column 31) _lhsOinstDep = {-# LINE 296 "Order.ag" #-} Seq.empty {-# LINE 3733 "Order.hs" #-} -- use rule "Order.ag"(line 239, column 18) _lhsOrules = {-# LINE 239 "Order.ag" #-} Seq.empty {-# LINE 3738 "Order.hs" #-} -- copy rule (chain) _lhsOvcount = {-# LINE 238 "Order.ag" #-} _lhsIvcount {-# LINE 3743 "Order.hs" #-} in ( _lhsOadditionalDep,_lhsOaroundDep,_lhsOcProductions,_lhsOcons,_lhsOdirectDep,_lhsOerrors,_lhsOinstDep,_lhsOrules,_lhsOvcount))) ) -- Rule -------------------------------------------------------- {- visit 0: inherited attributes: allTypeSigs : Map Identifier Type allfields : [(Identifier,Type,Bool)] allnts : [Identifier] altAttrs : Map AltAttr Vertex attrs : [(Identifier,Identifier)] childInhs : Map Identifier Attributes childNts : Map Identifier NontermIdent con : Identifier inh : Attributes inhsOfChildren : Map Identifier Attributes manualAttrDepMap : AttrOrderMap nt : Identifier o_case : Bool o_cata : Bool o_dovisit : Bool o_newtypes : Bool o_rename : Bool o_sem : Bool o_sig : Bool o_wantvisit : Bool prefix : String syn : Attributes synsOfChildren : Map Identifier Attributes synthesized attributes: additionalDep : Seq Edge directDep : Seq Edge errors : Seq Error gathAltAttrs : [AltAttr] gathRules : Seq CRule instDep : Seq Edge instVars : [Identifier] locVars : [Identifier] alternatives: alternative Rule: child pattern : Pattern child rhs : Expression child owrt : {Bool} child origin : {String} visit 0: local defines : _ local gathRules : _ local manualDeps : _ local instDep1 : _ local instDep2 : _ -} -- cata sem_Rule :: Rule -> T_Rule sem_Rule (Rule _pattern _rhs _owrt _origin ) = (sem_Rule_Rule (sem_Pattern _pattern ) (sem_Expression _rhs ) _owrt _origin ) -- semantic domain newtype T_Rule = T_Rule ((Map Identifier Type) -> ([(Identifier,Type,Bool)]) -> ([Identifier]) -> (Map AltAttr Vertex) -> ([(Identifier,Identifier)]) -> (Map Identifier Attributes) -> (Map Identifier NontermIdent) -> Identifier -> Attributes -> (Map Identifier Attributes) -> AttrOrderMap -> Identifier -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> String -> Attributes -> (Map Identifier Attributes) -> ( (Seq Edge),(Seq Edge),(Seq Error),([AltAttr]),(Seq CRule),(Seq Edge),([Identifier]),([Identifier]))) data Inh_Rule = Inh_Rule {allTypeSigs_Inh_Rule :: !(Map Identifier Type),allfields_Inh_Rule :: !([(Identifier,Type,Bool)]),allnts_Inh_Rule :: !([Identifier]),altAttrs_Inh_Rule :: !(Map AltAttr Vertex),attrs_Inh_Rule :: !([(Identifier,Identifier)]),childInhs_Inh_Rule :: !(Map Identifier Attributes),childNts_Inh_Rule :: !(Map Identifier NontermIdent),con_Inh_Rule :: !(Identifier),inh_Inh_Rule :: !(Attributes),inhsOfChildren_Inh_Rule :: !(Map Identifier Attributes),manualAttrDepMap_Inh_Rule :: !(AttrOrderMap),nt_Inh_Rule :: !(Identifier),o_case_Inh_Rule :: !(Bool),o_cata_Inh_Rule :: !(Bool),o_dovisit_Inh_Rule :: !(Bool),o_newtypes_Inh_Rule :: !(Bool),o_rename_Inh_Rule :: !(Bool),o_sem_Inh_Rule :: !(Bool),o_sig_Inh_Rule :: !(Bool),o_wantvisit_Inh_Rule :: !(Bool),prefix_Inh_Rule :: !(String),syn_Inh_Rule :: !(Attributes),synsOfChildren_Inh_Rule :: !(Map Identifier Attributes)} data Syn_Rule = Syn_Rule {additionalDep_Syn_Rule :: !(Seq Edge),directDep_Syn_Rule :: !(Seq Edge),errors_Syn_Rule :: !(Seq Error),gathAltAttrs_Syn_Rule :: !([AltAttr]),gathRules_Syn_Rule :: !(Seq CRule),instDep_Syn_Rule :: !(Seq Edge),instVars_Syn_Rule :: !([Identifier]),locVars_Syn_Rule :: !([Identifier])} wrap_Rule :: T_Rule -> Inh_Rule -> Syn_Rule wrap_Rule (T_Rule sem ) (Inh_Rule _lhsIallTypeSigs _lhsIallfields _lhsIallnts _lhsIaltAttrs _lhsIattrs _lhsIchildInhs _lhsIchildNts _lhsIcon _lhsIinh _lhsIinhsOfChildren _lhsImanualAttrDepMap _lhsInt _lhsIo_case _lhsIo_cata _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_wantvisit _lhsIprefix _lhsIsyn _lhsIsynsOfChildren ) = (let ( _lhsOadditionalDep,_lhsOdirectDep,_lhsOerrors,_lhsOgathAltAttrs,_lhsOgathRules,_lhsOinstDep,_lhsOinstVars,_lhsOlocVars) = (sem _lhsIallTypeSigs _lhsIallfields _lhsIallnts _lhsIaltAttrs _lhsIattrs _lhsIchildInhs _lhsIchildNts _lhsIcon _lhsIinh _lhsIinhsOfChildren _lhsImanualAttrDepMap _lhsInt _lhsIo_case _lhsIo_cata _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_wantvisit _lhsIprefix _lhsIsyn _lhsIsynsOfChildren ) in (Syn_Rule _lhsOadditionalDep _lhsOdirectDep _lhsOerrors _lhsOgathAltAttrs _lhsOgathRules _lhsOinstDep _lhsOinstVars _lhsOlocVars )) sem_Rule_Rule :: T_Pattern -> T_Expression -> Bool -> String -> T_Rule sem_Rule_Rule (T_Pattern pattern_ ) (T_Expression rhs_ ) owrt_ origin_ = (T_Rule (\ _lhsIallTypeSigs _lhsIallfields _lhsIallnts _lhsIaltAttrs _lhsIattrs _lhsIchildInhs _lhsIchildNts _lhsIcon _lhsIinh _lhsIinhsOfChildren _lhsImanualAttrDepMap _lhsInt _lhsIo_case _lhsIo_cata _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_wantvisit _lhsIprefix _lhsIsyn _lhsIsynsOfChildren -> (let _lhsOdirectDep :: (Seq Edge) _lhsOadditionalDep :: (Seq Edge) _lhsOinstDep :: (Seq Edge) _lhsOerrors :: (Seq Error) _lhsOgathAltAttrs :: ([AltAttr]) _lhsOgathRules :: (Seq CRule) _lhsOinstVars :: ([Identifier]) _lhsOlocVars :: ([Identifier]) _patternOallTypeSigs :: (Map Identifier Type) _patternOaltAttrs :: (Map AltAttr Vertex) _patternOcon :: Identifier _patternOinh :: Attributes _patternOnt :: Identifier _patternOsyn :: Attributes _rhsOallfields :: ([(Identifier,Type,Bool)]) _rhsOallnts :: ([Identifier]) _rhsOattrs :: ([(Identifier,Identifier)]) _rhsOcon :: Identifier _rhsOnt :: Identifier _patternIcopy :: Pattern _patternIerrors :: (Seq Error) _patternIgathAltAttrs :: ([AltAttr]) _patternIinstVars :: ([Identifier]) _patternIlocVars :: ([Identifier]) _patternIpatternAttrs :: ([(Identifier,Identifier,Bool,Patterns)]) _rhsIallRhsVars :: (Set (Identifier,Identifier)) _rhsIcopy :: Expression _rhsIerrors :: (Seq Error) _rhsItextLines :: ([String]) _rhsIusedAttrs :: ([(Identifier,Identifier)]) _rhsIusedFields :: ([Identifier]) _rhsIusedLocals :: ([Identifier]) -- "Order.ag"(line 197, column 12) _defines = {-# LINE 197 "Order.ag" #-} let tp field attr parts | field == _LOC || field == _INST = case parts of [] -> Map.lookup attr _lhsIallTypeSigs _ -> (sequence (map typ parts)) >>= (haskellTupel . map (substSelf _lhsInt)) | field == _LHS = Map.lookup attr _lhsIsyn | otherwise = Map.lookup attr (findWithErr1 "Rule.defines.tp" field _lhsIchildInhs) typ :: Pattern -> Maybe Type typ (Alias field attr _ parts) = tp field attr parts typ (Underscore _) = Nothing typ (Product _ pats) = tp _LOC undefined pats typ _ = Nothing in Map.fromList [ (findWithErr1 "Rule.defines" aa _lhsIaltAttrs, (field,attr,(tp field attr parts))) | (field,attr,isLocalOrInst,parts) <- _patternIpatternAttrs , let aa = AltAttr field attr isLocalOrInst ] {-# LINE 3912 "Order.hs" #-} -- "Order.ag"(line 213, column 12) _gathRules = {-# LINE 213 "Order.ag" #-} let childnt field = Map.lookup field _lhsIchildNts in Seq.fromList [ CRule attr False True _lhsInt _lhsIcon field (childnt field) tp _patternIcopy _rhsItextLines _defines owrt_ origin_ _rhsIallRhsVars | (field,attr,tp) <- Map.elems _defines ] {-# LINE 3920 "Order.hs" #-} -- "Order.ag"(line 251, column 12) _lhsOdirectDep = {-# LINE 251 "Order.ag" #-} let defined = Map.keys _defines used = [ Map.lookup (AltAttr field attr True) _lhsIaltAttrs | (field,attr) <- _rhsIusedAttrs] ++ [ Map.lookup (AltAttr _LOC attr True) _lhsIaltAttrs | attr <- _rhsIusedLocals ++ _rhsIusedFields ] in Seq.fromList [ (x,y) | Just x <- used, y <- defined ] {-# LINE 3928 "Order.hs" #-} -- "Order.ag"(line 269, column 7) _manualDeps = {-# LINE 269 "Order.ag" #-} Set.toList $ Map.findWithDefault Set.empty _lhsIcon $ Map.findWithDefault Map.empty _lhsInt _lhsImanualAttrDepMap {-# LINE 3933 "Order.hs" #-} -- "Order.ag"(line 271, column 7) _lhsOadditionalDep = {-# LINE 271 "Order.ag" #-} Seq.fromList [ (vertexA, vertexB) | Dependency (fldA,nmA) (fldB,nmB) <- _manualDeps , let vertexA = findWithErr2 (AltAttr fldA nmA True) _lhsIaltAttrs , vertexB <- lookupVertices fldB nmB _lhsIaltAttrs ] {-# LINE 3942 "Order.hs" #-} -- "Order.ag"(line 299, column 6) _instDep1 = {-# LINE 299 "Order.ag" #-} Seq.fromList $ [ (instVert, synVert) | (field,instNm,_) <- Map.elems _defines , field == _INST , synNm <- Map.keys (findWithErr2 instNm _lhsIsynsOfChildren) , let instAttr = AltAttr _INST instNm True synAttr = AltAttr instNm synNm True instVert = findWithErr2 instAttr _lhsIaltAttrs synVert = findWithErr2 synAttr _lhsIaltAttrs ] {-# LINE 3956 "Order.hs" #-} -- "Order.ag"(line 310, column 6) _instDep2 = {-# LINE 310 "Order.ag" #-} Seq.fromList $ [ (instVert, inhVert) | (field,instNm,_) <- Map.elems _defines , field == _INST , inhNm <- Map.keys (findWithErr2 instNm _lhsIinhsOfChildren) , let instAttr = AltAttr _INST instNm True inhAttr = AltAttr instNm inhNm False instVert = findWithErr2 instAttr _lhsIaltAttrs inhVert = findWithErr2 inhAttr _lhsIaltAttrs ] {-# LINE 3970 "Order.hs" #-} -- "Order.ag"(line 321, column 6) _lhsOinstDep = {-# LINE 321 "Order.ag" #-} _instDep1 Seq.>< _instDep2 {-# LINE 3975 "Order.hs" #-} -- use rule "Order.ag"(line 64, column 70) _lhsOerrors = {-# LINE 64 "Order.ag" #-} _patternIerrors Seq.>< _rhsIerrors {-# LINE 3980 "Order.hs" #-} -- use rule "Order.ag"(line 150, column 68) _lhsOgathAltAttrs = {-# LINE 150 "Order.ag" #-} _patternIgathAltAttrs {-# LINE 3985 "Order.hs" #-} -- use rule "Order.ag"(line 186, column 23) _lhsOgathRules = {-# LINE 186 "Order.ag" #-} _gathRules {-# LINE 3990 "Order.hs" #-} -- use rule "Order.ag"(line 604, column 86) _lhsOinstVars = {-# LINE 604 "Order.ag" #-} _patternIinstVars {-# LINE 3995 "Order.hs" #-} -- use rule "Order.ag"(line 604, column 48) _lhsOlocVars = {-# LINE 604 "Order.ag" #-} _patternIlocVars {-# LINE 4000 "Order.hs" #-} -- copy rule (down) _patternOallTypeSigs = {-# LINE 462 "Order.ag" #-} _lhsIallTypeSigs {-# LINE 4005 "Order.hs" #-} -- copy rule (down) _patternOaltAttrs = {-# LINE 166 "Order.ag" #-} _lhsIaltAttrs {-# LINE 4010 "Order.hs" #-} -- copy rule (down) _patternOcon = {-# LINE 70 "Order.ag" #-} _lhsIcon {-# LINE 4015 "Order.hs" #-} -- copy rule (down) _patternOinh = {-# LINE 69 "Order.ag" #-} _lhsIinh {-# LINE 4020 "Order.hs" #-} -- copy rule (down) _patternOnt = {-# LINE 69 "Order.ag" #-} _lhsInt {-# LINE 4025 "Order.hs" #-} -- copy rule (down) _patternOsyn = {-# LINE 69 "Order.ag" #-} _lhsIsyn {-# LINE 4030 "Order.hs" #-} -- copy rule (down) _rhsOallfields = {-# LINE 386 "Order.ag" #-} _lhsIallfields {-# LINE 4035 "Order.hs" #-} -- copy rule (down) _rhsOallnts = {-# LINE 387 "Order.ag" #-} _lhsIallnts {-# LINE 4040 "Order.hs" #-} -- copy rule (down) _rhsOattrs = {-# LINE 388 "Order.ag" #-} _lhsIattrs {-# LINE 4045 "Order.hs" #-} -- copy rule (down) _rhsOcon = {-# LINE 385 "Order.ag" #-} _lhsIcon {-# LINE 4050 "Order.hs" #-} -- copy rule (down) _rhsOnt = {-# LINE 385 "Order.ag" #-} _lhsInt {-# LINE 4055 "Order.hs" #-} ( _patternIcopy,_patternIerrors,_patternIgathAltAttrs,_patternIinstVars,_patternIlocVars,_patternIpatternAttrs) = (pattern_ _patternOallTypeSigs _patternOaltAttrs _patternOcon _patternOinh _patternOnt _patternOsyn ) ( _rhsIallRhsVars,_rhsIcopy,_rhsIerrors,_rhsItextLines,_rhsIusedAttrs,_rhsIusedFields,_rhsIusedLocals) = (rhs_ _rhsOallfields _rhsOallnts _rhsOattrs _rhsOcon _rhsOnt ) in ( _lhsOadditionalDep,_lhsOdirectDep,_lhsOerrors,_lhsOgathAltAttrs,_lhsOgathRules,_lhsOinstDep,_lhsOinstVars,_lhsOlocVars))) ) -- Rules ------------------------------------------------------- {- visit 0: inherited attributes: allTypeSigs : Map Identifier Type allfields : [(Identifier,Type,Bool)] allnts : [Identifier] altAttrs : Map AltAttr Vertex attrs : [(Identifier,Identifier)] childInhs : Map Identifier Attributes childNts : Map Identifier NontermIdent con : Identifier inh : Attributes inhsOfChildren : Map Identifier Attributes manualAttrDepMap : AttrOrderMap nt : Identifier o_case : Bool o_cata : Bool o_dovisit : Bool o_newtypes : Bool o_rename : Bool o_sem : Bool o_sig : Bool o_wantvisit : Bool prefix : String syn : Attributes synsOfChildren : Map Identifier Attributes synthesized attributes: additionalDep : Seq Edge directDep : Seq Edge errors : Seq Error gathAltAttrs : [AltAttr] gathRules : Seq CRule instDep : Seq Edge instVars : [Identifier] locVars : [Identifier] alternatives: alternative Cons: child hd : Rule child tl : Rules alternative Nil: -} -- cata sem_Rules :: Rules -> T_Rules sem_Rules list = (Prelude.foldr sem_Rules_Cons sem_Rules_Nil (Prelude.map sem_Rule list) ) -- semantic domain newtype T_Rules = T_Rules ((Map Identifier Type) -> ([(Identifier,Type,Bool)]) -> ([Identifier]) -> (Map AltAttr Vertex) -> ([(Identifier,Identifier)]) -> (Map Identifier Attributes) -> (Map Identifier NontermIdent) -> Identifier -> Attributes -> (Map Identifier Attributes) -> AttrOrderMap -> Identifier -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> String -> Attributes -> (Map Identifier Attributes) -> ( (Seq Edge),(Seq Edge),(Seq Error),([AltAttr]),(Seq CRule),(Seq Edge),([Identifier]),([Identifier]))) data Inh_Rules = Inh_Rules {allTypeSigs_Inh_Rules :: !(Map Identifier Type),allfields_Inh_Rules :: !([(Identifier,Type,Bool)]),allnts_Inh_Rules :: !([Identifier]),altAttrs_Inh_Rules :: !(Map AltAttr Vertex),attrs_Inh_Rules :: !([(Identifier,Identifier)]),childInhs_Inh_Rules :: !(Map Identifier Attributes),childNts_Inh_Rules :: !(Map Identifier NontermIdent),con_Inh_Rules :: !(Identifier),inh_Inh_Rules :: !(Attributes),inhsOfChildren_Inh_Rules :: !(Map Identifier Attributes),manualAttrDepMap_Inh_Rules :: !(AttrOrderMap),nt_Inh_Rules :: !(Identifier),o_case_Inh_Rules :: !(Bool),o_cata_Inh_Rules :: !(Bool),o_dovisit_Inh_Rules :: !(Bool),o_newtypes_Inh_Rules :: !(Bool),o_rename_Inh_Rules :: !(Bool),o_sem_Inh_Rules :: !(Bool),o_sig_Inh_Rules :: !(Bool),o_wantvisit_Inh_Rules :: !(Bool),prefix_Inh_Rules :: !(String),syn_Inh_Rules :: !(Attributes),synsOfChildren_Inh_Rules :: !(Map Identifier Attributes)} data Syn_Rules = Syn_Rules {additionalDep_Syn_Rules :: !(Seq Edge),directDep_Syn_Rules :: !(Seq Edge),errors_Syn_Rules :: !(Seq Error),gathAltAttrs_Syn_Rules :: !([AltAttr]),gathRules_Syn_Rules :: !(Seq CRule),instDep_Syn_Rules :: !(Seq Edge),instVars_Syn_Rules :: !([Identifier]),locVars_Syn_Rules :: !([Identifier])} wrap_Rules :: T_Rules -> Inh_Rules -> Syn_Rules wrap_Rules (T_Rules sem ) (Inh_Rules _lhsIallTypeSigs _lhsIallfields _lhsIallnts _lhsIaltAttrs _lhsIattrs _lhsIchildInhs _lhsIchildNts _lhsIcon _lhsIinh _lhsIinhsOfChildren _lhsImanualAttrDepMap _lhsInt _lhsIo_case _lhsIo_cata _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_wantvisit _lhsIprefix _lhsIsyn _lhsIsynsOfChildren ) = (let ( _lhsOadditionalDep,_lhsOdirectDep,_lhsOerrors,_lhsOgathAltAttrs,_lhsOgathRules,_lhsOinstDep,_lhsOinstVars,_lhsOlocVars) = (sem _lhsIallTypeSigs _lhsIallfields _lhsIallnts _lhsIaltAttrs _lhsIattrs _lhsIchildInhs _lhsIchildNts _lhsIcon _lhsIinh _lhsIinhsOfChildren _lhsImanualAttrDepMap _lhsInt _lhsIo_case _lhsIo_cata _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_wantvisit _lhsIprefix _lhsIsyn _lhsIsynsOfChildren ) in (Syn_Rules _lhsOadditionalDep _lhsOdirectDep _lhsOerrors _lhsOgathAltAttrs _lhsOgathRules _lhsOinstDep _lhsOinstVars _lhsOlocVars )) sem_Rules_Cons :: T_Rule -> T_Rules -> T_Rules sem_Rules_Cons (T_Rule hd_ ) (T_Rules tl_ ) = (T_Rules (\ _lhsIallTypeSigs _lhsIallfields _lhsIallnts _lhsIaltAttrs _lhsIattrs _lhsIchildInhs _lhsIchildNts _lhsIcon _lhsIinh _lhsIinhsOfChildren _lhsImanualAttrDepMap _lhsInt _lhsIo_case _lhsIo_cata _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_wantvisit _lhsIprefix _lhsIsyn _lhsIsynsOfChildren -> (let _lhsOadditionalDep :: (Seq Edge) _lhsOdirectDep :: (Seq Edge) _lhsOerrors :: (Seq Error) _lhsOgathAltAttrs :: ([AltAttr]) _lhsOgathRules :: (Seq CRule) _lhsOinstDep :: (Seq Edge) _lhsOinstVars :: ([Identifier]) _lhsOlocVars :: ([Identifier]) _hdOallTypeSigs :: (Map Identifier Type) _hdOallfields :: ([(Identifier,Type,Bool)]) _hdOallnts :: ([Identifier]) _hdOaltAttrs :: (Map AltAttr Vertex) _hdOattrs :: ([(Identifier,Identifier)]) _hdOchildInhs :: (Map Identifier Attributes) _hdOchildNts :: (Map Identifier NontermIdent) _hdOcon :: Identifier _hdOinh :: Attributes _hdOinhsOfChildren :: (Map Identifier Attributes) _hdOmanualAttrDepMap :: AttrOrderMap _hdOnt :: Identifier _hdOo_case :: Bool _hdOo_cata :: Bool _hdOo_dovisit :: Bool _hdOo_newtypes :: Bool _hdOo_rename :: Bool _hdOo_sem :: Bool _hdOo_sig :: Bool _hdOo_wantvisit :: Bool _hdOprefix :: String _hdOsyn :: Attributes _hdOsynsOfChildren :: (Map Identifier Attributes) _tlOallTypeSigs :: (Map Identifier Type) _tlOallfields :: ([(Identifier,Type,Bool)]) _tlOallnts :: ([Identifier]) _tlOaltAttrs :: (Map AltAttr Vertex) _tlOattrs :: ([(Identifier,Identifier)]) _tlOchildInhs :: (Map Identifier Attributes) _tlOchildNts :: (Map Identifier NontermIdent) _tlOcon :: Identifier _tlOinh :: Attributes _tlOinhsOfChildren :: (Map Identifier Attributes) _tlOmanualAttrDepMap :: AttrOrderMap _tlOnt :: Identifier _tlOo_case :: Bool _tlOo_cata :: Bool _tlOo_dovisit :: Bool _tlOo_newtypes :: Bool _tlOo_rename :: Bool _tlOo_sem :: Bool _tlOo_sig :: Bool _tlOo_wantvisit :: Bool _tlOprefix :: String _tlOsyn :: Attributes _tlOsynsOfChildren :: (Map Identifier Attributes) _hdIadditionalDep :: (Seq Edge) _hdIdirectDep :: (Seq Edge) _hdIerrors :: (Seq Error) _hdIgathAltAttrs :: ([AltAttr]) _hdIgathRules :: (Seq CRule) _hdIinstDep :: (Seq Edge) _hdIinstVars :: ([Identifier]) _hdIlocVars :: ([Identifier]) _tlIadditionalDep :: (Seq Edge) _tlIdirectDep :: (Seq Edge) _tlIerrors :: (Seq Error) _tlIgathAltAttrs :: ([AltAttr]) _tlIgathRules :: (Seq CRule) _tlIinstDep :: (Seq Edge) _tlIinstVars :: ([Identifier]) _tlIlocVars :: ([Identifier]) -- use rule "Order.ag"(line 263, column 71) _lhsOadditionalDep = {-# LINE 263 "Order.ag" #-} _hdIadditionalDep Seq.>< _tlIadditionalDep {-# LINE 4243 "Order.hs" #-} -- use rule "Order.ag"(line 249, column 33) _lhsOdirectDep = {-# LINE 249 "Order.ag" #-} _hdIdirectDep Seq.>< _tlIdirectDep {-# LINE 4248 "Order.hs" #-} -- use rule "Order.ag"(line 64, column 70) _lhsOerrors = {-# LINE 64 "Order.ag" #-} _hdIerrors Seq.>< _tlIerrors {-# LINE 4253 "Order.hs" #-} -- use rule "Order.ag"(line 150, column 68) _lhsOgathAltAttrs = {-# LINE 150 "Order.ag" #-} _hdIgathAltAttrs ++ _tlIgathAltAttrs {-# LINE 4258 "Order.hs" #-} -- use rule "Order.ag"(line 186, column 23) _lhsOgathRules = {-# LINE 186 "Order.ag" #-} _hdIgathRules Seq.>< _tlIgathRules {-# LINE 4263 "Order.hs" #-} -- use rule "Order.ag"(line 296, column 31) _lhsOinstDep = {-# LINE 296 "Order.ag" #-} _hdIinstDep Seq.>< _tlIinstDep {-# LINE 4268 "Order.hs" #-} -- use rule "Order.ag"(line 604, column 86) _lhsOinstVars = {-# LINE 604 "Order.ag" #-} _hdIinstVars ++ _tlIinstVars {-# LINE 4273 "Order.hs" #-} -- use rule "Order.ag"(line 604, column 48) _lhsOlocVars = {-# LINE 604 "Order.ag" #-} _hdIlocVars ++ _tlIlocVars {-# LINE 4278 "Order.hs" #-} -- copy rule (down) _hdOallTypeSigs = {-# LINE 462 "Order.ag" #-} _lhsIallTypeSigs {-# LINE 4283 "Order.hs" #-} -- copy rule (down) _hdOallfields = {-# LINE 581 "Order.ag" #-} _lhsIallfields {-# LINE 4288 "Order.hs" #-} -- copy rule (down) _hdOallnts = {-# LINE 574 "Order.ag" #-} _lhsIallnts {-# LINE 4293 "Order.hs" #-} -- copy rule (down) _hdOaltAttrs = {-# LINE 166 "Order.ag" #-} _lhsIaltAttrs {-# LINE 4298 "Order.hs" #-} -- copy rule (down) _hdOattrs = {-# LINE 581 "Order.ag" #-} _lhsIattrs {-# LINE 4303 "Order.hs" #-} -- copy rule (down) _hdOchildInhs = {-# LINE 179 "Order.ag" #-} _lhsIchildInhs {-# LINE 4308 "Order.hs" #-} -- copy rule (down) _hdOchildNts = {-# LINE 178 "Order.ag" #-} _lhsIchildNts {-# LINE 4313 "Order.hs" #-} -- copy rule (down) _hdOcon = {-# LINE 70 "Order.ag" #-} _lhsIcon {-# LINE 4318 "Order.hs" #-} -- copy rule (down) _hdOinh = {-# LINE 69 "Order.ag" #-} _lhsIinh {-# LINE 4323 "Order.hs" #-} -- copy rule (down) _hdOinhsOfChildren = {-# LINE 323 "Order.ag" #-} _lhsIinhsOfChildren {-# LINE 4328 "Order.hs" #-} -- copy rule (down) _hdOmanualAttrDepMap = {-# LINE 263 "Order.ag" #-} _lhsImanualAttrDepMap {-# LINE 4333 "Order.hs" #-} -- copy rule (down) _hdOnt = {-# LINE 69 "Order.ag" #-} _lhsInt {-# LINE 4338 "Order.hs" #-} -- copy rule (down) _hdOo_case = {-# LINE 97 "Order.ag" #-} _lhsIo_case {-# LINE 4343 "Order.hs" #-} -- copy rule (down) _hdOo_cata = {-# LINE 91 "Order.ag" #-} _lhsIo_cata {-# LINE 4348 "Order.hs" #-} -- copy rule (down) _hdOo_dovisit = {-# LINE 96 "Order.ag" #-} _lhsIo_dovisit {-# LINE 4353 "Order.hs" #-} -- copy rule (down) _hdOo_newtypes = {-# LINE 90 "Order.ag" #-} _lhsIo_newtypes {-# LINE 4358 "Order.hs" #-} -- copy rule (down) _hdOo_rename = {-# LINE 94 "Order.ag" #-} _lhsIo_rename {-# LINE 4363 "Order.hs" #-} -- copy rule (down) _hdOo_sem = {-# LINE 93 "Order.ag" #-} _lhsIo_sem {-# LINE 4368 "Order.hs" #-} -- copy rule (down) _hdOo_sig = {-# LINE 92 "Order.ag" #-} _lhsIo_sig {-# LINE 4373 "Order.hs" #-} -- copy rule (down) _hdOo_wantvisit = {-# LINE 95 "Order.ag" #-} _lhsIo_wantvisit {-# LINE 4378 "Order.hs" #-} -- copy rule (down) _hdOprefix = {-# LINE 98 "Order.ag" #-} _lhsIprefix {-# LINE 4383 "Order.hs" #-} -- copy rule (down) _hdOsyn = {-# LINE 69 "Order.ag" #-} _lhsIsyn {-# LINE 4388 "Order.hs" #-} -- copy rule (down) _hdOsynsOfChildren = {-# LINE 323 "Order.ag" #-} _lhsIsynsOfChildren {-# LINE 4393 "Order.hs" #-} -- copy rule (down) _tlOallTypeSigs = {-# LINE 462 "Order.ag" #-} _lhsIallTypeSigs {-# LINE 4398 "Order.hs" #-} -- copy rule (down) _tlOallfields = {-# LINE 581 "Order.ag" #-} _lhsIallfields {-# LINE 4403 "Order.hs" #-} -- copy rule (down) _tlOallnts = {-# LINE 574 "Order.ag" #-} _lhsIallnts {-# LINE 4408 "Order.hs" #-} -- copy rule (down) _tlOaltAttrs = {-# LINE 166 "Order.ag" #-} _lhsIaltAttrs {-# LINE 4413 "Order.hs" #-} -- copy rule (down) _tlOattrs = {-# LINE 581 "Order.ag" #-} _lhsIattrs {-# LINE 4418 "Order.hs" #-} -- copy rule (down) _tlOchildInhs = {-# LINE 179 "Order.ag" #-} _lhsIchildInhs {-# LINE 4423 "Order.hs" #-} -- copy rule (down) _tlOchildNts = {-# LINE 178 "Order.ag" #-} _lhsIchildNts {-# LINE 4428 "Order.hs" #-} -- copy rule (down) _tlOcon = {-# LINE 70 "Order.ag" #-} _lhsIcon {-# LINE 4433 "Order.hs" #-} -- copy rule (down) _tlOinh = {-# LINE 69 "Order.ag" #-} _lhsIinh {-# LINE 4438 "Order.hs" #-} -- copy rule (down) _tlOinhsOfChildren = {-# LINE 323 "Order.ag" #-} _lhsIinhsOfChildren {-# LINE 4443 "Order.hs" #-} -- copy rule (down) _tlOmanualAttrDepMap = {-# LINE 263 "Order.ag" #-} _lhsImanualAttrDepMap {-# LINE 4448 "Order.hs" #-} -- copy rule (down) _tlOnt = {-# LINE 69 "Order.ag" #-} _lhsInt {-# LINE 4453 "Order.hs" #-} -- copy rule (down) _tlOo_case = {-# LINE 97 "Order.ag" #-} _lhsIo_case {-# LINE 4458 "Order.hs" #-} -- copy rule (down) _tlOo_cata = {-# LINE 91 "Order.ag" #-} _lhsIo_cata {-# LINE 4463 "Order.hs" #-} -- copy rule (down) _tlOo_dovisit = {-# LINE 96 "Order.ag" #-} _lhsIo_dovisit {-# LINE 4468 "Order.hs" #-} -- copy rule (down) _tlOo_newtypes = {-# LINE 90 "Order.ag" #-} _lhsIo_newtypes {-# LINE 4473 "Order.hs" #-} -- copy rule (down) _tlOo_rename = {-# LINE 94 "Order.ag" #-} _lhsIo_rename {-# LINE 4478 "Order.hs" #-} -- copy rule (down) _tlOo_sem = {-# LINE 93 "Order.ag" #-} _lhsIo_sem {-# LINE 4483 "Order.hs" #-} -- copy rule (down) _tlOo_sig = {-# LINE 92 "Order.ag" #-} _lhsIo_sig {-# LINE 4488 "Order.hs" #-} -- copy rule (down) _tlOo_wantvisit = {-# LINE 95 "Order.ag" #-} _lhsIo_wantvisit {-# LINE 4493 "Order.hs" #-} -- copy rule (down) _tlOprefix = {-# LINE 98 "Order.ag" #-} _lhsIprefix {-# LINE 4498 "Order.hs" #-} -- copy rule (down) _tlOsyn = {-# LINE 69 "Order.ag" #-} _lhsIsyn {-# LINE 4503 "Order.hs" #-} -- copy rule (down) _tlOsynsOfChildren = {-# LINE 323 "Order.ag" #-} _lhsIsynsOfChildren {-# LINE 4508 "Order.hs" #-} ( _hdIadditionalDep,_hdIdirectDep,_hdIerrors,_hdIgathAltAttrs,_hdIgathRules,_hdIinstDep,_hdIinstVars,_hdIlocVars) = (hd_ _hdOallTypeSigs _hdOallfields _hdOallnts _hdOaltAttrs _hdOattrs _hdOchildInhs _hdOchildNts _hdOcon _hdOinh _hdOinhsOfChildren _hdOmanualAttrDepMap _hdOnt _hdOo_case _hdOo_cata _hdOo_dovisit _hdOo_newtypes _hdOo_rename _hdOo_sem _hdOo_sig _hdOo_wantvisit _hdOprefix _hdOsyn _hdOsynsOfChildren ) ( _tlIadditionalDep,_tlIdirectDep,_tlIerrors,_tlIgathAltAttrs,_tlIgathRules,_tlIinstDep,_tlIinstVars,_tlIlocVars) = (tl_ _tlOallTypeSigs _tlOallfields _tlOallnts _tlOaltAttrs _tlOattrs _tlOchildInhs _tlOchildNts _tlOcon _tlOinh _tlOinhsOfChildren _tlOmanualAttrDepMap _tlOnt _tlOo_case _tlOo_cata _tlOo_dovisit _tlOo_newtypes _tlOo_rename _tlOo_sem _tlOo_sig _tlOo_wantvisit _tlOprefix _tlOsyn _tlOsynsOfChildren ) in ( _lhsOadditionalDep,_lhsOdirectDep,_lhsOerrors,_lhsOgathAltAttrs,_lhsOgathRules,_lhsOinstDep,_lhsOinstVars,_lhsOlocVars))) ) sem_Rules_Nil :: T_Rules sem_Rules_Nil = (T_Rules (\ _lhsIallTypeSigs _lhsIallfields _lhsIallnts _lhsIaltAttrs _lhsIattrs _lhsIchildInhs _lhsIchildNts _lhsIcon _lhsIinh _lhsIinhsOfChildren _lhsImanualAttrDepMap _lhsInt _lhsIo_case _lhsIo_cata _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_wantvisit _lhsIprefix _lhsIsyn _lhsIsynsOfChildren -> (let _lhsOadditionalDep :: (Seq Edge) _lhsOdirectDep :: (Seq Edge) _lhsOerrors :: (Seq Error) _lhsOgathAltAttrs :: ([AltAttr]) _lhsOgathRules :: (Seq CRule) _lhsOinstDep :: (Seq Edge) _lhsOinstVars :: ([Identifier]) _lhsOlocVars :: ([Identifier]) -- use rule "Order.ag"(line 263, column 71) _lhsOadditionalDep = {-# LINE 263 "Order.ag" #-} Seq.empty {-# LINE 4551 "Order.hs" #-} -- use rule "Order.ag"(line 249, column 33) _lhsOdirectDep = {-# LINE 249 "Order.ag" #-} Seq.empty {-# LINE 4556 "Order.hs" #-} -- use rule "Order.ag"(line 64, column 70) _lhsOerrors = {-# LINE 64 "Order.ag" #-} Seq.empty {-# LINE 4561 "Order.hs" #-} -- use rule "Order.ag"(line 150, column 68) _lhsOgathAltAttrs = {-# LINE 150 "Order.ag" #-} [] {-# LINE 4566 "Order.hs" #-} -- use rule "Order.ag"(line 186, column 23) _lhsOgathRules = {-# LINE 186 "Order.ag" #-} Seq.empty {-# LINE 4571 "Order.hs" #-} -- use rule "Order.ag"(line 296, column 31) _lhsOinstDep = {-# LINE 296 "Order.ag" #-} Seq.empty {-# LINE 4576 "Order.hs" #-} -- use rule "Order.ag"(line 604, column 86) _lhsOinstVars = {-# LINE 604 "Order.ag" #-} [] {-# LINE 4581 "Order.hs" #-} -- use rule "Order.ag"(line 604, column 48) _lhsOlocVars = {-# LINE 604 "Order.ag" #-} [] {-# LINE 4586 "Order.hs" #-} in ( _lhsOadditionalDep,_lhsOdirectDep,_lhsOerrors,_lhsOgathAltAttrs,_lhsOgathRules,_lhsOinstDep,_lhsOinstVars,_lhsOlocVars))) ) -- TypeSig ----------------------------------------------------- {- visit 0: chained attribute: typeSigs : Map Identifier Type alternatives: alternative TypeSig: child name : {Identifier} child tp : {Type} -} -- cata sem_TypeSig :: TypeSig -> T_TypeSig sem_TypeSig (TypeSig _name _tp ) = (sem_TypeSig_TypeSig _name _tp ) -- semantic domain newtype T_TypeSig = T_TypeSig ((Map Identifier Type) -> ( (Map Identifier Type))) data Inh_TypeSig = Inh_TypeSig {typeSigs_Inh_TypeSig :: !(Map Identifier Type)} data Syn_TypeSig = Syn_TypeSig {typeSigs_Syn_TypeSig :: !(Map Identifier Type)} wrap_TypeSig :: T_TypeSig -> Inh_TypeSig -> Syn_TypeSig wrap_TypeSig (T_TypeSig sem ) (Inh_TypeSig _lhsItypeSigs ) = (let ( _lhsOtypeSigs) = (sem _lhsItypeSigs ) in (Syn_TypeSig _lhsOtypeSigs )) sem_TypeSig_TypeSig :: Identifier -> Type -> T_TypeSig sem_TypeSig_TypeSig name_ tp_ = (T_TypeSig (\ _lhsItypeSigs -> (let _lhsOtypeSigs :: (Map Identifier Type) -- "Order.ag"(line 460, column 13) _lhsOtypeSigs = {-# LINE 460 "Order.ag" #-} Map.insert name_ tp_ _lhsItypeSigs {-# LINE 4625 "Order.hs" #-} in ( _lhsOtypeSigs))) ) -- TypeSigs ---------------------------------------------------- {- visit 0: chained attribute: typeSigs : Map Identifier Type alternatives: alternative Cons: child hd : TypeSig child tl : TypeSigs alternative Nil: -} -- cata sem_TypeSigs :: TypeSigs -> T_TypeSigs sem_TypeSigs list = (Prelude.foldr sem_TypeSigs_Cons sem_TypeSigs_Nil (Prelude.map sem_TypeSig list) ) -- semantic domain newtype T_TypeSigs = T_TypeSigs ((Map Identifier Type) -> ( (Map Identifier Type))) data Inh_TypeSigs = Inh_TypeSigs {typeSigs_Inh_TypeSigs :: !(Map Identifier Type)} data Syn_TypeSigs = Syn_TypeSigs {typeSigs_Syn_TypeSigs :: !(Map Identifier Type)} wrap_TypeSigs :: T_TypeSigs -> Inh_TypeSigs -> Syn_TypeSigs wrap_TypeSigs (T_TypeSigs sem ) (Inh_TypeSigs _lhsItypeSigs ) = (let ( _lhsOtypeSigs) = (sem _lhsItypeSigs ) in (Syn_TypeSigs _lhsOtypeSigs )) sem_TypeSigs_Cons :: T_TypeSig -> T_TypeSigs -> T_TypeSigs sem_TypeSigs_Cons (T_TypeSig hd_ ) (T_TypeSigs tl_ ) = (T_TypeSigs (\ _lhsItypeSigs -> (let _lhsOtypeSigs :: (Map Identifier Type) _hdOtypeSigs :: (Map Identifier Type) _tlOtypeSigs :: (Map Identifier Type) _hdItypeSigs :: (Map Identifier Type) _tlItypeSigs :: (Map Identifier Type) -- copy rule (up) _lhsOtypeSigs = {-# LINE 456 "Order.ag" #-} _tlItypeSigs {-# LINE 4669 "Order.hs" #-} -- copy rule (down) _hdOtypeSigs = {-# LINE 456 "Order.ag" #-} _lhsItypeSigs {-# LINE 4674 "Order.hs" #-} -- copy rule (chain) _tlOtypeSigs = {-# LINE 456 "Order.ag" #-} _hdItypeSigs {-# LINE 4679 "Order.hs" #-} ( _hdItypeSigs) = (hd_ _hdOtypeSigs ) ( _tlItypeSigs) = (tl_ _tlOtypeSigs ) in ( _lhsOtypeSigs))) ) sem_TypeSigs_Nil :: T_TypeSigs sem_TypeSigs_Nil = (T_TypeSigs (\ _lhsItypeSigs -> (let _lhsOtypeSigs :: (Map Identifier Type) -- copy rule (chain) _lhsOtypeSigs = {-# LINE 456 "Order.ag" #-} _lhsItypeSigs {-# LINE 4693 "Order.hs" #-} in ( _lhsOtypeSigs))) )