uuagc-0.9.29: src-derived/Transform.hs
-- UUAGC 0.9.28 (Transform.ag)
module Transform where
{-# LINE 8 "Transform.ag" #-}
import Control.Monad(mplus,mzero)
import List (partition, elem, nub,intersperse)
import Data.Maybe
import qualified Data.Map as Map
import Data.Map (Map)
import Data.Set as Set (Set, member, union, toList, fromList, empty, singleton, member, unions, size, fold, intersection, difference, insert)
import qualified Data.Sequence as Seq
import Data.Sequence(Seq, empty, (><),fromList)
import Data.Foldable(toList)
import UU.Scanner.Position(noPos)
import ConcreteSyntax
import AbstractSyntax
import ErrorMessages
import Patterns (Patterns(..),Pattern(..))
import Expression (Expression(..))
import HsToken
import Options
import CommonTypes
{-# LINE 28 "../src-derived/Transform.hs" #-}
{-# LINE 2 "./ConcreteSyntax.ag" #-}
import UU.Scanner.Position (Pos)
import Patterns (Pattern)
import Expression (Expression)
import CommonTypes
{-# LINE 36 "../src-derived/Transform.hs" #-}
{-# LINE 2 "./Patterns.ag" #-}
-- Patterns.ag imports
import UU.Scanner.Position(Pos)
import CommonTypes (ConstructorIdent,Identifier)
{-# LINE 43 "../src-derived/Transform.hs" #-}
{-# LINE 99 "Transform.ag" #-}
type DefinedSets = Map Identifier (Set NontermIdent)
{-# LINE 46 "../src-derived/Transform.hs" #-}
{-# LINE 119 "Transform.ag" #-}
type FieldMap = [(Identifier, Type)]
{-# LINE 50 "../src-derived/Transform.hs" #-}
{-# LINE 120 "Transform.ag" #-}
type DataTypes = Map.Map NontermIdent (Map.Map ConstructorIdent FieldMap)
{-# LINE 54 "../src-derived/Transform.hs" #-}
{-# LINE 140 "Transform.ag" #-}
type AttrName = (Identifier,Identifier)
{-# LINE 58 "../src-derived/Transform.hs" #-}
{-# LINE 141 "Transform.ag" #-}
type RuleInfo = (Maybe Identifier, [AttrName]->Pattern, Expression, [AttrName], Bool, String)
{-# LINE 62 "../src-derived/Transform.hs" #-}
{-# LINE 142 "Transform.ag" #-}
type SigInfo = (Identifier,Type)
{-# LINE 66 "../src-derived/Transform.hs" #-}
{-# LINE 143 "Transform.ag" #-}
type UniqueInfo = (Identifier,Identifier)
{-# LINE 70 "../src-derived/Transform.hs" #-}
{-# LINE 144 "Transform.ag" #-}
type AugmentInfo = (Identifier,Expression)
{-# LINE 74 "../src-derived/Transform.hs" #-}
{-# LINE 145 "Transform.ag" #-}
type AroundInfo = (Identifier,Expression)
{-# LINE 78 "../src-derived/Transform.hs" #-}
{-# LINE 192 "Transform.ag" #-}
checkDuplicate :: (Identifier -> Identifier -> Error)
-> Identifier -> val -> Map Identifier val -> (Map Identifier val,Seq Error)
checkDuplicate dupError key val m
= case Map.lookupIndex key m of
Just ix -> let (key',_) = Map.elemAt ix m
in (m,Seq.singleton (dupError key key'))
Nothing -> (Map.insert key val m,Seq.empty)
checkDuplicates :: (Identifier -> Identifier -> Error)
-> [(Identifier, val)] -> Map Identifier val -> (Map Identifier val,Seq Error)
checkDuplicates dupError new m = foldErrors check m new
where check = uncurry (checkDuplicate dupError)
foldErrors f e xs = foldl g (e,Seq.empty) xs
where g ~(e,es) x = let (e',es') = f x e
in (e', es >< es')
checkForDuplicates :: (Identifier -> Identifier -> Error) -> [Identifier] -> [Error]
checkForDuplicates err [] = []
checkForDuplicates err (x:xs) = let (same,other) = List.partition (equalId x) xs
in map (err x) same ++ checkForDuplicates err other
equalId :: Identifier -> Identifier -> Bool
equalId x y = getName x == getName y
{-# LINE 109 "../src-derived/Transform.hs" #-}
{-# LINE 321 "Transform.ag" #-}
type RulesAndErrors = ([Rule], Seq Error)
type SigsAndErrors = ([TypeSig], Seq Error)
type InstsAndErrors = ([(Identifier, Type)], Seq Error)
type UniquesAndErrors = (Map Identifier Identifier, Seq Error)
type AugmentsAndErrors = (Map Identifier [Expression], Seq Error)
type AroundsAndErrors = (Map Identifier [Expression], Seq Error)
type AttrOverwrite = Map AttrName Bool
type AccumRuleCheck = (RulesAndErrors, AttrOverwrite)
type AccumDefiCheck = (Seq Error, AttrOverwrite, [AttrName], [AttrName])
checkRules :: Map NontermIdent (Attributes, Attributes) -> Map NontermIdent (Map ConstructorIdent FieldMap) ->
Map NontermIdent (Map ConstructorIdent [Identifier]) -> Map NontermIdent (Map ConstructorIdent [SigInfo]) ->
NontermIdent -> ConstructorIdent -> [RuleInfo] -> RulesAndErrors
checkRules attributes fields allinsts allsigs nt con rs
= let fieldmap :: FieldMap
fieldmap = (_LHS,NT nt undefined) : (_LOC,NT undefined undefined) : (_INST, NT undefined undefined) : (_FIRST, NT undefined undefined) : (_LAST, NT undefined undefined)
: Map.findWithDefault [] con (Map.findWithDefault Map.empty nt fields)
++ mapMaybe (\instNm -> lookup instNm sigs >>= \tp -> return (instNm, tp)) (Map.findWithDefault [] con (Map.findWithDefault Map.empty nt allinsts))
sigs = Map.findWithDefault [] con (Map.findWithDefault Map.empty nt allsigs)
hasAttrib f tp attr = Map.member attr (f (Map.findWithDefault (Map.empty,Map.empty) tp attributes))
checkRule :: RuleInfo -> AccumRuleCheck -> AccumRuleCheck
checkRule (mbNm, pat,exp,as,owrt,str) ((r1,e1),m1)
= let (e2,m2,u2,b2) = foldr (checkDefi owrt) (e1,m1,[],[]) as
in ( (Rule mbNm (pat u2) exp owrt str True : r1, e2), m2)
checkDefi :: Bool -> AttrName -> AccumDefiCheck -> AccumDefiCheck
checkDefi owrt fa@(field,attr) (e,m,u,bs)
= case lookup field fieldmap
of Just (NT tp _) ->
let tp' = maybe tp id (deforestedNt tp)
in if field == _LOC || field == _INST || field == _FIRST || field == _LAST
|| hasAttrib (if getName field==getName _LHS then snd else fst) tp' attr
then case Map.lookupIndex fa m of
Just ix -> let ((_,attr2),b) = Map.elemAt ix m
in if b && not (fa `elem` bs)
then ( e, Map.insert fa owrt m, fa:u, fa:bs)
else (((Seq.<|)) (DupRule nt con field attr2 attr) e, m, fa:u, bs)
Nothing -> ( e, Map.insert fa owrt m, u, fa:bs)
else (((Seq.<|)) (SuperfluousRule nt con field attr) e, m, fa:u, bs)
_ -> (((Seq.<|)) (UndefChild nt con field) e, m, fa:u, bs )
in fst (foldr checkRule (([],Seq.empty),Map.empty) rs)
checkRuleNames :: NontermIdent -> ConstructorIdent -> [RuleInfo] -> Seq Error
checkRuleNames nt con
= fst . foldr checkRule (Seq.empty, Set.empty)
where
checkRule (Just nm,_,_,_,_,_) (errs, nms)
| nm `Set.member` nms = (DupRuleName nt con nm Seq.<| errs, nms)
| otherwise = (errs, Set.insert nm nms)
checkRule (Nothing,_,_,_,_,_) inp = inp
checkSigs :: NontermIdent -> ConstructorIdent -> [SigInfo] -> SigsAndErrors
checkSigs nt con sis
= let checkSig (ide,typ) (sigs,errs)
= if ide `elem` map (\(TypeSig n t)-> n) sigs
then (sigs, ((Seq.<|)) (DupSig nt con ide) errs)
-- else if not (ide `elem` locattrdefs)
-- then (sigs, ((Seq.<|)) (SupSig nt con ide) errs)
else (TypeSig ide typ:sigs, errs)
in foldr checkSig ([],Seq.empty) sis
checkInsts :: Set NontermIdent -> Map NontermIdent (Map ConstructorIdent [SigInfo]) -> Map NontermIdent (Map ConstructorIdent [(Identifier, Type)]) -> NontermIdent -> ConstructorIdent -> [Identifier] -> InstsAndErrors
checkInsts allNts sigMap fieldMap nt con
= foldr (\inst (insts, errs) ->
maybe (insts, Seq.singleton (MissingInstSig nt con inst) >< errs)
(\info@(k, NT nm _) ->
case findInst k insts of
Just k' -> (insts, Seq.singleton (DupChild nt con k k') >< errs)
Nothing -> case nm `Set.member` allNts of
True -> (info : insts, errs)
False | take 2 (getName nm) == "T_" -> let nm' = Ident (drop 2 (getName nm)) (getPos nm)
in case nm' `Set.member` allNts of
True -> (info : insts, errs)
False -> (insts, Seq.singleton (UndefNont nm') >< errs)
| otherwise -> (insts, Seq.singleton (UndefNont nm) >< errs)
)
$ findSig inst
) ([], Seq.empty)
where
sigs = Map.findWithDefault [] con (Map.findWithDefault Map.empty nt sigMap)
findSig name
= do tp@(NT _ _) <- lookup name sigs
return (name, tp)
findInst _ [] = Nothing
findInst k ((k', _): r)
| k == k' = Just k'
| otherwise = findInst k r
checkUniques :: Map NontermIdent (Attributes, Attributes) -> NontermIdent -> ConstructorIdent -> [UniqueInfo] -> UniquesAndErrors
checkUniques allAttrs nt con uniques
= let checkUnique (ident,ref) (us,errs)
= if ident `Map.member` us
then (us, ((Seq.<|)) (DupUnique nt con ident) errs)
else if Map.member ref inhs && Map.member ref syns
then (Map.insert ident ref us, errs)
else (us, ((Seq.<|)) (MissingUnique nt ref) errs)
(inhs,syns) = Map.findWithDefault (Map.empty,Map.empty) nt allAttrs
in foldr checkUnique (Map.empty, Seq.empty) uniques
checkAugments :: Map NontermIdent (Attributes, Attributes) -> NontermIdent -> ConstructorIdent -> [AugmentInfo] -> AugmentsAndErrors
checkAugments allAttrs nt con augments
= let checkAugment (ident,expr) (as,errs)
= if ident `Map.member` as
then (Map.update (\vs -> Just (vs ++ [expr])) ident as, errs)
else if Map.member ident syns
then (Map.insert ident [expr] as, errs)
else (as, ((Seq.<|)) (MissingSyn nt ident) errs)
(inhs,syns) = Map.findWithDefault (Map.empty,Map.empty) nt allAttrs
in foldr checkAugment (Map.empty, Seq.empty) augments
checkArounds :: Map NontermIdent (Map ConstructorIdent [(Identifier, Type)]) -> NontermIdent -> ConstructorIdent -> [AroundInfo] -> AroundsAndErrors
checkArounds fieldMap nt con arounds
= let checkAround (ident,expr) (as,errs)
= if ident `Map.member` as
then (Map.update (\vs -> Just (vs ++ [expr])) ident as, errs)
else case lookup ident fields of
Just (NT _ _) -> (Map.insert ident [expr] as, errs)
_ -> (as, ((Seq.<|)) (UndefChild nt con ident) errs)
fields = Map.findWithDefault [] con (Map.findWithDefault Map.empty nt fieldMap)
in foldr checkAround (Map.empty, Seq.empty) arounds
unionunionplusplus = Map.unionWith (Map.unionWith (++))
{-# LINE 243 "../src-derived/Transform.hs" #-}
{-# LINE 455 "Transform.ag" #-}
mkUniqueRules :: Options -> Map NontermIdent (Map ConstructorIdent [(Identifier, Type)]) -> Map NontermIdent (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 272 "../src-derived/Transform.hs" #-}
{-# LINE 627 "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 297 "../src-derived/Transform.hs" #-}
{-# LINE 735 "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 306 "../src-derived/Transform.hs" #-}
{-# LINE 767 "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 315 "../src-derived/Transform.hs" #-}
{-# LINE 793 "Transform.ag" #-}
mergeParams :: ParamMap -> ParamMap -> ParamMap
mergeParams = Map.unionWith (++)
{-# LINE 321 "../src-derived/Transform.hs" #-}
{-# LINE 816 "Transform.ag" #-}
mergeCtx :: ContextMap -> ContextMap -> ContextMap
mergeCtx
= Map.unionWith nubconcat
where nubconcat a b = nub (a ++ b)
{-# LINE 329 "../src-derived/Transform.hs" #-}
{-# LINE 829 "Transform.ag" #-}
mergeDerivings m1 m2 = foldr (\(n,cs) m -> Map.insertWith Set.union n cs m) m2 (Map.toList m1)
{-# LINE 334 "../src-derived/Transform.hs" #-}
{-# LINE 840 "Transform.ag" #-}
merge x y = foldr f y (Map.toList x)
where f ~(k,v) m = Map.insertWith (Map.union) k v m
{-# LINE 340 "../src-derived/Transform.hs" #-}
{-# LINE 867 "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 350 "../src-derived/Transform.hs" #-}
{-# LINE 878 "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 356 "../src-derived/Transform.hs" #-}
{-# LINE 1008 "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 365 "../src-derived/Transform.hs" #-}
{-# LINE 1015 "Transform.ag" #-}
constructGrammar :: Set NontermIdent
-> ParamMap
-> DataTypes
-> Map NontermIdent (Attributes, Attributes)
-> Map NontermIdent (Map Identifier (String, String, String))
-> Derivings
-> Set NontermIdent
-> Map NontermIdent (Map ConstructorIdent [Rule])
-> Map NontermIdent (Map ConstructorIdent [TypeSig])
-> Map NontermIdent (Map ConstructorIdent [(Identifier, Type)])
-> TypeSyns
-> PragmaMap
-> AttrOrderMap
-> ContextMap
-> UniqueMap
-> Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))
-> Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))
-> Grammar
constructGrammar nts ntParams gram attrs uses derivings wrappers allrules tsigs allinsts tsyns pragmaMap orderMap contextMap uniqueMap augmentsMap aroundsMap =
let gr = [ (nt,Map.toList alts) | (nt,alts) <- Map.toList gram]
nonts = map nont gr
nont (nt,alts) = let (inh,syn) = Map.findWithDefault (Map.empty,Map.empty) nt attrs
rmap = Map.findWithDefault Map.empty nt allrules
tsmap = Map.findWithDefault Map.empty nt tsigs
instsmap = Map.findWithDefault Map.empty nt allinsts
params = Map.findWithDefault [] nt ntParams
alt (con,flds) =
let rules = maybe [] id (Map.lookup con rmap)
tsigs = maybe [] id (Map.lookup con tsmap)
insts = maybe [] id (Map.lookup con instsmap)
-- important: keep order of children
cldrn = map child (flds ++ filter (not . existsAsField) insts)
child (nm, tp) =
let tpI = if existsAsInst nm
then fromJust $ lookup nm insts
else tp
(inh,syn) = case tpI of
NT nt _ -> let nt' = maybe nt id (deforestedNt nt)
in Map.findWithDefault (Map.empty,Map.empty) nt' attrs
_ -> (Map.empty,Map.empty)
virt = if existsAsInst nm
then case lookup nm flds of
Just tp' -> Just (Just tp')
Nothing -> Just Nothing
else Nothing
in Child nm tpI inh syn virt
existsAsInst nm = maybe False (const True) (lookup nm insts)
existsAsField (nm,_) = maybe False (const True) (lookup nm flds)
in Production con cldrn rules tsigs
in Nonterminal nt params inh syn (map alt alts)
in Grammar tsyns uses derivings wrappers nonts pragmaMap orderMap ntParams contextMap uniqueMap augmentsMap aroundsMap
{-# LINE 422 "../src-derived/Transform.hs" #-}
{-# LINE 1071 "Transform.ag" #-}
mapUnionWithSetUnion = Map.unionWith Set.union
mapUnionWithPlusPlus = Map.unionWith (++)
{-# LINE 428 "../src-derived/Transform.hs" #-}
-- AG ----------------------------------------------------------
{-
visit 0:
inherited attribute:
options : Options
synthesized attributes:
blocks : Blocks
errors : Seq Error
moduleDecl : Maybe (String,String,String)
output : Grammar
pragmas : Options -> Options
alternatives:
alternative AG:
child elems : Elems
visit 0:
local allFields : _
local allConstrs : _
local allRules : _
local allSigs : _
local allInsts : _
local allUniques : _
local allAugments : _
local allArounds : _
local augmentSigs : _
local allRulesErrs : _
local allNamesErrs : _
local allSigsErrs : _
local allInstsErrs : _
local allUniquesErrs : _
local allAugmentErrs : _
local allAroundsErrs : _
local checkedRulesPre : _
local checkedSigs : _
local checkedInsts : _
local checkedUniques : _
local checkedAugments : _
local checkedArounds : _
local checkedRules : _
local errs1 : _
local errs2 : _
local errs3 : _
local errs4 : _
local errs5 : _
local errs6 : _
local errs7 : _
local errs8 : _
local errs9 : _
local errs10 : _
local allNonterminals : _
local allAttrDecls : _
-}
-- cata
sem_AG :: AG ->
T_AG
sem_AG (AG _elems ) =
(sem_AG_AG (sem_Elems _elems ) )
-- semantic domain
newtype T_AG = T_AG (Options ->
( Blocks,(Seq Error),(Maybe (String,String,String)),Grammar,(Options -> Options)))
data Inh_AG = Inh_AG {options_Inh_AG :: !(Options)}
data Syn_AG = Syn_AG {blocks_Syn_AG :: !(Blocks),errors_Syn_AG :: !((Seq Error)),moduleDecl_Syn_AG :: !((Maybe (String,String,String))),output_Syn_AG :: !(Grammar),pragmas_Syn_AG :: !((Options -> Options))}
wrap_AG :: T_AG ->
Inh_AG ->
Syn_AG
wrap_AG (T_AG sem ) (Inh_AG _lhsIoptions ) =
(let ( _lhsOblocks,_lhsOerrors,_lhsOmoduleDecl,_lhsOoutput,_lhsOpragmas) =
(sem _lhsIoptions )
in (Syn_AG _lhsOblocks _lhsOerrors _lhsOmoduleDecl _lhsOoutput _lhsOpragmas ))
sem_AG_AG :: T_Elems ->
T_AG
sem_AG_AG (T_Elems elems_ ) =
(T_AG (\ _lhsIoptions ->
(let _lhsOoutput :: Grammar
_lhsOerrors :: (Seq Error)
_elemsOallConstructors :: (Map NontermIdent (Set ConstructorIdent))
_elemsOdefSets :: (Map Identifier (Set NontermIdent,Set Identifier))
_elemsOdefinedSets :: DefinedSets
_elemsOattrDecls :: (Map NontermIdent (Attributes, Attributes))
_lhsOblocks :: Blocks
_lhsOmoduleDecl :: (Maybe (String,String,String))
_lhsOpragmas :: (Options -> Options)
_elemsOallAttrDecls :: (Map NontermIdent (Attributes, Attributes))
_elemsOallFields :: DataTypes
_elemsOallNonterminals :: (Set NontermIdent)
_elemsIattrDecls :: (Map NontermIdent (Attributes, Attributes))
_elemsIattrOrderCollect :: AttrOrderMap
_elemsIblocks :: Blocks
_elemsIcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])
_elemsIcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])
_elemsIcollectedConstructorsMap :: (Map NontermIdent (Set ConstructorIdent))
_elemsIcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)])
_elemsIcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ])
_elemsIcollectedNames :: (Set Identifier)
_elemsIcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)])
_elemsIcollectedSetNames :: (Set Identifier)
_elemsIcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ])
_elemsIcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])
_elemsIctxCollect :: ContextMap
_elemsIdefSets :: (Map Identifier (Set NontermIdent,Set Identifier))
_elemsIderivings :: Derivings
_elemsIerrors :: (Seq Error)
_elemsImoduleDecl :: (Maybe (String,String,String))
_elemsIparamsCollect :: ParamMap
_elemsIpragmas :: (Options -> Options)
_elemsIsemPragmasCollect :: PragmaMap
_elemsItypeSyns :: TypeSyns
_elemsIuseMap :: (Map NontermIdent (Map Identifier (String,String,String)))
_elemsIwrappers :: (Set NontermIdent)
-- "Transform.ag"(line 51, column 8)
_lhsOoutput =
({-# LINE 51 "Transform.ag" #-}
constructGrammar _allNonterminals
_elemsIparamsCollect
_allFields
_allAttrDecls
_elemsIuseMap
_elemsIderivings
(if wrappers _lhsIoptions then _allNonterminals else _elemsIwrappers)
_checkedRules
_checkedSigs
_checkedInsts
_elemsItypeSyns
_elemsIsemPragmasCollect
_elemsIattrOrderCollect
_elemsIctxCollect
_checkedUniques
_checkedAugments
_checkedArounds
{-# LINE 557 "Transform.hs" #-})
-- "Transform.ag"(line 243, column 10)
_allFields =
({-# LINE 243 "Transform.ag" #-}
let f (nt,con,fm) = Map.insertWith (Map.unionWith (++)) nt (Map.singleton con fm)
in foldr f (Map.empty) _elemsIcollectedFields
{-# LINE 563 "Transform.hs" #-})
-- "Transform.ag"(line 246, column 10)
_allConstrs =
({-# LINE 246 "Transform.ag" #-}
let f (nt,con,_) = Map.insertWith (++) nt [con]
in foldr f (Map.empty) _elemsIcollectedFields
{-# LINE 569 "Transform.hs" #-})
-- "Transform.ag"(line 249, column 10)
_allRules =
({-# LINE 249 "Transform.ag" #-}
let f (nt,con,r) = Map.insertWith (Map.unionWith (++)) nt (Map.singleton con [r])
in foldr f (Map.empty) _elemsIcollectedRules
{-# LINE 575 "Transform.hs" #-})
-- "Transform.ag"(line 252, column 10)
_allSigs =
({-# LINE 252 "Transform.ag" #-}
let f (nt,con,t) = Map.insertWith (Map.unionWith (++)) nt (Map.singleton con [t])
typeof nt r = Map.findWithDefault (Haskell "<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 584 "Transform.hs" #-})
-- "Transform.ag"(line 258, column 10)
_allInsts =
({-# LINE 258 "Transform.ag" #-}
let f (nt,con,is) = Map.insertWith (Map.unionWith (++)) nt (Map.singleton con is)
in foldr f (Map.empty) _elemsIcollectedInsts
{-# LINE 590 "Transform.hs" #-})
-- "Transform.ag"(line 261, column 10)
_allUniques =
({-# LINE 261 "Transform.ag" #-}
let f (nt,con,us) = Map.insertWith (Map.unionWith (++)) nt (Map.singleton con us)
in foldr f (Map.empty) _elemsIcollectedUniques
{-# LINE 596 "Transform.hs" #-})
-- "Transform.ag"(line 263, column 10)
_allAugments =
({-# LINE 263 "Transform.ag" #-}
let f (nt,con,as) = Map.insertWith (Map.unionWith (++)) nt (Map.singleton con as)
in foldr f Map.empty _elemsIcollectedAugments
{-# LINE 602 "Transform.hs" #-})
-- "Transform.ag"(line 265, column 10)
_allArounds =
({-# LINE 265 "Transform.ag" #-}
let f (nt,con,as) = Map.insertWith (Map.unionWith (++)) nt (Map.singleton con as)
in foldr f Map.empty _elemsIcollectedArounds
{-# LINE 608 "Transform.hs" #-})
-- "Transform.ag"(line 268, column 10)
_augmentSigs =
({-# LINE 268 "Transform.ag" #-}
let gen mp = []
in Map.map (Map.map gen) _allAugments
{-# LINE 614 "Transform.hs" #-})
-- "Transform.ag"(line 271, column 10)
_allRulesErrs =
({-# LINE 271 "Transform.ag" #-}
Map.mapWithKey (Map.mapWithKey . (checkRules _allAttrDecls _allFields _allInsts _allSigs )) _allRules
{-# LINE 619 "Transform.hs" #-})
-- "Transform.ag"(line 272, column 10)
_allNamesErrs =
({-# LINE 272 "Transform.ag" #-}
Map.mapWithKey (Map.mapWithKey . checkRuleNames) _allRules
{-# LINE 624 "Transform.hs" #-})
-- "Transform.ag"(line 273, column 10)
_allSigsErrs =
({-# LINE 273 "Transform.ag" #-}
Map.mapWithKey (Map.mapWithKey . (checkSigs )) _allSigs
{-# LINE 629 "Transform.hs" #-})
-- "Transform.ag"(line 274, column 10)
_allInstsErrs =
({-# LINE 274 "Transform.ag" #-}
Map.mapWithKey (Map.mapWithKey . (checkInsts _allNonterminals _allSigs _allFields )) _allInsts
{-# LINE 634 "Transform.hs" #-})
-- "Transform.ag"(line 275, column 10)
_allUniquesErrs =
({-# LINE 275 "Transform.ag" #-}
Map.mapWithKey (Map.mapWithKey . (checkUniques _allAttrDecls )) _allUniques
{-# LINE 639 "Transform.hs" #-})
-- "Transform.ag"(line 276, column 10)
_allAugmentErrs =
({-# LINE 276 "Transform.ag" #-}
Map.mapWithKey (Map.mapWithKey . (checkAugments _allAttrDecls )) _allAugments
{-# LINE 644 "Transform.hs" #-})
-- "Transform.ag"(line 277, column 10)
_allAroundsErrs =
({-# LINE 277 "Transform.ag" #-}
Map.mapWithKey (Map.mapWithKey . (checkArounds _allFields )) _allArounds
{-# LINE 649 "Transform.hs" #-})
-- "Transform.ag"(line 279, column 10)
_checkedRulesPre =
({-# LINE 279 "Transform.ag" #-}
Map.map (Map.map fst) _allRulesErrs
{-# LINE 654 "Transform.hs" #-})
-- "Transform.ag"(line 280, column 10)
_checkedSigs =
({-# LINE 280 "Transform.ag" #-}
Map.map (Map.map fst) _allSigsErrs `unionunionplusplus` _augmentSigs
{-# LINE 659 "Transform.hs" #-})
-- "Transform.ag"(line 281, column 10)
_checkedInsts =
({-# LINE 281 "Transform.ag" #-}
Map.map (Map.map fst) _allInstsErrs
{-# LINE 664 "Transform.hs" #-})
-- "Transform.ag"(line 282, column 10)
_checkedUniques =
({-# LINE 282 "Transform.ag" #-}
Map.map (Map.map fst) _allUniquesErrs
{-# LINE 669 "Transform.hs" #-})
-- "Transform.ag"(line 283, column 10)
_checkedAugments =
({-# LINE 283 "Transform.ag" #-}
Map.map (Map.map fst) _allAugmentErrs
{-# LINE 674 "Transform.hs" #-})
-- "Transform.ag"(line 284, column 10)
_checkedArounds =
({-# LINE 284 "Transform.ag" #-}
Map.map (Map.map fst) _allAroundsErrs
{-# LINE 679 "Transform.hs" #-})
-- "Transform.ag"(line 285, column 10)
_checkedRules =
({-# LINE 285 "Transform.ag" #-}
Map.unionWith (Map.unionWith (++)) _checkedRulesPre (Map.mapWithKey (Map.mapWithKey . (mkUniqueRules _lhsIoptions _allFields _checkedInsts _allAttrDecls )) _checkedUniques )
{-# LINE 684 "Transform.hs" #-})
-- "Transform.ag"(line 287, column 10)
_errs1 =
({-# LINE 287 "Transform.ag" #-}
let f = checkForDuplicates (DupSynonym)
in Seq.fromList . f . map fst $ _elemsItypeSyns
{-# LINE 690 "Transform.hs" #-})
-- "Transform.ag"(line 290, column 10)
_errs2 =
({-# LINE 290 "Transform.ag" #-}
let g nt (con,fm) = checkForDuplicates (DupChild nt con) (map fst fm)
f (nt,cfm) = concat . map (g nt) . Map.toList $ cfm
in Seq.fromList . concat . map f . Map.toList $ _allFields
{-# LINE 697 "Transform.hs" #-})
-- "Transform.ag"(line 294, column 10)
_errs3 =
({-# LINE 294 "Transform.ag" #-}
let f (nt,cons) = checkForDuplicates (DupAlt nt) cons
in Seq.empty
{-# LINE 703 "Transform.hs" #-})
-- "Transform.ag"(line 298, column 10)
_errs4 =
({-# LINE 298 "Transform.ag" #-}
let f m s = Map.fold ((><) . snd) s m
in Map.fold f Seq.empty _allRulesErrs
{-# LINE 709 "Transform.hs" #-})
-- "Transform.ag"(line 301, column 10)
_errs5 =
({-# LINE 301 "Transform.ag" #-}
let f m s = Map.fold ((><) . snd) s m
in Map.fold f Seq.empty _allSigsErrs
{-# LINE 715 "Transform.hs" #-})
-- "Transform.ag"(line 304, column 10)
_errs6 =
({-# LINE 304 "Transform.ag" #-}
let f m s = Map.fold ((><) . snd) s m
in Map.fold f Seq.empty _allInstsErrs
{-# LINE 721 "Transform.hs" #-})
-- "Transform.ag"(line 307, column 10)
_errs7 =
({-# LINE 307 "Transform.ag" #-}
let f m s = Map.fold ((><) . snd) s m
in Map.fold f Seq.empty _allUniquesErrs
{-# LINE 727 "Transform.hs" #-})
-- "Transform.ag"(line 310, column 10)
_errs8 =
({-# LINE 310 "Transform.ag" #-}
let f m s = Map.fold ((><) . snd) s m
in Map.fold f Seq.empty _allAugmentErrs
{-# LINE 733 "Transform.hs" #-})
-- "Transform.ag"(line 313, column 10)
_errs9 =
({-# LINE 313 "Transform.ag" #-}
let f m s = Map.fold ((><) . snd) s m
in Map.fold f Seq.empty _allAroundsErrs
{-# LINE 739 "Transform.hs" #-})
-- "Transform.ag"(line 316, column 10)
_errs10 =
({-# LINE 316 "Transform.ag" #-}
let f m s = Map.fold ((><)) s m
in Map.fold f Seq.empty _allNamesErrs
{-# LINE 745 "Transform.hs" #-})
-- "Transform.ag"(line 319, column 10)
_lhsOerrors =
({-# LINE 319 "Transform.ag" #-}
_elemsIerrors >< _errs1 >< _errs2 >< _errs3 >< _errs4 >< _errs5 >< _errs6 >< _errs7 >< _errs8 >< _errs9 >< _errs10
{-# LINE 750 "Transform.hs" #-})
-- "Transform.ag"(line 500, column 10)
_allNonterminals =
({-# LINE 500 "Transform.ag" #-}
_elemsIcollectedNames `Set.difference` _elemsIcollectedSetNames
{-# LINE 755 "Transform.hs" #-})
-- "Transform.ag"(line 520, column 8)
_elemsOallConstructors =
({-# LINE 520 "Transform.ag" #-}
_elemsIcollectedConstructorsMap
{-# LINE 760 "Transform.hs" #-})
-- "Transform.ag"(line 593, column 8)
_elemsOdefSets =
({-# LINE 593 "Transform.ag" #-}
Map.fromList (map (\x->(x,(Set.singleton x, Set.empty))) (Set.toList _allNonterminals ))
{-# LINE 765 "Transform.hs" #-})
-- "Transform.ag"(line 594, column 8)
_elemsOdefinedSets =
({-# LINE 594 "Transform.ag" #-}
Map.map fst _elemsIdefSets
{-# LINE 770 "Transform.hs" #-})
-- "Transform.ag"(line 846, column 8)
_elemsOattrDecls =
({-# LINE 846 "Transform.ag" #-}
Map.empty
{-# LINE 775 "Transform.hs" #-})
-- "Transform.ag"(line 885, column 9)
_allAttrDecls =
({-# LINE 885 "Transform.ag" #-}
if withSelf _lhsIoptions
then foldr addSelf _elemsIattrDecls (Set.toList _allNonterminals )
else _elemsIattrDecls
{-# LINE 782 "Transform.hs" #-})
-- use rule "Transform.ag"(line 44, column 19)
_lhsOblocks =
({-# LINE 44 "Transform.ag" #-}
_elemsIblocks
{-# LINE 787 "Transform.hs" #-})
-- use rule "Transform.ag"(line 998, column 37)
_lhsOmoduleDecl =
({-# LINE 998 "Transform.ag" #-}
_elemsImoduleDecl
{-# LINE 792 "Transform.hs" #-})
-- use rule "Transform.ag"(line 675, column 34)
_lhsOpragmas =
({-# LINE 675 "Transform.ag" #-}
_elemsIpragmas
{-# LINE 797 "Transform.hs" #-})
-- copy rule (from local)
_elemsOallAttrDecls =
({-# LINE 748 "Transform.ag" #-}
_allAttrDecls
{-# LINE 802 "Transform.hs" #-})
-- copy rule (from local)
_elemsOallFields =
({-# LINE 126 "Transform.ag" #-}
_allFields
{-# LINE 807 "Transform.hs" #-})
-- copy rule (from local)
_elemsOallNonterminals =
({-# LINE 86 "Transform.ag" #-}
_allNonterminals
{-# LINE 812 "Transform.hs" #-})
( _elemsIattrDecls,_elemsIattrOrderCollect,_elemsIblocks,_elemsIcollectedArounds,_elemsIcollectedAugments,_elemsIcollectedConstructorsMap,_elemsIcollectedFields,_elemsIcollectedInsts,_elemsIcollectedNames,_elemsIcollectedRules,_elemsIcollectedSetNames,_elemsIcollectedSigs,_elemsIcollectedUniques,_elemsIctxCollect,_elemsIdefSets,_elemsIderivings,_elemsIerrors,_elemsImoduleDecl,_elemsIparamsCollect,_elemsIpragmas,_elemsIsemPragmasCollect,_elemsItypeSyns,_elemsIuseMap,_elemsIwrappers) =
(elems_ _elemsOallAttrDecls _elemsOallConstructors _elemsOallFields _elemsOallNonterminals _elemsOattrDecls _elemsOdefSets _elemsOdefinedSets )
in ( _lhsOblocks,_lhsOerrors,_lhsOmoduleDecl,_lhsOoutput,_lhsOpragmas))) )
-- Alt ---------------------------------------------------------
{-
visit 0:
inherited attributes:
allConstructors : Map NontermIdent (Set ConstructorIdent)
allNonterminals : Set NontermIdent
nts : Set NontermIdent
synthesized attributes:
collectedConstructorNames : Set ConstructorIdent
collectedFields : [(NontermIdent, ConstructorIdent, FieldMap)]
alternatives:
alternative Alt:
child pos : {Pos}
child names : ConstructorSet
child fields : {Fields}
-}
-- cata
sem_Alt :: Alt ->
T_Alt
sem_Alt (Alt _pos _names _fields ) =
(sem_Alt_Alt _pos (sem_ConstructorSet _names ) _fields )
-- semantic domain
newtype T_Alt = T_Alt ((Map NontermIdent (Set ConstructorIdent)) ->
(Set NontermIdent) ->
(Set NontermIdent) ->
( (Set ConstructorIdent),([(NontermIdent, ConstructorIdent, FieldMap)])))
data Inh_Alt = Inh_Alt {allConstructors_Inh_Alt :: !((Map NontermIdent (Set ConstructorIdent))),allNonterminals_Inh_Alt :: !((Set NontermIdent)),nts_Inh_Alt :: !((Set NontermIdent))}
data Syn_Alt = Syn_Alt {collectedConstructorNames_Syn_Alt :: !((Set ConstructorIdent)),collectedFields_Syn_Alt :: !(([(NontermIdent, ConstructorIdent, FieldMap)]))}
wrap_Alt :: T_Alt ->
Inh_Alt ->
Syn_Alt
wrap_Alt (T_Alt sem ) (Inh_Alt _lhsIallConstructors _lhsIallNonterminals _lhsInts ) =
(let ( _lhsOcollectedConstructorNames,_lhsOcollectedFields) =
(sem _lhsIallConstructors _lhsIallNonterminals _lhsInts )
in (Syn_Alt _lhsOcollectedConstructorNames _lhsOcollectedFields ))
sem_Alt_Alt :: Pos ->
T_ConstructorSet ->
Fields ->
T_Alt
sem_Alt_Alt pos_ (T_ConstructorSet names_ ) fields_ =
(T_Alt (\ _lhsIallConstructors
_lhsIallNonterminals
_lhsInts ->
(let _lhsOcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)])
_lhsOcollectedConstructorNames :: (Set ConstructorIdent)
_namesIcollectedConstructorNames :: (Set ConstructorIdent)
_namesIconstructors :: ((Set ConstructorIdent->Set ConstructorIdent))
_namesIerrors :: (Seq Error)
-- "Transform.ag"(line 228, column 10)
_lhsOcollectedFields =
({-# LINE 228 "Transform.ag" #-}
let fieldTable =
[ (attr, makeType _lhsIallNonterminals tp)
| (attr, tp) <- fields_
]
in [ (nt, con, fieldTable)
| nt <- Set.toList _lhsInts
, con <- Set.toList (_namesIconstructors (Map.findWithDefault Set.empty nt _lhsIallConstructors))
]
{-# LINE 875 "Transform.hs" #-})
-- use rule "Transform.ag"(line 91, column 62)
_lhsOcollectedConstructorNames =
({-# LINE 91 "Transform.ag" #-}
_namesIcollectedConstructorNames
{-# LINE 880 "Transform.hs" #-})
( _namesIcollectedConstructorNames,_namesIconstructors,_namesIerrors) =
(names_ )
in ( _lhsOcollectedConstructorNames,_lhsOcollectedFields))) )
-- Alts --------------------------------------------------------
{-
visit 0:
inherited attributes:
allConstructors : Map NontermIdent (Set ConstructorIdent)
allNonterminals : Set NontermIdent
nts : Set NontermIdent
synthesized attributes:
collectedConstructorNames : Set ConstructorIdent
collectedFields : [(NontermIdent, ConstructorIdent, FieldMap)]
alternatives:
alternative Cons:
child hd : Alt
child tl : Alts
alternative Nil:
-}
-- cata
sem_Alts :: Alts ->
T_Alts
sem_Alts list =
(Prelude.foldr sem_Alts_Cons sem_Alts_Nil (Prelude.map sem_Alt list) )
-- semantic domain
newtype T_Alts = T_Alts ((Map NontermIdent (Set ConstructorIdent)) ->
(Set NontermIdent) ->
(Set NontermIdent) ->
( (Set ConstructorIdent),([(NontermIdent, ConstructorIdent, FieldMap)])))
data Inh_Alts = Inh_Alts {allConstructors_Inh_Alts :: !((Map NontermIdent (Set ConstructorIdent))),allNonterminals_Inh_Alts :: !((Set NontermIdent)),nts_Inh_Alts :: !((Set NontermIdent))}
data Syn_Alts = Syn_Alts {collectedConstructorNames_Syn_Alts :: !((Set ConstructorIdent)),collectedFields_Syn_Alts :: !(([(NontermIdent, ConstructorIdent, FieldMap)]))}
wrap_Alts :: T_Alts ->
Inh_Alts ->
Syn_Alts
wrap_Alts (T_Alts sem ) (Inh_Alts _lhsIallConstructors _lhsIallNonterminals _lhsInts ) =
(let ( _lhsOcollectedConstructorNames,_lhsOcollectedFields) =
(sem _lhsIallConstructors _lhsIallNonterminals _lhsInts )
in (Syn_Alts _lhsOcollectedConstructorNames _lhsOcollectedFields ))
sem_Alts_Cons :: T_Alt ->
T_Alts ->
T_Alts
sem_Alts_Cons (T_Alt hd_ ) (T_Alts tl_ ) =
(T_Alts (\ _lhsIallConstructors
_lhsIallNonterminals
_lhsInts ->
(let _lhsOcollectedConstructorNames :: (Set ConstructorIdent)
_lhsOcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)])
_hdOallConstructors :: (Map NontermIdent (Set ConstructorIdent))
_hdOallNonterminals :: (Set NontermIdent)
_hdOnts :: (Set NontermIdent)
_tlOallConstructors :: (Map NontermIdent (Set ConstructorIdent))
_tlOallNonterminals :: (Set NontermIdent)
_tlOnts :: (Set NontermIdent)
_hdIcollectedConstructorNames :: (Set ConstructorIdent)
_hdIcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)])
_tlIcollectedConstructorNames :: (Set ConstructorIdent)
_tlIcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)])
-- use rule "Transform.ag"(line 91, column 62)
_lhsOcollectedConstructorNames =
({-# LINE 91 "Transform.ag" #-}
_hdIcollectedConstructorNames `Set.union` _tlIcollectedConstructorNames
{-# LINE 942 "Transform.hs" #-})
-- use rule "Transform.ag"(line 123, column 28)
_lhsOcollectedFields =
({-# LINE 123 "Transform.ag" #-}
_hdIcollectedFields ++ _tlIcollectedFields
{-# LINE 947 "Transform.hs" #-})
-- copy rule (down)
_hdOallConstructors =
({-# LINE 94 "Transform.ag" #-}
_lhsIallConstructors
{-# LINE 952 "Transform.hs" #-})
-- copy rule (down)
_hdOallNonterminals =
({-# LINE 86 "Transform.ag" #-}
_lhsIallNonterminals
{-# LINE 957 "Transform.hs" #-})
-- copy rule (down)
_hdOnts =
({-# LINE 163 "Transform.ag" #-}
_lhsInts
{-# LINE 962 "Transform.hs" #-})
-- copy rule (down)
_tlOallConstructors =
({-# LINE 94 "Transform.ag" #-}
_lhsIallConstructors
{-# LINE 967 "Transform.hs" #-})
-- copy rule (down)
_tlOallNonterminals =
({-# LINE 86 "Transform.ag" #-}
_lhsIallNonterminals
{-# LINE 972 "Transform.hs" #-})
-- copy rule (down)
_tlOnts =
({-# LINE 163 "Transform.ag" #-}
_lhsInts
{-# LINE 977 "Transform.hs" #-})
( _hdIcollectedConstructorNames,_hdIcollectedFields) =
(hd_ _hdOallConstructors _hdOallNonterminals _hdOnts )
( _tlIcollectedConstructorNames,_tlIcollectedFields) =
(tl_ _tlOallConstructors _tlOallNonterminals _tlOnts )
in ( _lhsOcollectedConstructorNames,_lhsOcollectedFields))) )
sem_Alts_Nil :: T_Alts
sem_Alts_Nil =
(T_Alts (\ _lhsIallConstructors
_lhsIallNonterminals
_lhsInts ->
(let _lhsOcollectedConstructorNames :: (Set ConstructorIdent)
_lhsOcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)])
-- use rule "Transform.ag"(line 91, column 62)
_lhsOcollectedConstructorNames =
({-# LINE 91 "Transform.ag" #-}
Set.empty
{-# LINE 994 "Transform.hs" #-})
-- use rule "Transform.ag"(line 123, column 28)
_lhsOcollectedFields =
({-# LINE 123 "Transform.ag" #-}
[]
{-# LINE 999 "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 854, column 15)
__tup1 =
({-# LINE 854 "Transform.ag" #-}
checkAttrs _lhsIallFields (Set.toList _lhsInts) _inherited _synthesized _lhsIattrDecls
{-# LINE 1065 "Transform.hs" #-})
-- "Transform.ag"(line 854, column 15)
(_attrDecls,_) =
({-# LINE 854 "Transform.ag" #-}
__tup1
{-# LINE 1070 "Transform.hs" #-})
-- "Transform.ag"(line 854, column 15)
(_,_errors) =
({-# LINE 854 "Transform.ag" #-}
__tup1
{-# LINE 1075 "Transform.hs" #-})
-- "Transform.ag"(line 856, column 15)
__tup2 =
({-# LINE 856 "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 1087 "Transform.hs" #-})
-- "Transform.ag"(line 856, column 15)
(_inherited,_,_) =
({-# LINE 856 "Transform.ag" #-}
__tup2
{-# LINE 1092 "Transform.hs" #-})
-- "Transform.ag"(line 856, column 15)
(_,_synthesized,_) =
({-# LINE 856 "Transform.ag" #-}
__tup2
{-# LINE 1097 "Transform.hs" #-})
-- "Transform.ag"(line 856, column 15)
(_,_,_useMap) =
({-# LINE 856 "Transform.ag" #-}
__tup2
{-# LINE 1102 "Transform.hs" #-})
-- "Transform.ag"(line 864, column 11)
_lhsOuseMap =
({-# LINE 864 "Transform.ag" #-}
Map.fromList (zip (Set.toList _lhsInts) (repeat _useMap))
{-# LINE 1107 "Transform.hs" #-})
-- use rule "Transform.ag"(line 42, column 19)
_lhsOerrors =
({-# LINE 42 "Transform.ag" #-}
_errors
{-# LINE 1112 "Transform.hs" #-})
-- copy rule (from local)
_lhsOattrDecls =
({-# LINE 134 "Transform.ag" #-}
_attrDecls
{-# LINE 1117 "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 660, column 17)
_lhsOconstructors =
({-# LINE 660 "Transform.ag" #-}
\ds -> ds
{-# LINE 1168 "Transform.hs" #-})
-- use rule "Transform.ag"(line 91, column 62)
_lhsOcollectedConstructorNames =
({-# LINE 91 "Transform.ag" #-}
Set.empty
{-# LINE 1173 "Transform.hs" #-})
-- use rule "Transform.ag"(line 42, column 19)
_lhsOerrors =
({-# LINE 42 "Transform.ag" #-}
Seq.empty
{-# LINE 1178 "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 659, column 17)
_lhsOconstructors =
({-# LINE 659 "Transform.ag" #-}
\ds -> _set1Iconstructors ds `Set.difference` _set2Iconstructors ds
{-# LINE 1197 "Transform.hs" #-})
-- use rule "Transform.ag"(line 91, column 62)
_lhsOcollectedConstructorNames =
({-# LINE 91 "Transform.ag" #-}
_set1IcollectedConstructorNames `Set.union` _set2IcollectedConstructorNames
{-# LINE 1202 "Transform.hs" #-})
-- use rule "Transform.ag"(line 42, column 19)
_lhsOerrors =
({-# LINE 42 "Transform.ag" #-}
_set1Ierrors Seq.>< _set2Ierrors
{-# LINE 1207 "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 508, column 11)
_lhsOcollectedConstructorNames =
({-# LINE 508 "Transform.ag" #-}
Set.singleton name_
{-# LINE 1223 "Transform.hs" #-})
-- "Transform.ag"(line 657, column 17)
_lhsOconstructors =
({-# LINE 657 "Transform.ag" #-}
\ds -> Set.singleton name_
{-# LINE 1228 "Transform.hs" #-})
-- use rule "Transform.ag"(line 42, column 19)
_lhsOerrors =
({-# LINE 42 "Transform.ag" #-}
Seq.empty
{-# LINE 1233 "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 658, column 17)
_lhsOconstructors =
({-# LINE 658 "Transform.ag" #-}
\ds -> _set1Iconstructors ds `Set.union` _set2Iconstructors ds
{-# LINE 1252 "Transform.hs" #-})
-- use rule "Transform.ag"(line 91, column 62)
_lhsOcollectedConstructorNames =
({-# LINE 91 "Transform.ag" #-}
_set1IcollectedConstructorNames `Set.union` _set2IcollectedConstructorNames
{-# LINE 1257 "Transform.hs" #-})
-- use rule "Transform.ag"(line 42, column 19)
_lhsOerrors =
({-# LINE 42 "Transform.ag" #-}
_set1Ierrors Seq.>< _set2Ierrors
{-# LINE 1262 "Transform.hs" #-})
( _set1IcollectedConstructorNames,_set1Iconstructors,_set1Ierrors) =
(set1_ )
( _set2IcollectedConstructorNames,_set2Iconstructors,_set2Ierrors) =
(set2_ )
in ( _lhsOcollectedConstructorNames,_lhsOconstructors,_lhsOerrors)) )
-- Elem --------------------------------------------------------
{-
visit 0:
inherited attributes:
allAttrDecls : Map NontermIdent (Attributes, Attributes)
allConstructors : Map NontermIdent (Set ConstructorIdent)
allFields : DataTypes
allNonterminals : Set NontermIdent
definedSets : DefinedSets
chained attributes:
attrDecls : Map NontermIdent (Attributes, Attributes)
defSets : Map Identifier (Set NontermIdent,Set Identifier)
synthesized attributes:
attrOrderCollect : AttrOrderMap
blocks : Blocks
collectedArounds : [ (NontermIdent, ConstructorIdent, [AroundInfo]) ]
collectedAugments : [ (NontermIdent, ConstructorIdent, [AugmentInfo]) ]
collectedConstructorsMap : Map NontermIdent (Set ConstructorIdent)
collectedFields : [(NontermIdent, ConstructorIdent, FieldMap)]
collectedInsts : [ (NontermIdent, ConstructorIdent, [Identifier]) ]
collectedNames : Set Identifier
collectedRules : [ (NontermIdent, ConstructorIdent, RuleInfo)]
collectedSetNames : Set Identifier
collectedSigs : [ (NontermIdent, ConstructorIdent, SigInfo) ]
collectedUniques : [ (NontermIdent, ConstructorIdent, [UniqueInfo]) ]
ctxCollect : ContextMap
derivings : Derivings
errors : Seq Error
moduleDecl : Maybe (String,String,String)
paramsCollect : ParamMap
pragmas : Options -> Options
semPragmasCollect : PragmaMap
typeSyns : TypeSyns
useMap : Map NontermIdent (Map Identifier (String,String,String))
wrappers : Set NontermIdent
alternatives:
alternative Attr:
child pos : {Pos}
child ctx : {ClassContext}
child names : NontSet
child attrs : Attrs
alternative Data:
child pos : {Pos}
child ctx : {ClassContext}
child names : NontSet
child params : {[Identifier]}
child attrs : Attrs
child alts : Alts
child ext : {Bool}
alternative Deriving:
child pos : {Pos}
child set : NontSet
child classes : {[NontermIdent]}
alternative Module:
child pos : {Pos}
child name : {String}
child exports : {String}
child imports : {String}
alternative Pragma:
child pos : {Pos}
child names : {[NontermIdent]}
alternative Sem:
child pos : {Pos}
child ctx : {ClassContext}
child names : NontSet
child attrs : Attrs
child alts : SemAlts
alternative Set:
child pos : {Pos}
child name : {NontermIdent}
child set : NontSet
visit 0:
local _tup3 : _
local defSets2 : _
local errs : _
alternative Txt:
child pos : {Pos}
child name : {Identifier}
child mbNt : {Maybe NontermIdent}
child lines : {[String]}
visit 0:
local blockInfo : _
local blockValue : _
alternative Type:
child pos : {Pos}
child ctx : {ClassContext}
child name : {NontermIdent}
child params : {[Identifier]}
child type : {ComplexType}
visit 0:
local expanded : _
local argType : _
alternative Wrapper:
child pos : {Pos}
child set : NontSet
-}
-- cata
sem_Elem :: Elem ->
T_Elem
sem_Elem (Attr _pos _ctx _names _attrs ) =
(sem_Elem_Attr _pos _ctx (sem_NontSet _names ) (sem_Attrs _attrs ) )
sem_Elem (Data _pos _ctx _names _params _attrs _alts _ext ) =
(sem_Elem_Data _pos _ctx (sem_NontSet _names ) _params (sem_Attrs _attrs ) (sem_Alts _alts ) _ext )
sem_Elem (Deriving _pos _set _classes ) =
(sem_Elem_Deriving _pos (sem_NontSet _set ) _classes )
sem_Elem (Module _pos _name _exports _imports ) =
(sem_Elem_Module _pos _name _exports _imports )
sem_Elem (Pragma _pos _names ) =
(sem_Elem_Pragma _pos _names )
sem_Elem (Sem _pos _ctx _names _attrs _alts ) =
(sem_Elem_Sem _pos _ctx (sem_NontSet _names ) (sem_Attrs _attrs ) (sem_SemAlts _alts ) )
sem_Elem (Set _pos _name _set ) =
(sem_Elem_Set _pos _name (sem_NontSet _set ) )
sem_Elem (Txt _pos _name _mbNt _lines ) =
(sem_Elem_Txt _pos _name _mbNt _lines )
sem_Elem (Type _pos _ctx _name _params _type ) =
(sem_Elem_Type _pos _ctx _name _params _type )
sem_Elem (Wrapper _pos _set ) =
(sem_Elem_Wrapper _pos (sem_NontSet _set ) )
-- semantic domain
newtype T_Elem = T_Elem ((Map NontermIdent (Attributes, Attributes)) ->
(Map NontermIdent (Set ConstructorIdent)) ->
DataTypes ->
(Set NontermIdent) ->
(Map NontermIdent (Attributes, Attributes)) ->
(Map Identifier (Set NontermIdent,Set Identifier)) ->
DefinedSets ->
( (Map NontermIdent (Attributes, Attributes)),AttrOrderMap,Blocks,([ (NontermIdent, ConstructorIdent, [AroundInfo]) ]),([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ]),(Map NontermIdent (Set ConstructorIdent)),([(NontermIdent, ConstructorIdent, FieldMap)]),([ (NontermIdent, ConstructorIdent, [Identifier]) ]),(Set Identifier),([ (NontermIdent, ConstructorIdent, RuleInfo)]),(Set Identifier),([ (NontermIdent, ConstructorIdent, SigInfo) ]),([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ]),ContextMap,(Map Identifier (Set NontermIdent,Set Identifier)),Derivings,(Seq Error),(Maybe (String,String,String)),ParamMap,(Options -> Options),PragmaMap,TypeSyns,(Map NontermIdent (Map Identifier (String,String,String))),(Set NontermIdent)))
data Inh_Elem = Inh_Elem {allAttrDecls_Inh_Elem :: !((Map NontermIdent (Attributes, Attributes))),allConstructors_Inh_Elem :: !((Map NontermIdent (Set ConstructorIdent))),allFields_Inh_Elem :: !(DataTypes),allNonterminals_Inh_Elem :: !((Set NontermIdent)),attrDecls_Inh_Elem :: !((Map NontermIdent (Attributes, Attributes))),defSets_Inh_Elem :: !((Map Identifier (Set NontermIdent,Set Identifier))),definedSets_Inh_Elem :: !(DefinedSets)}
data Syn_Elem = Syn_Elem {attrDecls_Syn_Elem :: !((Map NontermIdent (Attributes, Attributes))),attrOrderCollect_Syn_Elem :: !(AttrOrderMap),blocks_Syn_Elem :: !(Blocks),collectedArounds_Syn_Elem :: !(([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])),collectedAugments_Syn_Elem :: !(([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])),collectedConstructorsMap_Syn_Elem :: !((Map NontermIdent (Set ConstructorIdent))),collectedFields_Syn_Elem :: !(([(NontermIdent, ConstructorIdent, FieldMap)])),collectedInsts_Syn_Elem :: !(([ (NontermIdent, ConstructorIdent, [Identifier]) ])),collectedNames_Syn_Elem :: !((Set Identifier)),collectedRules_Syn_Elem :: !(([ (NontermIdent, ConstructorIdent, RuleInfo)])),collectedSetNames_Syn_Elem :: !((Set Identifier)),collectedSigs_Syn_Elem :: !(([ (NontermIdent, ConstructorIdent, SigInfo) ])),collectedUniques_Syn_Elem :: !(([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])),ctxCollect_Syn_Elem :: !(ContextMap),defSets_Syn_Elem :: !((Map Identifier (Set NontermIdent,Set Identifier))),derivings_Syn_Elem :: !(Derivings),errors_Syn_Elem :: !((Seq Error)),moduleDecl_Syn_Elem :: !((Maybe (String,String,String))),paramsCollect_Syn_Elem :: !(ParamMap),pragmas_Syn_Elem :: !((Options -> Options)),semPragmasCollect_Syn_Elem :: !(PragmaMap),typeSyns_Syn_Elem :: !(TypeSyns),useMap_Syn_Elem :: !((Map NontermIdent (Map Identifier (String,String,String)))),wrappers_Syn_Elem :: !((Set NontermIdent))}
wrap_Elem :: T_Elem ->
Inh_Elem ->
Syn_Elem
wrap_Elem (T_Elem sem ) (Inh_Elem _lhsIallAttrDecls _lhsIallConstructors _lhsIallFields _lhsIallNonterminals _lhsIattrDecls _lhsIdefSets _lhsIdefinedSets ) =
(let ( _lhsOattrDecls,_lhsOattrOrderCollect,_lhsOblocks,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedConstructorsMap,_lhsOcollectedFields,_lhsOcollectedInsts,_lhsOcollectedNames,_lhsOcollectedRules,_lhsOcollectedSetNames,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOctxCollect,_lhsOdefSets,_lhsOderivings,_lhsOerrors,_lhsOmoduleDecl,_lhsOparamsCollect,_lhsOpragmas,_lhsOsemPragmasCollect,_lhsOtypeSyns,_lhsOuseMap,_lhsOwrappers) =
(sem _lhsIallAttrDecls _lhsIallConstructors _lhsIallFields _lhsIallNonterminals _lhsIattrDecls _lhsIdefSets _lhsIdefinedSets )
in (Syn_Elem _lhsOattrDecls _lhsOattrOrderCollect _lhsOblocks _lhsOcollectedArounds _lhsOcollectedAugments _lhsOcollectedConstructorsMap _lhsOcollectedFields _lhsOcollectedInsts _lhsOcollectedNames _lhsOcollectedRules _lhsOcollectedSetNames _lhsOcollectedSigs _lhsOcollectedUniques _lhsOctxCollect _lhsOdefSets _lhsOderivings _lhsOerrors _lhsOmoduleDecl _lhsOparamsCollect _lhsOpragmas _lhsOsemPragmasCollect _lhsOtypeSyns _lhsOuseMap _lhsOwrappers ))
sem_Elem_Attr :: Pos ->
ClassContext ->
T_NontSet ->
T_Attrs ->
T_Elem
sem_Elem_Attr pos_ ctx_ (T_NontSet names_ ) (T_Attrs attrs_ ) =
(T_Elem (\ _lhsIallAttrDecls
_lhsIallConstructors
_lhsIallFields
_lhsIallNonterminals
_lhsIattrDecls
_lhsIdefSets
_lhsIdefinedSets ->
(let _lhsOctxCollect :: ContextMap
_attrsOnts :: (Set NontermIdent)
_lhsOattrOrderCollect :: AttrOrderMap
_lhsOblocks :: Blocks
_lhsOcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])
_lhsOcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])
_lhsOcollectedConstructorsMap :: (Map NontermIdent (Set ConstructorIdent))
_lhsOcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)])
_lhsOcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ])
_lhsOcollectedNames :: (Set Identifier)
_lhsOcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)])
_lhsOcollectedSetNames :: (Set Identifier)
_lhsOcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ])
_lhsOcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])
_lhsOderivings :: Derivings
_lhsOerrors :: (Seq Error)
_lhsOmoduleDecl :: (Maybe (String,String,String))
_lhsOparamsCollect :: ParamMap
_lhsOpragmas :: (Options -> Options)
_lhsOsemPragmasCollect :: PragmaMap
_lhsOtypeSyns :: TypeSyns
_lhsOuseMap :: (Map NontermIdent (Map Identifier (String,String,String)))
_lhsOwrappers :: (Set NontermIdent)
_lhsOattrDecls :: (Map NontermIdent (Attributes, Attributes))
_lhsOdefSets :: (Map Identifier (Set NontermIdent,Set Identifier))
_namesOallFields :: DataTypes
_namesOallNonterminals :: (Set NontermIdent)
_namesOdefinedSets :: DefinedSets
_attrsOallFields :: DataTypes
_attrsOallNonterminals :: (Set NontermIdent)
_attrsOattrDecls :: (Map NontermIdent (Attributes, Attributes))
_namesIcollectedNames :: (Set Identifier)
_namesIerrors :: (Seq Error)
_namesInontSet :: (Set NontermIdent)
_attrsIattrDecls :: (Map NontermIdent (Attributes, Attributes))
_attrsIerrors :: (Seq Error)
_attrsIuseMap :: (Map NontermIdent (Map Identifier (String,String,String)))
-- "Transform.ag"(line 806, column 7)
_lhsOctxCollect =
({-# LINE 806 "Transform.ag" #-}
if null ctx_
then Map.empty
else Map.fromList [(nt, ctx_) | nt <- Set.toList _namesInontSet]
{-# LINE 1461 "Transform.hs" #-})
-- "Transform.ag"(line 850, column 10)
_attrsOnts =
({-# LINE 850 "Transform.ag" #-}
_namesInontSet
{-# LINE 1466 "Transform.hs" #-})
-- use rule "Transform.ag"(line 747, column 55)
_lhsOattrOrderCollect =
({-# LINE 747 "Transform.ag" #-}
Map.empty
{-# LINE 1471 "Transform.hs" #-})
-- use rule "Transform.ag"(line 44, column 19)
_lhsOblocks =
({-# LINE 44 "Transform.ag" #-}
Map.empty
{-# LINE 1476 "Transform.hs" #-})
-- use rule "Transform.ag"(line 153, column 32)
_lhsOcollectedArounds =
({-# LINE 153 "Transform.ag" #-}
[]
{-# LINE 1481 "Transform.hs" #-})
-- use rule "Transform.ag"(line 152, column 32)
_lhsOcollectedAugments =
({-# LINE 152 "Transform.ag" #-}
[]
{-# LINE 1486 "Transform.hs" #-})
-- use rule "Transform.ag"(line 92, column 48)
_lhsOcollectedConstructorsMap =
({-# LINE 92 "Transform.ag" #-}
Map.empty
{-# LINE 1491 "Transform.hs" #-})
-- use rule "Transform.ag"(line 123, column 28)
_lhsOcollectedFields =
({-# LINE 123 "Transform.ag" #-}
[]
{-# LINE 1496 "Transform.hs" #-})
-- use rule "Transform.ag"(line 150, column 32)
_lhsOcollectedInsts =
({-# LINE 150 "Transform.ag" #-}
[]
{-# LINE 1501 "Transform.hs" #-})
-- use rule "Transform.ag"(line 84, column 50)
_lhsOcollectedNames =
({-# LINE 84 "Transform.ag" #-}
_namesIcollectedNames
{-# LINE 1506 "Transform.hs" #-})
-- use rule "Transform.ag"(line 148, column 32)
_lhsOcollectedRules =
({-# LINE 148 "Transform.ag" #-}
[]
{-# LINE 1511 "Transform.hs" #-})
-- use rule "Transform.ag"(line 83, column 50)
_lhsOcollectedSetNames =
({-# LINE 83 "Transform.ag" #-}
Set.empty
{-# LINE 1516 "Transform.hs" #-})
-- use rule "Transform.ag"(line 149, column 32)
_lhsOcollectedSigs =
({-# LINE 149 "Transform.ag" #-}
[]
{-# LINE 1521 "Transform.hs" #-})
-- use rule "Transform.ag"(line 151, column 32)
_lhsOcollectedUniques =
({-# LINE 151 "Transform.ag" #-}
[]
{-# LINE 1526 "Transform.hs" #-})
-- use rule "Transform.ag"(line 827, column 33)
_lhsOderivings =
({-# LINE 827 "Transform.ag" #-}
Map.empty
{-# LINE 1531 "Transform.hs" #-})
-- use rule "Transform.ag"(line 42, column 19)
_lhsOerrors =
({-# LINE 42 "Transform.ag" #-}
_namesIerrors Seq.>< _attrsIerrors
{-# LINE 1536 "Transform.hs" #-})
-- use rule "Transform.ag"(line 998, column 37)
_lhsOmoduleDecl =
({-# LINE 998 "Transform.ag" #-}
mzero
{-# LINE 1541 "Transform.hs" #-})
-- use rule "Transform.ag"(line 779, column 37)
_lhsOparamsCollect =
({-# LINE 779 "Transform.ag" #-}
Map.empty
{-# LINE 1546 "Transform.hs" #-})
-- use rule "Transform.ag"(line 675, column 34)
_lhsOpragmas =
({-# LINE 675 "Transform.ag" #-}
id
{-# LINE 1551 "Transform.hs" #-})
-- use rule "Transform.ag"(line 719, column 56)
_lhsOsemPragmasCollect =
({-# LINE 719 "Transform.ag" #-}
Map.empty
{-# LINE 1556 "Transform.hs" #-})
-- use rule "Transform.ag"(line 535, column 32)
_lhsOtypeSyns =
({-# LINE 535 "Transform.ag" #-}
[]
{-# LINE 1561 "Transform.hs" #-})
-- use rule "Transform.ag"(line 135, column 15)
_lhsOuseMap =
({-# LINE 135 "Transform.ag" #-}
_attrsIuseMap
{-# LINE 1566 "Transform.hs" #-})
-- use rule "Transform.ag"(line 666, column 32)
_lhsOwrappers =
({-# LINE 666 "Transform.ag" #-}
Set.empty
{-# LINE 1571 "Transform.hs" #-})
-- copy rule (up)
_lhsOattrDecls =
({-# LINE 134 "Transform.ag" #-}
_attrsIattrDecls
{-# LINE 1576 "Transform.hs" #-})
-- copy rule (chain)
_lhsOdefSets =
({-# LINE 102 "Transform.ag" #-}
_lhsIdefSets
{-# LINE 1581 "Transform.hs" #-})
-- copy rule (down)
_namesOallFields =
({-# LINE 126 "Transform.ag" #-}
_lhsIallFields
{-# LINE 1586 "Transform.hs" #-})
-- copy rule (down)
_namesOallNonterminals =
({-# LINE 86 "Transform.ag" #-}
_lhsIallNonterminals
{-# LINE 1591 "Transform.hs" #-})
-- copy rule (down)
_namesOdefinedSets =
({-# LINE 105 "Transform.ag" #-}
_lhsIdefinedSets
{-# LINE 1596 "Transform.hs" #-})
-- copy rule (down)
_attrsOallFields =
({-# LINE 126 "Transform.ag" #-}
_lhsIallFields
{-# LINE 1601 "Transform.hs" #-})
-- copy rule (down)
_attrsOallNonterminals =
({-# LINE 86 "Transform.ag" #-}
_lhsIallNonterminals
{-# LINE 1606 "Transform.hs" #-})
-- copy rule (down)
_attrsOattrDecls =
({-# LINE 134 "Transform.ag" #-}
_lhsIattrDecls
{-# LINE 1611 "Transform.hs" #-})
( _namesIcollectedNames,_namesIerrors,_namesInontSet) =
(names_ _namesOallFields _namesOallNonterminals _namesOdefinedSets )
( _attrsIattrDecls,_attrsIerrors,_attrsIuseMap) =
(attrs_ _attrsOallFields _attrsOallNonterminals _attrsOattrDecls _attrsOnts )
in ( _lhsOattrDecls,_lhsOattrOrderCollect,_lhsOblocks,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedConstructorsMap,_lhsOcollectedFields,_lhsOcollectedInsts,_lhsOcollectedNames,_lhsOcollectedRules,_lhsOcollectedSetNames,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOctxCollect,_lhsOdefSets,_lhsOderivings,_lhsOerrors,_lhsOmoduleDecl,_lhsOparamsCollect,_lhsOpragmas,_lhsOsemPragmasCollect,_lhsOtypeSyns,_lhsOuseMap,_lhsOwrappers))) )
sem_Elem_Data :: Pos ->
ClassContext ->
T_NontSet ->
([Identifier]) ->
T_Attrs ->
T_Alts ->
Bool ->
T_Elem
sem_Elem_Data pos_ ctx_ (T_NontSet names_ ) params_ (T_Attrs attrs_ ) (T_Alts alts_ ) ext_ =
(T_Elem (\ _lhsIallAttrDecls
_lhsIallConstructors
_lhsIallFields
_lhsIallNonterminals
_lhsIattrDecls
_lhsIdefSets
_lhsIdefinedSets ->
(let _altsOnts :: (Set NontermIdent)
_lhsOcollectedConstructorsMap :: (Map NontermIdent (Set ConstructorIdent))
_lhsOparamsCollect :: ParamMap
_lhsOctxCollect :: ContextMap
_attrsOnts :: (Set NontermIdent)
_lhsOattrOrderCollect :: AttrOrderMap
_lhsOblocks :: Blocks
_lhsOcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])
_lhsOcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])
_lhsOcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)])
_lhsOcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ])
_lhsOcollectedNames :: (Set Identifier)
_lhsOcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)])
_lhsOcollectedSetNames :: (Set Identifier)
_lhsOcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ])
_lhsOcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])
_lhsOderivings :: Derivings
_lhsOerrors :: (Seq Error)
_lhsOmoduleDecl :: (Maybe (String,String,String))
_lhsOpragmas :: (Options -> Options)
_lhsOsemPragmasCollect :: PragmaMap
_lhsOtypeSyns :: TypeSyns
_lhsOuseMap :: (Map NontermIdent (Map Identifier (String,String,String)))
_lhsOwrappers :: (Set NontermIdent)
_lhsOattrDecls :: (Map NontermIdent (Attributes, Attributes))
_lhsOdefSets :: (Map Identifier (Set NontermIdent,Set Identifier))
_namesOallFields :: DataTypes
_namesOallNonterminals :: (Set NontermIdent)
_namesOdefinedSets :: DefinedSets
_attrsOallFields :: DataTypes
_attrsOallNonterminals :: (Set NontermIdent)
_attrsOattrDecls :: (Map NontermIdent (Attributes, Attributes))
_altsOallConstructors :: (Map NontermIdent (Set ConstructorIdent))
_altsOallNonterminals :: (Set NontermIdent)
_namesIcollectedNames :: (Set Identifier)
_namesIerrors :: (Seq Error)
_namesInontSet :: (Set NontermIdent)
_attrsIattrDecls :: (Map NontermIdent (Attributes, Attributes))
_attrsIerrors :: (Seq Error)
_attrsIuseMap :: (Map NontermIdent (Map Identifier (String,String,String)))
_altsIcollectedConstructorNames :: (Set ConstructorIdent)
_altsIcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)])
-- "Transform.ag"(line 166, column 10)
_altsOnts =
({-# LINE 166 "Transform.ag" #-}
_namesInontSet
{-# LINE 1679 "Transform.hs" #-})
-- "Transform.ag"(line 514, column 11)
_lhsOcollectedConstructorsMap =
({-# LINE 514 "Transform.ag" #-}
Map.fromList
[ (n, _altsIcollectedConstructorNames)
| n <- Set.toList _namesInontSet
]
{-# LINE 1687 "Transform.hs" #-})
-- "Transform.ag"(line 783, column 7)
_lhsOparamsCollect =
({-# LINE 783 "Transform.ag" #-}
if null params_
then Map.empty
else Map.fromList [(nt, params_) | nt <- Set.toList _namesInontSet]
{-# LINE 1694 "Transform.hs" #-})
-- "Transform.ag"(line 806, column 7)
_lhsOctxCollect =
({-# LINE 806 "Transform.ag" #-}
if null ctx_
then Map.empty
else Map.fromList [(nt, ctx_) | nt <- Set.toList _namesInontSet]
{-# LINE 1701 "Transform.hs" #-})
-- "Transform.ag"(line 849, column 10)
_attrsOnts =
({-# LINE 849 "Transform.ag" #-}
_namesInontSet
{-# LINE 1706 "Transform.hs" #-})
-- use rule "Transform.ag"(line 747, column 55)
_lhsOattrOrderCollect =
({-# LINE 747 "Transform.ag" #-}
Map.empty
{-# LINE 1711 "Transform.hs" #-})
-- use rule "Transform.ag"(line 44, column 19)
_lhsOblocks =
({-# LINE 44 "Transform.ag" #-}
Map.empty
{-# LINE 1716 "Transform.hs" #-})
-- use rule "Transform.ag"(line 153, column 32)
_lhsOcollectedArounds =
({-# LINE 153 "Transform.ag" #-}
[]
{-# LINE 1721 "Transform.hs" #-})
-- use rule "Transform.ag"(line 152, column 32)
_lhsOcollectedAugments =
({-# LINE 152 "Transform.ag" #-}
[]
{-# LINE 1726 "Transform.hs" #-})
-- use rule "Transform.ag"(line 123, column 28)
_lhsOcollectedFields =
({-# LINE 123 "Transform.ag" #-}
_altsIcollectedFields
{-# LINE 1731 "Transform.hs" #-})
-- use rule "Transform.ag"(line 150, column 32)
_lhsOcollectedInsts =
({-# LINE 150 "Transform.ag" #-}
[]
{-# LINE 1736 "Transform.hs" #-})
-- use rule "Transform.ag"(line 84, column 50)
_lhsOcollectedNames =
({-# LINE 84 "Transform.ag" #-}
_namesIcollectedNames
{-# LINE 1741 "Transform.hs" #-})
-- use rule "Transform.ag"(line 148, column 32)
_lhsOcollectedRules =
({-# LINE 148 "Transform.ag" #-}
[]
{-# LINE 1746 "Transform.hs" #-})
-- use rule "Transform.ag"(line 83, column 50)
_lhsOcollectedSetNames =
({-# LINE 83 "Transform.ag" #-}
Set.empty
{-# LINE 1751 "Transform.hs" #-})
-- use rule "Transform.ag"(line 149, column 32)
_lhsOcollectedSigs =
({-# LINE 149 "Transform.ag" #-}
[]
{-# LINE 1756 "Transform.hs" #-})
-- use rule "Transform.ag"(line 151, column 32)
_lhsOcollectedUniques =
({-# LINE 151 "Transform.ag" #-}
[]
{-# LINE 1761 "Transform.hs" #-})
-- use rule "Transform.ag"(line 827, column 33)
_lhsOderivings =
({-# LINE 827 "Transform.ag" #-}
Map.empty
{-# LINE 1766 "Transform.hs" #-})
-- use rule "Transform.ag"(line 42, column 19)
_lhsOerrors =
({-# LINE 42 "Transform.ag" #-}
_namesIerrors Seq.>< _attrsIerrors
{-# LINE 1771 "Transform.hs" #-})
-- use rule "Transform.ag"(line 998, column 37)
_lhsOmoduleDecl =
({-# LINE 998 "Transform.ag" #-}
mzero
{-# LINE 1776 "Transform.hs" #-})
-- use rule "Transform.ag"(line 675, column 34)
_lhsOpragmas =
({-# LINE 675 "Transform.ag" #-}
id
{-# LINE 1781 "Transform.hs" #-})
-- use rule "Transform.ag"(line 719, column 56)
_lhsOsemPragmasCollect =
({-# LINE 719 "Transform.ag" #-}
Map.empty
{-# LINE 1786 "Transform.hs" #-})
-- use rule "Transform.ag"(line 535, column 32)
_lhsOtypeSyns =
({-# LINE 535 "Transform.ag" #-}
[]
{-# LINE 1791 "Transform.hs" #-})
-- use rule "Transform.ag"(line 135, column 15)
_lhsOuseMap =
({-# LINE 135 "Transform.ag" #-}
_attrsIuseMap
{-# LINE 1796 "Transform.hs" #-})
-- use rule "Transform.ag"(line 666, column 32)
_lhsOwrappers =
({-# LINE 666 "Transform.ag" #-}
Set.empty
{-# LINE 1801 "Transform.hs" #-})
-- copy rule (up)
_lhsOattrDecls =
({-# LINE 134 "Transform.ag" #-}
_attrsIattrDecls
{-# LINE 1806 "Transform.hs" #-})
-- copy rule (chain)
_lhsOdefSets =
({-# LINE 102 "Transform.ag" #-}
_lhsIdefSets
{-# LINE 1811 "Transform.hs" #-})
-- copy rule (down)
_namesOallFields =
({-# LINE 126 "Transform.ag" #-}
_lhsIallFields
{-# LINE 1816 "Transform.hs" #-})
-- copy rule (down)
_namesOallNonterminals =
({-# LINE 86 "Transform.ag" #-}
_lhsIallNonterminals
{-# LINE 1821 "Transform.hs" #-})
-- copy rule (down)
_namesOdefinedSets =
({-# LINE 105 "Transform.ag" #-}
_lhsIdefinedSets
{-# LINE 1826 "Transform.hs" #-})
-- copy rule (down)
_attrsOallFields =
({-# LINE 126 "Transform.ag" #-}
_lhsIallFields
{-# LINE 1831 "Transform.hs" #-})
-- copy rule (down)
_attrsOallNonterminals =
({-# LINE 86 "Transform.ag" #-}
_lhsIallNonterminals
{-# LINE 1836 "Transform.hs" #-})
-- copy rule (down)
_attrsOattrDecls =
({-# LINE 134 "Transform.ag" #-}
_lhsIattrDecls
{-# LINE 1841 "Transform.hs" #-})
-- copy rule (down)
_altsOallConstructors =
({-# LINE 94 "Transform.ag" #-}
_lhsIallConstructors
{-# LINE 1846 "Transform.hs" #-})
-- copy rule (down)
_altsOallNonterminals =
({-# LINE 86 "Transform.ag" #-}
_lhsIallNonterminals
{-# LINE 1851 "Transform.hs" #-})
( _namesIcollectedNames,_namesIerrors,_namesInontSet) =
(names_ _namesOallFields _namesOallNonterminals _namesOdefinedSets )
( _attrsIattrDecls,_attrsIerrors,_attrsIuseMap) =
(attrs_ _attrsOallFields _attrsOallNonterminals _attrsOattrDecls _attrsOnts )
( _altsIcollectedConstructorNames,_altsIcollectedFields) =
(alts_ _altsOallConstructors _altsOallNonterminals _altsOnts )
in ( _lhsOattrDecls,_lhsOattrOrderCollect,_lhsOblocks,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedConstructorsMap,_lhsOcollectedFields,_lhsOcollectedInsts,_lhsOcollectedNames,_lhsOcollectedRules,_lhsOcollectedSetNames,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOctxCollect,_lhsOdefSets,_lhsOderivings,_lhsOerrors,_lhsOmoduleDecl,_lhsOparamsCollect,_lhsOpragmas,_lhsOsemPragmasCollect,_lhsOtypeSyns,_lhsOuseMap,_lhsOwrappers))) )
sem_Elem_Deriving :: Pos ->
T_NontSet ->
([NontermIdent]) ->
T_Elem
sem_Elem_Deriving pos_ (T_NontSet set_ ) classes_ =
(T_Elem (\ _lhsIallAttrDecls
_lhsIallConstructors
_lhsIallFields
_lhsIallNonterminals
_lhsIattrDecls
_lhsIdefSets
_lhsIdefinedSets ->
(let _lhsOderivings :: Derivings
_lhsOattrOrderCollect :: AttrOrderMap
_lhsOblocks :: Blocks
_lhsOcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])
_lhsOcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])
_lhsOcollectedConstructorsMap :: (Map NontermIdent (Set ConstructorIdent))
_lhsOcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)])
_lhsOcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ])
_lhsOcollectedNames :: (Set Identifier)
_lhsOcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)])
_lhsOcollectedSetNames :: (Set Identifier)
_lhsOcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ])
_lhsOcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])
_lhsOctxCollect :: ContextMap
_lhsOerrors :: (Seq Error)
_lhsOmoduleDecl :: (Maybe (String,String,String))
_lhsOparamsCollect :: ParamMap
_lhsOpragmas :: (Options -> Options)
_lhsOsemPragmasCollect :: PragmaMap
_lhsOtypeSyns :: TypeSyns
_lhsOuseMap :: (Map NontermIdent (Map Identifier (String,String,String)))
_lhsOwrappers :: (Set NontermIdent)
_lhsOattrDecls :: (Map NontermIdent (Attributes, Attributes))
_lhsOdefSets :: (Map Identifier (Set NontermIdent,Set Identifier))
_setOallFields :: DataTypes
_setOallNonterminals :: (Set NontermIdent)
_setOdefinedSets :: DefinedSets
_setIcollectedNames :: (Set Identifier)
_setIerrors :: (Seq Error)
_setInontSet :: (Set NontermIdent)
-- "Transform.ag"(line 834, column 14)
_lhsOderivings =
({-# LINE 834 "Transform.ag" #-}
Map.fromList [(nt,Set.fromList classes_) | nt <- Set.toList _setInontSet]
{-# LINE 1905 "Transform.hs" #-})
-- use rule "Transform.ag"(line 747, column 55)
_lhsOattrOrderCollect =
({-# LINE 747 "Transform.ag" #-}
Map.empty
{-# LINE 1910 "Transform.hs" #-})
-- use rule "Transform.ag"(line 44, column 19)
_lhsOblocks =
({-# LINE 44 "Transform.ag" #-}
Map.empty
{-# LINE 1915 "Transform.hs" #-})
-- use rule "Transform.ag"(line 153, column 32)
_lhsOcollectedArounds =
({-# LINE 153 "Transform.ag" #-}
[]
{-# LINE 1920 "Transform.hs" #-})
-- use rule "Transform.ag"(line 152, column 32)
_lhsOcollectedAugments =
({-# LINE 152 "Transform.ag" #-}
[]
{-# LINE 1925 "Transform.hs" #-})
-- use rule "Transform.ag"(line 92, column 48)
_lhsOcollectedConstructorsMap =
({-# LINE 92 "Transform.ag" #-}
Map.empty
{-# LINE 1930 "Transform.hs" #-})
-- use rule "Transform.ag"(line 123, column 28)
_lhsOcollectedFields =
({-# LINE 123 "Transform.ag" #-}
[]
{-# LINE 1935 "Transform.hs" #-})
-- use rule "Transform.ag"(line 150, column 32)
_lhsOcollectedInsts =
({-# LINE 150 "Transform.ag" #-}
[]
{-# LINE 1940 "Transform.hs" #-})
-- use rule "Transform.ag"(line 84, column 50)
_lhsOcollectedNames =
({-# LINE 84 "Transform.ag" #-}
_setIcollectedNames
{-# LINE 1945 "Transform.hs" #-})
-- use rule "Transform.ag"(line 148, column 32)
_lhsOcollectedRules =
({-# LINE 148 "Transform.ag" #-}
[]
{-# LINE 1950 "Transform.hs" #-})
-- use rule "Transform.ag"(line 83, column 50)
_lhsOcollectedSetNames =
({-# LINE 83 "Transform.ag" #-}
Set.empty
{-# LINE 1955 "Transform.hs" #-})
-- use rule "Transform.ag"(line 149, column 32)
_lhsOcollectedSigs =
({-# LINE 149 "Transform.ag" #-}
[]
{-# LINE 1960 "Transform.hs" #-})
-- use rule "Transform.ag"(line 151, column 32)
_lhsOcollectedUniques =
({-# LINE 151 "Transform.ag" #-}
[]
{-# LINE 1965 "Transform.hs" #-})
-- use rule "Transform.ag"(line 802, column 34)
_lhsOctxCollect =
({-# LINE 802 "Transform.ag" #-}
Map.empty
{-# LINE 1970 "Transform.hs" #-})
-- use rule "Transform.ag"(line 42, column 19)
_lhsOerrors =
({-# LINE 42 "Transform.ag" #-}
_setIerrors
{-# LINE 1975 "Transform.hs" #-})
-- use rule "Transform.ag"(line 998, column 37)
_lhsOmoduleDecl =
({-# LINE 998 "Transform.ag" #-}
mzero
{-# LINE 1980 "Transform.hs" #-})
-- use rule "Transform.ag"(line 779, column 37)
_lhsOparamsCollect =
({-# LINE 779 "Transform.ag" #-}
Map.empty
{-# LINE 1985 "Transform.hs" #-})
-- use rule "Transform.ag"(line 675, column 34)
_lhsOpragmas =
({-# LINE 675 "Transform.ag" #-}
id
{-# LINE 1990 "Transform.hs" #-})
-- use rule "Transform.ag"(line 719, column 56)
_lhsOsemPragmasCollect =
({-# LINE 719 "Transform.ag" #-}
Map.empty
{-# LINE 1995 "Transform.hs" #-})
-- use rule "Transform.ag"(line 535, column 32)
_lhsOtypeSyns =
({-# LINE 535 "Transform.ag" #-}
[]
{-# LINE 2000 "Transform.hs" #-})
-- use rule "Transform.ag"(line 135, column 15)
_lhsOuseMap =
({-# LINE 135 "Transform.ag" #-}
Map.empty
{-# LINE 2005 "Transform.hs" #-})
-- use rule "Transform.ag"(line 666, column 32)
_lhsOwrappers =
({-# LINE 666 "Transform.ag" #-}
Set.empty
{-# LINE 2010 "Transform.hs" #-})
-- copy rule (chain)
_lhsOattrDecls =
({-# LINE 134 "Transform.ag" #-}
_lhsIattrDecls
{-# LINE 2015 "Transform.hs" #-})
-- copy rule (chain)
_lhsOdefSets =
({-# LINE 102 "Transform.ag" #-}
_lhsIdefSets
{-# LINE 2020 "Transform.hs" #-})
-- copy rule (down)
_setOallFields =
({-# LINE 126 "Transform.ag" #-}
_lhsIallFields
{-# LINE 2025 "Transform.hs" #-})
-- copy rule (down)
_setOallNonterminals =
({-# LINE 86 "Transform.ag" #-}
_lhsIallNonterminals
{-# LINE 2030 "Transform.hs" #-})
-- copy rule (down)
_setOdefinedSets =
({-# LINE 105 "Transform.ag" #-}
_lhsIdefinedSets
{-# LINE 2035 "Transform.hs" #-})
( _setIcollectedNames,_setIerrors,_setInontSet) =
(set_ _setOallFields _setOallNonterminals _setOdefinedSets )
in ( _lhsOattrDecls,_lhsOattrOrderCollect,_lhsOblocks,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedConstructorsMap,_lhsOcollectedFields,_lhsOcollectedInsts,_lhsOcollectedNames,_lhsOcollectedRules,_lhsOcollectedSetNames,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOctxCollect,_lhsOdefSets,_lhsOderivings,_lhsOerrors,_lhsOmoduleDecl,_lhsOparamsCollect,_lhsOpragmas,_lhsOsemPragmasCollect,_lhsOtypeSyns,_lhsOuseMap,_lhsOwrappers))) )
sem_Elem_Module :: Pos ->
String ->
String ->
String ->
T_Elem
sem_Elem_Module pos_ name_ exports_ imports_ =
(T_Elem (\ _lhsIallAttrDecls
_lhsIallConstructors
_lhsIallFields
_lhsIallNonterminals
_lhsIattrDecls
_lhsIdefSets
_lhsIdefinedSets ->
(let _lhsOmoduleDecl :: (Maybe (String,String,String))
_lhsOattrOrderCollect :: AttrOrderMap
_lhsOblocks :: Blocks
_lhsOcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])
_lhsOcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])
_lhsOcollectedConstructorsMap :: (Map NontermIdent (Set ConstructorIdent))
_lhsOcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)])
_lhsOcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ])
_lhsOcollectedNames :: (Set Identifier)
_lhsOcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)])
_lhsOcollectedSetNames :: (Set Identifier)
_lhsOcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ])
_lhsOcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])
_lhsOctxCollect :: ContextMap
_lhsOderivings :: Derivings
_lhsOerrors :: (Seq Error)
_lhsOparamsCollect :: ParamMap
_lhsOpragmas :: (Options -> Options)
_lhsOsemPragmasCollect :: PragmaMap
_lhsOtypeSyns :: TypeSyns
_lhsOuseMap :: (Map NontermIdent (Map Identifier (String,String,String)))
_lhsOwrappers :: (Set NontermIdent)
_lhsOattrDecls :: (Map NontermIdent (Attributes, Attributes))
_lhsOdefSets :: (Map Identifier (Set NontermIdent,Set Identifier))
-- "Transform.ag"(line 1002, column 7)
_lhsOmoduleDecl =
({-# LINE 1002 "Transform.ag" #-}
Just (name_, exports_, imports_)
{-# LINE 2080 "Transform.hs" #-})
-- use rule "Transform.ag"(line 747, column 55)
_lhsOattrOrderCollect =
({-# LINE 747 "Transform.ag" #-}
Map.empty
{-# LINE 2085 "Transform.hs" #-})
-- use rule "Transform.ag"(line 44, column 19)
_lhsOblocks =
({-# LINE 44 "Transform.ag" #-}
Map.empty
{-# LINE 2090 "Transform.hs" #-})
-- use rule "Transform.ag"(line 153, column 32)
_lhsOcollectedArounds =
({-# LINE 153 "Transform.ag" #-}
[]
{-# LINE 2095 "Transform.hs" #-})
-- use rule "Transform.ag"(line 152, column 32)
_lhsOcollectedAugments =
({-# LINE 152 "Transform.ag" #-}
[]
{-# LINE 2100 "Transform.hs" #-})
-- use rule "Transform.ag"(line 92, column 48)
_lhsOcollectedConstructorsMap =
({-# LINE 92 "Transform.ag" #-}
Map.empty
{-# LINE 2105 "Transform.hs" #-})
-- use rule "Transform.ag"(line 123, column 28)
_lhsOcollectedFields =
({-# LINE 123 "Transform.ag" #-}
[]
{-# LINE 2110 "Transform.hs" #-})
-- use rule "Transform.ag"(line 150, column 32)
_lhsOcollectedInsts =
({-# LINE 150 "Transform.ag" #-}
[]
{-# LINE 2115 "Transform.hs" #-})
-- use rule "Transform.ag"(line 84, column 50)
_lhsOcollectedNames =
({-# LINE 84 "Transform.ag" #-}
Set.empty
{-# LINE 2120 "Transform.hs" #-})
-- use rule "Transform.ag"(line 148, column 32)
_lhsOcollectedRules =
({-# LINE 148 "Transform.ag" #-}
[]
{-# LINE 2125 "Transform.hs" #-})
-- use rule "Transform.ag"(line 83, column 50)
_lhsOcollectedSetNames =
({-# LINE 83 "Transform.ag" #-}
Set.empty
{-# LINE 2130 "Transform.hs" #-})
-- use rule "Transform.ag"(line 149, column 32)
_lhsOcollectedSigs =
({-# LINE 149 "Transform.ag" #-}
[]
{-# LINE 2135 "Transform.hs" #-})
-- use rule "Transform.ag"(line 151, column 32)
_lhsOcollectedUniques =
({-# LINE 151 "Transform.ag" #-}
[]
{-# LINE 2140 "Transform.hs" #-})
-- use rule "Transform.ag"(line 802, column 34)
_lhsOctxCollect =
({-# LINE 802 "Transform.ag" #-}
Map.empty
{-# LINE 2145 "Transform.hs" #-})
-- use rule "Transform.ag"(line 827, column 33)
_lhsOderivings =
({-# LINE 827 "Transform.ag" #-}
Map.empty
{-# LINE 2150 "Transform.hs" #-})
-- use rule "Transform.ag"(line 42, column 19)
_lhsOerrors =
({-# LINE 42 "Transform.ag" #-}
Seq.empty
{-# LINE 2155 "Transform.hs" #-})
-- use rule "Transform.ag"(line 779, column 37)
_lhsOparamsCollect =
({-# LINE 779 "Transform.ag" #-}
Map.empty
{-# LINE 2160 "Transform.hs" #-})
-- use rule "Transform.ag"(line 675, column 34)
_lhsOpragmas =
({-# LINE 675 "Transform.ag" #-}
id
{-# LINE 2165 "Transform.hs" #-})
-- use rule "Transform.ag"(line 719, column 56)
_lhsOsemPragmasCollect =
({-# LINE 719 "Transform.ag" #-}
Map.empty
{-# LINE 2170 "Transform.hs" #-})
-- use rule "Transform.ag"(line 535, column 32)
_lhsOtypeSyns =
({-# LINE 535 "Transform.ag" #-}
[]
{-# LINE 2175 "Transform.hs" #-})
-- use rule "Transform.ag"(line 135, column 15)
_lhsOuseMap =
({-# LINE 135 "Transform.ag" #-}
Map.empty
{-# LINE 2180 "Transform.hs" #-})
-- use rule "Transform.ag"(line 666, column 32)
_lhsOwrappers =
({-# LINE 666 "Transform.ag" #-}
Set.empty
{-# LINE 2185 "Transform.hs" #-})
-- copy rule (chain)
_lhsOattrDecls =
({-# LINE 134 "Transform.ag" #-}
_lhsIattrDecls
{-# LINE 2190 "Transform.hs" #-})
-- copy rule (chain)
_lhsOdefSets =
({-# LINE 102 "Transform.ag" #-}
_lhsIdefSets
{-# LINE 2195 "Transform.hs" #-})
in ( _lhsOattrDecls,_lhsOattrOrderCollect,_lhsOblocks,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedConstructorsMap,_lhsOcollectedFields,_lhsOcollectedInsts,_lhsOcollectedNames,_lhsOcollectedRules,_lhsOcollectedSetNames,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOctxCollect,_lhsOdefSets,_lhsOderivings,_lhsOerrors,_lhsOmoduleDecl,_lhsOparamsCollect,_lhsOpragmas,_lhsOsemPragmasCollect,_lhsOtypeSyns,_lhsOuseMap,_lhsOwrappers))) )
sem_Elem_Pragma :: Pos ->
([NontermIdent]) ->
T_Elem
sem_Elem_Pragma pos_ names_ =
(T_Elem (\ _lhsIallAttrDecls
_lhsIallConstructors
_lhsIallFields
_lhsIallNonterminals
_lhsIattrDecls
_lhsIdefSets
_lhsIdefinedSets ->
(let _lhsOpragmas :: (Options -> Options)
_lhsOattrOrderCollect :: AttrOrderMap
_lhsOblocks :: Blocks
_lhsOcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])
_lhsOcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])
_lhsOcollectedConstructorsMap :: (Map NontermIdent (Set ConstructorIdent))
_lhsOcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)])
_lhsOcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ])
_lhsOcollectedNames :: (Set Identifier)
_lhsOcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)])
_lhsOcollectedSetNames :: (Set Identifier)
_lhsOcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ])
_lhsOcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])
_lhsOctxCollect :: ContextMap
_lhsOderivings :: Derivings
_lhsOerrors :: (Seq Error)
_lhsOmoduleDecl :: (Maybe (String,String,String))
_lhsOparamsCollect :: ParamMap
_lhsOsemPragmasCollect :: PragmaMap
_lhsOtypeSyns :: TypeSyns
_lhsOuseMap :: (Map NontermIdent (Map Identifier (String,String,String)))
_lhsOwrappers :: (Set NontermIdent)
_lhsOattrDecls :: (Map NontermIdent (Attributes, Attributes))
_lhsOdefSets :: (Map Identifier (Set NontermIdent,Set Identifier))
-- "Transform.ag"(line 678, column 13)
_lhsOpragmas =
({-# LINE 678 "Transform.ag" #-}
let mk n o = case getName n of
"gencatas" -> o { folds = True }
"nogencatas" -> o { folds = False }
"gendatas" -> o { dataTypes = True }
"nogendatas" -> o { dataTypes = False }
"gensems" -> o { semfuns = True }
"nogensems" -> o { semfuns = False }
"gentypesigs" -> o { typeSigs = True }
"nogentypesigs"-> o { typeSigs = False }
"nocycle" -> o { withCycle = False }
"cycle" -> o { withCycle = True }
"nostrictdata" -> o { strictData = False }
"strictdata" -> o { strictData = True }
"nostrictcase" -> o { strictCases = False }
"strictcase" -> o { strictCases = True }
"strictercase" -> o { strictCases = True, stricterCases = True }
"nostrictwrap" -> o { strictWrap = False }
"strictwrap" -> o { strictWrap = True }
"novisit" -> o { visit = False }
"visit" -> o { visit = True }
"nocase" -> o { cases = False }
"case" -> o { cases = True }
"noseq" -> o { withSeq = False }
"seq" -> o { withSeq = True }
"nounbox" -> o { unbox = False }
"unbox" -> o { unbox = True }
"bangpats" -> o { bangpats = True }
"nooptimize" -> o { cases = False , visit = False }
"optimize" -> o { cases = True , visit = True }
"strictsem" -> o { strictSems = True }
"gentraces" -> o { genTraces = True }
"genusetraces" -> o { genUseTraces = True }
"splitsems" -> o { splitSems = True }
"gencostcentres" -> o { genCostCentres = True }
"sepsemmods" -> o { sepSemMods = True }
"genlinepragmas" -> o { genLinePragmas = True }
"newtypes" -> o { newtypes = True }
"nonewtypes" -> o { newtypes = False }
_ -> o
in \o -> foldr mk o names_
{-# LINE 2275 "Transform.hs" #-})
-- use rule "Transform.ag"(line 747, column 55)
_lhsOattrOrderCollect =
({-# LINE 747 "Transform.ag" #-}
Map.empty
{-# LINE 2280 "Transform.hs" #-})
-- use rule "Transform.ag"(line 44, column 19)
_lhsOblocks =
({-# LINE 44 "Transform.ag" #-}
Map.empty
{-# LINE 2285 "Transform.hs" #-})
-- use rule "Transform.ag"(line 153, column 32)
_lhsOcollectedArounds =
({-# LINE 153 "Transform.ag" #-}
[]
{-# LINE 2290 "Transform.hs" #-})
-- use rule "Transform.ag"(line 152, column 32)
_lhsOcollectedAugments =
({-# LINE 152 "Transform.ag" #-}
[]
{-# LINE 2295 "Transform.hs" #-})
-- use rule "Transform.ag"(line 92, column 48)
_lhsOcollectedConstructorsMap =
({-# LINE 92 "Transform.ag" #-}
Map.empty
{-# LINE 2300 "Transform.hs" #-})
-- use rule "Transform.ag"(line 123, column 28)
_lhsOcollectedFields =
({-# LINE 123 "Transform.ag" #-}
[]
{-# LINE 2305 "Transform.hs" #-})
-- use rule "Transform.ag"(line 150, column 32)
_lhsOcollectedInsts =
({-# LINE 150 "Transform.ag" #-}
[]
{-# LINE 2310 "Transform.hs" #-})
-- use rule "Transform.ag"(line 84, column 50)
_lhsOcollectedNames =
({-# LINE 84 "Transform.ag" #-}
Set.empty
{-# LINE 2315 "Transform.hs" #-})
-- use rule "Transform.ag"(line 148, column 32)
_lhsOcollectedRules =
({-# LINE 148 "Transform.ag" #-}
[]
{-# LINE 2320 "Transform.hs" #-})
-- use rule "Transform.ag"(line 83, column 50)
_lhsOcollectedSetNames =
({-# LINE 83 "Transform.ag" #-}
Set.empty
{-# LINE 2325 "Transform.hs" #-})
-- use rule "Transform.ag"(line 149, column 32)
_lhsOcollectedSigs =
({-# LINE 149 "Transform.ag" #-}
[]
{-# LINE 2330 "Transform.hs" #-})
-- use rule "Transform.ag"(line 151, column 32)
_lhsOcollectedUniques =
({-# LINE 151 "Transform.ag" #-}
[]
{-# LINE 2335 "Transform.hs" #-})
-- use rule "Transform.ag"(line 802, column 34)
_lhsOctxCollect =
({-# LINE 802 "Transform.ag" #-}
Map.empty
{-# LINE 2340 "Transform.hs" #-})
-- use rule "Transform.ag"(line 827, column 33)
_lhsOderivings =
({-# LINE 827 "Transform.ag" #-}
Map.empty
{-# LINE 2345 "Transform.hs" #-})
-- use rule "Transform.ag"(line 42, column 19)
_lhsOerrors =
({-# LINE 42 "Transform.ag" #-}
Seq.empty
{-# LINE 2350 "Transform.hs" #-})
-- use rule "Transform.ag"(line 998, column 37)
_lhsOmoduleDecl =
({-# LINE 998 "Transform.ag" #-}
mzero
{-# LINE 2355 "Transform.hs" #-})
-- use rule "Transform.ag"(line 779, column 37)
_lhsOparamsCollect =
({-# LINE 779 "Transform.ag" #-}
Map.empty
{-# LINE 2360 "Transform.hs" #-})
-- use rule "Transform.ag"(line 719, column 56)
_lhsOsemPragmasCollect =
({-# LINE 719 "Transform.ag" #-}
Map.empty
{-# LINE 2365 "Transform.hs" #-})
-- use rule "Transform.ag"(line 535, column 32)
_lhsOtypeSyns =
({-# LINE 535 "Transform.ag" #-}
[]
{-# LINE 2370 "Transform.hs" #-})
-- use rule "Transform.ag"(line 135, column 15)
_lhsOuseMap =
({-# LINE 135 "Transform.ag" #-}
Map.empty
{-# LINE 2375 "Transform.hs" #-})
-- use rule "Transform.ag"(line 666, column 32)
_lhsOwrappers =
({-# LINE 666 "Transform.ag" #-}
Set.empty
{-# LINE 2380 "Transform.hs" #-})
-- copy rule (chain)
_lhsOattrDecls =
({-# LINE 134 "Transform.ag" #-}
_lhsIattrDecls
{-# LINE 2385 "Transform.hs" #-})
-- copy rule (chain)
_lhsOdefSets =
({-# LINE 102 "Transform.ag" #-}
_lhsIdefSets
{-# LINE 2390 "Transform.hs" #-})
in ( _lhsOattrDecls,_lhsOattrOrderCollect,_lhsOblocks,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedConstructorsMap,_lhsOcollectedFields,_lhsOcollectedInsts,_lhsOcollectedNames,_lhsOcollectedRules,_lhsOcollectedSetNames,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOctxCollect,_lhsOdefSets,_lhsOderivings,_lhsOerrors,_lhsOmoduleDecl,_lhsOparamsCollect,_lhsOpragmas,_lhsOsemPragmasCollect,_lhsOtypeSyns,_lhsOuseMap,_lhsOwrappers))) )
sem_Elem_Sem :: Pos ->
ClassContext ->
T_NontSet ->
T_Attrs ->
T_SemAlts ->
T_Elem
sem_Elem_Sem pos_ ctx_ (T_NontSet names_ ) (T_Attrs attrs_ ) (T_SemAlts alts_ ) =
(T_Elem (\ _lhsIallAttrDecls
_lhsIallConstructors
_lhsIallFields
_lhsIallNonterminals
_lhsIattrDecls
_lhsIdefSets
_lhsIdefinedSets ->
(let _altsOnts :: (Set NontermIdent)
_lhsOctxCollect :: ContextMap
_attrsOnts :: (Set NontermIdent)
_lhsOattrOrderCollect :: AttrOrderMap
_lhsOblocks :: Blocks
_lhsOcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])
_lhsOcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])
_lhsOcollectedConstructorsMap :: (Map NontermIdent (Set ConstructorIdent))
_lhsOcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)])
_lhsOcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ])
_lhsOcollectedNames :: (Set Identifier)
_lhsOcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)])
_lhsOcollectedSetNames :: (Set Identifier)
_lhsOcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ])
_lhsOcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])
_lhsOderivings :: Derivings
_lhsOerrors :: (Seq Error)
_lhsOmoduleDecl :: (Maybe (String,String,String))
_lhsOparamsCollect :: ParamMap
_lhsOpragmas :: (Options -> Options)
_lhsOsemPragmasCollect :: PragmaMap
_lhsOtypeSyns :: TypeSyns
_lhsOuseMap :: (Map NontermIdent (Map Identifier (String,String,String)))
_lhsOwrappers :: (Set NontermIdent)
_lhsOattrDecls :: (Map NontermIdent (Attributes, Attributes))
_lhsOdefSets :: (Map Identifier (Set NontermIdent,Set Identifier))
_namesOallFields :: DataTypes
_namesOallNonterminals :: (Set NontermIdent)
_namesOdefinedSets :: DefinedSets
_attrsOallFields :: DataTypes
_attrsOallNonterminals :: (Set NontermIdent)
_attrsOattrDecls :: (Map NontermIdent (Attributes, Attributes))
_altsOallAttrDecls :: (Map NontermIdent (Attributes, Attributes))
_altsOallFields :: DataTypes
_namesIcollectedNames :: (Set Identifier)
_namesIerrors :: (Seq Error)
_namesInontSet :: (Set NontermIdent)
_attrsIattrDecls :: (Map NontermIdent (Attributes, Attributes))
_attrsIerrors :: (Seq Error)
_attrsIuseMap :: (Map NontermIdent (Map Identifier (String,String,String)))
_altsIattrOrderCollect :: AttrOrderMap
_altsIcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])
_altsIcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])
_altsIcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ])
_altsIcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)])
_altsIcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ])
_altsIcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])
_altsIerrors :: (Seq Error)
_altsIsemPragmasCollect :: PragmaMap
-- "Transform.ag"(line 167, column 10)
_altsOnts =
({-# LINE 167 "Transform.ag" #-}
_namesInontSet
{-# LINE 2459 "Transform.hs" #-})
-- "Transform.ag"(line 806, column 7)
_lhsOctxCollect =
({-# LINE 806 "Transform.ag" #-}
if null ctx_
then Map.empty
else Map.fromList [(nt, ctx_) | nt <- Set.toList _namesInontSet]
{-# LINE 2466 "Transform.hs" #-})
-- "Transform.ag"(line 851, column 10)
_attrsOnts =
({-# LINE 851 "Transform.ag" #-}
_namesInontSet
{-# LINE 2471 "Transform.hs" #-})
-- use rule "Transform.ag"(line 747, column 55)
_lhsOattrOrderCollect =
({-# LINE 747 "Transform.ag" #-}
_altsIattrOrderCollect
{-# LINE 2476 "Transform.hs" #-})
-- use rule "Transform.ag"(line 44, column 19)
_lhsOblocks =
({-# LINE 44 "Transform.ag" #-}
Map.empty
{-# LINE 2481 "Transform.hs" #-})
-- use rule "Transform.ag"(line 153, column 32)
_lhsOcollectedArounds =
({-# LINE 153 "Transform.ag" #-}
_altsIcollectedArounds
{-# LINE 2486 "Transform.hs" #-})
-- use rule "Transform.ag"(line 152, column 32)
_lhsOcollectedAugments =
({-# LINE 152 "Transform.ag" #-}
_altsIcollectedAugments
{-# LINE 2491 "Transform.hs" #-})
-- use rule "Transform.ag"(line 92, column 48)
_lhsOcollectedConstructorsMap =
({-# LINE 92 "Transform.ag" #-}
Map.empty
{-# LINE 2496 "Transform.hs" #-})
-- use rule "Transform.ag"(line 123, column 28)
_lhsOcollectedFields =
({-# LINE 123 "Transform.ag" #-}
[]
{-# LINE 2501 "Transform.hs" #-})
-- use rule "Transform.ag"(line 150, column 32)
_lhsOcollectedInsts =
({-# LINE 150 "Transform.ag" #-}
_altsIcollectedInsts
{-# LINE 2506 "Transform.hs" #-})
-- use rule "Transform.ag"(line 84, column 50)
_lhsOcollectedNames =
({-# LINE 84 "Transform.ag" #-}
_namesIcollectedNames
{-# LINE 2511 "Transform.hs" #-})
-- use rule "Transform.ag"(line 148, column 32)
_lhsOcollectedRules =
({-# LINE 148 "Transform.ag" #-}
_altsIcollectedRules
{-# LINE 2516 "Transform.hs" #-})
-- use rule "Transform.ag"(line 83, column 50)
_lhsOcollectedSetNames =
({-# LINE 83 "Transform.ag" #-}
Set.empty
{-# LINE 2521 "Transform.hs" #-})
-- use rule "Transform.ag"(line 149, column 32)
_lhsOcollectedSigs =
({-# LINE 149 "Transform.ag" #-}
_altsIcollectedSigs
{-# LINE 2526 "Transform.hs" #-})
-- use rule "Transform.ag"(line 151, column 32)
_lhsOcollectedUniques =
({-# LINE 151 "Transform.ag" #-}
_altsIcollectedUniques
{-# LINE 2531 "Transform.hs" #-})
-- use rule "Transform.ag"(line 827, column 33)
_lhsOderivings =
({-# LINE 827 "Transform.ag" #-}
Map.empty
{-# LINE 2536 "Transform.hs" #-})
-- use rule "Transform.ag"(line 42, column 19)
_lhsOerrors =
({-# LINE 42 "Transform.ag" #-}
_namesIerrors Seq.>< _attrsIerrors Seq.>< _altsIerrors
{-# LINE 2541 "Transform.hs" #-})
-- use rule "Transform.ag"(line 998, column 37)
_lhsOmoduleDecl =
({-# LINE 998 "Transform.ag" #-}
mzero
{-# LINE 2546 "Transform.hs" #-})
-- use rule "Transform.ag"(line 779, column 37)
_lhsOparamsCollect =
({-# LINE 779 "Transform.ag" #-}
Map.empty
{-# LINE 2551 "Transform.hs" #-})
-- use rule "Transform.ag"(line 675, column 34)
_lhsOpragmas =
({-# LINE 675 "Transform.ag" #-}
id
{-# LINE 2556 "Transform.hs" #-})
-- use rule "Transform.ag"(line 719, column 56)
_lhsOsemPragmasCollect =
({-# LINE 719 "Transform.ag" #-}
_altsIsemPragmasCollect
{-# LINE 2561 "Transform.hs" #-})
-- use rule "Transform.ag"(line 535, column 32)
_lhsOtypeSyns =
({-# LINE 535 "Transform.ag" #-}
[]
{-# LINE 2566 "Transform.hs" #-})
-- use rule "Transform.ag"(line 135, column 15)
_lhsOuseMap =
({-# LINE 135 "Transform.ag" #-}
_attrsIuseMap
{-# LINE 2571 "Transform.hs" #-})
-- use rule "Transform.ag"(line 666, column 32)
_lhsOwrappers =
({-# LINE 666 "Transform.ag" #-}
Set.empty
{-# LINE 2576 "Transform.hs" #-})
-- copy rule (up)
_lhsOattrDecls =
({-# LINE 134 "Transform.ag" #-}
_attrsIattrDecls
{-# LINE 2581 "Transform.hs" #-})
-- copy rule (chain)
_lhsOdefSets =
({-# LINE 102 "Transform.ag" #-}
_lhsIdefSets
{-# LINE 2586 "Transform.hs" #-})
-- copy rule (down)
_namesOallFields =
({-# LINE 126 "Transform.ag" #-}
_lhsIallFields
{-# LINE 2591 "Transform.hs" #-})
-- copy rule (down)
_namesOallNonterminals =
({-# LINE 86 "Transform.ag" #-}
_lhsIallNonterminals
{-# LINE 2596 "Transform.hs" #-})
-- copy rule (down)
_namesOdefinedSets =
({-# LINE 105 "Transform.ag" #-}
_lhsIdefinedSets
{-# LINE 2601 "Transform.hs" #-})
-- copy rule (down)
_attrsOallFields =
({-# LINE 126 "Transform.ag" #-}
_lhsIallFields
{-# LINE 2606 "Transform.hs" #-})
-- copy rule (down)
_attrsOallNonterminals =
({-# LINE 86 "Transform.ag" #-}
_lhsIallNonterminals
{-# LINE 2611 "Transform.hs" #-})
-- copy rule (down)
_attrsOattrDecls =
({-# LINE 134 "Transform.ag" #-}
_lhsIattrDecls
{-# LINE 2616 "Transform.hs" #-})
-- copy rule (down)
_altsOallAttrDecls =
({-# LINE 748 "Transform.ag" #-}
_lhsIallAttrDecls
{-# LINE 2621 "Transform.hs" #-})
-- copy rule (down)
_altsOallFields =
({-# LINE 126 "Transform.ag" #-}
_lhsIallFields
{-# LINE 2626 "Transform.hs" #-})
( _namesIcollectedNames,_namesIerrors,_namesInontSet) =
(names_ _namesOallFields _namesOallNonterminals _namesOdefinedSets )
( _attrsIattrDecls,_attrsIerrors,_attrsIuseMap) =
(attrs_ _attrsOallFields _attrsOallNonterminals _attrsOattrDecls _attrsOnts )
( _altsIattrOrderCollect,_altsIcollectedArounds,_altsIcollectedAugments,_altsIcollectedInsts,_altsIcollectedRules,_altsIcollectedSigs,_altsIcollectedUniques,_altsIerrors,_altsIsemPragmasCollect) =
(alts_ _altsOallAttrDecls _altsOallFields _altsOnts )
in ( _lhsOattrDecls,_lhsOattrOrderCollect,_lhsOblocks,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedConstructorsMap,_lhsOcollectedFields,_lhsOcollectedInsts,_lhsOcollectedNames,_lhsOcollectedRules,_lhsOcollectedSetNames,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOctxCollect,_lhsOdefSets,_lhsOderivings,_lhsOerrors,_lhsOmoduleDecl,_lhsOparamsCollect,_lhsOpragmas,_lhsOsemPragmasCollect,_lhsOtypeSyns,_lhsOuseMap,_lhsOwrappers))) )
sem_Elem_Set :: Pos ->
NontermIdent ->
T_NontSet ->
T_Elem
sem_Elem_Set pos_ name_ (T_NontSet set_ ) =
(T_Elem (\ _lhsIallAttrDecls
_lhsIallConstructors
_lhsIallFields
_lhsIallNonterminals
_lhsIattrDecls
_lhsIdefSets
_lhsIdefinedSets ->
(let _lhsOcollectedSetNames :: (Set Identifier)
_lhsOdefSets :: (Map Identifier (Set NontermIdent,Set Identifier))
_lhsOerrors :: (Seq Error)
_lhsOattrOrderCollect :: AttrOrderMap
_lhsOblocks :: Blocks
_lhsOcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])
_lhsOcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])
_lhsOcollectedConstructorsMap :: (Map NontermIdent (Set ConstructorIdent))
_lhsOcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)])
_lhsOcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ])
_lhsOcollectedNames :: (Set Identifier)
_lhsOcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)])
_lhsOcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ])
_lhsOcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])
_lhsOctxCollect :: ContextMap
_lhsOderivings :: Derivings
_lhsOmoduleDecl :: (Maybe (String,String,String))
_lhsOparamsCollect :: ParamMap
_lhsOpragmas :: (Options -> Options)
_lhsOsemPragmasCollect :: PragmaMap
_lhsOtypeSyns :: TypeSyns
_lhsOuseMap :: (Map NontermIdent (Map Identifier (String,String,String)))
_lhsOwrappers :: (Set NontermIdent)
_lhsOattrDecls :: (Map NontermIdent (Attributes, Attributes))
_setOallFields :: DataTypes
_setOallNonterminals :: (Set NontermIdent)
_setOdefinedSets :: DefinedSets
_setIcollectedNames :: (Set Identifier)
_setIerrors :: (Seq Error)
_setInontSet :: (Set NontermIdent)
-- "Transform.ag"(line 491, column 10)
_lhsOcollectedSetNames =
({-# LINE 491 "Transform.ag" #-}
Set.singleton name_
{-# LINE 2680 "Transform.hs" #-})
-- "Transform.ag"(line 598, column 13)
__tup3 =
({-# LINE 598 "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 2694 "Transform.hs" #-})
-- "Transform.ag"(line 598, column 13)
(_defSets2,_) =
({-# LINE 598 "Transform.ag" #-}
__tup3
{-# LINE 2699 "Transform.hs" #-})
-- "Transform.ag"(line 598, column 13)
(_,_errs) =
({-# LINE 598 "Transform.ag" #-}
__tup3
{-# LINE 2704 "Transform.hs" #-})
-- "Transform.ag"(line 608, column 9)
_lhsOdefSets =
({-# LINE 608 "Transform.ag" #-}
_defSets2
{-# LINE 2709 "Transform.hs" #-})
-- "Transform.ag"(line 608, column 9)
_lhsOerrors =
({-# LINE 609 "Transform.ag" #-}
_errs >< _setIerrors
{-# LINE 2714 "Transform.hs" #-})
-- use rule "Transform.ag"(line 747, column 55)
_lhsOattrOrderCollect =
({-# LINE 747 "Transform.ag" #-}
Map.empty
{-# LINE 2719 "Transform.hs" #-})
-- use rule "Transform.ag"(line 44, column 19)
_lhsOblocks =
({-# LINE 44 "Transform.ag" #-}
Map.empty
{-# LINE 2724 "Transform.hs" #-})
-- use rule "Transform.ag"(line 153, column 32)
_lhsOcollectedArounds =
({-# LINE 153 "Transform.ag" #-}
[]
{-# LINE 2729 "Transform.hs" #-})
-- use rule "Transform.ag"(line 152, column 32)
_lhsOcollectedAugments =
({-# LINE 152 "Transform.ag" #-}
[]
{-# LINE 2734 "Transform.hs" #-})
-- use rule "Transform.ag"(line 92, column 48)
_lhsOcollectedConstructorsMap =
({-# LINE 92 "Transform.ag" #-}
Map.empty
{-# LINE 2739 "Transform.hs" #-})
-- use rule "Transform.ag"(line 123, column 28)
_lhsOcollectedFields =
({-# LINE 123 "Transform.ag" #-}
[]
{-# LINE 2744 "Transform.hs" #-})
-- use rule "Transform.ag"(line 150, column 32)
_lhsOcollectedInsts =
({-# LINE 150 "Transform.ag" #-}
[]
{-# LINE 2749 "Transform.hs" #-})
-- use rule "Transform.ag"(line 84, column 50)
_lhsOcollectedNames =
({-# LINE 84 "Transform.ag" #-}
_setIcollectedNames
{-# LINE 2754 "Transform.hs" #-})
-- use rule "Transform.ag"(line 148, column 32)
_lhsOcollectedRules =
({-# LINE 148 "Transform.ag" #-}
[]
{-# LINE 2759 "Transform.hs" #-})
-- use rule "Transform.ag"(line 149, column 32)
_lhsOcollectedSigs =
({-# LINE 149 "Transform.ag" #-}
[]
{-# LINE 2764 "Transform.hs" #-})
-- use rule "Transform.ag"(line 151, column 32)
_lhsOcollectedUniques =
({-# LINE 151 "Transform.ag" #-}
[]
{-# LINE 2769 "Transform.hs" #-})
-- use rule "Transform.ag"(line 802, column 34)
_lhsOctxCollect =
({-# LINE 802 "Transform.ag" #-}
Map.empty
{-# LINE 2774 "Transform.hs" #-})
-- use rule "Transform.ag"(line 827, column 33)
_lhsOderivings =
({-# LINE 827 "Transform.ag" #-}
Map.empty
{-# LINE 2779 "Transform.hs" #-})
-- use rule "Transform.ag"(line 998, column 37)
_lhsOmoduleDecl =
({-# LINE 998 "Transform.ag" #-}
mzero
{-# LINE 2784 "Transform.hs" #-})
-- use rule "Transform.ag"(line 779, column 37)
_lhsOparamsCollect =
({-# LINE 779 "Transform.ag" #-}
Map.empty
{-# LINE 2789 "Transform.hs" #-})
-- use rule "Transform.ag"(line 675, column 34)
_lhsOpragmas =
({-# LINE 675 "Transform.ag" #-}
id
{-# LINE 2794 "Transform.hs" #-})
-- use rule "Transform.ag"(line 719, column 56)
_lhsOsemPragmasCollect =
({-# LINE 719 "Transform.ag" #-}
Map.empty
{-# LINE 2799 "Transform.hs" #-})
-- use rule "Transform.ag"(line 535, column 32)
_lhsOtypeSyns =
({-# LINE 535 "Transform.ag" #-}
[]
{-# LINE 2804 "Transform.hs" #-})
-- use rule "Transform.ag"(line 135, column 15)
_lhsOuseMap =
({-# LINE 135 "Transform.ag" #-}
Map.empty
{-# LINE 2809 "Transform.hs" #-})
-- use rule "Transform.ag"(line 666, column 32)
_lhsOwrappers =
({-# LINE 666 "Transform.ag" #-}
Set.empty
{-# LINE 2814 "Transform.hs" #-})
-- copy rule (chain)
_lhsOattrDecls =
({-# LINE 134 "Transform.ag" #-}
_lhsIattrDecls
{-# LINE 2819 "Transform.hs" #-})
-- copy rule (down)
_setOallFields =
({-# LINE 126 "Transform.ag" #-}
_lhsIallFields
{-# LINE 2824 "Transform.hs" #-})
-- copy rule (down)
_setOallNonterminals =
({-# LINE 86 "Transform.ag" #-}
_lhsIallNonterminals
{-# LINE 2829 "Transform.hs" #-})
-- copy rule (down)
_setOdefinedSets =
({-# LINE 105 "Transform.ag" #-}
_lhsIdefinedSets
{-# LINE 2834 "Transform.hs" #-})
( _setIcollectedNames,_setIerrors,_setInontSet) =
(set_ _setOallFields _setOallNonterminals _setOdefinedSets )
in ( _lhsOattrDecls,_lhsOattrOrderCollect,_lhsOblocks,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedConstructorsMap,_lhsOcollectedFields,_lhsOcollectedInsts,_lhsOcollectedNames,_lhsOcollectedRules,_lhsOcollectedSetNames,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOctxCollect,_lhsOdefSets,_lhsOderivings,_lhsOerrors,_lhsOmoduleDecl,_lhsOparamsCollect,_lhsOpragmas,_lhsOsemPragmasCollect,_lhsOtypeSyns,_lhsOuseMap,_lhsOwrappers))) )
sem_Elem_Txt :: Pos ->
Identifier ->
(Maybe NontermIdent) ->
([String]) ->
T_Elem
sem_Elem_Txt pos_ name_ mbNt_ lines_ =
(T_Elem (\ _lhsIallAttrDecls
_lhsIallConstructors
_lhsIallFields
_lhsIallNonterminals
_lhsIattrDecls
_lhsIdefSets
_lhsIdefinedSets ->
(let _lhsOblocks :: Blocks
_lhsOattrOrderCollect :: AttrOrderMap
_lhsOcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])
_lhsOcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])
_lhsOcollectedConstructorsMap :: (Map NontermIdent (Set ConstructorIdent))
_lhsOcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)])
_lhsOcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ])
_lhsOcollectedNames :: (Set Identifier)
_lhsOcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)])
_lhsOcollectedSetNames :: (Set Identifier)
_lhsOcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ])
_lhsOcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])
_lhsOctxCollect :: ContextMap
_lhsOderivings :: Derivings
_lhsOerrors :: (Seq Error)
_lhsOmoduleDecl :: (Maybe (String,String,String))
_lhsOparamsCollect :: ParamMap
_lhsOpragmas :: (Options -> Options)
_lhsOsemPragmasCollect :: PragmaMap
_lhsOtypeSyns :: TypeSyns
_lhsOuseMap :: (Map NontermIdent (Map Identifier (String,String,String)))
_lhsOwrappers :: (Set NontermIdent)
_lhsOattrDecls :: (Map NontermIdent (Attributes, Attributes))
_lhsOdefSets :: (Map Identifier (Set NontermIdent,Set Identifier))
-- "Transform.ag"(line 176, column 10)
_blockInfo =
({-# LINE 176 "Transform.ag" #-}
( let nm = getName name_
in if nm == "imports"
then BlockImport
else if nm == "optpragmas"
then BlockPragma
else BlockOther
, mbNt_
)
{-# LINE 2886 "Transform.hs" #-})
-- "Transform.ag"(line 184, column 10)
_blockValue =
({-# LINE 184 "Transform.ag" #-}
[(lines_, pos_)]
{-# LINE 2891 "Transform.hs" #-})
-- "Transform.ag"(line 185, column 10)
_lhsOblocks =
({-# LINE 185 "Transform.ag" #-}
Map.singleton _blockInfo _blockValue
{-# LINE 2896 "Transform.hs" #-})
-- use rule "Transform.ag"(line 747, column 55)
_lhsOattrOrderCollect =
({-# LINE 747 "Transform.ag" #-}
Map.empty
{-# LINE 2901 "Transform.hs" #-})
-- use rule "Transform.ag"(line 153, column 32)
_lhsOcollectedArounds =
({-# LINE 153 "Transform.ag" #-}
[]
{-# LINE 2906 "Transform.hs" #-})
-- use rule "Transform.ag"(line 152, column 32)
_lhsOcollectedAugments =
({-# LINE 152 "Transform.ag" #-}
[]
{-# LINE 2911 "Transform.hs" #-})
-- use rule "Transform.ag"(line 92, column 48)
_lhsOcollectedConstructorsMap =
({-# LINE 92 "Transform.ag" #-}
Map.empty
{-# LINE 2916 "Transform.hs" #-})
-- use rule "Transform.ag"(line 123, column 28)
_lhsOcollectedFields =
({-# LINE 123 "Transform.ag" #-}
[]
{-# LINE 2921 "Transform.hs" #-})
-- use rule "Transform.ag"(line 150, column 32)
_lhsOcollectedInsts =
({-# LINE 150 "Transform.ag" #-}
[]
{-# LINE 2926 "Transform.hs" #-})
-- use rule "Transform.ag"(line 84, column 50)
_lhsOcollectedNames =
({-# LINE 84 "Transform.ag" #-}
Set.empty
{-# LINE 2931 "Transform.hs" #-})
-- use rule "Transform.ag"(line 148, column 32)
_lhsOcollectedRules =
({-# LINE 148 "Transform.ag" #-}
[]
{-# LINE 2936 "Transform.hs" #-})
-- use rule "Transform.ag"(line 83, column 50)
_lhsOcollectedSetNames =
({-# LINE 83 "Transform.ag" #-}
Set.empty
{-# LINE 2941 "Transform.hs" #-})
-- use rule "Transform.ag"(line 149, column 32)
_lhsOcollectedSigs =
({-# LINE 149 "Transform.ag" #-}
[]
{-# LINE 2946 "Transform.hs" #-})
-- use rule "Transform.ag"(line 151, column 32)
_lhsOcollectedUniques =
({-# LINE 151 "Transform.ag" #-}
[]
{-# LINE 2951 "Transform.hs" #-})
-- use rule "Transform.ag"(line 802, column 34)
_lhsOctxCollect =
({-# LINE 802 "Transform.ag" #-}
Map.empty
{-# LINE 2956 "Transform.hs" #-})
-- use rule "Transform.ag"(line 827, column 33)
_lhsOderivings =
({-# LINE 827 "Transform.ag" #-}
Map.empty
{-# LINE 2961 "Transform.hs" #-})
-- use rule "Transform.ag"(line 42, column 19)
_lhsOerrors =
({-# LINE 42 "Transform.ag" #-}
Seq.empty
{-# LINE 2966 "Transform.hs" #-})
-- use rule "Transform.ag"(line 998, column 37)
_lhsOmoduleDecl =
({-# LINE 998 "Transform.ag" #-}
mzero
{-# LINE 2971 "Transform.hs" #-})
-- use rule "Transform.ag"(line 779, column 37)
_lhsOparamsCollect =
({-# LINE 779 "Transform.ag" #-}
Map.empty
{-# LINE 2976 "Transform.hs" #-})
-- use rule "Transform.ag"(line 675, column 34)
_lhsOpragmas =
({-# LINE 675 "Transform.ag" #-}
id
{-# LINE 2981 "Transform.hs" #-})
-- use rule "Transform.ag"(line 719, column 56)
_lhsOsemPragmasCollect =
({-# LINE 719 "Transform.ag" #-}
Map.empty
{-# LINE 2986 "Transform.hs" #-})
-- use rule "Transform.ag"(line 535, column 32)
_lhsOtypeSyns =
({-# LINE 535 "Transform.ag" #-}
[]
{-# LINE 2991 "Transform.hs" #-})
-- use rule "Transform.ag"(line 135, column 15)
_lhsOuseMap =
({-# LINE 135 "Transform.ag" #-}
Map.empty
{-# LINE 2996 "Transform.hs" #-})
-- use rule "Transform.ag"(line 666, column 32)
_lhsOwrappers =
({-# LINE 666 "Transform.ag" #-}
Set.empty
{-# LINE 3001 "Transform.hs" #-})
-- copy rule (chain)
_lhsOattrDecls =
({-# LINE 134 "Transform.ag" #-}
_lhsIattrDecls
{-# LINE 3006 "Transform.hs" #-})
-- copy rule (chain)
_lhsOdefSets =
({-# LINE 102 "Transform.ag" #-}
_lhsIdefSets
{-# LINE 3011 "Transform.hs" #-})
in ( _lhsOattrDecls,_lhsOattrOrderCollect,_lhsOblocks,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedConstructorsMap,_lhsOcollectedFields,_lhsOcollectedInsts,_lhsOcollectedNames,_lhsOcollectedRules,_lhsOcollectedSetNames,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOctxCollect,_lhsOdefSets,_lhsOderivings,_lhsOerrors,_lhsOmoduleDecl,_lhsOparamsCollect,_lhsOpragmas,_lhsOsemPragmasCollect,_lhsOtypeSyns,_lhsOuseMap,_lhsOwrappers))) )
sem_Elem_Type :: Pos ->
ClassContext ->
NontermIdent ->
([Identifier]) ->
ComplexType ->
T_Elem
sem_Elem_Type pos_ ctx_ name_ params_ type_ =
(T_Elem (\ _lhsIallAttrDecls
_lhsIallConstructors
_lhsIallFields
_lhsIallNonterminals
_lhsIattrDecls
_lhsIdefSets
_lhsIdefinedSets ->
(let _lhsOcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)])
_lhsOcollectedNames :: (Set Identifier)
_lhsOtypeSyns :: TypeSyns
_lhsOparamsCollect :: ParamMap
_lhsOctxCollect :: ContextMap
_lhsOattrOrderCollect :: AttrOrderMap
_lhsOblocks :: Blocks
_lhsOcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])
_lhsOcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])
_lhsOcollectedConstructorsMap :: (Map NontermIdent (Set ConstructorIdent))
_lhsOcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ])
_lhsOcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)])
_lhsOcollectedSetNames :: (Set Identifier)
_lhsOcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ])
_lhsOcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])
_lhsOderivings :: Derivings
_lhsOerrors :: (Seq Error)
_lhsOmoduleDecl :: (Maybe (String,String,String))
_lhsOpragmas :: (Options -> Options)
_lhsOsemPragmasCollect :: PragmaMap
_lhsOuseMap :: (Map NontermIdent (Map Identifier (String,String,String)))
_lhsOwrappers :: (Set NontermIdent)
_lhsOattrDecls :: (Map NontermIdent (Attributes, Attributes))
_lhsOdefSets :: (Map Identifier (Set NontermIdent,Set Identifier))
-- "Transform.ag"(line 238, column 10)
_lhsOcollectedFields =
({-# LINE 238 "Transform.ag" #-}
map (\(x,y)->(name_, x, y)) _expanded
{-# LINE 3055 "Transform.hs" #-})
-- "Transform.ag"(line 494, column 11)
_lhsOcollectedNames =
({-# LINE 494 "Transform.ag" #-}
Set.singleton name_
{-# LINE 3060 "Transform.hs" #-})
-- "Transform.ag"(line 548, column 11)
_expanded =
({-# LINE 548 "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 3093 "Transform.hs" #-})
-- "Transform.ag"(line 577, column 11)
_argType =
({-# LINE 577 "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 3104 "Transform.hs" #-})
-- "Transform.ag"(line 584, column 11)
_lhsOtypeSyns =
({-# LINE 584 "Transform.ag" #-}
[(name_,_argType)]
{-# LINE 3109 "Transform.hs" #-})
-- "Transform.ag"(line 789, column 7)
_lhsOparamsCollect =
({-# LINE 789 "Transform.ag" #-}
if null params_
then Map.empty
else Map.singleton name_ params_
{-# LINE 3116 "Transform.hs" #-})
-- "Transform.ag"(line 812, column 7)
_lhsOctxCollect =
({-# LINE 812 "Transform.ag" #-}
if null ctx_
then Map.empty
else Map.singleton name_ ctx_
{-# LINE 3123 "Transform.hs" #-})
-- use rule "Transform.ag"(line 747, column 55)
_lhsOattrOrderCollect =
({-# LINE 747 "Transform.ag" #-}
Map.empty
{-# LINE 3128 "Transform.hs" #-})
-- use rule "Transform.ag"(line 44, column 19)
_lhsOblocks =
({-# LINE 44 "Transform.ag" #-}
Map.empty
{-# LINE 3133 "Transform.hs" #-})
-- use rule "Transform.ag"(line 153, column 32)
_lhsOcollectedArounds =
({-# LINE 153 "Transform.ag" #-}
[]
{-# LINE 3138 "Transform.hs" #-})
-- use rule "Transform.ag"(line 152, column 32)
_lhsOcollectedAugments =
({-# LINE 152 "Transform.ag" #-}
[]
{-# LINE 3143 "Transform.hs" #-})
-- use rule "Transform.ag"(line 92, column 48)
_lhsOcollectedConstructorsMap =
({-# LINE 92 "Transform.ag" #-}
Map.empty
{-# LINE 3148 "Transform.hs" #-})
-- use rule "Transform.ag"(line 150, column 32)
_lhsOcollectedInsts =
({-# LINE 150 "Transform.ag" #-}
[]
{-# LINE 3153 "Transform.hs" #-})
-- use rule "Transform.ag"(line 148, column 32)
_lhsOcollectedRules =
({-# LINE 148 "Transform.ag" #-}
[]
{-# LINE 3158 "Transform.hs" #-})
-- use rule "Transform.ag"(line 83, column 50)
_lhsOcollectedSetNames =
({-# LINE 83 "Transform.ag" #-}
Set.empty
{-# LINE 3163 "Transform.hs" #-})
-- use rule "Transform.ag"(line 149, column 32)
_lhsOcollectedSigs =
({-# LINE 149 "Transform.ag" #-}
[]
{-# LINE 3168 "Transform.hs" #-})
-- use rule "Transform.ag"(line 151, column 32)
_lhsOcollectedUniques =
({-# LINE 151 "Transform.ag" #-}
[]
{-# LINE 3173 "Transform.hs" #-})
-- use rule "Transform.ag"(line 827, column 33)
_lhsOderivings =
({-# LINE 827 "Transform.ag" #-}
Map.empty
{-# LINE 3178 "Transform.hs" #-})
-- use rule "Transform.ag"(line 42, column 19)
_lhsOerrors =
({-# LINE 42 "Transform.ag" #-}
Seq.empty
{-# LINE 3183 "Transform.hs" #-})
-- use rule "Transform.ag"(line 998, column 37)
_lhsOmoduleDecl =
({-# LINE 998 "Transform.ag" #-}
mzero
{-# LINE 3188 "Transform.hs" #-})
-- use rule "Transform.ag"(line 675, column 34)
_lhsOpragmas =
({-# LINE 675 "Transform.ag" #-}
id
{-# LINE 3193 "Transform.hs" #-})
-- use rule "Transform.ag"(line 719, column 56)
_lhsOsemPragmasCollect =
({-# LINE 719 "Transform.ag" #-}
Map.empty
{-# LINE 3198 "Transform.hs" #-})
-- use rule "Transform.ag"(line 135, column 15)
_lhsOuseMap =
({-# LINE 135 "Transform.ag" #-}
Map.empty
{-# LINE 3203 "Transform.hs" #-})
-- use rule "Transform.ag"(line 666, column 32)
_lhsOwrappers =
({-# LINE 666 "Transform.ag" #-}
Set.empty
{-# LINE 3208 "Transform.hs" #-})
-- copy rule (chain)
_lhsOattrDecls =
({-# LINE 134 "Transform.ag" #-}
_lhsIattrDecls
{-# LINE 3213 "Transform.hs" #-})
-- copy rule (chain)
_lhsOdefSets =
({-# LINE 102 "Transform.ag" #-}
_lhsIdefSets
{-# LINE 3218 "Transform.hs" #-})
in ( _lhsOattrDecls,_lhsOattrOrderCollect,_lhsOblocks,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedConstructorsMap,_lhsOcollectedFields,_lhsOcollectedInsts,_lhsOcollectedNames,_lhsOcollectedRules,_lhsOcollectedSetNames,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOctxCollect,_lhsOdefSets,_lhsOderivings,_lhsOerrors,_lhsOmoduleDecl,_lhsOparamsCollect,_lhsOpragmas,_lhsOsemPragmasCollect,_lhsOtypeSyns,_lhsOuseMap,_lhsOwrappers))) )
sem_Elem_Wrapper :: Pos ->
T_NontSet ->
T_Elem
sem_Elem_Wrapper pos_ (T_NontSet set_ ) =
(T_Elem (\ _lhsIallAttrDecls
_lhsIallConstructors
_lhsIallFields
_lhsIallNonterminals
_lhsIattrDecls
_lhsIdefSets
_lhsIdefinedSets ->
(let _lhsOwrappers :: (Set NontermIdent)
_lhsOattrOrderCollect :: AttrOrderMap
_lhsOblocks :: Blocks
_lhsOcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])
_lhsOcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])
_lhsOcollectedConstructorsMap :: (Map NontermIdent (Set ConstructorIdent))
_lhsOcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)])
_lhsOcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ])
_lhsOcollectedNames :: (Set Identifier)
_lhsOcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)])
_lhsOcollectedSetNames :: (Set Identifier)
_lhsOcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ])
_lhsOcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])
_lhsOctxCollect :: ContextMap
_lhsOderivings :: Derivings
_lhsOerrors :: (Seq Error)
_lhsOmoduleDecl :: (Maybe (String,String,String))
_lhsOparamsCollect :: ParamMap
_lhsOpragmas :: (Options -> Options)
_lhsOsemPragmasCollect :: PragmaMap
_lhsOtypeSyns :: TypeSyns
_lhsOuseMap :: (Map NontermIdent (Map Identifier (String,String,String)))
_lhsOattrDecls :: (Map NontermIdent (Attributes, Attributes))
_lhsOdefSets :: (Map Identifier (Set NontermIdent,Set Identifier))
_setOallFields :: DataTypes
_setOallNonterminals :: (Set NontermIdent)
_setOdefinedSets :: DefinedSets
_setIcollectedNames :: (Set Identifier)
_setIerrors :: (Seq Error)
_setInontSet :: (Set NontermIdent)
-- "Transform.ag"(line 669, column 13)
_lhsOwrappers =
({-# LINE 669 "Transform.ag" #-}
_setInontSet
{-# LINE 3265 "Transform.hs" #-})
-- use rule "Transform.ag"(line 747, column 55)
_lhsOattrOrderCollect =
({-# LINE 747 "Transform.ag" #-}
Map.empty
{-# LINE 3270 "Transform.hs" #-})
-- use rule "Transform.ag"(line 44, column 19)
_lhsOblocks =
({-# LINE 44 "Transform.ag" #-}
Map.empty
{-# LINE 3275 "Transform.hs" #-})
-- use rule "Transform.ag"(line 153, column 32)
_lhsOcollectedArounds =
({-# LINE 153 "Transform.ag" #-}
[]
{-# LINE 3280 "Transform.hs" #-})
-- use rule "Transform.ag"(line 152, column 32)
_lhsOcollectedAugments =
({-# LINE 152 "Transform.ag" #-}
[]
{-# LINE 3285 "Transform.hs" #-})
-- use rule "Transform.ag"(line 92, column 48)
_lhsOcollectedConstructorsMap =
({-# LINE 92 "Transform.ag" #-}
Map.empty
{-# LINE 3290 "Transform.hs" #-})
-- use rule "Transform.ag"(line 123, column 28)
_lhsOcollectedFields =
({-# LINE 123 "Transform.ag" #-}
[]
{-# LINE 3295 "Transform.hs" #-})
-- use rule "Transform.ag"(line 150, column 32)
_lhsOcollectedInsts =
({-# LINE 150 "Transform.ag" #-}
[]
{-# LINE 3300 "Transform.hs" #-})
-- use rule "Transform.ag"(line 84, column 50)
_lhsOcollectedNames =
({-# LINE 84 "Transform.ag" #-}
_setIcollectedNames
{-# LINE 3305 "Transform.hs" #-})
-- use rule "Transform.ag"(line 148, column 32)
_lhsOcollectedRules =
({-# LINE 148 "Transform.ag" #-}
[]
{-# LINE 3310 "Transform.hs" #-})
-- use rule "Transform.ag"(line 83, column 50)
_lhsOcollectedSetNames =
({-# LINE 83 "Transform.ag" #-}
Set.empty
{-# LINE 3315 "Transform.hs" #-})
-- use rule "Transform.ag"(line 149, column 32)
_lhsOcollectedSigs =
({-# LINE 149 "Transform.ag" #-}
[]
{-# LINE 3320 "Transform.hs" #-})
-- use rule "Transform.ag"(line 151, column 32)
_lhsOcollectedUniques =
({-# LINE 151 "Transform.ag" #-}
[]
{-# LINE 3325 "Transform.hs" #-})
-- use rule "Transform.ag"(line 802, column 34)
_lhsOctxCollect =
({-# LINE 802 "Transform.ag" #-}
Map.empty
{-# LINE 3330 "Transform.hs" #-})
-- use rule "Transform.ag"(line 827, column 33)
_lhsOderivings =
({-# LINE 827 "Transform.ag" #-}
Map.empty
{-# LINE 3335 "Transform.hs" #-})
-- use rule "Transform.ag"(line 42, column 19)
_lhsOerrors =
({-# LINE 42 "Transform.ag" #-}
_setIerrors
{-# LINE 3340 "Transform.hs" #-})
-- use rule "Transform.ag"(line 998, column 37)
_lhsOmoduleDecl =
({-# LINE 998 "Transform.ag" #-}
mzero
{-# LINE 3345 "Transform.hs" #-})
-- use rule "Transform.ag"(line 779, column 37)
_lhsOparamsCollect =
({-# LINE 779 "Transform.ag" #-}
Map.empty
{-# LINE 3350 "Transform.hs" #-})
-- use rule "Transform.ag"(line 675, column 34)
_lhsOpragmas =
({-# LINE 675 "Transform.ag" #-}
id
{-# LINE 3355 "Transform.hs" #-})
-- use rule "Transform.ag"(line 719, column 56)
_lhsOsemPragmasCollect =
({-# LINE 719 "Transform.ag" #-}
Map.empty
{-# LINE 3360 "Transform.hs" #-})
-- use rule "Transform.ag"(line 535, column 32)
_lhsOtypeSyns =
({-# LINE 535 "Transform.ag" #-}
[]
{-# LINE 3365 "Transform.hs" #-})
-- use rule "Transform.ag"(line 135, column 15)
_lhsOuseMap =
({-# LINE 135 "Transform.ag" #-}
Map.empty
{-# LINE 3370 "Transform.hs" #-})
-- copy rule (chain)
_lhsOattrDecls =
({-# LINE 134 "Transform.ag" #-}
_lhsIattrDecls
{-# LINE 3375 "Transform.hs" #-})
-- copy rule (chain)
_lhsOdefSets =
({-# LINE 102 "Transform.ag" #-}
_lhsIdefSets
{-# LINE 3380 "Transform.hs" #-})
-- copy rule (down)
_setOallFields =
({-# LINE 126 "Transform.ag" #-}
_lhsIallFields
{-# LINE 3385 "Transform.hs" #-})
-- copy rule (down)
_setOallNonterminals =
({-# LINE 86 "Transform.ag" #-}
_lhsIallNonterminals
{-# LINE 3390 "Transform.hs" #-})
-- copy rule (down)
_setOdefinedSets =
({-# LINE 105 "Transform.ag" #-}
_lhsIdefinedSets
{-# LINE 3395 "Transform.hs" #-})
( _setIcollectedNames,_setIerrors,_setInontSet) =
(set_ _setOallFields _setOallNonterminals _setOdefinedSets )
in ( _lhsOattrDecls,_lhsOattrOrderCollect,_lhsOblocks,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedConstructorsMap,_lhsOcollectedFields,_lhsOcollectedInsts,_lhsOcollectedNames,_lhsOcollectedRules,_lhsOcollectedSetNames,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOctxCollect,_lhsOdefSets,_lhsOderivings,_lhsOerrors,_lhsOmoduleDecl,_lhsOparamsCollect,_lhsOpragmas,_lhsOsemPragmasCollect,_lhsOtypeSyns,_lhsOuseMap,_lhsOwrappers))) )
-- Elems -------------------------------------------------------
{-
visit 0:
inherited attributes:
allAttrDecls : Map NontermIdent (Attributes, Attributes)
allConstructors : Map NontermIdent (Set ConstructorIdent)
allFields : DataTypes
allNonterminals : Set NontermIdent
definedSets : DefinedSets
chained attributes:
attrDecls : Map NontermIdent (Attributes, Attributes)
defSets : Map Identifier (Set NontermIdent,Set Identifier)
synthesized attributes:
attrOrderCollect : AttrOrderMap
blocks : Blocks
collectedArounds : [ (NontermIdent, ConstructorIdent, [AroundInfo]) ]
collectedAugments : [ (NontermIdent, ConstructorIdent, [AugmentInfo]) ]
collectedConstructorsMap : Map NontermIdent (Set ConstructorIdent)
collectedFields : [(NontermIdent, ConstructorIdent, FieldMap)]
collectedInsts : [ (NontermIdent, ConstructorIdent, [Identifier]) ]
collectedNames : Set Identifier
collectedRules : [ (NontermIdent, ConstructorIdent, RuleInfo)]
collectedSetNames : Set Identifier
collectedSigs : [ (NontermIdent, ConstructorIdent, SigInfo) ]
collectedUniques : [ (NontermIdent, ConstructorIdent, [UniqueInfo]) ]
ctxCollect : ContextMap
derivings : Derivings
errors : Seq Error
moduleDecl : Maybe (String,String,String)
paramsCollect : ParamMap
pragmas : Options -> Options
semPragmasCollect : PragmaMap
typeSyns : TypeSyns
useMap : Map NontermIdent (Map Identifier (String,String,String))
wrappers : Set NontermIdent
alternatives:
alternative Cons:
child hd : Elem
child tl : Elems
alternative Nil:
-}
-- cata
sem_Elems :: Elems ->
T_Elems
sem_Elems list =
(Prelude.foldr sem_Elems_Cons sem_Elems_Nil (Prelude.map sem_Elem list) )
-- semantic domain
newtype T_Elems = T_Elems ((Map NontermIdent (Attributes, Attributes)) ->
(Map NontermIdent (Set ConstructorIdent)) ->
DataTypes ->
(Set NontermIdent) ->
(Map NontermIdent (Attributes, Attributes)) ->
(Map Identifier (Set NontermIdent,Set Identifier)) ->
DefinedSets ->
( (Map NontermIdent (Attributes, Attributes)),AttrOrderMap,Blocks,([ (NontermIdent, ConstructorIdent, [AroundInfo]) ]),([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ]),(Map NontermIdent (Set ConstructorIdent)),([(NontermIdent, ConstructorIdent, FieldMap)]),([ (NontermIdent, ConstructorIdent, [Identifier]) ]),(Set Identifier),([ (NontermIdent, ConstructorIdent, RuleInfo)]),(Set Identifier),([ (NontermIdent, ConstructorIdent, SigInfo) ]),([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ]),ContextMap,(Map Identifier (Set NontermIdent,Set Identifier)),Derivings,(Seq Error),(Maybe (String,String,String)),ParamMap,(Options -> Options),PragmaMap,TypeSyns,(Map NontermIdent (Map Identifier (String,String,String))),(Set NontermIdent)))
data Inh_Elems = Inh_Elems {allAttrDecls_Inh_Elems :: !((Map NontermIdent (Attributes, Attributes))),allConstructors_Inh_Elems :: !((Map NontermIdent (Set ConstructorIdent))),allFields_Inh_Elems :: !(DataTypes),allNonterminals_Inh_Elems :: !((Set NontermIdent)),attrDecls_Inh_Elems :: !((Map NontermIdent (Attributes, Attributes))),defSets_Inh_Elems :: !((Map Identifier (Set NontermIdent,Set Identifier))),definedSets_Inh_Elems :: !(DefinedSets)}
data Syn_Elems = Syn_Elems {attrDecls_Syn_Elems :: !((Map NontermIdent (Attributes, Attributes))),attrOrderCollect_Syn_Elems :: !(AttrOrderMap),blocks_Syn_Elems :: !(Blocks),collectedArounds_Syn_Elems :: !(([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])),collectedAugments_Syn_Elems :: !(([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])),collectedConstructorsMap_Syn_Elems :: !((Map NontermIdent (Set ConstructorIdent))),collectedFields_Syn_Elems :: !(([(NontermIdent, ConstructorIdent, FieldMap)])),collectedInsts_Syn_Elems :: !(([ (NontermIdent, ConstructorIdent, [Identifier]) ])),collectedNames_Syn_Elems :: !((Set Identifier)),collectedRules_Syn_Elems :: !(([ (NontermIdent, ConstructorIdent, RuleInfo)])),collectedSetNames_Syn_Elems :: !((Set Identifier)),collectedSigs_Syn_Elems :: !(([ (NontermIdent, ConstructorIdent, SigInfo) ])),collectedUniques_Syn_Elems :: !(([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])),ctxCollect_Syn_Elems :: !(ContextMap),defSets_Syn_Elems :: !((Map Identifier (Set NontermIdent,Set Identifier))),derivings_Syn_Elems :: !(Derivings),errors_Syn_Elems :: !((Seq Error)),moduleDecl_Syn_Elems :: !((Maybe (String,String,String))),paramsCollect_Syn_Elems :: !(ParamMap),pragmas_Syn_Elems :: !((Options -> Options)),semPragmasCollect_Syn_Elems :: !(PragmaMap),typeSyns_Syn_Elems :: !(TypeSyns),useMap_Syn_Elems :: !((Map NontermIdent (Map Identifier (String,String,String)))),wrappers_Syn_Elems :: !((Set NontermIdent))}
wrap_Elems :: T_Elems ->
Inh_Elems ->
Syn_Elems
wrap_Elems (T_Elems sem ) (Inh_Elems _lhsIallAttrDecls _lhsIallConstructors _lhsIallFields _lhsIallNonterminals _lhsIattrDecls _lhsIdefSets _lhsIdefinedSets ) =
(let ( _lhsOattrDecls,_lhsOattrOrderCollect,_lhsOblocks,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedConstructorsMap,_lhsOcollectedFields,_lhsOcollectedInsts,_lhsOcollectedNames,_lhsOcollectedRules,_lhsOcollectedSetNames,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOctxCollect,_lhsOdefSets,_lhsOderivings,_lhsOerrors,_lhsOmoduleDecl,_lhsOparamsCollect,_lhsOpragmas,_lhsOsemPragmasCollect,_lhsOtypeSyns,_lhsOuseMap,_lhsOwrappers) =
(sem _lhsIallAttrDecls _lhsIallConstructors _lhsIallFields _lhsIallNonterminals _lhsIattrDecls _lhsIdefSets _lhsIdefinedSets )
in (Syn_Elems _lhsOattrDecls _lhsOattrOrderCollect _lhsOblocks _lhsOcollectedArounds _lhsOcollectedAugments _lhsOcollectedConstructorsMap _lhsOcollectedFields _lhsOcollectedInsts _lhsOcollectedNames _lhsOcollectedRules _lhsOcollectedSetNames _lhsOcollectedSigs _lhsOcollectedUniques _lhsOctxCollect _lhsOdefSets _lhsOderivings _lhsOerrors _lhsOmoduleDecl _lhsOparamsCollect _lhsOpragmas _lhsOsemPragmasCollect _lhsOtypeSyns _lhsOuseMap _lhsOwrappers ))
sem_Elems_Cons :: T_Elem ->
T_Elems ->
T_Elems
sem_Elems_Cons (T_Elem hd_ ) (T_Elems tl_ ) =
(T_Elems (\ _lhsIallAttrDecls
_lhsIallConstructors
_lhsIallFields
_lhsIallNonterminals
_lhsIattrDecls
_lhsIdefSets
_lhsIdefinedSets ->
(let _lhsOattrOrderCollect :: AttrOrderMap
_lhsOblocks :: Blocks
_lhsOcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])
_lhsOcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])
_lhsOcollectedConstructorsMap :: (Map NontermIdent (Set ConstructorIdent))
_lhsOcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)])
_lhsOcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ])
_lhsOcollectedNames :: (Set Identifier)
_lhsOcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)])
_lhsOcollectedSetNames :: (Set Identifier)
_lhsOcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ])
_lhsOcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])
_lhsOctxCollect :: ContextMap
_lhsOderivings :: Derivings
_lhsOerrors :: (Seq Error)
_lhsOmoduleDecl :: (Maybe (String,String,String))
_lhsOparamsCollect :: ParamMap
_lhsOpragmas :: (Options -> Options)
_lhsOsemPragmasCollect :: PragmaMap
_lhsOtypeSyns :: TypeSyns
_lhsOuseMap :: (Map NontermIdent (Map Identifier (String,String,String)))
_lhsOwrappers :: (Set NontermIdent)
_lhsOattrDecls :: (Map NontermIdent (Attributes, Attributes))
_lhsOdefSets :: (Map Identifier (Set NontermIdent,Set Identifier))
_hdOallAttrDecls :: (Map NontermIdent (Attributes, Attributes))
_hdOallConstructors :: (Map NontermIdent (Set ConstructorIdent))
_hdOallFields :: DataTypes
_hdOallNonterminals :: (Set NontermIdent)
_hdOattrDecls :: (Map NontermIdent (Attributes, Attributes))
_hdOdefSets :: (Map Identifier (Set NontermIdent,Set Identifier))
_hdOdefinedSets :: DefinedSets
_tlOallAttrDecls :: (Map NontermIdent (Attributes, Attributes))
_tlOallConstructors :: (Map NontermIdent (Set ConstructorIdent))
_tlOallFields :: DataTypes
_tlOallNonterminals :: (Set NontermIdent)
_tlOattrDecls :: (Map NontermIdent (Attributes, Attributes))
_tlOdefSets :: (Map Identifier (Set NontermIdent,Set Identifier))
_tlOdefinedSets :: DefinedSets
_hdIattrDecls :: (Map NontermIdent (Attributes, Attributes))
_hdIattrOrderCollect :: AttrOrderMap
_hdIblocks :: Blocks
_hdIcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])
_hdIcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])
_hdIcollectedConstructorsMap :: (Map NontermIdent (Set ConstructorIdent))
_hdIcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)])
_hdIcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ])
_hdIcollectedNames :: (Set Identifier)
_hdIcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)])
_hdIcollectedSetNames :: (Set Identifier)
_hdIcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ])
_hdIcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])
_hdIctxCollect :: ContextMap
_hdIdefSets :: (Map Identifier (Set NontermIdent,Set Identifier))
_hdIderivings :: Derivings
_hdIerrors :: (Seq Error)
_hdImoduleDecl :: (Maybe (String,String,String))
_hdIparamsCollect :: ParamMap
_hdIpragmas :: (Options -> Options)
_hdIsemPragmasCollect :: PragmaMap
_hdItypeSyns :: TypeSyns
_hdIuseMap :: (Map NontermIdent (Map Identifier (String,String,String)))
_hdIwrappers :: (Set NontermIdent)
_tlIattrDecls :: (Map NontermIdent (Attributes, Attributes))
_tlIattrOrderCollect :: AttrOrderMap
_tlIblocks :: Blocks
_tlIcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])
_tlIcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])
_tlIcollectedConstructorsMap :: (Map NontermIdent (Set ConstructorIdent))
_tlIcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)])
_tlIcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ])
_tlIcollectedNames :: (Set Identifier)
_tlIcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)])
_tlIcollectedSetNames :: (Set Identifier)
_tlIcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ])
_tlIcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])
_tlIctxCollect :: ContextMap
_tlIdefSets :: (Map Identifier (Set NontermIdent,Set Identifier))
_tlIderivings :: Derivings
_tlIerrors :: (Seq Error)
_tlImoduleDecl :: (Maybe (String,String,String))
_tlIparamsCollect :: ParamMap
_tlIpragmas :: (Options -> Options)
_tlIsemPragmasCollect :: PragmaMap
_tlItypeSyns :: TypeSyns
_tlIuseMap :: (Map NontermIdent (Map Identifier (String,String,String)))
_tlIwrappers :: (Set NontermIdent)
-- use rule "Transform.ag"(line 747, column 55)
_lhsOattrOrderCollect =
({-# LINE 747 "Transform.ag" #-}
_hdIattrOrderCollect `orderMapUnion` _tlIattrOrderCollect
{-# LINE 3564 "Transform.hs" #-})
-- use rule "Transform.ag"(line 44, column 19)
_lhsOblocks =
({-# LINE 44 "Transform.ag" #-}
_hdIblocks `mapUnionWithPlusPlus` _tlIblocks
{-# LINE 3569 "Transform.hs" #-})
-- use rule "Transform.ag"(line 153, column 32)
_lhsOcollectedArounds =
({-# LINE 153 "Transform.ag" #-}
_hdIcollectedArounds ++ _tlIcollectedArounds
{-# LINE 3574 "Transform.hs" #-})
-- use rule "Transform.ag"(line 152, column 32)
_lhsOcollectedAugments =
({-# LINE 152 "Transform.ag" #-}
_hdIcollectedAugments ++ _tlIcollectedAugments
{-# LINE 3579 "Transform.hs" #-})
-- use rule "Transform.ag"(line 92, column 48)
_lhsOcollectedConstructorsMap =
({-# LINE 92 "Transform.ag" #-}
_hdIcollectedConstructorsMap `mapUnionWithSetUnion` _tlIcollectedConstructorsMap
{-# LINE 3584 "Transform.hs" #-})
-- use rule "Transform.ag"(line 123, column 28)
_lhsOcollectedFields =
({-# LINE 123 "Transform.ag" #-}
_hdIcollectedFields ++ _tlIcollectedFields
{-# LINE 3589 "Transform.hs" #-})
-- use rule "Transform.ag"(line 150, column 32)
_lhsOcollectedInsts =
({-# LINE 150 "Transform.ag" #-}
_hdIcollectedInsts ++ _tlIcollectedInsts
{-# LINE 3594 "Transform.hs" #-})
-- use rule "Transform.ag"(line 84, column 50)
_lhsOcollectedNames =
({-# LINE 84 "Transform.ag" #-}
_hdIcollectedNames `Set.union` _tlIcollectedNames
{-# LINE 3599 "Transform.hs" #-})
-- use rule "Transform.ag"(line 148, column 32)
_lhsOcollectedRules =
({-# LINE 148 "Transform.ag" #-}
_hdIcollectedRules ++ _tlIcollectedRules
{-# LINE 3604 "Transform.hs" #-})
-- use rule "Transform.ag"(line 83, column 50)
_lhsOcollectedSetNames =
({-# LINE 83 "Transform.ag" #-}
_hdIcollectedSetNames `Set.union` _tlIcollectedSetNames
{-# LINE 3609 "Transform.hs" #-})
-- use rule "Transform.ag"(line 149, column 32)
_lhsOcollectedSigs =
({-# LINE 149 "Transform.ag" #-}
_hdIcollectedSigs ++ _tlIcollectedSigs
{-# LINE 3614 "Transform.hs" #-})
-- use rule "Transform.ag"(line 151, column 32)
_lhsOcollectedUniques =
({-# LINE 151 "Transform.ag" #-}
_hdIcollectedUniques ++ _tlIcollectedUniques
{-# LINE 3619 "Transform.hs" #-})
-- use rule "Transform.ag"(line 802, column 34)
_lhsOctxCollect =
({-# LINE 802 "Transform.ag" #-}
_hdIctxCollect `mergeCtx` _tlIctxCollect
{-# LINE 3624 "Transform.hs" #-})
-- use rule "Transform.ag"(line 827, column 33)
_lhsOderivings =
({-# LINE 827 "Transform.ag" #-}
_hdIderivings `mergeDerivings` _tlIderivings
{-# LINE 3629 "Transform.hs" #-})
-- use rule "Transform.ag"(line 42, column 19)
_lhsOerrors =
({-# LINE 42 "Transform.ag" #-}
_hdIerrors Seq.>< _tlIerrors
{-# LINE 3634 "Transform.hs" #-})
-- use rule "Transform.ag"(line 998, column 37)
_lhsOmoduleDecl =
({-# LINE 998 "Transform.ag" #-}
_hdImoduleDecl `mplus` _tlImoduleDecl
{-# LINE 3639 "Transform.hs" #-})
-- use rule "Transform.ag"(line 779, column 37)
_lhsOparamsCollect =
({-# LINE 779 "Transform.ag" #-}
_hdIparamsCollect `mergeParams` _tlIparamsCollect
{-# LINE 3644 "Transform.hs" #-})
-- use rule "Transform.ag"(line 675, column 34)
_lhsOpragmas =
({-# LINE 675 "Transform.ag" #-}
_hdIpragmas . _tlIpragmas
{-# LINE 3649 "Transform.hs" #-})
-- use rule "Transform.ag"(line 719, column 56)
_lhsOsemPragmasCollect =
({-# LINE 719 "Transform.ag" #-}
_hdIsemPragmasCollect `pragmaMapUnion` _tlIsemPragmasCollect
{-# LINE 3654 "Transform.hs" #-})
-- use rule "Transform.ag"(line 535, column 32)
_lhsOtypeSyns =
({-# LINE 535 "Transform.ag" #-}
_hdItypeSyns ++ _tlItypeSyns
{-# LINE 3659 "Transform.hs" #-})
-- use rule "Transform.ag"(line 135, column 15)
_lhsOuseMap =
({-# LINE 135 "Transform.ag" #-}
_hdIuseMap `merge` _tlIuseMap
{-# LINE 3664 "Transform.hs" #-})
-- use rule "Transform.ag"(line 666, column 32)
_lhsOwrappers =
({-# LINE 666 "Transform.ag" #-}
_hdIwrappers `Set.union` _tlIwrappers
{-# LINE 3669 "Transform.hs" #-})
-- copy rule (up)
_lhsOattrDecls =
({-# LINE 134 "Transform.ag" #-}
_tlIattrDecls
{-# LINE 3674 "Transform.hs" #-})
-- copy rule (up)
_lhsOdefSets =
({-# LINE 102 "Transform.ag" #-}
_tlIdefSets
{-# LINE 3679 "Transform.hs" #-})
-- copy rule (down)
_hdOallAttrDecls =
({-# LINE 748 "Transform.ag" #-}
_lhsIallAttrDecls
{-# LINE 3684 "Transform.hs" #-})
-- copy rule (down)
_hdOallConstructors =
({-# LINE 94 "Transform.ag" #-}
_lhsIallConstructors
{-# LINE 3689 "Transform.hs" #-})
-- copy rule (down)
_hdOallFields =
({-# LINE 126 "Transform.ag" #-}
_lhsIallFields
{-# LINE 3694 "Transform.hs" #-})
-- copy rule (down)
_hdOallNonterminals =
({-# LINE 86 "Transform.ag" #-}
_lhsIallNonterminals
{-# LINE 3699 "Transform.hs" #-})
-- copy rule (down)
_hdOattrDecls =
({-# LINE 134 "Transform.ag" #-}
_lhsIattrDecls
{-# LINE 3704 "Transform.hs" #-})
-- copy rule (down)
_hdOdefSets =
({-# LINE 102 "Transform.ag" #-}
_lhsIdefSets
{-# LINE 3709 "Transform.hs" #-})
-- copy rule (down)
_hdOdefinedSets =
({-# LINE 105 "Transform.ag" #-}
_lhsIdefinedSets
{-# LINE 3714 "Transform.hs" #-})
-- copy rule (down)
_tlOallAttrDecls =
({-# LINE 748 "Transform.ag" #-}
_lhsIallAttrDecls
{-# LINE 3719 "Transform.hs" #-})
-- copy rule (down)
_tlOallConstructors =
({-# LINE 94 "Transform.ag" #-}
_lhsIallConstructors
{-# LINE 3724 "Transform.hs" #-})
-- copy rule (down)
_tlOallFields =
({-# LINE 126 "Transform.ag" #-}
_lhsIallFields
{-# LINE 3729 "Transform.hs" #-})
-- copy rule (down)
_tlOallNonterminals =
({-# LINE 86 "Transform.ag" #-}
_lhsIallNonterminals
{-# LINE 3734 "Transform.hs" #-})
-- copy rule (chain)
_tlOattrDecls =
({-# LINE 134 "Transform.ag" #-}
_hdIattrDecls
{-# LINE 3739 "Transform.hs" #-})
-- copy rule (chain)
_tlOdefSets =
({-# LINE 102 "Transform.ag" #-}
_hdIdefSets
{-# LINE 3744 "Transform.hs" #-})
-- copy rule (down)
_tlOdefinedSets =
({-# LINE 105 "Transform.ag" #-}
_lhsIdefinedSets
{-# LINE 3749 "Transform.hs" #-})
( _hdIattrDecls,_hdIattrOrderCollect,_hdIblocks,_hdIcollectedArounds,_hdIcollectedAugments,_hdIcollectedConstructorsMap,_hdIcollectedFields,_hdIcollectedInsts,_hdIcollectedNames,_hdIcollectedRules,_hdIcollectedSetNames,_hdIcollectedSigs,_hdIcollectedUniques,_hdIctxCollect,_hdIdefSets,_hdIderivings,_hdIerrors,_hdImoduleDecl,_hdIparamsCollect,_hdIpragmas,_hdIsemPragmasCollect,_hdItypeSyns,_hdIuseMap,_hdIwrappers) =
(hd_ _hdOallAttrDecls _hdOallConstructors _hdOallFields _hdOallNonterminals _hdOattrDecls _hdOdefSets _hdOdefinedSets )
( _tlIattrDecls,_tlIattrOrderCollect,_tlIblocks,_tlIcollectedArounds,_tlIcollectedAugments,_tlIcollectedConstructorsMap,_tlIcollectedFields,_tlIcollectedInsts,_tlIcollectedNames,_tlIcollectedRules,_tlIcollectedSetNames,_tlIcollectedSigs,_tlIcollectedUniques,_tlIctxCollect,_tlIdefSets,_tlIderivings,_tlIerrors,_tlImoduleDecl,_tlIparamsCollect,_tlIpragmas,_tlIsemPragmasCollect,_tlItypeSyns,_tlIuseMap,_tlIwrappers) =
(tl_ _tlOallAttrDecls _tlOallConstructors _tlOallFields _tlOallNonterminals _tlOattrDecls _tlOdefSets _tlOdefinedSets )
in ( _lhsOattrDecls,_lhsOattrOrderCollect,_lhsOblocks,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedConstructorsMap,_lhsOcollectedFields,_lhsOcollectedInsts,_lhsOcollectedNames,_lhsOcollectedRules,_lhsOcollectedSetNames,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOctxCollect,_lhsOdefSets,_lhsOderivings,_lhsOerrors,_lhsOmoduleDecl,_lhsOparamsCollect,_lhsOpragmas,_lhsOsemPragmasCollect,_lhsOtypeSyns,_lhsOuseMap,_lhsOwrappers))) )
sem_Elems_Nil :: T_Elems
sem_Elems_Nil =
(T_Elems (\ _lhsIallAttrDecls
_lhsIallConstructors
_lhsIallFields
_lhsIallNonterminals
_lhsIattrDecls
_lhsIdefSets
_lhsIdefinedSets ->
(let _lhsOattrOrderCollect :: AttrOrderMap
_lhsOblocks :: Blocks
_lhsOcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])
_lhsOcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])
_lhsOcollectedConstructorsMap :: (Map NontermIdent (Set ConstructorIdent))
_lhsOcollectedFields :: ([(NontermIdent, ConstructorIdent, FieldMap)])
_lhsOcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ])
_lhsOcollectedNames :: (Set Identifier)
_lhsOcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)])
_lhsOcollectedSetNames :: (Set Identifier)
_lhsOcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ])
_lhsOcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])
_lhsOctxCollect :: ContextMap
_lhsOderivings :: Derivings
_lhsOerrors :: (Seq Error)
_lhsOmoduleDecl :: (Maybe (String,String,String))
_lhsOparamsCollect :: ParamMap
_lhsOpragmas :: (Options -> Options)
_lhsOsemPragmasCollect :: PragmaMap
_lhsOtypeSyns :: TypeSyns
_lhsOuseMap :: (Map NontermIdent (Map Identifier (String,String,String)))
_lhsOwrappers :: (Set NontermIdent)
_lhsOattrDecls :: (Map NontermIdent (Attributes, Attributes))
_lhsOdefSets :: (Map Identifier (Set NontermIdent,Set Identifier))
-- use rule "Transform.ag"(line 747, column 55)
_lhsOattrOrderCollect =
({-# LINE 747 "Transform.ag" #-}
Map.empty
{-# LINE 3792 "Transform.hs" #-})
-- use rule "Transform.ag"(line 44, column 19)
_lhsOblocks =
({-# LINE 44 "Transform.ag" #-}
Map.empty
{-# LINE 3797 "Transform.hs" #-})
-- use rule "Transform.ag"(line 153, column 32)
_lhsOcollectedArounds =
({-# LINE 153 "Transform.ag" #-}
[]
{-# LINE 3802 "Transform.hs" #-})
-- use rule "Transform.ag"(line 152, column 32)
_lhsOcollectedAugments =
({-# LINE 152 "Transform.ag" #-}
[]
{-# LINE 3807 "Transform.hs" #-})
-- use rule "Transform.ag"(line 92, column 48)
_lhsOcollectedConstructorsMap =
({-# LINE 92 "Transform.ag" #-}
Map.empty
{-# LINE 3812 "Transform.hs" #-})
-- use rule "Transform.ag"(line 123, column 28)
_lhsOcollectedFields =
({-# LINE 123 "Transform.ag" #-}
[]
{-# LINE 3817 "Transform.hs" #-})
-- use rule "Transform.ag"(line 150, column 32)
_lhsOcollectedInsts =
({-# LINE 150 "Transform.ag" #-}
[]
{-# LINE 3822 "Transform.hs" #-})
-- use rule "Transform.ag"(line 84, column 50)
_lhsOcollectedNames =
({-# LINE 84 "Transform.ag" #-}
Set.empty
{-# LINE 3827 "Transform.hs" #-})
-- use rule "Transform.ag"(line 148, column 32)
_lhsOcollectedRules =
({-# LINE 148 "Transform.ag" #-}
[]
{-# LINE 3832 "Transform.hs" #-})
-- use rule "Transform.ag"(line 83, column 50)
_lhsOcollectedSetNames =
({-# LINE 83 "Transform.ag" #-}
Set.empty
{-# LINE 3837 "Transform.hs" #-})
-- use rule "Transform.ag"(line 149, column 32)
_lhsOcollectedSigs =
({-# LINE 149 "Transform.ag" #-}
[]
{-# LINE 3842 "Transform.hs" #-})
-- use rule "Transform.ag"(line 151, column 32)
_lhsOcollectedUniques =
({-# LINE 151 "Transform.ag" #-}
[]
{-# LINE 3847 "Transform.hs" #-})
-- use rule "Transform.ag"(line 802, column 34)
_lhsOctxCollect =
({-# LINE 802 "Transform.ag" #-}
Map.empty
{-# LINE 3852 "Transform.hs" #-})
-- use rule "Transform.ag"(line 827, column 33)
_lhsOderivings =
({-# LINE 827 "Transform.ag" #-}
Map.empty
{-# LINE 3857 "Transform.hs" #-})
-- use rule "Transform.ag"(line 42, column 19)
_lhsOerrors =
({-# LINE 42 "Transform.ag" #-}
Seq.empty
{-# LINE 3862 "Transform.hs" #-})
-- use rule "Transform.ag"(line 998, column 37)
_lhsOmoduleDecl =
({-# LINE 998 "Transform.ag" #-}
mzero
{-# LINE 3867 "Transform.hs" #-})
-- use rule "Transform.ag"(line 779, column 37)
_lhsOparamsCollect =
({-# LINE 779 "Transform.ag" #-}
Map.empty
{-# LINE 3872 "Transform.hs" #-})
-- use rule "Transform.ag"(line 675, column 34)
_lhsOpragmas =
({-# LINE 675 "Transform.ag" #-}
id
{-# LINE 3877 "Transform.hs" #-})
-- use rule "Transform.ag"(line 719, column 56)
_lhsOsemPragmasCollect =
({-# LINE 719 "Transform.ag" #-}
Map.empty
{-# LINE 3882 "Transform.hs" #-})
-- use rule "Transform.ag"(line 535, column 32)
_lhsOtypeSyns =
({-# LINE 535 "Transform.ag" #-}
[]
{-# LINE 3887 "Transform.hs" #-})
-- use rule "Transform.ag"(line 135, column 15)
_lhsOuseMap =
({-# LINE 135 "Transform.ag" #-}
Map.empty
{-# LINE 3892 "Transform.hs" #-})
-- use rule "Transform.ag"(line 666, column 32)
_lhsOwrappers =
({-# LINE 666 "Transform.ag" #-}
Set.empty
{-# LINE 3897 "Transform.hs" #-})
-- copy rule (chain)
_lhsOattrDecls =
({-# LINE 134 "Transform.ag" #-}
_lhsIattrDecls
{-# LINE 3902 "Transform.hs" #-})
-- copy rule (chain)
_lhsOdefSets =
({-# LINE 102 "Transform.ag" #-}
_lhsIdefSets
{-# LINE 3907 "Transform.hs" #-})
in ( _lhsOattrDecls,_lhsOattrOrderCollect,_lhsOblocks,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedConstructorsMap,_lhsOcollectedFields,_lhsOcollectedInsts,_lhsOcollectedNames,_lhsOcollectedRules,_lhsOcollectedSetNames,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOctxCollect,_lhsOdefSets,_lhsOderivings,_lhsOerrors,_lhsOmoduleDecl,_lhsOparamsCollect,_lhsOpragmas,_lhsOsemPragmasCollect,_lhsOtypeSyns,_lhsOuseMap,_lhsOwrappers))) )
-- NontSet -----------------------------------------------------
{-
visit 0:
inherited attributes:
allFields : DataTypes
allNonterminals : Set NontermIdent
definedSets : DefinedSets
synthesized attributes:
collectedNames : Set Identifier
errors : Seq Error
nontSet : Set NontermIdent
alternatives:
alternative All:
alternative Difference:
child set1 : NontSet
child set2 : NontSet
alternative Intersect:
child set1 : NontSet
child set2 : NontSet
alternative NamedSet:
child name : {NontermIdent}
visit 0:
local _tup4 : _
local nontSet : _
local errors : _
alternative Path:
child from : {NontermIdent}
child to : {NontermIdent}
alternative Union:
child set1 : NontSet
child set2 : NontSet
-}
-- cata
sem_NontSet :: NontSet ->
T_NontSet
sem_NontSet (All ) =
(sem_NontSet_All )
sem_NontSet (Difference _set1 _set2 ) =
(sem_NontSet_Difference (sem_NontSet _set1 ) (sem_NontSet _set2 ) )
sem_NontSet (Intersect _set1 _set2 ) =
(sem_NontSet_Intersect (sem_NontSet _set1 ) (sem_NontSet _set2 ) )
sem_NontSet (NamedSet _name ) =
(sem_NontSet_NamedSet _name )
sem_NontSet (Path _from _to ) =
(sem_NontSet_Path _from _to )
sem_NontSet (Union _set1 _set2 ) =
(sem_NontSet_Union (sem_NontSet _set1 ) (sem_NontSet _set2 ) )
-- semantic domain
newtype T_NontSet = T_NontSet (DataTypes ->
(Set NontermIdent) ->
DefinedSets ->
( (Set Identifier),(Seq Error),(Set NontermIdent)))
data Inh_NontSet = Inh_NontSet {allFields_Inh_NontSet :: !(DataTypes),allNonterminals_Inh_NontSet :: !((Set NontermIdent)),definedSets_Inh_NontSet :: !(DefinedSets)}
data Syn_NontSet = Syn_NontSet {collectedNames_Syn_NontSet :: !((Set Identifier)),errors_Syn_NontSet :: !((Seq Error)),nontSet_Syn_NontSet :: !((Set NontermIdent))}
wrap_NontSet :: T_NontSet ->
Inh_NontSet ->
Syn_NontSet
wrap_NontSet (T_NontSet sem ) (Inh_NontSet _lhsIallFields _lhsIallNonterminals _lhsIdefinedSets ) =
(let ( _lhsOcollectedNames,_lhsOerrors,_lhsOnontSet) =
(sem _lhsIallFields _lhsIallNonterminals _lhsIdefinedSets )
in (Syn_NontSet _lhsOcollectedNames _lhsOerrors _lhsOnontSet ))
sem_NontSet_All :: T_NontSet
sem_NontSet_All =
(T_NontSet (\ _lhsIallFields
_lhsIallNonterminals
_lhsIdefinedSets ->
(let _lhsOnontSet :: (Set NontermIdent)
_lhsOcollectedNames :: (Set Identifier)
_lhsOerrors :: (Seq Error)
-- "Transform.ag"(line 612, column 16)
_lhsOnontSet =
({-# LINE 612 "Transform.ag" #-}
_lhsIallNonterminals
{-# LINE 3982 "Transform.hs" #-})
-- use rule "Transform.ag"(line 84, column 50)
_lhsOcollectedNames =
({-# LINE 84 "Transform.ag" #-}
Set.empty
{-# LINE 3987 "Transform.hs" #-})
-- use rule "Transform.ag"(line 42, column 19)
_lhsOerrors =
({-# LINE 42 "Transform.ag" #-}
Seq.empty
{-# LINE 3992 "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 618, column 16)
_lhsOnontSet =
({-# LINE 618 "Transform.ag" #-}
Set.difference _set1InontSet _set2InontSet
{-# LINE 4020 "Transform.hs" #-})
-- use rule "Transform.ag"(line 84, column 50)
_lhsOcollectedNames =
({-# LINE 84 "Transform.ag" #-}
_set1IcollectedNames `Set.union` _set2IcollectedNames
{-# LINE 4025 "Transform.hs" #-})
-- use rule "Transform.ag"(line 42, column 19)
_lhsOerrors =
({-# LINE 42 "Transform.ag" #-}
_set1Ierrors Seq.>< _set2Ierrors
{-# LINE 4030 "Transform.hs" #-})
-- copy rule (down)
_set1OallFields =
({-# LINE 126 "Transform.ag" #-}
_lhsIallFields
{-# LINE 4035 "Transform.hs" #-})
-- copy rule (down)
_set1OallNonterminals =
({-# LINE 86 "Transform.ag" #-}
_lhsIallNonterminals
{-# LINE 4040 "Transform.hs" #-})
-- copy rule (down)
_set1OdefinedSets =
({-# LINE 105 "Transform.ag" #-}
_lhsIdefinedSets
{-# LINE 4045 "Transform.hs" #-})
-- copy rule (down)
_set2OallFields =
({-# LINE 126 "Transform.ag" #-}
_lhsIallFields
{-# LINE 4050 "Transform.hs" #-})
-- copy rule (down)
_set2OallNonterminals =
({-# LINE 86 "Transform.ag" #-}
_lhsIallNonterminals
{-# LINE 4055 "Transform.hs" #-})
-- copy rule (down)
_set2OdefinedSets =
({-# LINE 105 "Transform.ag" #-}
_lhsIdefinedSets
{-# LINE 4060 "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 617, column 16)
_lhsOnontSet =
({-# LINE 617 "Transform.ag" #-}
Set.intersection _set1InontSet _set2InontSet
{-# LINE 4092 "Transform.hs" #-})
-- use rule "Transform.ag"(line 84, column 50)
_lhsOcollectedNames =
({-# LINE 84 "Transform.ag" #-}
_set1IcollectedNames `Set.union` _set2IcollectedNames
{-# LINE 4097 "Transform.hs" #-})
-- use rule "Transform.ag"(line 42, column 19)
_lhsOerrors =
({-# LINE 42 "Transform.ag" #-}
_set1Ierrors Seq.>< _set2Ierrors
{-# LINE 4102 "Transform.hs" #-})
-- copy rule (down)
_set1OallFields =
({-# LINE 126 "Transform.ag" #-}
_lhsIallFields
{-# LINE 4107 "Transform.hs" #-})
-- copy rule (down)
_set1OallNonterminals =
({-# LINE 86 "Transform.ag" #-}
_lhsIallNonterminals
{-# LINE 4112 "Transform.hs" #-})
-- copy rule (down)
_set1OdefinedSets =
({-# LINE 105 "Transform.ag" #-}
_lhsIdefinedSets
{-# LINE 4117 "Transform.hs" #-})
-- copy rule (down)
_set2OallFields =
({-# LINE 126 "Transform.ag" #-}
_lhsIallFields
{-# LINE 4122 "Transform.hs" #-})
-- copy rule (down)
_set2OallNonterminals =
({-# LINE 86 "Transform.ag" #-}
_lhsIallNonterminals
{-# LINE 4127 "Transform.hs" #-})
-- copy rule (down)
_set2OdefinedSets =
({-# LINE 105 "Transform.ag" #-}
_lhsIdefinedSets
{-# LINE 4132 "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 497, column 14)
_lhsOcollectedNames =
({-# LINE 497 "Transform.ag" #-}
Set.singleton name_
{-# LINE 4151 "Transform.hs" #-})
-- "Transform.ag"(line 613, column 20)
__tup4 =
({-# LINE 613 "Transform.ag" #-}
case Map.lookup name_ _lhsIdefinedSets of
Nothing -> (Set.empty, Seq.singleton (UndefNont name_))
Just set -> (set, Seq.empty)
{-# LINE 4158 "Transform.hs" #-})
-- "Transform.ag"(line 613, column 20)
(_nontSet,_) =
({-# LINE 613 "Transform.ag" #-}
__tup4
{-# LINE 4163 "Transform.hs" #-})
-- "Transform.ag"(line 613, column 20)
(_,_errors) =
({-# LINE 613 "Transform.ag" #-}
__tup4
{-# LINE 4168 "Transform.hs" #-})
-- use rule "Transform.ag"(line 42, column 19)
_lhsOerrors =
({-# LINE 42 "Transform.ag" #-}
_errors
{-# LINE 4173 "Transform.hs" #-})
-- copy rule (from local)
_lhsOnontSet =
({-# LINE 110 "Transform.ag" #-}
_nontSet
{-# LINE 4178 "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 619, column 16)
_lhsOnontSet =
({-# LINE 619 "Transform.ag" #-}
let table = flattenDatas _lhsIallFields
in path table from_ to_
{-# LINE 4195 "Transform.hs" #-})
-- "Transform.ag"(line 621, column 16)
_lhsOerrors =
({-# LINE 621 "Transform.ag" #-}
let check name | Set.member name _lhsIallNonterminals
= Seq.empty
| otherwise = Seq.singleton (UndefNont name)
in check from_ >< check to_
{-# LINE 4203 "Transform.hs" #-})
-- use rule "Transform.ag"(line 84, column 50)
_lhsOcollectedNames =
({-# LINE 84 "Transform.ag" #-}
Set.empty
{-# LINE 4208 "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 616, column 16)
_lhsOnontSet =
({-# LINE 616 "Transform.ag" #-}
Set.union _set1InontSet _set2InontSet
{-# LINE 4236 "Transform.hs" #-})
-- use rule "Transform.ag"(line 84, column 50)
_lhsOcollectedNames =
({-# LINE 84 "Transform.ag" #-}
_set1IcollectedNames `Set.union` _set2IcollectedNames
{-# LINE 4241 "Transform.hs" #-})
-- use rule "Transform.ag"(line 42, column 19)
_lhsOerrors =
({-# LINE 42 "Transform.ag" #-}
_set1Ierrors Seq.>< _set2Ierrors
{-# LINE 4246 "Transform.hs" #-})
-- copy rule (down)
_set1OallFields =
({-# LINE 126 "Transform.ag" #-}
_lhsIallFields
{-# LINE 4251 "Transform.hs" #-})
-- copy rule (down)
_set1OallNonterminals =
({-# LINE 86 "Transform.ag" #-}
_lhsIallNonterminals
{-# LINE 4256 "Transform.hs" #-})
-- copy rule (down)
_set1OdefinedSets =
({-# LINE 105 "Transform.ag" #-}
_lhsIdefinedSets
{-# LINE 4261 "Transform.hs" #-})
-- copy rule (down)
_set2OallFields =
({-# LINE 126 "Transform.ag" #-}
_lhsIallFields
{-# LINE 4266 "Transform.hs" #-})
-- copy rule (down)
_set2OallNonterminals =
({-# LINE 86 "Transform.ag" #-}
_lhsIallNonterminals
{-# LINE 4271 "Transform.hs" #-})
-- copy rule (down)
_set2OdefinedSets =
({-# LINE 105 "Transform.ag" #-}
_lhsIdefinedSets
{-# LINE 4276 "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 974, column 11)
_lhsOdefinedAttrs =
({-# LINE 974 "Transform.ag" #-}
(field_, attr_) : _patIdefinedAttrs
{-# LINE 4366 "Transform.hs" #-})
-- "Transform.ag"(line 975, column 11)
_lhsOpatunder =
({-# LINE 975 "Transform.ag" #-}
\us -> if ((field_,attr_) `elem` us) then Underscore noPos else _copy
{-# LINE 4371 "Transform.hs" #-})
-- "Transform.ag"(line 976, column 11)
_lhsOdefinedInsts =
({-# LINE 976 "Transform.ag" #-}
(if field_ == _INST then [attr_] else []) ++ _patIdefinedInsts
{-# LINE 4376 "Transform.hs" #-})
-- "Transform.ag"(line 991, column 16)
_lhsOstpos =
({-# LINE 991 "Transform.ag" #-}
getPos field_
{-# LINE 4381 "Transform.hs" #-})
-- self rule
_copy =
({-# LINE 23 "./Patterns.ag" #-}
Alias field_ attr_ _patIcopy _partsIcopy
{-# LINE 4386 "Transform.hs" #-})
-- self rule
_lhsOcopy =
({-# LINE 23 "./Patterns.ag" #-}
_copy
{-# LINE 4391 "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 978, column 12)
_lhsOpatunder =
({-# LINE 978 "Transform.ag" #-}
\us -> Constr name_ (_patsIpatunder us)
{-# LINE 4414 "Transform.hs" #-})
-- "Transform.ag"(line 989, column 16)
_lhsOstpos =
({-# LINE 989 "Transform.ag" #-}
getPos name_
{-# LINE 4419 "Transform.hs" #-})
-- use rule "Transform.ag"(line 969, column 42)
_lhsOdefinedAttrs =
({-# LINE 969 "Transform.ag" #-}
_patsIdefinedAttrs
{-# LINE 4424 "Transform.hs" #-})
-- use rule "Transform.ag"(line 968, column 55)
_lhsOdefinedInsts =
({-# LINE 968 "Transform.ag" #-}
_patsIdefinedInsts
{-# LINE 4429 "Transform.hs" #-})
-- self rule
_copy =
({-# LINE 23 "./Patterns.ag" #-}
Constr name_ _patsIcopy
{-# LINE 4434 "Transform.hs" #-})
-- self rule
_lhsOcopy =
({-# LINE 23 "./Patterns.ag" #-}
_copy
{-# LINE 4439 "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 980, column 17)
_lhsOpatunder =
({-# LINE 980 "Transform.ag" #-}
\us -> Irrefutable (_patIpatunder us)
{-# LINE 4460 "Transform.hs" #-})
-- use rule "Transform.ag"(line 969, column 42)
_lhsOdefinedAttrs =
({-# LINE 969 "Transform.ag" #-}
_patIdefinedAttrs
{-# LINE 4465 "Transform.hs" #-})
-- use rule "Transform.ag"(line 968, column 55)
_lhsOdefinedInsts =
({-# LINE 968 "Transform.ag" #-}
_patIdefinedInsts
{-# LINE 4470 "Transform.hs" #-})
-- self rule
_copy =
({-# LINE 23 "./Patterns.ag" #-}
Irrefutable _patIcopy
{-# LINE 4475 "Transform.hs" #-})
-- self rule
_lhsOcopy =
({-# LINE 23 "./Patterns.ag" #-}
_copy
{-# LINE 4480 "Transform.hs" #-})
-- copy rule (up)
_lhsOstpos =
({-# LINE 986 "Transform.ag" #-}
_patIstpos
{-# LINE 4485 "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 979, column 13)
_lhsOpatunder =
({-# LINE 979 "Transform.ag" #-}
\us -> Product pos_ (_patsIpatunder us)
{-# LINE 4506 "Transform.hs" #-})
-- "Transform.ag"(line 990, column 16)
_lhsOstpos =
({-# LINE 990 "Transform.ag" #-}
pos_
{-# LINE 4511 "Transform.hs" #-})
-- use rule "Transform.ag"(line 969, column 42)
_lhsOdefinedAttrs =
({-# LINE 969 "Transform.ag" #-}
_patsIdefinedAttrs
{-# LINE 4516 "Transform.hs" #-})
-- use rule "Transform.ag"(line 968, column 55)
_lhsOdefinedInsts =
({-# LINE 968 "Transform.ag" #-}
_patsIdefinedInsts
{-# LINE 4521 "Transform.hs" #-})
-- self rule
_copy =
({-# LINE 23 "./Patterns.ag" #-}
Product pos_ _patsIcopy
{-# LINE 4526 "Transform.hs" #-})
-- self rule
_lhsOcopy =
({-# LINE 23 "./Patterns.ag" #-}
_copy
{-# LINE 4531 "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 977, column 16)
_lhsOpatunder =
({-# LINE 977 "Transform.ag" #-}
\us -> _copy
{-# LINE 4547 "Transform.hs" #-})
-- "Transform.ag"(line 992, column 16)
_lhsOstpos =
({-# LINE 992 "Transform.ag" #-}
pos_
{-# LINE 4552 "Transform.hs" #-})
-- use rule "Transform.ag"(line 969, column 42)
_lhsOdefinedAttrs =
({-# LINE 969 "Transform.ag" #-}
[]
{-# LINE 4557 "Transform.hs" #-})
-- use rule "Transform.ag"(line 968, column 55)
_lhsOdefinedInsts =
({-# LINE 968 "Transform.ag" #-}
[]
{-# LINE 4562 "Transform.hs" #-})
-- self rule
_copy =
({-# LINE 23 "./Patterns.ag" #-}
Underscore pos_
{-# LINE 4567 "Transform.hs" #-})
-- self rule
_lhsOcopy =
({-# LINE 23 "./Patterns.ag" #-}
_copy
{-# LINE 4572 "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 984, column 10)
_lhsOpatunder =
({-# LINE 984 "Transform.ag" #-}
\us -> (_hdIpatunder us) : (_tlIpatunder us)
{-# LINE 4629 "Transform.hs" #-})
-- use rule "Transform.ag"(line 969, column 42)
_lhsOdefinedAttrs =
({-# LINE 969 "Transform.ag" #-}
_hdIdefinedAttrs ++ _tlIdefinedAttrs
{-# LINE 4634 "Transform.hs" #-})
-- use rule "Transform.ag"(line 968, column 55)
_lhsOdefinedInsts =
({-# LINE 968 "Transform.ag" #-}
_hdIdefinedInsts ++ _tlIdefinedInsts
{-# LINE 4639 "Transform.hs" #-})
-- self rule
_copy =
({-# LINE 23 "./Patterns.ag" #-}
(:) _hdIcopy _tlIcopy
{-# LINE 4644 "Transform.hs" #-})
-- self rule
_lhsOcopy =
({-# LINE 23 "./Patterns.ag" #-}
_copy
{-# LINE 4649 "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 983, column 9)
_lhsOpatunder =
({-# LINE 983 "Transform.ag" #-}
\us -> []
{-# LINE 4665 "Transform.hs" #-})
-- use rule "Transform.ag"(line 969, column 42)
_lhsOdefinedAttrs =
({-# LINE 969 "Transform.ag" #-}
[]
{-# LINE 4670 "Transform.hs" #-})
-- use rule "Transform.ag"(line 968, column 55)
_lhsOdefinedInsts =
({-# LINE 968 "Transform.ag" #-}
[]
{-# LINE 4675 "Transform.hs" #-})
-- self rule
_copy =
({-# LINE 23 "./Patterns.ag" #-}
[]
{-# LINE 4680 "Transform.hs" #-})
-- self rule
_lhsOcopy =
({-# LINE 23 "./Patterns.ag" #-}
_copy
{-# LINE 4685 "Transform.hs" #-})
in ( _lhsOcopy,_lhsOdefinedAttrs,_lhsOdefinedInsts,_lhsOpatunder)) )
-- SemAlt ------------------------------------------------------
{-
visit 0:
inherited attributes:
allAttrDecls : Map NontermIdent (Attributes, Attributes)
allFields : DataTypes
nts : Set NontermIdent
synthesized attributes:
attrOrderCollect : AttrOrderMap
collectedArounds : [ (NontermIdent, ConstructorIdent, [AroundInfo]) ]
collectedAugments : [ (NontermIdent, ConstructorIdent, [AugmentInfo]) ]
collectedInsts : [ (NontermIdent, ConstructorIdent, [Identifier]) ]
collectedRules : [ (NontermIdent, ConstructorIdent, RuleInfo)]
collectedSigs : [ (NontermIdent, ConstructorIdent, SigInfo) ]
collectedUniques : [ (NontermIdent, ConstructorIdent, [UniqueInfo]) ]
errors : Seq Error
semPragmasCollect : PragmaMap
alternatives:
alternative SemAlt:
child pos : {Pos}
child constructorSet : ConstructorSet
child rules : SemDefs
visit 0:
local pragmaNames : _
local attrOrders : _
local coninfo : _
-}
-- cata
sem_SemAlt :: SemAlt ->
T_SemAlt
sem_SemAlt (SemAlt _pos _constructorSet _rules ) =
(sem_SemAlt_SemAlt _pos (sem_ConstructorSet _constructorSet ) (sem_SemDefs _rules ) )
-- semantic domain
newtype T_SemAlt = T_SemAlt ((Map NontermIdent (Attributes, Attributes)) ->
DataTypes ->
(Set NontermIdent) ->
( AttrOrderMap,([ (NontermIdent, ConstructorIdent, [AroundInfo]) ]),([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ]),([ (NontermIdent, ConstructorIdent, [Identifier]) ]),([ (NontermIdent, ConstructorIdent, RuleInfo)]),([ (NontermIdent, ConstructorIdent, SigInfo) ]),([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ]),(Seq Error),PragmaMap))
data Inh_SemAlt = Inh_SemAlt {allAttrDecls_Inh_SemAlt :: !((Map NontermIdent (Attributes, Attributes))),allFields_Inh_SemAlt :: !(DataTypes),nts_Inh_SemAlt :: !((Set NontermIdent))}
data Syn_SemAlt = Syn_SemAlt {attrOrderCollect_Syn_SemAlt :: !(AttrOrderMap),collectedArounds_Syn_SemAlt :: !(([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])),collectedAugments_Syn_SemAlt :: !(([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])),collectedInsts_Syn_SemAlt :: !(([ (NontermIdent, ConstructorIdent, [Identifier]) ])),collectedRules_Syn_SemAlt :: !(([ (NontermIdent, ConstructorIdent, RuleInfo)])),collectedSigs_Syn_SemAlt :: !(([ (NontermIdent, ConstructorIdent, SigInfo) ])),collectedUniques_Syn_SemAlt :: !(([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])),errors_Syn_SemAlt :: !((Seq Error)),semPragmasCollect_Syn_SemAlt :: !(PragmaMap)}
wrap_SemAlt :: T_SemAlt ->
Inh_SemAlt ->
Syn_SemAlt
wrap_SemAlt (T_SemAlt sem ) (Inh_SemAlt _lhsIallAttrDecls _lhsIallFields _lhsInts ) =
(let ( _lhsOattrOrderCollect,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedInsts,_lhsOcollectedRules,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOerrors,_lhsOsemPragmasCollect) =
(sem _lhsIallAttrDecls _lhsIallFields _lhsInts )
in (Syn_SemAlt _lhsOattrOrderCollect _lhsOcollectedArounds _lhsOcollectedAugments _lhsOcollectedInsts _lhsOcollectedRules _lhsOcollectedSigs _lhsOcollectedUniques _lhsOerrors _lhsOsemPragmasCollect ))
sem_SemAlt_SemAlt :: Pos ->
T_ConstructorSet ->
T_SemDefs ->
T_SemAlt
sem_SemAlt_SemAlt pos_ (T_ConstructorSet constructorSet_ ) (T_SemDefs rules_ ) =
(T_SemAlt (\ _lhsIallAttrDecls
_lhsIallFields
_lhsInts ->
(let _lhsOsemPragmasCollect :: PragmaMap
_lhsOattrOrderCollect :: AttrOrderMap
_lhsOerrors :: (Seq Error)
_lhsOcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)])
_lhsOcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ])
_lhsOcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ])
_lhsOcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])
_lhsOcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])
_lhsOcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])
_constructorSetIcollectedConstructorNames :: (Set ConstructorIdent)
_constructorSetIconstructors :: ((Set ConstructorIdent->Set ConstructorIdent))
_constructorSetIerrors :: (Seq Error)
_rulesIaroundInfos :: ([AroundInfo])
_rulesIaugmentInfos :: ([AugmentInfo])
_rulesIdefinedInsts :: ([Identifier])
_rulesIorderDepsCollect :: (Set Dependency)
_rulesIpragmaNamesCollect :: ([Identifier])
_rulesIruleInfos :: ([RuleInfo])
_rulesIsigInfos :: ([SigInfo])
_rulesIuniqueInfos :: ([UniqueInfo])
-- "Transform.ag"(line 723, column 7)
_pragmaNames =
({-# LINE 723 "Transform.ag" #-}
Set.fromList _rulesIpragmaNamesCollect
{-# LINE 4765 "Transform.hs" #-})
-- "Transform.ag"(line 724, column 7)
_lhsOsemPragmasCollect =
({-# LINE 724 "Transform.ag" #-}
foldr pragmaMapUnion Map.empty [ pragmaMapSingle nt con _pragmaNames
| (nt, conset, _) <- _coninfo
, con <- Set.toList conset
]
{-# LINE 4773 "Transform.hs" #-})
-- "Transform.ag"(line 752, column 7)
_attrOrders =
({-# LINE 752 "Transform.ag" #-}
[ orderMapSingle nt con _rulesIorderDepsCollect
| (nt, conset, _) <- _coninfo
, con <- Set.toList conset
]
{-# LINE 4781 "Transform.hs" #-})
-- "Transform.ag"(line 758, column 7)
_lhsOattrOrderCollect =
({-# LINE 758 "Transform.ag" #-}
foldr orderMapUnion Map.empty _attrOrders
{-# LINE 4786 "Transform.hs" #-})
-- "Transform.ag"(line 903, column 12)
_coninfo =
({-# LINE 903 "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 4796 "Transform.hs" #-})
-- "Transform.ag"(line 910, column 12)
_lhsOerrors =
({-# LINE 910 "Transform.ag" #-}
Seq.fromList
[ UndefAlt nt con
| (nt, conset, conkeys) <- _coninfo
, con <- Set.toList (Set.difference conset conkeys)
]
{-# LINE 4805 "Transform.hs" #-})
-- "Transform.ag"(line 915, column 12)
_lhsOcollectedRules =
({-# LINE 915 "Transform.ag" #-}
[ (nt,con,r)
| (nt, conset, _) <- _coninfo
, con <- Set.toList conset
, r <- _rulesIruleInfos
]
{-# LINE 4814 "Transform.hs" #-})
-- "Transform.ag"(line 921, column 12)
_lhsOcollectedSigs =
({-# LINE 921 "Transform.ag" #-}
[ (nt,con,ts)
| (nt, conset, _) <- _coninfo
, con <- Set.toList conset
, ts <- _rulesIsigInfos
]
{-# LINE 4823 "Transform.hs" #-})
-- "Transform.ag"(line 928, column 12)
_lhsOcollectedInsts =
({-# LINE 928 "Transform.ag" #-}
[ (nt,con,_rulesIdefinedInsts)
| (nt, conset, _) <- _coninfo
, con <- Set.toList conset
]
{-# LINE 4831 "Transform.hs" #-})
-- "Transform.ag"(line 934, column 12)
_lhsOcollectedUniques =
({-# LINE 934 "Transform.ag" #-}
[ (nt,con,_rulesIuniqueInfos)
| (nt, conset, _) <- _coninfo
, con <- Set.toList conset
]
{-# LINE 4839 "Transform.hs" #-})
-- "Transform.ag"(line 940, column 12)
_lhsOcollectedAugments =
({-# LINE 940 "Transform.ag" #-}
[ (nt, con, _rulesIaugmentInfos)
| (nt, conset, _) <- _coninfo
, con <- Set.toList conset
]
{-# LINE 4847 "Transform.hs" #-})
-- "Transform.ag"(line 946, column 12)
_lhsOcollectedArounds =
({-# LINE 946 "Transform.ag" #-}
[ (nt, con, _rulesIaroundInfos)
| (nt, conset, _) <- _coninfo
, con <- Set.toList conset
]
{-# LINE 4855 "Transform.hs" #-})
( _constructorSetIcollectedConstructorNames,_constructorSetIconstructors,_constructorSetIerrors) =
(constructorSet_ )
( _rulesIaroundInfos,_rulesIaugmentInfos,_rulesIdefinedInsts,_rulesIorderDepsCollect,_rulesIpragmaNamesCollect,_rulesIruleInfos,_rulesIsigInfos,_rulesIuniqueInfos) =
(rules_ )
in ( _lhsOattrOrderCollect,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedInsts,_lhsOcollectedRules,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOerrors,_lhsOsemPragmasCollect))) )
-- SemAlts -----------------------------------------------------
{-
visit 0:
inherited attributes:
allAttrDecls : Map NontermIdent (Attributes, Attributes)
allFields : DataTypes
nts : Set NontermIdent
synthesized attributes:
attrOrderCollect : AttrOrderMap
collectedArounds : [ (NontermIdent, ConstructorIdent, [AroundInfo]) ]
collectedAugments : [ (NontermIdent, ConstructorIdent, [AugmentInfo]) ]
collectedInsts : [ (NontermIdent, ConstructorIdent, [Identifier]) ]
collectedRules : [ (NontermIdent, ConstructorIdent, RuleInfo)]
collectedSigs : [ (NontermIdent, ConstructorIdent, SigInfo) ]
collectedUniques : [ (NontermIdent, ConstructorIdent, [UniqueInfo]) ]
errors : Seq Error
semPragmasCollect : PragmaMap
alternatives:
alternative Cons:
child hd : SemAlt
child tl : SemAlts
alternative Nil:
-}
-- cata
sem_SemAlts :: SemAlts ->
T_SemAlts
sem_SemAlts list =
(Prelude.foldr sem_SemAlts_Cons sem_SemAlts_Nil (Prelude.map sem_SemAlt list) )
-- semantic domain
newtype T_SemAlts = T_SemAlts ((Map NontermIdent (Attributes, Attributes)) ->
DataTypes ->
(Set NontermIdent) ->
( AttrOrderMap,([ (NontermIdent, ConstructorIdent, [AroundInfo]) ]),([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ]),([ (NontermIdent, ConstructorIdent, [Identifier]) ]),([ (NontermIdent, ConstructorIdent, RuleInfo)]),([ (NontermIdent, ConstructorIdent, SigInfo) ]),([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ]),(Seq Error),PragmaMap))
data Inh_SemAlts = Inh_SemAlts {allAttrDecls_Inh_SemAlts :: !((Map NontermIdent (Attributes, Attributes))),allFields_Inh_SemAlts :: !(DataTypes),nts_Inh_SemAlts :: !((Set NontermIdent))}
data Syn_SemAlts = Syn_SemAlts {attrOrderCollect_Syn_SemAlts :: !(AttrOrderMap),collectedArounds_Syn_SemAlts :: !(([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])),collectedAugments_Syn_SemAlts :: !(([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])),collectedInsts_Syn_SemAlts :: !(([ (NontermIdent, ConstructorIdent, [Identifier]) ])),collectedRules_Syn_SemAlts :: !(([ (NontermIdent, ConstructorIdent, RuleInfo)])),collectedSigs_Syn_SemAlts :: !(([ (NontermIdent, ConstructorIdent, SigInfo) ])),collectedUniques_Syn_SemAlts :: !(([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])),errors_Syn_SemAlts :: !((Seq Error)),semPragmasCollect_Syn_SemAlts :: !(PragmaMap)}
wrap_SemAlts :: T_SemAlts ->
Inh_SemAlts ->
Syn_SemAlts
wrap_SemAlts (T_SemAlts sem ) (Inh_SemAlts _lhsIallAttrDecls _lhsIallFields _lhsInts ) =
(let ( _lhsOattrOrderCollect,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedInsts,_lhsOcollectedRules,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOerrors,_lhsOsemPragmasCollect) =
(sem _lhsIallAttrDecls _lhsIallFields _lhsInts )
in (Syn_SemAlts _lhsOattrOrderCollect _lhsOcollectedArounds _lhsOcollectedAugments _lhsOcollectedInsts _lhsOcollectedRules _lhsOcollectedSigs _lhsOcollectedUniques _lhsOerrors _lhsOsemPragmasCollect ))
sem_SemAlts_Cons :: T_SemAlt ->
T_SemAlts ->
T_SemAlts
sem_SemAlts_Cons (T_SemAlt hd_ ) (T_SemAlts tl_ ) =
(T_SemAlts (\ _lhsIallAttrDecls
_lhsIallFields
_lhsInts ->
(let _lhsOattrOrderCollect :: AttrOrderMap
_lhsOcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])
_lhsOcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])
_lhsOcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ])
_lhsOcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)])
_lhsOcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ])
_lhsOcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])
_lhsOerrors :: (Seq Error)
_lhsOsemPragmasCollect :: PragmaMap
_hdOallAttrDecls :: (Map NontermIdent (Attributes, Attributes))
_hdOallFields :: DataTypes
_hdOnts :: (Set NontermIdent)
_tlOallAttrDecls :: (Map NontermIdent (Attributes, Attributes))
_tlOallFields :: DataTypes
_tlOnts :: (Set NontermIdent)
_hdIattrOrderCollect :: AttrOrderMap
_hdIcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])
_hdIcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])
_hdIcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ])
_hdIcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)])
_hdIcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ])
_hdIcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])
_hdIerrors :: (Seq Error)
_hdIsemPragmasCollect :: PragmaMap
_tlIattrOrderCollect :: AttrOrderMap
_tlIcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])
_tlIcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])
_tlIcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ])
_tlIcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)])
_tlIcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ])
_tlIcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])
_tlIerrors :: (Seq Error)
_tlIsemPragmasCollect :: PragmaMap
-- use rule "Transform.ag"(line 747, column 55)
_lhsOattrOrderCollect =
({-# LINE 747 "Transform.ag" #-}
_hdIattrOrderCollect `orderMapUnion` _tlIattrOrderCollect
{-# LINE 4947 "Transform.hs" #-})
-- use rule "Transform.ag"(line 153, column 32)
_lhsOcollectedArounds =
({-# LINE 153 "Transform.ag" #-}
_hdIcollectedArounds ++ _tlIcollectedArounds
{-# LINE 4952 "Transform.hs" #-})
-- use rule "Transform.ag"(line 152, column 32)
_lhsOcollectedAugments =
({-# LINE 152 "Transform.ag" #-}
_hdIcollectedAugments ++ _tlIcollectedAugments
{-# LINE 4957 "Transform.hs" #-})
-- use rule "Transform.ag"(line 150, column 32)
_lhsOcollectedInsts =
({-# LINE 150 "Transform.ag" #-}
_hdIcollectedInsts ++ _tlIcollectedInsts
{-# LINE 4962 "Transform.hs" #-})
-- use rule "Transform.ag"(line 148, column 32)
_lhsOcollectedRules =
({-# LINE 148 "Transform.ag" #-}
_hdIcollectedRules ++ _tlIcollectedRules
{-# LINE 4967 "Transform.hs" #-})
-- use rule "Transform.ag"(line 149, column 32)
_lhsOcollectedSigs =
({-# LINE 149 "Transform.ag" #-}
_hdIcollectedSigs ++ _tlIcollectedSigs
{-# LINE 4972 "Transform.hs" #-})
-- use rule "Transform.ag"(line 151, column 32)
_lhsOcollectedUniques =
({-# LINE 151 "Transform.ag" #-}
_hdIcollectedUniques ++ _tlIcollectedUniques
{-# LINE 4977 "Transform.hs" #-})
-- use rule "Transform.ag"(line 42, column 19)
_lhsOerrors =
({-# LINE 42 "Transform.ag" #-}
_hdIerrors Seq.>< _tlIerrors
{-# LINE 4982 "Transform.hs" #-})
-- use rule "Transform.ag"(line 719, column 56)
_lhsOsemPragmasCollect =
({-# LINE 719 "Transform.ag" #-}
_hdIsemPragmasCollect `pragmaMapUnion` _tlIsemPragmasCollect
{-# LINE 4987 "Transform.hs" #-})
-- copy rule (down)
_hdOallAttrDecls =
({-# LINE 748 "Transform.ag" #-}
_lhsIallAttrDecls
{-# LINE 4992 "Transform.hs" #-})
-- copy rule (down)
_hdOallFields =
({-# LINE 126 "Transform.ag" #-}
_lhsIallFields
{-# LINE 4997 "Transform.hs" #-})
-- copy rule (down)
_hdOnts =
({-# LINE 163 "Transform.ag" #-}
_lhsInts
{-# LINE 5002 "Transform.hs" #-})
-- copy rule (down)
_tlOallAttrDecls =
({-# LINE 748 "Transform.ag" #-}
_lhsIallAttrDecls
{-# LINE 5007 "Transform.hs" #-})
-- copy rule (down)
_tlOallFields =
({-# LINE 126 "Transform.ag" #-}
_lhsIallFields
{-# LINE 5012 "Transform.hs" #-})
-- copy rule (down)
_tlOnts =
({-# LINE 163 "Transform.ag" #-}
_lhsInts
{-# LINE 5017 "Transform.hs" #-})
( _hdIattrOrderCollect,_hdIcollectedArounds,_hdIcollectedAugments,_hdIcollectedInsts,_hdIcollectedRules,_hdIcollectedSigs,_hdIcollectedUniques,_hdIerrors,_hdIsemPragmasCollect) =
(hd_ _hdOallAttrDecls _hdOallFields _hdOnts )
( _tlIattrOrderCollect,_tlIcollectedArounds,_tlIcollectedAugments,_tlIcollectedInsts,_tlIcollectedRules,_tlIcollectedSigs,_tlIcollectedUniques,_tlIerrors,_tlIsemPragmasCollect) =
(tl_ _tlOallAttrDecls _tlOallFields _tlOnts )
in ( _lhsOattrOrderCollect,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedInsts,_lhsOcollectedRules,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOerrors,_lhsOsemPragmasCollect))) )
sem_SemAlts_Nil :: T_SemAlts
sem_SemAlts_Nil =
(T_SemAlts (\ _lhsIallAttrDecls
_lhsIallFields
_lhsInts ->
(let _lhsOattrOrderCollect :: AttrOrderMap
_lhsOcollectedArounds :: ([ (NontermIdent, ConstructorIdent, [AroundInfo]) ])
_lhsOcollectedAugments :: ([ (NontermIdent, ConstructorIdent, [AugmentInfo]) ])
_lhsOcollectedInsts :: ([ (NontermIdent, ConstructorIdent, [Identifier]) ])
_lhsOcollectedRules :: ([ (NontermIdent, ConstructorIdent, RuleInfo)])
_lhsOcollectedSigs :: ([ (NontermIdent, ConstructorIdent, SigInfo) ])
_lhsOcollectedUniques :: ([ (NontermIdent, ConstructorIdent, [UniqueInfo]) ])
_lhsOerrors :: (Seq Error)
_lhsOsemPragmasCollect :: PragmaMap
-- use rule "Transform.ag"(line 747, column 55)
_lhsOattrOrderCollect =
({-# LINE 747 "Transform.ag" #-}
Map.empty
{-# LINE 5041 "Transform.hs" #-})
-- use rule "Transform.ag"(line 153, column 32)
_lhsOcollectedArounds =
({-# LINE 153 "Transform.ag" #-}
[]
{-# LINE 5046 "Transform.hs" #-})
-- use rule "Transform.ag"(line 152, column 32)
_lhsOcollectedAugments =
({-# LINE 152 "Transform.ag" #-}
[]
{-# LINE 5051 "Transform.hs" #-})
-- use rule "Transform.ag"(line 150, column 32)
_lhsOcollectedInsts =
({-# LINE 150 "Transform.ag" #-}
[]
{-# LINE 5056 "Transform.hs" #-})
-- use rule "Transform.ag"(line 148, column 32)
_lhsOcollectedRules =
({-# LINE 148 "Transform.ag" #-}
[]
{-# LINE 5061 "Transform.hs" #-})
-- use rule "Transform.ag"(line 149, column 32)
_lhsOcollectedSigs =
({-# LINE 149 "Transform.ag" #-}
[]
{-# LINE 5066 "Transform.hs" #-})
-- use rule "Transform.ag"(line 151, column 32)
_lhsOcollectedUniques =
({-# LINE 151 "Transform.ag" #-}
[]
{-# LINE 5071 "Transform.hs" #-})
-- use rule "Transform.ag"(line 42, column 19)
_lhsOerrors =
({-# LINE 42 "Transform.ag" #-}
Seq.empty
{-# LINE 5076 "Transform.hs" #-})
-- use rule "Transform.ag"(line 719, column 56)
_lhsOsemPragmasCollect =
({-# LINE 719 "Transform.ag" #-}
Map.empty
{-# LINE 5081 "Transform.hs" #-})
in ( _lhsOattrOrderCollect,_lhsOcollectedArounds,_lhsOcollectedAugments,_lhsOcollectedInsts,_lhsOcollectedRules,_lhsOcollectedSigs,_lhsOcollectedUniques,_lhsOerrors,_lhsOsemPragmasCollect))) )
-- SemDef ------------------------------------------------------
{-
visit 0:
synthesized attributes:
aroundInfos : [AroundInfo]
augmentInfos : [AugmentInfo]
definedInsts : [Identifier]
orderDepsCollect : Set Dependency
pragmaNamesCollect : [Identifier]
ruleInfos : [RuleInfo]
sigInfos : [SigInfo]
uniqueInfos : [UniqueInfo]
alternatives:
alternative AroundDef:
child ident : {Identifier}
child rhs : {Expression}
alternative AttrOrderBefore:
child before : {[Occurrence]}
child after : {[Occurrence]}
visit 0:
local dependency : _
alternative AugmentDef:
child ident : {Identifier}
child rhs : {Expression}
alternative Def:
child pos : {Pos}
child mbName : {Maybe Identifier}
child pattern : Pattern
child rhs : {Expression}
child owrt : {Bool}
alternative SemPragma:
child names : {[NontermIdent]}
alternative TypeDef:
child ident : {Identifier}
child tp : {Type}
alternative UniqueDef:
child ident : {Identifier}
child ref : {Identifier}
-}
-- cata
sem_SemDef :: SemDef ->
T_SemDef
sem_SemDef (AroundDef _ident _rhs ) =
(sem_SemDef_AroundDef _ident _rhs )
sem_SemDef (AttrOrderBefore _before _after ) =
(sem_SemDef_AttrOrderBefore _before _after )
sem_SemDef (AugmentDef _ident _rhs ) =
(sem_SemDef_AugmentDef _ident _rhs )
sem_SemDef (Def _pos _mbName _pattern _rhs _owrt ) =
(sem_SemDef_Def _pos _mbName (sem_Pattern _pattern ) _rhs _owrt )
sem_SemDef (SemPragma _names ) =
(sem_SemDef_SemPragma _names )
sem_SemDef (TypeDef _ident _tp ) =
(sem_SemDef_TypeDef _ident _tp )
sem_SemDef (UniqueDef _ident _ref ) =
(sem_SemDef_UniqueDef _ident _ref )
-- semantic domain
newtype T_SemDef = T_SemDef (( ([AroundInfo]),([AugmentInfo]),([Identifier]),(Set Dependency),([Identifier]),([RuleInfo]),([SigInfo]),([UniqueInfo])))
data Inh_SemDef = Inh_SemDef {}
data Syn_SemDef = Syn_SemDef {aroundInfos_Syn_SemDef :: !(([AroundInfo])),augmentInfos_Syn_SemDef :: !(([AugmentInfo])),definedInsts_Syn_SemDef :: !(([Identifier])),orderDepsCollect_Syn_SemDef :: !((Set Dependency)),pragmaNamesCollect_Syn_SemDef :: !(([Identifier])),ruleInfos_Syn_SemDef :: !(([RuleInfo])),sigInfos_Syn_SemDef :: !(([SigInfo])),uniqueInfos_Syn_SemDef :: !(([UniqueInfo]))}
wrap_SemDef :: T_SemDef ->
Inh_SemDef ->
Syn_SemDef
wrap_SemDef (T_SemDef sem ) (Inh_SemDef ) =
(let ( _lhsOaroundInfos,_lhsOaugmentInfos,_lhsOdefinedInsts,_lhsOorderDepsCollect,_lhsOpragmaNamesCollect,_lhsOruleInfos,_lhsOsigInfos,_lhsOuniqueInfos) =
(sem )
in (Syn_SemDef _lhsOaroundInfos _lhsOaugmentInfos _lhsOdefinedInsts _lhsOorderDepsCollect _lhsOpragmaNamesCollect _lhsOruleInfos _lhsOsigInfos _lhsOuniqueInfos ))
sem_SemDef_AroundDef :: Identifier ->
Expression ->
T_SemDef
sem_SemDef_AroundDef ident_ rhs_ =
(T_SemDef (let _lhsOaroundInfos :: ([AroundInfo])
_lhsOaugmentInfos :: ([AugmentInfo])
_lhsOdefinedInsts :: ([Identifier])
_lhsOorderDepsCollect :: (Set Dependency)
_lhsOpragmaNamesCollect :: ([Identifier])
_lhsOruleInfos :: ([RuleInfo])
_lhsOsigInfos :: ([SigInfo])
_lhsOuniqueInfos :: ([UniqueInfo])
-- "Transform.ag"(line 965, column 17)
_lhsOaroundInfos =
({-# LINE 965 "Transform.ag" #-}
[ (ident_, rhs_) ]
{-# LINE 5166 "Transform.hs" #-})
-- use rule "Transform.ag"(line 897, column 40)
_lhsOaugmentInfos =
({-# LINE 897 "Transform.ag" #-}
[]
{-# LINE 5171 "Transform.hs" #-})
-- use rule "Transform.ag"(line 968, column 55)
_lhsOdefinedInsts =
({-# LINE 968 "Transform.ag" #-}
[]
{-# LINE 5176 "Transform.hs" #-})
-- use rule "Transform.ag"(line 760, column 44)
_lhsOorderDepsCollect =
({-# LINE 760 "Transform.ag" #-}
Set.empty
{-# LINE 5181 "Transform.hs" #-})
-- use rule "Transform.ag"(line 729, column 46)
_lhsOpragmaNamesCollect =
({-# LINE 729 "Transform.ag" #-}
[]
{-# LINE 5186 "Transform.hs" #-})
-- use rule "Transform.ag"(line 894, column 40)
_lhsOruleInfos =
({-# LINE 894 "Transform.ag" #-}
[]
{-# LINE 5191 "Transform.hs" #-})
-- use rule "Transform.ag"(line 895, column 40)
_lhsOsigInfos =
({-# LINE 895 "Transform.ag" #-}
[]
{-# LINE 5196 "Transform.hs" #-})
-- use rule "Transform.ag"(line 896, column 40)
_lhsOuniqueInfos =
({-# LINE 896 "Transform.ag" #-}
[]
{-# LINE 5201 "Transform.hs" #-})
in ( _lhsOaroundInfos,_lhsOaugmentInfos,_lhsOdefinedInsts,_lhsOorderDepsCollect,_lhsOpragmaNamesCollect,_lhsOruleInfos,_lhsOsigInfos,_lhsOuniqueInfos)) )
sem_SemDef_AttrOrderBefore :: ([Occurrence]) ->
([Occurrence]) ->
T_SemDef
sem_SemDef_AttrOrderBefore before_ after_ =
(T_SemDef (let _lhsOorderDepsCollect :: (Set Dependency)
_lhsOaroundInfos :: ([AroundInfo])
_lhsOaugmentInfos :: ([AugmentInfo])
_lhsOdefinedInsts :: ([Identifier])
_lhsOpragmaNamesCollect :: ([Identifier])
_lhsOruleInfos :: ([RuleInfo])
_lhsOsigInfos :: ([SigInfo])
_lhsOuniqueInfos :: ([UniqueInfo])
-- "Transform.ag"(line 764, column 7)
_dependency =
({-# LINE 764 "Transform.ag" #-}
[ Dependency b a | b <- before_, a <- after_ ]
{-# LINE 5219 "Transform.hs" #-})
-- "Transform.ag"(line 765, column 7)
_lhsOorderDepsCollect =
({-# LINE 765 "Transform.ag" #-}
Set.fromList _dependency
{-# LINE 5224 "Transform.hs" #-})
-- use rule "Transform.ag"(line 898, column 40)
_lhsOaroundInfos =
({-# LINE 898 "Transform.ag" #-}
[]
{-# LINE 5229 "Transform.hs" #-})
-- use rule "Transform.ag"(line 897, column 40)
_lhsOaugmentInfos =
({-# LINE 897 "Transform.ag" #-}
[]
{-# LINE 5234 "Transform.hs" #-})
-- use rule "Transform.ag"(line 968, column 55)
_lhsOdefinedInsts =
({-# LINE 968 "Transform.ag" #-}
[]
{-# LINE 5239 "Transform.hs" #-})
-- use rule "Transform.ag"(line 729, column 46)
_lhsOpragmaNamesCollect =
({-# LINE 729 "Transform.ag" #-}
[]
{-# LINE 5244 "Transform.hs" #-})
-- use rule "Transform.ag"(line 894, column 40)
_lhsOruleInfos =
({-# LINE 894 "Transform.ag" #-}
[]
{-# LINE 5249 "Transform.hs" #-})
-- use rule "Transform.ag"(line 895, column 40)
_lhsOsigInfos =
({-# LINE 895 "Transform.ag" #-}
[]
{-# LINE 5254 "Transform.hs" #-})
-- use rule "Transform.ag"(line 896, column 40)
_lhsOuniqueInfos =
({-# LINE 896 "Transform.ag" #-}
[]
{-# LINE 5259 "Transform.hs" #-})
in ( _lhsOaroundInfos,_lhsOaugmentInfos,_lhsOdefinedInsts,_lhsOorderDepsCollect,_lhsOpragmaNamesCollect,_lhsOruleInfos,_lhsOsigInfos,_lhsOuniqueInfos)) )
sem_SemDef_AugmentDef :: Identifier ->
Expression ->
T_SemDef
sem_SemDef_AugmentDef ident_ rhs_ =
(T_SemDef (let _lhsOaugmentInfos :: ([AugmentInfo])
_lhsOaroundInfos :: ([AroundInfo])
_lhsOdefinedInsts :: ([Identifier])
_lhsOorderDepsCollect :: (Set Dependency)
_lhsOpragmaNamesCollect :: ([Identifier])
_lhsOruleInfos :: ([RuleInfo])
_lhsOsigInfos :: ([SigInfo])
_lhsOuniqueInfos :: ([UniqueInfo])
-- "Transform.ag"(line 962, column 17)
_lhsOaugmentInfos =
({-# LINE 962 "Transform.ag" #-}
[ (ident_, rhs_) ]
{-# LINE 5277 "Transform.hs" #-})
-- use rule "Transform.ag"(line 898, column 40)
_lhsOaroundInfos =
({-# LINE 898 "Transform.ag" #-}
[]
{-# LINE 5282 "Transform.hs" #-})
-- use rule "Transform.ag"(line 968, column 55)
_lhsOdefinedInsts =
({-# LINE 968 "Transform.ag" #-}
[]
{-# LINE 5287 "Transform.hs" #-})
-- use rule "Transform.ag"(line 760, column 44)
_lhsOorderDepsCollect =
({-# LINE 760 "Transform.ag" #-}
Set.empty
{-# LINE 5292 "Transform.hs" #-})
-- use rule "Transform.ag"(line 729, column 46)
_lhsOpragmaNamesCollect =
({-# LINE 729 "Transform.ag" #-}
[]
{-# LINE 5297 "Transform.hs" #-})
-- use rule "Transform.ag"(line 894, column 40)
_lhsOruleInfos =
({-# LINE 894 "Transform.ag" #-}
[]
{-# LINE 5302 "Transform.hs" #-})
-- use rule "Transform.ag"(line 895, column 40)
_lhsOsigInfos =
({-# LINE 895 "Transform.ag" #-}
[]
{-# LINE 5307 "Transform.hs" #-})
-- use rule "Transform.ag"(line 896, column 40)
_lhsOuniqueInfos =
({-# LINE 896 "Transform.ag" #-}
[]
{-# LINE 5312 "Transform.hs" #-})
in ( _lhsOaroundInfos,_lhsOaugmentInfos,_lhsOdefinedInsts,_lhsOorderDepsCollect,_lhsOpragmaNamesCollect,_lhsOruleInfos,_lhsOsigInfos,_lhsOuniqueInfos)) )
sem_SemDef_Def :: Pos ->
(Maybe Identifier) ->
T_Pattern ->
Expression ->
Bool ->
T_SemDef
sem_SemDef_Def pos_ mbName_ (T_Pattern pattern_ ) rhs_ owrt_ =
(T_SemDef (let _lhsOruleInfos :: ([RuleInfo])
_lhsOaroundInfos :: ([AroundInfo])
_lhsOaugmentInfos :: ([AugmentInfo])
_lhsOdefinedInsts :: ([Identifier])
_lhsOorderDepsCollect :: (Set Dependency)
_lhsOpragmaNamesCollect :: ([Identifier])
_lhsOsigInfos :: ([SigInfo])
_lhsOuniqueInfos :: ([UniqueInfo])
_patternIcopy :: Pattern
_patternIdefinedAttrs :: ([AttrName])
_patternIdefinedInsts :: ([Identifier])
_patternIpatunder :: ([AttrName]->Pattern)
_patternIstpos :: Pos
-- "Transform.ag"(line 953, column 10)
_lhsOruleInfos =
({-# LINE 953 "Transform.ag" #-}
[ (mbName_, _patternIpatunder, rhs_, _patternIdefinedAttrs, owrt_, show _patternIstpos) ]
{-# LINE 5338 "Transform.hs" #-})
-- use rule "Transform.ag"(line 898, column 40)
_lhsOaroundInfos =
({-# LINE 898 "Transform.ag" #-}
[]
{-# LINE 5343 "Transform.hs" #-})
-- use rule "Transform.ag"(line 897, column 40)
_lhsOaugmentInfos =
({-# LINE 897 "Transform.ag" #-}
[]
{-# LINE 5348 "Transform.hs" #-})
-- use rule "Transform.ag"(line 968, column 55)
_lhsOdefinedInsts =
({-# LINE 968 "Transform.ag" #-}
_patternIdefinedInsts
{-# LINE 5353 "Transform.hs" #-})
-- use rule "Transform.ag"(line 760, column 44)
_lhsOorderDepsCollect =
({-# LINE 760 "Transform.ag" #-}
Set.empty
{-# LINE 5358 "Transform.hs" #-})
-- use rule "Transform.ag"(line 729, column 46)
_lhsOpragmaNamesCollect =
({-# LINE 729 "Transform.ag" #-}
[]
{-# LINE 5363 "Transform.hs" #-})
-- use rule "Transform.ag"(line 895, column 40)
_lhsOsigInfos =
({-# LINE 895 "Transform.ag" #-}
[]
{-# LINE 5368 "Transform.hs" #-})
-- use rule "Transform.ag"(line 896, column 40)
_lhsOuniqueInfos =
({-# LINE 896 "Transform.ag" #-}
[]
{-# LINE 5373 "Transform.hs" #-})
( _patternIcopy,_patternIdefinedAttrs,_patternIdefinedInsts,_patternIpatunder,_patternIstpos) =
(pattern_ )
in ( _lhsOaroundInfos,_lhsOaugmentInfos,_lhsOdefinedInsts,_lhsOorderDepsCollect,_lhsOpragmaNamesCollect,_lhsOruleInfos,_lhsOsigInfos,_lhsOuniqueInfos)) )
sem_SemDef_SemPragma :: ([NontermIdent]) ->
T_SemDef
sem_SemDef_SemPragma names_ =
(T_SemDef (let _lhsOpragmaNamesCollect :: ([Identifier])
_lhsOaroundInfos :: ([AroundInfo])
_lhsOaugmentInfos :: ([AugmentInfo])
_lhsOdefinedInsts :: ([Identifier])
_lhsOorderDepsCollect :: (Set Dependency)
_lhsOruleInfos :: ([RuleInfo])
_lhsOsigInfos :: ([SigInfo])
_lhsOuniqueInfos :: ([UniqueInfo])
-- "Transform.ag"(line 733, column 7)
_lhsOpragmaNamesCollect =
({-# LINE 733 "Transform.ag" #-}
names_
{-# LINE 5392 "Transform.hs" #-})
-- use rule "Transform.ag"(line 898, column 40)
_lhsOaroundInfos =
({-# LINE 898 "Transform.ag" #-}
[]
{-# LINE 5397 "Transform.hs" #-})
-- use rule "Transform.ag"(line 897, column 40)
_lhsOaugmentInfos =
({-# LINE 897 "Transform.ag" #-}
[]
{-# LINE 5402 "Transform.hs" #-})
-- use rule "Transform.ag"(line 968, column 55)
_lhsOdefinedInsts =
({-# LINE 968 "Transform.ag" #-}
[]
{-# LINE 5407 "Transform.hs" #-})
-- use rule "Transform.ag"(line 760, column 44)
_lhsOorderDepsCollect =
({-# LINE 760 "Transform.ag" #-}
Set.empty
{-# LINE 5412 "Transform.hs" #-})
-- use rule "Transform.ag"(line 894, column 40)
_lhsOruleInfos =
({-# LINE 894 "Transform.ag" #-}
[]
{-# LINE 5417 "Transform.hs" #-})
-- use rule "Transform.ag"(line 895, column 40)
_lhsOsigInfos =
({-# LINE 895 "Transform.ag" #-}
[]
{-# LINE 5422 "Transform.hs" #-})
-- use rule "Transform.ag"(line 896, column 40)
_lhsOuniqueInfos =
({-# LINE 896 "Transform.ag" #-}
[]
{-# LINE 5427 "Transform.hs" #-})
in ( _lhsOaroundInfos,_lhsOaugmentInfos,_lhsOdefinedInsts,_lhsOorderDepsCollect,_lhsOpragmaNamesCollect,_lhsOruleInfos,_lhsOsigInfos,_lhsOuniqueInfos)) )
sem_SemDef_TypeDef :: Identifier ->
Type ->
T_SemDef
sem_SemDef_TypeDef ident_ tp_ =
(T_SemDef (let _lhsOsigInfos :: ([SigInfo])
_lhsOaroundInfos :: ([AroundInfo])
_lhsOaugmentInfos :: ([AugmentInfo])
_lhsOdefinedInsts :: ([Identifier])
_lhsOorderDepsCollect :: (Set Dependency)
_lhsOpragmaNamesCollect :: ([Identifier])
_lhsOruleInfos :: ([RuleInfo])
_lhsOuniqueInfos :: ([UniqueInfo])
-- "Transform.ag"(line 956, column 14)
_lhsOsigInfos =
({-# LINE 956 "Transform.ag" #-}
[ (ident_, tp_) ]
{-# LINE 5445 "Transform.hs" #-})
-- use rule "Transform.ag"(line 898, column 40)
_lhsOaroundInfos =
({-# LINE 898 "Transform.ag" #-}
[]
{-# LINE 5450 "Transform.hs" #-})
-- use rule "Transform.ag"(line 897, column 40)
_lhsOaugmentInfos =
({-# LINE 897 "Transform.ag" #-}
[]
{-# LINE 5455 "Transform.hs" #-})
-- use rule "Transform.ag"(line 968, column 55)
_lhsOdefinedInsts =
({-# LINE 968 "Transform.ag" #-}
[]
{-# LINE 5460 "Transform.hs" #-})
-- use rule "Transform.ag"(line 760, column 44)
_lhsOorderDepsCollect =
({-# LINE 760 "Transform.ag" #-}
Set.empty
{-# LINE 5465 "Transform.hs" #-})
-- use rule "Transform.ag"(line 729, column 46)
_lhsOpragmaNamesCollect =
({-# LINE 729 "Transform.ag" #-}
[]
{-# LINE 5470 "Transform.hs" #-})
-- use rule "Transform.ag"(line 894, column 40)
_lhsOruleInfos =
({-# LINE 894 "Transform.ag" #-}
[]
{-# LINE 5475 "Transform.hs" #-})
-- use rule "Transform.ag"(line 896, column 40)
_lhsOuniqueInfos =
({-# LINE 896 "Transform.ag" #-}
[]
{-# LINE 5480 "Transform.hs" #-})
in ( _lhsOaroundInfos,_lhsOaugmentInfos,_lhsOdefinedInsts,_lhsOorderDepsCollect,_lhsOpragmaNamesCollect,_lhsOruleInfos,_lhsOsigInfos,_lhsOuniqueInfos)) )
sem_SemDef_UniqueDef :: Identifier ->
Identifier ->
T_SemDef
sem_SemDef_UniqueDef ident_ ref_ =
(T_SemDef (let _lhsOuniqueInfos :: ([UniqueInfo])
_lhsOaroundInfos :: ([AroundInfo])
_lhsOaugmentInfos :: ([AugmentInfo])
_lhsOdefinedInsts :: ([Identifier])
_lhsOorderDepsCollect :: (Set Dependency)
_lhsOpragmaNamesCollect :: ([Identifier])
_lhsOruleInfos :: ([RuleInfo])
_lhsOsigInfos :: ([SigInfo])
-- "Transform.ag"(line 959, column 16)
_lhsOuniqueInfos =
({-# LINE 959 "Transform.ag" #-}
[ (ident_, ref_) ]
{-# LINE 5498 "Transform.hs" #-})
-- use rule "Transform.ag"(line 898, column 40)
_lhsOaroundInfos =
({-# LINE 898 "Transform.ag" #-}
[]
{-# LINE 5503 "Transform.hs" #-})
-- use rule "Transform.ag"(line 897, column 40)
_lhsOaugmentInfos =
({-# LINE 897 "Transform.ag" #-}
[]
{-# LINE 5508 "Transform.hs" #-})
-- use rule "Transform.ag"(line 968, column 55)
_lhsOdefinedInsts =
({-# LINE 968 "Transform.ag" #-}
[]
{-# LINE 5513 "Transform.hs" #-})
-- use rule "Transform.ag"(line 760, column 44)
_lhsOorderDepsCollect =
({-# LINE 760 "Transform.ag" #-}
Set.empty
{-# LINE 5518 "Transform.hs" #-})
-- use rule "Transform.ag"(line 729, column 46)
_lhsOpragmaNamesCollect =
({-# LINE 729 "Transform.ag" #-}
[]
{-# LINE 5523 "Transform.hs" #-})
-- use rule "Transform.ag"(line 894, column 40)
_lhsOruleInfos =
({-# LINE 894 "Transform.ag" #-}
[]
{-# LINE 5528 "Transform.hs" #-})
-- use rule "Transform.ag"(line 895, column 40)
_lhsOsigInfos =
({-# LINE 895 "Transform.ag" #-}
[]
{-# LINE 5533 "Transform.hs" #-})
in ( _lhsOaroundInfos,_lhsOaugmentInfos,_lhsOdefinedInsts,_lhsOorderDepsCollect,_lhsOpragmaNamesCollect,_lhsOruleInfos,_lhsOsigInfos,_lhsOuniqueInfos)) )
-- SemDefs -----------------------------------------------------
{-
visit 0:
synthesized attributes:
aroundInfos : [AroundInfo]
augmentInfos : [AugmentInfo]
definedInsts : [Identifier]
orderDepsCollect : Set Dependency
pragmaNamesCollect : [Identifier]
ruleInfos : [RuleInfo]
sigInfos : [SigInfo]
uniqueInfos : [UniqueInfo]
alternatives:
alternative Cons:
child hd : SemDef
child tl : SemDefs
alternative Nil:
-}
-- cata
sem_SemDefs :: SemDefs ->
T_SemDefs
sem_SemDefs list =
(Prelude.foldr sem_SemDefs_Cons sem_SemDefs_Nil (Prelude.map sem_SemDef list) )
-- semantic domain
newtype T_SemDefs = T_SemDefs (( ([AroundInfo]),([AugmentInfo]),([Identifier]),(Set Dependency),([Identifier]),([RuleInfo]),([SigInfo]),([UniqueInfo])))
data Inh_SemDefs = Inh_SemDefs {}
data Syn_SemDefs = Syn_SemDefs {aroundInfos_Syn_SemDefs :: !(([AroundInfo])),augmentInfos_Syn_SemDefs :: !(([AugmentInfo])),definedInsts_Syn_SemDefs :: !(([Identifier])),orderDepsCollect_Syn_SemDefs :: !((Set Dependency)),pragmaNamesCollect_Syn_SemDefs :: !(([Identifier])),ruleInfos_Syn_SemDefs :: !(([RuleInfo])),sigInfos_Syn_SemDefs :: !(([SigInfo])),uniqueInfos_Syn_SemDefs :: !(([UniqueInfo]))}
wrap_SemDefs :: T_SemDefs ->
Inh_SemDefs ->
Syn_SemDefs
wrap_SemDefs (T_SemDefs sem ) (Inh_SemDefs ) =
(let ( _lhsOaroundInfos,_lhsOaugmentInfos,_lhsOdefinedInsts,_lhsOorderDepsCollect,_lhsOpragmaNamesCollect,_lhsOruleInfos,_lhsOsigInfos,_lhsOuniqueInfos) =
(sem )
in (Syn_SemDefs _lhsOaroundInfos _lhsOaugmentInfos _lhsOdefinedInsts _lhsOorderDepsCollect _lhsOpragmaNamesCollect _lhsOruleInfos _lhsOsigInfos _lhsOuniqueInfos ))
sem_SemDefs_Cons :: T_SemDef ->
T_SemDefs ->
T_SemDefs
sem_SemDefs_Cons (T_SemDef hd_ ) (T_SemDefs tl_ ) =
(T_SemDefs (let _lhsOaroundInfos :: ([AroundInfo])
_lhsOaugmentInfos :: ([AugmentInfo])
_lhsOdefinedInsts :: ([Identifier])
_lhsOorderDepsCollect :: (Set Dependency)
_lhsOpragmaNamesCollect :: ([Identifier])
_lhsOruleInfos :: ([RuleInfo])
_lhsOsigInfos :: ([SigInfo])
_lhsOuniqueInfos :: ([UniqueInfo])
_hdIaroundInfos :: ([AroundInfo])
_hdIaugmentInfos :: ([AugmentInfo])
_hdIdefinedInsts :: ([Identifier])
_hdIorderDepsCollect :: (Set Dependency)
_hdIpragmaNamesCollect :: ([Identifier])
_hdIruleInfos :: ([RuleInfo])
_hdIsigInfos :: ([SigInfo])
_hdIuniqueInfos :: ([UniqueInfo])
_tlIaroundInfos :: ([AroundInfo])
_tlIaugmentInfos :: ([AugmentInfo])
_tlIdefinedInsts :: ([Identifier])
_tlIorderDepsCollect :: (Set Dependency)
_tlIpragmaNamesCollect :: ([Identifier])
_tlIruleInfos :: ([RuleInfo])
_tlIsigInfos :: ([SigInfo])
_tlIuniqueInfos :: ([UniqueInfo])
-- use rule "Transform.ag"(line 898, column 40)
_lhsOaroundInfos =
({-# LINE 898 "Transform.ag" #-}
_hdIaroundInfos ++ _tlIaroundInfos
{-# LINE 5601 "Transform.hs" #-})
-- use rule "Transform.ag"(line 897, column 40)
_lhsOaugmentInfos =
({-# LINE 897 "Transform.ag" #-}
_hdIaugmentInfos ++ _tlIaugmentInfos
{-# LINE 5606 "Transform.hs" #-})
-- use rule "Transform.ag"(line 968, column 55)
_lhsOdefinedInsts =
({-# LINE 968 "Transform.ag" #-}
_hdIdefinedInsts ++ _tlIdefinedInsts
{-# LINE 5611 "Transform.hs" #-})
-- use rule "Transform.ag"(line 760, column 44)
_lhsOorderDepsCollect =
({-# LINE 760 "Transform.ag" #-}
_hdIorderDepsCollect `Set.union` _tlIorderDepsCollect
{-# LINE 5616 "Transform.hs" #-})
-- use rule "Transform.ag"(line 729, column 46)
_lhsOpragmaNamesCollect =
({-# LINE 729 "Transform.ag" #-}
_hdIpragmaNamesCollect ++ _tlIpragmaNamesCollect
{-# LINE 5621 "Transform.hs" #-})
-- use rule "Transform.ag"(line 894, column 40)
_lhsOruleInfos =
({-# LINE 894 "Transform.ag" #-}
_hdIruleInfos ++ _tlIruleInfos
{-# LINE 5626 "Transform.hs" #-})
-- use rule "Transform.ag"(line 895, column 40)
_lhsOsigInfos =
({-# LINE 895 "Transform.ag" #-}
_hdIsigInfos ++ _tlIsigInfos
{-# LINE 5631 "Transform.hs" #-})
-- use rule "Transform.ag"(line 896, column 40)
_lhsOuniqueInfos =
({-# LINE 896 "Transform.ag" #-}
_hdIuniqueInfos ++ _tlIuniqueInfos
{-# LINE 5636 "Transform.hs" #-})
( _hdIaroundInfos,_hdIaugmentInfos,_hdIdefinedInsts,_hdIorderDepsCollect,_hdIpragmaNamesCollect,_hdIruleInfos,_hdIsigInfos,_hdIuniqueInfos) =
(hd_ )
( _tlIaroundInfos,_tlIaugmentInfos,_tlIdefinedInsts,_tlIorderDepsCollect,_tlIpragmaNamesCollect,_tlIruleInfos,_tlIsigInfos,_tlIuniqueInfos) =
(tl_ )
in ( _lhsOaroundInfos,_lhsOaugmentInfos,_lhsOdefinedInsts,_lhsOorderDepsCollect,_lhsOpragmaNamesCollect,_lhsOruleInfos,_lhsOsigInfos,_lhsOuniqueInfos)) )
sem_SemDefs_Nil :: T_SemDefs
sem_SemDefs_Nil =
(T_SemDefs (let _lhsOaroundInfos :: ([AroundInfo])
_lhsOaugmentInfos :: ([AugmentInfo])
_lhsOdefinedInsts :: ([Identifier])
_lhsOorderDepsCollect :: (Set Dependency)
_lhsOpragmaNamesCollect :: ([Identifier])
_lhsOruleInfos :: ([RuleInfo])
_lhsOsigInfos :: ([SigInfo])
_lhsOuniqueInfos :: ([UniqueInfo])
-- use rule "Transform.ag"(line 898, column 40)
_lhsOaroundInfos =
({-# LINE 898 "Transform.ag" #-}
[]
{-# LINE 5656 "Transform.hs" #-})
-- use rule "Transform.ag"(line 897, column 40)
_lhsOaugmentInfos =
({-# LINE 897 "Transform.ag" #-}
[]
{-# LINE 5661 "Transform.hs" #-})
-- use rule "Transform.ag"(line 968, column 55)
_lhsOdefinedInsts =
({-# LINE 968 "Transform.ag" #-}
[]
{-# LINE 5666 "Transform.hs" #-})
-- use rule "Transform.ag"(line 760, column 44)
_lhsOorderDepsCollect =
({-# LINE 760 "Transform.ag" #-}
Set.empty
{-# LINE 5671 "Transform.hs" #-})
-- use rule "Transform.ag"(line 729, column 46)
_lhsOpragmaNamesCollect =
({-# LINE 729 "Transform.ag" #-}
[]
{-# LINE 5676 "Transform.hs" #-})
-- use rule "Transform.ag"(line 894, column 40)
_lhsOruleInfos =
({-# LINE 894 "Transform.ag" #-}
[]
{-# LINE 5681 "Transform.hs" #-})
-- use rule "Transform.ag"(line 895, column 40)
_lhsOsigInfos =
({-# LINE 895 "Transform.ag" #-}
[]
{-# LINE 5686 "Transform.hs" #-})
-- use rule "Transform.ag"(line 896, column 40)
_lhsOuniqueInfos =
({-# LINE 896 "Transform.ag" #-}
[]
{-# LINE 5691 "Transform.hs" #-})
in ( _lhsOaroundInfos,_lhsOaugmentInfos,_lhsOdefinedInsts,_lhsOorderDepsCollect,_lhsOpragmaNamesCollect,_lhsOruleInfos,_lhsOsigInfos,_lhsOuniqueInfos)) )