uuagc-0.9.31: src-derived/Transform.hs
-- UUAGC 0.9.30 (Transform.ag)
module Transform where
{-# LINE 8 "Transform.ag" #-}
import Control.Monad(mplus,mzero)
import List (partition, elem, nub,intersperse)
import Data.Maybe
import qualified Data.Map as Map
import Data.Map (Map)
import Data.Set as Set (Set, member, union, toList, fromList, empty, singleton, member, unions, size, fold, intersection, difference, insert)
import qualified Data.Sequence as Seq
import Data.Sequence(Seq, empty, (><),fromList)
import Data.Foldable(toList)
import UU.Scanner.Position(noPos)
import ConcreteSyntax
import AbstractSyntax
import ErrorMessages
import Patterns (Patterns(..),Pattern(..))
import Expression (Expression(..))
import HsToken
import Options
import CommonTypes
{-# LINE 28 "../src-derived/Transform.hs" #-}
{-# LINE 2 "./ConcreteSyntax.ag" #-}
import UU.Scanner.Position (Pos)
import Patterns (Pattern)
import Expression (Expression)
import CommonTypes
{-# LINE 36 "../src-derived/Transform.hs" #-}
{-# LINE 2 "./Patterns.ag" #-}
-- Patterns.ag imports
import UU.Scanner.Position(Pos)
import CommonTypes (ConstructorIdent,Identifier)
{-# LINE 43 "../src-derived/Transform.hs" #-}
{-# LINE 100 "Transform.ag" #-}
type DefinedSets = Map Identifier (Set NontermIdent)
{-# LINE 46 "../src-derived/Transform.hs" #-}
{-# LINE 120 "Transform.ag" #-}
type FieldMap = [(Identifier, Type)]
{-# LINE 50 "../src-derived/Transform.hs" #-}
{-# LINE 121 "Transform.ag" #-}
type DataTypes = Map.Map NontermIdent (Map.Map ConstructorIdent FieldMap)
{-# LINE 54 "../src-derived/Transform.hs" #-}
{-# LINE 141 "Transform.ag" #-}
type AttrName = (Identifier,Identifier)
{-# LINE 58 "../src-derived/Transform.hs" #-}
{-# LINE 142 "Transform.ag" #-}
type RuleInfo = (Maybe Identifier, [AttrName]->Pattern, Expression, [AttrName], Bool, String)
{-# LINE 62 "../src-derived/Transform.hs" #-}
{-# LINE 143 "Transform.ag" #-}
type SigInfo = (Identifier,Type)
{-# LINE 66 "../src-derived/Transform.hs" #-}
{-# LINE 144 "Transform.ag" #-}
type UniqueInfo = (Identifier,Identifier)
{-# LINE 70 "../src-derived/Transform.hs" #-}
{-# LINE 145 "Transform.ag" #-}
type AugmentInfo = (Identifier,Expression)
{-# LINE 74 "../src-derived/Transform.hs" #-}
{-# LINE 146 "Transform.ag" #-}
type AroundInfo = (Identifier,Expression)
{-# LINE 78 "../src-derived/Transform.hs" #-}
{-# LINE 147 "Transform.ag" #-}
type MergeInfo = (Identifier, Identifier, [Identifier], Expression)
{-# LINE 82 "../src-derived/Transform.hs" #-}
{-# LINE 195 "Transform.ag" #-}
checkDuplicate :: (Identifier -> Identifier -> Error)
-> Identifier -> val -> Map Identifier val -> (Map Identifier val,Seq Error)
checkDuplicate dupError key val m
= case Map.lookupIndex key m of
Just ix -> let (key',_) = Map.elemAt ix m
in (m,Seq.singleton (dupError key key'))
Nothing -> (Map.insert key val m,Seq.empty)
checkDuplicates :: (Identifier -> Identifier -> Error)
-> [(Identifier, val)] -> Map Identifier val -> (Map Identifier val,Seq Error)
checkDuplicates dupError new m = foldErrors check m new
where check = uncurry (checkDuplicate dupError)
foldErrors f e xs = foldl g (e,Seq.empty) xs
where g ~(e,es) x = let (e',es') = f x e
in (e', es >< es')
checkForDuplicates :: (Identifier -> Identifier -> Error) -> [Identifier] -> [Error]
checkForDuplicates err [] = []
checkForDuplicates err (x:xs) = let (same,other) = List.partition (equalId x) xs
in map (err x) same ++ checkForDuplicates err other
equalId :: Identifier -> Identifier -> Bool
equalId x y = getName x == getName y
{-# LINE 113 "../src-derived/Transform.hs" #-}
{-# LINE 331 "Transform.ag" #-}
type RulesAndErrors = ([Rule], Seq Error)
type SigsAndErrors = ([TypeSig], Seq Error)
type InstsAndErrors = ([(Identifier, Type)], Seq Error)
type UniquesAndErrors = (Map Identifier Identifier, Seq Error)
type AugmentsAndErrors = (Map Identifier [Expression], Seq Error)
type AroundsAndErrors = (Map Identifier [Expression], Seq Error)
type MergesAndErrors = (Map Identifier (Identifier, [Identifier], Expression), Seq Error)
type AttrOverwrite = Map AttrName Bool
type AccumRuleCheck = (RulesAndErrors, AttrOverwrite)
type AccumDefiCheck = (Seq Error, AttrOverwrite, [AttrName], [AttrName])
checkRules :: Map NontermIdent (Attributes, Attributes) -> Map NontermIdent (Map ConstructorIdent FieldMap) ->
Map NontermIdent (Map ConstructorIdent [Identifier]) -> Map NontermIdent (Map ConstructorIdent [SigInfo]) ->
Map NontermIdent (Map ConstructorIdent [MergeInfo]) ->
NontermIdent -> ConstructorIdent -> [RuleInfo] -> RulesAndErrors
checkRules attributes fields allinsts allsigs allmerges nt con rs
= let fieldmap :: FieldMap
fieldmap = (_LHS,NT nt undefined) : (_LOC,NT undefined undefined) : (_INST, NT undefined undefined) : (_FIRST, NT undefined undefined) : (_LAST, NT undefined undefined)
: Map.findWithDefault [] con (Map.findWithDefault Map.empty nt fields)
++ mapMaybe (\instNm -> lookup instNm sigs >>= \tp -> return (instNm, tp)) (Map.findWithDefault [] con (Map.findWithDefault Map.empty nt allinsts))
-- merged children are not allowed to have any inherited attrs defined: do not include
sigs = Map.findWithDefault [] con (Map.findWithDefault Map.empty nt allsigs)
hasAttrib f tp attr = Map.member attr (f (Map.findWithDefault (Map.empty,Map.empty) tp attributes))
checkRule :: RuleInfo -> AccumRuleCheck -> AccumRuleCheck
checkRule (mbNm, pat,exp,as,owrt,str) ((r1,e1),m1)
= let (e2,m2,u2,b2) = foldr (checkDefi owrt) (e1,m1,[],[]) as
in ( (Rule mbNm (pat u2) exp owrt str True : r1, e2), m2)
checkDefi :: Bool -> AttrName -> AccumDefiCheck -> AccumDefiCheck
checkDefi owrt fa@(field,attr) (e,m,u,bs)
= case lookup field fieldmap
of Just (NT tp _) ->
let tp' = maybe tp id (deforestedNt tp)
in if field == _LOC || field == _INST || field == _FIRST || field == _LAST
|| hasAttrib (if getName field==getName _LHS then snd else fst) tp' attr
then case Map.lookupIndex fa m of
Just ix -> let ((_,attr2),b) = Map.elemAt ix m
in if b && not (fa `elem` bs)
then ( e, Map.insert fa owrt m, fa:u, fa:bs)
else (((Seq.<|)) (DupRule nt con field attr2 attr) e, m, fa:u, bs)
Nothing -> ( e, Map.insert fa owrt m, u, fa:bs)
else (((Seq.<|)) (SuperfluousRule nt con field attr) e, m, fa:u, bs)
_ -> (((Seq.<|)) (UndefChild nt con field) e, m, fa:u, bs )
in fst (foldr checkRule (([],Seq.empty),Map.empty) rs)
checkRuleNames :: NontermIdent -> ConstructorIdent -> [RuleInfo] -> Seq Error
checkRuleNames nt con
= fst . foldr checkRule (Seq.empty, Set.empty)
where
checkRule (Just nm,_,_,_,_,_) (errs, nms)
| nm `Set.member` nms = (DupRuleName nt con nm Seq.<| errs, nms)
| otherwise = (errs, Set.insert nm nms)
checkRule (Nothing,_,_,_,_,_) inp = inp
checkSigs :: NontermIdent -> ConstructorIdent -> [SigInfo] -> SigsAndErrors
checkSigs nt con sis
= let checkSig (ide,typ) (sigs,errs)
= if ide `elem` map (\(TypeSig n t)-> n) sigs
then (sigs, ((Seq.<|)) (DupSig nt con ide) errs)
-- else if not (ide `elem` locattrdefs)
-- then (sigs, ((Seq.<|)) (SupSig nt con ide) errs)
else (TypeSig ide typ:sigs, errs)
in foldr checkSig ([],Seq.empty) sis
checkInsts :: Set NontermIdent -> Map NontermIdent (Map ConstructorIdent [SigInfo]) -> Map NontermIdent (Map ConstructorIdent [(Identifier, Type)]) -> NontermIdent -> ConstructorIdent -> [Identifier] -> InstsAndErrors
checkInsts allNts sigMap fieldMap nt con
= foldr (\inst (insts, errs) ->
maybe (insts, Seq.singleton (MissingInstSig nt con inst) >< errs)
(\info@(k, NT nm _) ->
case findInst k insts of
Just k' -> (insts, Seq.singleton (DupChild nt con k k') >< errs)
Nothing -> case nm `Set.member` allNts of
True -> (info : insts, errs)
False | take 2 (getName nm) == "T_" -> let nm' = Ident (drop 2 (getName nm)) (getPos nm)
in case nm' `Set.member` allNts of
True -> (info : insts, errs)
False -> (insts, Seq.singleton (UndefNont nm') >< errs)
| otherwise -> (insts, Seq.singleton (UndefNont nm) >< errs)
)
$ findSig inst
) ([], Seq.empty)
where
sigs = Map.findWithDefault [] con (Map.findWithDefault Map.empty nt sigMap)
findSig name
= do tp@(NT _ _) <- lookup name sigs
return (name, tp)
findInst _ [] = Nothing
findInst k ((k', _): r)
| k == k' = Just k'
| otherwise = findInst k r
checkUniques :: Map NontermIdent (Attributes, Attributes) -> NontermIdent -> ConstructorIdent -> [UniqueInfo] -> UniquesAndErrors
checkUniques allAttrs nt con uniques
= let checkUnique (ident,ref) (us,errs)
= if ident `Map.member` us
then (us, ((Seq.<|)) (DupUnique nt con ident) errs)
else if Map.member ref inhs && Map.member ref syns
then (Map.insert ident ref us, errs)
else (us, ((Seq.<|)) (MissingUnique nt ref) errs)
(inhs,syns) = Map.findWithDefault (Map.empty,Map.empty) nt allAttrs
in foldr checkUnique (Map.empty, Seq.empty) uniques
checkAugments :: Map NontermIdent (Attributes, Attributes) -> NontermIdent -> ConstructorIdent -> [AugmentInfo] -> AugmentsAndErrors
checkAugments allAttrs nt con augments
= let checkAugment (ident,expr) (as,errs)
= if ident `Map.member` as
then (Map.update (\vs -> Just (vs ++ [expr])) ident as, errs)
else if Map.member ident syns
then (Map.insert ident [expr] as, errs)
else (as, ((Seq.<|)) (MissingSyn nt ident) errs)
(inhs,syns) = Map.findWithDefault (Map.empty,Map.empty) nt allAttrs
in foldr checkAugment (Map.empty, Seq.empty) augments
checkArounds :: Map NontermIdent (Map ConstructorIdent [(Identifier, Type)]) -> NontermIdent -> ConstructorIdent -> [AroundInfo] -> AroundsAndErrors
checkArounds fieldMap nt con arounds
= let checkAround (ident,expr) (as,errs)
= if ident `Map.member` as
then (Map.update (\vs -> Just (vs ++ [expr])) ident as, errs)
else case lookup ident fields of
Just (NT _ _) -> (Map.insert ident [expr] as, errs)
_ -> (as, ((Seq.<|)) (UndefChild nt con ident) errs)
fields = Map.findWithDefault [] con (Map.findWithDefault Map.empty nt fieldMap)
in foldr checkAround (Map.empty, Seq.empty) arounds
checkMerges :: Set NontermIdent -> Map NontermIdent (Map ConstructorIdent [Identifier]) -> Map NontermIdent (Map ConstructorIdent [(Identifier, Type)]) -> NontermIdent -> ConstructorIdent -> [MergeInfo] -> MergesAndErrors
checkMerges allNts allInsts fieldMap nt con merges
= let checkMerge (target,nt,sources,expr) (m,errs)
= let fields = Map.findWithDefault [] con (Map.findWithDefault Map.empty nt fieldMap)
insts = Map.findWithDefault [] con (Map.findWithDefault Map.empty nt allInsts)
allFields = insts ++ map fst fields -- note: sources of merge may not contain a target (for simplicity)
in if target `Map.member` m -- check for duplicate with self
then (m, DupChild nt con target (fst $ Map.elemAt (Map.findIndex target m) m) Seq.<| errs)
else if target `elem` allFields
then (m, DupChild nt con target (head $ filter (== target) allFields) Seq.<| errs)
else let missing = filter (\s -> not (s `elem` allFields)) sources
in if null missing
then if nt `Set.member` allNts -- check if the nonterm is defined
then (Map.insert target (nt, sources, expr) m, errs) -- all ok..
else (m, UndefNont nt Seq.<| errs)
else (m, (Seq.fromList $ map (UndefChild nt con) missing) Seq.>< errs)
in foldr checkMerge (Map.empty, Seq.empty) merges
unionunionplusplus = Map.unionWith (Map.unionWith (++))
{-# LINE 268 "../src-derived/Transform.hs" #-}
{-# LINE 486 "Transform.ag" #-}
mkUniqueRules :: Options -> Map NontermIdent (Map ConstructorIdent [(Identifier, Type)]) -> Map NontermIdent (Map ConstructorIdent [(Identifier, Type)]) -> Map NontermIdent (Attributes,Attributes) -> NontermIdent -> ConstructorIdent -> Map Identifier Identifier -> [Rule]
mkUniqueRules opts allFields allInsts allAttrDecls nt con usMap
= map apply groups
where
fields = Map.findWithDefault [] con (Map.findWithDefault Map.empty nt allFields)
++ Map.findWithDefault [] con (Map.findWithDefault Map.empty nt allInsts)
-- may have duplicates
groups = Map.assocs $ Map.foldWithKey (\i r m -> Map.insertWith (++) r [i] m) Map.empty usMap
apply (ref,us) = mkRule ref (findOutField ref) us
findOutField ref = case [ chld | (chld,NT tp _) <- fields, tp `hasSyn` ref] of
[] -> _LHS
(x:_) -> x
hasSyn tp ref = Map.member ref $ snd $ Map.findWithDefault (Map.empty,Map.empty) tp allAttrDecls
mkRule ref outFld locAttrs
= let pat = Product noPos (attr outFld ref : [attr _LOC u | u <- locAttrs ])
rhs = Expression noPos $ wrap ref $ foldr gencase (finalout locAttrs) locAttrs
-- [HsToken ("mkUniques" ++ show (length locAttrs) ++ " ") noPos, AGField _LHS ref noPos Nothing]
in Rule Nothing pat rhs False "-- generated by the unique rule mechanism." False
attr fld a = Alias fld a (Underscore noPos) []
gencase nm outp
= h ("case " ++ uniqueDispenser opts ++ " __cont of { (__cont, " ++ getName nm ++ ") -> ") ++ outp ++ h "}"
h s = [HsToken s noPos]
finalout us = h ("(__cont, " ++ concat (intersperse "," (map getName us)) ++ ")")
wrap ref inp = h "case " ++ [AGField _LHS ref noPos Nothing] ++ h " of { __cont | __cont `seq` True -> " ++ inp ++ h "}"
{-# LINE 297 "../src-derived/Transform.hs" #-}
{-# LINE 658 "Transform.ag" #-}
flattenDatas :: DataTypes -> Map NontermIdent (Set NontermIdent)
flattenDatas ds = Map.map flatten ds
where flatten cs = Set.fromList [ nt | (_,NT nt _) <- concatMap snd (Map.toList cs)]
reachableFrom :: Map NontermIdent (Set NontermIdent) -> Set NontermIdent -> Set NontermIdent
reachableFrom table nts = reach nts
where reach nts = let nts' = Set.unions (nts : [ ns | nt <- Set.toList nts
, let ns = Map.findWithDefault Set.empty nt table ])
in if Set.size nts' > Set.size nts
then reach nts'
else nts
invert :: Map NontermIdent (Set NontermIdent) -> Map NontermIdent (Set NontermIdent)
invert m = foldr inv Map.empty (Map.toList m)
where inv (x,ns) m = fold (\n m -> Map.insertWith Set.union n (Set.singleton x) m) m ns
path :: Map NontermIdent (Set NontermIdent) -> NontermIdent -> NontermIdent -> Set NontermIdent
path table from to = let children = Map.findWithDefault Set.empty from table
forward = reachableFrom table children
backward = reachableFrom (invert table)
(Set.singleton to)
in Set.intersection forward backward
{-# LINE 322 "../src-derived/Transform.hs" #-}
{-# LINE 768 "Transform.ag" #-}
pragmaMapUnion :: PragmaMap -> PragmaMap -> PragmaMap
pragmaMapUnion = Map.unionWith (Map.unionWith Set.union)
pragmaMapSingle :: NontermIdent -> ConstructorIdent -> Set Identifier -> PragmaMap
pragmaMapSingle nt con nms = Map.singleton nt (Map.singleton con nms)
{-# LINE 331 "../src-derived/Transform.hs" #-}
{-# LINE 800 "Transform.ag" #-}
orderMapUnion :: AttrOrderMap -> AttrOrderMap -> AttrOrderMap
orderMapUnion = Map.unionWith (Map.unionWith Set.union)
orderMapSingle :: NontermIdent -> ConstructorIdent -> Set Dependency -> AttrOrderMap
orderMapSingle nt con deps = Map.singleton nt (Map.singleton con deps)
{-# LINE 340 "../src-derived/Transform.hs" #-}
{-# LINE 826 "Transform.ag" #-}
mergeParams :: ParamMap -> ParamMap -> ParamMap
mergeParams = Map.unionWith (++)
{-# LINE 346 "../src-derived/Transform.hs" #-}
{-# LINE 849 "Transform.ag" #-}
mergeCtx :: ContextMap -> ContextMap -> ContextMap
mergeCtx
= Map.unionWith nubconcat
where nubconcat a b = nub (a ++ b)
{-# LINE 354 "../src-derived/Transform.hs" #-}
{-# LINE 862 "Transform.ag" #-}
mergeDerivings m1 m2 = foldr (\(n,cs) m -> Map.insertWith Set.union n cs m) m2 (Map.toList m1)
{-# LINE 359 "../src-derived/Transform.hs" #-}
{-# LINE 873 "Transform.ag" #-}
merge x y = foldr f y (Map.toList x)
where f ~(k,v) m = Map.insertWith (Map.union) k v m
{-# LINE 365 "../src-derived/Transform.hs" #-}
{-# LINE 900 "Transform.ag" #-}
checkAttrs allFields nts inherited synthesized decls = foldErrors check decls nts where
check nt decls | not (nt `Map.member` allFields) = (decls,Seq.singleton(UndefNont nt))
| otherwise = let (inh,syn) = Map.findWithDefault (Map.empty,Map.empty) nt decls
(inh',einh) = checkDuplicates (DupInhAttr nt) inherited inh
(syn',esyn) = checkDuplicates (DupSynAttr nt) synthesized syn
in (Map.insert nt (inh',syn') decls,einh >< esyn)
{-# LINE 375 "../src-derived/Transform.hs" #-}
{-# LINE 911 "Transform.ag" #-}
addSelf name atMap = let (eInh,eSyn) = Map.findWithDefault(Map.empty,Map.empty) name atMap
in Map.insert name (eInh, Map.insert (Ident "self" noPos) (NT _SELF []) eSyn)atMap
{-# LINE 381 "../src-derived/Transform.hs" #-}
{-# LINE 1051 "Transform.ag" #-}
makeType :: Set NontermIdent -> Type -> Type
makeType nts tp@(NT x _) | x == _SELF = tp
| Set.member x nts = tp
| otherwise = Haskell (typeToHaskellString Nothing [] tp)
makeType _ tp = tp
{-# LINE 390 "../src-derived/Transform.hs" #-}
{-# LINE 1058 "Transform.ag" #-}
constructGrammar :: Set NontermIdent
-> ParamMap
-> DataTypes
-> Map NontermIdent (Attributes, Attributes)
-> Map NontermIdent (Map Identifier (String, String, String))
-> Derivings
-> Set NontermIdent
-> Map NontermIdent (Map ConstructorIdent [Rule])
-> Map NontermIdent (Map ConstructorIdent [TypeSig])
-> Map NontermIdent (Map ConstructorIdent [(Identifier, Type)])
-> TypeSyns
-> PragmaMap
-> AttrOrderMap
-> ContextMap
-> UniqueMap
-> Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))
-> Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))
-> Map NontermIdent (Map ConstructorIdent (Map Identifier (Identifier, [Identifier], Expression)))
-> Grammar
constructGrammar nts ntParams gram attrs uses derivings wrappers allrules tsigs allinsts tsyns pragmaMap orderMap contextMap uniqueMap augmentsMap aroundsMap mergeMap =
let gr = [ (nt,Map.toList alts) | (nt,alts) <- Map.toList gram]
nonts = map nont gr
nont (nt,alts) = let (inh,syn) = Map.findWithDefault (Map.empty,Map.empty) nt attrs
rmap = Map.findWithDefault Map.empty nt allrules
tsmap = Map.findWithDefault Map.empty nt tsigs
instsmap = Map.findWithDefault Map.empty nt allinsts
params = Map.findWithDefault [] nt ntParams
mergemap = Map.findWithDefault Map.empty nt mergeMap
alt (con,flds) =
let rules = maybe [] id (Map.lookup con rmap)
tsigs = maybe [] id (Map.lookup con tsmap)
insts = maybe [] id (Map.lookup con instsmap)
merges = [ (n, NT t []) | (n, (t, _, _)) <- Map.assocs $ maybe Map.empty id (Map.lookup con mergemap) ]
-- important: keep order of children
cldrn = map child (flds ++ filter (not . existsAsField) insts ++ merges)
child (nm, tp) =
let tpI = if existsAsInst nm
then fromJust $ lookup nm insts
else tp
(inh,syn) = case tpI of
NT nt _ -> let nt' = maybe nt id (deforestedNt nt)
in Map.findWithDefault (Map.empty,Map.empty) nt' attrs
_ -> (Map.empty,Map.empty)
virt = if existsAsInst nm
then case lookup nm flds of
Just tp' -> Just (Just tp')
Nothing -> Just Nothing
else if existsAsMerge nm
then (Just Nothing)
else Nothing
in Child nm tpI inh syn virt
existsAsInst nm = maybe False (const True) (lookup nm insts)
existsAsField (nm,_) = maybe False (const True) (lookup nm flds)
existsAsMerge nm = maybe False (const True) (lookup nm merges)
in Production con cldrn rules tsigs
in Nonterminal nt params inh syn (map alt alts)
in Grammar tsyns uses derivings wrappers nonts pragmaMap orderMap ntParams contextMap uniqueMap augmentsMap aroundsMap mergeMap
{-# LINE 453 "../src-derived/Transform.hs" #-}
{-# LINE 1120 "Transform.ag" #-}
mapUnionWithSetUnion = Map.unionWith Set.union
mapUnionWithPlusPlus = Map.unionWith (++)
{-# LINE 459 "../src-derived/Transform.hs" #-}
-- AG ----------------------------------------------------------
{-
visit 0:
inherited attribute:
options : Options
synthesized attributes:
blocks : Blocks
errors : Seq Error
moduleDecl : Maybe (String,String,String)
output : Grammar
pragmas : Options -> Options
alternatives:
alternative AG:
child elems : Elems
visit 0:
local allFields : _
local allConstrs : _
local allRules : _
local allSigs : _
local allInsts : _
local allUniques : _
local allAugments : _
local allArounds : _
local allMerges : _
local augmentSigs : _
local allRulesErrs : _
local allNamesErrs : _
local allSigsErrs : _
local allInstsErrs : _
local allUniquesErrs : _
local allAugmentErrs : _
local allAroundsErrs : _
local allMergesErrs : _
local checkedRulesPre : _
local checkedSigs : _
local checkedInsts : _
local checkedUniques : _
local checkedAugments : _
local checkedArounds : _
local checkedRules : _
local checkedMerges : _
local errs1 : _
local errs2 : _
local errs3 : _
local errs4 : _
local errs5 : _
local errs6 : _
local errs7 : _
local errs8 : _
local errs9 : _
local errs10 : _
local errs11 : _
local allNonterminals : _
local allAttrDecls : _
-}
-- cata
sem_AG :: AG ->
T_AG
sem_AG (AG _elems ) =
(sem_AG_AG (sem_Elems _elems ) )
-- semantic domain
newtype T_AG = T_AG (Options ->
( Blocks,(Seq Error),(Maybe (String,String,String)),Grammar,(Options -> Options)))
data Inh_AG = Inh_AG {options_Inh_AG :: !(Options)}
data Syn_AG = Syn_AG {blocks_Syn_AG :: !(Blocks),errors_Syn_AG :: !((Seq Error)),moduleDecl_Syn_AG :: !((Maybe (String,String,String))),output_Syn_AG :: !(Grammar),pragmas_Syn_AG :: !((Options -> Options))}
wrap_AG :: T_AG ->
Inh_AG ->
Syn_AG
wrap_AG (T_AG sem ) (Inh_AG _lhsIoptions ) =
(let ( _lhsOblocks,_lhsOerrors,_lhsOmoduleDecl,_lhsOoutput,_lhsOpragmas) = sem _lhsIoptions
in (Syn_AG _lhsOblocks _lhsOerrors _lhsOmoduleDecl _lhsOoutput _lhsOpragmas ))
sem_AG_AG :: T_Elems ->
T_AG
sem_AG_AG (T_Elems elems_ ) =
(T_AG (\ _lhsIoptions ->
(let _lhsOoutput :: Grammar
_lhsOerrors :: (Seq Error)
_elemsOallConstructors :: (Map NontermIdent (Set ConstructorIdent))
_elemsOdefSets :: (Map Identifier (Set NontermIdent,Set Identifier))
_elemsOdefinedSets :: DefinedSets
_elemsOattrDecls :: (Map NontermIdent (Attributes, Attributes))
_lhsOblocks :: Blocks
_lhsOmoduleDecl :: (Maybe (String,String,String))
_lhsOpragmas :: (Options -> Options)
_elemsOallAttrDecls :: (Map NontermIdent (Attributes, Attributes))
_elemsOallFields :: DataTypes
_elemsOallNonterminals :: (Set NontermIdent)
_elemsIattrDecls :: (Map NontermIdent (Attributes, Attributes))
_elemsIattrOrderCollect :: AttrOrderMap
_elemsIblocks :: Blocks
_elemsIcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])
_elemsIcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])
_elemsIcollectedConstructorsMap :: (Map NontermIdent (Set ConstructorIdent))
_elemsIcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)])
_elemsIcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ])
_elemsIcollectedMerges :: ([ (NontermIdent, ConstructorIdent, [MergeInfo]) ])
_elemsIcollectedNames :: (Set Identifier)
_elemsIcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)])
_elemsIcollectedSetNames :: (Set Identifier)
_elemsIcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ])
_elemsIcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])
_elemsIctxCollect :: ContextMap
_elemsIdefSets :: (Map Identifier (Set NontermIdent,Set Identifier))
_elemsIderivings :: Derivings
_elemsIerrors :: (Seq Error)
_elemsImoduleDecl :: (Maybe (String,String,String))
_elemsIparamsCollect :: ParamMap
_elemsIpragmas :: (Options -> Options)
_elemsIsemPragmasCollect :: PragmaMap
_elemsItypeSyns :: TypeSyns
_elemsIuseMap :: (Map NontermIdent (Map Identifier (String,String,String)))
_elemsIwrappers :: (Set NontermIdent)
-- "Transform.ag"(line 51, column 8)
_lhsOoutput =
({-# LINE 51 "Transform.ag" #-}
constructGrammar _allNonterminals
_elemsIparamsCollect
_allFields
_allAttrDecls
_elemsIuseMap
_elemsIderivings
(if wrappers _lhsIoptions then _allNonterminals else _elemsIwrappers)
_checkedRules
_checkedSigs
_checkedInsts
_elemsItypeSyns
_elemsIsemPragmasCollect
_elemsIattrOrderCollect
_elemsIctxCollect
_checkedUniques
_checkedAugments
_checkedArounds
_checkedMerges
{-# LINE 593 "Transform.hs" #-})
-- "Transform.ag"(line 246, column 10)
_allFields =
({-# LINE 246 "Transform.ag" #-}
let f (nt,con,fm) = Map.insertWith (Map.unionWith (++)) nt (Map.singleton con fm)
in foldr f (Map.empty) _elemsIcollectedFields
{-# LINE 599 "Transform.hs" #-})
-- "Transform.ag"(line 249, column 10)
_allConstrs =
({-# LINE 249 "Transform.ag" #-}
let f (nt,con,_) = Map.insertWith (++) nt [con]
in foldr f (Map.empty) _elemsIcollectedFields
{-# LINE 605 "Transform.hs" #-})
-- "Transform.ag"(line 252, column 10)
_allRules =
({-# LINE 252 "Transform.ag" #-}
let f (nt,con,r) = Map.insertWith (Map.unionWith (++)) nt (Map.singleton con [r])
in foldr f (Map.empty) _elemsIcollectedRules
{-# LINE 611 "Transform.hs" #-})
-- "Transform.ag"(line 255, column 10)
_allSigs =
({-# LINE 255 "Transform.ag" #-}
let f (nt,con,t) = Map.insertWith (Map.unionWith (++)) nt (Map.singleton con [t])
typeof nt r = Map.findWithDefault (Haskell "<unknown>") r $ fst $ Map.findWithDefault (Map.empty,Map.empty) nt _allAttrDecls
in foldr f (Map.empty) ( _elemsIcollectedSigs
++ [ (nt, con, (ident,typeof nt ref)) | (nt, con, us) <- _elemsIcollectedUniques, (ident,ref) <- us ]
)
{-# LINE 620 "Transform.hs" #-})
-- "Transform.ag"(line 261, column 10)
_allInsts =
({-# LINE 261 "Transform.ag" #-}
let f (nt,con,is) = Map.insertWith (Map.unionWith (++)) nt (Map.singleton con is)
in foldr f (Map.empty) _elemsIcollectedInsts
{-# LINE 626 "Transform.hs" #-})
-- "Transform.ag"(line 264, column 10)
_allUniques =
({-# LINE 264 "Transform.ag" #-}
let f (nt,con,us) = Map.insertWith (Map.unionWith (++)) nt (Map.singleton con us)
in foldr f (Map.empty) _elemsIcollectedUniques
{-# LINE 632 "Transform.hs" #-})
-- "Transform.ag"(line 266, column 10)
_allAugments =
({-# LINE 266 "Transform.ag" #-}
let f (nt,con,as) = Map.insertWith (Map.unionWith (++)) nt (Map.singleton con as)
in foldr f Map.empty _elemsIcollectedAugments
{-# LINE 638 "Transform.hs" #-})
-- "Transform.ag"(line 268, column 10)
_allArounds =
({-# LINE 268 "Transform.ag" #-}
let f (nt,con,as) = Map.insertWith (Map.unionWith (++)) nt (Map.singleton con as)
in foldr f Map.empty _elemsIcollectedArounds
{-# LINE 644 "Transform.hs" #-})
-- "Transform.ag"(line 270, column 10)
_allMerges =
({-# LINE 270 "Transform.ag" #-}
let f (nt,con,as) = Map.insertWith (Map.unionWith (++)) nt (Map.singleton con as)
in foldr f Map.empty _elemsIcollectedMerges
{-# LINE 650 "Transform.hs" #-})
-- "Transform.ag"(line 273, column 10)
_augmentSigs =
({-# LINE 273 "Transform.ag" #-}
let gen mp = []
in Map.map (Map.map gen) _allAugments
{-# LINE 656 "Transform.hs" #-})
-- "Transform.ag"(line 276, column 10)
_allRulesErrs =
({-# LINE 276 "Transform.ag" #-}
Map.mapWithKey (Map.mapWithKey . (checkRules _allAttrDecls _allFields _allInsts _allSigs _allMerges )) _allRules
{-# LINE 661 "Transform.hs" #-})
-- "Transform.ag"(line 277, column 10)
_allNamesErrs =
({-# LINE 277 "Transform.ag" #-}
Map.mapWithKey (Map.mapWithKey . checkRuleNames) _allRules
{-# LINE 666 "Transform.hs" #-})
-- "Transform.ag"(line 278, column 10)
_allSigsErrs =
({-# LINE 278 "Transform.ag" #-}
Map.mapWithKey (Map.mapWithKey . (checkSigs )) _allSigs
{-# LINE 671 "Transform.hs" #-})
-- "Transform.ag"(line 279, column 10)
_allInstsErrs =
({-# LINE 279 "Transform.ag" #-}
Map.mapWithKey (Map.mapWithKey . (checkInsts _allNonterminals _allSigs _allFields )) _allInsts
{-# LINE 676 "Transform.hs" #-})
-- "Transform.ag"(line 280, column 10)
_allUniquesErrs =
({-# LINE 280 "Transform.ag" #-}
Map.mapWithKey (Map.mapWithKey . (checkUniques _allAttrDecls )) _allUniques
{-# LINE 681 "Transform.hs" #-})
-- "Transform.ag"(line 281, column 10)
_allAugmentErrs =
({-# LINE 281 "Transform.ag" #-}
Map.mapWithKey (Map.mapWithKey . (checkAugments _allAttrDecls )) _allAugments
{-# LINE 686 "Transform.hs" #-})
-- "Transform.ag"(line 282, column 10)
_allAroundsErrs =
({-# LINE 282 "Transform.ag" #-}
Map.mapWithKey (Map.mapWithKey . (checkArounds _allFields )) _allArounds
{-# LINE 691 "Transform.hs" #-})
-- "Transform.ag"(line 283, column 10)
_allMergesErrs =
({-# LINE 283 "Transform.ag" #-}
Map.mapWithKey (Map.mapWithKey . (checkMerges _allNonterminals _allInsts _allFields )) _allMerges
{-# LINE 696 "Transform.hs" #-})
-- "Transform.ag"(line 285, column 10)
_checkedRulesPre =
({-# LINE 285 "Transform.ag" #-}
Map.map (Map.map fst) _allRulesErrs
{-# LINE 701 "Transform.hs" #-})
-- "Transform.ag"(line 286, column 10)
_checkedSigs =
({-# LINE 286 "Transform.ag" #-}
Map.map (Map.map fst) _allSigsErrs `unionunionplusplus` _augmentSigs
{-# LINE 706 "Transform.hs" #-})
-- "Transform.ag"(line 287, column 10)
_checkedInsts =
({-# LINE 287 "Transform.ag" #-}
Map.map (Map.map fst) _allInstsErrs
{-# LINE 711 "Transform.hs" #-})
-- "Transform.ag"(line 288, column 10)
_checkedUniques =
({-# LINE 288 "Transform.ag" #-}
Map.map (Map.map fst) _allUniquesErrs
{-# LINE 716 "Transform.hs" #-})
-- "Transform.ag"(line 289, column 10)
_checkedAugments =
({-# LINE 289 "Transform.ag" #-}
Map.map (Map.map fst) _allAugmentErrs
{-# LINE 721 "Transform.hs" #-})
-- "Transform.ag"(line 290, column 10)
_checkedArounds =
({-# LINE 290 "Transform.ag" #-}
Map.map (Map.map fst) _allAroundsErrs
{-# LINE 726 "Transform.hs" #-})
-- "Transform.ag"(line 291, column 10)
_checkedRules =
({-# LINE 291 "Transform.ag" #-}
Map.unionWith (Map.unionWith (++)) _checkedRulesPre (Map.mapWithKey (Map.mapWithKey . (mkUniqueRules _lhsIoptions _allFields _checkedInsts _allAttrDecls )) _checkedUniques )
{-# LINE 731 "Transform.hs" #-})
-- "Transform.ag"(line 292, column 10)
_checkedMerges =
({-# LINE 292 "Transform.ag" #-}
Map.map (Map.map fst) _allMergesErrs
{-# LINE 736 "Transform.hs" #-})
-- "Transform.ag"(line 294, column 10)
_errs1 =
({-# LINE 294 "Transform.ag" #-}
let f = checkForDuplicates (DupSynonym)
in Seq.fromList . f . map fst $ _elemsItypeSyns
{-# LINE 742 "Transform.hs" #-})
-- "Transform.ag"(line 297, column 10)
_errs2 =
({-# LINE 297 "Transform.ag" #-}
let g nt (con,fm) = checkForDuplicates (DupChild nt con) (map fst fm)
f (nt,cfm) = concat . map (g nt) . Map.toList $ cfm
in Seq.fromList . concat . map f . Map.toList $ _allFields
{-# LINE 749 "Transform.hs" #-})
-- "Transform.ag"(line 301, column 10)
_errs3 =
({-# LINE 301 "Transform.ag" #-}
let f (nt,cons) = checkForDuplicates (DupAlt nt) cons
in Seq.empty
{-# LINE 755 "Transform.hs" #-})
-- "Transform.ag"(line 305, column 10)
_errs4 =
({-# LINE 305 "Transform.ag" #-}
let f m s = Map.fold ((><) . snd) s m
in Map.fold f Seq.empty _allRulesErrs
{-# LINE 761 "Transform.hs" #-})
-- "Transform.ag"(line 308, column 10)
_errs5 =
({-# LINE 308 "Transform.ag" #-}
let f m s = Map.fold ((><) . snd) s m
in Map.fold f Seq.empty _allSigsErrs
{-# LINE 767 "Transform.hs" #-})
-- "Transform.ag"(line 311, column 10)
_errs6 =
({-# LINE 311 "Transform.ag" #-}
let f m s = Map.fold ((><) . snd) s m
in Map.fold f Seq.empty _allInstsErrs
{-# LINE 773 "Transform.hs" #-})
-- "Transform.ag"(line 314, column 10)
_errs7 =
({-# LINE 314 "Transform.ag" #-}
let f m s = Map.fold ((><) . snd) s m
in Map.fold f Seq.empty _allUniquesErrs
{-# LINE 779 "Transform.hs" #-})
-- "Transform.ag"(line 317, column 10)
_errs8 =
({-# LINE 317 "Transform.ag" #-}
let f m s = Map.fold ((><) . snd) s m
in Map.fold f Seq.empty _allAugmentErrs
{-# LINE 785 "Transform.hs" #-})
-- "Transform.ag"(line 320, column 10)
_errs9 =
({-# LINE 320 "Transform.ag" #-}
let f m s = Map.fold ((><) . snd) s m
in Map.fold f Seq.empty _allAroundsErrs
{-# LINE 791 "Transform.hs" #-})
-- "Transform.ag"(line 323, column 10)
_errs10 =
({-# LINE 323 "Transform.ag" #-}
let f m s = Map.fold ((><)) s m
in Map.fold f Seq.empty _allNamesErrs
{-# LINE 797 "Transform.hs" #-})
-- "Transform.ag"(line 326, column 10)
_errs11 =
({-# LINE 326 "Transform.ag" #-}
let f m s = Map.fold ((><) . snd) s m
in Map.fold f Seq.empty _allMergesErrs
{-# LINE 803 "Transform.hs" #-})
-- "Transform.ag"(line 329, column 10)
_lhsOerrors =
({-# LINE 329 "Transform.ag" #-}
_elemsIerrors >< _errs1 >< _errs2 >< _errs3 >< _errs4 >< _errs5 >< _errs6 >< _errs7 >< _errs8 >< _errs9 >< _errs10 >< _errs11
{-# LINE 808 "Transform.hs" #-})
-- "Transform.ag"(line 531, column 10)
_allNonterminals =
({-# LINE 531 "Transform.ag" #-}
_elemsIcollectedNames `Set.difference` _elemsIcollectedSetNames
{-# LINE 813 "Transform.hs" #-})
-- "Transform.ag"(line 551, column 8)
_elemsOallConstructors =
({-# LINE 551 "Transform.ag" #-}
_elemsIcollectedConstructorsMap
{-# LINE 818 "Transform.hs" #-})
-- "Transform.ag"(line 624, column 8)
_elemsOdefSets =
({-# LINE 624 "Transform.ag" #-}
Map.fromList (map (\x->(x,(Set.singleton x, Set.empty))) (Set.toList _allNonterminals ))
{-# LINE 823 "Transform.hs" #-})
-- "Transform.ag"(line 625, column 8)
_elemsOdefinedSets =
({-# LINE 625 "Transform.ag" #-}
Map.map fst _elemsIdefSets
{-# LINE 828 "Transform.hs" #-})
-- "Transform.ag"(line 879, column 8)
_elemsOattrDecls =
({-# LINE 879 "Transform.ag" #-}
Map.empty
{-# LINE 833 "Transform.hs" #-})
-- "Transform.ag"(line 918, column 9)
_allAttrDecls =
({-# LINE 918 "Transform.ag" #-}
if withSelf _lhsIoptions
then foldr addSelf _elemsIattrDecls (Set.toList _allNonterminals )
else _elemsIattrDecls
{-# LINE 840 "Transform.hs" #-})
-- use rule "Transform.ag"(line 44, column 19)
_lhsOblocks =
({-# LINE 44 "Transform.ag" #-}
_elemsIblocks
{-# LINE 845 "Transform.hs" #-})
-- use rule "Transform.ag"(line 1041, column 37)
_lhsOmoduleDecl =
({-# LINE 1041 "Transform.ag" #-}
_elemsImoduleDecl
{-# LINE 850 "Transform.hs" #-})
-- use rule "Transform.ag"(line 706, column 34)
_lhsOpragmas =
({-# LINE 706 "Transform.ag" #-}
_elemsIpragmas
{-# LINE 855 "Transform.hs" #-})
-- copy rule (from local)
_elemsOallAttrDecls =
({-# LINE 781 "Transform.ag" #-}
_allAttrDecls
{-# LINE 860 "Transform.hs" #-})
-- copy rule (from local)
_elemsOallFields =
({-# LINE 127 "Transform.ag" #-}
_allFields
{-# LINE 865 "Transform.hs" #-})
-- copy rule (from local)
_elemsOallNonterminals =
({-# LINE 87 "Transform.ag" #-}
_allNonterminals
{-# LINE 870 "Transform.hs" #-})
( _elemsIattrDecls,_elemsIattrOrderCollect,_elemsIblocks,_elemsIcollectedArounds,_elemsIcollectedAugments,_elemsIcollectedConstructorsMap,_elemsIcollectedFields,_elemsIcollectedInsts,_elemsIcollectedMerges,_elemsIcollectedNames,_elemsIcollectedRules,_elemsIcollectedSetNames,_elemsIcollectedSigs,_elemsIcollectedUniques,_elemsIctxCollect,_elemsIdefSets,_elemsIderivings,_elemsIerrors,_elemsImoduleDecl,_elemsIparamsCollect,_elemsIpragmas,_elemsIsemPragmasCollect,_elemsItypeSyns,_elemsIuseMap,_elemsIwrappers) =
elems_ _elemsOallAttrDecls _elemsOallConstructors _elemsOallFields _elemsOallNonterminals _elemsOattrDecls _elemsOdefSets _elemsOdefinedSets
in ( _lhsOblocks,_lhsOerrors,_lhsOmoduleDecl,_lhsOoutput,_lhsOpragmas))) )
-- Alt ---------------------------------------------------------
{-
visit 0:
inherited attributes:
allConstructors : Map NontermIdent (Set ConstructorIdent)
allNonterminals : Set NontermIdent
nts : Set NontermIdent
synthesized attributes:
collectedConstructorNames : Set ConstructorIdent
collectedFields : [(NontermIdent, ConstructorIdent, FieldMap)]
alternatives:
alternative Alt:
child pos : {Pos}
child names : ConstructorSet
child fields : {Fields}
-}
-- cata
sem_Alt :: Alt ->
T_Alt
sem_Alt (Alt _pos _names _fields ) =
(sem_Alt_Alt _pos (sem_ConstructorSet _names ) _fields )
-- semantic domain
newtype T_Alt = T_Alt ((Map NontermIdent (Set ConstructorIdent)) ->
(Set NontermIdent) ->
(Set NontermIdent) ->
( (Set ConstructorIdent),([(NontermIdent, ConstructorIdent, FieldMap)])))
data Inh_Alt = Inh_Alt {allConstructors_Inh_Alt :: !((Map NontermIdent (Set ConstructorIdent))),allNonterminals_Inh_Alt :: !((Set NontermIdent)),nts_Inh_Alt :: !((Set NontermIdent))}
data Syn_Alt = Syn_Alt {collectedConstructorNames_Syn_Alt :: !((Set ConstructorIdent)),collectedFields_Syn_Alt :: !(([(NontermIdent, ConstructorIdent, FieldMap)]))}
wrap_Alt :: T_Alt ->
Inh_Alt ->
Syn_Alt
wrap_Alt (T_Alt sem ) (Inh_Alt _lhsIallConstructors _lhsIallNonterminals _lhsInts ) =
(let ( _lhsOcollectedConstructorNames,_lhsOcollectedFields) = sem _lhsIallConstructors _lhsIallNonterminals _lhsInts
in (Syn_Alt _lhsOcollectedConstructorNames _lhsOcollectedFields ))
sem_Alt_Alt :: Pos ->
T_ConstructorSet ->
Fields ->
T_Alt
sem_Alt_Alt pos_ (T_ConstructorSet names_ ) fields_ =
(T_Alt (\ _lhsIallConstructors
_lhsIallNonterminals
_lhsInts ->
(let _lhsOcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)])
_lhsOcollectedConstructorNames :: (Set ConstructorIdent)
_namesIcollectedConstructorNames :: (Set ConstructorIdent)
_namesIconstructors :: ((Set ConstructorIdent->Set ConstructorIdent))
_namesIerrors :: (Seq Error)
-- "Transform.ag"(line 231, column 10)
_lhsOcollectedFields =
({-# LINE 231 "Transform.ag" #-}
let fieldTable =
[ (attr, makeType _lhsIallNonterminals tp)
| (attr, tp) <- fields_
]
in [ (nt, con, fieldTable)
| nt <- Set.toList _lhsInts
, con <- Set.toList (_namesIconstructors (Map.findWithDefault Set.empty nt _lhsIallConstructors))
]
{-# LINE 932 "Transform.hs" #-})
-- use rule "Transform.ag"(line 92, column 62)
_lhsOcollectedConstructorNames =
({-# LINE 92 "Transform.ag" #-}
_namesIcollectedConstructorNames
{-# LINE 937 "Transform.hs" #-})
( _namesIcollectedConstructorNames,_namesIconstructors,_namesIerrors) =
names_
in ( _lhsOcollectedConstructorNames,_lhsOcollectedFields))) )
-- Alts --------------------------------------------------------
{-
visit 0:
inherited attributes:
allConstructors : Map NontermIdent (Set ConstructorIdent)
allNonterminals : Set NontermIdent
nts : Set NontermIdent
synthesized attributes:
collectedConstructorNames : Set ConstructorIdent
collectedFields : [(NontermIdent, ConstructorIdent, FieldMap)]
alternatives:
alternative Cons:
child hd : Alt
child tl : Alts
alternative Nil:
-}
-- cata
sem_Alts :: Alts ->
T_Alts
sem_Alts list =
(Prelude.foldr sem_Alts_Cons sem_Alts_Nil (Prelude.map sem_Alt list) )
-- semantic domain
newtype T_Alts = T_Alts ((Map NontermIdent (Set ConstructorIdent)) ->
(Set NontermIdent) ->
(Set NontermIdent) ->
( (Set ConstructorIdent),([(NontermIdent, ConstructorIdent, FieldMap)])))
data Inh_Alts = Inh_Alts {allConstructors_Inh_Alts :: !((Map NontermIdent (Set ConstructorIdent))),allNonterminals_Inh_Alts :: !((Set NontermIdent)),nts_Inh_Alts :: !((Set NontermIdent))}
data Syn_Alts = Syn_Alts {collectedConstructorNames_Syn_Alts :: !((Set ConstructorIdent)),collectedFields_Syn_Alts :: !(([(NontermIdent, ConstructorIdent, FieldMap)]))}
wrap_Alts :: T_Alts ->
Inh_Alts ->
Syn_Alts
wrap_Alts (T_Alts sem ) (Inh_Alts _lhsIallConstructors _lhsIallNonterminals _lhsInts ) =
(let ( _lhsOcollectedConstructorNames,_lhsOcollectedFields) = sem _lhsIallConstructors _lhsIallNonterminals _lhsInts
in (Syn_Alts _lhsOcollectedConstructorNames _lhsOcollectedFields ))
sem_Alts_Cons :: T_Alt ->
T_Alts ->
T_Alts
sem_Alts_Cons (T_Alt hd_ ) (T_Alts tl_ ) =
(T_Alts (\ _lhsIallConstructors
_lhsIallNonterminals
_lhsInts ->
(let _lhsOcollectedConstructorNames :: (Set ConstructorIdent)
_lhsOcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)])
_hdOallConstructors :: (Map NontermIdent (Set ConstructorIdent))
_hdOallNonterminals :: (Set NontermIdent)
_hdOnts :: (Set NontermIdent)
_tlOallConstructors :: (Map NontermIdent (Set ConstructorIdent))
_tlOallNonterminals :: (Set NontermIdent)
_tlOnts :: (Set NontermIdent)
_hdIcollectedConstructorNames :: (Set ConstructorIdent)
_hdIcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)])
_tlIcollectedConstructorNames :: (Set ConstructorIdent)
_tlIcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)])
-- use rule "Transform.ag"(line 92, column 62)
_lhsOcollectedConstructorNames =
({-# LINE 92 "Transform.ag" #-}
_hdIcollectedConstructorNames `Set.union` _tlIcollectedConstructorNames
{-# LINE 998 "Transform.hs" #-})
-- use rule "Transform.ag"(line 124, column 28)
_lhsOcollectedFields =
({-# LINE 124 "Transform.ag" #-}
_hdIcollectedFields ++ _tlIcollectedFields
{-# LINE 1003 "Transform.hs" #-})
-- copy rule (down)
_hdOallConstructors =
({-# LINE 95 "Transform.ag" #-}
_lhsIallConstructors
{-# LINE 1008 "Transform.hs" #-})
-- copy rule (down)
_hdOallNonterminals =
({-# LINE 87 "Transform.ag" #-}
_lhsIallNonterminals
{-# LINE 1013 "Transform.hs" #-})
-- copy rule (down)
_hdOnts =
({-# LINE 166 "Transform.ag" #-}
_lhsInts
{-# LINE 1018 "Transform.hs" #-})
-- copy rule (down)
_tlOallConstructors =
({-# LINE 95 "Transform.ag" #-}
_lhsIallConstructors
{-# LINE 1023 "Transform.hs" #-})
-- copy rule (down)
_tlOallNonterminals =
({-# LINE 87 "Transform.ag" #-}
_lhsIallNonterminals
{-# LINE 1028 "Transform.hs" #-})
-- copy rule (down)
_tlOnts =
({-# LINE 166 "Transform.ag" #-}
_lhsInts
{-# LINE 1033 "Transform.hs" #-})
( _hdIcollectedConstructorNames,_hdIcollectedFields) =
hd_ _hdOallConstructors _hdOallNonterminals _hdOnts
( _tlIcollectedConstructorNames,_tlIcollectedFields) =
tl_ _tlOallConstructors _tlOallNonterminals _tlOnts
in ( _lhsOcollectedConstructorNames,_lhsOcollectedFields))) )
sem_Alts_Nil :: T_Alts
sem_Alts_Nil =
(T_Alts (\ _lhsIallConstructors
_lhsIallNonterminals
_lhsInts ->
(let _lhsOcollectedConstructorNames :: (Set ConstructorIdent)
_lhsOcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)])
-- use rule "Transform.ag"(line 92, column 62)
_lhsOcollectedConstructorNames =
({-# LINE 92 "Transform.ag" #-}
Set.empty
{-# LINE 1050 "Transform.hs" #-})
-- use rule "Transform.ag"(line 124, column 28)
_lhsOcollectedFields =
({-# LINE 124 "Transform.ag" #-}
[]
{-# LINE 1055 "Transform.hs" #-})
in ( _lhsOcollectedConstructorNames,_lhsOcollectedFields))) )
-- Attrs -------------------------------------------------------
{-
visit 0:
inherited attributes:
allFields : DataTypes
allNonterminals : Set NontermIdent
nts : Set NontermIdent
chained attribute:
attrDecls : Map NontermIdent (Attributes, Attributes)
synthesized attributes:
errors : Seq Error
useMap : Map NontermIdent (Map Identifier (String,String,String))
alternatives:
alternative Attrs:
child pos : {Pos}
child inh : {AttrNames}
child chn : {AttrNames}
child syn : {AttrNames}
visit 0:
local _tup1 : _
local attrDecls : _
local errors : _
local _tup2 : _
local inherited : _
local synthesized : _
local useMap : _
-}
-- cata
sem_Attrs :: Attrs ->
T_Attrs
sem_Attrs (Attrs _pos _inh _chn _syn ) =
(sem_Attrs_Attrs _pos _inh _chn _syn )
-- semantic domain
newtype T_Attrs = T_Attrs (DataTypes ->
(Set NontermIdent) ->
(Map NontermIdent (Attributes, Attributes)) ->
(Set NontermIdent) ->
( (Map NontermIdent (Attributes, Attributes)),(Seq Error),(Map NontermIdent (Map Identifier (String,String,String)))))
data Inh_Attrs = Inh_Attrs {allFields_Inh_Attrs :: !(DataTypes),allNonterminals_Inh_Attrs :: !((Set NontermIdent)),attrDecls_Inh_Attrs :: !((Map NontermIdent (Attributes, Attributes))),nts_Inh_Attrs :: !((Set NontermIdent))}
data Syn_Attrs = Syn_Attrs {attrDecls_Syn_Attrs :: !((Map NontermIdent (Attributes, Attributes))),errors_Syn_Attrs :: !((Seq Error)),useMap_Syn_Attrs :: !((Map NontermIdent (Map Identifier (String,String,String))))}
wrap_Attrs :: T_Attrs ->
Inh_Attrs ->
Syn_Attrs
wrap_Attrs (T_Attrs sem ) (Inh_Attrs _lhsIallFields _lhsIallNonterminals _lhsIattrDecls _lhsInts ) =
(let ( _lhsOattrDecls,_lhsOerrors,_lhsOuseMap) = sem _lhsIallFields _lhsIallNonterminals _lhsIattrDecls _lhsInts
in (Syn_Attrs _lhsOattrDecls _lhsOerrors _lhsOuseMap ))
sem_Attrs_Attrs :: Pos ->
AttrNames ->
AttrNames ->
AttrNames ->
T_Attrs
sem_Attrs_Attrs pos_ inh_ chn_ syn_ =
(T_Attrs (\ _lhsIallFields
_lhsIallNonterminals
_lhsIattrDecls
_lhsInts ->
(let _lhsOuseMap :: (Map NontermIdent (Map Identifier (String,String,String)))
_lhsOerrors :: (Seq Error)
_lhsOattrDecls :: (Map NontermIdent (Attributes, Attributes))
-- "Transform.ag"(line 887, column 15)
__tup1 =
({-# LINE 887 "Transform.ag" #-}
checkAttrs _lhsIallFields (Set.toList _lhsInts) _inherited _synthesized _lhsIattrDecls
{-# LINE 1120 "Transform.hs" #-})
-- "Transform.ag"(line 887, column 15)
(_attrDecls,_) =
({-# LINE 887 "Transform.ag" #-}
__tup1
{-# LINE 1125 "Transform.hs" #-})
-- "Transform.ag"(line 887, column 15)
(_,_errors) =
({-# LINE 887 "Transform.ag" #-}
__tup1
{-# LINE 1130 "Transform.hs" #-})
-- "Transform.ag"(line 889, column 15)
__tup2 =
({-# LINE 889 "Transform.ag" #-}
let splitAttrs xs = unzip [ ((n,makeType _lhsIallNonterminals t),(n,ud))
| (n,t,ud) <- xs
]
(inh,_) = splitAttrs inh_
(chn,uses1) = splitAttrs chn_
(syn,uses2) = splitAttrs syn_
isUse (n,(e1,e2,_)) = not (null e1 || null e2)
in (inh++chn,chn++syn, Map.fromList (Prelude.filter isUse (uses1++uses2)))
{-# LINE 1142 "Transform.hs" #-})
-- "Transform.ag"(line 889, column 15)
(_inherited,_,_) =
({-# LINE 889 "Transform.ag" #-}
__tup2
{-# LINE 1147 "Transform.hs" #-})
-- "Transform.ag"(line 889, column 15)
(_,_synthesized,_) =
({-# LINE 889 "Transform.ag" #-}
__tup2
{-# LINE 1152 "Transform.hs" #-})
-- "Transform.ag"(line 889, column 15)
(_,_,_useMap) =
({-# LINE 889 "Transform.ag" #-}
__tup2
{-# LINE 1157 "Transform.hs" #-})
-- "Transform.ag"(line 897, column 11)
_lhsOuseMap =
({-# LINE 897 "Transform.ag" #-}
Map.fromList (zip (Set.toList _lhsInts) (repeat _useMap))
{-# LINE 1162 "Transform.hs" #-})
-- use rule "Transform.ag"(line 42, column 19)
_lhsOerrors =
({-# LINE 42 "Transform.ag" #-}
_errors
{-# LINE 1167 "Transform.hs" #-})
-- copy rule (from local)
_lhsOattrDecls =
({-# LINE 135 "Transform.ag" #-}
_attrDecls
{-# LINE 1172 "Transform.hs" #-})
in ( _lhsOattrDecls,_lhsOerrors,_lhsOuseMap))) )
-- ConstructorSet ----------------------------------------------
{-
visit 0:
synthesized attributes:
collectedConstructorNames : Set ConstructorIdent
constructors : (Set ConstructorIdent->Set ConstructorIdent)
errors : Seq Error
alternatives:
alternative CAll:
alternative CDifference:
child set1 : ConstructorSet
child set2 : ConstructorSet
alternative CName:
child name : {ConstructorIdent}
alternative CUnion:
child set1 : ConstructorSet
child set2 : ConstructorSet
-}
-- cata
sem_ConstructorSet :: ConstructorSet ->
T_ConstructorSet
sem_ConstructorSet (CAll ) =
(sem_ConstructorSet_CAll )
sem_ConstructorSet (CDifference _set1 _set2 ) =
(sem_ConstructorSet_CDifference (sem_ConstructorSet _set1 ) (sem_ConstructorSet _set2 ) )
sem_ConstructorSet (CName _name ) =
(sem_ConstructorSet_CName _name )
sem_ConstructorSet (CUnion _set1 _set2 ) =
(sem_ConstructorSet_CUnion (sem_ConstructorSet _set1 ) (sem_ConstructorSet _set2 ) )
-- semantic domain
newtype T_ConstructorSet = T_ConstructorSet (( (Set ConstructorIdent),((Set ConstructorIdent->Set ConstructorIdent)),(Seq Error)))
data Inh_ConstructorSet = Inh_ConstructorSet {}
data Syn_ConstructorSet = Syn_ConstructorSet {collectedConstructorNames_Syn_ConstructorSet :: !((Set ConstructorIdent)),constructors_Syn_ConstructorSet :: !(((Set ConstructorIdent->Set ConstructorIdent))),errors_Syn_ConstructorSet :: !((Seq Error))}
wrap_ConstructorSet :: T_ConstructorSet ->
Inh_ConstructorSet ->
Syn_ConstructorSet
wrap_ConstructorSet (T_ConstructorSet sem ) (Inh_ConstructorSet ) =
(let ( _lhsOcollectedConstructorNames,_lhsOconstructors,_lhsOerrors) = sem
in (Syn_ConstructorSet _lhsOcollectedConstructorNames _lhsOconstructors _lhsOerrors ))
sem_ConstructorSet_CAll :: T_ConstructorSet
sem_ConstructorSet_CAll =
(T_ConstructorSet (let _lhsOconstructors :: ((Set ConstructorIdent->Set ConstructorIdent))
_lhsOcollectedConstructorNames :: (Set ConstructorIdent)
_lhsOerrors :: (Seq Error)
-- "Transform.ag"(line 691, column 17)
_lhsOconstructors =
({-# LINE 691 "Transform.ag" #-}
\ds -> ds
{-# LINE 1222 "Transform.hs" #-})
-- use rule "Transform.ag"(line 92, column 62)
_lhsOcollectedConstructorNames =
({-# LINE 92 "Transform.ag" #-}
Set.empty
{-# LINE 1227 "Transform.hs" #-})
-- use rule "Transform.ag"(line 42, column 19)
_lhsOerrors =
({-# LINE 42 "Transform.ag" #-}
Seq.empty
{-# LINE 1232 "Transform.hs" #-})
in ( _lhsOcollectedConstructorNames,_lhsOconstructors,_lhsOerrors)) )
sem_ConstructorSet_CDifference :: T_ConstructorSet ->
T_ConstructorSet ->
T_ConstructorSet
sem_ConstructorSet_CDifference (T_ConstructorSet set1_ ) (T_ConstructorSet set2_ ) =
(T_ConstructorSet (let _lhsOconstructors :: ((Set ConstructorIdent->Set ConstructorIdent))
_lhsOcollectedConstructorNames :: (Set ConstructorIdent)
_lhsOerrors :: (Seq Error)
_set1IcollectedConstructorNames :: (Set ConstructorIdent)
_set1Iconstructors :: ((Set ConstructorIdent->Set ConstructorIdent))
_set1Ierrors :: (Seq Error)
_set2IcollectedConstructorNames :: (Set ConstructorIdent)
_set2Iconstructors :: ((Set ConstructorIdent->Set ConstructorIdent))
_set2Ierrors :: (Seq Error)
-- "Transform.ag"(line 690, column 17)
_lhsOconstructors =
({-# LINE 690 "Transform.ag" #-}
\ds -> _set1Iconstructors ds `Set.difference` _set2Iconstructors ds
{-# LINE 1251 "Transform.hs" #-})
-- use rule "Transform.ag"(line 92, column 62)
_lhsOcollectedConstructorNames =
({-# LINE 92 "Transform.ag" #-}
_set1IcollectedConstructorNames `Set.union` _set2IcollectedConstructorNames
{-# LINE 1256 "Transform.hs" #-})
-- use rule "Transform.ag"(line 42, column 19)
_lhsOerrors =
({-# LINE 42 "Transform.ag" #-}
_set1Ierrors Seq.>< _set2Ierrors
{-# LINE 1261 "Transform.hs" #-})
( _set1IcollectedConstructorNames,_set1Iconstructors,_set1Ierrors) =
set1_
( _set2IcollectedConstructorNames,_set2Iconstructors,_set2Ierrors) =
set2_
in ( _lhsOcollectedConstructorNames,_lhsOconstructors,_lhsOerrors)) )
sem_ConstructorSet_CName :: ConstructorIdent ->
T_ConstructorSet
sem_ConstructorSet_CName name_ =
(T_ConstructorSet (let _lhsOcollectedConstructorNames :: (Set ConstructorIdent)
_lhsOconstructors :: ((Set ConstructorIdent->Set ConstructorIdent))
_lhsOerrors :: (Seq Error)
-- "Transform.ag"(line 539, column 11)
_lhsOcollectedConstructorNames =
({-# LINE 539 "Transform.ag" #-}
Set.singleton name_
{-# LINE 1277 "Transform.hs" #-})
-- "Transform.ag"(line 688, column 17)
_lhsOconstructors =
({-# LINE 688 "Transform.ag" #-}
\ds -> Set.singleton name_
{-# LINE 1282 "Transform.hs" #-})
-- use rule "Transform.ag"(line 42, column 19)
_lhsOerrors =
({-# LINE 42 "Transform.ag" #-}
Seq.empty
{-# LINE 1287 "Transform.hs" #-})
in ( _lhsOcollectedConstructorNames,_lhsOconstructors,_lhsOerrors)) )
sem_ConstructorSet_CUnion :: T_ConstructorSet ->
T_ConstructorSet ->
T_ConstructorSet
sem_ConstructorSet_CUnion (T_ConstructorSet set1_ ) (T_ConstructorSet set2_ ) =
(T_ConstructorSet (let _lhsOconstructors :: ((Set ConstructorIdent->Set ConstructorIdent))
_lhsOcollectedConstructorNames :: (Set ConstructorIdent)
_lhsOerrors :: (Seq Error)
_set1IcollectedConstructorNames :: (Set ConstructorIdent)
_set1Iconstructors :: ((Set ConstructorIdent->Set ConstructorIdent))
_set1Ierrors :: (Seq Error)
_set2IcollectedConstructorNames :: (Set ConstructorIdent)
_set2Iconstructors :: ((Set ConstructorIdent->Set ConstructorIdent))
_set2Ierrors :: (Seq Error)
-- "Transform.ag"(line 689, column 17)
_lhsOconstructors =
({-# LINE 689 "Transform.ag" #-}
\ds -> _set1Iconstructors ds `Set.union` _set2Iconstructors ds
{-# LINE 1306 "Transform.hs" #-})
-- use rule "Transform.ag"(line 92, column 62)
_lhsOcollectedConstructorNames =
({-# LINE 92 "Transform.ag" #-}
_set1IcollectedConstructorNames `Set.union` _set2IcollectedConstructorNames
{-# LINE 1311 "Transform.hs" #-})
-- use rule "Transform.ag"(line 42, column 19)
_lhsOerrors =
({-# LINE 42 "Transform.ag" #-}
_set1Ierrors Seq.>< _set2Ierrors
{-# LINE 1316 "Transform.hs" #-})
( _set1IcollectedConstructorNames,_set1Iconstructors,_set1Ierrors) =
set1_
( _set2IcollectedConstructorNames,_set2Iconstructors,_set2Ierrors) =
set2_
in ( _lhsOcollectedConstructorNames,_lhsOconstructors,_lhsOerrors)) )
-- Elem --------------------------------------------------------
{-
visit 0:
inherited attributes:
allAttrDecls : Map NontermIdent (Attributes, Attributes)
allConstructors : Map NontermIdent (Set ConstructorIdent)
allFields : DataTypes
allNonterminals : Set NontermIdent
definedSets : DefinedSets
chained attributes:
attrDecls : Map NontermIdent (Attributes, Attributes)
defSets : Map Identifier (Set NontermIdent,Set Identifier)
synthesized attributes:
attrOrderCollect : AttrOrderMap
blocks : Blocks
collectedArounds : [ (NontermIdent, ConstructorIdent, [AroundInfo]) ]
collectedAugments : [ (NontermIdent, ConstructorIdent, [AugmentInfo]) ]
collectedConstructorsMap : Map NontermIdent (Set ConstructorIdent)
collectedFields : [(NontermIdent, ConstructorIdent, FieldMap)]
collectedInsts : [ (NontermIdent, ConstructorIdent, [Identifier]) ]
collectedMerges : [ (NontermIdent, ConstructorIdent, [MergeInfo]) ]
collectedNames : Set Identifier
collectedRules : [ (NontermIdent, ConstructorIdent, RuleInfo)]
collectedSetNames : Set Identifier
collectedSigs : [ (NontermIdent, ConstructorIdent, SigInfo) ]
collectedUniques : [ (NontermIdent, ConstructorIdent, [UniqueInfo]) ]
ctxCollect : ContextMap
derivings : Derivings
errors : Seq Error
moduleDecl : Maybe (String,String,String)
paramsCollect : ParamMap
pragmas : Options -> Options
semPragmasCollect : PragmaMap
typeSyns : TypeSyns
useMap : Map NontermIdent (Map Identifier (String,String,String))
wrappers : Set NontermIdent
alternatives:
alternative Attr:
child pos : {Pos}
child ctx : {ClassContext}
child names : NontSet
child attrs : Attrs
alternative Data:
child pos : {Pos}
child ctx : {ClassContext}
child names : NontSet
child params : {[Identifier]}
child attrs : Attrs
child alts : Alts
child ext : {Bool}
alternative Deriving:
child pos : {Pos}
child set : NontSet
child classes : {[NontermIdent]}
alternative Module:
child pos : {Pos}
child name : {String}
child exports : {String}
child imports : {String}
alternative Pragma:
child pos : {Pos}
child names : {[NontermIdent]}
alternative Sem:
child pos : {Pos}
child ctx : {ClassContext}
child names : NontSet
child attrs : Attrs
child alts : SemAlts
alternative Set:
child pos : {Pos}
child name : {NontermIdent}
child set : NontSet
visit 0:
local _tup3 : _
local defSets2 : _
local errs : _
alternative Txt:
child pos : {Pos}
child name : {Identifier}
child mbNt : {Maybe NontermIdent}
child lines : {[String]}
visit 0:
local blockInfo : _
local blockValue : _
alternative Type:
child pos : {Pos}
child ctx : {ClassContext}
child name : {NontermIdent}
child params : {[Identifier]}
child type : {ComplexType}
visit 0:
local expanded : _
local argType : _
alternative Wrapper:
child pos : {Pos}
child set : NontSet
-}
-- cata
sem_Elem :: Elem ->
T_Elem
sem_Elem (Attr _pos _ctx _names _attrs ) =
(sem_Elem_Attr _pos _ctx (sem_NontSet _names ) (sem_Attrs _attrs ) )
sem_Elem (Data _pos _ctx _names _params _attrs _alts _ext ) =
(sem_Elem_Data _pos _ctx (sem_NontSet _names ) _params (sem_Attrs _attrs ) (sem_Alts _alts ) _ext )
sem_Elem (Deriving _pos _set _classes ) =
(sem_Elem_Deriving _pos (sem_NontSet _set ) _classes )
sem_Elem (Module _pos _name _exports _imports ) =
(sem_Elem_Module _pos _name _exports _imports )
sem_Elem (Pragma _pos _names ) =
(sem_Elem_Pragma _pos _names )
sem_Elem (Sem _pos _ctx _names _attrs _alts ) =
(sem_Elem_Sem _pos _ctx (sem_NontSet _names ) (sem_Attrs _attrs ) (sem_SemAlts _alts ) )
sem_Elem (Set _pos _name _set ) =
(sem_Elem_Set _pos _name (sem_NontSet _set ) )
sem_Elem (Txt _pos _name _mbNt _lines ) =
(sem_Elem_Txt _pos _name _mbNt _lines )
sem_Elem (Type _pos _ctx _name _params _type ) =
(sem_Elem_Type _pos _ctx _name _params _type )
sem_Elem (Wrapper _pos _set ) =
(sem_Elem_Wrapper _pos (sem_NontSet _set ) )
-- semantic domain
newtype T_Elem = T_Elem ((Map NontermIdent (Attributes, Attributes)) ->
(Map NontermIdent (Set ConstructorIdent)) ->
DataTypes ->
(Set NontermIdent) ->
(Map NontermIdent (Attributes, Attributes)) ->
(Map Identifier (Set NontermIdent,Set Identifier)) ->
DefinedSets ->
( (Map NontermIdent (Attributes, Attributes)),AttrOrderMap,Blocks,([ (NontermIdent, ConstructorIdent, [AroundInfo]) ]),([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ]),(Map NontermIdent (Set ConstructorIdent)),([(NontermIdent, ConstructorIdent, FieldMap)]),([ (NontermIdent, ConstructorIdent, [Identifier]) ]),([ (NontermIdent, ConstructorIdent, [MergeInfo]) ]),(Set Identifier),([ (NontermIdent, ConstructorIdent, RuleInfo)]),(Set Identifier),([ (NontermIdent, ConstructorIdent, SigInfo) ]),([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ]),ContextMap,(Map Identifier (Set NontermIdent,Set Identifier)),Derivings,(Seq Error),(Maybe (String,String,String)),ParamMap,(Options -> Options),PragmaMap,TypeSyns,(Map NontermIdent (Map Identifier (String,String,String))),(Set NontermIdent)))
data Inh_Elem = Inh_Elem {allAttrDecls_Inh_Elem :: !((Map NontermIdent (Attributes, Attributes))),allConstructors_Inh_Elem :: !((Map NontermIdent (Set ConstructorIdent))),allFields_Inh_Elem :: !(DataTypes),allNonterminals_Inh_Elem :: !((Set NontermIdent)),attrDecls_Inh_Elem :: !((Map NontermIdent (Attributes, Attributes))),defSets_Inh_Elem :: !((Map Identifier (Set NontermIdent,Set Identifier))),definedSets_Inh_Elem :: !(DefinedSets)}
data Syn_Elem = Syn_Elem {attrDecls_Syn_Elem :: !((Map NontermIdent (Attributes, Attributes))),attrOrderCollect_Syn_Elem :: !(AttrOrderMap),blocks_Syn_Elem :: !(Blocks),collectedArounds_Syn_Elem :: !(([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])),collectedAugments_Syn_Elem :: !(([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])),collectedConstructorsMap_Syn_Elem :: !((Map NontermIdent (Set ConstructorIdent))),collectedFields_Syn_Elem :: !(([(NontermIdent, ConstructorIdent, FieldMap)])),collectedInsts_Syn_Elem :: !(([ (NontermIdent, ConstructorIdent, [Identifier]) ])),collectedMerges_Syn_Elem :: !(([ (NontermIdent, ConstructorIdent, [MergeInfo]) ])),collectedNames_Syn_Elem :: !((Set Identifier)),collectedRules_Syn_Elem :: !(([ (NontermIdent, ConstructorIdent, RuleInfo)])),collectedSetNames_Syn_Elem :: !((Set Identifier)),collectedSigs_Syn_Elem :: !(([ (NontermIdent, ConstructorIdent, SigInfo) ])),collectedUniques_Syn_Elem :: !(([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])),ctxCollect_Syn_Elem :: !(ContextMap),defSets_Syn_Elem :: !((Map Identifier (Set NontermIdent,Set Identifier))),derivings_Syn_Elem :: !(Derivings),errors_Syn_Elem :: !((Seq Error)),moduleDecl_Syn_Elem :: !((Maybe (String,String,String))),paramsCollect_Syn_Elem :: !(ParamMap),pragmas_Syn_Elem :: !((Options -> Options)),semPragmasCollect_Syn_Elem :: !(PragmaMap),typeSyns_Syn_Elem :: !(TypeSyns),useMap_Syn_Elem :: !((Map NontermIdent (Map Identifier (String,String,String)))),wrappers_Syn_Elem :: !((Set NontermIdent))}
wrap_Elem :: T_Elem ->
Inh_Elem ->
Syn_Elem
wrap_Elem (T_Elem sem ) (Inh_Elem _lhsIallAttrDecls _lhsIallConstructors _lhsIallFields _lhsIallNonterminals _lhsIattrDecls _lhsIdefSets _lhsIdefinedSets ) =
(let ( _lhsOattrDecls,_lhsOattrOrderCollect,_lhsOblocks,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedConstructorsMap,_lhsOcollectedFields,_lhsOcollectedInsts,_lhsOcollectedMerges,_lhsOcollectedNames,_lhsOcollectedRules,_lhsOcollectedSetNames,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOctxCollect,_lhsOdefSets,_lhsOderivings,_lhsOerrors,_lhsOmoduleDecl,_lhsOparamsCollect,_lhsOpragmas,_lhsOsemPragmasCollect,_lhsOtypeSyns,_lhsOuseMap,_lhsOwrappers) = sem _lhsIallAttrDecls _lhsIallConstructors _lhsIallFields _lhsIallNonterminals _lhsIattrDecls _lhsIdefSets _lhsIdefinedSets
in (Syn_Elem _lhsOattrDecls _lhsOattrOrderCollect _lhsOblocks _lhsOcollectedArounds _lhsOcollectedAugments _lhsOcollectedConstructorsMap _lhsOcollectedFields _lhsOcollectedInsts _lhsOcollectedMerges _lhsOcollectedNames _lhsOcollectedRules _lhsOcollectedSetNames _lhsOcollectedSigs _lhsOcollectedUniques _lhsOctxCollect _lhsOdefSets _lhsOderivings _lhsOerrors _lhsOmoduleDecl _lhsOparamsCollect _lhsOpragmas _lhsOsemPragmasCollect _lhsOtypeSyns _lhsOuseMap _lhsOwrappers ))
sem_Elem_Attr :: Pos ->
ClassContext ->
T_NontSet ->
T_Attrs ->
T_Elem
sem_Elem_Attr pos_ ctx_ (T_NontSet names_ ) (T_Attrs attrs_ ) =
(T_Elem (\ _lhsIallAttrDecls
_lhsIallConstructors
_lhsIallFields
_lhsIallNonterminals
_lhsIattrDecls
_lhsIdefSets
_lhsIdefinedSets ->
(let _lhsOctxCollect :: ContextMap
_attrsOnts :: (Set NontermIdent)
_lhsOattrOrderCollect :: AttrOrderMap
_lhsOblocks :: Blocks
_lhsOcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])
_lhsOcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])
_lhsOcollectedConstructorsMap :: (Map NontermIdent (Set ConstructorIdent))
_lhsOcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)])
_lhsOcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ])
_lhsOcollectedMerges :: ([ (NontermIdent, ConstructorIdent, [MergeInfo]) ])
_lhsOcollectedNames :: (Set Identifier)
_lhsOcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)])
_lhsOcollectedSetNames :: (Set Identifier)
_lhsOcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ])
_lhsOcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])
_lhsOderivings :: Derivings
_lhsOerrors :: (Seq Error)
_lhsOmoduleDecl :: (Maybe (String,String,String))
_lhsOparamsCollect :: ParamMap
_lhsOpragmas :: (Options -> Options)
_lhsOsemPragmasCollect :: PragmaMap
_lhsOtypeSyns :: TypeSyns
_lhsOuseMap :: (Map NontermIdent (Map Identifier (String,String,String)))
_lhsOwrappers :: (Set NontermIdent)
_lhsOattrDecls :: (Map NontermIdent (Attributes, Attributes))
_lhsOdefSets :: (Map Identifier (Set NontermIdent,Set Identifier))
_namesOallFields :: DataTypes
_namesOallNonterminals :: (Set NontermIdent)
_namesOdefinedSets :: DefinedSets
_attrsOallFields :: DataTypes
_attrsOallNonterminals :: (Set NontermIdent)
_attrsOattrDecls :: (Map NontermIdent (Attributes, Attributes))
_namesIcollectedNames :: (Set Identifier)
_namesIerrors :: (Seq Error)
_namesInontSet :: (Set NontermIdent)
_attrsIattrDecls :: (Map NontermIdent (Attributes, Attributes))
_attrsIerrors :: (Seq Error)
_attrsIuseMap :: (Map NontermIdent (Map Identifier (String,String,String)))
-- "Transform.ag"(line 839, column 7)
_lhsOctxCollect =
({-# LINE 839 "Transform.ag" #-}
if null ctx_
then Map.empty
else Map.fromList [(nt, ctx_) | nt <- Set.toList _namesInontSet]
{-# LINE 1516 "Transform.hs" #-})
-- "Transform.ag"(line 883, column 10)
_attrsOnts =
({-# LINE 883 "Transform.ag" #-}
_namesInontSet
{-# LINE 1521 "Transform.hs" #-})
-- use rule "Transform.ag"(line 780, column 55)
_lhsOattrOrderCollect =
({-# LINE 780 "Transform.ag" #-}
Map.empty
{-# LINE 1526 "Transform.hs" #-})
-- use rule "Transform.ag"(line 44, column 19)
_lhsOblocks =
({-# LINE 44 "Transform.ag" #-}
Map.empty
{-# LINE 1531 "Transform.hs" #-})
-- use rule "Transform.ag"(line 155, column 32)
_lhsOcollectedArounds =
({-# LINE 155 "Transform.ag" #-}
[]
{-# LINE 1536 "Transform.hs" #-})
-- use rule "Transform.ag"(line 154, column 32)
_lhsOcollectedAugments =
({-# LINE 154 "Transform.ag" #-}
[]
{-# LINE 1541 "Transform.hs" #-})
-- use rule "Transform.ag"(line 93, column 48)
_lhsOcollectedConstructorsMap =
({-# LINE 93 "Transform.ag" #-}
Map.empty
{-# LINE 1546 "Transform.hs" #-})
-- use rule "Transform.ag"(line 124, column 28)
_lhsOcollectedFields =
({-# LINE 124 "Transform.ag" #-}
[]
{-# LINE 1551 "Transform.hs" #-})
-- use rule "Transform.ag"(line 152, column 32)
_lhsOcollectedInsts =
({-# LINE 152 "Transform.ag" #-}
[]
{-# LINE 1556 "Transform.hs" #-})
-- use rule "Transform.ag"(line 156, column 32)
_lhsOcollectedMerges =
({-# LINE 156 "Transform.ag" #-}
[]
{-# LINE 1561 "Transform.hs" #-})
-- use rule "Transform.ag"(line 85, column 50)
_lhsOcollectedNames =
({-# LINE 85 "Transform.ag" #-}
_namesIcollectedNames
{-# LINE 1566 "Transform.hs" #-})
-- use rule "Transform.ag"(line 150, column 32)
_lhsOcollectedRules =
({-# LINE 150 "Transform.ag" #-}
[]
{-# LINE 1571 "Transform.hs" #-})
-- use rule "Transform.ag"(line 84, column 50)
_lhsOcollectedSetNames =
({-# LINE 84 "Transform.ag" #-}
Set.empty
{-# LINE 1576 "Transform.hs" #-})
-- use rule "Transform.ag"(line 151, column 32)
_lhsOcollectedSigs =
({-# LINE 151 "Transform.ag" #-}
[]
{-# LINE 1581 "Transform.hs" #-})
-- use rule "Transform.ag"(line 153, column 32)
_lhsOcollectedUniques =
({-# LINE 153 "Transform.ag" #-}
[]
{-# LINE 1586 "Transform.hs" #-})
-- use rule "Transform.ag"(line 860, column 33)
_lhsOderivings =
({-# LINE 860 "Transform.ag" #-}
Map.empty
{-# LINE 1591 "Transform.hs" #-})
-- use rule "Transform.ag"(line 42, column 19)
_lhsOerrors =
({-# LINE 42 "Transform.ag" #-}
_namesIerrors Seq.>< _attrsIerrors
{-# LINE 1596 "Transform.hs" #-})
-- use rule "Transform.ag"(line 1041, column 37)
_lhsOmoduleDecl =
({-# LINE 1041 "Transform.ag" #-}
mzero
{-# LINE 1601 "Transform.hs" #-})
-- use rule "Transform.ag"(line 812, column 37)
_lhsOparamsCollect =
({-# LINE 812 "Transform.ag" #-}
Map.empty
{-# LINE 1606 "Transform.hs" #-})
-- use rule "Transform.ag"(line 706, column 34)
_lhsOpragmas =
({-# LINE 706 "Transform.ag" #-}
id
{-# LINE 1611 "Transform.hs" #-})
-- use rule "Transform.ag"(line 752, column 56)
_lhsOsemPragmasCollect =
({-# LINE 752 "Transform.ag" #-}
Map.empty
{-# LINE 1616 "Transform.hs" #-})
-- use rule "Transform.ag"(line 566, column 32)
_lhsOtypeSyns =
({-# LINE 566 "Transform.ag" #-}
[]
{-# LINE 1621 "Transform.hs" #-})
-- use rule "Transform.ag"(line 136, column 15)
_lhsOuseMap =
({-# LINE 136 "Transform.ag" #-}
_attrsIuseMap
{-# LINE 1626 "Transform.hs" #-})
-- use rule "Transform.ag"(line 697, column 32)
_lhsOwrappers =
({-# LINE 697 "Transform.ag" #-}
Set.empty
{-# LINE 1631 "Transform.hs" #-})
-- copy rule (up)
_lhsOattrDecls =
({-# LINE 135 "Transform.ag" #-}
_attrsIattrDecls
{-# LINE 1636 "Transform.hs" #-})
-- copy rule (chain)
_lhsOdefSets =
({-# LINE 103 "Transform.ag" #-}
_lhsIdefSets
{-# LINE 1641 "Transform.hs" #-})
-- copy rule (down)
_namesOallFields =
({-# LINE 127 "Transform.ag" #-}
_lhsIallFields
{-# LINE 1646 "Transform.hs" #-})
-- copy rule (down)
_namesOallNonterminals =
({-# LINE 87 "Transform.ag" #-}
_lhsIallNonterminals
{-# LINE 1651 "Transform.hs" #-})
-- copy rule (down)
_namesOdefinedSets =
({-# LINE 106 "Transform.ag" #-}
_lhsIdefinedSets
{-# LINE 1656 "Transform.hs" #-})
-- copy rule (down)
_attrsOallFields =
({-# LINE 127 "Transform.ag" #-}
_lhsIallFields
{-# LINE 1661 "Transform.hs" #-})
-- copy rule (down)
_attrsOallNonterminals =
({-# LINE 87 "Transform.ag" #-}
_lhsIallNonterminals
{-# LINE 1666 "Transform.hs" #-})
-- copy rule (down)
_attrsOattrDecls =
({-# LINE 135 "Transform.ag" #-}
_lhsIattrDecls
{-# LINE 1671 "Transform.hs" #-})
( _namesIcollectedNames,_namesIerrors,_namesInontSet) =
names_ _namesOallFields _namesOallNonterminals _namesOdefinedSets
( _attrsIattrDecls,_attrsIerrors,_attrsIuseMap) =
attrs_ _attrsOallFields _attrsOallNonterminals _attrsOattrDecls _attrsOnts
in ( _lhsOattrDecls,_lhsOattrOrderCollect,_lhsOblocks,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedConstructorsMap,_lhsOcollectedFields,_lhsOcollectedInsts,_lhsOcollectedMerges,_lhsOcollectedNames,_lhsOcollectedRules,_lhsOcollectedSetNames,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOctxCollect,_lhsOdefSets,_lhsOderivings,_lhsOerrors,_lhsOmoduleDecl,_lhsOparamsCollect,_lhsOpragmas,_lhsOsemPragmasCollect,_lhsOtypeSyns,_lhsOuseMap,_lhsOwrappers))) )
sem_Elem_Data :: Pos ->
ClassContext ->
T_NontSet ->
([Identifier]) ->
T_Attrs ->
T_Alts ->
Bool ->
T_Elem
sem_Elem_Data pos_ ctx_ (T_NontSet names_ ) params_ (T_Attrs attrs_ ) (T_Alts alts_ ) ext_ =
(T_Elem (\ _lhsIallAttrDecls
_lhsIallConstructors
_lhsIallFields
_lhsIallNonterminals
_lhsIattrDecls
_lhsIdefSets
_lhsIdefinedSets ->
(let _altsOnts :: (Set NontermIdent)
_lhsOcollectedConstructorsMap :: (Map NontermIdent (Set ConstructorIdent))
_lhsOparamsCollect :: ParamMap
_lhsOctxCollect :: ContextMap
_attrsOnts :: (Set NontermIdent)
_lhsOattrOrderCollect :: AttrOrderMap
_lhsOblocks :: Blocks
_lhsOcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])
_lhsOcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])
_lhsOcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)])
_lhsOcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ])
_lhsOcollectedMerges :: ([ (NontermIdent, ConstructorIdent, [MergeInfo]) ])
_lhsOcollectedNames :: (Set Identifier)
_lhsOcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)])
_lhsOcollectedSetNames :: (Set Identifier)
_lhsOcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ])
_lhsOcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])
_lhsOderivings :: Derivings
_lhsOerrors :: (Seq Error)
_lhsOmoduleDecl :: (Maybe (String,String,String))
_lhsOpragmas :: (Options -> Options)
_lhsOsemPragmasCollect :: PragmaMap
_lhsOtypeSyns :: TypeSyns
_lhsOuseMap :: (Map NontermIdent (Map Identifier (String,String,String)))
_lhsOwrappers :: (Set NontermIdent)
_lhsOattrDecls :: (Map NontermIdent (Attributes, Attributes))
_lhsOdefSets :: (Map Identifier (Set NontermIdent,Set Identifier))
_namesOallFields :: DataTypes
_namesOallNonterminals :: (Set NontermIdent)
_namesOdefinedSets :: DefinedSets
_attrsOallFields :: DataTypes
_attrsOallNonterminals :: (Set NontermIdent)
_attrsOattrDecls :: (Map NontermIdent (Attributes, Attributes))
_altsOallConstructors :: (Map NontermIdent (Set ConstructorIdent))
_altsOallNonterminals :: (Set NontermIdent)
_namesIcollectedNames :: (Set Identifier)
_namesIerrors :: (Seq Error)
_namesInontSet :: (Set NontermIdent)
_attrsIattrDecls :: (Map NontermIdent (Attributes, Attributes))
_attrsIerrors :: (Seq Error)
_attrsIuseMap :: (Map NontermIdent (Map Identifier (String,String,String)))
_altsIcollectedConstructorNames :: (Set ConstructorIdent)
_altsIcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)])
-- "Transform.ag"(line 169, column 10)
_altsOnts =
({-# LINE 169 "Transform.ag" #-}
_namesInontSet
{-# LINE 1740 "Transform.hs" #-})
-- "Transform.ag"(line 545, column 11)
_lhsOcollectedConstructorsMap =
({-# LINE 545 "Transform.ag" #-}
Map.fromList
[ (n, _altsIcollectedConstructorNames)
| n <- Set.toList _namesInontSet
]
{-# LINE 1748 "Transform.hs" #-})
-- "Transform.ag"(line 816, column 7)
_lhsOparamsCollect =
({-# LINE 816 "Transform.ag" #-}
if null params_
then Map.empty
else Map.fromList [(nt, params_) | nt <- Set.toList _namesInontSet]
{-# LINE 1755 "Transform.hs" #-})
-- "Transform.ag"(line 839, column 7)
_lhsOctxCollect =
({-# LINE 839 "Transform.ag" #-}
if null ctx_
then Map.empty
else Map.fromList [(nt, ctx_) | nt <- Set.toList _namesInontSet]
{-# LINE 1762 "Transform.hs" #-})
-- "Transform.ag"(line 882, column 10)
_attrsOnts =
({-# LINE 882 "Transform.ag" #-}
_namesInontSet
{-# LINE 1767 "Transform.hs" #-})
-- use rule "Transform.ag"(line 780, column 55)
_lhsOattrOrderCollect =
({-# LINE 780 "Transform.ag" #-}
Map.empty
{-# LINE 1772 "Transform.hs" #-})
-- use rule "Transform.ag"(line 44, column 19)
_lhsOblocks =
({-# LINE 44 "Transform.ag" #-}
Map.empty
{-# LINE 1777 "Transform.hs" #-})
-- use rule "Transform.ag"(line 155, column 32)
_lhsOcollectedArounds =
({-# LINE 155 "Transform.ag" #-}
[]
{-# LINE 1782 "Transform.hs" #-})
-- use rule "Transform.ag"(line 154, column 32)
_lhsOcollectedAugments =
({-# LINE 154 "Transform.ag" #-}
[]
{-# LINE 1787 "Transform.hs" #-})
-- use rule "Transform.ag"(line 124, column 28)
_lhsOcollectedFields =
({-# LINE 124 "Transform.ag" #-}
_altsIcollectedFields
{-# LINE 1792 "Transform.hs" #-})
-- use rule "Transform.ag"(line 152, column 32)
_lhsOcollectedInsts =
({-# LINE 152 "Transform.ag" #-}
[]
{-# LINE 1797 "Transform.hs" #-})
-- use rule "Transform.ag"(line 156, column 32)
_lhsOcollectedMerges =
({-# LINE 156 "Transform.ag" #-}
[]
{-# LINE 1802 "Transform.hs" #-})
-- use rule "Transform.ag"(line 85, column 50)
_lhsOcollectedNames =
({-# LINE 85 "Transform.ag" #-}
_namesIcollectedNames
{-# LINE 1807 "Transform.hs" #-})
-- use rule "Transform.ag"(line 150, column 32)
_lhsOcollectedRules =
({-# LINE 150 "Transform.ag" #-}
[]
{-# LINE 1812 "Transform.hs" #-})
-- use rule "Transform.ag"(line 84, column 50)
_lhsOcollectedSetNames =
({-# LINE 84 "Transform.ag" #-}
Set.empty
{-# LINE 1817 "Transform.hs" #-})
-- use rule "Transform.ag"(line 151, column 32)
_lhsOcollectedSigs =
({-# LINE 151 "Transform.ag" #-}
[]
{-# LINE 1822 "Transform.hs" #-})
-- use rule "Transform.ag"(line 153, column 32)
_lhsOcollectedUniques =
({-# LINE 153 "Transform.ag" #-}
[]
{-# LINE 1827 "Transform.hs" #-})
-- use rule "Transform.ag"(line 860, column 33)
_lhsOderivings =
({-# LINE 860 "Transform.ag" #-}
Map.empty
{-# LINE 1832 "Transform.hs" #-})
-- use rule "Transform.ag"(line 42, column 19)
_lhsOerrors =
({-# LINE 42 "Transform.ag" #-}
_namesIerrors Seq.>< _attrsIerrors
{-# LINE 1837 "Transform.hs" #-})
-- use rule "Transform.ag"(line 1041, column 37)
_lhsOmoduleDecl =
({-# LINE 1041 "Transform.ag" #-}
mzero
{-# LINE 1842 "Transform.hs" #-})
-- use rule "Transform.ag"(line 706, column 34)
_lhsOpragmas =
({-# LINE 706 "Transform.ag" #-}
id
{-# LINE 1847 "Transform.hs" #-})
-- use rule "Transform.ag"(line 752, column 56)
_lhsOsemPragmasCollect =
({-# LINE 752 "Transform.ag" #-}
Map.empty
{-# LINE 1852 "Transform.hs" #-})
-- use rule "Transform.ag"(line 566, column 32)
_lhsOtypeSyns =
({-# LINE 566 "Transform.ag" #-}
[]
{-# LINE 1857 "Transform.hs" #-})
-- use rule "Transform.ag"(line 136, column 15)
_lhsOuseMap =
({-# LINE 136 "Transform.ag" #-}
_attrsIuseMap
{-# LINE 1862 "Transform.hs" #-})
-- use rule "Transform.ag"(line 697, column 32)
_lhsOwrappers =
({-# LINE 697 "Transform.ag" #-}
Set.empty
{-# LINE 1867 "Transform.hs" #-})
-- copy rule (up)
_lhsOattrDecls =
({-# LINE 135 "Transform.ag" #-}
_attrsIattrDecls
{-# LINE 1872 "Transform.hs" #-})
-- copy rule (chain)
_lhsOdefSets =
({-# LINE 103 "Transform.ag" #-}
_lhsIdefSets
{-# LINE 1877 "Transform.hs" #-})
-- copy rule (down)
_namesOallFields =
({-# LINE 127 "Transform.ag" #-}
_lhsIallFields
{-# LINE 1882 "Transform.hs" #-})
-- copy rule (down)
_namesOallNonterminals =
({-# LINE 87 "Transform.ag" #-}
_lhsIallNonterminals
{-# LINE 1887 "Transform.hs" #-})
-- copy rule (down)
_namesOdefinedSets =
({-# LINE 106 "Transform.ag" #-}
_lhsIdefinedSets
{-# LINE 1892 "Transform.hs" #-})
-- copy rule (down)
_attrsOallFields =
({-# LINE 127 "Transform.ag" #-}
_lhsIallFields
{-# LINE 1897 "Transform.hs" #-})
-- copy rule (down)
_attrsOallNonterminals =
({-# LINE 87 "Transform.ag" #-}
_lhsIallNonterminals
{-# LINE 1902 "Transform.hs" #-})
-- copy rule (down)
_attrsOattrDecls =
({-# LINE 135 "Transform.ag" #-}
_lhsIattrDecls
{-# LINE 1907 "Transform.hs" #-})
-- copy rule (down)
_altsOallConstructors =
({-# LINE 95 "Transform.ag" #-}
_lhsIallConstructors
{-# LINE 1912 "Transform.hs" #-})
-- copy rule (down)
_altsOallNonterminals =
({-# LINE 87 "Transform.ag" #-}
_lhsIallNonterminals
{-# LINE 1917 "Transform.hs" #-})
( _namesIcollectedNames,_namesIerrors,_namesInontSet) =
names_ _namesOallFields _namesOallNonterminals _namesOdefinedSets
( _attrsIattrDecls,_attrsIerrors,_attrsIuseMap) =
attrs_ _attrsOallFields _attrsOallNonterminals _attrsOattrDecls _attrsOnts
( _altsIcollectedConstructorNames,_altsIcollectedFields) =
alts_ _altsOallConstructors _altsOallNonterminals _altsOnts
in ( _lhsOattrDecls,_lhsOattrOrderCollect,_lhsOblocks,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedConstructorsMap,_lhsOcollectedFields,_lhsOcollectedInsts,_lhsOcollectedMerges,_lhsOcollectedNames,_lhsOcollectedRules,_lhsOcollectedSetNames,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOctxCollect,_lhsOdefSets,_lhsOderivings,_lhsOerrors,_lhsOmoduleDecl,_lhsOparamsCollect,_lhsOpragmas,_lhsOsemPragmasCollect,_lhsOtypeSyns,_lhsOuseMap,_lhsOwrappers))) )
sem_Elem_Deriving :: Pos ->
T_NontSet ->
([NontermIdent]) ->
T_Elem
sem_Elem_Deriving pos_ (T_NontSet set_ ) classes_ =
(T_Elem (\ _lhsIallAttrDecls
_lhsIallConstructors
_lhsIallFields
_lhsIallNonterminals
_lhsIattrDecls
_lhsIdefSets
_lhsIdefinedSets ->
(let _lhsOderivings :: Derivings
_lhsOattrOrderCollect :: AttrOrderMap
_lhsOblocks :: Blocks
_lhsOcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])
_lhsOcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])
_lhsOcollectedConstructorsMap :: (Map NontermIdent (Set ConstructorIdent))
_lhsOcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)])
_lhsOcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ])
_lhsOcollectedMerges :: ([ (NontermIdent, ConstructorIdent, [MergeInfo]) ])
_lhsOcollectedNames :: (Set Identifier)
_lhsOcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)])
_lhsOcollectedSetNames :: (Set Identifier)
_lhsOcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ])
_lhsOcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])
_lhsOctxCollect :: ContextMap
_lhsOerrors :: (Seq Error)
_lhsOmoduleDecl :: (Maybe (String,String,String))
_lhsOparamsCollect :: ParamMap
_lhsOpragmas :: (Options -> Options)
_lhsOsemPragmasCollect :: PragmaMap
_lhsOtypeSyns :: TypeSyns
_lhsOuseMap :: (Map NontermIdent (Map Identifier (String,String,String)))
_lhsOwrappers :: (Set NontermIdent)
_lhsOattrDecls :: (Map NontermIdent (Attributes, Attributes))
_lhsOdefSets :: (Map Identifier (Set NontermIdent,Set Identifier))
_setOallFields :: DataTypes
_setOallNonterminals :: (Set NontermIdent)
_setOdefinedSets :: DefinedSets
_setIcollectedNames :: (Set Identifier)
_setIerrors :: (Seq Error)
_setInontSet :: (Set NontermIdent)
-- "Transform.ag"(line 867, column 14)
_lhsOderivings =
({-# LINE 867 "Transform.ag" #-}
Map.fromList [(nt,Set.fromList classes_) | nt <- Set.toList _setInontSet]
{-# LINE 1972 "Transform.hs" #-})
-- use rule "Transform.ag"(line 780, column 55)
_lhsOattrOrderCollect =
({-# LINE 780 "Transform.ag" #-}
Map.empty
{-# LINE 1977 "Transform.hs" #-})
-- use rule "Transform.ag"(line 44, column 19)
_lhsOblocks =
({-# LINE 44 "Transform.ag" #-}
Map.empty
{-# LINE 1982 "Transform.hs" #-})
-- use rule "Transform.ag"(line 155, column 32)
_lhsOcollectedArounds =
({-# LINE 155 "Transform.ag" #-}
[]
{-# LINE 1987 "Transform.hs" #-})
-- use rule "Transform.ag"(line 154, column 32)
_lhsOcollectedAugments =
({-# LINE 154 "Transform.ag" #-}
[]
{-# LINE 1992 "Transform.hs" #-})
-- use rule "Transform.ag"(line 93, column 48)
_lhsOcollectedConstructorsMap =
({-# LINE 93 "Transform.ag" #-}
Map.empty
{-# LINE 1997 "Transform.hs" #-})
-- use rule "Transform.ag"(line 124, column 28)
_lhsOcollectedFields =
({-# LINE 124 "Transform.ag" #-}
[]
{-# LINE 2002 "Transform.hs" #-})
-- use rule "Transform.ag"(line 152, column 32)
_lhsOcollectedInsts =
({-# LINE 152 "Transform.ag" #-}
[]
{-# LINE 2007 "Transform.hs" #-})
-- use rule "Transform.ag"(line 156, column 32)
_lhsOcollectedMerges =
({-# LINE 156 "Transform.ag" #-}
[]
{-# LINE 2012 "Transform.hs" #-})
-- use rule "Transform.ag"(line 85, column 50)
_lhsOcollectedNames =
({-# LINE 85 "Transform.ag" #-}
_setIcollectedNames
{-# LINE 2017 "Transform.hs" #-})
-- use rule "Transform.ag"(line 150, column 32)
_lhsOcollectedRules =
({-# LINE 150 "Transform.ag" #-}
[]
{-# LINE 2022 "Transform.hs" #-})
-- use rule "Transform.ag"(line 84, column 50)
_lhsOcollectedSetNames =
({-# LINE 84 "Transform.ag" #-}
Set.empty
{-# LINE 2027 "Transform.hs" #-})
-- use rule "Transform.ag"(line 151, column 32)
_lhsOcollectedSigs =
({-# LINE 151 "Transform.ag" #-}
[]
{-# LINE 2032 "Transform.hs" #-})
-- use rule "Transform.ag"(line 153, column 32)
_lhsOcollectedUniques =
({-# LINE 153 "Transform.ag" #-}
[]
{-# LINE 2037 "Transform.hs" #-})
-- use rule "Transform.ag"(line 835, column 34)
_lhsOctxCollect =
({-# LINE 835 "Transform.ag" #-}
Map.empty
{-# LINE 2042 "Transform.hs" #-})
-- use rule "Transform.ag"(line 42, column 19)
_lhsOerrors =
({-# LINE 42 "Transform.ag" #-}
_setIerrors
{-# LINE 2047 "Transform.hs" #-})
-- use rule "Transform.ag"(line 1041, column 37)
_lhsOmoduleDecl =
({-# LINE 1041 "Transform.ag" #-}
mzero
{-# LINE 2052 "Transform.hs" #-})
-- use rule "Transform.ag"(line 812, column 37)
_lhsOparamsCollect =
({-# LINE 812 "Transform.ag" #-}
Map.empty
{-# LINE 2057 "Transform.hs" #-})
-- use rule "Transform.ag"(line 706, column 34)
_lhsOpragmas =
({-# LINE 706 "Transform.ag" #-}
id
{-# LINE 2062 "Transform.hs" #-})
-- use rule "Transform.ag"(line 752, column 56)
_lhsOsemPragmasCollect =
({-# LINE 752 "Transform.ag" #-}
Map.empty
{-# LINE 2067 "Transform.hs" #-})
-- use rule "Transform.ag"(line 566, column 32)
_lhsOtypeSyns =
({-# LINE 566 "Transform.ag" #-}
[]
{-# LINE 2072 "Transform.hs" #-})
-- use rule "Transform.ag"(line 136, column 15)
_lhsOuseMap =
({-# LINE 136 "Transform.ag" #-}
Map.empty
{-# LINE 2077 "Transform.hs" #-})
-- use rule "Transform.ag"(line 697, column 32)
_lhsOwrappers =
({-# LINE 697 "Transform.ag" #-}
Set.empty
{-# LINE 2082 "Transform.hs" #-})
-- copy rule (chain)
_lhsOattrDecls =
({-# LINE 135 "Transform.ag" #-}
_lhsIattrDecls
{-# LINE 2087 "Transform.hs" #-})
-- copy rule (chain)
_lhsOdefSets =
({-# LINE 103 "Transform.ag" #-}
_lhsIdefSets
{-# LINE 2092 "Transform.hs" #-})
-- copy rule (down)
_setOallFields =
({-# LINE 127 "Transform.ag" #-}
_lhsIallFields
{-# LINE 2097 "Transform.hs" #-})
-- copy rule (down)
_setOallNonterminals =
({-# LINE 87 "Transform.ag" #-}
_lhsIallNonterminals
{-# LINE 2102 "Transform.hs" #-})
-- copy rule (down)
_setOdefinedSets =
({-# LINE 106 "Transform.ag" #-}
_lhsIdefinedSets
{-# LINE 2107 "Transform.hs" #-})
( _setIcollectedNames,_setIerrors,_setInontSet) =
set_ _setOallFields _setOallNonterminals _setOdefinedSets
in ( _lhsOattrDecls,_lhsOattrOrderCollect,_lhsOblocks,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedConstructorsMap,_lhsOcollectedFields,_lhsOcollectedInsts,_lhsOcollectedMerges,_lhsOcollectedNames,_lhsOcollectedRules,_lhsOcollectedSetNames,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOctxCollect,_lhsOdefSets,_lhsOderivings,_lhsOerrors,_lhsOmoduleDecl,_lhsOparamsCollect,_lhsOpragmas,_lhsOsemPragmasCollect,_lhsOtypeSyns,_lhsOuseMap,_lhsOwrappers))) )
sem_Elem_Module :: Pos ->
String ->
String ->
String ->
T_Elem
sem_Elem_Module pos_ name_ exports_ imports_ =
(T_Elem (\ _lhsIallAttrDecls
_lhsIallConstructors
_lhsIallFields
_lhsIallNonterminals
_lhsIattrDecls
_lhsIdefSets
_lhsIdefinedSets ->
(let _lhsOmoduleDecl :: (Maybe (String,String,String))
_lhsOattrOrderCollect :: AttrOrderMap
_lhsOblocks :: Blocks
_lhsOcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])
_lhsOcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])
_lhsOcollectedConstructorsMap :: (Map NontermIdent (Set ConstructorIdent))
_lhsOcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)])
_lhsOcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ])
_lhsOcollectedMerges :: ([ (NontermIdent, ConstructorIdent, [MergeInfo]) ])
_lhsOcollectedNames :: (Set Identifier)
_lhsOcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)])
_lhsOcollectedSetNames :: (Set Identifier)
_lhsOcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ])
_lhsOcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])
_lhsOctxCollect :: ContextMap
_lhsOderivings :: Derivings
_lhsOerrors :: (Seq Error)
_lhsOparamsCollect :: ParamMap
_lhsOpragmas :: (Options -> Options)
_lhsOsemPragmasCollect :: PragmaMap
_lhsOtypeSyns :: TypeSyns
_lhsOuseMap :: (Map NontermIdent (Map Identifier (String,String,String)))
_lhsOwrappers :: (Set NontermIdent)
_lhsOattrDecls :: (Map NontermIdent (Attributes, Attributes))
_lhsOdefSets :: (Map Identifier (Set NontermIdent,Set Identifier))
-- "Transform.ag"(line 1045, column 7)
_lhsOmoduleDecl =
({-# LINE 1045 "Transform.ag" #-}
Just (name_, exports_, imports_)
{-# LINE 2153 "Transform.hs" #-})
-- use rule "Transform.ag"(line 780, column 55)
_lhsOattrOrderCollect =
({-# LINE 780 "Transform.ag" #-}
Map.empty
{-# LINE 2158 "Transform.hs" #-})
-- use rule "Transform.ag"(line 44, column 19)
_lhsOblocks =
({-# LINE 44 "Transform.ag" #-}
Map.empty
{-# LINE 2163 "Transform.hs" #-})
-- use rule "Transform.ag"(line 155, column 32)
_lhsOcollectedArounds =
({-# LINE 155 "Transform.ag" #-}
[]
{-# LINE 2168 "Transform.hs" #-})
-- use rule "Transform.ag"(line 154, column 32)
_lhsOcollectedAugments =
({-# LINE 154 "Transform.ag" #-}
[]
{-# LINE 2173 "Transform.hs" #-})
-- use rule "Transform.ag"(line 93, column 48)
_lhsOcollectedConstructorsMap =
({-# LINE 93 "Transform.ag" #-}
Map.empty
{-# LINE 2178 "Transform.hs" #-})
-- use rule "Transform.ag"(line 124, column 28)
_lhsOcollectedFields =
({-# LINE 124 "Transform.ag" #-}
[]
{-# LINE 2183 "Transform.hs" #-})
-- use rule "Transform.ag"(line 152, column 32)
_lhsOcollectedInsts =
({-# LINE 152 "Transform.ag" #-}
[]
{-# LINE 2188 "Transform.hs" #-})
-- use rule "Transform.ag"(line 156, column 32)
_lhsOcollectedMerges =
({-# LINE 156 "Transform.ag" #-}
[]
{-# LINE 2193 "Transform.hs" #-})
-- use rule "Transform.ag"(line 85, column 50)
_lhsOcollectedNames =
({-# LINE 85 "Transform.ag" #-}
Set.empty
{-# LINE 2198 "Transform.hs" #-})
-- use rule "Transform.ag"(line 150, column 32)
_lhsOcollectedRules =
({-# LINE 150 "Transform.ag" #-}
[]
{-# LINE 2203 "Transform.hs" #-})
-- use rule "Transform.ag"(line 84, column 50)
_lhsOcollectedSetNames =
({-# LINE 84 "Transform.ag" #-}
Set.empty
{-# LINE 2208 "Transform.hs" #-})
-- use rule "Transform.ag"(line 151, column 32)
_lhsOcollectedSigs =
({-# LINE 151 "Transform.ag" #-}
[]
{-# LINE 2213 "Transform.hs" #-})
-- use rule "Transform.ag"(line 153, column 32)
_lhsOcollectedUniques =
({-# LINE 153 "Transform.ag" #-}
[]
{-# LINE 2218 "Transform.hs" #-})
-- use rule "Transform.ag"(line 835, column 34)
_lhsOctxCollect =
({-# LINE 835 "Transform.ag" #-}
Map.empty
{-# LINE 2223 "Transform.hs" #-})
-- use rule "Transform.ag"(line 860, column 33)
_lhsOderivings =
({-# LINE 860 "Transform.ag" #-}
Map.empty
{-# LINE 2228 "Transform.hs" #-})
-- use rule "Transform.ag"(line 42, column 19)
_lhsOerrors =
({-# LINE 42 "Transform.ag" #-}
Seq.empty
{-# LINE 2233 "Transform.hs" #-})
-- use rule "Transform.ag"(line 812, column 37)
_lhsOparamsCollect =
({-# LINE 812 "Transform.ag" #-}
Map.empty
{-# LINE 2238 "Transform.hs" #-})
-- use rule "Transform.ag"(line 706, column 34)
_lhsOpragmas =
({-# LINE 706 "Transform.ag" #-}
id
{-# LINE 2243 "Transform.hs" #-})
-- use rule "Transform.ag"(line 752, column 56)
_lhsOsemPragmasCollect =
({-# LINE 752 "Transform.ag" #-}
Map.empty
{-# LINE 2248 "Transform.hs" #-})
-- use rule "Transform.ag"(line 566, column 32)
_lhsOtypeSyns =
({-# LINE 566 "Transform.ag" #-}
[]
{-# LINE 2253 "Transform.hs" #-})
-- use rule "Transform.ag"(line 136, column 15)
_lhsOuseMap =
({-# LINE 136 "Transform.ag" #-}
Map.empty
{-# LINE 2258 "Transform.hs" #-})
-- use rule "Transform.ag"(line 697, column 32)
_lhsOwrappers =
({-# LINE 697 "Transform.ag" #-}
Set.empty
{-# LINE 2263 "Transform.hs" #-})
-- copy rule (chain)
_lhsOattrDecls =
({-# LINE 135 "Transform.ag" #-}
_lhsIattrDecls
{-# LINE 2268 "Transform.hs" #-})
-- copy rule (chain)
_lhsOdefSets =
({-# LINE 103 "Transform.ag" #-}
_lhsIdefSets
{-# LINE 2273 "Transform.hs" #-})
in ( _lhsOattrDecls,_lhsOattrOrderCollect,_lhsOblocks,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedConstructorsMap,_lhsOcollectedFields,_lhsOcollectedInsts,_lhsOcollectedMerges,_lhsOcollectedNames,_lhsOcollectedRules,_lhsOcollectedSetNames,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOctxCollect,_lhsOdefSets,_lhsOderivings,_lhsOerrors,_lhsOmoduleDecl,_lhsOparamsCollect,_lhsOpragmas,_lhsOsemPragmasCollect,_lhsOtypeSyns,_lhsOuseMap,_lhsOwrappers))) )
sem_Elem_Pragma :: Pos ->
([NontermIdent]) ->
T_Elem
sem_Elem_Pragma pos_ names_ =
(T_Elem (\ _lhsIallAttrDecls
_lhsIallConstructors
_lhsIallFields
_lhsIallNonterminals
_lhsIattrDecls
_lhsIdefSets
_lhsIdefinedSets ->
(let _lhsOpragmas :: (Options -> Options)
_lhsOattrOrderCollect :: AttrOrderMap
_lhsOblocks :: Blocks
_lhsOcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])
_lhsOcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])
_lhsOcollectedConstructorsMap :: (Map NontermIdent (Set ConstructorIdent))
_lhsOcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)])
_lhsOcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ])
_lhsOcollectedMerges :: ([ (NontermIdent, ConstructorIdent, [MergeInfo]) ])
_lhsOcollectedNames :: (Set Identifier)
_lhsOcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)])
_lhsOcollectedSetNames :: (Set Identifier)
_lhsOcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ])
_lhsOcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])
_lhsOctxCollect :: ContextMap
_lhsOderivings :: Derivings
_lhsOerrors :: (Seq Error)
_lhsOmoduleDecl :: (Maybe (String,String,String))
_lhsOparamsCollect :: ParamMap
_lhsOsemPragmasCollect :: PragmaMap
_lhsOtypeSyns :: TypeSyns
_lhsOuseMap :: (Map NontermIdent (Map Identifier (String,String,String)))
_lhsOwrappers :: (Set NontermIdent)
_lhsOattrDecls :: (Map NontermIdent (Attributes, Attributes))
_lhsOdefSets :: (Map Identifier (Set NontermIdent,Set Identifier))
-- "Transform.ag"(line 709, column 13)
_lhsOpragmas =
({-# LINE 709 "Transform.ag" #-}
let mk n o = case getName n of
"gencatas" -> o { folds = True }
"nogencatas" -> o { folds = False }
"gendatas" -> o { dataTypes = True }
"nogendatas" -> o { dataTypes = False }
"gensems" -> o { semfuns = True }
"nogensems" -> o { semfuns = False }
"gentypesigs" -> o { typeSigs = True }
"nogentypesigs"-> o { typeSigs = False }
"nocycle" -> o { withCycle = False }
"cycle" -> o { withCycle = True }
"nostrictdata" -> o { strictData = False }
"strictdata" -> o { strictData = True }
"nostrictcase" -> o { strictCases = False }
"strictcase" -> o { strictCases = True }
"strictercase" -> o { strictCases = True, stricterCases = True }
"nostrictwrap" -> o { strictWrap = False }
"strictwrap" -> o { strictWrap = True }
"novisit" -> o { visit = False }
"visit" -> o { visit = True }
"nocase" -> o { cases = False }
"case" -> o { cases = True }
"noseq" -> o { withSeq = False }
"seq" -> o { withSeq = True }
"nounbox" -> o { unbox = False }
"unbox" -> o { unbox = True }
"bangpats" -> o { bangpats = True }
"breadthfirst" -> o { breadthFirst = True }
"breadthfirstStrict" -> o { breadthFirstStrict = True }
"nooptimize" -> o { cases = False , visit = False }
"optimize" -> o { cases = True , visit = True }
"strictsem" -> o { strictSems = True }
"gentraces" -> o { genTraces = True }
"genusetraces" -> o { genUseTraces = True }
"splitsems" -> o { splitSems = True }
"gencostcentres" -> o { genCostCentres = True }
"sepsemmods" -> o { sepSemMods = True }
"genlinepragmas" -> o { genLinePragmas = True }
"newtypes" -> o { newtypes = True }
"nonewtypes" -> o { newtypes = False }
_ -> o
in \o -> foldr mk o names_
{-# LINE 2356 "Transform.hs" #-})
-- use rule "Transform.ag"(line 780, column 55)
_lhsOattrOrderCollect =
({-# LINE 780 "Transform.ag" #-}
Map.empty
{-# LINE 2361 "Transform.hs" #-})
-- use rule "Transform.ag"(line 44, column 19)
_lhsOblocks =
({-# LINE 44 "Transform.ag" #-}
Map.empty
{-# LINE 2366 "Transform.hs" #-})
-- use rule "Transform.ag"(line 155, column 32)
_lhsOcollectedArounds =
({-# LINE 155 "Transform.ag" #-}
[]
{-# LINE 2371 "Transform.hs" #-})
-- use rule "Transform.ag"(line 154, column 32)
_lhsOcollectedAugments =
({-# LINE 154 "Transform.ag" #-}
[]
{-# LINE 2376 "Transform.hs" #-})
-- use rule "Transform.ag"(line 93, column 48)
_lhsOcollectedConstructorsMap =
({-# LINE 93 "Transform.ag" #-}
Map.empty
{-# LINE 2381 "Transform.hs" #-})
-- use rule "Transform.ag"(line 124, column 28)
_lhsOcollectedFields =
({-# LINE 124 "Transform.ag" #-}
[]
{-# LINE 2386 "Transform.hs" #-})
-- use rule "Transform.ag"(line 152, column 32)
_lhsOcollectedInsts =
({-# LINE 152 "Transform.ag" #-}
[]
{-# LINE 2391 "Transform.hs" #-})
-- use rule "Transform.ag"(line 156, column 32)
_lhsOcollectedMerges =
({-# LINE 156 "Transform.ag" #-}
[]
{-# LINE 2396 "Transform.hs" #-})
-- use rule "Transform.ag"(line 85, column 50)
_lhsOcollectedNames =
({-# LINE 85 "Transform.ag" #-}
Set.empty
{-# LINE 2401 "Transform.hs" #-})
-- use rule "Transform.ag"(line 150, column 32)
_lhsOcollectedRules =
({-# LINE 150 "Transform.ag" #-}
[]
{-# LINE 2406 "Transform.hs" #-})
-- use rule "Transform.ag"(line 84, column 50)
_lhsOcollectedSetNames =
({-# LINE 84 "Transform.ag" #-}
Set.empty
{-# LINE 2411 "Transform.hs" #-})
-- use rule "Transform.ag"(line 151, column 32)
_lhsOcollectedSigs =
({-# LINE 151 "Transform.ag" #-}
[]
{-# LINE 2416 "Transform.hs" #-})
-- use rule "Transform.ag"(line 153, column 32)
_lhsOcollectedUniques =
({-# LINE 153 "Transform.ag" #-}
[]
{-# LINE 2421 "Transform.hs" #-})
-- use rule "Transform.ag"(line 835, column 34)
_lhsOctxCollect =
({-# LINE 835 "Transform.ag" #-}
Map.empty
{-# LINE 2426 "Transform.hs" #-})
-- use rule "Transform.ag"(line 860, column 33)
_lhsOderivings =
({-# LINE 860 "Transform.ag" #-}
Map.empty
{-# LINE 2431 "Transform.hs" #-})
-- use rule "Transform.ag"(line 42, column 19)
_lhsOerrors =
({-# LINE 42 "Transform.ag" #-}
Seq.empty
{-# LINE 2436 "Transform.hs" #-})
-- use rule "Transform.ag"(line 1041, column 37)
_lhsOmoduleDecl =
({-# LINE 1041 "Transform.ag" #-}
mzero
{-# LINE 2441 "Transform.hs" #-})
-- use rule "Transform.ag"(line 812, column 37)
_lhsOparamsCollect =
({-# LINE 812 "Transform.ag" #-}
Map.empty
{-# LINE 2446 "Transform.hs" #-})
-- use rule "Transform.ag"(line 752, column 56)
_lhsOsemPragmasCollect =
({-# LINE 752 "Transform.ag" #-}
Map.empty
{-# LINE 2451 "Transform.hs" #-})
-- use rule "Transform.ag"(line 566, column 32)
_lhsOtypeSyns =
({-# LINE 566 "Transform.ag" #-}
[]
{-# LINE 2456 "Transform.hs" #-})
-- use rule "Transform.ag"(line 136, column 15)
_lhsOuseMap =
({-# LINE 136 "Transform.ag" #-}
Map.empty
{-# LINE 2461 "Transform.hs" #-})
-- use rule "Transform.ag"(line 697, column 32)
_lhsOwrappers =
({-# LINE 697 "Transform.ag" #-}
Set.empty
{-# LINE 2466 "Transform.hs" #-})
-- copy rule (chain)
_lhsOattrDecls =
({-# LINE 135 "Transform.ag" #-}
_lhsIattrDecls
{-# LINE 2471 "Transform.hs" #-})
-- copy rule (chain)
_lhsOdefSets =
({-# LINE 103 "Transform.ag" #-}
_lhsIdefSets
{-# LINE 2476 "Transform.hs" #-})
in ( _lhsOattrDecls,_lhsOattrOrderCollect,_lhsOblocks,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedConstructorsMap,_lhsOcollectedFields,_lhsOcollectedInsts,_lhsOcollectedMerges,_lhsOcollectedNames,_lhsOcollectedRules,_lhsOcollectedSetNames,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOctxCollect,_lhsOdefSets,_lhsOderivings,_lhsOerrors,_lhsOmoduleDecl,_lhsOparamsCollect,_lhsOpragmas,_lhsOsemPragmasCollect,_lhsOtypeSyns,_lhsOuseMap,_lhsOwrappers))) )
sem_Elem_Sem :: Pos ->
ClassContext ->
T_NontSet ->
T_Attrs ->
T_SemAlts ->
T_Elem
sem_Elem_Sem pos_ ctx_ (T_NontSet names_ ) (T_Attrs attrs_ ) (T_SemAlts alts_ ) =
(T_Elem (\ _lhsIallAttrDecls
_lhsIallConstructors
_lhsIallFields
_lhsIallNonterminals
_lhsIattrDecls
_lhsIdefSets
_lhsIdefinedSets ->
(let _altsOnts :: (Set NontermIdent)
_lhsOctxCollect :: ContextMap
_attrsOnts :: (Set NontermIdent)
_lhsOattrOrderCollect :: AttrOrderMap
_lhsOblocks :: Blocks
_lhsOcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])
_lhsOcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])
_lhsOcollectedConstructorsMap :: (Map NontermIdent (Set ConstructorIdent))
_lhsOcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)])
_lhsOcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ])
_lhsOcollectedMerges :: ([ (NontermIdent, ConstructorIdent, [MergeInfo]) ])
_lhsOcollectedNames :: (Set Identifier)
_lhsOcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)])
_lhsOcollectedSetNames :: (Set Identifier)
_lhsOcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ])
_lhsOcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])
_lhsOderivings :: Derivings
_lhsOerrors :: (Seq Error)
_lhsOmoduleDecl :: (Maybe (String,String,String))
_lhsOparamsCollect :: ParamMap
_lhsOpragmas :: (Options -> Options)
_lhsOsemPragmasCollect :: PragmaMap
_lhsOtypeSyns :: TypeSyns
_lhsOuseMap :: (Map NontermIdent (Map Identifier (String,String,String)))
_lhsOwrappers :: (Set NontermIdent)
_lhsOattrDecls :: (Map NontermIdent (Attributes, Attributes))
_lhsOdefSets :: (Map Identifier (Set NontermIdent,Set Identifier))
_namesOallFields :: DataTypes
_namesOallNonterminals :: (Set NontermIdent)
_namesOdefinedSets :: DefinedSets
_attrsOallFields :: DataTypes
_attrsOallNonterminals :: (Set NontermIdent)
_attrsOattrDecls :: (Map NontermIdent (Attributes, Attributes))
_altsOallAttrDecls :: (Map NontermIdent (Attributes, Attributes))
_altsOallFields :: DataTypes
_namesIcollectedNames :: (Set Identifier)
_namesIerrors :: (Seq Error)
_namesInontSet :: (Set NontermIdent)
_attrsIattrDecls :: (Map NontermIdent (Attributes, Attributes))
_attrsIerrors :: (Seq Error)
_attrsIuseMap :: (Map NontermIdent (Map Identifier (String,String,String)))
_altsIattrOrderCollect :: AttrOrderMap
_altsIcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])
_altsIcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])
_altsIcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ])
_altsIcollectedMerges :: ([ (NontermIdent, ConstructorIdent, [MergeInfo]) ])
_altsIcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)])
_altsIcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ])
_altsIcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])
_altsIerrors :: (Seq Error)
_altsIsemPragmasCollect :: PragmaMap
-- "Transform.ag"(line 170, column 10)
_altsOnts =
({-# LINE 170 "Transform.ag" #-}
_namesInontSet
{-# LINE 2547 "Transform.hs" #-})
-- "Transform.ag"(line 839, column 7)
_lhsOctxCollect =
({-# LINE 839 "Transform.ag" #-}
if null ctx_
then Map.empty
else Map.fromList [(nt, ctx_) | nt <- Set.toList _namesInontSet]
{-# LINE 2554 "Transform.hs" #-})
-- "Transform.ag"(line 884, column 10)
_attrsOnts =
({-# LINE 884 "Transform.ag" #-}
_namesInontSet
{-# LINE 2559 "Transform.hs" #-})
-- use rule "Transform.ag"(line 780, column 55)
_lhsOattrOrderCollect =
({-# LINE 780 "Transform.ag" #-}
_altsIattrOrderCollect
{-# LINE 2564 "Transform.hs" #-})
-- use rule "Transform.ag"(line 44, column 19)
_lhsOblocks =
({-# LINE 44 "Transform.ag" #-}
Map.empty
{-# LINE 2569 "Transform.hs" #-})
-- use rule "Transform.ag"(line 155, column 32)
_lhsOcollectedArounds =
({-# LINE 155 "Transform.ag" #-}
_altsIcollectedArounds
{-# LINE 2574 "Transform.hs" #-})
-- use rule "Transform.ag"(line 154, column 32)
_lhsOcollectedAugments =
({-# LINE 154 "Transform.ag" #-}
_altsIcollectedAugments
{-# LINE 2579 "Transform.hs" #-})
-- use rule "Transform.ag"(line 93, column 48)
_lhsOcollectedConstructorsMap =
({-# LINE 93 "Transform.ag" #-}
Map.empty
{-# LINE 2584 "Transform.hs" #-})
-- use rule "Transform.ag"(line 124, column 28)
_lhsOcollectedFields =
({-# LINE 124 "Transform.ag" #-}
[]
{-# LINE 2589 "Transform.hs" #-})
-- use rule "Transform.ag"(line 152, column 32)
_lhsOcollectedInsts =
({-# LINE 152 "Transform.ag" #-}
_altsIcollectedInsts
{-# LINE 2594 "Transform.hs" #-})
-- use rule "Transform.ag"(line 156, column 32)
_lhsOcollectedMerges =
({-# LINE 156 "Transform.ag" #-}
_altsIcollectedMerges
{-# LINE 2599 "Transform.hs" #-})
-- use rule "Transform.ag"(line 85, column 50)
_lhsOcollectedNames =
({-# LINE 85 "Transform.ag" #-}
_namesIcollectedNames
{-# LINE 2604 "Transform.hs" #-})
-- use rule "Transform.ag"(line 150, column 32)
_lhsOcollectedRules =
({-# LINE 150 "Transform.ag" #-}
_altsIcollectedRules
{-# LINE 2609 "Transform.hs" #-})
-- use rule "Transform.ag"(line 84, column 50)
_lhsOcollectedSetNames =
({-# LINE 84 "Transform.ag" #-}
Set.empty
{-# LINE 2614 "Transform.hs" #-})
-- use rule "Transform.ag"(line 151, column 32)
_lhsOcollectedSigs =
({-# LINE 151 "Transform.ag" #-}
_altsIcollectedSigs
{-# LINE 2619 "Transform.hs" #-})
-- use rule "Transform.ag"(line 153, column 32)
_lhsOcollectedUniques =
({-# LINE 153 "Transform.ag" #-}
_altsIcollectedUniques
{-# LINE 2624 "Transform.hs" #-})
-- use rule "Transform.ag"(line 860, column 33)
_lhsOderivings =
({-# LINE 860 "Transform.ag" #-}
Map.empty
{-# LINE 2629 "Transform.hs" #-})
-- use rule "Transform.ag"(line 42, column 19)
_lhsOerrors =
({-# LINE 42 "Transform.ag" #-}
_namesIerrors Seq.>< _attrsIerrors Seq.>< _altsIerrors
{-# LINE 2634 "Transform.hs" #-})
-- use rule "Transform.ag"(line 1041, column 37)
_lhsOmoduleDecl =
({-# LINE 1041 "Transform.ag" #-}
mzero
{-# LINE 2639 "Transform.hs" #-})
-- use rule "Transform.ag"(line 812, column 37)
_lhsOparamsCollect =
({-# LINE 812 "Transform.ag" #-}
Map.empty
{-# LINE 2644 "Transform.hs" #-})
-- use rule "Transform.ag"(line 706, column 34)
_lhsOpragmas =
({-# LINE 706 "Transform.ag" #-}
id
{-# LINE 2649 "Transform.hs" #-})
-- use rule "Transform.ag"(line 752, column 56)
_lhsOsemPragmasCollect =
({-# LINE 752 "Transform.ag" #-}
_altsIsemPragmasCollect
{-# LINE 2654 "Transform.hs" #-})
-- use rule "Transform.ag"(line 566, column 32)
_lhsOtypeSyns =
({-# LINE 566 "Transform.ag" #-}
[]
{-# LINE 2659 "Transform.hs" #-})
-- use rule "Transform.ag"(line 136, column 15)
_lhsOuseMap =
({-# LINE 136 "Transform.ag" #-}
_attrsIuseMap
{-# LINE 2664 "Transform.hs" #-})
-- use rule "Transform.ag"(line 697, column 32)
_lhsOwrappers =
({-# LINE 697 "Transform.ag" #-}
Set.empty
{-# LINE 2669 "Transform.hs" #-})
-- copy rule (up)
_lhsOattrDecls =
({-# LINE 135 "Transform.ag" #-}
_attrsIattrDecls
{-# LINE 2674 "Transform.hs" #-})
-- copy rule (chain)
_lhsOdefSets =
({-# LINE 103 "Transform.ag" #-}
_lhsIdefSets
{-# LINE 2679 "Transform.hs" #-})
-- copy rule (down)
_namesOallFields =
({-# LINE 127 "Transform.ag" #-}
_lhsIallFields
{-# LINE 2684 "Transform.hs" #-})
-- copy rule (down)
_namesOallNonterminals =
({-# LINE 87 "Transform.ag" #-}
_lhsIallNonterminals
{-# LINE 2689 "Transform.hs" #-})
-- copy rule (down)
_namesOdefinedSets =
({-# LINE 106 "Transform.ag" #-}
_lhsIdefinedSets
{-# LINE 2694 "Transform.hs" #-})
-- copy rule (down)
_attrsOallFields =
({-# LINE 127 "Transform.ag" #-}
_lhsIallFields
{-# LINE 2699 "Transform.hs" #-})
-- copy rule (down)
_attrsOallNonterminals =
({-# LINE 87 "Transform.ag" #-}
_lhsIallNonterminals
{-# LINE 2704 "Transform.hs" #-})
-- copy rule (down)
_attrsOattrDecls =
({-# LINE 135 "Transform.ag" #-}
_lhsIattrDecls
{-# LINE 2709 "Transform.hs" #-})
-- copy rule (down)
_altsOallAttrDecls =
({-# LINE 781 "Transform.ag" #-}
_lhsIallAttrDecls
{-# LINE 2714 "Transform.hs" #-})
-- copy rule (down)
_altsOallFields =
({-# LINE 127 "Transform.ag" #-}
_lhsIallFields
{-# LINE 2719 "Transform.hs" #-})
( _namesIcollectedNames,_namesIerrors,_namesInontSet) =
names_ _namesOallFields _namesOallNonterminals _namesOdefinedSets
( _attrsIattrDecls,_attrsIerrors,_attrsIuseMap) =
attrs_ _attrsOallFields _attrsOallNonterminals _attrsOattrDecls _attrsOnts
( _altsIattrOrderCollect,_altsIcollectedArounds,_altsIcollectedAugments,_altsIcollectedInsts,_altsIcollectedMerges,_altsIcollectedRules,_altsIcollectedSigs,_altsIcollectedUniques,_altsIerrors,_altsIsemPragmasCollect) =
alts_ _altsOallAttrDecls _altsOallFields _altsOnts
in ( _lhsOattrDecls,_lhsOattrOrderCollect,_lhsOblocks,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedConstructorsMap,_lhsOcollectedFields,_lhsOcollectedInsts,_lhsOcollectedMerges,_lhsOcollectedNames,_lhsOcollectedRules,_lhsOcollectedSetNames,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOctxCollect,_lhsOdefSets,_lhsOderivings,_lhsOerrors,_lhsOmoduleDecl,_lhsOparamsCollect,_lhsOpragmas,_lhsOsemPragmasCollect,_lhsOtypeSyns,_lhsOuseMap,_lhsOwrappers))) )
sem_Elem_Set :: Pos ->
NontermIdent ->
T_NontSet ->
T_Elem
sem_Elem_Set pos_ name_ (T_NontSet set_ ) =
(T_Elem (\ _lhsIallAttrDecls
_lhsIallConstructors
_lhsIallFields
_lhsIallNonterminals
_lhsIattrDecls
_lhsIdefSets
_lhsIdefinedSets ->
(let _lhsOcollectedSetNames :: (Set Identifier)
_lhsOdefSets :: (Map Identifier (Set NontermIdent,Set Identifier))
_lhsOerrors :: (Seq Error)
_lhsOattrOrderCollect :: AttrOrderMap
_lhsOblocks :: Blocks
_lhsOcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])
_lhsOcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])
_lhsOcollectedConstructorsMap :: (Map NontermIdent (Set ConstructorIdent))
_lhsOcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)])
_lhsOcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ])
_lhsOcollectedMerges :: ([ (NontermIdent, ConstructorIdent, [MergeInfo]) ])
_lhsOcollectedNames :: (Set Identifier)
_lhsOcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)])
_lhsOcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ])
_lhsOcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])
_lhsOctxCollect :: ContextMap
_lhsOderivings :: Derivings
_lhsOmoduleDecl :: (Maybe (String,String,String))
_lhsOparamsCollect :: ParamMap
_lhsOpragmas :: (Options -> Options)
_lhsOsemPragmasCollect :: PragmaMap
_lhsOtypeSyns :: TypeSyns
_lhsOuseMap :: (Map NontermIdent (Map Identifier (String,String,String)))
_lhsOwrappers :: (Set NontermIdent)
_lhsOattrDecls :: (Map NontermIdent (Attributes, Attributes))
_setOallFields :: DataTypes
_setOallNonterminals :: (Set NontermIdent)
_setOdefinedSets :: DefinedSets
_setIcollectedNames :: (Set Identifier)
_setIerrors :: (Seq Error)
_setInontSet :: (Set NontermIdent)
-- "Transform.ag"(line 522, column 10)
_lhsOcollectedSetNames =
({-# LINE 522 "Transform.ag" #-}
Set.singleton name_
{-# LINE 2774 "Transform.hs" #-})
-- "Transform.ag"(line 629, column 13)
__tup3 =
({-# LINE 629 "Transform.ag" #-}
let allUsedNames = Set.unions [ maybe (Set.singleton n)
snd
(Map.lookup n _lhsIdefSets)
| n <- Set.toList _setIcollectedNames
]
(nontSet,e1) | Set.member name_ allUsedNames
= (Set.empty, Seq.singleton(CyclicSet name_))
| otherwise = (_setInontSet, Seq.empty)
(res, e2) = checkDuplicate DupSet name_ (nontSet,Set.insert name_ allUsedNames) _lhsIdefSets
in (res, e1 Seq.>< e2)
{-# LINE 2788 "Transform.hs" #-})
-- "Transform.ag"(line 629, column 13)
(_defSets2,_) =
({-# LINE 629 "Transform.ag" #-}
__tup3
{-# LINE 2793 "Transform.hs" #-})
-- "Transform.ag"(line 629, column 13)
(_,_errs) =
({-# LINE 629 "Transform.ag" #-}
__tup3
{-# LINE 2798 "Transform.hs" #-})
-- "Transform.ag"(line 639, column 9)
_lhsOdefSets =
({-# LINE 639 "Transform.ag" #-}
_defSets2
{-# LINE 2803 "Transform.hs" #-})
-- "Transform.ag"(line 639, column 9)
_lhsOerrors =
({-# LINE 640 "Transform.ag" #-}
_errs >< _setIerrors
{-# LINE 2808 "Transform.hs" #-})
-- use rule "Transform.ag"(line 780, column 55)
_lhsOattrOrderCollect =
({-# LINE 780 "Transform.ag" #-}
Map.empty
{-# LINE 2813 "Transform.hs" #-})
-- use rule "Transform.ag"(line 44, column 19)
_lhsOblocks =
({-# LINE 44 "Transform.ag" #-}
Map.empty
{-# LINE 2818 "Transform.hs" #-})
-- use rule "Transform.ag"(line 155, column 32)
_lhsOcollectedArounds =
({-# LINE 155 "Transform.ag" #-}
[]
{-# LINE 2823 "Transform.hs" #-})
-- use rule "Transform.ag"(line 154, column 32)
_lhsOcollectedAugments =
({-# LINE 154 "Transform.ag" #-}
[]
{-# LINE 2828 "Transform.hs" #-})
-- use rule "Transform.ag"(line 93, column 48)
_lhsOcollectedConstructorsMap =
({-# LINE 93 "Transform.ag" #-}
Map.empty
{-# LINE 2833 "Transform.hs" #-})
-- use rule "Transform.ag"(line 124, column 28)
_lhsOcollectedFields =
({-# LINE 124 "Transform.ag" #-}
[]
{-# LINE 2838 "Transform.hs" #-})
-- use rule "Transform.ag"(line 152, column 32)
_lhsOcollectedInsts =
({-# LINE 152 "Transform.ag" #-}
[]
{-# LINE 2843 "Transform.hs" #-})
-- use rule "Transform.ag"(line 156, column 32)
_lhsOcollectedMerges =
({-# LINE 156 "Transform.ag" #-}
[]
{-# LINE 2848 "Transform.hs" #-})
-- use rule "Transform.ag"(line 85, column 50)
_lhsOcollectedNames =
({-# LINE 85 "Transform.ag" #-}
_setIcollectedNames
{-# LINE 2853 "Transform.hs" #-})
-- use rule "Transform.ag"(line 150, column 32)
_lhsOcollectedRules =
({-# LINE 150 "Transform.ag" #-}
[]
{-# LINE 2858 "Transform.hs" #-})
-- use rule "Transform.ag"(line 151, column 32)
_lhsOcollectedSigs =
({-# LINE 151 "Transform.ag" #-}
[]
{-# LINE 2863 "Transform.hs" #-})
-- use rule "Transform.ag"(line 153, column 32)
_lhsOcollectedUniques =
({-# LINE 153 "Transform.ag" #-}
[]
{-# LINE 2868 "Transform.hs" #-})
-- use rule "Transform.ag"(line 835, column 34)
_lhsOctxCollect =
({-# LINE 835 "Transform.ag" #-}
Map.empty
{-# LINE 2873 "Transform.hs" #-})
-- use rule "Transform.ag"(line 860, column 33)
_lhsOderivings =
({-# LINE 860 "Transform.ag" #-}
Map.empty
{-# LINE 2878 "Transform.hs" #-})
-- use rule "Transform.ag"(line 1041, column 37)
_lhsOmoduleDecl =
({-# LINE 1041 "Transform.ag" #-}
mzero
{-# LINE 2883 "Transform.hs" #-})
-- use rule "Transform.ag"(line 812, column 37)
_lhsOparamsCollect =
({-# LINE 812 "Transform.ag" #-}
Map.empty
{-# LINE 2888 "Transform.hs" #-})
-- use rule "Transform.ag"(line 706, column 34)
_lhsOpragmas =
({-# LINE 706 "Transform.ag" #-}
id
{-# LINE 2893 "Transform.hs" #-})
-- use rule "Transform.ag"(line 752, column 56)
_lhsOsemPragmasCollect =
({-# LINE 752 "Transform.ag" #-}
Map.empty
{-# LINE 2898 "Transform.hs" #-})
-- use rule "Transform.ag"(line 566, column 32)
_lhsOtypeSyns =
({-# LINE 566 "Transform.ag" #-}
[]
{-# LINE 2903 "Transform.hs" #-})
-- use rule "Transform.ag"(line 136, column 15)
_lhsOuseMap =
({-# LINE 136 "Transform.ag" #-}
Map.empty
{-# LINE 2908 "Transform.hs" #-})
-- use rule "Transform.ag"(line 697, column 32)
_lhsOwrappers =
({-# LINE 697 "Transform.ag" #-}
Set.empty
{-# LINE 2913 "Transform.hs" #-})
-- copy rule (chain)
_lhsOattrDecls =
({-# LINE 135 "Transform.ag" #-}
_lhsIattrDecls
{-# LINE 2918 "Transform.hs" #-})
-- copy rule (down)
_setOallFields =
({-# LINE 127 "Transform.ag" #-}
_lhsIallFields
{-# LINE 2923 "Transform.hs" #-})
-- copy rule (down)
_setOallNonterminals =
({-# LINE 87 "Transform.ag" #-}
_lhsIallNonterminals
{-# LINE 2928 "Transform.hs" #-})
-- copy rule (down)
_setOdefinedSets =
({-# LINE 106 "Transform.ag" #-}
_lhsIdefinedSets
{-# LINE 2933 "Transform.hs" #-})
( _setIcollectedNames,_setIerrors,_setInontSet) =
set_ _setOallFields _setOallNonterminals _setOdefinedSets
in ( _lhsOattrDecls,_lhsOattrOrderCollect,_lhsOblocks,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedConstructorsMap,_lhsOcollectedFields,_lhsOcollectedInsts,_lhsOcollectedMerges,_lhsOcollectedNames,_lhsOcollectedRules,_lhsOcollectedSetNames,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOctxCollect,_lhsOdefSets,_lhsOderivings,_lhsOerrors,_lhsOmoduleDecl,_lhsOparamsCollect,_lhsOpragmas,_lhsOsemPragmasCollect,_lhsOtypeSyns,_lhsOuseMap,_lhsOwrappers))) )
sem_Elem_Txt :: Pos ->
Identifier ->
(Maybe NontermIdent) ->
([String]) ->
T_Elem
sem_Elem_Txt pos_ name_ mbNt_ lines_ =
(T_Elem (\ _lhsIallAttrDecls
_lhsIallConstructors
_lhsIallFields
_lhsIallNonterminals
_lhsIattrDecls
_lhsIdefSets
_lhsIdefinedSets ->
(let _lhsOblocks :: Blocks
_lhsOattrOrderCollect :: AttrOrderMap
_lhsOcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])
_lhsOcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])
_lhsOcollectedConstructorsMap :: (Map NontermIdent (Set ConstructorIdent))
_lhsOcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)])
_lhsOcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ])
_lhsOcollectedMerges :: ([ (NontermIdent, ConstructorIdent, [MergeInfo]) ])
_lhsOcollectedNames :: (Set Identifier)
_lhsOcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)])
_lhsOcollectedSetNames :: (Set Identifier)
_lhsOcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ])
_lhsOcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])
_lhsOctxCollect :: ContextMap
_lhsOderivings :: Derivings
_lhsOerrors :: (Seq Error)
_lhsOmoduleDecl :: (Maybe (String,String,String))
_lhsOparamsCollect :: ParamMap
_lhsOpragmas :: (Options -> Options)
_lhsOsemPragmasCollect :: PragmaMap
_lhsOtypeSyns :: TypeSyns
_lhsOuseMap :: (Map NontermIdent (Map Identifier (String,String,String)))
_lhsOwrappers :: (Set NontermIdent)
_lhsOattrDecls :: (Map NontermIdent (Attributes, Attributes))
_lhsOdefSets :: (Map Identifier (Set NontermIdent,Set Identifier))
-- "Transform.ag"(line 179, column 10)
_blockInfo =
({-# LINE 179 "Transform.ag" #-}
( let nm = getName name_
in if nm == "imports"
then BlockImport
else if nm == "optpragmas"
then BlockPragma
else BlockOther
, mbNt_
)
{-# LINE 2986 "Transform.hs" #-})
-- "Transform.ag"(line 187, column 10)
_blockValue =
({-# LINE 187 "Transform.ag" #-}
[(lines_, pos_)]
{-# LINE 2991 "Transform.hs" #-})
-- "Transform.ag"(line 188, column 10)
_lhsOblocks =
({-# LINE 188 "Transform.ag" #-}
Map.singleton _blockInfo _blockValue
{-# LINE 2996 "Transform.hs" #-})
-- use rule "Transform.ag"(line 780, column 55)
_lhsOattrOrderCollect =
({-# LINE 780 "Transform.ag" #-}
Map.empty
{-# LINE 3001 "Transform.hs" #-})
-- use rule "Transform.ag"(line 155, column 32)
_lhsOcollectedArounds =
({-# LINE 155 "Transform.ag" #-}
[]
{-# LINE 3006 "Transform.hs" #-})
-- use rule "Transform.ag"(line 154, column 32)
_lhsOcollectedAugments =
({-# LINE 154 "Transform.ag" #-}
[]
{-# LINE 3011 "Transform.hs" #-})
-- use rule "Transform.ag"(line 93, column 48)
_lhsOcollectedConstructorsMap =
({-# LINE 93 "Transform.ag" #-}
Map.empty
{-# LINE 3016 "Transform.hs" #-})
-- use rule "Transform.ag"(line 124, column 28)
_lhsOcollectedFields =
({-# LINE 124 "Transform.ag" #-}
[]
{-# LINE 3021 "Transform.hs" #-})
-- use rule "Transform.ag"(line 152, column 32)
_lhsOcollectedInsts =
({-# LINE 152 "Transform.ag" #-}
[]
{-# LINE 3026 "Transform.hs" #-})
-- use rule "Transform.ag"(line 156, column 32)
_lhsOcollectedMerges =
({-# LINE 156 "Transform.ag" #-}
[]
{-# LINE 3031 "Transform.hs" #-})
-- use rule "Transform.ag"(line 85, column 50)
_lhsOcollectedNames =
({-# LINE 85 "Transform.ag" #-}
Set.empty
{-# LINE 3036 "Transform.hs" #-})
-- use rule "Transform.ag"(line 150, column 32)
_lhsOcollectedRules =
({-# LINE 150 "Transform.ag" #-}
[]
{-# LINE 3041 "Transform.hs" #-})
-- use rule "Transform.ag"(line 84, column 50)
_lhsOcollectedSetNames =
({-# LINE 84 "Transform.ag" #-}
Set.empty
{-# LINE 3046 "Transform.hs" #-})
-- use rule "Transform.ag"(line 151, column 32)
_lhsOcollectedSigs =
({-# LINE 151 "Transform.ag" #-}
[]
{-# LINE 3051 "Transform.hs" #-})
-- use rule "Transform.ag"(line 153, column 32)
_lhsOcollectedUniques =
({-# LINE 153 "Transform.ag" #-}
[]
{-# LINE 3056 "Transform.hs" #-})
-- use rule "Transform.ag"(line 835, column 34)
_lhsOctxCollect =
({-# LINE 835 "Transform.ag" #-}
Map.empty
{-# LINE 3061 "Transform.hs" #-})
-- use rule "Transform.ag"(line 860, column 33)
_lhsOderivings =
({-# LINE 860 "Transform.ag" #-}
Map.empty
{-# LINE 3066 "Transform.hs" #-})
-- use rule "Transform.ag"(line 42, column 19)
_lhsOerrors =
({-# LINE 42 "Transform.ag" #-}
Seq.empty
{-# LINE 3071 "Transform.hs" #-})
-- use rule "Transform.ag"(line 1041, column 37)
_lhsOmoduleDecl =
({-# LINE 1041 "Transform.ag" #-}
mzero
{-# LINE 3076 "Transform.hs" #-})
-- use rule "Transform.ag"(line 812, column 37)
_lhsOparamsCollect =
({-# LINE 812 "Transform.ag" #-}
Map.empty
{-# LINE 3081 "Transform.hs" #-})
-- use rule "Transform.ag"(line 706, column 34)
_lhsOpragmas =
({-# LINE 706 "Transform.ag" #-}
id
{-# LINE 3086 "Transform.hs" #-})
-- use rule "Transform.ag"(line 752, column 56)
_lhsOsemPragmasCollect =
({-# LINE 752 "Transform.ag" #-}
Map.empty
{-# LINE 3091 "Transform.hs" #-})
-- use rule "Transform.ag"(line 566, column 32)
_lhsOtypeSyns =
({-# LINE 566 "Transform.ag" #-}
[]
{-# LINE 3096 "Transform.hs" #-})
-- use rule "Transform.ag"(line 136, column 15)
_lhsOuseMap =
({-# LINE 136 "Transform.ag" #-}
Map.empty
{-# LINE 3101 "Transform.hs" #-})
-- use rule "Transform.ag"(line 697, column 32)
_lhsOwrappers =
({-# LINE 697 "Transform.ag" #-}
Set.empty
{-# LINE 3106 "Transform.hs" #-})
-- copy rule (chain)
_lhsOattrDecls =
({-# LINE 135 "Transform.ag" #-}
_lhsIattrDecls
{-# LINE 3111 "Transform.hs" #-})
-- copy rule (chain)
_lhsOdefSets =
({-# LINE 103 "Transform.ag" #-}
_lhsIdefSets
{-# LINE 3116 "Transform.hs" #-})
in ( _lhsOattrDecls,_lhsOattrOrderCollect,_lhsOblocks,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedConstructorsMap,_lhsOcollectedFields,_lhsOcollectedInsts,_lhsOcollectedMerges,_lhsOcollectedNames,_lhsOcollectedRules,_lhsOcollectedSetNames,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOctxCollect,_lhsOdefSets,_lhsOderivings,_lhsOerrors,_lhsOmoduleDecl,_lhsOparamsCollect,_lhsOpragmas,_lhsOsemPragmasCollect,_lhsOtypeSyns,_lhsOuseMap,_lhsOwrappers))) )
sem_Elem_Type :: Pos ->
ClassContext ->
NontermIdent ->
([Identifier]) ->
ComplexType ->
T_Elem
sem_Elem_Type pos_ ctx_ name_ params_ type_ =
(T_Elem (\ _lhsIallAttrDecls
_lhsIallConstructors
_lhsIallFields
_lhsIallNonterminals
_lhsIattrDecls
_lhsIdefSets
_lhsIdefinedSets ->
(let _lhsOcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)])
_lhsOcollectedNames :: (Set Identifier)
_lhsOtypeSyns :: TypeSyns
_lhsOparamsCollect :: ParamMap
_lhsOctxCollect :: ContextMap
_lhsOattrOrderCollect :: AttrOrderMap
_lhsOblocks :: Blocks
_lhsOcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])
_lhsOcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])
_lhsOcollectedConstructorsMap :: (Map NontermIdent (Set ConstructorIdent))
_lhsOcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ])
_lhsOcollectedMerges :: ([ (NontermIdent, ConstructorIdent, [MergeInfo]) ])
_lhsOcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)])
_lhsOcollectedSetNames :: (Set Identifier)
_lhsOcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ])
_lhsOcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])
_lhsOderivings :: Derivings
_lhsOerrors :: (Seq Error)
_lhsOmoduleDecl :: (Maybe (String,String,String))
_lhsOpragmas :: (Options -> Options)
_lhsOsemPragmasCollect :: PragmaMap
_lhsOuseMap :: (Map NontermIdent (Map Identifier (String,String,String)))
_lhsOwrappers :: (Set NontermIdent)
_lhsOattrDecls :: (Map NontermIdent (Attributes, Attributes))
_lhsOdefSets :: (Map Identifier (Set NontermIdent,Set Identifier))
-- "Transform.ag"(line 241, column 10)
_lhsOcollectedFields =
({-# LINE 241 "Transform.ag" #-}
map (\(x,y)->(name_, x, y)) _expanded
{-# LINE 3161 "Transform.hs" #-})
-- "Transform.ag"(line 525, column 11)
_lhsOcollectedNames =
({-# LINE 525 "Transform.ag" #-}
Set.singleton name_
{-# LINE 3166 "Transform.hs" #-})
-- "Transform.ag"(line 579, column 11)
_expanded =
({-# LINE 579 "Transform.ag" #-}
case _argType of
List tp -> [(Ident "Cons" pos_, [(Ident "hd" pos_, tp)
,(Ident "tl" pos_, NT name_ (map getName params_))
]
)
,(Ident "Nil" pos_, [])
]
Maybe tp -> [(Ident "Just" pos_, [(Ident "just" pos_, tp)
]
)
,(Ident "Nothing" pos_, [])
]
Either tp1 tp2 -> [
(Ident "Left" pos_, [(Ident "left" pos_, tp1) ])
, (Ident "Right" pos_, [(Ident "right" pos_, tp2) ])
]
Map tp1 tp2 -> [ (Ident "Entry" pos_, [ (Ident "key" pos_, tp1)
, (Ident "val" pos_, tp2)
, (Ident "tl" pos_, NT name_ (map getName params_))
])
, (Ident "Nil" pos_, [])
]
IntMap tp -> [ (Ident "Entry" pos_, [ (Ident "key" pos_, Haskell "Int")
, (Ident "val" pos_, tp)
, (Ident "tl" pos_, NT name_ (map getName params_))
])
, (Ident "Nil" pos_, [])
]
Tuple xs -> [(Ident "Tuple" pos_, xs)]
{-# LINE 3199 "Transform.hs" #-})
-- "Transform.ag"(line 608, column 11)
_argType =
({-# LINE 608 "Transform.ag" #-}
case type_ of
Maybe tp -> Maybe ( makeType _lhsIallNonterminals tp)
Either tp1 tp2 -> Either ( makeType _lhsIallNonterminals tp1) (makeType _lhsIallNonterminals tp2)
List tp -> List ( makeType _lhsIallNonterminals tp)
Tuple xs -> Tuple [(f,makeType _lhsIallNonterminals tp) | (f,tp) <- xs]
Map tp1 tp2 -> Map ( makeType _lhsIallNonterminals tp1) (makeType _lhsIallNonterminals tp2)
IntMap tp -> IntMap ( makeType _lhsIallNonterminals tp)
{-# LINE 3210 "Transform.hs" #-})
-- "Transform.ag"(line 615, column 11)
_lhsOtypeSyns =
({-# LINE 615 "Transform.ag" #-}
[(name_,_argType)]
{-# LINE 3215 "Transform.hs" #-})
-- "Transform.ag"(line 822, column 7)
_lhsOparamsCollect =
({-# LINE 822 "Transform.ag" #-}
if null params_
then Map.empty
else Map.singleton name_ params_
{-# LINE 3222 "Transform.hs" #-})
-- "Transform.ag"(line 845, column 7)
_lhsOctxCollect =
({-# LINE 845 "Transform.ag" #-}
if null ctx_
then Map.empty
else Map.singleton name_ ctx_
{-# LINE 3229 "Transform.hs" #-})
-- use rule "Transform.ag"(line 780, column 55)
_lhsOattrOrderCollect =
({-# LINE 780 "Transform.ag" #-}
Map.empty
{-# LINE 3234 "Transform.hs" #-})
-- use rule "Transform.ag"(line 44, column 19)
_lhsOblocks =
({-# LINE 44 "Transform.ag" #-}
Map.empty
{-# LINE 3239 "Transform.hs" #-})
-- use rule "Transform.ag"(line 155, column 32)
_lhsOcollectedArounds =
({-# LINE 155 "Transform.ag" #-}
[]
{-# LINE 3244 "Transform.hs" #-})
-- use rule "Transform.ag"(line 154, column 32)
_lhsOcollectedAugments =
({-# LINE 154 "Transform.ag" #-}
[]
{-# LINE 3249 "Transform.hs" #-})
-- use rule "Transform.ag"(line 93, column 48)
_lhsOcollectedConstructorsMap =
({-# LINE 93 "Transform.ag" #-}
Map.empty
{-# LINE 3254 "Transform.hs" #-})
-- use rule "Transform.ag"(line 152, column 32)
_lhsOcollectedInsts =
({-# LINE 152 "Transform.ag" #-}
[]
{-# LINE 3259 "Transform.hs" #-})
-- use rule "Transform.ag"(line 156, column 32)
_lhsOcollectedMerges =
({-# LINE 156 "Transform.ag" #-}
[]
{-# LINE 3264 "Transform.hs" #-})
-- use rule "Transform.ag"(line 150, column 32)
_lhsOcollectedRules =
({-# LINE 150 "Transform.ag" #-}
[]
{-# LINE 3269 "Transform.hs" #-})
-- use rule "Transform.ag"(line 84, column 50)
_lhsOcollectedSetNames =
({-# LINE 84 "Transform.ag" #-}
Set.empty
{-# LINE 3274 "Transform.hs" #-})
-- use rule "Transform.ag"(line 151, column 32)
_lhsOcollectedSigs =
({-# LINE 151 "Transform.ag" #-}
[]
{-# LINE 3279 "Transform.hs" #-})
-- use rule "Transform.ag"(line 153, column 32)
_lhsOcollectedUniques =
({-# LINE 153 "Transform.ag" #-}
[]
{-# LINE 3284 "Transform.hs" #-})
-- use rule "Transform.ag"(line 860, column 33)
_lhsOderivings =
({-# LINE 860 "Transform.ag" #-}
Map.empty
{-# LINE 3289 "Transform.hs" #-})
-- use rule "Transform.ag"(line 42, column 19)
_lhsOerrors =
({-# LINE 42 "Transform.ag" #-}
Seq.empty
{-# LINE 3294 "Transform.hs" #-})
-- use rule "Transform.ag"(line 1041, column 37)
_lhsOmoduleDecl =
({-# LINE 1041 "Transform.ag" #-}
mzero
{-# LINE 3299 "Transform.hs" #-})
-- use rule "Transform.ag"(line 706, column 34)
_lhsOpragmas =
({-# LINE 706 "Transform.ag" #-}
id
{-# LINE 3304 "Transform.hs" #-})
-- use rule "Transform.ag"(line 752, column 56)
_lhsOsemPragmasCollect =
({-# LINE 752 "Transform.ag" #-}
Map.empty
{-# LINE 3309 "Transform.hs" #-})
-- use rule "Transform.ag"(line 136, column 15)
_lhsOuseMap =
({-# LINE 136 "Transform.ag" #-}
Map.empty
{-# LINE 3314 "Transform.hs" #-})
-- use rule "Transform.ag"(line 697, column 32)
_lhsOwrappers =
({-# LINE 697 "Transform.ag" #-}
Set.empty
{-# LINE 3319 "Transform.hs" #-})
-- copy rule (chain)
_lhsOattrDecls =
({-# LINE 135 "Transform.ag" #-}
_lhsIattrDecls
{-# LINE 3324 "Transform.hs" #-})
-- copy rule (chain)
_lhsOdefSets =
({-# LINE 103 "Transform.ag" #-}
_lhsIdefSets
{-# LINE 3329 "Transform.hs" #-})
in ( _lhsOattrDecls,_lhsOattrOrderCollect,_lhsOblocks,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedConstructorsMap,_lhsOcollectedFields,_lhsOcollectedInsts,_lhsOcollectedMerges,_lhsOcollectedNames,_lhsOcollectedRules,_lhsOcollectedSetNames,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOctxCollect,_lhsOdefSets,_lhsOderivings,_lhsOerrors,_lhsOmoduleDecl,_lhsOparamsCollect,_lhsOpragmas,_lhsOsemPragmasCollect,_lhsOtypeSyns,_lhsOuseMap,_lhsOwrappers))) )
sem_Elem_Wrapper :: Pos ->
T_NontSet ->
T_Elem
sem_Elem_Wrapper pos_ (T_NontSet set_ ) =
(T_Elem (\ _lhsIallAttrDecls
_lhsIallConstructors
_lhsIallFields
_lhsIallNonterminals
_lhsIattrDecls
_lhsIdefSets
_lhsIdefinedSets ->
(let _lhsOwrappers :: (Set NontermIdent)
_lhsOattrOrderCollect :: AttrOrderMap
_lhsOblocks :: Blocks
_lhsOcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])
_lhsOcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])
_lhsOcollectedConstructorsMap :: (Map NontermIdent (Set ConstructorIdent))
_lhsOcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)])
_lhsOcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ])
_lhsOcollectedMerges :: ([ (NontermIdent, ConstructorIdent, [MergeInfo]) ])
_lhsOcollectedNames :: (Set Identifier)
_lhsOcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)])
_lhsOcollectedSetNames :: (Set Identifier)
_lhsOcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ])
_lhsOcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])
_lhsOctxCollect :: ContextMap
_lhsOderivings :: Derivings
_lhsOerrors :: (Seq Error)
_lhsOmoduleDecl :: (Maybe (String,String,String))
_lhsOparamsCollect :: ParamMap
_lhsOpragmas :: (Options -> Options)
_lhsOsemPragmasCollect :: PragmaMap
_lhsOtypeSyns :: TypeSyns
_lhsOuseMap :: (Map NontermIdent (Map Identifier (String,String,String)))
_lhsOattrDecls :: (Map NontermIdent (Attributes, Attributes))
_lhsOdefSets :: (Map Identifier (Set NontermIdent,Set Identifier))
_setOallFields :: DataTypes
_setOallNonterminals :: (Set NontermIdent)
_setOdefinedSets :: DefinedSets
_setIcollectedNames :: (Set Identifier)
_setIerrors :: (Seq Error)
_setInontSet :: (Set NontermIdent)
-- "Transform.ag"(line 700, column 13)
_lhsOwrappers =
({-# LINE 700 "Transform.ag" #-}
_setInontSet
{-# LINE 3377 "Transform.hs" #-})
-- use rule "Transform.ag"(line 780, column 55)
_lhsOattrOrderCollect =
({-# LINE 780 "Transform.ag" #-}
Map.empty
{-# LINE 3382 "Transform.hs" #-})
-- use rule "Transform.ag"(line 44, column 19)
_lhsOblocks =
({-# LINE 44 "Transform.ag" #-}
Map.empty
{-# LINE 3387 "Transform.hs" #-})
-- use rule "Transform.ag"(line 155, column 32)
_lhsOcollectedArounds =
({-# LINE 155 "Transform.ag" #-}
[]
{-# LINE 3392 "Transform.hs" #-})
-- use rule "Transform.ag"(line 154, column 32)
_lhsOcollectedAugments =
({-# LINE 154 "Transform.ag" #-}
[]
{-# LINE 3397 "Transform.hs" #-})
-- use rule "Transform.ag"(line 93, column 48)
_lhsOcollectedConstructorsMap =
({-# LINE 93 "Transform.ag" #-}
Map.empty
{-# LINE 3402 "Transform.hs" #-})
-- use rule "Transform.ag"(line 124, column 28)
_lhsOcollectedFields =
({-# LINE 124 "Transform.ag" #-}
[]
{-# LINE 3407 "Transform.hs" #-})
-- use rule "Transform.ag"(line 152, column 32)
_lhsOcollectedInsts =
({-# LINE 152 "Transform.ag" #-}
[]
{-# LINE 3412 "Transform.hs" #-})
-- use rule "Transform.ag"(line 156, column 32)
_lhsOcollectedMerges =
({-# LINE 156 "Transform.ag" #-}
[]
{-# LINE 3417 "Transform.hs" #-})
-- use rule "Transform.ag"(line 85, column 50)
_lhsOcollectedNames =
({-# LINE 85 "Transform.ag" #-}
_setIcollectedNames
{-# LINE 3422 "Transform.hs" #-})
-- use rule "Transform.ag"(line 150, column 32)
_lhsOcollectedRules =
({-# LINE 150 "Transform.ag" #-}
[]
{-# LINE 3427 "Transform.hs" #-})
-- use rule "Transform.ag"(line 84, column 50)
_lhsOcollectedSetNames =
({-# LINE 84 "Transform.ag" #-}
Set.empty
{-# LINE 3432 "Transform.hs" #-})
-- use rule "Transform.ag"(line 151, column 32)
_lhsOcollectedSigs =
({-# LINE 151 "Transform.ag" #-}
[]
{-# LINE 3437 "Transform.hs" #-})
-- use rule "Transform.ag"(line 153, column 32)
_lhsOcollectedUniques =
({-# LINE 153 "Transform.ag" #-}
[]
{-# LINE 3442 "Transform.hs" #-})
-- use rule "Transform.ag"(line 835, column 34)
_lhsOctxCollect =
({-# LINE 835 "Transform.ag" #-}
Map.empty
{-# LINE 3447 "Transform.hs" #-})
-- use rule "Transform.ag"(line 860, column 33)
_lhsOderivings =
({-# LINE 860 "Transform.ag" #-}
Map.empty
{-# LINE 3452 "Transform.hs" #-})
-- use rule "Transform.ag"(line 42, column 19)
_lhsOerrors =
({-# LINE 42 "Transform.ag" #-}
_setIerrors
{-# LINE 3457 "Transform.hs" #-})
-- use rule "Transform.ag"(line 1041, column 37)
_lhsOmoduleDecl =
({-# LINE 1041 "Transform.ag" #-}
mzero
{-# LINE 3462 "Transform.hs" #-})
-- use rule "Transform.ag"(line 812, column 37)
_lhsOparamsCollect =
({-# LINE 812 "Transform.ag" #-}
Map.empty
{-# LINE 3467 "Transform.hs" #-})
-- use rule "Transform.ag"(line 706, column 34)
_lhsOpragmas =
({-# LINE 706 "Transform.ag" #-}
id
{-# LINE 3472 "Transform.hs" #-})
-- use rule "Transform.ag"(line 752, column 56)
_lhsOsemPragmasCollect =
({-# LINE 752 "Transform.ag" #-}
Map.empty
{-# LINE 3477 "Transform.hs" #-})
-- use rule "Transform.ag"(line 566, column 32)
_lhsOtypeSyns =
({-# LINE 566 "Transform.ag" #-}
[]
{-# LINE 3482 "Transform.hs" #-})
-- use rule "Transform.ag"(line 136, column 15)
_lhsOuseMap =
({-# LINE 136 "Transform.ag" #-}
Map.empty
{-# LINE 3487 "Transform.hs" #-})
-- copy rule (chain)
_lhsOattrDecls =
({-# LINE 135 "Transform.ag" #-}
_lhsIattrDecls
{-# LINE 3492 "Transform.hs" #-})
-- copy rule (chain)
_lhsOdefSets =
({-# LINE 103 "Transform.ag" #-}
_lhsIdefSets
{-# LINE 3497 "Transform.hs" #-})
-- copy rule (down)
_setOallFields =
({-# LINE 127 "Transform.ag" #-}
_lhsIallFields
{-# LINE 3502 "Transform.hs" #-})
-- copy rule (down)
_setOallNonterminals =
({-# LINE 87 "Transform.ag" #-}
_lhsIallNonterminals
{-# LINE 3507 "Transform.hs" #-})
-- copy rule (down)
_setOdefinedSets =
({-# LINE 106 "Transform.ag" #-}
_lhsIdefinedSets
{-# LINE 3512 "Transform.hs" #-})
( _setIcollectedNames,_setIerrors,_setInontSet) =
set_ _setOallFields _setOallNonterminals _setOdefinedSets
in ( _lhsOattrDecls,_lhsOattrOrderCollect,_lhsOblocks,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedConstructorsMap,_lhsOcollectedFields,_lhsOcollectedInsts,_lhsOcollectedMerges,_lhsOcollectedNames,_lhsOcollectedRules,_lhsOcollectedSetNames,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOctxCollect,_lhsOdefSets,_lhsOderivings,_lhsOerrors,_lhsOmoduleDecl,_lhsOparamsCollect,_lhsOpragmas,_lhsOsemPragmasCollect,_lhsOtypeSyns,_lhsOuseMap,_lhsOwrappers))) )
-- Elems -------------------------------------------------------
{-
visit 0:
inherited attributes:
allAttrDecls : Map NontermIdent (Attributes, Attributes)
allConstructors : Map NontermIdent (Set ConstructorIdent)
allFields : DataTypes
allNonterminals : Set NontermIdent
definedSets : DefinedSets
chained attributes:
attrDecls : Map NontermIdent (Attributes, Attributes)
defSets : Map Identifier (Set NontermIdent,Set Identifier)
synthesized attributes:
attrOrderCollect : AttrOrderMap
blocks : Blocks
collectedArounds : [ (NontermIdent, ConstructorIdent, [AroundInfo]) ]
collectedAugments : [ (NontermIdent, ConstructorIdent, [AugmentInfo]) ]
collectedConstructorsMap : Map NontermIdent (Set ConstructorIdent)
collectedFields : [(NontermIdent, ConstructorIdent, FieldMap)]
collectedInsts : [ (NontermIdent, ConstructorIdent, [Identifier]) ]
collectedMerges : [ (NontermIdent, ConstructorIdent, [MergeInfo]) ]
collectedNames : Set Identifier
collectedRules : [ (NontermIdent, ConstructorIdent, RuleInfo)]
collectedSetNames : Set Identifier
collectedSigs : [ (NontermIdent, ConstructorIdent, SigInfo) ]
collectedUniques : [ (NontermIdent, ConstructorIdent, [UniqueInfo]) ]
ctxCollect : ContextMap
derivings : Derivings
errors : Seq Error
moduleDecl : Maybe (String,String,String)
paramsCollect : ParamMap
pragmas : Options -> Options
semPragmasCollect : PragmaMap
typeSyns : TypeSyns
useMap : Map NontermIdent (Map Identifier (String,String,String))
wrappers : Set NontermIdent
alternatives:
alternative Cons:
child hd : Elem
child tl : Elems
alternative Nil:
-}
-- cata
sem_Elems :: Elems ->
T_Elems
sem_Elems list =
(Prelude.foldr sem_Elems_Cons sem_Elems_Nil (Prelude.map sem_Elem list) )
-- semantic domain
newtype T_Elems = T_Elems ((Map NontermIdent (Attributes, Attributes)) ->
(Map NontermIdent (Set ConstructorIdent)) ->
DataTypes ->
(Set NontermIdent) ->
(Map NontermIdent (Attributes, Attributes)) ->
(Map Identifier (Set NontermIdent,Set Identifier)) ->
DefinedSets ->
( (Map NontermIdent (Attributes, Attributes)),AttrOrderMap,Blocks,([ (NontermIdent, ConstructorIdent, [AroundInfo]) ]),([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ]),(Map NontermIdent (Set ConstructorIdent)),([(NontermIdent, ConstructorIdent, FieldMap)]),([ (NontermIdent, ConstructorIdent, [Identifier]) ]),([ (NontermIdent, ConstructorIdent, [MergeInfo]) ]),(Set Identifier),([ (NontermIdent, ConstructorIdent, RuleInfo)]),(Set Identifier),([ (NontermIdent, ConstructorIdent, SigInfo) ]),([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ]),ContextMap,(Map Identifier (Set NontermIdent,Set Identifier)),Derivings,(Seq Error),(Maybe (String,String,String)),ParamMap,(Options -> Options),PragmaMap,TypeSyns,(Map NontermIdent (Map Identifier (String,String,String))),(Set NontermIdent)))
data Inh_Elems = Inh_Elems {allAttrDecls_Inh_Elems :: !((Map NontermIdent (Attributes, Attributes))),allConstructors_Inh_Elems :: !((Map NontermIdent (Set ConstructorIdent))),allFields_Inh_Elems :: !(DataTypes),allNonterminals_Inh_Elems :: !((Set NontermIdent)),attrDecls_Inh_Elems :: !((Map NontermIdent (Attributes, Attributes))),defSets_Inh_Elems :: !((Map Identifier (Set NontermIdent,Set Identifier))),definedSets_Inh_Elems :: !(DefinedSets)}
data Syn_Elems = Syn_Elems {attrDecls_Syn_Elems :: !((Map NontermIdent (Attributes, Attributes))),attrOrderCollect_Syn_Elems :: !(AttrOrderMap),blocks_Syn_Elems :: !(Blocks),collectedArounds_Syn_Elems :: !(([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])),collectedAugments_Syn_Elems :: !(([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])),collectedConstructorsMap_Syn_Elems :: !((Map NontermIdent (Set ConstructorIdent))),collectedFields_Syn_Elems :: !(([(NontermIdent, ConstructorIdent, FieldMap)])),collectedInsts_Syn_Elems :: !(([ (NontermIdent, ConstructorIdent, [Identifier]) ])),collectedMerges_Syn_Elems :: !(([ (NontermIdent, ConstructorIdent, [MergeInfo]) ])),collectedNames_Syn_Elems :: !((Set Identifier)),collectedRules_Syn_Elems :: !(([ (NontermIdent, ConstructorIdent, RuleInfo)])),collectedSetNames_Syn_Elems :: !((Set Identifier)),collectedSigs_Syn_Elems :: !(([ (NontermIdent, ConstructorIdent, SigInfo) ])),collectedUniques_Syn_Elems :: !(([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])),ctxCollect_Syn_Elems :: !(ContextMap),defSets_Syn_Elems :: !((Map Identifier (Set NontermIdent,Set Identifier))),derivings_Syn_Elems :: !(Derivings),errors_Syn_Elems :: !((Seq Error)),moduleDecl_Syn_Elems :: !((Maybe (String,String,String))),paramsCollect_Syn_Elems :: !(ParamMap),pragmas_Syn_Elems :: !((Options -> Options)),semPragmasCollect_Syn_Elems :: !(PragmaMap),typeSyns_Syn_Elems :: !(TypeSyns),useMap_Syn_Elems :: !((Map NontermIdent (Map Identifier (String,String,String)))),wrappers_Syn_Elems :: !((Set NontermIdent))}
wrap_Elems :: T_Elems ->
Inh_Elems ->
Syn_Elems
wrap_Elems (T_Elems sem ) (Inh_Elems _lhsIallAttrDecls _lhsIallConstructors _lhsIallFields _lhsIallNonterminals _lhsIattrDecls _lhsIdefSets _lhsIdefinedSets ) =
(let ( _lhsOattrDecls,_lhsOattrOrderCollect,_lhsOblocks,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedConstructorsMap,_lhsOcollectedFields,_lhsOcollectedInsts,_lhsOcollectedMerges,_lhsOcollectedNames,_lhsOcollectedRules,_lhsOcollectedSetNames,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOctxCollect,_lhsOdefSets,_lhsOderivings,_lhsOerrors,_lhsOmoduleDecl,_lhsOparamsCollect,_lhsOpragmas,_lhsOsemPragmasCollect,_lhsOtypeSyns,_lhsOuseMap,_lhsOwrappers) = sem _lhsIallAttrDecls _lhsIallConstructors _lhsIallFields _lhsIallNonterminals _lhsIattrDecls _lhsIdefSets _lhsIdefinedSets
in (Syn_Elems _lhsOattrDecls _lhsOattrOrderCollect _lhsOblocks _lhsOcollectedArounds _lhsOcollectedAugments _lhsOcollectedConstructorsMap _lhsOcollectedFields _lhsOcollectedInsts _lhsOcollectedMerges _lhsOcollectedNames _lhsOcollectedRules _lhsOcollectedSetNames _lhsOcollectedSigs _lhsOcollectedUniques _lhsOctxCollect _lhsOdefSets _lhsOderivings _lhsOerrors _lhsOmoduleDecl _lhsOparamsCollect _lhsOpragmas _lhsOsemPragmasCollect _lhsOtypeSyns _lhsOuseMap _lhsOwrappers ))
sem_Elems_Cons :: T_Elem ->
T_Elems ->
T_Elems
sem_Elems_Cons (T_Elem hd_ ) (T_Elems tl_ ) =
(T_Elems (\ _lhsIallAttrDecls
_lhsIallConstructors
_lhsIallFields
_lhsIallNonterminals
_lhsIattrDecls
_lhsIdefSets
_lhsIdefinedSets ->
(let _lhsOattrOrderCollect :: AttrOrderMap
_lhsOblocks :: Blocks
_lhsOcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])
_lhsOcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])
_lhsOcollectedConstructorsMap :: (Map NontermIdent (Set ConstructorIdent))
_lhsOcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)])
_lhsOcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ])
_lhsOcollectedMerges :: ([ (NontermIdent, ConstructorIdent, [MergeInfo]) ])
_lhsOcollectedNames :: (Set Identifier)
_lhsOcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)])
_lhsOcollectedSetNames :: (Set Identifier)
_lhsOcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ])
_lhsOcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])
_lhsOctxCollect :: ContextMap
_lhsOderivings :: Derivings
_lhsOerrors :: (Seq Error)
_lhsOmoduleDecl :: (Maybe (String,String,String))
_lhsOparamsCollect :: ParamMap
_lhsOpragmas :: (Options -> Options)
_lhsOsemPragmasCollect :: PragmaMap
_lhsOtypeSyns :: TypeSyns
_lhsOuseMap :: (Map NontermIdent (Map Identifier (String,String,String)))
_lhsOwrappers :: (Set NontermIdent)
_lhsOattrDecls :: (Map NontermIdent (Attributes, Attributes))
_lhsOdefSets :: (Map Identifier (Set NontermIdent,Set Identifier))
_hdOallAttrDecls :: (Map NontermIdent (Attributes, Attributes))
_hdOallConstructors :: (Map NontermIdent (Set ConstructorIdent))
_hdOallFields :: DataTypes
_hdOallNonterminals :: (Set NontermIdent)
_hdOattrDecls :: (Map NontermIdent (Attributes, Attributes))
_hdOdefSets :: (Map Identifier (Set NontermIdent,Set Identifier))
_hdOdefinedSets :: DefinedSets
_tlOallAttrDecls :: (Map NontermIdent (Attributes, Attributes))
_tlOallConstructors :: (Map NontermIdent (Set ConstructorIdent))
_tlOallFields :: DataTypes
_tlOallNonterminals :: (Set NontermIdent)
_tlOattrDecls :: (Map NontermIdent (Attributes, Attributes))
_tlOdefSets :: (Map Identifier (Set NontermIdent,Set Identifier))
_tlOdefinedSets :: DefinedSets
_hdIattrDecls :: (Map NontermIdent (Attributes, Attributes))
_hdIattrOrderCollect :: AttrOrderMap
_hdIblocks :: Blocks
_hdIcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])
_hdIcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])
_hdIcollectedConstructorsMap :: (Map NontermIdent (Set ConstructorIdent))
_hdIcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)])
_hdIcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ])
_hdIcollectedMerges :: ([ (NontermIdent, ConstructorIdent, [MergeInfo]) ])
_hdIcollectedNames :: (Set Identifier)
_hdIcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)])
_hdIcollectedSetNames :: (Set Identifier)
_hdIcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ])
_hdIcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])
_hdIctxCollect :: ContextMap
_hdIdefSets :: (Map Identifier (Set NontermIdent,Set Identifier))
_hdIderivings :: Derivings
_hdIerrors :: (Seq Error)
_hdImoduleDecl :: (Maybe (String,String,String))
_hdIparamsCollect :: ParamMap
_hdIpragmas :: (Options -> Options)
_hdIsemPragmasCollect :: PragmaMap
_hdItypeSyns :: TypeSyns
_hdIuseMap :: (Map NontermIdent (Map Identifier (String,String,String)))
_hdIwrappers :: (Set NontermIdent)
_tlIattrDecls :: (Map NontermIdent (Attributes, Attributes))
_tlIattrOrderCollect :: AttrOrderMap
_tlIblocks :: Blocks
_tlIcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])
_tlIcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])
_tlIcollectedConstructorsMap :: (Map NontermIdent (Set ConstructorIdent))
_tlIcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)])
_tlIcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ])
_tlIcollectedMerges :: ([ (NontermIdent, ConstructorIdent, [MergeInfo]) ])
_tlIcollectedNames :: (Set Identifier)
_tlIcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)])
_tlIcollectedSetNames :: (Set Identifier)
_tlIcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ])
_tlIcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])
_tlIctxCollect :: ContextMap
_tlIdefSets :: (Map Identifier (Set NontermIdent,Set Identifier))
_tlIderivings :: Derivings
_tlIerrors :: (Seq Error)
_tlImoduleDecl :: (Maybe (String,String,String))
_tlIparamsCollect :: ParamMap
_tlIpragmas :: (Options -> Options)
_tlIsemPragmasCollect :: PragmaMap
_tlItypeSyns :: TypeSyns
_tlIuseMap :: (Map NontermIdent (Map Identifier (String,String,String)))
_tlIwrappers :: (Set NontermIdent)
-- use rule "Transform.ag"(line 780, column 55)
_lhsOattrOrderCollect =
({-# LINE 780 "Transform.ag" #-}
_hdIattrOrderCollect `orderMapUnion` _tlIattrOrderCollect
{-# LINE 3684 "Transform.hs" #-})
-- use rule "Transform.ag"(line 44, column 19)
_lhsOblocks =
({-# LINE 44 "Transform.ag" #-}
_hdIblocks `mapUnionWithPlusPlus` _tlIblocks
{-# LINE 3689 "Transform.hs" #-})
-- use rule "Transform.ag"(line 155, column 32)
_lhsOcollectedArounds =
({-# LINE 155 "Transform.ag" #-}
_hdIcollectedArounds ++ _tlIcollectedArounds
{-# LINE 3694 "Transform.hs" #-})
-- use rule "Transform.ag"(line 154, column 32)
_lhsOcollectedAugments =
({-# LINE 154 "Transform.ag" #-}
_hdIcollectedAugments ++ _tlIcollectedAugments
{-# LINE 3699 "Transform.hs" #-})
-- use rule "Transform.ag"(line 93, column 48)
_lhsOcollectedConstructorsMap =
({-# LINE 93 "Transform.ag" #-}
_hdIcollectedConstructorsMap `mapUnionWithSetUnion` _tlIcollectedConstructorsMap
{-# LINE 3704 "Transform.hs" #-})
-- use rule "Transform.ag"(line 124, column 28)
_lhsOcollectedFields =
({-# LINE 124 "Transform.ag" #-}
_hdIcollectedFields ++ _tlIcollectedFields
{-# LINE 3709 "Transform.hs" #-})
-- use rule "Transform.ag"(line 152, column 32)
_lhsOcollectedInsts =
({-# LINE 152 "Transform.ag" #-}
_hdIcollectedInsts ++ _tlIcollectedInsts
{-# LINE 3714 "Transform.hs" #-})
-- use rule "Transform.ag"(line 156, column 32)
_lhsOcollectedMerges =
({-# LINE 156 "Transform.ag" #-}
_hdIcollectedMerges ++ _tlIcollectedMerges
{-# LINE 3719 "Transform.hs" #-})
-- use rule "Transform.ag"(line 85, column 50)
_lhsOcollectedNames =
({-# LINE 85 "Transform.ag" #-}
_hdIcollectedNames `Set.union` _tlIcollectedNames
{-# LINE 3724 "Transform.hs" #-})
-- use rule "Transform.ag"(line 150, column 32)
_lhsOcollectedRules =
({-# LINE 150 "Transform.ag" #-}
_hdIcollectedRules ++ _tlIcollectedRules
{-# LINE 3729 "Transform.hs" #-})
-- use rule "Transform.ag"(line 84, column 50)
_lhsOcollectedSetNames =
({-# LINE 84 "Transform.ag" #-}
_hdIcollectedSetNames `Set.union` _tlIcollectedSetNames
{-# LINE 3734 "Transform.hs" #-})
-- use rule "Transform.ag"(line 151, column 32)
_lhsOcollectedSigs =
({-# LINE 151 "Transform.ag" #-}
_hdIcollectedSigs ++ _tlIcollectedSigs
{-# LINE 3739 "Transform.hs" #-})
-- use rule "Transform.ag"(line 153, column 32)
_lhsOcollectedUniques =
({-# LINE 153 "Transform.ag" #-}
_hdIcollectedUniques ++ _tlIcollectedUniques
{-# LINE 3744 "Transform.hs" #-})
-- use rule "Transform.ag"(line 835, column 34)
_lhsOctxCollect =
({-# LINE 835 "Transform.ag" #-}
_hdIctxCollect `mergeCtx` _tlIctxCollect
{-# LINE 3749 "Transform.hs" #-})
-- use rule "Transform.ag"(line 860, column 33)
_lhsOderivings =
({-# LINE 860 "Transform.ag" #-}
_hdIderivings `mergeDerivings` _tlIderivings
{-# LINE 3754 "Transform.hs" #-})
-- use rule "Transform.ag"(line 42, column 19)
_lhsOerrors =
({-# LINE 42 "Transform.ag" #-}
_hdIerrors Seq.>< _tlIerrors
{-# LINE 3759 "Transform.hs" #-})
-- use rule "Transform.ag"(line 1041, column 37)
_lhsOmoduleDecl =
({-# LINE 1041 "Transform.ag" #-}
_hdImoduleDecl `mplus` _tlImoduleDecl
{-# LINE 3764 "Transform.hs" #-})
-- use rule "Transform.ag"(line 812, column 37)
_lhsOparamsCollect =
({-# LINE 812 "Transform.ag" #-}
_hdIparamsCollect `mergeParams` _tlIparamsCollect
{-# LINE 3769 "Transform.hs" #-})
-- use rule "Transform.ag"(line 706, column 34)
_lhsOpragmas =
({-# LINE 706 "Transform.ag" #-}
_hdIpragmas . _tlIpragmas
{-# LINE 3774 "Transform.hs" #-})
-- use rule "Transform.ag"(line 752, column 56)
_lhsOsemPragmasCollect =
({-# LINE 752 "Transform.ag" #-}
_hdIsemPragmasCollect `pragmaMapUnion` _tlIsemPragmasCollect
{-# LINE 3779 "Transform.hs" #-})
-- use rule "Transform.ag"(line 566, column 32)
_lhsOtypeSyns =
({-# LINE 566 "Transform.ag" #-}
_hdItypeSyns ++ _tlItypeSyns
{-# LINE 3784 "Transform.hs" #-})
-- use rule "Transform.ag"(line 136, column 15)
_lhsOuseMap =
({-# LINE 136 "Transform.ag" #-}
_hdIuseMap `merge` _tlIuseMap
{-# LINE 3789 "Transform.hs" #-})
-- use rule "Transform.ag"(line 697, column 32)
_lhsOwrappers =
({-# LINE 697 "Transform.ag" #-}
_hdIwrappers `Set.union` _tlIwrappers
{-# LINE 3794 "Transform.hs" #-})
-- copy rule (up)
_lhsOattrDecls =
({-# LINE 135 "Transform.ag" #-}
_tlIattrDecls
{-# LINE 3799 "Transform.hs" #-})
-- copy rule (up)
_lhsOdefSets =
({-# LINE 103 "Transform.ag" #-}
_tlIdefSets
{-# LINE 3804 "Transform.hs" #-})
-- copy rule (down)
_hdOallAttrDecls =
({-# LINE 781 "Transform.ag" #-}
_lhsIallAttrDecls
{-# LINE 3809 "Transform.hs" #-})
-- copy rule (down)
_hdOallConstructors =
({-# LINE 95 "Transform.ag" #-}
_lhsIallConstructors
{-# LINE 3814 "Transform.hs" #-})
-- copy rule (down)
_hdOallFields =
({-# LINE 127 "Transform.ag" #-}
_lhsIallFields
{-# LINE 3819 "Transform.hs" #-})
-- copy rule (down)
_hdOallNonterminals =
({-# LINE 87 "Transform.ag" #-}
_lhsIallNonterminals
{-# LINE 3824 "Transform.hs" #-})
-- copy rule (down)
_hdOattrDecls =
({-# LINE 135 "Transform.ag" #-}
_lhsIattrDecls
{-# LINE 3829 "Transform.hs" #-})
-- copy rule (down)
_hdOdefSets =
({-# LINE 103 "Transform.ag" #-}
_lhsIdefSets
{-# LINE 3834 "Transform.hs" #-})
-- copy rule (down)
_hdOdefinedSets =
({-# LINE 106 "Transform.ag" #-}
_lhsIdefinedSets
{-# LINE 3839 "Transform.hs" #-})
-- copy rule (down)
_tlOallAttrDecls =
({-# LINE 781 "Transform.ag" #-}
_lhsIallAttrDecls
{-# LINE 3844 "Transform.hs" #-})
-- copy rule (down)
_tlOallConstructors =
({-# LINE 95 "Transform.ag" #-}
_lhsIallConstructors
{-# LINE 3849 "Transform.hs" #-})
-- copy rule (down)
_tlOallFields =
({-# LINE 127 "Transform.ag" #-}
_lhsIallFields
{-# LINE 3854 "Transform.hs" #-})
-- copy rule (down)
_tlOallNonterminals =
({-# LINE 87 "Transform.ag" #-}
_lhsIallNonterminals
{-# LINE 3859 "Transform.hs" #-})
-- copy rule (chain)
_tlOattrDecls =
({-# LINE 135 "Transform.ag" #-}
_hdIattrDecls
{-# LINE 3864 "Transform.hs" #-})
-- copy rule (chain)
_tlOdefSets =
({-# LINE 103 "Transform.ag" #-}
_hdIdefSets
{-# LINE 3869 "Transform.hs" #-})
-- copy rule (down)
_tlOdefinedSets =
({-# LINE 106 "Transform.ag" #-}
_lhsIdefinedSets
{-# LINE 3874 "Transform.hs" #-})
( _hdIattrDecls,_hdIattrOrderCollect,_hdIblocks,_hdIcollectedArounds,_hdIcollectedAugments,_hdIcollectedConstructorsMap,_hdIcollectedFields,_hdIcollectedInsts,_hdIcollectedMerges,_hdIcollectedNames,_hdIcollectedRules,_hdIcollectedSetNames,_hdIcollectedSigs,_hdIcollectedUniques,_hdIctxCollect,_hdIdefSets,_hdIderivings,_hdIerrors,_hdImoduleDecl,_hdIparamsCollect,_hdIpragmas,_hdIsemPragmasCollect,_hdItypeSyns,_hdIuseMap,_hdIwrappers) =
hd_ _hdOallAttrDecls _hdOallConstructors _hdOallFields _hdOallNonterminals _hdOattrDecls _hdOdefSets _hdOdefinedSets
( _tlIattrDecls,_tlIattrOrderCollect,_tlIblocks,_tlIcollectedArounds,_tlIcollectedAugments,_tlIcollectedConstructorsMap,_tlIcollectedFields,_tlIcollectedInsts,_tlIcollectedMerges,_tlIcollectedNames,_tlIcollectedRules,_tlIcollectedSetNames,_tlIcollectedSigs,_tlIcollectedUniques,_tlIctxCollect,_tlIdefSets,_tlIderivings,_tlIerrors,_tlImoduleDecl,_tlIparamsCollect,_tlIpragmas,_tlIsemPragmasCollect,_tlItypeSyns,_tlIuseMap,_tlIwrappers) =
tl_ _tlOallAttrDecls _tlOallConstructors _tlOallFields _tlOallNonterminals _tlOattrDecls _tlOdefSets _tlOdefinedSets
in ( _lhsOattrDecls,_lhsOattrOrderCollect,_lhsOblocks,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedConstructorsMap,_lhsOcollectedFields,_lhsOcollectedInsts,_lhsOcollectedMerges,_lhsOcollectedNames,_lhsOcollectedRules,_lhsOcollectedSetNames,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOctxCollect,_lhsOdefSets,_lhsOderivings,_lhsOerrors,_lhsOmoduleDecl,_lhsOparamsCollect,_lhsOpragmas,_lhsOsemPragmasCollect,_lhsOtypeSyns,_lhsOuseMap,_lhsOwrappers))) )
sem_Elems_Nil :: T_Elems
sem_Elems_Nil =
(T_Elems (\ _lhsIallAttrDecls
_lhsIallConstructors
_lhsIallFields
_lhsIallNonterminals
_lhsIattrDecls
_lhsIdefSets
_lhsIdefinedSets ->
(let _lhsOattrOrderCollect :: AttrOrderMap
_lhsOblocks :: Blocks
_lhsOcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])
_lhsOcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])
_lhsOcollectedConstructorsMap :: (Map NontermIdent (Set ConstructorIdent))
_lhsOcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)])
_lhsOcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ])
_lhsOcollectedMerges :: ([ (NontermIdent, ConstructorIdent, [MergeInfo]) ])
_lhsOcollectedNames :: (Set Identifier)
_lhsOcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)])
_lhsOcollectedSetNames :: (Set Identifier)
_lhsOcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ])
_lhsOcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])
_lhsOctxCollect :: ContextMap
_lhsOderivings :: Derivings
_lhsOerrors :: (Seq Error)
_lhsOmoduleDecl :: (Maybe (String,String,String))
_lhsOparamsCollect :: ParamMap
_lhsOpragmas :: (Options -> Options)
_lhsOsemPragmasCollect :: PragmaMap
_lhsOtypeSyns :: TypeSyns
_lhsOuseMap :: (Map NontermIdent (Map Identifier (String,String,String)))
_lhsOwrappers :: (Set NontermIdent)
_lhsOattrDecls :: (Map NontermIdent (Attributes, Attributes))
_lhsOdefSets :: (Map Identifier (Set NontermIdent,Set Identifier))
-- use rule "Transform.ag"(line 780, column 55)
_lhsOattrOrderCollect =
({-# LINE 780 "Transform.ag" #-}
Map.empty
{-# LINE 3918 "Transform.hs" #-})
-- use rule "Transform.ag"(line 44, column 19)
_lhsOblocks =
({-# LINE 44 "Transform.ag" #-}
Map.empty
{-# LINE 3923 "Transform.hs" #-})
-- use rule "Transform.ag"(line 155, column 32)
_lhsOcollectedArounds =
({-# LINE 155 "Transform.ag" #-}
[]
{-# LINE 3928 "Transform.hs" #-})
-- use rule "Transform.ag"(line 154, column 32)
_lhsOcollectedAugments =
({-# LINE 154 "Transform.ag" #-}
[]
{-# LINE 3933 "Transform.hs" #-})
-- use rule "Transform.ag"(line 93, column 48)
_lhsOcollectedConstructorsMap =
({-# LINE 93 "Transform.ag" #-}
Map.empty
{-# LINE 3938 "Transform.hs" #-})
-- use rule "Transform.ag"(line 124, column 28)
_lhsOcollectedFields =
({-# LINE 124 "Transform.ag" #-}
[]
{-# LINE 3943 "Transform.hs" #-})
-- use rule "Transform.ag"(line 152, column 32)
_lhsOcollectedInsts =
({-# LINE 152 "Transform.ag" #-}
[]
{-# LINE 3948 "Transform.hs" #-})
-- use rule "Transform.ag"(line 156, column 32)
_lhsOcollectedMerges =
({-# LINE 156 "Transform.ag" #-}
[]
{-# LINE 3953 "Transform.hs" #-})
-- use rule "Transform.ag"(line 85, column 50)
_lhsOcollectedNames =
({-# LINE 85 "Transform.ag" #-}
Set.empty
{-# LINE 3958 "Transform.hs" #-})
-- use rule "Transform.ag"(line 150, column 32)
_lhsOcollectedRules =
({-# LINE 150 "Transform.ag" #-}
[]
{-# LINE 3963 "Transform.hs" #-})
-- use rule "Transform.ag"(line 84, column 50)
_lhsOcollectedSetNames =
({-# LINE 84 "Transform.ag" #-}
Set.empty
{-# LINE 3968 "Transform.hs" #-})
-- use rule "Transform.ag"(line 151, column 32)
_lhsOcollectedSigs =
({-# LINE 151 "Transform.ag" #-}
[]
{-# LINE 3973 "Transform.hs" #-})
-- use rule "Transform.ag"(line 153, column 32)
_lhsOcollectedUniques =
({-# LINE 153 "Transform.ag" #-}
[]
{-# LINE 3978 "Transform.hs" #-})
-- use rule "Transform.ag"(line 835, column 34)
_lhsOctxCollect =
({-# LINE 835 "Transform.ag" #-}
Map.empty
{-# LINE 3983 "Transform.hs" #-})
-- use rule "Transform.ag"(line 860, column 33)
_lhsOderivings =
({-# LINE 860 "Transform.ag" #-}
Map.empty
{-# LINE 3988 "Transform.hs" #-})
-- use rule "Transform.ag"(line 42, column 19)
_lhsOerrors =
({-# LINE 42 "Transform.ag" #-}
Seq.empty
{-# LINE 3993 "Transform.hs" #-})
-- use rule "Transform.ag"(line 1041, column 37)
_lhsOmoduleDecl =
({-# LINE 1041 "Transform.ag" #-}
mzero
{-# LINE 3998 "Transform.hs" #-})
-- use rule "Transform.ag"(line 812, column 37)
_lhsOparamsCollect =
({-# LINE 812 "Transform.ag" #-}
Map.empty
{-# LINE 4003 "Transform.hs" #-})
-- use rule "Transform.ag"(line 706, column 34)
_lhsOpragmas =
({-# LINE 706 "Transform.ag" #-}
id
{-# LINE 4008 "Transform.hs" #-})
-- use rule "Transform.ag"(line 752, column 56)
_lhsOsemPragmasCollect =
({-# LINE 752 "Transform.ag" #-}
Map.empty
{-# LINE 4013 "Transform.hs" #-})
-- use rule "Transform.ag"(line 566, column 32)
_lhsOtypeSyns =
({-# LINE 566 "Transform.ag" #-}
[]
{-# LINE 4018 "Transform.hs" #-})
-- use rule "Transform.ag"(line 136, column 15)
_lhsOuseMap =
({-# LINE 136 "Transform.ag" #-}
Map.empty
{-# LINE 4023 "Transform.hs" #-})
-- use rule "Transform.ag"(line 697, column 32)
_lhsOwrappers =
({-# LINE 697 "Transform.ag" #-}
Set.empty
{-# LINE 4028 "Transform.hs" #-})
-- copy rule (chain)
_lhsOattrDecls =
({-# LINE 135 "Transform.ag" #-}
_lhsIattrDecls
{-# LINE 4033 "Transform.hs" #-})
-- copy rule (chain)
_lhsOdefSets =
({-# LINE 103 "Transform.ag" #-}
_lhsIdefSets
{-# LINE 4038 "Transform.hs" #-})
in ( _lhsOattrDecls,_lhsOattrOrderCollect,_lhsOblocks,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedConstructorsMap,_lhsOcollectedFields,_lhsOcollectedInsts,_lhsOcollectedMerges,_lhsOcollectedNames,_lhsOcollectedRules,_lhsOcollectedSetNames,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOctxCollect,_lhsOdefSets,_lhsOderivings,_lhsOerrors,_lhsOmoduleDecl,_lhsOparamsCollect,_lhsOpragmas,_lhsOsemPragmasCollect,_lhsOtypeSyns,_lhsOuseMap,_lhsOwrappers))) )
-- NontSet -----------------------------------------------------
{-
visit 0:
inherited attributes:
allFields : DataTypes
allNonterminals : Set NontermIdent
definedSets : DefinedSets
synthesized attributes:
collectedNames : Set Identifier
errors : Seq Error
nontSet : Set NontermIdent
alternatives:
alternative All:
alternative Difference:
child set1 : NontSet
child set2 : NontSet
alternative Intersect:
child set1 : NontSet
child set2 : NontSet
alternative NamedSet:
child name : {NontermIdent}
visit 0:
local _tup4 : _
local nontSet : _
local errors : _
alternative Path:
child from : {NontermIdent}
child to : {NontermIdent}
alternative Union:
child set1 : NontSet
child set2 : NontSet
-}
-- cata
sem_NontSet :: NontSet ->
T_NontSet
sem_NontSet (All ) =
(sem_NontSet_All )
sem_NontSet (Difference _set1 _set2 ) =
(sem_NontSet_Difference (sem_NontSet _set1 ) (sem_NontSet _set2 ) )
sem_NontSet (Intersect _set1 _set2 ) =
(sem_NontSet_Intersect (sem_NontSet _set1 ) (sem_NontSet _set2 ) )
sem_NontSet (NamedSet _name ) =
(sem_NontSet_NamedSet _name )
sem_NontSet (Path _from _to ) =
(sem_NontSet_Path _from _to )
sem_NontSet (Union _set1 _set2 ) =
(sem_NontSet_Union (sem_NontSet _set1 ) (sem_NontSet _set2 ) )
-- semantic domain
newtype T_NontSet = T_NontSet (DataTypes ->
(Set NontermIdent) ->
DefinedSets ->
( (Set Identifier),(Seq Error),(Set NontermIdent)))
data Inh_NontSet = Inh_NontSet {allFields_Inh_NontSet :: !(DataTypes),allNonterminals_Inh_NontSet :: !((Set NontermIdent)),definedSets_Inh_NontSet :: !(DefinedSets)}
data Syn_NontSet = Syn_NontSet {collectedNames_Syn_NontSet :: !((Set Identifier)),errors_Syn_NontSet :: !((Seq Error)),nontSet_Syn_NontSet :: !((Set NontermIdent))}
wrap_NontSet :: T_NontSet ->
Inh_NontSet ->
Syn_NontSet
wrap_NontSet (T_NontSet sem ) (Inh_NontSet _lhsIallFields _lhsIallNonterminals _lhsIdefinedSets ) =
(let ( _lhsOcollectedNames,_lhsOerrors,_lhsOnontSet) = sem _lhsIallFields _lhsIallNonterminals _lhsIdefinedSets
in (Syn_NontSet _lhsOcollectedNames _lhsOerrors _lhsOnontSet ))
sem_NontSet_All :: T_NontSet
sem_NontSet_All =
(T_NontSet (\ _lhsIallFields
_lhsIallNonterminals
_lhsIdefinedSets ->
(let _lhsOnontSet :: (Set NontermIdent)
_lhsOcollectedNames :: (Set Identifier)
_lhsOerrors :: (Seq Error)
-- "Transform.ag"(line 643, column 16)
_lhsOnontSet =
({-# LINE 643 "Transform.ag" #-}
_lhsIallNonterminals
{-# LINE 4112 "Transform.hs" #-})
-- use rule "Transform.ag"(line 85, column 50)
_lhsOcollectedNames =
({-# LINE 85 "Transform.ag" #-}
Set.empty
{-# LINE 4117 "Transform.hs" #-})
-- use rule "Transform.ag"(line 42, column 19)
_lhsOerrors =
({-# LINE 42 "Transform.ag" #-}
Seq.empty
{-# LINE 4122 "Transform.hs" #-})
in ( _lhsOcollectedNames,_lhsOerrors,_lhsOnontSet))) )
sem_NontSet_Difference :: T_NontSet ->
T_NontSet ->
T_NontSet
sem_NontSet_Difference (T_NontSet set1_ ) (T_NontSet set2_ ) =
(T_NontSet (\ _lhsIallFields
_lhsIallNonterminals
_lhsIdefinedSets ->
(let _lhsOnontSet :: (Set NontermIdent)
_lhsOcollectedNames :: (Set Identifier)
_lhsOerrors :: (Seq Error)
_set1OallFields :: DataTypes
_set1OallNonterminals :: (Set NontermIdent)
_set1OdefinedSets :: DefinedSets
_set2OallFields :: DataTypes
_set2OallNonterminals :: (Set NontermIdent)
_set2OdefinedSets :: DefinedSets
_set1IcollectedNames :: (Set Identifier)
_set1Ierrors :: (Seq Error)
_set1InontSet :: (Set NontermIdent)
_set2IcollectedNames :: (Set Identifier)
_set2Ierrors :: (Seq Error)
_set2InontSet :: (Set NontermIdent)
-- "Transform.ag"(line 649, column 16)
_lhsOnontSet =
({-# LINE 649 "Transform.ag" #-}
Set.difference _set1InontSet _set2InontSet
{-# LINE 4150 "Transform.hs" #-})
-- use rule "Transform.ag"(line 85, column 50)
_lhsOcollectedNames =
({-# LINE 85 "Transform.ag" #-}
_set1IcollectedNames `Set.union` _set2IcollectedNames
{-# LINE 4155 "Transform.hs" #-})
-- use rule "Transform.ag"(line 42, column 19)
_lhsOerrors =
({-# LINE 42 "Transform.ag" #-}
_set1Ierrors Seq.>< _set2Ierrors
{-# LINE 4160 "Transform.hs" #-})
-- copy rule (down)
_set1OallFields =
({-# LINE 127 "Transform.ag" #-}
_lhsIallFields
{-# LINE 4165 "Transform.hs" #-})
-- copy rule (down)
_set1OallNonterminals =
({-# LINE 87 "Transform.ag" #-}
_lhsIallNonterminals
{-# LINE 4170 "Transform.hs" #-})
-- copy rule (down)
_set1OdefinedSets =
({-# LINE 106 "Transform.ag" #-}
_lhsIdefinedSets
{-# LINE 4175 "Transform.hs" #-})
-- copy rule (down)
_set2OallFields =
({-# LINE 127 "Transform.ag" #-}
_lhsIallFields
{-# LINE 4180 "Transform.hs" #-})
-- copy rule (down)
_set2OallNonterminals =
({-# LINE 87 "Transform.ag" #-}
_lhsIallNonterminals
{-# LINE 4185 "Transform.hs" #-})
-- copy rule (down)
_set2OdefinedSets =
({-# LINE 106 "Transform.ag" #-}
_lhsIdefinedSets
{-# LINE 4190 "Transform.hs" #-})
( _set1IcollectedNames,_set1Ierrors,_set1InontSet) =
set1_ _set1OallFields _set1OallNonterminals _set1OdefinedSets
( _set2IcollectedNames,_set2Ierrors,_set2InontSet) =
set2_ _set2OallFields _set2OallNonterminals _set2OdefinedSets
in ( _lhsOcollectedNames,_lhsOerrors,_lhsOnontSet))) )
sem_NontSet_Intersect :: T_NontSet ->
T_NontSet ->
T_NontSet
sem_NontSet_Intersect (T_NontSet set1_ ) (T_NontSet set2_ ) =
(T_NontSet (\ _lhsIallFields
_lhsIallNonterminals
_lhsIdefinedSets ->
(let _lhsOnontSet :: (Set NontermIdent)
_lhsOcollectedNames :: (Set Identifier)
_lhsOerrors :: (Seq Error)
_set1OallFields :: DataTypes
_set1OallNonterminals :: (Set NontermIdent)
_set1OdefinedSets :: DefinedSets
_set2OallFields :: DataTypes
_set2OallNonterminals :: (Set NontermIdent)
_set2OdefinedSets :: DefinedSets
_set1IcollectedNames :: (Set Identifier)
_set1Ierrors :: (Seq Error)
_set1InontSet :: (Set NontermIdent)
_set2IcollectedNames :: (Set Identifier)
_set2Ierrors :: (Seq Error)
_set2InontSet :: (Set NontermIdent)
-- "Transform.ag"(line 648, column 16)
_lhsOnontSet =
({-# LINE 648 "Transform.ag" #-}
Set.intersection _set1InontSet _set2InontSet
{-# LINE 4222 "Transform.hs" #-})
-- use rule "Transform.ag"(line 85, column 50)
_lhsOcollectedNames =
({-# LINE 85 "Transform.ag" #-}
_set1IcollectedNames `Set.union` _set2IcollectedNames
{-# LINE 4227 "Transform.hs" #-})
-- use rule "Transform.ag"(line 42, column 19)
_lhsOerrors =
({-# LINE 42 "Transform.ag" #-}
_set1Ierrors Seq.>< _set2Ierrors
{-# LINE 4232 "Transform.hs" #-})
-- copy rule (down)
_set1OallFields =
({-# LINE 127 "Transform.ag" #-}
_lhsIallFields
{-# LINE 4237 "Transform.hs" #-})
-- copy rule (down)
_set1OallNonterminals =
({-# LINE 87 "Transform.ag" #-}
_lhsIallNonterminals
{-# LINE 4242 "Transform.hs" #-})
-- copy rule (down)
_set1OdefinedSets =
({-# LINE 106 "Transform.ag" #-}
_lhsIdefinedSets
{-# LINE 4247 "Transform.hs" #-})
-- copy rule (down)
_set2OallFields =
({-# LINE 127 "Transform.ag" #-}
_lhsIallFields
{-# LINE 4252 "Transform.hs" #-})
-- copy rule (down)
_set2OallNonterminals =
({-# LINE 87 "Transform.ag" #-}
_lhsIallNonterminals
{-# LINE 4257 "Transform.hs" #-})
-- copy rule (down)
_set2OdefinedSets =
({-# LINE 106 "Transform.ag" #-}
_lhsIdefinedSets
{-# LINE 4262 "Transform.hs" #-})
( _set1IcollectedNames,_set1Ierrors,_set1InontSet) =
set1_ _set1OallFields _set1OallNonterminals _set1OdefinedSets
( _set2IcollectedNames,_set2Ierrors,_set2InontSet) =
set2_ _set2OallFields _set2OallNonterminals _set2OdefinedSets
in ( _lhsOcollectedNames,_lhsOerrors,_lhsOnontSet))) )
sem_NontSet_NamedSet :: NontermIdent ->
T_NontSet
sem_NontSet_NamedSet name_ =
(T_NontSet (\ _lhsIallFields
_lhsIallNonterminals
_lhsIdefinedSets ->
(let _lhsOcollectedNames :: (Set Identifier)
_lhsOerrors :: (Seq Error)
_lhsOnontSet :: (Set NontermIdent)
-- "Transform.ag"(line 528, column 14)
_lhsOcollectedNames =
({-# LINE 528 "Transform.ag" #-}
Set.singleton name_
{-# LINE 4281 "Transform.hs" #-})
-- "Transform.ag"(line 644, column 20)
__tup4 =
({-# LINE 644 "Transform.ag" #-}
case Map.lookup name_ _lhsIdefinedSets of
Nothing -> (Set.empty, Seq.singleton (UndefNont name_))
Just set -> (set, Seq.empty)
{-# LINE 4288 "Transform.hs" #-})
-- "Transform.ag"(line 644, column 20)
(_nontSet,_) =
({-# LINE 644 "Transform.ag" #-}
__tup4
{-# LINE 4293 "Transform.hs" #-})
-- "Transform.ag"(line 644, column 20)
(_,_errors) =
({-# LINE 644 "Transform.ag" #-}
__tup4
{-# LINE 4298 "Transform.hs" #-})
-- use rule "Transform.ag"(line 42, column 19)
_lhsOerrors =
({-# LINE 42 "Transform.ag" #-}
_errors
{-# LINE 4303 "Transform.hs" #-})
-- copy rule (from local)
_lhsOnontSet =
({-# LINE 111 "Transform.ag" #-}
_nontSet
{-# LINE 4308 "Transform.hs" #-})
in ( _lhsOcollectedNames,_lhsOerrors,_lhsOnontSet))) )
sem_NontSet_Path :: NontermIdent ->
NontermIdent ->
T_NontSet
sem_NontSet_Path from_ to_ =
(T_NontSet (\ _lhsIallFields
_lhsIallNonterminals
_lhsIdefinedSets ->
(let _lhsOnontSet :: (Set NontermIdent)
_lhsOerrors :: (Seq Error)
_lhsOcollectedNames :: (Set Identifier)
-- "Transform.ag"(line 650, column 16)
_lhsOnontSet =
({-# LINE 650 "Transform.ag" #-}
let table = flattenDatas _lhsIallFields
in path table from_ to_
{-# LINE 4325 "Transform.hs" #-})
-- "Transform.ag"(line 652, column 16)
_lhsOerrors =
({-# LINE 652 "Transform.ag" #-}
let check name | Set.member name _lhsIallNonterminals
= Seq.empty
| otherwise = Seq.singleton (UndefNont name)
in check from_ >< check to_
{-# LINE 4333 "Transform.hs" #-})
-- use rule "Transform.ag"(line 85, column 50)
_lhsOcollectedNames =
({-# LINE 85 "Transform.ag" #-}
Set.empty
{-# LINE 4338 "Transform.hs" #-})
in ( _lhsOcollectedNames,_lhsOerrors,_lhsOnontSet))) )
sem_NontSet_Union :: T_NontSet ->
T_NontSet ->
T_NontSet
sem_NontSet_Union (T_NontSet set1_ ) (T_NontSet set2_ ) =
(T_NontSet (\ _lhsIallFields
_lhsIallNonterminals
_lhsIdefinedSets ->
(let _lhsOnontSet :: (Set NontermIdent)
_lhsOcollectedNames :: (Set Identifier)
_lhsOerrors :: (Seq Error)
_set1OallFields :: DataTypes
_set1OallNonterminals :: (Set NontermIdent)
_set1OdefinedSets :: DefinedSets
_set2OallFields :: DataTypes
_set2OallNonterminals :: (Set NontermIdent)
_set2OdefinedSets :: DefinedSets
_set1IcollectedNames :: (Set Identifier)
_set1Ierrors :: (Seq Error)
_set1InontSet :: (Set NontermIdent)
_set2IcollectedNames :: (Set Identifier)
_set2Ierrors :: (Seq Error)
_set2InontSet :: (Set NontermIdent)
-- "Transform.ag"(line 647, column 16)
_lhsOnontSet =
({-# LINE 647 "Transform.ag" #-}
Set.union _set1InontSet _set2InontSet
{-# LINE 4366 "Transform.hs" #-})
-- use rule "Transform.ag"(line 85, column 50)
_lhsOcollectedNames =
({-# LINE 85 "Transform.ag" #-}
_set1IcollectedNames `Set.union` _set2IcollectedNames
{-# LINE 4371 "Transform.hs" #-})
-- use rule "Transform.ag"(line 42, column 19)
_lhsOerrors =
({-# LINE 42 "Transform.ag" #-}
_set1Ierrors Seq.>< _set2Ierrors
{-# LINE 4376 "Transform.hs" #-})
-- copy rule (down)
_set1OallFields =
({-# LINE 127 "Transform.ag" #-}
_lhsIallFields
{-# LINE 4381 "Transform.hs" #-})
-- copy rule (down)
_set1OallNonterminals =
({-# LINE 87 "Transform.ag" #-}
_lhsIallNonterminals
{-# LINE 4386 "Transform.hs" #-})
-- copy rule (down)
_set1OdefinedSets =
({-# LINE 106 "Transform.ag" #-}
_lhsIdefinedSets
{-# LINE 4391 "Transform.hs" #-})
-- copy rule (down)
_set2OallFields =
({-# LINE 127 "Transform.ag" #-}
_lhsIallFields
{-# LINE 4396 "Transform.hs" #-})
-- copy rule (down)
_set2OallNonterminals =
({-# LINE 87 "Transform.ag" #-}
_lhsIallNonterminals
{-# LINE 4401 "Transform.hs" #-})
-- copy rule (down)
_set2OdefinedSets =
({-# LINE 106 "Transform.ag" #-}
_lhsIdefinedSets
{-# LINE 4406 "Transform.hs" #-})
( _set1IcollectedNames,_set1Ierrors,_set1InontSet) =
set1_ _set1OallFields _set1OallNonterminals _set1OdefinedSets
( _set2IcollectedNames,_set2Ierrors,_set2InontSet) =
set2_ _set2OallFields _set2OallNonterminals _set2OdefinedSets
in ( _lhsOcollectedNames,_lhsOerrors,_lhsOnontSet))) )
-- Pattern -----------------------------------------------------
{-
visit 0:
synthesized attributes:
copy : SELF
definedAttrs : [AttrName]
definedInsts : [Identifier]
patunder : [AttrName]->Pattern
stpos : Pos
alternatives:
alternative Alias:
child field : {Identifier}
child attr : {Identifier}
child pat : Pattern
child parts : Patterns
visit 0:
local copy : _
alternative Constr:
child name : {ConstructorIdent}
child pats : Patterns
visit 0:
local copy : _
alternative Irrefutable:
child pat : Pattern
visit 0:
local copy : _
alternative Product:
child pos : {Pos}
child pats : Patterns
visit 0:
local copy : _
alternative Underscore:
child pos : {Pos}
visit 0:
local copy : _
-}
-- cata
sem_Pattern :: Pattern ->
T_Pattern
sem_Pattern (Alias _field _attr _pat _parts ) =
(sem_Pattern_Alias _field _attr (sem_Pattern _pat ) (sem_Patterns _parts ) )
sem_Pattern (Constr _name _pats ) =
(sem_Pattern_Constr _name (sem_Patterns _pats ) )
sem_Pattern (Irrefutable _pat ) =
(sem_Pattern_Irrefutable (sem_Pattern _pat ) )
sem_Pattern (Product _pos _pats ) =
(sem_Pattern_Product _pos (sem_Patterns _pats ) )
sem_Pattern (Underscore _pos ) =
(sem_Pattern_Underscore _pos )
-- semantic domain
newtype T_Pattern = T_Pattern (( Pattern ,([AttrName]),([Identifier]),([AttrName]->Pattern),Pos))
data Inh_Pattern = Inh_Pattern {}
data Syn_Pattern = Syn_Pattern {copy_Syn_Pattern :: !(Pattern ),definedAttrs_Syn_Pattern :: !(([AttrName])),definedInsts_Syn_Pattern :: !(([Identifier])),patunder_Syn_Pattern :: !(([AttrName]->Pattern)),stpos_Syn_Pattern :: !(Pos)}
wrap_Pattern :: T_Pattern ->
Inh_Pattern ->
Syn_Pattern
wrap_Pattern (T_Pattern sem ) (Inh_Pattern ) =
(let ( _lhsOcopy,_lhsOdefinedAttrs,_lhsOdefinedInsts,_lhsOpatunder,_lhsOstpos) = sem
in (Syn_Pattern _lhsOcopy _lhsOdefinedAttrs _lhsOdefinedInsts _lhsOpatunder _lhsOstpos ))
sem_Pattern_Alias :: Identifier ->
Identifier ->
T_Pattern ->
T_Patterns ->
T_Pattern
sem_Pattern_Alias field_ attr_ (T_Pattern pat_ ) (T_Patterns parts_ ) =
(T_Pattern (let _lhsOdefinedAttrs :: ([AttrName])
_lhsOpatunder :: ([AttrName]->Pattern)
_lhsOdefinedInsts :: ([Identifier])
_lhsOstpos :: Pos
_lhsOcopy :: Pattern
_patIcopy :: Pattern
_patIdefinedAttrs :: ([AttrName])
_patIdefinedInsts :: ([Identifier])
_patIpatunder :: ([AttrName]->Pattern)
_patIstpos :: Pos
_partsIcopy :: Patterns
_partsIdefinedAttrs :: ([AttrName])
_partsIdefinedInsts :: ([Identifier])
_partsIpatunder :: ([AttrName]->Patterns)
-- "Transform.ag"(line 1017, column 11)
_lhsOdefinedAttrs =
({-# LINE 1017 "Transform.ag" #-}
(field_, attr_) : _patIdefinedAttrs
{-# LINE 4495 "Transform.hs" #-})
-- "Transform.ag"(line 1018, column 11)
_lhsOpatunder =
({-# LINE 1018 "Transform.ag" #-}
\us -> if ((field_,attr_) `elem` us) then Underscore noPos else _copy
{-# LINE 4500 "Transform.hs" #-})
-- "Transform.ag"(line 1019, column 11)
_lhsOdefinedInsts =
({-# LINE 1019 "Transform.ag" #-}
(if field_ == _INST then [attr_] else []) ++ _patIdefinedInsts
{-# LINE 4505 "Transform.hs" #-})
-- "Transform.ag"(line 1034, column 16)
_lhsOstpos =
({-# LINE 1034 "Transform.ag" #-}
getPos field_
{-# LINE 4510 "Transform.hs" #-})
-- self rule
_copy =
({-# LINE 23 "./Patterns.ag" #-}
Alias field_ attr_ _patIcopy _partsIcopy
{-# LINE 4515 "Transform.hs" #-})
-- self rule
_lhsOcopy =
({-# LINE 23 "./Patterns.ag" #-}
_copy
{-# LINE 4520 "Transform.hs" #-})
( _patIcopy,_patIdefinedAttrs,_patIdefinedInsts,_patIpatunder,_patIstpos) =
pat_
( _partsIcopy,_partsIdefinedAttrs,_partsIdefinedInsts,_partsIpatunder) =
parts_
in ( _lhsOcopy,_lhsOdefinedAttrs,_lhsOdefinedInsts,_lhsOpatunder,_lhsOstpos)) )
sem_Pattern_Constr :: ConstructorIdent ->
T_Patterns ->
T_Pattern
sem_Pattern_Constr name_ (T_Patterns pats_ ) =
(T_Pattern (let _lhsOpatunder :: ([AttrName]->Pattern)
_lhsOstpos :: Pos
_lhsOdefinedAttrs :: ([AttrName])
_lhsOdefinedInsts :: ([Identifier])
_lhsOcopy :: Pattern
_patsIcopy :: Patterns
_patsIdefinedAttrs :: ([AttrName])
_patsIdefinedInsts :: ([Identifier])
_patsIpatunder :: ([AttrName]->Patterns)
-- "Transform.ag"(line 1021, column 12)
_lhsOpatunder =
({-# LINE 1021 "Transform.ag" #-}
\us -> Constr name_ (_patsIpatunder us)
{-# LINE 4543 "Transform.hs" #-})
-- "Transform.ag"(line 1032, column 16)
_lhsOstpos =
({-# LINE 1032 "Transform.ag" #-}
getPos name_
{-# LINE 4548 "Transform.hs" #-})
-- use rule "Transform.ag"(line 1012, column 42)
_lhsOdefinedAttrs =
({-# LINE 1012 "Transform.ag" #-}
_patsIdefinedAttrs
{-# LINE 4553 "Transform.hs" #-})
-- use rule "Transform.ag"(line 1011, column 55)
_lhsOdefinedInsts =
({-# LINE 1011 "Transform.ag" #-}
_patsIdefinedInsts
{-# LINE 4558 "Transform.hs" #-})
-- self rule
_copy =
({-# LINE 23 "./Patterns.ag" #-}
Constr name_ _patsIcopy
{-# LINE 4563 "Transform.hs" #-})
-- self rule
_lhsOcopy =
({-# LINE 23 "./Patterns.ag" #-}
_copy
{-# LINE 4568 "Transform.hs" #-})
( _patsIcopy,_patsIdefinedAttrs,_patsIdefinedInsts,_patsIpatunder) =
pats_
in ( _lhsOcopy,_lhsOdefinedAttrs,_lhsOdefinedInsts,_lhsOpatunder,_lhsOstpos)) )
sem_Pattern_Irrefutable :: T_Pattern ->
T_Pattern
sem_Pattern_Irrefutable (T_Pattern pat_ ) =
(T_Pattern (let _lhsOpatunder :: ([AttrName]->Pattern)
_lhsOdefinedAttrs :: ([AttrName])
_lhsOdefinedInsts :: ([Identifier])
_lhsOcopy :: Pattern
_lhsOstpos :: Pos
_patIcopy :: Pattern
_patIdefinedAttrs :: ([AttrName])
_patIdefinedInsts :: ([Identifier])
_patIpatunder :: ([AttrName]->Pattern)
_patIstpos :: Pos
-- "Transform.ag"(line 1023, column 17)
_lhsOpatunder =
({-# LINE 1023 "Transform.ag" #-}
\us -> Irrefutable (_patIpatunder us)
{-# LINE 4589 "Transform.hs" #-})
-- use rule "Transform.ag"(line 1012, column 42)
_lhsOdefinedAttrs =
({-# LINE 1012 "Transform.ag" #-}
_patIdefinedAttrs
{-# LINE 4594 "Transform.hs" #-})
-- use rule "Transform.ag"(line 1011, column 55)
_lhsOdefinedInsts =
({-# LINE 1011 "Transform.ag" #-}
_patIdefinedInsts
{-# LINE 4599 "Transform.hs" #-})
-- self rule
_copy =
({-# LINE 23 "./Patterns.ag" #-}
Irrefutable _patIcopy
{-# LINE 4604 "Transform.hs" #-})
-- self rule
_lhsOcopy =
({-# LINE 23 "./Patterns.ag" #-}
_copy
{-# LINE 4609 "Transform.hs" #-})
-- copy rule (up)
_lhsOstpos =
({-# LINE 1029 "Transform.ag" #-}
_patIstpos
{-# LINE 4614 "Transform.hs" #-})
( _patIcopy,_patIdefinedAttrs,_patIdefinedInsts,_patIpatunder,_patIstpos) =
pat_
in ( _lhsOcopy,_lhsOdefinedAttrs,_lhsOdefinedInsts,_lhsOpatunder,_lhsOstpos)) )
sem_Pattern_Product :: Pos ->
T_Patterns ->
T_Pattern
sem_Pattern_Product pos_ (T_Patterns pats_ ) =
(T_Pattern (let _lhsOpatunder :: ([AttrName]->Pattern)
_lhsOstpos :: Pos
_lhsOdefinedAttrs :: ([AttrName])
_lhsOdefinedInsts :: ([Identifier])
_lhsOcopy :: Pattern
_patsIcopy :: Patterns
_patsIdefinedAttrs :: ([AttrName])
_patsIdefinedInsts :: ([Identifier])
_patsIpatunder :: ([AttrName]->Patterns)
-- "Transform.ag"(line 1022, column 13)
_lhsOpatunder =
({-# LINE 1022 "Transform.ag" #-}
\us -> Product pos_ (_patsIpatunder us)
{-# LINE 4635 "Transform.hs" #-})
-- "Transform.ag"(line 1033, column 16)
_lhsOstpos =
({-# LINE 1033 "Transform.ag" #-}
pos_
{-# LINE 4640 "Transform.hs" #-})
-- use rule "Transform.ag"(line 1012, column 42)
_lhsOdefinedAttrs =
({-# LINE 1012 "Transform.ag" #-}
_patsIdefinedAttrs
{-# LINE 4645 "Transform.hs" #-})
-- use rule "Transform.ag"(line 1011, column 55)
_lhsOdefinedInsts =
({-# LINE 1011 "Transform.ag" #-}
_patsIdefinedInsts
{-# LINE 4650 "Transform.hs" #-})
-- self rule
_copy =
({-# LINE 23 "./Patterns.ag" #-}
Product pos_ _patsIcopy
{-# LINE 4655 "Transform.hs" #-})
-- self rule
_lhsOcopy =
({-# LINE 23 "./Patterns.ag" #-}
_copy
{-# LINE 4660 "Transform.hs" #-})
( _patsIcopy,_patsIdefinedAttrs,_patsIdefinedInsts,_patsIpatunder) =
pats_
in ( _lhsOcopy,_lhsOdefinedAttrs,_lhsOdefinedInsts,_lhsOpatunder,_lhsOstpos)) )
sem_Pattern_Underscore :: Pos ->
T_Pattern
sem_Pattern_Underscore pos_ =
(T_Pattern (let _lhsOpatunder :: ([AttrName]->Pattern)
_lhsOstpos :: Pos
_lhsOdefinedAttrs :: ([AttrName])
_lhsOdefinedInsts :: ([Identifier])
_lhsOcopy :: Pattern
-- "Transform.ag"(line 1020, column 16)
_lhsOpatunder =
({-# LINE 1020 "Transform.ag" #-}
\us -> _copy
{-# LINE 4676 "Transform.hs" #-})
-- "Transform.ag"(line 1035, column 16)
_lhsOstpos =
({-# LINE 1035 "Transform.ag" #-}
pos_
{-# LINE 4681 "Transform.hs" #-})
-- use rule "Transform.ag"(line 1012, column 42)
_lhsOdefinedAttrs =
({-# LINE 1012 "Transform.ag" #-}
[]
{-# LINE 4686 "Transform.hs" #-})
-- use rule "Transform.ag"(line 1011, column 55)
_lhsOdefinedInsts =
({-# LINE 1011 "Transform.ag" #-}
[]
{-# LINE 4691 "Transform.hs" #-})
-- self rule
_copy =
({-# LINE 23 "./Patterns.ag" #-}
Underscore pos_
{-# LINE 4696 "Transform.hs" #-})
-- self rule
_lhsOcopy =
({-# LINE 23 "./Patterns.ag" #-}
_copy
{-# LINE 4701 "Transform.hs" #-})
in ( _lhsOcopy,_lhsOdefinedAttrs,_lhsOdefinedInsts,_lhsOpatunder,_lhsOstpos)) )
-- Patterns ----------------------------------------------------
{-
visit 0:
synthesized attributes:
copy : SELF
definedAttrs : [AttrName]
definedInsts : [Identifier]
patunder : [AttrName]->Patterns
alternatives:
alternative Cons:
child hd : Pattern
child tl : Patterns
visit 0:
local copy : _
alternative Nil:
visit 0:
local copy : _
-}
-- cata
sem_Patterns :: Patterns ->
T_Patterns
sem_Patterns list =
(Prelude.foldr sem_Patterns_Cons sem_Patterns_Nil (Prelude.map sem_Pattern list) )
-- semantic domain
newtype T_Patterns = T_Patterns (( Patterns ,([AttrName]),([Identifier]),([AttrName]->Patterns)))
data Inh_Patterns = Inh_Patterns {}
data Syn_Patterns = Syn_Patterns {copy_Syn_Patterns :: !(Patterns ),definedAttrs_Syn_Patterns :: !(([AttrName])),definedInsts_Syn_Patterns :: !(([Identifier])),patunder_Syn_Patterns :: !(([AttrName]->Patterns))}
wrap_Patterns :: T_Patterns ->
Inh_Patterns ->
Syn_Patterns
wrap_Patterns (T_Patterns sem ) (Inh_Patterns ) =
(let ( _lhsOcopy,_lhsOdefinedAttrs,_lhsOdefinedInsts,_lhsOpatunder) = sem
in (Syn_Patterns _lhsOcopy _lhsOdefinedAttrs _lhsOdefinedInsts _lhsOpatunder ))
sem_Patterns_Cons :: T_Pattern ->
T_Patterns ->
T_Patterns
sem_Patterns_Cons (T_Pattern hd_ ) (T_Patterns tl_ ) =
(T_Patterns (let _lhsOpatunder :: ([AttrName]->Patterns)
_lhsOdefinedAttrs :: ([AttrName])
_lhsOdefinedInsts :: ([Identifier])
_lhsOcopy :: Patterns
_hdIcopy :: Pattern
_hdIdefinedAttrs :: ([AttrName])
_hdIdefinedInsts :: ([Identifier])
_hdIpatunder :: ([AttrName]->Pattern)
_hdIstpos :: Pos
_tlIcopy :: Patterns
_tlIdefinedAttrs :: ([AttrName])
_tlIdefinedInsts :: ([Identifier])
_tlIpatunder :: ([AttrName]->Patterns)
-- "Transform.ag"(line 1027, column 10)
_lhsOpatunder =
({-# LINE 1027 "Transform.ag" #-}
\us -> (_hdIpatunder us) : (_tlIpatunder us)
{-# LINE 4757 "Transform.hs" #-})
-- use rule "Transform.ag"(line 1012, column 42)
_lhsOdefinedAttrs =
({-# LINE 1012 "Transform.ag" #-}
_hdIdefinedAttrs ++ _tlIdefinedAttrs
{-# LINE 4762 "Transform.hs" #-})
-- use rule "Transform.ag"(line 1011, column 55)
_lhsOdefinedInsts =
({-# LINE 1011 "Transform.ag" #-}
_hdIdefinedInsts ++ _tlIdefinedInsts
{-# LINE 4767 "Transform.hs" #-})
-- self rule
_copy =
({-# LINE 23 "./Patterns.ag" #-}
(:) _hdIcopy _tlIcopy
{-# LINE 4772 "Transform.hs" #-})
-- self rule
_lhsOcopy =
({-# LINE 23 "./Patterns.ag" #-}
_copy
{-# LINE 4777 "Transform.hs" #-})
( _hdIcopy,_hdIdefinedAttrs,_hdIdefinedInsts,_hdIpatunder,_hdIstpos) =
hd_
( _tlIcopy,_tlIdefinedAttrs,_tlIdefinedInsts,_tlIpatunder) =
tl_
in ( _lhsOcopy,_lhsOdefinedAttrs,_lhsOdefinedInsts,_lhsOpatunder)) )
sem_Patterns_Nil :: T_Patterns
sem_Patterns_Nil =
(T_Patterns (let _lhsOpatunder :: ([AttrName]->Patterns)
_lhsOdefinedAttrs :: ([AttrName])
_lhsOdefinedInsts :: ([Identifier])
_lhsOcopy :: Patterns
-- "Transform.ag"(line 1026, column 9)
_lhsOpatunder =
({-# LINE 1026 "Transform.ag" #-}
\us -> []
{-# LINE 4793 "Transform.hs" #-})
-- use rule "Transform.ag"(line 1012, column 42)
_lhsOdefinedAttrs =
({-# LINE 1012 "Transform.ag" #-}
[]
{-# LINE 4798 "Transform.hs" #-})
-- use rule "Transform.ag"(line 1011, column 55)
_lhsOdefinedInsts =
({-# LINE 1011 "Transform.ag" #-}
[]
{-# LINE 4803 "Transform.hs" #-})
-- self rule
_copy =
({-# LINE 23 "./Patterns.ag" #-}
[]
{-# LINE 4808 "Transform.hs" #-})
-- self rule
_lhsOcopy =
({-# LINE 23 "./Patterns.ag" #-}
_copy
{-# LINE 4813 "Transform.hs" #-})
in ( _lhsOcopy,_lhsOdefinedAttrs,_lhsOdefinedInsts,_lhsOpatunder)) )
-- SemAlt ------------------------------------------------------
{-
visit 0:
inherited attributes:
allAttrDecls : Map NontermIdent (Attributes, Attributes)
allFields : DataTypes
nts : Set NontermIdent
synthesized attributes:
attrOrderCollect : AttrOrderMap
collectedArounds : [ (NontermIdent, ConstructorIdent, [AroundInfo]) ]
collectedAugments : [ (NontermIdent, ConstructorIdent, [AugmentInfo]) ]
collectedInsts : [ (NontermIdent, ConstructorIdent, [Identifier]) ]
collectedMerges : [ (NontermIdent, ConstructorIdent, [MergeInfo]) ]
collectedRules : [ (NontermIdent, ConstructorIdent, RuleInfo)]
collectedSigs : [ (NontermIdent, ConstructorIdent, SigInfo) ]
collectedUniques : [ (NontermIdent, ConstructorIdent, [UniqueInfo]) ]
errors : Seq Error
semPragmasCollect : PragmaMap
alternatives:
alternative SemAlt:
child pos : {Pos}
child constructorSet : ConstructorSet
child rules : SemDefs
visit 0:
local pragmaNames : _
local attrOrders : _
local coninfo : _
-}
-- cata
sem_SemAlt :: SemAlt ->
T_SemAlt
sem_SemAlt (SemAlt _pos _constructorSet _rules ) =
(sem_SemAlt_SemAlt _pos (sem_ConstructorSet _constructorSet ) (sem_SemDefs _rules ) )
-- semantic domain
newtype T_SemAlt = T_SemAlt ((Map NontermIdent (Attributes, Attributes)) ->
DataTypes ->
(Set NontermIdent) ->
( AttrOrderMap,([ (NontermIdent, ConstructorIdent, [AroundInfo]) ]),([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ]),([ (NontermIdent, ConstructorIdent, [Identifier]) ]),([ (NontermIdent, ConstructorIdent, [MergeInfo]) ]),([ (NontermIdent, ConstructorIdent, RuleInfo)]),([ (NontermIdent, ConstructorIdent, SigInfo) ]),([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ]),(Seq Error),PragmaMap))
data Inh_SemAlt = Inh_SemAlt {allAttrDecls_Inh_SemAlt :: !((Map NontermIdent (Attributes, Attributes))),allFields_Inh_SemAlt :: !(DataTypes),nts_Inh_SemAlt :: !((Set NontermIdent))}
data Syn_SemAlt = Syn_SemAlt {attrOrderCollect_Syn_SemAlt :: !(AttrOrderMap),collectedArounds_Syn_SemAlt :: !(([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])),collectedAugments_Syn_SemAlt :: !(([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])),collectedInsts_Syn_SemAlt :: !(([ (NontermIdent, ConstructorIdent, [Identifier]) ])),collectedMerges_Syn_SemAlt :: !(([ (NontermIdent, ConstructorIdent, [MergeInfo]) ])),collectedRules_Syn_SemAlt :: !(([ (NontermIdent, ConstructorIdent, RuleInfo)])),collectedSigs_Syn_SemAlt :: !(([ (NontermIdent, ConstructorIdent, SigInfo) ])),collectedUniques_Syn_SemAlt :: !(([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])),errors_Syn_SemAlt :: !((Seq Error)),semPragmasCollect_Syn_SemAlt :: !(PragmaMap)}
wrap_SemAlt :: T_SemAlt ->
Inh_SemAlt ->
Syn_SemAlt
wrap_SemAlt (T_SemAlt sem ) (Inh_SemAlt _lhsIallAttrDecls _lhsIallFields _lhsInts ) =
(let ( _lhsOattrOrderCollect,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedInsts,_lhsOcollectedMerges,_lhsOcollectedRules,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOerrors,_lhsOsemPragmasCollect) = sem _lhsIallAttrDecls _lhsIallFields _lhsInts
in (Syn_SemAlt _lhsOattrOrderCollect _lhsOcollectedArounds _lhsOcollectedAugments _lhsOcollectedInsts _lhsOcollectedMerges _lhsOcollectedRules _lhsOcollectedSigs _lhsOcollectedUniques _lhsOerrors _lhsOsemPragmasCollect ))
sem_SemAlt_SemAlt :: Pos ->
T_ConstructorSet ->
T_SemDefs ->
T_SemAlt
sem_SemAlt_SemAlt pos_ (T_ConstructorSet constructorSet_ ) (T_SemDefs rules_ ) =
(T_SemAlt (\ _lhsIallAttrDecls
_lhsIallFields
_lhsInts ->
(let _lhsOsemPragmasCollect :: PragmaMap
_lhsOattrOrderCollect :: AttrOrderMap
_lhsOerrors :: (Seq Error)
_lhsOcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)])
_lhsOcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ])
_lhsOcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ])
_lhsOcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])
_lhsOcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])
_lhsOcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])
_lhsOcollectedMerges :: ([ (NontermIdent, ConstructorIdent, [MergeInfo]) ])
_constructorSetIcollectedConstructorNames :: (Set ConstructorIdent)
_constructorSetIconstructors :: ((Set ConstructorIdent->Set ConstructorIdent))
_constructorSetIerrors :: (Seq Error)
_rulesIaroundInfos :: ([AroundInfo])
_rulesIaugmentInfos :: ([AugmentInfo])
_rulesIdefinedInsts :: ([Identifier])
_rulesImergeInfos :: ([MergeInfo])
_rulesIorderDepsCollect :: (Set Dependency)
_rulesIpragmaNamesCollect :: ([Identifier])
_rulesIruleInfos :: ([RuleInfo])
_rulesIsigInfos :: ([SigInfo])
_rulesIuniqueInfos :: ([UniqueInfo])
-- "Transform.ag"(line 756, column 7)
_pragmaNames =
({-# LINE 756 "Transform.ag" #-}
Set.fromList _rulesIpragmaNamesCollect
{-# LINE 4895 "Transform.hs" #-})
-- "Transform.ag"(line 757, column 7)
_lhsOsemPragmasCollect =
({-# LINE 757 "Transform.ag" #-}
foldr pragmaMapUnion Map.empty [ pragmaMapSingle nt con _pragmaNames
| (nt, conset, _) <- _coninfo
, con <- Set.toList conset
]
{-# LINE 4903 "Transform.hs" #-})
-- "Transform.ag"(line 785, column 7)
_attrOrders =
({-# LINE 785 "Transform.ag" #-}
[ orderMapSingle nt con _rulesIorderDepsCollect
| (nt, conset, _) <- _coninfo
, con <- Set.toList conset
]
{-# LINE 4911 "Transform.hs" #-})
-- "Transform.ag"(line 791, column 7)
_lhsOattrOrderCollect =
({-# LINE 791 "Transform.ag" #-}
foldr orderMapUnion Map.empty _attrOrders
{-# LINE 4916 "Transform.hs" #-})
-- "Transform.ag"(line 937, column 12)
_coninfo =
({-# LINE 937 "Transform.ag" #-}
[ (nt, conset, conkeys)
| nt <- Set.toList _lhsInts
, let conmap = Map.findWithDefault Map.empty nt _lhsIallFields
, let conkeys = Set.fromList (Map.keys conmap)
, let conset = _constructorSetIconstructors conkeys
]
{-# LINE 4926 "Transform.hs" #-})
-- "Transform.ag"(line 944, column 12)
_lhsOerrors =
({-# LINE 944 "Transform.ag" #-}
Seq.fromList
[ UndefAlt nt con
| (nt, conset, conkeys) <- _coninfo
, con <- Set.toList (Set.difference conset conkeys)
]
{-# LINE 4935 "Transform.hs" #-})
-- "Transform.ag"(line 949, column 12)
_lhsOcollectedRules =
({-# LINE 949 "Transform.ag" #-}
[ (nt,con,r)
| (nt, conset, _) <- _coninfo
, con <- Set.toList conset
, r <- _rulesIruleInfos
]
{-# LINE 4944 "Transform.hs" #-})
-- "Transform.ag"(line 955, column 12)
_lhsOcollectedSigs =
({-# LINE 955 "Transform.ag" #-}
[ (nt,con,ts)
| (nt, conset, _) <- _coninfo
, con <- Set.toList conset
, ts <- _rulesIsigInfos
]
{-# LINE 4953 "Transform.hs" #-})
-- "Transform.ag"(line 962, column 12)
_lhsOcollectedInsts =
({-# LINE 962 "Transform.ag" #-}
[ (nt,con,_rulesIdefinedInsts)
| (nt, conset, _) <- _coninfo
, con <- Set.toList conset
]
{-# LINE 4961 "Transform.hs" #-})
-- "Transform.ag"(line 968, column 12)
_lhsOcollectedUniques =
({-# LINE 968 "Transform.ag" #-}
[ (nt,con,_rulesIuniqueInfos)
| (nt, conset, _) <- _coninfo
, con <- Set.toList conset
]
{-# LINE 4969 "Transform.hs" #-})
-- "Transform.ag"(line 974, column 12)
_lhsOcollectedAugments =
({-# LINE 974 "Transform.ag" #-}
[ (nt, con, _rulesIaugmentInfos)
| (nt, conset, _) <- _coninfo
, con <- Set.toList conset
]
{-# LINE 4977 "Transform.hs" #-})
-- "Transform.ag"(line 980, column 12)
_lhsOcollectedArounds =
({-# LINE 980 "Transform.ag" #-}
[ (nt, con, _rulesIaroundInfos)
| (nt, conset, _) <- _coninfo
, con <- Set.toList conset
]
{-# LINE 4985 "Transform.hs" #-})
-- "Transform.ag"(line 986, column 12)
_lhsOcollectedMerges =
({-# LINE 986 "Transform.ag" #-}
[ (nt, con, _rulesImergeInfos)
| (nt, conset, _) <- _coninfo
, con <- Set.toList conset
]
{-# LINE 4993 "Transform.hs" #-})
( _constructorSetIcollectedConstructorNames,_constructorSetIconstructors,_constructorSetIerrors) =
constructorSet_
( _rulesIaroundInfos,_rulesIaugmentInfos,_rulesIdefinedInsts,_rulesImergeInfos,_rulesIorderDepsCollect,_rulesIpragmaNamesCollect,_rulesIruleInfos,_rulesIsigInfos,_rulesIuniqueInfos) =
rules_
in ( _lhsOattrOrderCollect,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedInsts,_lhsOcollectedMerges,_lhsOcollectedRules,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOerrors,_lhsOsemPragmasCollect))) )
-- SemAlts -----------------------------------------------------
{-
visit 0:
inherited attributes:
allAttrDecls : Map NontermIdent (Attributes, Attributes)
allFields : DataTypes
nts : Set NontermIdent
synthesized attributes:
attrOrderCollect : AttrOrderMap
collectedArounds : [ (NontermIdent, ConstructorIdent, [AroundInfo]) ]
collectedAugments : [ (NontermIdent, ConstructorIdent, [AugmentInfo]) ]
collectedInsts : [ (NontermIdent, ConstructorIdent, [Identifier]) ]
collectedMerges : [ (NontermIdent, ConstructorIdent, [MergeInfo]) ]
collectedRules : [ (NontermIdent, ConstructorIdent, RuleInfo)]
collectedSigs : [ (NontermIdent, ConstructorIdent, SigInfo) ]
collectedUniques : [ (NontermIdent, ConstructorIdent, [UniqueInfo]) ]
errors : Seq Error
semPragmasCollect : PragmaMap
alternatives:
alternative Cons:
child hd : SemAlt
child tl : SemAlts
alternative Nil:
-}
-- cata
sem_SemAlts :: SemAlts ->
T_SemAlts
sem_SemAlts list =
(Prelude.foldr sem_SemAlts_Cons sem_SemAlts_Nil (Prelude.map sem_SemAlt list) )
-- semantic domain
newtype T_SemAlts = T_SemAlts ((Map NontermIdent (Attributes, Attributes)) ->
DataTypes ->
(Set NontermIdent) ->
( AttrOrderMap,([ (NontermIdent, ConstructorIdent, [AroundInfo]) ]),([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ]),([ (NontermIdent, ConstructorIdent, [Identifier]) ]),([ (NontermIdent, ConstructorIdent, [MergeInfo]) ]),([ (NontermIdent, ConstructorIdent, RuleInfo)]),([ (NontermIdent, ConstructorIdent, SigInfo) ]),([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ]),(Seq Error),PragmaMap))
data Inh_SemAlts = Inh_SemAlts {allAttrDecls_Inh_SemAlts :: !((Map NontermIdent (Attributes, Attributes))),allFields_Inh_SemAlts :: !(DataTypes),nts_Inh_SemAlts :: !((Set NontermIdent))}
data Syn_SemAlts = Syn_SemAlts {attrOrderCollect_Syn_SemAlts :: !(AttrOrderMap),collectedArounds_Syn_SemAlts :: !(([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])),collectedAugments_Syn_SemAlts :: !(([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])),collectedInsts_Syn_SemAlts :: !(([ (NontermIdent, ConstructorIdent, [Identifier]) ])),collectedMerges_Syn_SemAlts :: !(([ (NontermIdent, ConstructorIdent, [MergeInfo]) ])),collectedRules_Syn_SemAlts :: !(([ (NontermIdent, ConstructorIdent, RuleInfo)])),collectedSigs_Syn_SemAlts :: !(([ (NontermIdent, ConstructorIdent, SigInfo) ])),collectedUniques_Syn_SemAlts :: !(([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])),errors_Syn_SemAlts :: !((Seq Error)),semPragmasCollect_Syn_SemAlts :: !(PragmaMap)}
wrap_SemAlts :: T_SemAlts ->
Inh_SemAlts ->
Syn_SemAlts
wrap_SemAlts (T_SemAlts sem ) (Inh_SemAlts _lhsIallAttrDecls _lhsIallFields _lhsInts ) =
(let ( _lhsOattrOrderCollect,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedInsts,_lhsOcollectedMerges,_lhsOcollectedRules,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOerrors,_lhsOsemPragmasCollect) = sem _lhsIallAttrDecls _lhsIallFields _lhsInts
in (Syn_SemAlts _lhsOattrOrderCollect _lhsOcollectedArounds _lhsOcollectedAugments _lhsOcollectedInsts _lhsOcollectedMerges _lhsOcollectedRules _lhsOcollectedSigs _lhsOcollectedUniques _lhsOerrors _lhsOsemPragmasCollect ))
sem_SemAlts_Cons :: T_SemAlt ->
T_SemAlts ->
T_SemAlts
sem_SemAlts_Cons (T_SemAlt hd_ ) (T_SemAlts tl_ ) =
(T_SemAlts (\ _lhsIallAttrDecls
_lhsIallFields
_lhsInts ->
(let _lhsOattrOrderCollect :: AttrOrderMap
_lhsOcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])
_lhsOcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])
_lhsOcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ])
_lhsOcollectedMerges :: ([ (NontermIdent, ConstructorIdent, [MergeInfo]) ])
_lhsOcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)])
_lhsOcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ])
_lhsOcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])
_lhsOerrors :: (Seq Error)
_lhsOsemPragmasCollect :: PragmaMap
_hdOallAttrDecls :: (Map NontermIdent (Attributes, Attributes))
_hdOallFields :: DataTypes
_hdOnts :: (Set NontermIdent)
_tlOallAttrDecls :: (Map NontermIdent (Attributes, Attributes))
_tlOallFields :: DataTypes
_tlOnts :: (Set NontermIdent)
_hdIattrOrderCollect :: AttrOrderMap
_hdIcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])
_hdIcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])
_hdIcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ])
_hdIcollectedMerges :: ([ (NontermIdent, ConstructorIdent, [MergeInfo]) ])
_hdIcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)])
_hdIcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ])
_hdIcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])
_hdIerrors :: (Seq Error)
_hdIsemPragmasCollect :: PragmaMap
_tlIattrOrderCollect :: AttrOrderMap
_tlIcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])
_tlIcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])
_tlIcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ])
_tlIcollectedMerges :: ([ (NontermIdent, ConstructorIdent, [MergeInfo]) ])
_tlIcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)])
_tlIcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ])
_tlIcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])
_tlIerrors :: (Seq Error)
_tlIsemPragmasCollect :: PragmaMap
-- use rule "Transform.ag"(line 780, column 55)
_lhsOattrOrderCollect =
({-# LINE 780 "Transform.ag" #-}
_hdIattrOrderCollect `orderMapUnion` _tlIattrOrderCollect
{-# LINE 5088 "Transform.hs" #-})
-- use rule "Transform.ag"(line 155, column 32)
_lhsOcollectedArounds =
({-# LINE 155 "Transform.ag" #-}
_hdIcollectedArounds ++ _tlIcollectedArounds
{-# LINE 5093 "Transform.hs" #-})
-- use rule "Transform.ag"(line 154, column 32)
_lhsOcollectedAugments =
({-# LINE 154 "Transform.ag" #-}
_hdIcollectedAugments ++ _tlIcollectedAugments
{-# LINE 5098 "Transform.hs" #-})
-- use rule "Transform.ag"(line 152, column 32)
_lhsOcollectedInsts =
({-# LINE 152 "Transform.ag" #-}
_hdIcollectedInsts ++ _tlIcollectedInsts
{-# LINE 5103 "Transform.hs" #-})
-- use rule "Transform.ag"(line 156, column 32)
_lhsOcollectedMerges =
({-# LINE 156 "Transform.ag" #-}
_hdIcollectedMerges ++ _tlIcollectedMerges
{-# LINE 5108 "Transform.hs" #-})
-- use rule "Transform.ag"(line 150, column 32)
_lhsOcollectedRules =
({-# LINE 150 "Transform.ag" #-}
_hdIcollectedRules ++ _tlIcollectedRules
{-# LINE 5113 "Transform.hs" #-})
-- use rule "Transform.ag"(line 151, column 32)
_lhsOcollectedSigs =
({-# LINE 151 "Transform.ag" #-}
_hdIcollectedSigs ++ _tlIcollectedSigs
{-# LINE 5118 "Transform.hs" #-})
-- use rule "Transform.ag"(line 153, column 32)
_lhsOcollectedUniques =
({-# LINE 153 "Transform.ag" #-}
_hdIcollectedUniques ++ _tlIcollectedUniques
{-# LINE 5123 "Transform.hs" #-})
-- use rule "Transform.ag"(line 42, column 19)
_lhsOerrors =
({-# LINE 42 "Transform.ag" #-}
_hdIerrors Seq.>< _tlIerrors
{-# LINE 5128 "Transform.hs" #-})
-- use rule "Transform.ag"(line 752, column 56)
_lhsOsemPragmasCollect =
({-# LINE 752 "Transform.ag" #-}
_hdIsemPragmasCollect `pragmaMapUnion` _tlIsemPragmasCollect
{-# LINE 5133 "Transform.hs" #-})
-- copy rule (down)
_hdOallAttrDecls =
({-# LINE 781 "Transform.ag" #-}
_lhsIallAttrDecls
{-# LINE 5138 "Transform.hs" #-})
-- copy rule (down)
_hdOallFields =
({-# LINE 127 "Transform.ag" #-}
_lhsIallFields
{-# LINE 5143 "Transform.hs" #-})
-- copy rule (down)
_hdOnts =
({-# LINE 166 "Transform.ag" #-}
_lhsInts
{-# LINE 5148 "Transform.hs" #-})
-- copy rule (down)
_tlOallAttrDecls =
({-# LINE 781 "Transform.ag" #-}
_lhsIallAttrDecls
{-# LINE 5153 "Transform.hs" #-})
-- copy rule (down)
_tlOallFields =
({-# LINE 127 "Transform.ag" #-}
_lhsIallFields
{-# LINE 5158 "Transform.hs" #-})
-- copy rule (down)
_tlOnts =
({-# LINE 166 "Transform.ag" #-}
_lhsInts
{-# LINE 5163 "Transform.hs" #-})
( _hdIattrOrderCollect,_hdIcollectedArounds,_hdIcollectedAugments,_hdIcollectedInsts,_hdIcollectedMerges,_hdIcollectedRules,_hdIcollectedSigs,_hdIcollectedUniques,_hdIerrors,_hdIsemPragmasCollect) =
hd_ _hdOallAttrDecls _hdOallFields _hdOnts
( _tlIattrOrderCollect,_tlIcollectedArounds,_tlIcollectedAugments,_tlIcollectedInsts,_tlIcollectedMerges,_tlIcollectedRules,_tlIcollectedSigs,_tlIcollectedUniques,_tlIerrors,_tlIsemPragmasCollect) =
tl_ _tlOallAttrDecls _tlOallFields _tlOnts
in ( _lhsOattrOrderCollect,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedInsts,_lhsOcollectedMerges,_lhsOcollectedRules,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOerrors,_lhsOsemPragmasCollect))) )
sem_SemAlts_Nil :: T_SemAlts
sem_SemAlts_Nil =
(T_SemAlts (\ _lhsIallAttrDecls
_lhsIallFields
_lhsInts ->
(let _lhsOattrOrderCollect :: AttrOrderMap
_lhsOcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])
_lhsOcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])
_lhsOcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ])
_lhsOcollectedMerges :: ([ (NontermIdent, ConstructorIdent, [MergeInfo]) ])
_lhsOcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)])
_lhsOcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ])
_lhsOcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])
_lhsOerrors :: (Seq Error)
_lhsOsemPragmasCollect :: PragmaMap
-- use rule "Transform.ag"(line 780, column 55)
_lhsOattrOrderCollect =
({-# LINE 780 "Transform.ag" #-}
Map.empty
{-# LINE 5188 "Transform.hs" #-})
-- use rule "Transform.ag"(line 155, column 32)
_lhsOcollectedArounds =
({-# LINE 155 "Transform.ag" #-}
[]
{-# LINE 5193 "Transform.hs" #-})
-- use rule "Transform.ag"(line 154, column 32)
_lhsOcollectedAugments =
({-# LINE 154 "Transform.ag" #-}
[]
{-# LINE 5198 "Transform.hs" #-})
-- use rule "Transform.ag"(line 152, column 32)
_lhsOcollectedInsts =
({-# LINE 152 "Transform.ag" #-}
[]
{-# LINE 5203 "Transform.hs" #-})
-- use rule "Transform.ag"(line 156, column 32)
_lhsOcollectedMerges =
({-# LINE 156 "Transform.ag" #-}
[]
{-# LINE 5208 "Transform.hs" #-})
-- use rule "Transform.ag"(line 150, column 32)
_lhsOcollectedRules =
({-# LINE 150 "Transform.ag" #-}
[]
{-# LINE 5213 "Transform.hs" #-})
-- use rule "Transform.ag"(line 151, column 32)
_lhsOcollectedSigs =
({-# LINE 151 "Transform.ag" #-}
[]
{-# LINE 5218 "Transform.hs" #-})
-- use rule "Transform.ag"(line 153, column 32)
_lhsOcollectedUniques =
({-# LINE 153 "Transform.ag" #-}
[]
{-# LINE 5223 "Transform.hs" #-})
-- use rule "Transform.ag"(line 42, column 19)
_lhsOerrors =
({-# LINE 42 "Transform.ag" #-}
Seq.empty
{-# LINE 5228 "Transform.hs" #-})
-- use rule "Transform.ag"(line 752, column 56)
_lhsOsemPragmasCollect =
({-# LINE 752 "Transform.ag" #-}
Map.empty
{-# LINE 5233 "Transform.hs" #-})
in ( _lhsOattrOrderCollect,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedInsts,_lhsOcollectedMerges,_lhsOcollectedRules,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOerrors,_lhsOsemPragmasCollect))) )
-- SemDef ------------------------------------------------------
{-
visit 0:
synthesized attributes:
aroundInfos : [AroundInfo]
augmentInfos : [AugmentInfo]
definedInsts : [Identifier]
mergeInfos : [MergeInfo]
orderDepsCollect : Set Dependency
pragmaNamesCollect : [Identifier]
ruleInfos : [RuleInfo]
sigInfos : [SigInfo]
uniqueInfos : [UniqueInfo]
alternatives:
alternative AroundDef:
child ident : {Identifier}
child rhs : {Expression}
alternative AttrOrderBefore:
child before : {[Occurrence]}
child after : {[Occurrence]}
visit 0:
local dependency : _
alternative AugmentDef:
child ident : {Identifier}
child rhs : {Expression}
alternative Def:
child pos : {Pos}
child mbName : {Maybe Identifier}
child pattern : Pattern
child rhs : {Expression}
child owrt : {Bool}
alternative MergeDef:
child target : {Identifier}
child nt : {Identifier}
child sources : {[Identifier]}
child rhs : {Expression}
alternative SemPragma:
child names : {[NontermIdent]}
alternative TypeDef:
child ident : {Identifier}
child tp : {Type}
alternative UniqueDef:
child ident : {Identifier}
child ref : {Identifier}
-}
-- cata
sem_SemDef :: SemDef ->
T_SemDef
sem_SemDef (AroundDef _ident _rhs ) =
(sem_SemDef_AroundDef _ident _rhs )
sem_SemDef (AttrOrderBefore _before _after ) =
(sem_SemDef_AttrOrderBefore _before _after )
sem_SemDef (AugmentDef _ident _rhs ) =
(sem_SemDef_AugmentDef _ident _rhs )
sem_SemDef (Def _pos _mbName _pattern _rhs _owrt ) =
(sem_SemDef_Def _pos _mbName (sem_Pattern _pattern ) _rhs _owrt )
sem_SemDef (MergeDef _target _nt _sources _rhs ) =
(sem_SemDef_MergeDef _target _nt _sources _rhs )
sem_SemDef (SemPragma _names ) =
(sem_SemDef_SemPragma _names )
sem_SemDef (TypeDef _ident _tp ) =
(sem_SemDef_TypeDef _ident _tp )
sem_SemDef (UniqueDef _ident _ref ) =
(sem_SemDef_UniqueDef _ident _ref )
-- semantic domain
newtype T_SemDef = T_SemDef (( ([AroundInfo]),([AugmentInfo]),([Identifier]),([MergeInfo]),(Set Dependency),([Identifier]),([RuleInfo]),([SigInfo]),([UniqueInfo])))
data Inh_SemDef = Inh_SemDef {}
data Syn_SemDef = Syn_SemDef {aroundInfos_Syn_SemDef :: !(([AroundInfo])),augmentInfos_Syn_SemDef :: !(([AugmentInfo])),definedInsts_Syn_SemDef :: !(([Identifier])),mergeInfos_Syn_SemDef :: !(([MergeInfo])),orderDepsCollect_Syn_SemDef :: !((Set Dependency)),pragmaNamesCollect_Syn_SemDef :: !(([Identifier])),ruleInfos_Syn_SemDef :: !(([RuleInfo])),sigInfos_Syn_SemDef :: !(([SigInfo])),uniqueInfos_Syn_SemDef :: !(([UniqueInfo]))}
wrap_SemDef :: T_SemDef ->
Inh_SemDef ->
Syn_SemDef
wrap_SemDef (T_SemDef sem ) (Inh_SemDef ) =
(let ( _lhsOaroundInfos,_lhsOaugmentInfos,_lhsOdefinedInsts,_lhsOmergeInfos,_lhsOorderDepsCollect,_lhsOpragmaNamesCollect,_lhsOruleInfos,_lhsOsigInfos,_lhsOuniqueInfos) = sem
in (Syn_SemDef _lhsOaroundInfos _lhsOaugmentInfos _lhsOdefinedInsts _lhsOmergeInfos _lhsOorderDepsCollect _lhsOpragmaNamesCollect _lhsOruleInfos _lhsOsigInfos _lhsOuniqueInfos ))
sem_SemDef_AroundDef :: Identifier ->
Expression ->
T_SemDef
sem_SemDef_AroundDef ident_ rhs_ =
(T_SemDef (let _lhsOaroundInfos :: ([AroundInfo])
_lhsOaugmentInfos :: ([AugmentInfo])
_lhsOdefinedInsts :: ([Identifier])
_lhsOmergeInfos :: ([MergeInfo])
_lhsOorderDepsCollect :: (Set Dependency)
_lhsOpragmaNamesCollect :: ([Identifier])
_lhsOruleInfos :: ([RuleInfo])
_lhsOsigInfos :: ([SigInfo])
_lhsOuniqueInfos :: ([UniqueInfo])
-- "Transform.ag"(line 1005, column 17)
_lhsOaroundInfos =
({-# LINE 1005 "Transform.ag" #-}
[ (ident_, rhs_) ]
{-# LINE 5326 "Transform.hs" #-})
-- use rule "Transform.ag"(line 930, column 40)
_lhsOaugmentInfos =
({-# LINE 930 "Transform.ag" #-}
[]
{-# LINE 5331 "Transform.hs" #-})
-- use rule "Transform.ag"(line 1011, column 55)
_lhsOdefinedInsts =
({-# LINE 1011 "Transform.ag" #-}
[]
{-# LINE 5336 "Transform.hs" #-})
-- use rule "Transform.ag"(line 932, column 40)
_lhsOmergeInfos =
({-# LINE 932 "Transform.ag" #-}
[]
{-# LINE 5341 "Transform.hs" #-})
-- use rule "Transform.ag"(line 793, column 44)
_lhsOorderDepsCollect =
({-# LINE 793 "Transform.ag" #-}
Set.empty
{-# LINE 5346 "Transform.hs" #-})
-- use rule "Transform.ag"(line 762, column 46)
_lhsOpragmaNamesCollect =
({-# LINE 762 "Transform.ag" #-}
[]
{-# LINE 5351 "Transform.hs" #-})
-- use rule "Transform.ag"(line 927, column 40)
_lhsOruleInfos =
({-# LINE 927 "Transform.ag" #-}
[]
{-# LINE 5356 "Transform.hs" #-})
-- use rule "Transform.ag"(line 928, column 40)
_lhsOsigInfos =
({-# LINE 928 "Transform.ag" #-}
[]
{-# LINE 5361 "Transform.hs" #-})
-- use rule "Transform.ag"(line 929, column 40)
_lhsOuniqueInfos =
({-# LINE 929 "Transform.ag" #-}
[]
{-# LINE 5366 "Transform.hs" #-})
in ( _lhsOaroundInfos,_lhsOaugmentInfos,_lhsOdefinedInsts,_lhsOmergeInfos,_lhsOorderDepsCollect,_lhsOpragmaNamesCollect,_lhsOruleInfos,_lhsOsigInfos,_lhsOuniqueInfos)) )
sem_SemDef_AttrOrderBefore :: ([Occurrence]) ->
([Occurrence]) ->
T_SemDef
sem_SemDef_AttrOrderBefore before_ after_ =
(T_SemDef (let _lhsOorderDepsCollect :: (Set Dependency)
_lhsOaroundInfos :: ([AroundInfo])
_lhsOaugmentInfos :: ([AugmentInfo])
_lhsOdefinedInsts :: ([Identifier])
_lhsOmergeInfos :: ([MergeInfo])
_lhsOpragmaNamesCollect :: ([Identifier])
_lhsOruleInfos :: ([RuleInfo])
_lhsOsigInfos :: ([SigInfo])
_lhsOuniqueInfos :: ([UniqueInfo])
-- "Transform.ag"(line 797, column 7)
_dependency =
({-# LINE 797 "Transform.ag" #-}
[ Dependency b a | b <- before_, a <- after_ ]
{-# LINE 5385 "Transform.hs" #-})
-- "Transform.ag"(line 798, column 7)
_lhsOorderDepsCollect =
({-# LINE 798 "Transform.ag" #-}
Set.fromList _dependency
{-# LINE 5390 "Transform.hs" #-})
-- use rule "Transform.ag"(line 931, column 40)
_lhsOaroundInfos =
({-# LINE 931 "Transform.ag" #-}
[]
{-# LINE 5395 "Transform.hs" #-})
-- use rule "Transform.ag"(line 930, column 40)
_lhsOaugmentInfos =
({-# LINE 930 "Transform.ag" #-}
[]
{-# LINE 5400 "Transform.hs" #-})
-- use rule "Transform.ag"(line 1011, column 55)
_lhsOdefinedInsts =
({-# LINE 1011 "Transform.ag" #-}
[]
{-# LINE 5405 "Transform.hs" #-})
-- use rule "Transform.ag"(line 932, column 40)
_lhsOmergeInfos =
({-# LINE 932 "Transform.ag" #-}
[]
{-# LINE 5410 "Transform.hs" #-})
-- use rule "Transform.ag"(line 762, column 46)
_lhsOpragmaNamesCollect =
({-# LINE 762 "Transform.ag" #-}
[]
{-# LINE 5415 "Transform.hs" #-})
-- use rule "Transform.ag"(line 927, column 40)
_lhsOruleInfos =
({-# LINE 927 "Transform.ag" #-}
[]
{-# LINE 5420 "Transform.hs" #-})
-- use rule "Transform.ag"(line 928, column 40)
_lhsOsigInfos =
({-# LINE 928 "Transform.ag" #-}
[]
{-# LINE 5425 "Transform.hs" #-})
-- use rule "Transform.ag"(line 929, column 40)
_lhsOuniqueInfos =
({-# LINE 929 "Transform.ag" #-}
[]
{-# LINE 5430 "Transform.hs" #-})
in ( _lhsOaroundInfos,_lhsOaugmentInfos,_lhsOdefinedInsts,_lhsOmergeInfos,_lhsOorderDepsCollect,_lhsOpragmaNamesCollect,_lhsOruleInfos,_lhsOsigInfos,_lhsOuniqueInfos)) )
sem_SemDef_AugmentDef :: Identifier ->
Expression ->
T_SemDef
sem_SemDef_AugmentDef ident_ rhs_ =
(T_SemDef (let _lhsOaugmentInfos :: ([AugmentInfo])
_lhsOaroundInfos :: ([AroundInfo])
_lhsOdefinedInsts :: ([Identifier])
_lhsOmergeInfos :: ([MergeInfo])
_lhsOorderDepsCollect :: (Set Dependency)
_lhsOpragmaNamesCollect :: ([Identifier])
_lhsOruleInfos :: ([RuleInfo])
_lhsOsigInfos :: ([SigInfo])
_lhsOuniqueInfos :: ([UniqueInfo])
-- "Transform.ag"(line 1002, column 17)
_lhsOaugmentInfos =
({-# LINE 1002 "Transform.ag" #-}
[ (ident_, rhs_) ]
{-# LINE 5449 "Transform.hs" #-})
-- use rule "Transform.ag"(line 931, column 40)
_lhsOaroundInfos =
({-# LINE 931 "Transform.ag" #-}
[]
{-# LINE 5454 "Transform.hs" #-})
-- use rule "Transform.ag"(line 1011, column 55)
_lhsOdefinedInsts =
({-# LINE 1011 "Transform.ag" #-}
[]
{-# LINE 5459 "Transform.hs" #-})
-- use rule "Transform.ag"(line 932, column 40)
_lhsOmergeInfos =
({-# LINE 932 "Transform.ag" #-}
[]
{-# LINE 5464 "Transform.hs" #-})
-- use rule "Transform.ag"(line 793, column 44)
_lhsOorderDepsCollect =
({-# LINE 793 "Transform.ag" #-}
Set.empty
{-# LINE 5469 "Transform.hs" #-})
-- use rule "Transform.ag"(line 762, column 46)
_lhsOpragmaNamesCollect =
({-# LINE 762 "Transform.ag" #-}
[]
{-# LINE 5474 "Transform.hs" #-})
-- use rule "Transform.ag"(line 927, column 40)
_lhsOruleInfos =
({-# LINE 927 "Transform.ag" #-}
[]
{-# LINE 5479 "Transform.hs" #-})
-- use rule "Transform.ag"(line 928, column 40)
_lhsOsigInfos =
({-# LINE 928 "Transform.ag" #-}
[]
{-# LINE 5484 "Transform.hs" #-})
-- use rule "Transform.ag"(line 929, column 40)
_lhsOuniqueInfos =
({-# LINE 929 "Transform.ag" #-}
[]
{-# LINE 5489 "Transform.hs" #-})
in ( _lhsOaroundInfos,_lhsOaugmentInfos,_lhsOdefinedInsts,_lhsOmergeInfos,_lhsOorderDepsCollect,_lhsOpragmaNamesCollect,_lhsOruleInfos,_lhsOsigInfos,_lhsOuniqueInfos)) )
sem_SemDef_Def :: Pos ->
(Maybe Identifier) ->
T_Pattern ->
Expression ->
Bool ->
T_SemDef
sem_SemDef_Def pos_ mbName_ (T_Pattern pattern_ ) rhs_ owrt_ =
(T_SemDef (let _lhsOruleInfos :: ([RuleInfo])
_lhsOaroundInfos :: ([AroundInfo])
_lhsOaugmentInfos :: ([AugmentInfo])
_lhsOdefinedInsts :: ([Identifier])
_lhsOmergeInfos :: ([MergeInfo])
_lhsOorderDepsCollect :: (Set Dependency)
_lhsOpragmaNamesCollect :: ([Identifier])
_lhsOsigInfos :: ([SigInfo])
_lhsOuniqueInfos :: ([UniqueInfo])
_patternIcopy :: Pattern
_patternIdefinedAttrs :: ([AttrName])
_patternIdefinedInsts :: ([Identifier])
_patternIpatunder :: ([AttrName]->Pattern)
_patternIstpos :: Pos
-- "Transform.ag"(line 993, column 10)
_lhsOruleInfos =
({-# LINE 993 "Transform.ag" #-}
[ (mbName_, _patternIpatunder, rhs_, _patternIdefinedAttrs, owrt_, show _patternIstpos) ]
{-# LINE 5516 "Transform.hs" #-})
-- use rule "Transform.ag"(line 931, column 40)
_lhsOaroundInfos =
({-# LINE 931 "Transform.ag" #-}
[]
{-# LINE 5521 "Transform.hs" #-})
-- use rule "Transform.ag"(line 930, column 40)
_lhsOaugmentInfos =
({-# LINE 930 "Transform.ag" #-}
[]
{-# LINE 5526 "Transform.hs" #-})
-- use rule "Transform.ag"(line 1011, column 55)
_lhsOdefinedInsts =
({-# LINE 1011 "Transform.ag" #-}
_patternIdefinedInsts
{-# LINE 5531 "Transform.hs" #-})
-- use rule "Transform.ag"(line 932, column 40)
_lhsOmergeInfos =
({-# LINE 932 "Transform.ag" #-}
[]
{-# LINE 5536 "Transform.hs" #-})
-- use rule "Transform.ag"(line 793, column 44)
_lhsOorderDepsCollect =
({-# LINE 793 "Transform.ag" #-}
Set.empty
{-# LINE 5541 "Transform.hs" #-})
-- use rule "Transform.ag"(line 762, column 46)
_lhsOpragmaNamesCollect =
({-# LINE 762 "Transform.ag" #-}
[]
{-# LINE 5546 "Transform.hs" #-})
-- use rule "Transform.ag"(line 928, column 40)
_lhsOsigInfos =
({-# LINE 928 "Transform.ag" #-}
[]
{-# LINE 5551 "Transform.hs" #-})
-- use rule "Transform.ag"(line 929, column 40)
_lhsOuniqueInfos =
({-# LINE 929 "Transform.ag" #-}
[]
{-# LINE 5556 "Transform.hs" #-})
( _patternIcopy,_patternIdefinedAttrs,_patternIdefinedInsts,_patternIpatunder,_patternIstpos) =
pattern_
in ( _lhsOaroundInfos,_lhsOaugmentInfos,_lhsOdefinedInsts,_lhsOmergeInfos,_lhsOorderDepsCollect,_lhsOpragmaNamesCollect,_lhsOruleInfos,_lhsOsigInfos,_lhsOuniqueInfos)) )
sem_SemDef_MergeDef :: Identifier ->
Identifier ->
([Identifier]) ->
Expression ->
T_SemDef
sem_SemDef_MergeDef target_ nt_ sources_ rhs_ =
(T_SemDef (let _lhsOmergeInfos :: ([MergeInfo])
_lhsOaroundInfos :: ([AroundInfo])
_lhsOaugmentInfos :: ([AugmentInfo])
_lhsOdefinedInsts :: ([Identifier])
_lhsOorderDepsCollect :: (Set Dependency)
_lhsOpragmaNamesCollect :: ([Identifier])
_lhsOruleInfos :: ([RuleInfo])
_lhsOsigInfos :: ([SigInfo])
_lhsOuniqueInfos :: ([UniqueInfo])
-- "Transform.ag"(line 1008, column 17)
_lhsOmergeInfos =
({-# LINE 1008 "Transform.ag" #-}
[ (target_, nt_, sources_, rhs_) ]
{-# LINE 5579 "Transform.hs" #-})
-- use rule "Transform.ag"(line 931, column 40)
_lhsOaroundInfos =
({-# LINE 931 "Transform.ag" #-}
[]
{-# LINE 5584 "Transform.hs" #-})
-- use rule "Transform.ag"(line 930, column 40)
_lhsOaugmentInfos =
({-# LINE 930 "Transform.ag" #-}
[]
{-# LINE 5589 "Transform.hs" #-})
-- use rule "Transform.ag"(line 1011, column 55)
_lhsOdefinedInsts =
({-# LINE 1011 "Transform.ag" #-}
[]
{-# LINE 5594 "Transform.hs" #-})
-- use rule "Transform.ag"(line 793, column 44)
_lhsOorderDepsCollect =
({-# LINE 793 "Transform.ag" #-}
Set.empty
{-# LINE 5599 "Transform.hs" #-})
-- use rule "Transform.ag"(line 762, column 46)
_lhsOpragmaNamesCollect =
({-# LINE 762 "Transform.ag" #-}
[]
{-# LINE 5604 "Transform.hs" #-})
-- use rule "Transform.ag"(line 927, column 40)
_lhsOruleInfos =
({-# LINE 927 "Transform.ag" #-}
[]
{-# LINE 5609 "Transform.hs" #-})
-- use rule "Transform.ag"(line 928, column 40)
_lhsOsigInfos =
({-# LINE 928 "Transform.ag" #-}
[]
{-# LINE 5614 "Transform.hs" #-})
-- use rule "Transform.ag"(line 929, column 40)
_lhsOuniqueInfos =
({-# LINE 929 "Transform.ag" #-}
[]
{-# LINE 5619 "Transform.hs" #-})
in ( _lhsOaroundInfos,_lhsOaugmentInfos,_lhsOdefinedInsts,_lhsOmergeInfos,_lhsOorderDepsCollect,_lhsOpragmaNamesCollect,_lhsOruleInfos,_lhsOsigInfos,_lhsOuniqueInfos)) )
sem_SemDef_SemPragma :: ([NontermIdent]) ->
T_SemDef
sem_SemDef_SemPragma names_ =
(T_SemDef (let _lhsOpragmaNamesCollect :: ([Identifier])
_lhsOaroundInfos :: ([AroundInfo])
_lhsOaugmentInfos :: ([AugmentInfo])
_lhsOdefinedInsts :: ([Identifier])
_lhsOmergeInfos :: ([MergeInfo])
_lhsOorderDepsCollect :: (Set Dependency)
_lhsOruleInfos :: ([RuleInfo])
_lhsOsigInfos :: ([SigInfo])
_lhsOuniqueInfos :: ([UniqueInfo])
-- "Transform.ag"(line 766, column 7)
_lhsOpragmaNamesCollect =
({-# LINE 766 "Transform.ag" #-}
names_
{-# LINE 5637 "Transform.hs" #-})
-- use rule "Transform.ag"(line 931, column 40)
_lhsOaroundInfos =
({-# LINE 931 "Transform.ag" #-}
[]
{-# LINE 5642 "Transform.hs" #-})
-- use rule "Transform.ag"(line 930, column 40)
_lhsOaugmentInfos =
({-# LINE 930 "Transform.ag" #-}
[]
{-# LINE 5647 "Transform.hs" #-})
-- use rule "Transform.ag"(line 1011, column 55)
_lhsOdefinedInsts =
({-# LINE 1011 "Transform.ag" #-}
[]
{-# LINE 5652 "Transform.hs" #-})
-- use rule "Transform.ag"(line 932, column 40)
_lhsOmergeInfos =
({-# LINE 932 "Transform.ag" #-}
[]
{-# LINE 5657 "Transform.hs" #-})
-- use rule "Transform.ag"(line 793, column 44)
_lhsOorderDepsCollect =
({-# LINE 793 "Transform.ag" #-}
Set.empty
{-# LINE 5662 "Transform.hs" #-})
-- use rule "Transform.ag"(line 927, column 40)
_lhsOruleInfos =
({-# LINE 927 "Transform.ag" #-}
[]
{-# LINE 5667 "Transform.hs" #-})
-- use rule "Transform.ag"(line 928, column 40)
_lhsOsigInfos =
({-# LINE 928 "Transform.ag" #-}
[]
{-# LINE 5672 "Transform.hs" #-})
-- use rule "Transform.ag"(line 929, column 40)
_lhsOuniqueInfos =
({-# LINE 929 "Transform.ag" #-}
[]
{-# LINE 5677 "Transform.hs" #-})
in ( _lhsOaroundInfos,_lhsOaugmentInfos,_lhsOdefinedInsts,_lhsOmergeInfos,_lhsOorderDepsCollect,_lhsOpragmaNamesCollect,_lhsOruleInfos,_lhsOsigInfos,_lhsOuniqueInfos)) )
sem_SemDef_TypeDef :: Identifier ->
Type ->
T_SemDef
sem_SemDef_TypeDef ident_ tp_ =
(T_SemDef (let _lhsOsigInfos :: ([SigInfo])
_lhsOaroundInfos :: ([AroundInfo])
_lhsOaugmentInfos :: ([AugmentInfo])
_lhsOdefinedInsts :: ([Identifier])
_lhsOmergeInfos :: ([MergeInfo])
_lhsOorderDepsCollect :: (Set Dependency)
_lhsOpragmaNamesCollect :: ([Identifier])
_lhsOruleInfos :: ([RuleInfo])
_lhsOuniqueInfos :: ([UniqueInfo])
-- "Transform.ag"(line 996, column 14)
_lhsOsigInfos =
({-# LINE 996 "Transform.ag" #-}
[ (ident_, tp_) ]
{-# LINE 5696 "Transform.hs" #-})
-- use rule "Transform.ag"(line 931, column 40)
_lhsOaroundInfos =
({-# LINE 931 "Transform.ag" #-}
[]
{-# LINE 5701 "Transform.hs" #-})
-- use rule "Transform.ag"(line 930, column 40)
_lhsOaugmentInfos =
({-# LINE 930 "Transform.ag" #-}
[]
{-# LINE 5706 "Transform.hs" #-})
-- use rule "Transform.ag"(line 1011, column 55)
_lhsOdefinedInsts =
({-# LINE 1011 "Transform.ag" #-}
[]
{-# LINE 5711 "Transform.hs" #-})
-- use rule "Transform.ag"(line 932, column 40)
_lhsOmergeInfos =
({-# LINE 932 "Transform.ag" #-}
[]
{-# LINE 5716 "Transform.hs" #-})
-- use rule "Transform.ag"(line 793, column 44)
_lhsOorderDepsCollect =
({-# LINE 793 "Transform.ag" #-}
Set.empty
{-# LINE 5721 "Transform.hs" #-})
-- use rule "Transform.ag"(line 762, column 46)
_lhsOpragmaNamesCollect =
({-# LINE 762 "Transform.ag" #-}
[]
{-# LINE 5726 "Transform.hs" #-})
-- use rule "Transform.ag"(line 927, column 40)
_lhsOruleInfos =
({-# LINE 927 "Transform.ag" #-}
[]
{-# LINE 5731 "Transform.hs" #-})
-- use rule "Transform.ag"(line 929, column 40)
_lhsOuniqueInfos =
({-# LINE 929 "Transform.ag" #-}
[]
{-# LINE 5736 "Transform.hs" #-})
in ( _lhsOaroundInfos,_lhsOaugmentInfos,_lhsOdefinedInsts,_lhsOmergeInfos,_lhsOorderDepsCollect,_lhsOpragmaNamesCollect,_lhsOruleInfos,_lhsOsigInfos,_lhsOuniqueInfos)) )
sem_SemDef_UniqueDef :: Identifier ->
Identifier ->
T_SemDef
sem_SemDef_UniqueDef ident_ ref_ =
(T_SemDef (let _lhsOuniqueInfos :: ([UniqueInfo])
_lhsOaroundInfos :: ([AroundInfo])
_lhsOaugmentInfos :: ([AugmentInfo])
_lhsOdefinedInsts :: ([Identifier])
_lhsOmergeInfos :: ([MergeInfo])
_lhsOorderDepsCollect :: (Set Dependency)
_lhsOpragmaNamesCollect :: ([Identifier])
_lhsOruleInfos :: ([RuleInfo])
_lhsOsigInfos :: ([SigInfo])
-- "Transform.ag"(line 999, column 16)
_lhsOuniqueInfos =
({-# LINE 999 "Transform.ag" #-}
[ (ident_, ref_) ]
{-# LINE 5755 "Transform.hs" #-})
-- use rule "Transform.ag"(line 931, column 40)
_lhsOaroundInfos =
({-# LINE 931 "Transform.ag" #-}
[]
{-# LINE 5760 "Transform.hs" #-})
-- use rule "Transform.ag"(line 930, column 40)
_lhsOaugmentInfos =
({-# LINE 930 "Transform.ag" #-}
[]
{-# LINE 5765 "Transform.hs" #-})
-- use rule "Transform.ag"(line 1011, column 55)
_lhsOdefinedInsts =
({-# LINE 1011 "Transform.ag" #-}
[]
{-# LINE 5770 "Transform.hs" #-})
-- use rule "Transform.ag"(line 932, column 40)
_lhsOmergeInfos =
({-# LINE 932 "Transform.ag" #-}
[]
{-# LINE 5775 "Transform.hs" #-})
-- use rule "Transform.ag"(line 793, column 44)
_lhsOorderDepsCollect =
({-# LINE 793 "Transform.ag" #-}
Set.empty
{-# LINE 5780 "Transform.hs" #-})
-- use rule "Transform.ag"(line 762, column 46)
_lhsOpragmaNamesCollect =
({-# LINE 762 "Transform.ag" #-}
[]
{-# LINE 5785 "Transform.hs" #-})
-- use rule "Transform.ag"(line 927, column 40)
_lhsOruleInfos =
({-# LINE 927 "Transform.ag" #-}
[]
{-# LINE 5790 "Transform.hs" #-})
-- use rule "Transform.ag"(line 928, column 40)
_lhsOsigInfos =
({-# LINE 928 "Transform.ag" #-}
[]
{-# LINE 5795 "Transform.hs" #-})
in ( _lhsOaroundInfos,_lhsOaugmentInfos,_lhsOdefinedInsts,_lhsOmergeInfos,_lhsOorderDepsCollect,_lhsOpragmaNamesCollect,_lhsOruleInfos,_lhsOsigInfos,_lhsOuniqueInfos)) )
-- SemDefs -----------------------------------------------------
{-
visit 0:
synthesized attributes:
aroundInfos : [AroundInfo]
augmentInfos : [AugmentInfo]
definedInsts : [Identifier]
mergeInfos : [MergeInfo]
orderDepsCollect : Set Dependency
pragmaNamesCollect : [Identifier]
ruleInfos : [RuleInfo]
sigInfos : [SigInfo]
uniqueInfos : [UniqueInfo]
alternatives:
alternative Cons:
child hd : SemDef
child tl : SemDefs
alternative Nil:
-}
-- cata
sem_SemDefs :: SemDefs ->
T_SemDefs
sem_SemDefs list =
(Prelude.foldr sem_SemDefs_Cons sem_SemDefs_Nil (Prelude.map sem_SemDef list) )
-- semantic domain
newtype T_SemDefs = T_SemDefs (( ([AroundInfo]),([AugmentInfo]),([Identifier]),([MergeInfo]),(Set Dependency),([Identifier]),([RuleInfo]),([SigInfo]),([UniqueInfo])))
data Inh_SemDefs = Inh_SemDefs {}
data Syn_SemDefs = Syn_SemDefs {aroundInfos_Syn_SemDefs :: !(([AroundInfo])),augmentInfos_Syn_SemDefs :: !(([AugmentInfo])),definedInsts_Syn_SemDefs :: !(([Identifier])),mergeInfos_Syn_SemDefs :: !(([MergeInfo])),orderDepsCollect_Syn_SemDefs :: !((Set Dependency)),pragmaNamesCollect_Syn_SemDefs :: !(([Identifier])),ruleInfos_Syn_SemDefs :: !(([RuleInfo])),sigInfos_Syn_SemDefs :: !(([SigInfo])),uniqueInfos_Syn_SemDefs :: !(([UniqueInfo]))}
wrap_SemDefs :: T_SemDefs ->
Inh_SemDefs ->
Syn_SemDefs
wrap_SemDefs (T_SemDefs sem ) (Inh_SemDefs ) =
(let ( _lhsOaroundInfos,_lhsOaugmentInfos,_lhsOdefinedInsts,_lhsOmergeInfos,_lhsOorderDepsCollect,_lhsOpragmaNamesCollect,_lhsOruleInfos,_lhsOsigInfos,_lhsOuniqueInfos) = sem
in (Syn_SemDefs _lhsOaroundInfos _lhsOaugmentInfos _lhsOdefinedInsts _lhsOmergeInfos _lhsOorderDepsCollect _lhsOpragmaNamesCollect _lhsOruleInfos _lhsOsigInfos _lhsOuniqueInfos ))
sem_SemDefs_Cons :: T_SemDef ->
T_SemDefs ->
T_SemDefs
sem_SemDefs_Cons (T_SemDef hd_ ) (T_SemDefs tl_ ) =
(T_SemDefs (let _lhsOaroundInfos :: ([AroundInfo])
_lhsOaugmentInfos :: ([AugmentInfo])
_lhsOdefinedInsts :: ([Identifier])
_lhsOmergeInfos :: ([MergeInfo])
_lhsOorderDepsCollect :: (Set Dependency)
_lhsOpragmaNamesCollect :: ([Identifier])
_lhsOruleInfos :: ([RuleInfo])
_lhsOsigInfos :: ([SigInfo])
_lhsOuniqueInfos :: ([UniqueInfo])
_hdIaroundInfos :: ([AroundInfo])
_hdIaugmentInfos :: ([AugmentInfo])
_hdIdefinedInsts :: ([Identifier])
_hdImergeInfos :: ([MergeInfo])
_hdIorderDepsCollect :: (Set Dependency)
_hdIpragmaNamesCollect :: ([Identifier])
_hdIruleInfos :: ([RuleInfo])
_hdIsigInfos :: ([SigInfo])
_hdIuniqueInfos :: ([UniqueInfo])
_tlIaroundInfos :: ([AroundInfo])
_tlIaugmentInfos :: ([AugmentInfo])
_tlIdefinedInsts :: ([Identifier])
_tlImergeInfos :: ([MergeInfo])
_tlIorderDepsCollect :: (Set Dependency)
_tlIpragmaNamesCollect :: ([Identifier])
_tlIruleInfos :: ([RuleInfo])
_tlIsigInfos :: ([SigInfo])
_tlIuniqueInfos :: ([UniqueInfo])
-- use rule "Transform.ag"(line 931, column 40)
_lhsOaroundInfos =
({-# LINE 931 "Transform.ag" #-}
_hdIaroundInfos ++ _tlIaroundInfos
{-# LINE 5866 "Transform.hs" #-})
-- use rule "Transform.ag"(line 930, column 40)
_lhsOaugmentInfos =
({-# LINE 930 "Transform.ag" #-}
_hdIaugmentInfos ++ _tlIaugmentInfos
{-# LINE 5871 "Transform.hs" #-})
-- use rule "Transform.ag"(line 1011, column 55)
_lhsOdefinedInsts =
({-# LINE 1011 "Transform.ag" #-}
_hdIdefinedInsts ++ _tlIdefinedInsts
{-# LINE 5876 "Transform.hs" #-})
-- use rule "Transform.ag"(line 932, column 40)
_lhsOmergeInfos =
({-# LINE 932 "Transform.ag" #-}
_hdImergeInfos ++ _tlImergeInfos
{-# LINE 5881 "Transform.hs" #-})
-- use rule "Transform.ag"(line 793, column 44)
_lhsOorderDepsCollect =
({-# LINE 793 "Transform.ag" #-}
_hdIorderDepsCollect `Set.union` _tlIorderDepsCollect
{-# LINE 5886 "Transform.hs" #-})
-- use rule "Transform.ag"(line 762, column 46)
_lhsOpragmaNamesCollect =
({-# LINE 762 "Transform.ag" #-}
_hdIpragmaNamesCollect ++ _tlIpragmaNamesCollect
{-# LINE 5891 "Transform.hs" #-})
-- use rule "Transform.ag"(line 927, column 40)
_lhsOruleInfos =
({-# LINE 927 "Transform.ag" #-}
_hdIruleInfos ++ _tlIruleInfos
{-# LINE 5896 "Transform.hs" #-})
-- use rule "Transform.ag"(line 928, column 40)
_lhsOsigInfos =
({-# LINE 928 "Transform.ag" #-}
_hdIsigInfos ++ _tlIsigInfos
{-# LINE 5901 "Transform.hs" #-})
-- use rule "Transform.ag"(line 929, column 40)
_lhsOuniqueInfos =
({-# LINE 929 "Transform.ag" #-}
_hdIuniqueInfos ++ _tlIuniqueInfos
{-# LINE 5906 "Transform.hs" #-})
( _hdIaroundInfos,_hdIaugmentInfos,_hdIdefinedInsts,_hdImergeInfos,_hdIorderDepsCollect,_hdIpragmaNamesCollect,_hdIruleInfos,_hdIsigInfos,_hdIuniqueInfos) =
hd_
( _tlIaroundInfos,_tlIaugmentInfos,_tlIdefinedInsts,_tlImergeInfos,_tlIorderDepsCollect,_tlIpragmaNamesCollect,_tlIruleInfos,_tlIsigInfos,_tlIuniqueInfos) =
tl_
in ( _lhsOaroundInfos,_lhsOaugmentInfos,_lhsOdefinedInsts,_lhsOmergeInfos,_lhsOorderDepsCollect,_lhsOpragmaNamesCollect,_lhsOruleInfos,_lhsOsigInfos,_lhsOuniqueInfos)) )
sem_SemDefs_Nil :: T_SemDefs
sem_SemDefs_Nil =
(T_SemDefs (let _lhsOaroundInfos :: ([AroundInfo])
_lhsOaugmentInfos :: ([AugmentInfo])
_lhsOdefinedInsts :: ([Identifier])
_lhsOmergeInfos :: ([MergeInfo])
_lhsOorderDepsCollect :: (Set Dependency)
_lhsOpragmaNamesCollect :: ([Identifier])
_lhsOruleInfos :: ([RuleInfo])
_lhsOsigInfos :: ([SigInfo])
_lhsOuniqueInfos :: ([UniqueInfo])
-- use rule "Transform.ag"(line 931, column 40)
_lhsOaroundInfos =
({-# LINE 931 "Transform.ag" #-}
[]
{-# LINE 5927 "Transform.hs" #-})
-- use rule "Transform.ag"(line 930, column 40)
_lhsOaugmentInfos =
({-# LINE 930 "Transform.ag" #-}
[]
{-# LINE 5932 "Transform.hs" #-})
-- use rule "Transform.ag"(line 1011, column 55)
_lhsOdefinedInsts =
({-# LINE 1011 "Transform.ag" #-}
[]
{-# LINE 5937 "Transform.hs" #-})
-- use rule "Transform.ag"(line 932, column 40)
_lhsOmergeInfos =
({-# LINE 932 "Transform.ag" #-}
[]
{-# LINE 5942 "Transform.hs" #-})
-- use rule "Transform.ag"(line 793, column 44)
_lhsOorderDepsCollect =
({-# LINE 793 "Transform.ag" #-}
Set.empty
{-# LINE 5947 "Transform.hs" #-})
-- use rule "Transform.ag"(line 762, column 46)
_lhsOpragmaNamesCollect =
({-# LINE 762 "Transform.ag" #-}
[]
{-# LINE 5952 "Transform.hs" #-})
-- use rule "Transform.ag"(line 927, column 40)
_lhsOruleInfos =
({-# LINE 927 "Transform.ag" #-}
[]
{-# LINE 5957 "Transform.hs" #-})
-- use rule "Transform.ag"(line 928, column 40)
_lhsOsigInfos =
({-# LINE 928 "Transform.ag" #-}
[]
{-# LINE 5962 "Transform.hs" #-})
-- use rule "Transform.ag"(line 929, column 40)
_lhsOuniqueInfos =
({-# LINE 929 "Transform.ag" #-}
[]
{-# LINE 5967 "Transform.hs" #-})
in ( _lhsOaroundInfos,_lhsOaugmentInfos,_lhsOdefinedInsts,_lhsOmergeInfos,_lhsOorderDepsCollect,_lhsOpragmaNamesCollect,_lhsOruleInfos,_lhsOsigInfos,_lhsOuniqueInfos)) )