uuagc-0.9.54: src-generated/TfmToMirage.hs
{-# LANGUAGE Rank2Types, GADTs #-}
{-# LANGUAGE ScopedTypeVariables #-}
module TfmToMirage where
{-# LINE 2 "src-ag/Patterns.ag" #-}
-- Patterns.ag imports
import UU.Scanner.Position(Pos)
import CommonTypes (ConstructorIdent,Identifier)
{-# LINE 11 "src-generated/TfmToMirage.hs" #-}
{-# LINE 10 "src-ag/Order.ag" #-}
-- From uuagc
import CommonTypes
import Patterns
import ErrorMessages
import AbstractSyntax
import Code hiding (Type)
import qualified Code
import Expression
import Options
import SequentialComputation
import SequentialTypes
import CodeSyntax
import GrammarInfo
import HsToken(HsTokensRoot(HsTokensRoot))
import SemHsTokens(sem_HsTokensRoot,wrap_HsTokensRoot, Syn_HsTokensRoot(..),Inh_HsTokensRoot(..))
-- From uulib
import qualified Data.Map as Map
import qualified Data.Set as Set
import qualified Data.Sequence as Seq
import Data.Map(Map)
import Data.Set(Set)
import Data.Sequence(Seq, (><))
import UU.Util.Utils
import UU.Scanner.Position(Pos(..),initPos)
import Data.Foldable(toList)
-- From haskell libraries
import Control.Monad(liftM)
import qualified Data.Array as Array
import Data.Array((!),bounds,inRange)
import Data.List(elemIndex,partition,sort,mapAccumL,find,nubBy,intersperse,groupBy,transpose)
import qualified Data.Tree as Tree
import Data.Maybe
{-# LINE 48 "src-generated/TfmToMirage.hs" #-}
{-# LINE 2 "src-ag/Expression.ag" #-}
import UU.Scanner.Position(Pos)
import HsToken
{-# LINE 54 "src-generated/TfmToMirage.hs" #-}
{-# LINE 2 "src-ag/AbstractSyntax.ag" #-}
-- AbstractSyntax.ag imports
import Data.Set(Set)
import Data.Map(Map)
import Patterns (Pattern(..),Patterns)
import Expression (Expression(..))
import Macro --marcos
import CommonTypes
import ErrorMessages
{-# LINE 66 "src-generated/TfmToMirage.hs" #-}
{-# LINE 5 "src-ag/TfmToMirage.ag" #-}
import AbstractSyntax
import qualified Data.Map as Map
import Pretty
import TokenDef
import qualified MirageSyntax as Mirage
{-# LINE 75 "src-generated/TfmToMirage.hs" #-}
import Control.Monad.Identity (Identity)
import qualified Control.Monad.Identity
{-# LINE 46 "src-ag/Order.ag" #-}
-- Terminates with an error if the key is not in the map
findWithErr1 :: (Ord k, Show k) => String -> k -> Map k a -> a
findWithErr1 s k
= Map.findWithDefault (error ("findWithErr1 " ++ s ++ ": key " ++ show k ++ " not in map.")) k
findWithErr2 :: (Ord k, Show k, Show a) => k -> Map k a -> a
findWithErr2 k m
= Map.findWithDefault (error ("findWithErr2: key " ++ show k ++ " not in map: " ++ show m)) k m
{-# LINE 88 "src-generated/TfmToMirage.hs" #-}
{-# LINE 71 "src-ag/Order.ag" #-}
startsWith :: String -> String -> Bool
startsWith k h = k == take (length k) h
{-# LINE 94 "src-generated/TfmToMirage.hs" #-}
{-# LINE 138 "src-ag/Order.ag" #-}
getNtName :: Type -> NontermIdent
getNtName (NT nt _ _) = nt
getNtName _ = nullIdent
{-# LINE 101 "src-generated/TfmToMirage.hs" #-}
{-# LINE 166 "src-ag/Order.ag" #-}
data AltAttr = AltAttr Identifier Identifier Bool
deriving (Eq, Ord, Show)
{-# LINE 107 "src-generated/TfmToMirage.hs" #-}
{-# LINE 239 "src-ag/Order.ag" #-}
substSelf nt tp
= case tp of
NT n tps defor | n == _SELF -> NT nt tps defor
_ -> tp
haskellTupel :: [Type] -> Maybe Type
haskellTupel ts = Just ( Haskell ( '(' : (concat (intersperse "," (map show ts))) ++ ")" ))
{-# LINE 118 "src-generated/TfmToMirage.hs" #-}
{-# LINE 692 "src-ag/Order.ag" #-}
swap (a,b) = (b,a)
showPath :: Table CRule -> [Vertex] -> [String]
showPath ruleTable path
= let look a | inRange (bounds ruleTable) a = [showOrigin (ruleTable ! a)]
| otherwise = ["Vertex " ++ show a]
showOrigin cr | getHasCode cr && getName (getAttr cr) /= "self" = prettyCRule cr ++ " (" ++ show (getPos (getAttr cr)) ++ ")"
| otherwise = prettyCRule cr
in concatMap look path
showPathLocal :: Table CRule -> [Vertex] -> [String]
showPathLocal _ [] = []
showPathLocal ruleTable xs = showP (xs++[-1])
where showP [] = []
showP (v1:v2:vs) = let line = step v1 v2
lines = showP vs
in line:lines
step v1 v2 = " - " ++ a1
where r1 = ruleTable ! v1
a1 = show (getAttr r1)
limitTo :: Int -> [String] -> [String]
limitTo _ [] = []
limitTo 0 _ = ["....etcetera, etcetera...."]
limitTo n (x:xs) = x : limitTo (n-1) xs
showPathNice :: Table CRule -> [Vertex] -> [String]
showPathNice _ [] = []
showPathNice ruleTable xs = limitTo 100 (showP ((-1):xs++[-1]))
where [maxf, maxa, maxn, maxc] = maxWidths ruleTable (take 100 xs)
showP [] = []
showP (v1:v2:vs) = let line = step v1 v2
lines = showP vs
in if null line then lines else line:lines
step v1 v2 | last && first = induced
| last && isSyn r1 = "pass up " ++ alignR maxf "" ++ " " ++ alignL maxa a1 ++ " in " ++ alignR maxn n1 ++ "|" ++ c1 ++ induced
| first&& not(isSyn r2) = "get from above " ++ alignR maxf "" ++ " " ++ alignL maxa a2 ++ " in " ++ alignR maxn n2 ++ "|" ++ c2
| last = "pass down " ++ alignR maxf f1 ++ "." ++ a1 ++ induced
| isSyn r2 = "get from below " ++ alignR maxf f2 ++ "." ++ alignL maxa a2 ++ " in " ++ alignR maxn n2 ++ "|" ++ c2
| isLocal r1 = if head a1 == '_'
then ""
else "calculate " ++ alignR maxf "loc" ++ "." ++ a1
| otherwise = "pass down " ++ alignR maxf f1 ++ "." ++ alignL maxa a1 ++ " to " ++ alignR maxn n2 ++ "|" ++ c2
where
first = v1<0
last = v2<0
r1 = ruleTable ! v1
r2 = ruleTable ! v2
a1 = show (getAttr r1)
a2 = show (getAttr r2)
f1 = show (getField r1)
f2 = show (getField r2)
n1 = show (getLhsNt r1)
n2 = show (getLhsNt r2)
c1 = show (getCon r1)
c2 = show (getCon r2)
induced | v2== -2 = " INDUCED dependency to "
| otherwise = ""
maxWidths ruleTable vs
= map maximum (transpose (map getWidth vs))
where getWidth v | v<0 = [0,0,0,0]
| otherwise = map (length . show . ($ (ruleTable!v))) [getField, getAttr, getLhsNt, getCon]
alignL n xs | k<n = xs ++ replicate (n-k) ' '
| otherwise = xs
where k = length xs
alignR n xs | k<n = replicate (n-k) ' ' ++ xs
| otherwise = xs
where k = length xs
localCycleErr :: Table CRule -> Bool -> Route -> Error
localCycleErr ruleTable o_visit (s:path)
= let cr = ruleTable ! s
attr = getAttr cr
nt = getLhsNt cr
con = getCon cr
in LocalCirc nt con attr o_visit (showPathLocal ruleTable path)
instCycleErr :: Table CRule -> Bool -> Route -> Error
instCycleErr ruleTable o_visit (s:path)
= let cr = ruleTable ! s
attr = getAttr cr
nt = getLhsNt cr
con = getCon cr
in InstCirc nt con attr o_visit (showPathLocal ruleTable path)
directCycleErrs :: Table NTAttr -> Table CRule -> Bool -> [EdgeRoutes] -> [Error]
directCycleErrs attrTable ruleTable o_visit xs
= let getNont v = case attrTable ! v of
NTASyn nt _ _ -> nt
NTAInh nt _ _ -> nt
getAttr v = case attrTable ! v of
NTASyn _ a _ -> a
NTAInh _ a _ -> a
sameNont ((v1,_),_,_) ((v2,_),_,_) = getNont v1 == getNont v2
procCycle ((v1,v2),p1,p2) = ((getAttr v1, getAttr v2), showPathNice ruleTable p1, showPathNice ruleTable p2)
wrapGroup gr@(((v1,_),_,_):_) = DirectCirc (getNont v1) o_visit (map procCycle gr)
in map wrapGroup (groupBy sameNont xs)
inducedCycleErrs :: Table NTAttr -> Table CRule -> CInterfaceMap -> [EdgeRoutes] -> [Error]
inducedCycleErrs attrTable ruleTable cim xs
= let getNont v = case attrTable ! v of
NTASyn nt _ _ -> nt
NTAInh nt _ _ -> nt
getAttr v = case attrTable ! v of
NTASyn _ a _ -> a
NTAInh _ a _ -> a
sameNont ((v1,_),_,_) ((v2,_),_,_) = getNont v1 == getNont v2
procCycle ((v1,v2),p1,p2) = ((getAttr v1, getAttr v2), showPathNice ruleTable p1, showPathNice ruleTable p2)
wrapGroup gr@(((v1,_),_,_):_) = InducedCirc (getNont v1) (findWithErr1 "inducedCycleErr.cinter" (getNont v1) cim) (map procCycle gr)
in map wrapGroup (groupBy sameNont xs)
{-# LINE 238 "src-generated/TfmToMirage.hs" #-}
{-# LINE 13 "src-ag/TfmToMirage.ag" #-}
typeToMirage :: Type -> Mirage.Type
typeToMirage x = case x of
Haskell y -> Mirage.Haskell y
NT y ys _ -> Mirage.NT (getName y) ys
Self -> Mirage.Self
{-# LINE 247 "src-generated/TfmToMirage.hs" #-}
-- Child -------------------------------------------------------
-- wrapper
data Inh_Child = Inh_Child { allfields_Inh_Child :: ([(Identifier,Type,ChildKind)]), allnts_Inh_Child :: ([Identifier]), attrs_Inh_Child :: ([(Identifier,Identifier)]), con_Inh_Child :: (Identifier), inh_Inh_Child :: (Attributes), inhMap_Inh_Child :: (Map Identifier Attributes), mergeMap_Inh_Child :: (Map Identifier (Identifier,[Identifier])), nt_Inh_Child :: (Identifier), o_unbox_Inh_Child :: (Bool), syn_Inh_Child :: (Attributes), synMap_Inh_Child :: (Map Identifier Attributes) }
data Syn_Child = Syn_Child { attributes_Syn_Child :: ([(Identifier,Attributes,Attributes)]), collectChildrenInhs_Syn_Child :: (Map Identifier Attributes ), collectChildrenSyns_Syn_Child :: (Map Identifier Attributes ), errors_Syn_Child :: (Seq Error), field_Syn_Child :: ((Identifier,Type,ChildKind)), gathAltAttrs_Syn_Child :: ([AltAttr]), gathRules_Syn_Child :: (Seq CRule), inhs_Syn_Child :: (Seq (Identifier,Attributes)), mirage_Syn_Child :: (Mirage.Child), nts_Syn_Child :: (Seq (Identifier,NontermIdent)), singlevisits_Syn_Child :: ([CRule]), terminals_Syn_Child :: ([Identifier]) }
{-# INLINABLE wrap_Child #-}
wrap_Child :: T_Child -> Inh_Child -> (Syn_Child )
wrap_Child (T_Child act) (Inh_Child _lhsIallfields _lhsIallnts _lhsIattrs _lhsIcon _lhsIinh _lhsIinhMap _lhsImergeMap _lhsInt _lhsIo_unbox _lhsIsyn _lhsIsynMap) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg1 = T_Child_vIn1 _lhsIallfields _lhsIallnts _lhsIattrs _lhsIcon _lhsIinh _lhsIinhMap _lhsImergeMap _lhsInt _lhsIo_unbox _lhsIsyn _lhsIsynMap
(T_Child_vOut1 _lhsOattributes _lhsOcollectChildrenInhs _lhsOcollectChildrenSyns _lhsOerrors _lhsOfield _lhsOgathAltAttrs _lhsOgathRules _lhsOinhs _lhsOmirage _lhsOnts _lhsOsinglevisits _lhsOterminals) <- return (inv_Child_s2 sem arg1)
return (Syn_Child _lhsOattributes _lhsOcollectChildrenInhs _lhsOcollectChildrenSyns _lhsOerrors _lhsOfield _lhsOgathAltAttrs _lhsOgathRules _lhsOinhs _lhsOmirage _lhsOnts _lhsOsinglevisits _lhsOterminals)
)
-- cata
{-# INLINE sem_Child #-}
sem_Child :: Child -> T_Child
sem_Child ( Child name_ tp_ kind_ ) = sem_Child_Child name_ tp_ kind_
-- semantic domain
newtype T_Child = T_Child {
attach_T_Child :: Identity (T_Child_s2 )
}
newtype T_Child_s2 = C_Child_s2 {
inv_Child_s2 :: (T_Child_v1 )
}
data T_Child_s3 = C_Child_s3
type T_Child_v1 = (T_Child_vIn1 ) -> (T_Child_vOut1 )
data T_Child_vIn1 = T_Child_vIn1 ([(Identifier,Type,ChildKind)]) ([Identifier]) ([(Identifier,Identifier)]) (Identifier) (Attributes) (Map Identifier Attributes) (Map Identifier (Identifier,[Identifier])) (Identifier) (Bool) (Attributes) (Map Identifier Attributes)
data T_Child_vOut1 = T_Child_vOut1 ([(Identifier,Attributes,Attributes)]) (Map Identifier Attributes ) (Map Identifier Attributes ) (Seq Error) ((Identifier,Type,ChildKind)) ([AltAttr]) (Seq CRule) (Seq (Identifier,Attributes)) (Mirage.Child) (Seq (Identifier,NontermIdent)) ([CRule]) ([Identifier])
{-# NOINLINE sem_Child_Child #-}
sem_Child_Child :: (Identifier) -> (Type) -> (ChildKind) -> T_Child
sem_Child_Child arg_name_ arg_tp_ arg_kind_ = T_Child (return st2) where
{-# NOINLINE st2 #-}
st2 = let
v1 :: T_Child_v1
v1 = \ (T_Child_vIn1 _lhsIallfields _lhsIallnts _lhsIattrs _lhsIcon _lhsIinh _lhsIinhMap _lhsImergeMap _lhsInt _lhsIo_unbox _lhsIsyn _lhsIsynMap) -> ( let
_chnt = rule0 arg_name_ arg_tp_
_inh = rule1 _chnt _lhsIinhMap
_syn = rule2 _chnt _lhsIsynMap
_maptolocal = rule3 _syn arg_tp_
_lhsOgathAltAttrs :: [AltAttr]
_lhsOgathAltAttrs = rule4 _maptolocal _syn arg_name_
_lhsOnts :: Seq (Identifier,NontermIdent)
_lhsOnts = rule5 arg_name_ arg_tp_
_lhsOinhs :: Seq (Identifier,Attributes)
_lhsOinhs = rule6 _inh arg_name_
_gathRules = rule7 _lhsIcon _lhsInt _maptolocal _syn arg_name_ arg_tp_
_lhsOcollectChildrenSyns :: Map Identifier Attributes
_lhsOcollectChildrenSyns = rule8 _syn arg_name_
_lhsOcollectChildrenInhs :: Map Identifier Attributes
_lhsOcollectChildrenInhs = rule9 _inh arg_name_
_lhsOsinglevisits :: [CRule]
_lhsOsinglevisits = rule10 _inh _maptolocal _syn arg_name_ arg_tp_
_lhsOterminals :: [Identifier]
_lhsOterminals = rule11 _maptolocal arg_name_
_lhsOattributes :: [(Identifier,Attributes,Attributes)]
_lhsOattributes = rule12 _inh _syn arg_name_
_lhsOfield :: (Identifier,Type,ChildKind)
_lhsOfield = rule13 arg_kind_ arg_name_ arg_tp_
_lhsOmirage :: Mirage.Child
_lhsOmirage = rule14 arg_name_ arg_tp_
_lhsOerrors :: Seq Error
_lhsOerrors = rule15 ()
_lhsOgathRules :: Seq CRule
_lhsOgathRules = rule16 _gathRules
__result_ = T_Child_vOut1 _lhsOattributes _lhsOcollectChildrenInhs _lhsOcollectChildrenSyns _lhsOerrors _lhsOfield _lhsOgathAltAttrs _lhsOgathRules _lhsOinhs _lhsOmirage _lhsOnts _lhsOsinglevisits _lhsOterminals
in __result_ )
in C_Child_s2 v1
{-# INLINE rule0 #-}
{-# LINE 19 "src-ag/DistChildAttr.ag" #-}
rule0 = \ name_ tp_ ->
{-# LINE 19 "src-ag/DistChildAttr.ag" #-}
case tp_ of
NT nt _ _ -> nt
Self -> error ("The type of child " ++ show name_ ++ " should not be a Self type.")
Haskell t -> identifier ""
{-# LINE 325 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule1 #-}
{-# LINE 23 "src-ag/DistChildAttr.ag" #-}
rule1 = \ _chnt ((_lhsIinhMap) :: Map Identifier Attributes) ->
{-# LINE 23 "src-ag/DistChildAttr.ag" #-}
Map.findWithDefault Map.empty _chnt _lhsIinhMap
{-# LINE 331 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule2 #-}
{-# LINE 24 "src-ag/DistChildAttr.ag" #-}
rule2 = \ _chnt ((_lhsIsynMap) :: Map Identifier Attributes) ->
{-# LINE 24 "src-ag/DistChildAttr.ag" #-}
Map.findWithDefault Map.empty _chnt _lhsIsynMap
{-# LINE 337 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule3 #-}
{-# LINE 180 "src-ag/Order.ag" #-}
rule3 = \ _syn tp_ ->
{-# LINE 180 "src-ag/Order.ag" #-}
case tp_ of
NT nt _ _ -> Map.null _syn
_ -> True
{-# LINE 345 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule4 #-}
{-# LINE 183 "src-ag/Order.ag" #-}
rule4 = \ _maptolocal _syn name_ ->
{-# LINE 183 "src-ag/Order.ag" #-}
if _maptolocal
then [ AltAttr _LOC name_ True ]
else [ AltAttr name_ syn True | syn <- Map.keys _syn ]
{-# LINE 353 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule5 #-}
{-# LINE 198 "src-ag/Order.ag" #-}
rule5 = \ name_ tp_ ->
{-# LINE 198 "src-ag/Order.ag" #-}
Seq.singleton (name_,getNtName tp_)
{-# LINE 359 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule6 #-}
{-# LINE 199 "src-ag/Order.ag" #-}
rule6 = \ _inh name_ ->
{-# LINE 199 "src-ag/Order.ag" #-}
Seq.singleton (name_,_inh )
{-# LINE 365 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule7 #-}
{-# LINE 215 "src-ag/Order.ag" #-}
rule7 = \ ((_lhsIcon) :: Identifier) ((_lhsInt) :: Identifier) _maptolocal _syn name_ tp_ ->
{-# LINE 215 "src-ag/Order.ag" #-}
if _maptolocal
then Seq.singleton (cRuleTerminal name_ _lhsInt _lhsIcon tp_)
else Seq.fromList [ cRuleRhsSyn syn _lhsInt _lhsIcon tp name_ (getNtName tp_) | (syn,tp) <- Map.assocs _syn ]
{-# LINE 373 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule8 #-}
{-# LINE 347 "src-ag/Order.ag" #-}
rule8 = \ _syn name_ ->
{-# LINE 347 "src-ag/Order.ag" #-}
Map.singleton name_ _syn
{-# LINE 379 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule9 #-}
{-# LINE 348 "src-ag/Order.ag" #-}
rule9 = \ _inh name_ ->
{-# LINE 348 "src-ag/Order.ag" #-}
Map.singleton name_ _inh
{-# LINE 385 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule10 #-}
{-# LINE 618 "src-ag/Order.ag" #-}
rule10 = \ _inh _maptolocal _syn name_ tp_ ->
{-# LINE 618 "src-ag/Order.ag" #-}
if _maptolocal
then []
else [CChildVisit name_ (getNtName tp_) 0 _inh _syn True]
{-# LINE 393 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule11 #-}
{-# LINE 643 "src-ag/Order.ag" #-}
rule11 = \ _maptolocal name_ ->
{-# LINE 643 "src-ag/Order.ag" #-}
if _maptolocal
then [name_]
else []
{-# LINE 401 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule12 #-}
{-# LINE 672 "src-ag/Order.ag" #-}
rule12 = \ _inh _syn name_ ->
{-# LINE 672 "src-ag/Order.ag" #-}
[(name_, _inh , _syn )]
{-# LINE 407 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule13 #-}
{-# LINE 676 "src-ag/Order.ag" #-}
rule13 = \ kind_ name_ tp_ ->
{-# LINE 676 "src-ag/Order.ag" #-}
(name_, tp_, kind_)
{-# LINE 413 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule14 #-}
{-# LINE 50 "src-ag/TfmToMirage.ag" #-}
rule14 = \ name_ tp_ ->
{-# LINE 50 "src-ag/TfmToMirage.ag" #-}
Mirage.Child (getName name_) (typeToMirage tp_)
{-# LINE 419 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule15 #-}
rule15 = \ (_ :: ()) ->
Seq.empty
{-# INLINE rule16 #-}
rule16 = \ _gathRules ->
_gathRules
-- Children ----------------------------------------------------
-- wrapper
data Inh_Children = Inh_Children { allfields_Inh_Children :: ([(Identifier,Type,ChildKind)]), allnts_Inh_Children :: ([Identifier]), attrs_Inh_Children :: ([(Identifier,Identifier)]), con_Inh_Children :: (Identifier), inh_Inh_Children :: (Attributes), inhMap_Inh_Children :: (Map Identifier Attributes), mergeMap_Inh_Children :: (Map Identifier (Identifier,[Identifier])), nt_Inh_Children :: (Identifier), o_unbox_Inh_Children :: (Bool), syn_Inh_Children :: (Attributes), synMap_Inh_Children :: (Map Identifier Attributes) }
data Syn_Children = Syn_Children { attributes_Syn_Children :: ([(Identifier,Attributes,Attributes)]), collectChildrenInhs_Syn_Children :: (Map Identifier Attributes ), collectChildrenSyns_Syn_Children :: (Map Identifier Attributes ), errors_Syn_Children :: (Seq Error), fields_Syn_Children :: ([(Identifier,Type,ChildKind)]), gathAltAttrs_Syn_Children :: ([AltAttr]), gathRules_Syn_Children :: (Seq CRule), inhs_Syn_Children :: (Seq (Identifier,Attributes)), mirages_Syn_Children :: ([Mirage.Child]), nts_Syn_Children :: (Seq (Identifier,NontermIdent)), singlevisits_Syn_Children :: ([CRule]), terminals_Syn_Children :: ([Identifier]) }
{-# INLINABLE wrap_Children #-}
wrap_Children :: T_Children -> Inh_Children -> (Syn_Children )
wrap_Children (T_Children act) (Inh_Children _lhsIallfields _lhsIallnts _lhsIattrs _lhsIcon _lhsIinh _lhsIinhMap _lhsImergeMap _lhsInt _lhsIo_unbox _lhsIsyn _lhsIsynMap) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg4 = T_Children_vIn4 _lhsIallfields _lhsIallnts _lhsIattrs _lhsIcon _lhsIinh _lhsIinhMap _lhsImergeMap _lhsInt _lhsIo_unbox _lhsIsyn _lhsIsynMap
(T_Children_vOut4 _lhsOattributes _lhsOcollectChildrenInhs _lhsOcollectChildrenSyns _lhsOerrors _lhsOfields _lhsOgathAltAttrs _lhsOgathRules _lhsOinhs _lhsOmirages _lhsOnts _lhsOsinglevisits _lhsOterminals) <- return (inv_Children_s5 sem arg4)
return (Syn_Children _lhsOattributes _lhsOcollectChildrenInhs _lhsOcollectChildrenSyns _lhsOerrors _lhsOfields _lhsOgathAltAttrs _lhsOgathRules _lhsOinhs _lhsOmirages _lhsOnts _lhsOsinglevisits _lhsOterminals)
)
-- cata
{-# NOINLINE sem_Children #-}
sem_Children :: Children -> T_Children
sem_Children list = Prelude.foldr sem_Children_Cons sem_Children_Nil (Prelude.map sem_Child list)
-- semantic domain
newtype T_Children = T_Children {
attach_T_Children :: Identity (T_Children_s5 )
}
newtype T_Children_s5 = C_Children_s5 {
inv_Children_s5 :: (T_Children_v4 )
}
data T_Children_s6 = C_Children_s6
type T_Children_v4 = (T_Children_vIn4 ) -> (T_Children_vOut4 )
data T_Children_vIn4 = T_Children_vIn4 ([(Identifier,Type,ChildKind)]) ([Identifier]) ([(Identifier,Identifier)]) (Identifier) (Attributes) (Map Identifier Attributes) (Map Identifier (Identifier,[Identifier])) (Identifier) (Bool) (Attributes) (Map Identifier Attributes)
data T_Children_vOut4 = T_Children_vOut4 ([(Identifier,Attributes,Attributes)]) (Map Identifier Attributes ) (Map Identifier Attributes ) (Seq Error) ([(Identifier,Type,ChildKind)]) ([AltAttr]) (Seq CRule) (Seq (Identifier,Attributes)) ([Mirage.Child]) (Seq (Identifier,NontermIdent)) ([CRule]) ([Identifier])
{-# NOINLINE sem_Children_Cons #-}
sem_Children_Cons :: T_Child -> T_Children -> T_Children
sem_Children_Cons arg_hd_ arg_tl_ = T_Children (return st5) where
{-# NOINLINE st5 #-}
st5 = let
v4 :: T_Children_v4
v4 = \ (T_Children_vIn4 _lhsIallfields _lhsIallnts _lhsIattrs _lhsIcon _lhsIinh _lhsIinhMap _lhsImergeMap _lhsInt _lhsIo_unbox _lhsIsyn _lhsIsynMap) -> ( let
_hdX2 = Control.Monad.Identity.runIdentity (attach_T_Child (arg_hd_))
_tlX5 = Control.Monad.Identity.runIdentity (attach_T_Children (arg_tl_))
(T_Child_vOut1 _hdIattributes _hdIcollectChildrenInhs _hdIcollectChildrenSyns _hdIerrors _hdIfield _hdIgathAltAttrs _hdIgathRules _hdIinhs _hdImirage _hdInts _hdIsinglevisits _hdIterminals) = inv_Child_s2 _hdX2 (T_Child_vIn1 _hdOallfields _hdOallnts _hdOattrs _hdOcon _hdOinh _hdOinhMap _hdOmergeMap _hdOnt _hdOo_unbox _hdOsyn _hdOsynMap)
(T_Children_vOut4 _tlIattributes _tlIcollectChildrenInhs _tlIcollectChildrenSyns _tlIerrors _tlIfields _tlIgathAltAttrs _tlIgathRules _tlIinhs _tlImirages _tlInts _tlIsinglevisits _tlIterminals) = inv_Children_s5 _tlX5 (T_Children_vIn4 _tlOallfields _tlOallnts _tlOattrs _tlOcon _tlOinh _tlOinhMap _tlOmergeMap _tlOnt _tlOo_unbox _tlOsyn _tlOsynMap)
_lhsOfields :: [(Identifier,Type,ChildKind)]
_lhsOfields = rule17 _hdIfield _tlIfields
_lhsOmirages :: [Mirage.Child]
_lhsOmirages = rule18 _hdImirage _tlImirages
_lhsOattributes :: [(Identifier,Attributes,Attributes)]
_lhsOattributes = rule19 _hdIattributes _tlIattributes
_lhsOcollectChildrenInhs :: Map Identifier Attributes
_lhsOcollectChildrenInhs = rule20 _hdIcollectChildrenInhs _tlIcollectChildrenInhs
_lhsOcollectChildrenSyns :: Map Identifier Attributes
_lhsOcollectChildrenSyns = rule21 _hdIcollectChildrenSyns _tlIcollectChildrenSyns
_lhsOerrors :: Seq Error
_lhsOerrors = rule22 _hdIerrors _tlIerrors
_lhsOgathAltAttrs :: [AltAttr]
_lhsOgathAltAttrs = rule23 _hdIgathAltAttrs _tlIgathAltAttrs
_lhsOgathRules :: Seq CRule
_lhsOgathRules = rule24 _hdIgathRules _tlIgathRules
_lhsOinhs :: Seq (Identifier,Attributes)
_lhsOinhs = rule25 _hdIinhs _tlIinhs
_lhsOnts :: Seq (Identifier,NontermIdent)
_lhsOnts = rule26 _hdInts _tlInts
_lhsOsinglevisits :: [CRule]
_lhsOsinglevisits = rule27 _hdIsinglevisits _tlIsinglevisits
_lhsOterminals :: [Identifier]
_lhsOterminals = rule28 _hdIterminals _tlIterminals
_hdOallfields = rule29 _lhsIallfields
_hdOallnts = rule30 _lhsIallnts
_hdOattrs = rule31 _lhsIattrs
_hdOcon = rule32 _lhsIcon
_hdOinh = rule33 _lhsIinh
_hdOinhMap = rule34 _lhsIinhMap
_hdOmergeMap = rule35 _lhsImergeMap
_hdOnt = rule36 _lhsInt
_hdOo_unbox = rule37 _lhsIo_unbox
_hdOsyn = rule38 _lhsIsyn
_hdOsynMap = rule39 _lhsIsynMap
_tlOallfields = rule40 _lhsIallfields
_tlOallnts = rule41 _lhsIallnts
_tlOattrs = rule42 _lhsIattrs
_tlOcon = rule43 _lhsIcon
_tlOinh = rule44 _lhsIinh
_tlOinhMap = rule45 _lhsIinhMap
_tlOmergeMap = rule46 _lhsImergeMap
_tlOnt = rule47 _lhsInt
_tlOo_unbox = rule48 _lhsIo_unbox
_tlOsyn = rule49 _lhsIsyn
_tlOsynMap = rule50 _lhsIsynMap
__result_ = T_Children_vOut4 _lhsOattributes _lhsOcollectChildrenInhs _lhsOcollectChildrenSyns _lhsOerrors _lhsOfields _lhsOgathAltAttrs _lhsOgathRules _lhsOinhs _lhsOmirages _lhsOnts _lhsOsinglevisits _lhsOterminals
in __result_ )
in C_Children_s5 v4
{-# INLINE rule17 #-}
{-# LINE 679 "src-ag/Order.ag" #-}
rule17 = \ ((_hdIfield) :: (Identifier,Type,ChildKind)) ((_tlIfields) :: [(Identifier,Type,ChildKind)]) ->
{-# LINE 679 "src-ag/Order.ag" #-}
_hdIfield : _tlIfields
{-# LINE 522 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule18 #-}
{-# LINE 46 "src-ag/TfmToMirage.ag" #-}
rule18 = \ ((_hdImirage) :: Mirage.Child) ((_tlImirages) :: [Mirage.Child]) ->
{-# LINE 46 "src-ag/TfmToMirage.ag" #-}
_hdImirage : _tlImirages
{-# LINE 528 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule19 #-}
rule19 = \ ((_hdIattributes) :: [(Identifier,Attributes,Attributes)]) ((_tlIattributes) :: [(Identifier,Attributes,Attributes)]) ->
_hdIattributes ++ _tlIattributes
{-# INLINE rule20 #-}
rule20 = \ ((_hdIcollectChildrenInhs) :: Map Identifier Attributes ) ((_tlIcollectChildrenInhs) :: Map Identifier Attributes ) ->
_hdIcollectChildrenInhs `Map.union` _tlIcollectChildrenInhs
{-# INLINE rule21 #-}
rule21 = \ ((_hdIcollectChildrenSyns) :: Map Identifier Attributes ) ((_tlIcollectChildrenSyns) :: Map Identifier Attributes ) ->
_hdIcollectChildrenSyns `Map.union` _tlIcollectChildrenSyns
{-# INLINE rule22 #-}
rule22 = \ ((_hdIerrors) :: Seq Error) ((_tlIerrors) :: Seq Error) ->
_hdIerrors Seq.>< _tlIerrors
{-# INLINE rule23 #-}
rule23 = \ ((_hdIgathAltAttrs) :: [AltAttr]) ((_tlIgathAltAttrs) :: [AltAttr]) ->
_hdIgathAltAttrs ++ _tlIgathAltAttrs
{-# INLINE rule24 #-}
rule24 = \ ((_hdIgathRules) :: Seq CRule) ((_tlIgathRules) :: Seq CRule) ->
_hdIgathRules Seq.>< _tlIgathRules
{-# INLINE rule25 #-}
rule25 = \ ((_hdIinhs) :: Seq (Identifier,Attributes)) ((_tlIinhs) :: Seq (Identifier,Attributes)) ->
_hdIinhs Seq.>< _tlIinhs
{-# INLINE rule26 #-}
rule26 = \ ((_hdInts) :: Seq (Identifier,NontermIdent)) ((_tlInts) :: Seq (Identifier,NontermIdent)) ->
_hdInts Seq.>< _tlInts
{-# INLINE rule27 #-}
rule27 = \ ((_hdIsinglevisits) :: [CRule]) ((_tlIsinglevisits) :: [CRule]) ->
_hdIsinglevisits ++ _tlIsinglevisits
{-# INLINE rule28 #-}
rule28 = \ ((_hdIterminals) :: [Identifier]) ((_tlIterminals) :: [Identifier]) ->
_hdIterminals ++ _tlIterminals
{-# INLINE rule29 #-}
rule29 = \ ((_lhsIallfields) :: [(Identifier,Type,ChildKind)]) ->
_lhsIallfields
{-# INLINE rule30 #-}
rule30 = \ ((_lhsIallnts) :: [Identifier]) ->
_lhsIallnts
{-# INLINE rule31 #-}
rule31 = \ ((_lhsIattrs) :: [(Identifier,Identifier)]) ->
_lhsIattrs
{-# INLINE rule32 #-}
rule32 = \ ((_lhsIcon) :: Identifier) ->
_lhsIcon
{-# INLINE rule33 #-}
rule33 = \ ((_lhsIinh) :: Attributes) ->
_lhsIinh
{-# INLINE rule34 #-}
rule34 = \ ((_lhsIinhMap) :: Map Identifier Attributes) ->
_lhsIinhMap
{-# INLINE rule35 #-}
rule35 = \ ((_lhsImergeMap) :: Map Identifier (Identifier,[Identifier])) ->
_lhsImergeMap
{-# INLINE rule36 #-}
rule36 = \ ((_lhsInt) :: Identifier) ->
_lhsInt
{-# INLINE rule37 #-}
rule37 = \ ((_lhsIo_unbox) :: Bool) ->
_lhsIo_unbox
{-# INLINE rule38 #-}
rule38 = \ ((_lhsIsyn) :: Attributes) ->
_lhsIsyn
{-# INLINE rule39 #-}
rule39 = \ ((_lhsIsynMap) :: Map Identifier Attributes) ->
_lhsIsynMap
{-# INLINE rule40 #-}
rule40 = \ ((_lhsIallfields) :: [(Identifier,Type,ChildKind)]) ->
_lhsIallfields
{-# INLINE rule41 #-}
rule41 = \ ((_lhsIallnts) :: [Identifier]) ->
_lhsIallnts
{-# INLINE rule42 #-}
rule42 = \ ((_lhsIattrs) :: [(Identifier,Identifier)]) ->
_lhsIattrs
{-# INLINE rule43 #-}
rule43 = \ ((_lhsIcon) :: Identifier) ->
_lhsIcon
{-# INLINE rule44 #-}
rule44 = \ ((_lhsIinh) :: Attributes) ->
_lhsIinh
{-# INLINE rule45 #-}
rule45 = \ ((_lhsIinhMap) :: Map Identifier Attributes) ->
_lhsIinhMap
{-# INLINE rule46 #-}
rule46 = \ ((_lhsImergeMap) :: Map Identifier (Identifier,[Identifier])) ->
_lhsImergeMap
{-# INLINE rule47 #-}
rule47 = \ ((_lhsInt) :: Identifier) ->
_lhsInt
{-# INLINE rule48 #-}
rule48 = \ ((_lhsIo_unbox) :: Bool) ->
_lhsIo_unbox
{-# INLINE rule49 #-}
rule49 = \ ((_lhsIsyn) :: Attributes) ->
_lhsIsyn
{-# INLINE rule50 #-}
rule50 = \ ((_lhsIsynMap) :: Map Identifier Attributes) ->
_lhsIsynMap
{-# NOINLINE sem_Children_Nil #-}
sem_Children_Nil :: T_Children
sem_Children_Nil = T_Children (return st5) where
{-# NOINLINE st5 #-}
st5 = let
v4 :: T_Children_v4
v4 = \ (T_Children_vIn4 _lhsIallfields _lhsIallnts _lhsIattrs _lhsIcon _lhsIinh _lhsIinhMap _lhsImergeMap _lhsInt _lhsIo_unbox _lhsIsyn _lhsIsynMap) -> ( let
_lhsOfields :: [(Identifier,Type,ChildKind)]
_lhsOfields = rule51 ()
_lhsOmirages :: [Mirage.Child]
_lhsOmirages = rule52 ()
_lhsOattributes :: [(Identifier,Attributes,Attributes)]
_lhsOattributes = rule53 ()
_lhsOcollectChildrenInhs :: Map Identifier Attributes
_lhsOcollectChildrenInhs = rule54 ()
_lhsOcollectChildrenSyns :: Map Identifier Attributes
_lhsOcollectChildrenSyns = rule55 ()
_lhsOerrors :: Seq Error
_lhsOerrors = rule56 ()
_lhsOgathAltAttrs :: [AltAttr]
_lhsOgathAltAttrs = rule57 ()
_lhsOgathRules :: Seq CRule
_lhsOgathRules = rule58 ()
_lhsOinhs :: Seq (Identifier,Attributes)
_lhsOinhs = rule59 ()
_lhsOnts :: Seq (Identifier,NontermIdent)
_lhsOnts = rule60 ()
_lhsOsinglevisits :: [CRule]
_lhsOsinglevisits = rule61 ()
_lhsOterminals :: [Identifier]
_lhsOterminals = rule62 ()
__result_ = T_Children_vOut4 _lhsOattributes _lhsOcollectChildrenInhs _lhsOcollectChildrenSyns _lhsOerrors _lhsOfields _lhsOgathAltAttrs _lhsOgathRules _lhsOinhs _lhsOmirages _lhsOnts _lhsOsinglevisits _lhsOterminals
in __result_ )
in C_Children_s5 v4
{-# INLINE rule51 #-}
{-# LINE 680 "src-ag/Order.ag" #-}
rule51 = \ (_ :: ()) ->
{-# LINE 680 "src-ag/Order.ag" #-}
[]
{-# LINE 664 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule52 #-}
{-# LINE 47 "src-ag/TfmToMirage.ag" #-}
rule52 = \ (_ :: ()) ->
{-# LINE 47 "src-ag/TfmToMirage.ag" #-}
[]
{-# LINE 670 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule53 #-}
rule53 = \ (_ :: ()) ->
[]
{-# INLINE rule54 #-}
rule54 = \ (_ :: ()) ->
Map.empty
{-# INLINE rule55 #-}
rule55 = \ (_ :: ()) ->
Map.empty
{-# INLINE rule56 #-}
rule56 = \ (_ :: ()) ->
Seq.empty
{-# INLINE rule57 #-}
rule57 = \ (_ :: ()) ->
[]
{-# INLINE rule58 #-}
rule58 = \ (_ :: ()) ->
Seq.empty
{-# INLINE rule59 #-}
rule59 = \ (_ :: ()) ->
Seq.empty
{-# INLINE rule60 #-}
rule60 = \ (_ :: ()) ->
Seq.empty
{-# INLINE rule61 #-}
rule61 = \ (_ :: ()) ->
[]
{-# INLINE rule62 #-}
rule62 = \ (_ :: ()) ->
[]
-- Expression --------------------------------------------------
-- wrapper
data Inh_Expression = Inh_Expression { allfields_Inh_Expression :: ([(Identifier,Type,ChildKind)]), allnts_Inh_Expression :: ([Identifier]), attrs_Inh_Expression :: ([(Identifier,Identifier)]), con_Inh_Expression :: (Identifier), mergeMap_Inh_Expression :: (Map Identifier (Identifier,[Identifier])), nt_Inh_Expression :: (Identifier), options_Inh_Expression :: (Options) }
data Syn_Expression = Syn_Expression { allRhsVars_Syn_Expression :: (Set (Identifier,Identifier)), copy_Syn_Expression :: (Expression), errors_Syn_Expression :: (Seq Error), lns_Syn_Expression :: ([String]), textLines_Syn_Expression :: ([String]), usedAttrs_Syn_Expression :: ([(Identifier,Identifier)]), usedFields_Syn_Expression :: ([Identifier]), usedLocals_Syn_Expression :: ([Identifier]) }
{-# INLINABLE wrap_Expression #-}
wrap_Expression :: T_Expression -> Inh_Expression -> (Syn_Expression )
wrap_Expression (T_Expression act) (Inh_Expression _lhsIallfields _lhsIallnts _lhsIattrs _lhsIcon _lhsImergeMap _lhsInt _lhsIoptions) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg7 = T_Expression_vIn7 _lhsIallfields _lhsIallnts _lhsIattrs _lhsIcon _lhsImergeMap _lhsInt _lhsIoptions
(T_Expression_vOut7 _lhsOallRhsVars _lhsOcopy _lhsOerrors _lhsOlns _lhsOtextLines _lhsOusedAttrs _lhsOusedFields _lhsOusedLocals) <- return (inv_Expression_s8 sem arg7)
return (Syn_Expression _lhsOallRhsVars _lhsOcopy _lhsOerrors _lhsOlns _lhsOtextLines _lhsOusedAttrs _lhsOusedFields _lhsOusedLocals)
)
-- cata
{-# INLINE sem_Expression #-}
sem_Expression :: Expression -> T_Expression
sem_Expression ( Expression pos_ tks_ ) = sem_Expression_Expression pos_ tks_
-- semantic domain
newtype T_Expression = T_Expression {
attach_T_Expression :: Identity (T_Expression_s8 )
}
newtype T_Expression_s8 = C_Expression_s8 {
inv_Expression_s8 :: (T_Expression_v7 )
}
data T_Expression_s9 = C_Expression_s9
type T_Expression_v7 = (T_Expression_vIn7 ) -> (T_Expression_vOut7 )
data T_Expression_vIn7 = T_Expression_vIn7 ([(Identifier,Type,ChildKind)]) ([Identifier]) ([(Identifier,Identifier)]) (Identifier) (Map Identifier (Identifier,[Identifier])) (Identifier) (Options)
data T_Expression_vOut7 = T_Expression_vOut7 (Set (Identifier,Identifier)) (Expression) (Seq Error) ([String]) ([String]) ([(Identifier,Identifier)]) ([Identifier]) ([Identifier])
{-# NOINLINE sem_Expression_Expression #-}
sem_Expression_Expression :: (Pos) -> ([HsToken]) -> T_Expression
sem_Expression_Expression arg_pos_ arg_tks_ = T_Expression (return st8) where
{-# NOINLINE st8 #-}
st8 = let
v7 :: T_Expression_v7
v7 = \ (T_Expression_vIn7 _lhsIallfields _lhsIallnts _lhsIattrs _lhsIcon _lhsImergeMap _lhsInt _lhsIoptions) -> ( let
(_textLines,_usedAttrs,_usedLocals,_usedFields) = rule63 _lhsIallfields _lhsIallnts _lhsIattrs _lhsIcon _lhsImergeMap _lhsInt _lhsIoptions arg_tks_
_lhsOerrors :: Seq Error
_lhsOerrors = rule64 ()
_lhsOallRhsVars :: Set (Identifier,Identifier)
_lhsOallRhsVars = rule65 _usedAttrs _usedFields _usedLocals
_lhsOlns :: [String]
_lhsOlns = rule66 arg_tks_
_copy = rule67 arg_pos_ arg_tks_
_lhsOcopy :: Expression
_lhsOcopy = rule68 _copy
_lhsOtextLines :: [String]
_lhsOtextLines = rule69 _textLines
_lhsOusedAttrs :: [(Identifier,Identifier)]
_lhsOusedAttrs = rule70 _usedAttrs
_lhsOusedFields :: [Identifier]
_lhsOusedFields = rule71 _usedFields
_lhsOusedLocals :: [Identifier]
_lhsOusedLocals = rule72 _usedLocals
__result_ = T_Expression_vOut7 _lhsOallRhsVars _lhsOcopy _lhsOerrors _lhsOlns _lhsOtextLines _lhsOusedAttrs _lhsOusedFields _lhsOusedLocals
in __result_ )
in C_Expression_s8 v7
{-# INLINE rule63 #-}
{-# LINE 469 "src-ag/Order.ag" #-}
rule63 = \ ((_lhsIallfields) :: [(Identifier,Type,ChildKind)]) ((_lhsIallnts) :: [Identifier]) ((_lhsIattrs) :: [(Identifier,Identifier)]) ((_lhsIcon) :: Identifier) ((_lhsImergeMap) :: Map Identifier (Identifier,[Identifier])) ((_lhsInt) :: Identifier) ((_lhsIoptions) :: Options) tks_ ->
{-# LINE 469 "src-ag/Order.ag" #-}
let mergedChildren = [ x | (_,xs) <- Map.elems _lhsImergeMap, x <- xs ]
attrsIn = filter (\(fld,_) -> not (fld `elem` mergedChildren)) _lhsIattrs
inherited = Inh_HsTokensRoot
{ attrs_Inh_HsTokensRoot = attrsIn
, con_Inh_HsTokensRoot = _lhsIcon
, allfields_Inh_HsTokensRoot = _lhsIallfields
, allnts_Inh_HsTokensRoot = _lhsIallnts
, nt_Inh_HsTokensRoot = _lhsInt
, options_Inh_HsTokensRoot = _lhsIoptions
}
synthesized = wrap_HsTokensRoot (sem_HsTokensRoot (HsTokensRoot tks_)) inherited
in case synthesized of
Syn_HsTokensRoot
{ textLines_Syn_HsTokensRoot = textLines
, usedAttrs_Syn_HsTokensRoot = usedAttrs
, usedLocals_Syn_HsTokensRoot = usedLocals
, usedFields_Syn_HsTokensRoot = usedFields
} -> let extraAttrs = [ (src,attr)
| (fld,attr) <- usedAttrs, let mbMerged = Map.lookup fld _lhsImergeMap, isJust mbMerged
, let (Just (_, srcs)) = mbMerged, src <- srcs ]
usedAttrs' = usedAttrs ++ extraAttrs
in (textLines,usedAttrs',usedLocals,usedFields)
{-# LINE 786 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule64 #-}
{-# LINE 492 "src-ag/Order.ag" #-}
rule64 = \ (_ :: ()) ->
{-# LINE 492 "src-ag/Order.ag" #-}
Seq.empty
{-# LINE 792 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule65 #-}
{-# LINE 493 "src-ag/Order.ag" #-}
rule65 = \ _usedAttrs _usedFields _usedLocals ->
{-# LINE 493 "src-ag/Order.ag" #-}
Set.fromList _usedAttrs
`Set.union`
Set.fromList [ (_LOC, l) | l <- _usedLocals ]
`Set.union`
Set.fromList [ (_FIELD, fld) | fld <- _usedFields ]
{-# LINE 802 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule66 #-}
{-# LINE 71 "src-ag/TfmToMirage.ag" #-}
rule66 = \ tks_ ->
{-# LINE 71 "src-ag/TfmToMirage.ag" #-}
showTokens . tokensToStrings $ tks_
{-# LINE 808 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule67 #-}
rule67 = \ pos_ tks_ ->
Expression pos_ tks_
{-# INLINE rule68 #-}
rule68 = \ _copy ->
_copy
{-# INLINE rule69 #-}
rule69 = \ _textLines ->
_textLines
{-# INLINE rule70 #-}
rule70 = \ _usedAttrs ->
_usedAttrs
{-# INLINE rule71 #-}
rule71 = \ _usedFields ->
_usedFields
{-# INLINE rule72 #-}
rule72 = \ _usedLocals ->
_usedLocals
-- Grammar -----------------------------------------------------
-- wrapper
data Inh_Grammar = Inh_Grammar { options_Inh_Grammar :: (Options) }
data Syn_Grammar = Syn_Grammar { errors_Syn_Grammar :: (Seq Error), mirage_Syn_Grammar :: (Mirage.Grammar), nAutoRules_Syn_Grammar :: (Int), nExplicitRules_Syn_Grammar :: (Int), output_Syn_Grammar :: (CGrammar) }
{-# INLINABLE wrap_Grammar #-}
wrap_Grammar :: T_Grammar -> Inh_Grammar -> (Syn_Grammar )
wrap_Grammar (T_Grammar act) (Inh_Grammar _lhsIoptions) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg10 = T_Grammar_vIn10 _lhsIoptions
(T_Grammar_vOut10 _lhsOerrors _lhsOmirage _lhsOnAutoRules _lhsOnExplicitRules _lhsOoutput) <- return (inv_Grammar_s11 sem arg10)
return (Syn_Grammar _lhsOerrors _lhsOmirage _lhsOnAutoRules _lhsOnExplicitRules _lhsOoutput)
)
-- cata
{-# INLINE sem_Grammar #-}
sem_Grammar :: Grammar -> T_Grammar
sem_Grammar ( Grammar typeSyns_ useMap_ derivings_ wrappers_ nonts_ pragmas_ manualAttrOrderMap_ paramMap_ contextMap_ quantMap_ uniqueMap_ augmentsMap_ aroundsMap_ mergeMap_ ) = sem_Grammar_Grammar typeSyns_ useMap_ derivings_ wrappers_ ( sem_Nonterminals nonts_ ) pragmas_ manualAttrOrderMap_ paramMap_ contextMap_ quantMap_ uniqueMap_ augmentsMap_ aroundsMap_ mergeMap_
-- semantic domain
newtype T_Grammar = T_Grammar {
attach_T_Grammar :: Identity (T_Grammar_s11 )
}
newtype T_Grammar_s11 = C_Grammar_s11 {
inv_Grammar_s11 :: (T_Grammar_v10 )
}
data T_Grammar_s12 = C_Grammar_s12
type T_Grammar_v10 = (T_Grammar_vIn10 ) -> (T_Grammar_vOut10 )
data T_Grammar_vIn10 = T_Grammar_vIn10 (Options)
data T_Grammar_vOut10 = T_Grammar_vOut10 (Seq Error) (Mirage.Grammar) (Int) (Int) (CGrammar)
{-# NOINLINE sem_Grammar_Grammar #-}
sem_Grammar_Grammar :: (TypeSyns) -> (UseMap) -> (Derivings) -> (Set NontermIdent) -> T_Nonterminals -> (PragmaMap) -> (AttrOrderMap) -> (ParamMap) -> (ContextMap) -> (QuantMap) -> (UniqueMap) -> (Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))) -> (Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))) -> (Map NontermIdent (Map ConstructorIdent (Map Identifier (Identifier, [Identifier], Expression)))) -> T_Grammar
sem_Grammar_Grammar arg_typeSyns_ _ arg_derivings_ arg_wrappers_ arg_nonts_ arg_pragmas_ arg_manualAttrOrderMap_ arg_paramMap_ arg_contextMap_ arg_quantMap_ _ _ arg_aroundsMap_ arg_mergeMap_ = T_Grammar (return st11) where
{-# NOINLINE st11 #-}
st11 = let
v10 :: T_Grammar_v10
v10 = \ (T_Grammar_vIn10 _lhsIoptions) -> ( let
_nontsX17 = Control.Monad.Identity.runIdentity (attach_T_Nonterminals (arg_nonts_))
(T_Nonterminals_vOut16 _nontsIacount _nontsIadditionalDep _nontsIaranges _nontsIaroundDep _nontsIcNonterminals _nontsIdirectDep _nontsIerrors _nontsIinhMap' _nontsIinstDep _nontsImergeDep _nontsImirages _nontsInAutoRules _nontsInExplicitRules _nontsInonts _nontsIntattrs _nontsIrules _nontsIsynMap' _nontsIvcount) = inv_Nonterminals_s17 _nontsX17 (T_Nonterminals_vIn16 _nontsOacount _nontsOallnts _nontsOaroundMap _nontsOcInterfaceMap _nontsOcVisitsMap _nontsOinhMap _nontsOmanualAttrDepMap _nontsOmergeMap _nontsOo_case _nontsOo_cata _nontsOo_data _nontsOo_dovisit _nontsOo_newtypes _nontsOo_rename _nontsOo_sem _nontsOo_sig _nontsOo_unbox _nontsOo_wantvisit _nontsOoptions _nontsOprefix _nontsOsynMap _nontsOvcount)
_nontsOinhMap = rule73 _nontsIinhMap'
_nontsOsynMap = rule74 _nontsIsynMap'
_o_dovisit = rule75 _cyclesErrors _lhsIoptions
_nontsOo_cata = rule76 _lhsIoptions
_nontsOo_data = rule77 _lhsIoptions
_nontsOo_sig = rule78 _lhsIoptions
_nontsOo_sem = rule79 _lhsIoptions
_nontsOo_rename = rule80 _lhsIoptions
_nontsOo_newtypes = rule81 _lhsIoptions
_nontsOo_wantvisit = rule82 _lhsIoptions
_nontsOo_unbox = rule83 _lhsIoptions
_nontsOo_case = rule84 _lhsIoptions
_nontsOprefix = rule85 _lhsIoptions
_nontsOvcount = rule86 ()
_nontsOmanualAttrDepMap = rule87 arg_manualAttrOrderMap_
_nontsOaroundMap = rule88 arg_aroundsMap_
_nontsOacount = rule89 ()
_ruleTable = rule90 _nontsIrules _nontsIvcount
_attrTable = rule91 _nontsIacount _nontsIntattrs
_attrVertex = rule92 _nontsIntattrs
_tdpToTds = rule93 _attrVertex _nontsIrules
_tdsToTdp = rule94 _tdpToTds
_directDep = rule95 _nontsIadditionalDep _nontsIdirectDep
_instDep = rule96 _nontsIinstDep
_aroundDep = rule97 _nontsIaroundDep
_mergeDep = rule98 _nontsImergeDep
_info = rule99 _attrTable _nontsIacount _nontsIaranges _nontsInonts _nontsIvcount _ruleTable _tdpToTds _tdsToTdp arg_wrappers_
(_cInterfaceMap,_cVisitsMap,_cyclesErrors) = rule100 _aroundDep _attrTable _directDep _info _instDep _lhsIoptions _mergeDep _ruleTable
_lhsOerrors :: Seq Error
_lhsOerrors = rule101 _cyclesErrors _lhsIoptions _nontsIerrors
_lhsOoutput :: CGrammar
_lhsOoutput = rule102 _aroundMap _mergeMap _nontsIcNonterminals _o_dovisit arg_contextMap_ arg_derivings_ arg_paramMap_ arg_pragmas_ arg_quantMap_ arg_typeSyns_ arg_wrappers_
_aroundMap = rule103 arg_aroundsMap_
_mergeMap = rule104 arg_mergeMap_
_nontsOallnts = rule105 _nontsInonts
_lhsOmirage :: Mirage.Grammar
_lhsOmirage = rule106 _nontsImirages
_lhsOnAutoRules :: Int
_lhsOnAutoRules = rule107 _nontsInAutoRules
_lhsOnExplicitRules :: Int
_lhsOnExplicitRules = rule108 _nontsInExplicitRules
_nontsOcInterfaceMap = rule109 _cInterfaceMap
_nontsOcVisitsMap = rule110 _cVisitsMap
_nontsOmergeMap = rule111 _mergeMap
_nontsOo_dovisit = rule112 _o_dovisit
_nontsOoptions = rule113 _lhsIoptions
__result_ = T_Grammar_vOut10 _lhsOerrors _lhsOmirage _lhsOnAutoRules _lhsOnExplicitRules _lhsOoutput
in __result_ )
in C_Grammar_s11 v10
{-# INLINE rule73 #-}
{-# LINE 15 "src-ag/DistChildAttr.ag" #-}
rule73 = \ ((_nontsIinhMap') :: Map Identifier Attributes) ->
{-# LINE 15 "src-ag/DistChildAttr.ag" #-}
_nontsIinhMap'
{-# LINE 921 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule74 #-}
{-# LINE 16 "src-ag/DistChildAttr.ag" #-}
rule74 = \ ((_nontsIsynMap') :: Map Identifier Attributes) ->
{-# LINE 16 "src-ag/DistChildAttr.ag" #-}
_nontsIsynMap'
{-# LINE 927 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule75 #-}
{-# LINE 123 "src-ag/Order.ag" #-}
rule75 = \ _cyclesErrors ((_lhsIoptions) :: Options) ->
{-# LINE 123 "src-ag/Order.ag" #-}
visit _lhsIoptions && null _cyclesErrors
{-# LINE 933 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule76 #-}
{-# LINE 124 "src-ag/Order.ag" #-}
rule76 = \ ((_lhsIoptions) :: Options) ->
{-# LINE 124 "src-ag/Order.ag" #-}
folds _lhsIoptions
{-# LINE 939 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule77 #-}
{-# LINE 125 "src-ag/Order.ag" #-}
rule77 = \ ((_lhsIoptions) :: Options) ->
{-# LINE 125 "src-ag/Order.ag" #-}
dataTypes _lhsIoptions
{-# LINE 945 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule78 #-}
{-# LINE 126 "src-ag/Order.ag" #-}
rule78 = \ ((_lhsIoptions) :: Options) ->
{-# LINE 126 "src-ag/Order.ag" #-}
typeSigs _lhsIoptions
{-# LINE 951 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule79 #-}
{-# LINE 127 "src-ag/Order.ag" #-}
rule79 = \ ((_lhsIoptions) :: Options) ->
{-# LINE 127 "src-ag/Order.ag" #-}
semfuns _lhsIoptions
{-# LINE 957 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule80 #-}
{-# LINE 128 "src-ag/Order.ag" #-}
rule80 = \ ((_lhsIoptions) :: Options) ->
{-# LINE 128 "src-ag/Order.ag" #-}
rename _lhsIoptions
{-# LINE 963 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule81 #-}
{-# LINE 129 "src-ag/Order.ag" #-}
rule81 = \ ((_lhsIoptions) :: Options) ->
{-# LINE 129 "src-ag/Order.ag" #-}
newtypes _lhsIoptions
{-# LINE 969 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule82 #-}
{-# LINE 130 "src-ag/Order.ag" #-}
rule82 = \ ((_lhsIoptions) :: Options) ->
{-# LINE 130 "src-ag/Order.ag" #-}
visit _lhsIoptions
{-# LINE 975 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule83 #-}
{-# LINE 131 "src-ag/Order.ag" #-}
rule83 = \ ((_lhsIoptions) :: Options) ->
{-# LINE 131 "src-ag/Order.ag" #-}
unbox _lhsIoptions
{-# LINE 981 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule84 #-}
{-# LINE 132 "src-ag/Order.ag" #-}
rule84 = \ ((_lhsIoptions) :: Options) ->
{-# LINE 132 "src-ag/Order.ag" #-}
cases _lhsIoptions
{-# LINE 987 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule85 #-}
{-# LINE 133 "src-ag/Order.ag" #-}
rule85 = \ ((_lhsIoptions) :: Options) ->
{-# LINE 133 "src-ag/Order.ag" #-}
prefix _lhsIoptions
{-# LINE 993 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule86 #-}
{-# LINE 262 "src-ag/Order.ag" #-}
rule86 = \ (_ :: ()) ->
{-# LINE 262 "src-ag/Order.ag" #-}
0
{-# LINE 999 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule87 #-}
{-# LINE 288 "src-ag/Order.ag" #-}
rule87 = \ manualAttrOrderMap_ ->
{-# LINE 288 "src-ag/Order.ag" #-}
manualAttrOrderMap_
{-# LINE 1005 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule88 #-}
{-# LINE 417 "src-ag/Order.ag" #-}
rule88 = \ aroundsMap_ ->
{-# LINE 417 "src-ag/Order.ag" #-}
aroundsMap_
{-# LINE 1011 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule89 #-}
{-# LINE 508 "src-ag/Order.ag" #-}
rule89 = \ (_ :: ()) ->
{-# LINE 508 "src-ag/Order.ag" #-}
0
{-# LINE 1017 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule90 #-}
{-# LINE 546 "src-ag/Order.ag" #-}
rule90 = \ ((_nontsIrules) :: Seq (Vertex,CRule)) ((_nontsIvcount) :: Int) ->
{-# LINE 546 "src-ag/Order.ag" #-}
Array.array (0,_nontsIvcount-1) (toList _nontsIrules)
{-# LINE 1023 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule91 #-}
{-# LINE 547 "src-ag/Order.ag" #-}
rule91 = \ ((_nontsIacount) :: Int) ((_nontsIntattrs) :: Seq (Vertex,NTAttr)) ->
{-# LINE 547 "src-ag/Order.ag" #-}
Array.array (0,_nontsIacount-1) (toList _nontsIntattrs)
{-# LINE 1029 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule92 #-}
{-# LINE 548 "src-ag/Order.ag" #-}
rule92 = \ ((_nontsIntattrs) :: Seq (Vertex,NTAttr)) ->
{-# LINE 548 "src-ag/Order.ag" #-}
Map.fromList (map swap (toList _nontsIntattrs))
{-# LINE 1035 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule93 #-}
{-# LINE 549 "src-ag/Order.ag" #-}
rule93 = \ _attrVertex ((_nontsIrules) :: Seq (Vertex,CRule)) ->
{-# LINE 549 "src-ag/Order.ag" #-}
[ (s, maybe (-1) (\v -> findWithErr1 "Grammar.tdpToTds" v _attrVertex) (ntattr cr))
| (s,cr) <- toList _nontsIrules]
{-# LINE 1042 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule94 #-}
{-# LINE 551 "src-ag/Order.ag" #-}
rule94 = \ _tdpToTds ->
{-# LINE 551 "src-ag/Order.ag" #-}
let eq (_,v) (_,v') = v == v'
conv ((s,v):svs) | v == -1 = Nothing
| otherwise = Just (v,s:map fst svs)
in mapMaybe conv (eqClasses eq _tdpToTds)
{-# LINE 1051 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule95 #-}
{-# LINE 555 "src-ag/Order.ag" #-}
rule95 = \ ((_nontsIadditionalDep) :: Seq Edge) ((_nontsIdirectDep) :: Seq Edge) ->
{-# LINE 555 "src-ag/Order.ag" #-}
toList (_nontsIdirectDep Seq.>< _nontsIadditionalDep)
{-# LINE 1057 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule96 #-}
{-# LINE 556 "src-ag/Order.ag" #-}
rule96 = \ ((_nontsIinstDep) :: Seq Edge) ->
{-# LINE 556 "src-ag/Order.ag" #-}
toList _nontsIinstDep
{-# LINE 1063 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule97 #-}
{-# LINE 557 "src-ag/Order.ag" #-}
rule97 = \ ((_nontsIaroundDep) :: Seq Edge) ->
{-# LINE 557 "src-ag/Order.ag" #-}
toList _nontsIaroundDep
{-# LINE 1069 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule98 #-}
{-# LINE 558 "src-ag/Order.ag" #-}
rule98 = \ ((_nontsImergeDep) :: Seq Edge) ->
{-# LINE 558 "src-ag/Order.ag" #-}
toList _nontsImergeDep
{-# LINE 1075 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule99 #-}
{-# LINE 559 "src-ag/Order.ag" #-}
rule99 = \ _attrTable ((_nontsIacount) :: Int) ((_nontsIaranges) :: Seq (Int,Int,Int)) ((_nontsInonts) :: [(NontermIdent,[ConstructorIdent])]) ((_nontsIvcount) :: Int) _ruleTable _tdpToTds _tdsToTdp wrappers_ ->
{-# LINE 559 "src-ag/Order.ag" #-}
let def [] = -1
def (v:vs) = v
in Info { tdsToTdp = Array.array (0,_nontsIacount-1) _tdsToTdp
, tdpToTds = Array.array (0,_nontsIvcount-1) _tdpToTds
, attrTable = _attrTable
, ruleTable = _ruleTable
, lmh = toList _nontsIaranges
, nonts = _nontsInonts
, wraps = wrappers_
}
{-# LINE 1090 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule100 #-}
{-# LINE 571 "src-ag/Order.ag" #-}
rule100 = \ _aroundDep _attrTable _directDep _info _instDep ((_lhsIoptions) :: Options) _mergeDep _ruleTable ->
{-# LINE 571 "src-ag/Order.ag" #-}
case computeSequential _info _directDep (_instDep ++ _aroundDep ++ _mergeDep ) of
CycleFree cim cvm -> ( cim
, cvm
, []
)
LocalCycle errs -> ( error "No interfaces for AG with local cycles"
, error "No visit sub-sequences for AG with local cycles"
, map (localCycleErr _ruleTable (visit _lhsIoptions)) errs
)
InstCycle errs -> ( error "No interfaces for AG with cycles through insts"
, error "No visit sub-sequences for AG with cycles through insts"
, map (instCycleErr _ruleTable (visit _lhsIoptions)) errs
)
DirectCycle errs -> ( error "No interfaces for AG with direct cycles"
, error "No visit sub-sequences for AG with direct cycles"
, directCycleErrs _attrTable _ruleTable (visit _lhsIoptions) errs
)
InducedCycle cim errs -> ( cim
, error "No visit sub-sequences for AG with induced cycles"
, inducedCycleErrs _attrTable _ruleTable cim errs
)
{-# LINE 1116 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule101 #-}
{-# LINE 592 "src-ag/Order.ag" #-}
rule101 = \ _cyclesErrors ((_lhsIoptions) :: Options) ((_nontsIerrors) :: Seq Error) ->
{-# LINE 592 "src-ag/Order.ag" #-}
(if withCycle _lhsIoptions then Seq.fromList _cyclesErrors else Seq.empty)
Seq.>< _nontsIerrors
{-# LINE 1123 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule102 #-}
{-# LINE 624 "src-ag/Order.ag" #-}
rule102 = \ _aroundMap _mergeMap ((_nontsIcNonterminals) :: CNonterminals) _o_dovisit contextMap_ derivings_ paramMap_ pragmas_ quantMap_ typeSyns_ wrappers_ ->
{-# LINE 624 "src-ag/Order.ag" #-}
CGrammar typeSyns_ derivings_ wrappers_ _nontsIcNonterminals pragmas_ paramMap_ contextMap_ quantMap_ _aroundMap _mergeMap _o_dovisit
{-# LINE 1129 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule103 #-}
{-# LINE 637 "src-ag/Order.ag" #-}
rule103 = \ aroundsMap_ ->
{-# LINE 637 "src-ag/Order.ag" #-}
Map.map (Map.map Map.keysSet) aroundsMap_
{-# LINE 1135 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule104 #-}
{-# LINE 638 "src-ag/Order.ag" #-}
rule104 = \ mergeMap_ ->
{-# LINE 638 "src-ag/Order.ag" #-}
Map.map (Map.map (Map.map (\(nt,srcs,_) -> (nt,srcs)))) mergeMap_
{-# LINE 1141 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule105 #-}
{-# LINE 655 "src-ag/Order.ag" #-}
rule105 = \ ((_nontsInonts) :: [(NontermIdent,[ConstructorIdent])]) ->
{-# LINE 655 "src-ag/Order.ag" #-}
map fst (_nontsInonts)
{-# LINE 1147 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule106 #-}
{-# LINE 22 "src-ag/TfmToMirage.ag" #-}
rule106 = \ ((_nontsImirages) :: [Mirage.Nonterminal]) ->
{-# LINE 22 "src-ag/TfmToMirage.ag" #-}
Mirage.Grammar _nontsImirages
{-# LINE 1153 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule107 #-}
rule107 = \ ((_nontsInAutoRules) :: Int) ->
_nontsInAutoRules
{-# INLINE rule108 #-}
rule108 = \ ((_nontsInExplicitRules) :: Int) ->
_nontsInExplicitRules
{-# INLINE rule109 #-}
rule109 = \ _cInterfaceMap ->
_cInterfaceMap
{-# INLINE rule110 #-}
rule110 = \ _cVisitsMap ->
_cVisitsMap
{-# INLINE rule111 #-}
rule111 = \ _mergeMap ->
_mergeMap
{-# INLINE rule112 #-}
rule112 = \ _o_dovisit ->
_o_dovisit
{-# INLINE rule113 #-}
rule113 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
-- Nonterminal -------------------------------------------------
-- wrapper
data Inh_Nonterminal = Inh_Nonterminal { acount_Inh_Nonterminal :: (Int), allnts_Inh_Nonterminal :: ([Identifier]), aroundMap_Inh_Nonterminal :: (Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))), cInterfaceMap_Inh_Nonterminal :: (CInterfaceMap), cVisitsMap_Inh_Nonterminal :: (CVisitsMap), inhMap_Inh_Nonterminal :: (Map Identifier Attributes), manualAttrDepMap_Inh_Nonterminal :: (AttrOrderMap), mergeMap_Inh_Nonterminal :: (Map NontermIdent (Map ConstructorIdent (Map Identifier (Identifier,[Identifier])))), o_case_Inh_Nonterminal :: (Bool), o_cata_Inh_Nonterminal :: (Bool), o_data_Inh_Nonterminal :: (Bool), o_dovisit_Inh_Nonterminal :: (Bool), o_newtypes_Inh_Nonterminal :: (Bool), o_rename_Inh_Nonterminal :: (Bool), o_sem_Inh_Nonterminal :: (Bool), o_sig_Inh_Nonterminal :: (Bool), o_unbox_Inh_Nonterminal :: (Bool), o_wantvisit_Inh_Nonterminal :: (Bool), options_Inh_Nonterminal :: (Options), prefix_Inh_Nonterminal :: (String), synMap_Inh_Nonterminal :: (Map Identifier Attributes), vcount_Inh_Nonterminal :: (Int) }
data Syn_Nonterminal = Syn_Nonterminal { acount_Syn_Nonterminal :: (Int), additionalDep_Syn_Nonterminal :: (Seq Edge), aranges_Syn_Nonterminal :: (Seq (Int,Int,Int)), aroundDep_Syn_Nonterminal :: (Seq Edge), cNonterminal_Syn_Nonterminal :: (CNonterminal), directDep_Syn_Nonterminal :: (Seq Edge), errors_Syn_Nonterminal :: (Seq Error), inhMap'_Syn_Nonterminal :: (Map Identifier Attributes), instDep_Syn_Nonterminal :: (Seq Edge), mergeDep_Syn_Nonterminal :: (Seq Edge), mirage_Syn_Nonterminal :: (Mirage.Nonterminal), nAutoRules_Syn_Nonterminal :: (Int), nExplicitRules_Syn_Nonterminal :: (Int), nonts_Syn_Nonterminal :: ([(NontermIdent,[ConstructorIdent])]), ntattrs_Syn_Nonterminal :: (Seq (Vertex,NTAttr)), rules_Syn_Nonterminal :: (Seq (Vertex,CRule)), synMap'_Syn_Nonterminal :: (Map Identifier Attributes), vcount_Syn_Nonterminal :: (Int) }
{-# INLINABLE wrap_Nonterminal #-}
wrap_Nonterminal :: T_Nonterminal -> Inh_Nonterminal -> (Syn_Nonterminal )
wrap_Nonterminal (T_Nonterminal act) (Inh_Nonterminal _lhsIacount _lhsIallnts _lhsIaroundMap _lhsIcInterfaceMap _lhsIcVisitsMap _lhsIinhMap _lhsImanualAttrDepMap _lhsImergeMap _lhsIo_case _lhsIo_cata _lhsIo_data _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_unbox _lhsIo_wantvisit _lhsIoptions _lhsIprefix _lhsIsynMap _lhsIvcount) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg13 = T_Nonterminal_vIn13 _lhsIacount _lhsIallnts _lhsIaroundMap _lhsIcInterfaceMap _lhsIcVisitsMap _lhsIinhMap _lhsImanualAttrDepMap _lhsImergeMap _lhsIo_case _lhsIo_cata _lhsIo_data _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_unbox _lhsIo_wantvisit _lhsIoptions _lhsIprefix _lhsIsynMap _lhsIvcount
(T_Nonterminal_vOut13 _lhsOacount _lhsOadditionalDep _lhsOaranges _lhsOaroundDep _lhsOcNonterminal _lhsOdirectDep _lhsOerrors _lhsOinhMap' _lhsOinstDep _lhsOmergeDep _lhsOmirage _lhsOnAutoRules _lhsOnExplicitRules _lhsOnonts _lhsOntattrs _lhsOrules _lhsOsynMap' _lhsOvcount) <- return (inv_Nonterminal_s14 sem arg13)
return (Syn_Nonterminal _lhsOacount _lhsOadditionalDep _lhsOaranges _lhsOaroundDep _lhsOcNonterminal _lhsOdirectDep _lhsOerrors _lhsOinhMap' _lhsOinstDep _lhsOmergeDep _lhsOmirage _lhsOnAutoRules _lhsOnExplicitRules _lhsOnonts _lhsOntattrs _lhsOrules _lhsOsynMap' _lhsOvcount)
)
-- cata
{-# INLINE sem_Nonterminal #-}
sem_Nonterminal :: Nonterminal -> T_Nonterminal
sem_Nonterminal ( Nonterminal nt_ params_ inh_ syn_ prods_ ) = sem_Nonterminal_Nonterminal nt_ params_ inh_ syn_ ( sem_Productions prods_ )
-- semantic domain
newtype T_Nonterminal = T_Nonterminal {
attach_T_Nonterminal :: Identity (T_Nonterminal_s14 )
}
newtype T_Nonterminal_s14 = C_Nonterminal_s14 {
inv_Nonterminal_s14 :: (T_Nonterminal_v13 )
}
data T_Nonterminal_s15 = C_Nonterminal_s15
type T_Nonterminal_v13 = (T_Nonterminal_vIn13 ) -> (T_Nonterminal_vOut13 )
data T_Nonterminal_vIn13 = T_Nonterminal_vIn13 (Int) ([Identifier]) (Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))) (CInterfaceMap) (CVisitsMap) (Map Identifier Attributes) (AttrOrderMap) (Map NontermIdent (Map ConstructorIdent (Map Identifier (Identifier,[Identifier])))) (Bool) (Bool) (Bool) (Bool) (Bool) (Bool) (Bool) (Bool) (Bool) (Bool) (Options) (String) (Map Identifier Attributes) (Int)
data T_Nonterminal_vOut13 = T_Nonterminal_vOut13 (Int) (Seq Edge) (Seq (Int,Int,Int)) (Seq Edge) (CNonterminal) (Seq Edge) (Seq Error) (Map Identifier Attributes) (Seq Edge) (Seq Edge) (Mirage.Nonterminal) (Int) (Int) ([(NontermIdent,[ConstructorIdent])]) (Seq (Vertex,NTAttr)) (Seq (Vertex,CRule)) (Map Identifier Attributes) (Int)
{-# NOINLINE sem_Nonterminal_Nonterminal #-}
sem_Nonterminal_Nonterminal :: (NontermIdent) -> ([Identifier]) -> (Attributes) -> (Attributes) -> T_Productions -> T_Nonterminal
sem_Nonterminal_Nonterminal arg_nt_ arg_params_ arg_inh_ arg_syn_ arg_prods_ = T_Nonterminal (return st14) where
{-# NOINLINE st14 #-}
st14 = let
v13 :: T_Nonterminal_v13
v13 = \ (T_Nonterminal_vIn13 _lhsIacount _lhsIallnts _lhsIaroundMap _lhsIcInterfaceMap _lhsIcVisitsMap _lhsIinhMap _lhsImanualAttrDepMap _lhsImergeMap _lhsIo_case _lhsIo_cata _lhsIo_data _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_unbox _lhsIo_wantvisit _lhsIoptions _lhsIprefix _lhsIsynMap _lhsIvcount) -> ( let
_prodsX29 = Control.Monad.Identity.runIdentity (attach_T_Productions (arg_prods_))
(T_Productions_vOut28 _prodsIadditionalDep _prodsIaroundDep _prodsIcProductions _prodsIcons _prodsIdirectDep _prodsIerrors _prodsIinstDep _prodsImergeDep _prodsImirages _prodsInAutoRules _prodsInExplicitRules _prodsIrules _prodsIvcount) = inv_Productions_s29 _prodsX29 (T_Productions_vIn28 _prodsOallnts _prodsOaroundMap _prodsOcVisitsMap _prodsOinh _prodsOinhMap _prodsOmanualAttrDepMap _prodsOmergeMap _prodsOnt _prodsOo_case _prodsOo_cata _prodsOo_dovisit _prodsOo_newtypes _prodsOo_rename _prodsOo_sem _prodsOo_sig _prodsOo_unbox _prodsOo_wantvisit _prodsOoptions _prodsOprefix _prodsOsyn _prodsOsynMap _prodsOvcount)
_lhsOinhMap' :: Map Identifier Attributes
_lhsOinhMap' = rule114 arg_inh_ arg_nt_
_lhsOsynMap' :: Map Identifier Attributes
_lhsOsynMap' = rule115 arg_nt_ arg_syn_
_prodsOnt = rule116 arg_nt_
_prodsOinh = rule117 arg_inh_
_prodsOsyn = rule118 arg_syn_
_mergeMap = rule119 _lhsImergeMap arg_nt_
_aroundMap = rule120 _lhsIaroundMap arg_nt_
_ntattrs = rule121 arg_inh_ arg_nt_ arg_syn_
_lhsOntattrs :: Seq (Vertex,NTAttr)
_lhsOntattrs = rule122 _lhsIacount _ntattrs
_lhsOacount :: Int
_lhsOacount = rule123 _lhsIacount arg_inh_ arg_syn_
_lhsOaranges :: Seq (Int,Int,Int)
_lhsOaranges = rule124 _lhsIacount arg_inh_ arg_syn_
_lhsOnonts :: [(NontermIdent,[ConstructorIdent])]
_lhsOnonts = rule125 _prodsIcons arg_nt_
_cInter = rule126 _lhsIcInterfaceMap _lhsIo_dovisit arg_inh_ arg_nt_ arg_syn_
_lhsOcNonterminal :: CNonterminal
_lhsOcNonterminal = rule127 _cInter _prodsIcProductions arg_inh_ arg_nt_ arg_params_ arg_syn_
_lhsOmirage :: Mirage.Nonterminal
_lhsOmirage = rule128 _prodsImirages arg_inh_ arg_nt_ arg_params_ arg_syn_
_lhsOadditionalDep :: Seq Edge
_lhsOadditionalDep = rule129 _prodsIadditionalDep
_lhsOaroundDep :: Seq Edge
_lhsOaroundDep = rule130 _prodsIaroundDep
_lhsOdirectDep :: Seq Edge
_lhsOdirectDep = rule131 _prodsIdirectDep
_lhsOerrors :: Seq Error
_lhsOerrors = rule132 _prodsIerrors
_lhsOinstDep :: Seq Edge
_lhsOinstDep = rule133 _prodsIinstDep
_lhsOmergeDep :: Seq Edge
_lhsOmergeDep = rule134 _prodsImergeDep
_lhsOnAutoRules :: Int
_lhsOnAutoRules = rule135 _prodsInAutoRules
_lhsOnExplicitRules :: Int
_lhsOnExplicitRules = rule136 _prodsInExplicitRules
_lhsOrules :: Seq (Vertex,CRule)
_lhsOrules = rule137 _prodsIrules
_lhsOvcount :: Int
_lhsOvcount = rule138 _prodsIvcount
_prodsOallnts = rule139 _lhsIallnts
_prodsOaroundMap = rule140 _aroundMap
_prodsOcVisitsMap = rule141 _lhsIcVisitsMap
_prodsOinhMap = rule142 _lhsIinhMap
_prodsOmanualAttrDepMap = rule143 _lhsImanualAttrDepMap
_prodsOmergeMap = rule144 _mergeMap
_prodsOo_case = rule145 _lhsIo_case
_prodsOo_cata = rule146 _lhsIo_cata
_prodsOo_dovisit = rule147 _lhsIo_dovisit
_prodsOo_newtypes = rule148 _lhsIo_newtypes
_prodsOo_rename = rule149 _lhsIo_rename
_prodsOo_sem = rule150 _lhsIo_sem
_prodsOo_sig = rule151 _lhsIo_sig
_prodsOo_unbox = rule152 _lhsIo_unbox
_prodsOo_wantvisit = rule153 _lhsIo_wantvisit
_prodsOoptions = rule154 _lhsIoptions
_prodsOprefix = rule155 _lhsIprefix
_prodsOsynMap = rule156 _lhsIsynMap
_prodsOvcount = rule157 _lhsIvcount
__result_ = T_Nonterminal_vOut13 _lhsOacount _lhsOadditionalDep _lhsOaranges _lhsOaroundDep _lhsOcNonterminal _lhsOdirectDep _lhsOerrors _lhsOinhMap' _lhsOinstDep _lhsOmergeDep _lhsOmirage _lhsOnAutoRules _lhsOnExplicitRules _lhsOnonts _lhsOntattrs _lhsOrules _lhsOsynMap' _lhsOvcount
in __result_ )
in C_Nonterminal_s14 v13
{-# INLINE rule114 #-}
{-# LINE 7 "src-ag/DistChildAttr.ag" #-}
rule114 = \ inh_ nt_ ->
{-# LINE 7 "src-ag/DistChildAttr.ag" #-}
Map.singleton nt_ inh_
{-# LINE 1285 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule115 #-}
{-# LINE 8 "src-ag/DistChildAttr.ag" #-}
rule115 = \ nt_ syn_ ->
{-# LINE 8 "src-ag/DistChildAttr.ag" #-}
Map.singleton nt_ syn_
{-# LINE 1291 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule116 #-}
{-# LINE 97 "src-ag/Order.ag" #-}
rule116 = \ nt_ ->
{-# LINE 97 "src-ag/Order.ag" #-}
nt_
{-# LINE 1297 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule117 #-}
{-# LINE 100 "src-ag/Order.ag" #-}
rule117 = \ inh_ ->
{-# LINE 100 "src-ag/Order.ag" #-}
inh_
{-# LINE 1303 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule118 #-}
{-# LINE 101 "src-ag/Order.ag" #-}
rule118 = \ syn_ ->
{-# LINE 101 "src-ag/Order.ag" #-}
syn_
{-# LINE 1309 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule119 #-}
{-# LINE 360 "src-ag/Order.ag" #-}
rule119 = \ ((_lhsImergeMap) :: Map NontermIdent (Map ConstructorIdent (Map Identifier (Identifier,[Identifier])))) nt_ ->
{-# LINE 360 "src-ag/Order.ag" #-}
Map.findWithDefault Map.empty nt_ _lhsImergeMap
{-# LINE 1315 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule120 #-}
{-# LINE 413 "src-ag/Order.ag" #-}
rule120 = \ ((_lhsIaroundMap) :: Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))) nt_ ->
{-# LINE 413 "src-ag/Order.ag" #-}
Map.findWithDefault Map.empty nt_ _lhsIaroundMap
{-# LINE 1321 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule121 #-}
{-# LINE 511 "src-ag/Order.ag" #-}
rule121 = \ inh_ nt_ syn_ ->
{-# LINE 511 "src-ag/Order.ag" #-}
[ NTAInh nt_ inh tp | (inh,tp) <- Map.assocs inh_ ]
++ [NTASyn nt_ syn tp | (syn,tp) <- Map.assocs syn_ ]
{-# LINE 1328 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule122 #-}
{-# LINE 513 "src-ag/Order.ag" #-}
rule122 = \ ((_lhsIacount) :: Int) _ntattrs ->
{-# LINE 513 "src-ag/Order.ag" #-}
Seq.fromList (zip [_lhsIacount ..] _ntattrs)
{-# LINE 1334 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule123 #-}
{-# LINE 514 "src-ag/Order.ag" #-}
rule123 = \ ((_lhsIacount) :: Int) inh_ syn_ ->
{-# LINE 514 "src-ag/Order.ag" #-}
_lhsIacount + Map.size inh_ + Map.size syn_
{-# LINE 1340 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule124 #-}
{-# LINE 515 "src-ag/Order.ag" #-}
rule124 = \ ((_lhsIacount) :: Int) inh_ syn_ ->
{-# LINE 515 "src-ag/Order.ag" #-}
Seq.singleton
(_lhsIacount
,_lhsIacount + Map.size inh_
,_lhsIacount + Map.size syn_ + Map.size inh_ - 1)
{-# LINE 1349 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule125 #-}
{-# LINE 524 "src-ag/Order.ag" #-}
rule125 = \ ((_prodsIcons) :: [ConstructorIdent]) nt_ ->
{-# LINE 524 "src-ag/Order.ag" #-}
[(nt_,_prodsIcons)]
{-# LINE 1355 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule126 #-}
{-# LINE 601 "src-ag/Order.ag" #-}
rule126 = \ ((_lhsIcInterfaceMap) :: CInterfaceMap) ((_lhsIo_dovisit) :: Bool) inh_ nt_ syn_ ->
{-# LINE 601 "src-ag/Order.ag" #-}
if _lhsIo_dovisit
then findWithErr1 "Nonterminal.cInter" nt_ _lhsIcInterfaceMap
else CInterface [CSegment inh_ syn_]
{-# LINE 1363 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule127 #-}
{-# LINE 629 "src-ag/Order.ag" #-}
rule127 = \ _cInter ((_prodsIcProductions) :: CProductions) inh_ nt_ params_ syn_ ->
{-# LINE 629 "src-ag/Order.ag" #-}
CNonterminal nt_ params_ inh_ syn_ _prodsIcProductions _cInter
{-# LINE 1369 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule128 #-}
{-# LINE 30 "src-ag/TfmToMirage.ag" #-}
rule128 = \ ((_prodsImirages) :: [Mirage.Production]) inh_ nt_ params_ syn_ ->
{-# LINE 30 "src-ag/TfmToMirage.ag" #-}
Mirage.Nonterminal
(getName nt_)
(map getName params_)
(Map.foldrWithKey (\k x xs -> Mirage.Attribute (getName k) (typeToMirage x) : xs) [] inh_)
(Map.foldrWithKey (\k x xs -> Mirage.Attribute (getName k) (typeToMirage x) : xs) [] syn_)
_prodsImirages
{-# LINE 1380 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule129 #-}
rule129 = \ ((_prodsIadditionalDep) :: Seq Edge) ->
_prodsIadditionalDep
{-# INLINE rule130 #-}
rule130 = \ ((_prodsIaroundDep) :: Seq Edge) ->
_prodsIaroundDep
{-# INLINE rule131 #-}
rule131 = \ ((_prodsIdirectDep) :: Seq Edge) ->
_prodsIdirectDep
{-# INLINE rule132 #-}
rule132 = \ ((_prodsIerrors) :: Seq Error) ->
_prodsIerrors
{-# INLINE rule133 #-}
rule133 = \ ((_prodsIinstDep) :: Seq Edge) ->
_prodsIinstDep
{-# INLINE rule134 #-}
rule134 = \ ((_prodsImergeDep) :: Seq Edge) ->
_prodsImergeDep
{-# INLINE rule135 #-}
rule135 = \ ((_prodsInAutoRules) :: Int) ->
_prodsInAutoRules
{-# INLINE rule136 #-}
rule136 = \ ((_prodsInExplicitRules) :: Int) ->
_prodsInExplicitRules
{-# INLINE rule137 #-}
rule137 = \ ((_prodsIrules) :: Seq (Vertex,CRule)) ->
_prodsIrules
{-# INLINE rule138 #-}
rule138 = \ ((_prodsIvcount) :: Int) ->
_prodsIvcount
{-# INLINE rule139 #-}
rule139 = \ ((_lhsIallnts) :: [Identifier]) ->
_lhsIallnts
{-# INLINE rule140 #-}
rule140 = \ _aroundMap ->
_aroundMap
{-# INLINE rule141 #-}
rule141 = \ ((_lhsIcVisitsMap) :: CVisitsMap) ->
_lhsIcVisitsMap
{-# INLINE rule142 #-}
rule142 = \ ((_lhsIinhMap) :: Map Identifier Attributes) ->
_lhsIinhMap
{-# INLINE rule143 #-}
rule143 = \ ((_lhsImanualAttrDepMap) :: AttrOrderMap) ->
_lhsImanualAttrDepMap
{-# INLINE rule144 #-}
rule144 = \ _mergeMap ->
_mergeMap
{-# INLINE rule145 #-}
rule145 = \ ((_lhsIo_case) :: Bool) ->
_lhsIo_case
{-# INLINE rule146 #-}
rule146 = \ ((_lhsIo_cata) :: Bool) ->
_lhsIo_cata
{-# INLINE rule147 #-}
rule147 = \ ((_lhsIo_dovisit) :: Bool) ->
_lhsIo_dovisit
{-# INLINE rule148 #-}
rule148 = \ ((_lhsIo_newtypes) :: Bool) ->
_lhsIo_newtypes
{-# INLINE rule149 #-}
rule149 = \ ((_lhsIo_rename) :: Bool) ->
_lhsIo_rename
{-# INLINE rule150 #-}
rule150 = \ ((_lhsIo_sem) :: Bool) ->
_lhsIo_sem
{-# INLINE rule151 #-}
rule151 = \ ((_lhsIo_sig) :: Bool) ->
_lhsIo_sig
{-# INLINE rule152 #-}
rule152 = \ ((_lhsIo_unbox) :: Bool) ->
_lhsIo_unbox
{-# INLINE rule153 #-}
rule153 = \ ((_lhsIo_wantvisit) :: Bool) ->
_lhsIo_wantvisit
{-# INLINE rule154 #-}
rule154 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# INLINE rule155 #-}
rule155 = \ ((_lhsIprefix) :: String) ->
_lhsIprefix
{-# INLINE rule156 #-}
rule156 = \ ((_lhsIsynMap) :: Map Identifier Attributes) ->
_lhsIsynMap
{-# INLINE rule157 #-}
rule157 = \ ((_lhsIvcount) :: Int) ->
_lhsIvcount
-- Nonterminals ------------------------------------------------
-- wrapper
data Inh_Nonterminals = Inh_Nonterminals { acount_Inh_Nonterminals :: (Int), allnts_Inh_Nonterminals :: ([Identifier]), aroundMap_Inh_Nonterminals :: (Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))), cInterfaceMap_Inh_Nonterminals :: (CInterfaceMap), cVisitsMap_Inh_Nonterminals :: (CVisitsMap), inhMap_Inh_Nonterminals :: (Map Identifier Attributes), manualAttrDepMap_Inh_Nonterminals :: (AttrOrderMap), mergeMap_Inh_Nonterminals :: (Map NontermIdent (Map ConstructorIdent (Map Identifier (Identifier,[Identifier])))), o_case_Inh_Nonterminals :: (Bool), o_cata_Inh_Nonterminals :: (Bool), o_data_Inh_Nonterminals :: (Bool), o_dovisit_Inh_Nonterminals :: (Bool), o_newtypes_Inh_Nonterminals :: (Bool), o_rename_Inh_Nonterminals :: (Bool), o_sem_Inh_Nonterminals :: (Bool), o_sig_Inh_Nonterminals :: (Bool), o_unbox_Inh_Nonterminals :: (Bool), o_wantvisit_Inh_Nonterminals :: (Bool), options_Inh_Nonterminals :: (Options), prefix_Inh_Nonterminals :: (String), synMap_Inh_Nonterminals :: (Map Identifier Attributes), vcount_Inh_Nonterminals :: (Int) }
data Syn_Nonterminals = Syn_Nonterminals { acount_Syn_Nonterminals :: (Int), additionalDep_Syn_Nonterminals :: (Seq Edge), aranges_Syn_Nonterminals :: (Seq (Int,Int,Int)), aroundDep_Syn_Nonterminals :: (Seq Edge), cNonterminals_Syn_Nonterminals :: (CNonterminals), directDep_Syn_Nonterminals :: (Seq Edge), errors_Syn_Nonterminals :: (Seq Error), inhMap'_Syn_Nonterminals :: (Map Identifier Attributes), instDep_Syn_Nonterminals :: (Seq Edge), mergeDep_Syn_Nonterminals :: (Seq Edge), mirages_Syn_Nonterminals :: ([Mirage.Nonterminal]), nAutoRules_Syn_Nonterminals :: (Int), nExplicitRules_Syn_Nonterminals :: (Int), nonts_Syn_Nonterminals :: ([(NontermIdent,[ConstructorIdent])]), ntattrs_Syn_Nonterminals :: (Seq (Vertex,NTAttr)), rules_Syn_Nonterminals :: (Seq (Vertex,CRule)), synMap'_Syn_Nonterminals :: (Map Identifier Attributes), vcount_Syn_Nonterminals :: (Int) }
{-# INLINABLE wrap_Nonterminals #-}
wrap_Nonterminals :: T_Nonterminals -> Inh_Nonterminals -> (Syn_Nonterminals )
wrap_Nonterminals (T_Nonterminals act) (Inh_Nonterminals _lhsIacount _lhsIallnts _lhsIaroundMap _lhsIcInterfaceMap _lhsIcVisitsMap _lhsIinhMap _lhsImanualAttrDepMap _lhsImergeMap _lhsIo_case _lhsIo_cata _lhsIo_data _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_unbox _lhsIo_wantvisit _lhsIoptions _lhsIprefix _lhsIsynMap _lhsIvcount) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg16 = T_Nonterminals_vIn16 _lhsIacount _lhsIallnts _lhsIaroundMap _lhsIcInterfaceMap _lhsIcVisitsMap _lhsIinhMap _lhsImanualAttrDepMap _lhsImergeMap _lhsIo_case _lhsIo_cata _lhsIo_data _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_unbox _lhsIo_wantvisit _lhsIoptions _lhsIprefix _lhsIsynMap _lhsIvcount
(T_Nonterminals_vOut16 _lhsOacount _lhsOadditionalDep _lhsOaranges _lhsOaroundDep _lhsOcNonterminals _lhsOdirectDep _lhsOerrors _lhsOinhMap' _lhsOinstDep _lhsOmergeDep _lhsOmirages _lhsOnAutoRules _lhsOnExplicitRules _lhsOnonts _lhsOntattrs _lhsOrules _lhsOsynMap' _lhsOvcount) <- return (inv_Nonterminals_s17 sem arg16)
return (Syn_Nonterminals _lhsOacount _lhsOadditionalDep _lhsOaranges _lhsOaroundDep _lhsOcNonterminals _lhsOdirectDep _lhsOerrors _lhsOinhMap' _lhsOinstDep _lhsOmergeDep _lhsOmirages _lhsOnAutoRules _lhsOnExplicitRules _lhsOnonts _lhsOntattrs _lhsOrules _lhsOsynMap' _lhsOvcount)
)
-- cata
{-# NOINLINE sem_Nonterminals #-}
sem_Nonterminals :: Nonterminals -> T_Nonterminals
sem_Nonterminals list = Prelude.foldr sem_Nonterminals_Cons sem_Nonterminals_Nil (Prelude.map sem_Nonterminal list)
-- semantic domain
newtype T_Nonterminals = T_Nonterminals {
attach_T_Nonterminals :: Identity (T_Nonterminals_s17 )
}
newtype T_Nonterminals_s17 = C_Nonterminals_s17 {
inv_Nonterminals_s17 :: (T_Nonterminals_v16 )
}
data T_Nonterminals_s18 = C_Nonterminals_s18
type T_Nonterminals_v16 = (T_Nonterminals_vIn16 ) -> (T_Nonterminals_vOut16 )
data T_Nonterminals_vIn16 = T_Nonterminals_vIn16 (Int) ([Identifier]) (Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))) (CInterfaceMap) (CVisitsMap) (Map Identifier Attributes) (AttrOrderMap) (Map NontermIdent (Map ConstructorIdent (Map Identifier (Identifier,[Identifier])))) (Bool) (Bool) (Bool) (Bool) (Bool) (Bool) (Bool) (Bool) (Bool) (Bool) (Options) (String) (Map Identifier Attributes) (Int)
data T_Nonterminals_vOut16 = T_Nonterminals_vOut16 (Int) (Seq Edge) (Seq (Int,Int,Int)) (Seq Edge) (CNonterminals) (Seq Edge) (Seq Error) (Map Identifier Attributes) (Seq Edge) (Seq Edge) ([Mirage.Nonterminal]) (Int) (Int) ([(NontermIdent,[ConstructorIdent])]) (Seq (Vertex,NTAttr)) (Seq (Vertex,CRule)) (Map Identifier Attributes) (Int)
{-# NOINLINE sem_Nonterminals_Cons #-}
sem_Nonterminals_Cons :: T_Nonterminal -> T_Nonterminals -> T_Nonterminals
sem_Nonterminals_Cons arg_hd_ arg_tl_ = T_Nonterminals (return st17) where
{-# NOINLINE st17 #-}
st17 = let
v16 :: T_Nonterminals_v16
v16 = \ (T_Nonterminals_vIn16 _lhsIacount _lhsIallnts _lhsIaroundMap _lhsIcInterfaceMap _lhsIcVisitsMap _lhsIinhMap _lhsImanualAttrDepMap _lhsImergeMap _lhsIo_case _lhsIo_cata _lhsIo_data _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_unbox _lhsIo_wantvisit _lhsIoptions _lhsIprefix _lhsIsynMap _lhsIvcount) -> ( let
_hdX14 = Control.Monad.Identity.runIdentity (attach_T_Nonterminal (arg_hd_))
_tlX17 = Control.Monad.Identity.runIdentity (attach_T_Nonterminals (arg_tl_))
(T_Nonterminal_vOut13 _hdIacount _hdIadditionalDep _hdIaranges _hdIaroundDep _hdIcNonterminal _hdIdirectDep _hdIerrors _hdIinhMap' _hdIinstDep _hdImergeDep _hdImirage _hdInAutoRules _hdInExplicitRules _hdInonts _hdIntattrs _hdIrules _hdIsynMap' _hdIvcount) = inv_Nonterminal_s14 _hdX14 (T_Nonterminal_vIn13 _hdOacount _hdOallnts _hdOaroundMap _hdOcInterfaceMap _hdOcVisitsMap _hdOinhMap _hdOmanualAttrDepMap _hdOmergeMap _hdOo_case _hdOo_cata _hdOo_data _hdOo_dovisit _hdOo_newtypes _hdOo_rename _hdOo_sem _hdOo_sig _hdOo_unbox _hdOo_wantvisit _hdOoptions _hdOprefix _hdOsynMap _hdOvcount)
(T_Nonterminals_vOut16 _tlIacount _tlIadditionalDep _tlIaranges _tlIaroundDep _tlIcNonterminals _tlIdirectDep _tlIerrors _tlIinhMap' _tlIinstDep _tlImergeDep _tlImirages _tlInAutoRules _tlInExplicitRules _tlInonts _tlIntattrs _tlIrules _tlIsynMap' _tlIvcount) = inv_Nonterminals_s17 _tlX17 (T_Nonterminals_vIn16 _tlOacount _tlOallnts _tlOaroundMap _tlOcInterfaceMap _tlOcVisitsMap _tlOinhMap _tlOmanualAttrDepMap _tlOmergeMap _tlOo_case _tlOo_cata _tlOo_data _tlOo_dovisit _tlOo_newtypes _tlOo_rename _tlOo_sem _tlOo_sig _tlOo_unbox _tlOo_wantvisit _tlOoptions _tlOprefix _tlOsynMap _tlOvcount)
_lhsOcNonterminals :: CNonterminals
_lhsOcNonterminals = rule158 _hdIcNonterminal _tlIcNonterminals
_lhsOmirages :: [Mirage.Nonterminal]
_lhsOmirages = rule159 _hdImirage _tlImirages
_lhsOadditionalDep :: Seq Edge
_lhsOadditionalDep = rule160 _hdIadditionalDep _tlIadditionalDep
_lhsOaranges :: Seq (Int,Int,Int)
_lhsOaranges = rule161 _hdIaranges _tlIaranges
_lhsOaroundDep :: Seq Edge
_lhsOaroundDep = rule162 _hdIaroundDep _tlIaroundDep
_lhsOdirectDep :: Seq Edge
_lhsOdirectDep = rule163 _hdIdirectDep _tlIdirectDep
_lhsOerrors :: Seq Error
_lhsOerrors = rule164 _hdIerrors _tlIerrors
_lhsOinhMap' :: Map Identifier Attributes
_lhsOinhMap' = rule165 _hdIinhMap' _tlIinhMap'
_lhsOinstDep :: Seq Edge
_lhsOinstDep = rule166 _hdIinstDep _tlIinstDep
_lhsOmergeDep :: Seq Edge
_lhsOmergeDep = rule167 _hdImergeDep _tlImergeDep
_lhsOnAutoRules :: Int
_lhsOnAutoRules = rule168 _hdInAutoRules _tlInAutoRules
_lhsOnExplicitRules :: Int
_lhsOnExplicitRules = rule169 _hdInExplicitRules _tlInExplicitRules
_lhsOnonts :: [(NontermIdent,[ConstructorIdent])]
_lhsOnonts = rule170 _hdInonts _tlInonts
_lhsOntattrs :: Seq (Vertex,NTAttr)
_lhsOntattrs = rule171 _hdIntattrs _tlIntattrs
_lhsOrules :: Seq (Vertex,CRule)
_lhsOrules = rule172 _hdIrules _tlIrules
_lhsOsynMap' :: Map Identifier Attributes
_lhsOsynMap' = rule173 _hdIsynMap' _tlIsynMap'
_lhsOacount :: Int
_lhsOacount = rule174 _tlIacount
_lhsOvcount :: Int
_lhsOvcount = rule175 _tlIvcount
_hdOacount = rule176 _lhsIacount
_hdOallnts = rule177 _lhsIallnts
_hdOaroundMap = rule178 _lhsIaroundMap
_hdOcInterfaceMap = rule179 _lhsIcInterfaceMap
_hdOcVisitsMap = rule180 _lhsIcVisitsMap
_hdOinhMap = rule181 _lhsIinhMap
_hdOmanualAttrDepMap = rule182 _lhsImanualAttrDepMap
_hdOmergeMap = rule183 _lhsImergeMap
_hdOo_case = rule184 _lhsIo_case
_hdOo_cata = rule185 _lhsIo_cata
_hdOo_data = rule186 _lhsIo_data
_hdOo_dovisit = rule187 _lhsIo_dovisit
_hdOo_newtypes = rule188 _lhsIo_newtypes
_hdOo_rename = rule189 _lhsIo_rename
_hdOo_sem = rule190 _lhsIo_sem
_hdOo_sig = rule191 _lhsIo_sig
_hdOo_unbox = rule192 _lhsIo_unbox
_hdOo_wantvisit = rule193 _lhsIo_wantvisit
_hdOoptions = rule194 _lhsIoptions
_hdOprefix = rule195 _lhsIprefix
_hdOsynMap = rule196 _lhsIsynMap
_hdOvcount = rule197 _lhsIvcount
_tlOacount = rule198 _hdIacount
_tlOallnts = rule199 _lhsIallnts
_tlOaroundMap = rule200 _lhsIaroundMap
_tlOcInterfaceMap = rule201 _lhsIcInterfaceMap
_tlOcVisitsMap = rule202 _lhsIcVisitsMap
_tlOinhMap = rule203 _lhsIinhMap
_tlOmanualAttrDepMap = rule204 _lhsImanualAttrDepMap
_tlOmergeMap = rule205 _lhsImergeMap
_tlOo_case = rule206 _lhsIo_case
_tlOo_cata = rule207 _lhsIo_cata
_tlOo_data = rule208 _lhsIo_data
_tlOo_dovisit = rule209 _lhsIo_dovisit
_tlOo_newtypes = rule210 _lhsIo_newtypes
_tlOo_rename = rule211 _lhsIo_rename
_tlOo_sem = rule212 _lhsIo_sem
_tlOo_sig = rule213 _lhsIo_sig
_tlOo_unbox = rule214 _lhsIo_unbox
_tlOo_wantvisit = rule215 _lhsIo_wantvisit
_tlOoptions = rule216 _lhsIoptions
_tlOprefix = rule217 _lhsIprefix
_tlOsynMap = rule218 _lhsIsynMap
_tlOvcount = rule219 _hdIvcount
__result_ = T_Nonterminals_vOut16 _lhsOacount _lhsOadditionalDep _lhsOaranges _lhsOaroundDep _lhsOcNonterminals _lhsOdirectDep _lhsOerrors _lhsOinhMap' _lhsOinstDep _lhsOmergeDep _lhsOmirages _lhsOnAutoRules _lhsOnExplicitRules _lhsOnonts _lhsOntattrs _lhsOrules _lhsOsynMap' _lhsOvcount
in __result_ )
in C_Nonterminals_s17 v16
{-# INLINE rule158 #-}
{-# LINE 626 "src-ag/Order.ag" #-}
rule158 = \ ((_hdIcNonterminal) :: CNonterminal) ((_tlIcNonterminals) :: CNonterminals) ->
{-# LINE 626 "src-ag/Order.ag" #-}
_hdIcNonterminal : _tlIcNonterminals
{-# LINE 1598 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule159 #-}
{-# LINE 25 "src-ag/TfmToMirage.ag" #-}
rule159 = \ ((_hdImirage) :: Mirage.Nonterminal) ((_tlImirages) :: [Mirage.Nonterminal]) ->
{-# LINE 25 "src-ag/TfmToMirage.ag" #-}
_hdImirage : _tlImirages
{-# LINE 1604 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule160 #-}
rule160 = \ ((_hdIadditionalDep) :: Seq Edge) ((_tlIadditionalDep) :: Seq Edge) ->
_hdIadditionalDep Seq.>< _tlIadditionalDep
{-# INLINE rule161 #-}
rule161 = \ ((_hdIaranges) :: Seq (Int,Int,Int)) ((_tlIaranges) :: Seq (Int,Int,Int)) ->
_hdIaranges Seq.>< _tlIaranges
{-# INLINE rule162 #-}
rule162 = \ ((_hdIaroundDep) :: Seq Edge) ((_tlIaroundDep) :: Seq Edge) ->
_hdIaroundDep Seq.>< _tlIaroundDep
{-# INLINE rule163 #-}
rule163 = \ ((_hdIdirectDep) :: Seq Edge) ((_tlIdirectDep) :: Seq Edge) ->
_hdIdirectDep Seq.>< _tlIdirectDep
{-# INLINE rule164 #-}
rule164 = \ ((_hdIerrors) :: Seq Error) ((_tlIerrors) :: Seq Error) ->
_hdIerrors Seq.>< _tlIerrors
{-# INLINE rule165 #-}
rule165 = \ ((_hdIinhMap') :: Map Identifier Attributes) ((_tlIinhMap') :: Map Identifier Attributes) ->
_hdIinhMap' `Map.union` _tlIinhMap'
{-# INLINE rule166 #-}
rule166 = \ ((_hdIinstDep) :: Seq Edge) ((_tlIinstDep) :: Seq Edge) ->
_hdIinstDep Seq.>< _tlIinstDep
{-# INLINE rule167 #-}
rule167 = \ ((_hdImergeDep) :: Seq Edge) ((_tlImergeDep) :: Seq Edge) ->
_hdImergeDep Seq.>< _tlImergeDep
{-# INLINE rule168 #-}
rule168 = \ ((_hdInAutoRules) :: Int) ((_tlInAutoRules) :: Int) ->
_hdInAutoRules + _tlInAutoRules
{-# INLINE rule169 #-}
rule169 = \ ((_hdInExplicitRules) :: Int) ((_tlInExplicitRules) :: Int) ->
_hdInExplicitRules + _tlInExplicitRules
{-# INLINE rule170 #-}
rule170 = \ ((_hdInonts) :: [(NontermIdent,[ConstructorIdent])]) ((_tlInonts) :: [(NontermIdent,[ConstructorIdent])]) ->
_hdInonts ++ _tlInonts
{-# INLINE rule171 #-}
rule171 = \ ((_hdIntattrs) :: Seq (Vertex,NTAttr)) ((_tlIntattrs) :: Seq (Vertex,NTAttr)) ->
_hdIntattrs Seq.>< _tlIntattrs
{-# INLINE rule172 #-}
rule172 = \ ((_hdIrules) :: Seq (Vertex,CRule)) ((_tlIrules) :: Seq (Vertex,CRule)) ->
_hdIrules Seq.>< _tlIrules
{-# INLINE rule173 #-}
rule173 = \ ((_hdIsynMap') :: Map Identifier Attributes) ((_tlIsynMap') :: Map Identifier Attributes) ->
_hdIsynMap' `Map.union` _tlIsynMap'
{-# INLINE rule174 #-}
rule174 = \ ((_tlIacount) :: Int) ->
_tlIacount
{-# INLINE rule175 #-}
rule175 = \ ((_tlIvcount) :: Int) ->
_tlIvcount
{-# INLINE rule176 #-}
rule176 = \ ((_lhsIacount) :: Int) ->
_lhsIacount
{-# INLINE rule177 #-}
rule177 = \ ((_lhsIallnts) :: [Identifier]) ->
_lhsIallnts
{-# INLINE rule178 #-}
rule178 = \ ((_lhsIaroundMap) :: Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))) ->
_lhsIaroundMap
{-# INLINE rule179 #-}
rule179 = \ ((_lhsIcInterfaceMap) :: CInterfaceMap) ->
_lhsIcInterfaceMap
{-# INLINE rule180 #-}
rule180 = \ ((_lhsIcVisitsMap) :: CVisitsMap) ->
_lhsIcVisitsMap
{-# INLINE rule181 #-}
rule181 = \ ((_lhsIinhMap) :: Map Identifier Attributes) ->
_lhsIinhMap
{-# INLINE rule182 #-}
rule182 = \ ((_lhsImanualAttrDepMap) :: AttrOrderMap) ->
_lhsImanualAttrDepMap
{-# INLINE rule183 #-}
rule183 = \ ((_lhsImergeMap) :: Map NontermIdent (Map ConstructorIdent (Map Identifier (Identifier,[Identifier])))) ->
_lhsImergeMap
{-# INLINE rule184 #-}
rule184 = \ ((_lhsIo_case) :: Bool) ->
_lhsIo_case
{-# INLINE rule185 #-}
rule185 = \ ((_lhsIo_cata) :: Bool) ->
_lhsIo_cata
{-# INLINE rule186 #-}
rule186 = \ ((_lhsIo_data) :: Bool) ->
_lhsIo_data
{-# INLINE rule187 #-}
rule187 = \ ((_lhsIo_dovisit) :: Bool) ->
_lhsIo_dovisit
{-# INLINE rule188 #-}
rule188 = \ ((_lhsIo_newtypes) :: Bool) ->
_lhsIo_newtypes
{-# INLINE rule189 #-}
rule189 = \ ((_lhsIo_rename) :: Bool) ->
_lhsIo_rename
{-# INLINE rule190 #-}
rule190 = \ ((_lhsIo_sem) :: Bool) ->
_lhsIo_sem
{-# INLINE rule191 #-}
rule191 = \ ((_lhsIo_sig) :: Bool) ->
_lhsIo_sig
{-# INLINE rule192 #-}
rule192 = \ ((_lhsIo_unbox) :: Bool) ->
_lhsIo_unbox
{-# INLINE rule193 #-}
rule193 = \ ((_lhsIo_wantvisit) :: Bool) ->
_lhsIo_wantvisit
{-# INLINE rule194 #-}
rule194 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# INLINE rule195 #-}
rule195 = \ ((_lhsIprefix) :: String) ->
_lhsIprefix
{-# INLINE rule196 #-}
rule196 = \ ((_lhsIsynMap) :: Map Identifier Attributes) ->
_lhsIsynMap
{-# INLINE rule197 #-}
rule197 = \ ((_lhsIvcount) :: Int) ->
_lhsIvcount
{-# INLINE rule198 #-}
rule198 = \ ((_hdIacount) :: Int) ->
_hdIacount
{-# INLINE rule199 #-}
rule199 = \ ((_lhsIallnts) :: [Identifier]) ->
_lhsIallnts
{-# INLINE rule200 #-}
rule200 = \ ((_lhsIaroundMap) :: Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))) ->
_lhsIaroundMap
{-# INLINE rule201 #-}
rule201 = \ ((_lhsIcInterfaceMap) :: CInterfaceMap) ->
_lhsIcInterfaceMap
{-# INLINE rule202 #-}
rule202 = \ ((_lhsIcVisitsMap) :: CVisitsMap) ->
_lhsIcVisitsMap
{-# INLINE rule203 #-}
rule203 = \ ((_lhsIinhMap) :: Map Identifier Attributes) ->
_lhsIinhMap
{-# INLINE rule204 #-}
rule204 = \ ((_lhsImanualAttrDepMap) :: AttrOrderMap) ->
_lhsImanualAttrDepMap
{-# INLINE rule205 #-}
rule205 = \ ((_lhsImergeMap) :: Map NontermIdent (Map ConstructorIdent (Map Identifier (Identifier,[Identifier])))) ->
_lhsImergeMap
{-# INLINE rule206 #-}
rule206 = \ ((_lhsIo_case) :: Bool) ->
_lhsIo_case
{-# INLINE rule207 #-}
rule207 = \ ((_lhsIo_cata) :: Bool) ->
_lhsIo_cata
{-# INLINE rule208 #-}
rule208 = \ ((_lhsIo_data) :: Bool) ->
_lhsIo_data
{-# INLINE rule209 #-}
rule209 = \ ((_lhsIo_dovisit) :: Bool) ->
_lhsIo_dovisit
{-# INLINE rule210 #-}
rule210 = \ ((_lhsIo_newtypes) :: Bool) ->
_lhsIo_newtypes
{-# INLINE rule211 #-}
rule211 = \ ((_lhsIo_rename) :: Bool) ->
_lhsIo_rename
{-# INLINE rule212 #-}
rule212 = \ ((_lhsIo_sem) :: Bool) ->
_lhsIo_sem
{-# INLINE rule213 #-}
rule213 = \ ((_lhsIo_sig) :: Bool) ->
_lhsIo_sig
{-# INLINE rule214 #-}
rule214 = \ ((_lhsIo_unbox) :: Bool) ->
_lhsIo_unbox
{-# INLINE rule215 #-}
rule215 = \ ((_lhsIo_wantvisit) :: Bool) ->
_lhsIo_wantvisit
{-# INLINE rule216 #-}
rule216 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# INLINE rule217 #-}
rule217 = \ ((_lhsIprefix) :: String) ->
_lhsIprefix
{-# INLINE rule218 #-}
rule218 = \ ((_lhsIsynMap) :: Map Identifier Attributes) ->
_lhsIsynMap
{-# INLINE rule219 #-}
rule219 = \ ((_hdIvcount) :: Int) ->
_hdIvcount
{-# NOINLINE sem_Nonterminals_Nil #-}
sem_Nonterminals_Nil :: T_Nonterminals
sem_Nonterminals_Nil = T_Nonterminals (return st17) where
{-# NOINLINE st17 #-}
st17 = let
v16 :: T_Nonterminals_v16
v16 = \ (T_Nonterminals_vIn16 _lhsIacount _lhsIallnts _lhsIaroundMap _lhsIcInterfaceMap _lhsIcVisitsMap _lhsIinhMap _lhsImanualAttrDepMap _lhsImergeMap _lhsIo_case _lhsIo_cata _lhsIo_data _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_unbox _lhsIo_wantvisit _lhsIoptions _lhsIprefix _lhsIsynMap _lhsIvcount) -> ( let
_lhsOcNonterminals :: CNonterminals
_lhsOcNonterminals = rule220 ()
_lhsOmirages :: [Mirage.Nonterminal]
_lhsOmirages = rule221 ()
_lhsOadditionalDep :: Seq Edge
_lhsOadditionalDep = rule222 ()
_lhsOaranges :: Seq (Int,Int,Int)
_lhsOaranges = rule223 ()
_lhsOaroundDep :: Seq Edge
_lhsOaroundDep = rule224 ()
_lhsOdirectDep :: Seq Edge
_lhsOdirectDep = rule225 ()
_lhsOerrors :: Seq Error
_lhsOerrors = rule226 ()
_lhsOinhMap' :: Map Identifier Attributes
_lhsOinhMap' = rule227 ()
_lhsOinstDep :: Seq Edge
_lhsOinstDep = rule228 ()
_lhsOmergeDep :: Seq Edge
_lhsOmergeDep = rule229 ()
_lhsOnAutoRules :: Int
_lhsOnAutoRules = rule230 ()
_lhsOnExplicitRules :: Int
_lhsOnExplicitRules = rule231 ()
_lhsOnonts :: [(NontermIdent,[ConstructorIdent])]
_lhsOnonts = rule232 ()
_lhsOntattrs :: Seq (Vertex,NTAttr)
_lhsOntattrs = rule233 ()
_lhsOrules :: Seq (Vertex,CRule)
_lhsOrules = rule234 ()
_lhsOsynMap' :: Map Identifier Attributes
_lhsOsynMap' = rule235 ()
_lhsOacount :: Int
_lhsOacount = rule236 _lhsIacount
_lhsOvcount :: Int
_lhsOvcount = rule237 _lhsIvcount
__result_ = T_Nonterminals_vOut16 _lhsOacount _lhsOadditionalDep _lhsOaranges _lhsOaroundDep _lhsOcNonterminals _lhsOdirectDep _lhsOerrors _lhsOinhMap' _lhsOinstDep _lhsOmergeDep _lhsOmirages _lhsOnAutoRules _lhsOnExplicitRules _lhsOnonts _lhsOntattrs _lhsOrules _lhsOsynMap' _lhsOvcount
in __result_ )
in C_Nonterminals_s17 v16
{-# INLINE rule220 #-}
{-# LINE 627 "src-ag/Order.ag" #-}
rule220 = \ (_ :: ()) ->
{-# LINE 627 "src-ag/Order.ag" #-}
[]
{-# LINE 1836 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule221 #-}
{-# LINE 26 "src-ag/TfmToMirage.ag" #-}
rule221 = \ (_ :: ()) ->
{-# LINE 26 "src-ag/TfmToMirage.ag" #-}
[]
{-# LINE 1842 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule222 #-}
rule222 = \ (_ :: ()) ->
Seq.empty
{-# INLINE rule223 #-}
rule223 = \ (_ :: ()) ->
Seq.empty
{-# INLINE rule224 #-}
rule224 = \ (_ :: ()) ->
Seq.empty
{-# INLINE rule225 #-}
rule225 = \ (_ :: ()) ->
Seq.empty
{-# INLINE rule226 #-}
rule226 = \ (_ :: ()) ->
Seq.empty
{-# INLINE rule227 #-}
rule227 = \ (_ :: ()) ->
Map.empty
{-# INLINE rule228 #-}
rule228 = \ (_ :: ()) ->
Seq.empty
{-# INLINE rule229 #-}
rule229 = \ (_ :: ()) ->
Seq.empty
{-# INLINE rule230 #-}
rule230 = \ (_ :: ()) ->
0
{-# INLINE rule231 #-}
rule231 = \ (_ :: ()) ->
0
{-# INLINE rule232 #-}
rule232 = \ (_ :: ()) ->
[]
{-# INLINE rule233 #-}
rule233 = \ (_ :: ()) ->
Seq.empty
{-# INLINE rule234 #-}
rule234 = \ (_ :: ()) ->
Seq.empty
{-# INLINE rule235 #-}
rule235 = \ (_ :: ()) ->
Map.empty
{-# INLINE rule236 #-}
rule236 = \ ((_lhsIacount) :: Int) ->
_lhsIacount
{-# INLINE rule237 #-}
rule237 = \ ((_lhsIvcount) :: Int) ->
_lhsIvcount
-- Pattern -----------------------------------------------------
-- wrapper
data Inh_Pattern = Inh_Pattern { allTypeSigs_Inh_Pattern :: (Map Identifier Type), altAttrs_Inh_Pattern :: (Map AltAttr Vertex), belowIrrefutable_Inh_Pattern :: (Bool), con_Inh_Pattern :: (Identifier), inh_Inh_Pattern :: (Attributes), nt_Inh_Pattern :: (Identifier), syn_Inh_Pattern :: (Attributes) }
data Syn_Pattern = Syn_Pattern { copy_Syn_Pattern :: (Pattern), errors_Syn_Pattern :: (Seq Error), gathAltAttrs_Syn_Pattern :: ([AltAttr]), instVars_Syn_Pattern :: ([Identifier]), isUnderscore_Syn_Pattern :: (Bool), locVars_Syn_Pattern :: ([Identifier]), patternAttrs_Syn_Pattern :: ([(Identifier,Identifier,Bool)]), pp_Syn_Pattern :: (PP_Doc) }
{-# INLINABLE wrap_Pattern #-}
wrap_Pattern :: T_Pattern -> Inh_Pattern -> (Syn_Pattern )
wrap_Pattern (T_Pattern act) (Inh_Pattern _lhsIallTypeSigs _lhsIaltAttrs _lhsIbelowIrrefutable _lhsIcon _lhsIinh _lhsInt _lhsIsyn) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg19 = T_Pattern_vIn19 _lhsIallTypeSigs _lhsIaltAttrs _lhsIbelowIrrefutable _lhsIcon _lhsIinh _lhsInt _lhsIsyn
(T_Pattern_vOut19 _lhsOcopy _lhsOerrors _lhsOgathAltAttrs _lhsOinstVars _lhsOisUnderscore _lhsOlocVars _lhsOpatternAttrs _lhsOpp) <- return (inv_Pattern_s20 sem arg19)
return (Syn_Pattern _lhsOcopy _lhsOerrors _lhsOgathAltAttrs _lhsOinstVars _lhsOisUnderscore _lhsOlocVars _lhsOpatternAttrs _lhsOpp)
)
-- cata
{-# NOINLINE sem_Pattern #-}
sem_Pattern :: Pattern -> T_Pattern
sem_Pattern ( Constr name_ pats_ ) = sem_Pattern_Constr name_ ( sem_Patterns pats_ )
sem_Pattern ( Product pos_ pats_ ) = sem_Pattern_Product pos_ ( sem_Patterns pats_ )
sem_Pattern ( Alias field_ attr_ pat_ ) = sem_Pattern_Alias field_ attr_ ( sem_Pattern pat_ )
sem_Pattern ( Irrefutable pat_ ) = sem_Pattern_Irrefutable ( sem_Pattern pat_ )
sem_Pattern ( Underscore pos_ ) = sem_Pattern_Underscore pos_
-- semantic domain
newtype T_Pattern = T_Pattern {
attach_T_Pattern :: Identity (T_Pattern_s20 )
}
newtype T_Pattern_s20 = C_Pattern_s20 {
inv_Pattern_s20 :: (T_Pattern_v19 )
}
data T_Pattern_s21 = C_Pattern_s21
type T_Pattern_v19 = (T_Pattern_vIn19 ) -> (T_Pattern_vOut19 )
data T_Pattern_vIn19 = T_Pattern_vIn19 (Map Identifier Type) (Map AltAttr Vertex) (Bool) (Identifier) (Attributes) (Identifier) (Attributes)
data T_Pattern_vOut19 = T_Pattern_vOut19 (Pattern) (Seq Error) ([AltAttr]) ([Identifier]) (Bool) ([Identifier]) ([(Identifier,Identifier,Bool)]) (PP_Doc)
{-# NOINLINE sem_Pattern_Constr #-}
sem_Pattern_Constr :: (ConstructorIdent) -> T_Patterns -> T_Pattern
sem_Pattern_Constr arg_name_ arg_pats_ = T_Pattern (return st20) where
{-# NOINLINE st20 #-}
st20 = let
v19 :: T_Pattern_v19
v19 = \ (T_Pattern_vIn19 _lhsIallTypeSigs _lhsIaltAttrs _lhsIbelowIrrefutable _lhsIcon _lhsIinh _lhsInt _lhsIsyn) -> ( let
_patsX23 = Control.Monad.Identity.runIdentity (attach_T_Patterns (arg_pats_))
(T_Patterns_vOut22 _patsIcopy _patsIerrors _patsIgathAltAttrs _patsIinstVars _patsIlocVars _patsIpatternAttrs _patsIpps) = inv_Patterns_s23 _patsX23 (T_Patterns_vIn22 _patsOallTypeSigs _patsOaltAttrs _patsObelowIrrefutable _patsOcon _patsOinh _patsOnt _patsOsyn)
_lhsOpp :: PP_Doc
_lhsOpp = rule238 _patsIpps arg_name_
_lhsOisUnderscore :: Bool
_lhsOisUnderscore = rule239 ()
_lhsOerrors :: Seq Error
_lhsOerrors = rule240 _patsIerrors
_lhsOgathAltAttrs :: [AltAttr]
_lhsOgathAltAttrs = rule241 _patsIgathAltAttrs
_lhsOinstVars :: [Identifier]
_lhsOinstVars = rule242 _patsIinstVars
_lhsOlocVars :: [Identifier]
_lhsOlocVars = rule243 _patsIlocVars
_lhsOpatternAttrs :: [(Identifier,Identifier,Bool)]
_lhsOpatternAttrs = rule244 _patsIpatternAttrs
_copy = rule245 _patsIcopy arg_name_
_lhsOcopy :: Pattern
_lhsOcopy = rule246 _copy
_patsOallTypeSigs = rule247 _lhsIallTypeSigs
_patsOaltAttrs = rule248 _lhsIaltAttrs
_patsObelowIrrefutable = rule249 _lhsIbelowIrrefutable
_patsOcon = rule250 _lhsIcon
_patsOinh = rule251 _lhsIinh
_patsOnt = rule252 _lhsInt
_patsOsyn = rule253 _lhsIsyn
__result_ = T_Pattern_vOut19 _lhsOcopy _lhsOerrors _lhsOgathAltAttrs _lhsOinstVars _lhsOisUnderscore _lhsOlocVars _lhsOpatternAttrs _lhsOpp
in __result_ )
in C_Pattern_s20 v19
{-# INLINE rule238 #-}
{-# LINE 80 "src-ag/TfmToMirage.ag" #-}
rule238 = \ ((_patsIpps) :: [PP_Doc]) name_ ->
{-# LINE 80 "src-ag/TfmToMirage.ag" #-}
pp_parens $ name_ >#< hv_sp _patsIpps
{-# LINE 1967 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule239 #-}
{-# LINE 91 "src-ag/TfmToMirage.ag" #-}
rule239 = \ (_ :: ()) ->
{-# LINE 91 "src-ag/TfmToMirage.ag" #-}
False
{-# LINE 1973 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule240 #-}
rule240 = \ ((_patsIerrors) :: Seq Error) ->
_patsIerrors
{-# INLINE rule241 #-}
rule241 = \ ((_patsIgathAltAttrs) :: [AltAttr]) ->
_patsIgathAltAttrs
{-# INLINE rule242 #-}
rule242 = \ ((_patsIinstVars) :: [Identifier]) ->
_patsIinstVars
{-# INLINE rule243 #-}
rule243 = \ ((_patsIlocVars) :: [Identifier]) ->
_patsIlocVars
{-# INLINE rule244 #-}
rule244 = \ ((_patsIpatternAttrs) :: [(Identifier,Identifier,Bool)]) ->
_patsIpatternAttrs
{-# INLINE rule245 #-}
rule245 = \ ((_patsIcopy) :: Patterns) name_ ->
Constr name_ _patsIcopy
{-# INLINE rule246 #-}
rule246 = \ _copy ->
_copy
{-# INLINE rule247 #-}
rule247 = \ ((_lhsIallTypeSigs) :: Map Identifier Type) ->
_lhsIallTypeSigs
{-# INLINE rule248 #-}
rule248 = \ ((_lhsIaltAttrs) :: Map AltAttr Vertex) ->
_lhsIaltAttrs
{-# INLINE rule249 #-}
rule249 = \ ((_lhsIbelowIrrefutable) :: Bool) ->
_lhsIbelowIrrefutable
{-# INLINE rule250 #-}
rule250 = \ ((_lhsIcon) :: Identifier) ->
_lhsIcon
{-# INLINE rule251 #-}
rule251 = \ ((_lhsIinh) :: Attributes) ->
_lhsIinh
{-# INLINE rule252 #-}
rule252 = \ ((_lhsInt) :: Identifier) ->
_lhsInt
{-# INLINE rule253 #-}
rule253 = \ ((_lhsIsyn) :: Attributes) ->
_lhsIsyn
{-# NOINLINE sem_Pattern_Product #-}
sem_Pattern_Product :: (Pos) -> T_Patterns -> T_Pattern
sem_Pattern_Product arg_pos_ arg_pats_ = T_Pattern (return st20) where
{-# NOINLINE st20 #-}
st20 = let
v19 :: T_Pattern_v19
v19 = \ (T_Pattern_vIn19 _lhsIallTypeSigs _lhsIaltAttrs _lhsIbelowIrrefutable _lhsIcon _lhsIinh _lhsInt _lhsIsyn) -> ( let
_patsX23 = Control.Monad.Identity.runIdentity (attach_T_Patterns (arg_pats_))
(T_Patterns_vOut22 _patsIcopy _patsIerrors _patsIgathAltAttrs _patsIinstVars _patsIlocVars _patsIpatternAttrs _patsIpps) = inv_Patterns_s23 _patsX23 (T_Patterns_vIn22 _patsOallTypeSigs _patsOaltAttrs _patsObelowIrrefutable _patsOcon _patsOinh _patsOnt _patsOsyn)
_lhsOpp :: PP_Doc
_lhsOpp = rule254 _patsIpps
_lhsOisUnderscore :: Bool
_lhsOisUnderscore = rule255 ()
_lhsOerrors :: Seq Error
_lhsOerrors = rule256 _patsIerrors
_lhsOgathAltAttrs :: [AltAttr]
_lhsOgathAltAttrs = rule257 _patsIgathAltAttrs
_lhsOinstVars :: [Identifier]
_lhsOinstVars = rule258 _patsIinstVars
_lhsOlocVars :: [Identifier]
_lhsOlocVars = rule259 _patsIlocVars
_lhsOpatternAttrs :: [(Identifier,Identifier,Bool)]
_lhsOpatternAttrs = rule260 _patsIpatternAttrs
_copy = rule261 _patsIcopy arg_pos_
_lhsOcopy :: Pattern
_lhsOcopy = rule262 _copy
_patsOallTypeSigs = rule263 _lhsIallTypeSigs
_patsOaltAttrs = rule264 _lhsIaltAttrs
_patsObelowIrrefutable = rule265 _lhsIbelowIrrefutable
_patsOcon = rule266 _lhsIcon
_patsOinh = rule267 _lhsIinh
_patsOnt = rule268 _lhsInt
_patsOsyn = rule269 _lhsIsyn
__result_ = T_Pattern_vOut19 _lhsOcopy _lhsOerrors _lhsOgathAltAttrs _lhsOinstVars _lhsOisUnderscore _lhsOlocVars _lhsOpatternAttrs _lhsOpp
in __result_ )
in C_Pattern_s20 v19
{-# INLINE rule254 #-}
{-# LINE 81 "src-ag/TfmToMirage.ag" #-}
rule254 = \ ((_patsIpps) :: [PP_Doc]) ->
{-# LINE 81 "src-ag/TfmToMirage.ag" #-}
pp_block "(" ")" "," _patsIpps
{-# LINE 2057 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule255 #-}
{-# LINE 92 "src-ag/TfmToMirage.ag" #-}
rule255 = \ (_ :: ()) ->
{-# LINE 92 "src-ag/TfmToMirage.ag" #-}
False
{-# LINE 2063 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule256 #-}
rule256 = \ ((_patsIerrors) :: Seq Error) ->
_patsIerrors
{-# INLINE rule257 #-}
rule257 = \ ((_patsIgathAltAttrs) :: [AltAttr]) ->
_patsIgathAltAttrs
{-# INLINE rule258 #-}
rule258 = \ ((_patsIinstVars) :: [Identifier]) ->
_patsIinstVars
{-# INLINE rule259 #-}
rule259 = \ ((_patsIlocVars) :: [Identifier]) ->
_patsIlocVars
{-# INLINE rule260 #-}
rule260 = \ ((_patsIpatternAttrs) :: [(Identifier,Identifier,Bool)]) ->
_patsIpatternAttrs
{-# INLINE rule261 #-}
rule261 = \ ((_patsIcopy) :: Patterns) pos_ ->
Product pos_ _patsIcopy
{-# INLINE rule262 #-}
rule262 = \ _copy ->
_copy
{-# INLINE rule263 #-}
rule263 = \ ((_lhsIallTypeSigs) :: Map Identifier Type) ->
_lhsIallTypeSigs
{-# INLINE rule264 #-}
rule264 = \ ((_lhsIaltAttrs) :: Map AltAttr Vertex) ->
_lhsIaltAttrs
{-# INLINE rule265 #-}
rule265 = \ ((_lhsIbelowIrrefutable) :: Bool) ->
_lhsIbelowIrrefutable
{-# INLINE rule266 #-}
rule266 = \ ((_lhsIcon) :: Identifier) ->
_lhsIcon
{-# INLINE rule267 #-}
rule267 = \ ((_lhsIinh) :: Attributes) ->
_lhsIinh
{-# INLINE rule268 #-}
rule268 = \ ((_lhsInt) :: Identifier) ->
_lhsInt
{-# INLINE rule269 #-}
rule269 = \ ((_lhsIsyn) :: Attributes) ->
_lhsIsyn
{-# NOINLINE sem_Pattern_Alias #-}
sem_Pattern_Alias :: (Identifier) -> (Identifier) -> T_Pattern -> T_Pattern
sem_Pattern_Alias arg_field_ arg_attr_ arg_pat_ = T_Pattern (return st20) where
{-# NOINLINE st20 #-}
st20 = let
v19 :: T_Pattern_v19
v19 = \ (T_Pattern_vIn19 _lhsIallTypeSigs _lhsIaltAttrs _lhsIbelowIrrefutable _lhsIcon _lhsIinh _lhsInt _lhsIsyn) -> ( let
_patX20 = Control.Monad.Identity.runIdentity (attach_T_Pattern (arg_pat_))
(T_Pattern_vOut19 _patIcopy _patIerrors _patIgathAltAttrs _patIinstVars _patIisUnderscore _patIlocVars _patIpatternAttrs _patIpp) = inv_Pattern_s20 _patX20 (T_Pattern_vIn19 _patOallTypeSigs _patOaltAttrs _patObelowIrrefutable _patOcon _patOinh _patOnt _patOsyn)
_lhsOgathAltAttrs :: [AltAttr]
_lhsOgathAltAttrs = rule270 arg_attr_ arg_field_
_lhsOpatternAttrs :: [(Identifier,Identifier,Bool)]
_lhsOpatternAttrs = rule271 arg_attr_ arg_field_
_lhsOlocVars :: [Identifier]
_lhsOlocVars = rule272 arg_attr_ arg_field_
_lhsOinstVars :: [Identifier]
_lhsOinstVars = rule273 arg_attr_ arg_field_
_ppVar = rule274 arg_attr_ arg_field_
_ppVarBang = rule275 _ppVar
_lhsOpp :: PP_Doc
_lhsOpp = rule276 _patIisUnderscore _patIpp _ppVarBang
_lhsOisUnderscore :: Bool
_lhsOisUnderscore = rule277 ()
_lhsOerrors :: Seq Error
_lhsOerrors = rule278 _patIerrors
_copy = rule279 _patIcopy arg_attr_ arg_field_
_lhsOcopy :: Pattern
_lhsOcopy = rule280 _copy
_patOallTypeSigs = rule281 _lhsIallTypeSigs
_patOaltAttrs = rule282 _lhsIaltAttrs
_patObelowIrrefutable = rule283 _lhsIbelowIrrefutable
_patOcon = rule284 _lhsIcon
_patOinh = rule285 _lhsIinh
_patOnt = rule286 _lhsInt
_patOsyn = rule287 _lhsIsyn
__result_ = T_Pattern_vOut19 _lhsOcopy _lhsOerrors _lhsOgathAltAttrs _lhsOinstVars _lhsOisUnderscore _lhsOlocVars _lhsOpatternAttrs _lhsOpp
in __result_ )
in C_Pattern_s20 v19
{-# INLINE rule270 #-}
{-# LINE 187 "src-ag/Order.ag" #-}
rule270 = \ attr_ field_ ->
{-# LINE 187 "src-ag/Order.ag" #-}
[AltAttr field_ attr_ (field_ == _LOC || field_ == _INST)]
{-# LINE 2149 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule271 #-}
{-# LINE 253 "src-ag/Order.ag" #-}
rule271 = \ attr_ field_ ->
{-# LINE 253 "src-ag/Order.ag" #-}
[(field_,attr_,(field_ == _LOC || field_ == _INST))]
{-# LINE 2155 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule272 #-}
{-# LINE 685 "src-ag/Order.ag" #-}
rule272 = \ attr_ field_ ->
{-# LINE 685 "src-ag/Order.ag" #-}
if field_ == _LOC
then [attr_]
else []
{-# LINE 2163 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule273 #-}
{-# LINE 688 "src-ag/Order.ag" #-}
rule273 = \ attr_ field_ ->
{-# LINE 688 "src-ag/Order.ag" #-}
if field_ == _INST
then [attr_]
else []
{-# LINE 2171 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule274 #-}
{-# LINE 82 "src-ag/TfmToMirage.ag" #-}
rule274 = \ attr_ field_ ->
{-# LINE 82 "src-ag/TfmToMirage.ag" #-}
pp field_ >|< "." >|< pp attr_
{-# LINE 2177 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule275 #-}
{-# LINE 83 "src-ag/TfmToMirage.ag" #-}
rule275 = \ _ppVar ->
{-# LINE 83 "src-ag/TfmToMirage.ag" #-}
_ppVar
{-# LINE 2183 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule276 #-}
{-# LINE 84 "src-ag/TfmToMirage.ag" #-}
rule276 = \ ((_patIisUnderscore) :: Bool) ((_patIpp) :: PP_Doc) _ppVarBang ->
{-# LINE 84 "src-ag/TfmToMirage.ag" #-}
if _patIisUnderscore
then _ppVarBang
else _ppVarBang >|< "@" >|< _patIpp
{-# LINE 2191 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule277 #-}
{-# LINE 93 "src-ag/TfmToMirage.ag" #-}
rule277 = \ (_ :: ()) ->
{-# LINE 93 "src-ag/TfmToMirage.ag" #-}
False
{-# LINE 2197 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule278 #-}
rule278 = \ ((_patIerrors) :: Seq Error) ->
_patIerrors
{-# INLINE rule279 #-}
rule279 = \ ((_patIcopy) :: Pattern) attr_ field_ ->
Alias field_ attr_ _patIcopy
{-# INLINE rule280 #-}
rule280 = \ _copy ->
_copy
{-# INLINE rule281 #-}
rule281 = \ ((_lhsIallTypeSigs) :: Map Identifier Type) ->
_lhsIallTypeSigs
{-# INLINE rule282 #-}
rule282 = \ ((_lhsIaltAttrs) :: Map AltAttr Vertex) ->
_lhsIaltAttrs
{-# INLINE rule283 #-}
rule283 = \ ((_lhsIbelowIrrefutable) :: Bool) ->
_lhsIbelowIrrefutable
{-# INLINE rule284 #-}
rule284 = \ ((_lhsIcon) :: Identifier) ->
_lhsIcon
{-# INLINE rule285 #-}
rule285 = \ ((_lhsIinh) :: Attributes) ->
_lhsIinh
{-# INLINE rule286 #-}
rule286 = \ ((_lhsInt) :: Identifier) ->
_lhsInt
{-# INLINE rule287 #-}
rule287 = \ ((_lhsIsyn) :: Attributes) ->
_lhsIsyn
{-# NOINLINE sem_Pattern_Irrefutable #-}
sem_Pattern_Irrefutable :: T_Pattern -> T_Pattern
sem_Pattern_Irrefutable arg_pat_ = T_Pattern (return st20) where
{-# NOINLINE st20 #-}
st20 = let
v19 :: T_Pattern_v19
v19 = \ (T_Pattern_vIn19 _lhsIallTypeSigs _lhsIaltAttrs _lhsIbelowIrrefutable _lhsIcon _lhsIinh _lhsInt _lhsIsyn) -> ( let
_patX20 = Control.Monad.Identity.runIdentity (attach_T_Pattern (arg_pat_))
(T_Pattern_vOut19 _patIcopy _patIerrors _patIgathAltAttrs _patIinstVars _patIisUnderscore _patIlocVars _patIpatternAttrs _patIpp) = inv_Pattern_s20 _patX20 (T_Pattern_vIn19 _patOallTypeSigs _patOaltAttrs _patObelowIrrefutable _patOcon _patOinh _patOnt _patOsyn)
_lhsOpp :: PP_Doc
_lhsOpp = rule288 _patIpp
_patObelowIrrefutable = rule289 ()
_lhsOerrors :: Seq Error
_lhsOerrors = rule290 _patIerrors
_lhsOgathAltAttrs :: [AltAttr]
_lhsOgathAltAttrs = rule291 _patIgathAltAttrs
_lhsOinstVars :: [Identifier]
_lhsOinstVars = rule292 _patIinstVars
_lhsOlocVars :: [Identifier]
_lhsOlocVars = rule293 _patIlocVars
_lhsOpatternAttrs :: [(Identifier,Identifier,Bool)]
_lhsOpatternAttrs = rule294 _patIpatternAttrs
_copy = rule295 _patIcopy
_lhsOcopy :: Pattern
_lhsOcopy = rule296 _copy
_lhsOisUnderscore :: Bool
_lhsOisUnderscore = rule297 _patIisUnderscore
_patOallTypeSigs = rule298 _lhsIallTypeSigs
_patOaltAttrs = rule299 _lhsIaltAttrs
_patOcon = rule300 _lhsIcon
_patOinh = rule301 _lhsIinh
_patOnt = rule302 _lhsInt
_patOsyn = rule303 _lhsIsyn
__result_ = T_Pattern_vOut19 _lhsOcopy _lhsOerrors _lhsOgathAltAttrs _lhsOinstVars _lhsOisUnderscore _lhsOlocVars _lhsOpatternAttrs _lhsOpp
in __result_ )
in C_Pattern_s20 v19
{-# INLINE rule288 #-}
{-# LINE 87 "src-ag/TfmToMirage.ag" #-}
rule288 = \ ((_patIpp) :: PP_Doc) ->
{-# LINE 87 "src-ag/TfmToMirage.ag" #-}
text "~" >|< pp_parens _patIpp
{-# LINE 2269 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule289 #-}
{-# LINE 100 "src-ag/TfmToMirage.ag" #-}
rule289 = \ (_ :: ()) ->
{-# LINE 100 "src-ag/TfmToMirage.ag" #-}
True
{-# LINE 2275 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule290 #-}
rule290 = \ ((_patIerrors) :: Seq Error) ->
_patIerrors
{-# INLINE rule291 #-}
rule291 = \ ((_patIgathAltAttrs) :: [AltAttr]) ->
_patIgathAltAttrs
{-# INLINE rule292 #-}
rule292 = \ ((_patIinstVars) :: [Identifier]) ->
_patIinstVars
{-# INLINE rule293 #-}
rule293 = \ ((_patIlocVars) :: [Identifier]) ->
_patIlocVars
{-# INLINE rule294 #-}
rule294 = \ ((_patIpatternAttrs) :: [(Identifier,Identifier,Bool)]) ->
_patIpatternAttrs
{-# INLINE rule295 #-}
rule295 = \ ((_patIcopy) :: Pattern) ->
Irrefutable _patIcopy
{-# INLINE rule296 #-}
rule296 = \ _copy ->
_copy
{-# INLINE rule297 #-}
rule297 = \ ((_patIisUnderscore) :: Bool) ->
_patIisUnderscore
{-# INLINE rule298 #-}
rule298 = \ ((_lhsIallTypeSigs) :: Map Identifier Type) ->
_lhsIallTypeSigs
{-# INLINE rule299 #-}
rule299 = \ ((_lhsIaltAttrs) :: Map AltAttr Vertex) ->
_lhsIaltAttrs
{-# INLINE rule300 #-}
rule300 = \ ((_lhsIcon) :: Identifier) ->
_lhsIcon
{-# INLINE rule301 #-}
rule301 = \ ((_lhsIinh) :: Attributes) ->
_lhsIinh
{-# INLINE rule302 #-}
rule302 = \ ((_lhsInt) :: Identifier) ->
_lhsInt
{-# INLINE rule303 #-}
rule303 = \ ((_lhsIsyn) :: Attributes) ->
_lhsIsyn
{-# NOINLINE sem_Pattern_Underscore #-}
sem_Pattern_Underscore :: (Pos) -> T_Pattern
sem_Pattern_Underscore arg_pos_ = T_Pattern (return st20) where
{-# NOINLINE st20 #-}
st20 = let
v19 :: T_Pattern_v19
v19 = \ (T_Pattern_vIn19 _lhsIallTypeSigs _lhsIaltAttrs _lhsIbelowIrrefutable _lhsIcon _lhsIinh _lhsInt _lhsIsyn) -> ( let
_lhsOpp :: PP_Doc
_lhsOpp = rule304 ()
_lhsOisUnderscore :: Bool
_lhsOisUnderscore = rule305 ()
_lhsOerrors :: Seq Error
_lhsOerrors = rule306 ()
_lhsOgathAltAttrs :: [AltAttr]
_lhsOgathAltAttrs = rule307 ()
_lhsOinstVars :: [Identifier]
_lhsOinstVars = rule308 ()
_lhsOlocVars :: [Identifier]
_lhsOlocVars = rule309 ()
_lhsOpatternAttrs :: [(Identifier,Identifier,Bool)]
_lhsOpatternAttrs = rule310 ()
_copy = rule311 arg_pos_
_lhsOcopy :: Pattern
_lhsOcopy = rule312 _copy
__result_ = T_Pattern_vOut19 _lhsOcopy _lhsOerrors _lhsOgathAltAttrs _lhsOinstVars _lhsOisUnderscore _lhsOlocVars _lhsOpatternAttrs _lhsOpp
in __result_ )
in C_Pattern_s20 v19
{-# INLINE rule304 #-}
{-# LINE 88 "src-ag/TfmToMirage.ag" #-}
rule304 = \ (_ :: ()) ->
{-# LINE 88 "src-ag/TfmToMirage.ag" #-}
text "_"
{-# LINE 2350 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule305 #-}
{-# LINE 94 "src-ag/TfmToMirage.ag" #-}
rule305 = \ (_ :: ()) ->
{-# LINE 94 "src-ag/TfmToMirage.ag" #-}
True
{-# LINE 2356 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule306 #-}
rule306 = \ (_ :: ()) ->
Seq.empty
{-# INLINE rule307 #-}
rule307 = \ (_ :: ()) ->
[]
{-# INLINE rule308 #-}
rule308 = \ (_ :: ()) ->
[]
{-# INLINE rule309 #-}
rule309 = \ (_ :: ()) ->
[]
{-# INLINE rule310 #-}
rule310 = \ (_ :: ()) ->
[]
{-# INLINE rule311 #-}
rule311 = \ pos_ ->
Underscore pos_
{-# INLINE rule312 #-}
rule312 = \ _copy ->
_copy
-- Patterns ----------------------------------------------------
-- wrapper
data Inh_Patterns = Inh_Patterns { allTypeSigs_Inh_Patterns :: (Map Identifier Type), altAttrs_Inh_Patterns :: (Map AltAttr Vertex), belowIrrefutable_Inh_Patterns :: (Bool), con_Inh_Patterns :: (Identifier), inh_Inh_Patterns :: (Attributes), nt_Inh_Patterns :: (Identifier), syn_Inh_Patterns :: (Attributes) }
data Syn_Patterns = Syn_Patterns { copy_Syn_Patterns :: (Patterns), errors_Syn_Patterns :: (Seq Error), gathAltAttrs_Syn_Patterns :: ([AltAttr]), instVars_Syn_Patterns :: ([Identifier]), locVars_Syn_Patterns :: ([Identifier]), patternAttrs_Syn_Patterns :: ([(Identifier,Identifier,Bool)]), pps_Syn_Patterns :: ([PP_Doc]) }
{-# INLINABLE wrap_Patterns #-}
wrap_Patterns :: T_Patterns -> Inh_Patterns -> (Syn_Patterns )
wrap_Patterns (T_Patterns act) (Inh_Patterns _lhsIallTypeSigs _lhsIaltAttrs _lhsIbelowIrrefutable _lhsIcon _lhsIinh _lhsInt _lhsIsyn) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg22 = T_Patterns_vIn22 _lhsIallTypeSigs _lhsIaltAttrs _lhsIbelowIrrefutable _lhsIcon _lhsIinh _lhsInt _lhsIsyn
(T_Patterns_vOut22 _lhsOcopy _lhsOerrors _lhsOgathAltAttrs _lhsOinstVars _lhsOlocVars _lhsOpatternAttrs _lhsOpps) <- return (inv_Patterns_s23 sem arg22)
return (Syn_Patterns _lhsOcopy _lhsOerrors _lhsOgathAltAttrs _lhsOinstVars _lhsOlocVars _lhsOpatternAttrs _lhsOpps)
)
-- cata
{-# NOINLINE sem_Patterns #-}
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 {
attach_T_Patterns :: Identity (T_Patterns_s23 )
}
newtype T_Patterns_s23 = C_Patterns_s23 {
inv_Patterns_s23 :: (T_Patterns_v22 )
}
data T_Patterns_s24 = C_Patterns_s24
type T_Patterns_v22 = (T_Patterns_vIn22 ) -> (T_Patterns_vOut22 )
data T_Patterns_vIn22 = T_Patterns_vIn22 (Map Identifier Type) (Map AltAttr Vertex) (Bool) (Identifier) (Attributes) (Identifier) (Attributes)
data T_Patterns_vOut22 = T_Patterns_vOut22 (Patterns) (Seq Error) ([AltAttr]) ([Identifier]) ([Identifier]) ([(Identifier,Identifier,Bool)]) ([PP_Doc])
{-# NOINLINE sem_Patterns_Cons #-}
sem_Patterns_Cons :: T_Pattern -> T_Patterns -> T_Patterns
sem_Patterns_Cons arg_hd_ arg_tl_ = T_Patterns (return st23) where
{-# NOINLINE st23 #-}
st23 = let
v22 :: T_Patterns_v22
v22 = \ (T_Patterns_vIn22 _lhsIallTypeSigs _lhsIaltAttrs _lhsIbelowIrrefutable _lhsIcon _lhsIinh _lhsInt _lhsIsyn) -> ( let
_hdX20 = Control.Monad.Identity.runIdentity (attach_T_Pattern (arg_hd_))
_tlX23 = Control.Monad.Identity.runIdentity (attach_T_Patterns (arg_tl_))
(T_Pattern_vOut19 _hdIcopy _hdIerrors _hdIgathAltAttrs _hdIinstVars _hdIisUnderscore _hdIlocVars _hdIpatternAttrs _hdIpp) = inv_Pattern_s20 _hdX20 (T_Pattern_vIn19 _hdOallTypeSigs _hdOaltAttrs _hdObelowIrrefutable _hdOcon _hdOinh _hdOnt _hdOsyn)
(T_Patterns_vOut22 _tlIcopy _tlIerrors _tlIgathAltAttrs _tlIinstVars _tlIlocVars _tlIpatternAttrs _tlIpps) = inv_Patterns_s23 _tlX23 (T_Patterns_vIn22 _tlOallTypeSigs _tlOaltAttrs _tlObelowIrrefutable _tlOcon _tlOinh _tlOnt _tlOsyn)
_lhsOpps :: [PP_Doc]
_lhsOpps = rule313 _hdIpp _tlIpps
_lhsOerrors :: Seq Error
_lhsOerrors = rule314 _hdIerrors _tlIerrors
_lhsOgathAltAttrs :: [AltAttr]
_lhsOgathAltAttrs = rule315 _hdIgathAltAttrs _tlIgathAltAttrs
_lhsOinstVars :: [Identifier]
_lhsOinstVars = rule316 _hdIinstVars _tlIinstVars
_lhsOlocVars :: [Identifier]
_lhsOlocVars = rule317 _hdIlocVars _tlIlocVars
_lhsOpatternAttrs :: [(Identifier,Identifier,Bool)]
_lhsOpatternAttrs = rule318 _hdIpatternAttrs _tlIpatternAttrs
_copy = rule319 _hdIcopy _tlIcopy
_lhsOcopy :: Patterns
_lhsOcopy = rule320 _copy
_hdOallTypeSigs = rule321 _lhsIallTypeSigs
_hdOaltAttrs = rule322 _lhsIaltAttrs
_hdObelowIrrefutable = rule323 _lhsIbelowIrrefutable
_hdOcon = rule324 _lhsIcon
_hdOinh = rule325 _lhsIinh
_hdOnt = rule326 _lhsInt
_hdOsyn = rule327 _lhsIsyn
_tlOallTypeSigs = rule328 _lhsIallTypeSigs
_tlOaltAttrs = rule329 _lhsIaltAttrs
_tlObelowIrrefutable = rule330 _lhsIbelowIrrefutable
_tlOcon = rule331 _lhsIcon
_tlOinh = rule332 _lhsIinh
_tlOnt = rule333 _lhsInt
_tlOsyn = rule334 _lhsIsyn
__result_ = T_Patterns_vOut22 _lhsOcopy _lhsOerrors _lhsOgathAltAttrs _lhsOinstVars _lhsOlocVars _lhsOpatternAttrs _lhsOpps
in __result_ )
in C_Patterns_s23 v22
{-# INLINE rule313 #-}
{-# LINE 76 "src-ag/TfmToMirage.ag" #-}
rule313 = \ ((_hdIpp) :: PP_Doc) ((_tlIpps) :: [PP_Doc]) ->
{-# LINE 76 "src-ag/TfmToMirage.ag" #-}
_hdIpp : _tlIpps
{-# LINE 2457 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule314 #-}
rule314 = \ ((_hdIerrors) :: Seq Error) ((_tlIerrors) :: Seq Error) ->
_hdIerrors Seq.>< _tlIerrors
{-# INLINE rule315 #-}
rule315 = \ ((_hdIgathAltAttrs) :: [AltAttr]) ((_tlIgathAltAttrs) :: [AltAttr]) ->
_hdIgathAltAttrs ++ _tlIgathAltAttrs
{-# INLINE rule316 #-}
rule316 = \ ((_hdIinstVars) :: [Identifier]) ((_tlIinstVars) :: [Identifier]) ->
_hdIinstVars ++ _tlIinstVars
{-# INLINE rule317 #-}
rule317 = \ ((_hdIlocVars) :: [Identifier]) ((_tlIlocVars) :: [Identifier]) ->
_hdIlocVars ++ _tlIlocVars
{-# INLINE rule318 #-}
rule318 = \ ((_hdIpatternAttrs) :: [(Identifier,Identifier,Bool)]) ((_tlIpatternAttrs) :: [(Identifier,Identifier,Bool)]) ->
_hdIpatternAttrs ++ _tlIpatternAttrs
{-# INLINE rule319 #-}
rule319 = \ ((_hdIcopy) :: Pattern) ((_tlIcopy) :: Patterns) ->
(:) _hdIcopy _tlIcopy
{-# INLINE rule320 #-}
rule320 = \ _copy ->
_copy
{-# INLINE rule321 #-}
rule321 = \ ((_lhsIallTypeSigs) :: Map Identifier Type) ->
_lhsIallTypeSigs
{-# INLINE rule322 #-}
rule322 = \ ((_lhsIaltAttrs) :: Map AltAttr Vertex) ->
_lhsIaltAttrs
{-# INLINE rule323 #-}
rule323 = \ ((_lhsIbelowIrrefutable) :: Bool) ->
_lhsIbelowIrrefutable
{-# INLINE rule324 #-}
rule324 = \ ((_lhsIcon) :: Identifier) ->
_lhsIcon
{-# INLINE rule325 #-}
rule325 = \ ((_lhsIinh) :: Attributes) ->
_lhsIinh
{-# INLINE rule326 #-}
rule326 = \ ((_lhsInt) :: Identifier) ->
_lhsInt
{-# INLINE rule327 #-}
rule327 = \ ((_lhsIsyn) :: Attributes) ->
_lhsIsyn
{-# INLINE rule328 #-}
rule328 = \ ((_lhsIallTypeSigs) :: Map Identifier Type) ->
_lhsIallTypeSigs
{-# INLINE rule329 #-}
rule329 = \ ((_lhsIaltAttrs) :: Map AltAttr Vertex) ->
_lhsIaltAttrs
{-# INLINE rule330 #-}
rule330 = \ ((_lhsIbelowIrrefutable) :: Bool) ->
_lhsIbelowIrrefutable
{-# INLINE rule331 #-}
rule331 = \ ((_lhsIcon) :: Identifier) ->
_lhsIcon
{-# INLINE rule332 #-}
rule332 = \ ((_lhsIinh) :: Attributes) ->
_lhsIinh
{-# INLINE rule333 #-}
rule333 = \ ((_lhsInt) :: Identifier) ->
_lhsInt
{-# INLINE rule334 #-}
rule334 = \ ((_lhsIsyn) :: Attributes) ->
_lhsIsyn
{-# NOINLINE sem_Patterns_Nil #-}
sem_Patterns_Nil :: T_Patterns
sem_Patterns_Nil = T_Patterns (return st23) where
{-# NOINLINE st23 #-}
st23 = let
v22 :: T_Patterns_v22
v22 = \ (T_Patterns_vIn22 _lhsIallTypeSigs _lhsIaltAttrs _lhsIbelowIrrefutable _lhsIcon _lhsIinh _lhsInt _lhsIsyn) -> ( let
_lhsOpps :: [PP_Doc]
_lhsOpps = rule335 ()
_lhsOerrors :: Seq Error
_lhsOerrors = rule336 ()
_lhsOgathAltAttrs :: [AltAttr]
_lhsOgathAltAttrs = rule337 ()
_lhsOinstVars :: [Identifier]
_lhsOinstVars = rule338 ()
_lhsOlocVars :: [Identifier]
_lhsOlocVars = rule339 ()
_lhsOpatternAttrs :: [(Identifier,Identifier,Bool)]
_lhsOpatternAttrs = rule340 ()
_copy = rule341 ()
_lhsOcopy :: Patterns
_lhsOcopy = rule342 _copy
__result_ = T_Patterns_vOut22 _lhsOcopy _lhsOerrors _lhsOgathAltAttrs _lhsOinstVars _lhsOlocVars _lhsOpatternAttrs _lhsOpps
in __result_ )
in C_Patterns_s23 v22
{-# INLINE rule335 #-}
{-# LINE 77 "src-ag/TfmToMirage.ag" #-}
rule335 = \ (_ :: ()) ->
{-# LINE 77 "src-ag/TfmToMirage.ag" #-}
[]
{-# LINE 2551 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule336 #-}
rule336 = \ (_ :: ()) ->
Seq.empty
{-# INLINE rule337 #-}
rule337 = \ (_ :: ()) ->
[]
{-# INLINE rule338 #-}
rule338 = \ (_ :: ()) ->
[]
{-# INLINE rule339 #-}
rule339 = \ (_ :: ()) ->
[]
{-# INLINE rule340 #-}
rule340 = \ (_ :: ()) ->
[]
{-# INLINE rule341 #-}
rule341 = \ (_ :: ()) ->
[]
{-# INLINE rule342 #-}
rule342 = \ _copy ->
_copy
-- Production --------------------------------------------------
-- wrapper
data Inh_Production = Inh_Production { allnts_Inh_Production :: ([Identifier]), aroundMap_Inh_Production :: (Map ConstructorIdent (Map Identifier [Expression])), cVisitsMap_Inh_Production :: (CVisitsMap), inh_Inh_Production :: (Attributes), inhMap_Inh_Production :: (Map Identifier Attributes), manualAttrDepMap_Inh_Production :: (AttrOrderMap), mergeMap_Inh_Production :: (Map ConstructorIdent (Map Identifier (Identifier,[Identifier]))), nt_Inh_Production :: (Identifier), o_case_Inh_Production :: (Bool), o_cata_Inh_Production :: (Bool), o_dovisit_Inh_Production :: (Bool), o_newtypes_Inh_Production :: (Bool), o_rename_Inh_Production :: (Bool), o_sem_Inh_Production :: (Bool), o_sig_Inh_Production :: (Bool), o_unbox_Inh_Production :: (Bool), o_wantvisit_Inh_Production :: (Bool), options_Inh_Production :: (Options), prefix_Inh_Production :: (String), syn_Inh_Production :: (Attributes), synMap_Inh_Production :: (Map Identifier Attributes), vcount_Inh_Production :: (Int) }
data Syn_Production = Syn_Production { additionalDep_Syn_Production :: (Seq Edge), aroundDep_Syn_Production :: (Seq Edge), cProduction_Syn_Production :: (CProduction), cons_Syn_Production :: ([ConstructorIdent]), directDep_Syn_Production :: (Seq Edge), errors_Syn_Production :: (Seq Error), instDep_Syn_Production :: (Seq Edge), mergeDep_Syn_Production :: (Seq Edge), mirage_Syn_Production :: (Mirage.Production), nAutoRules_Syn_Production :: (Int), nExplicitRules_Syn_Production :: (Int), rules_Syn_Production :: (Seq (Vertex,CRule)), vcount_Syn_Production :: (Int) }
{-# INLINABLE wrap_Production #-}
wrap_Production :: T_Production -> Inh_Production -> (Syn_Production )
wrap_Production (T_Production act) (Inh_Production _lhsIallnts _lhsIaroundMap _lhsIcVisitsMap _lhsIinh _lhsIinhMap _lhsImanualAttrDepMap _lhsImergeMap _lhsInt _lhsIo_case _lhsIo_cata _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_unbox _lhsIo_wantvisit _lhsIoptions _lhsIprefix _lhsIsyn _lhsIsynMap _lhsIvcount) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg25 = T_Production_vIn25 _lhsIallnts _lhsIaroundMap _lhsIcVisitsMap _lhsIinh _lhsIinhMap _lhsImanualAttrDepMap _lhsImergeMap _lhsInt _lhsIo_case _lhsIo_cata _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_unbox _lhsIo_wantvisit _lhsIoptions _lhsIprefix _lhsIsyn _lhsIsynMap _lhsIvcount
(T_Production_vOut25 _lhsOadditionalDep _lhsOaroundDep _lhsOcProduction _lhsOcons _lhsOdirectDep _lhsOerrors _lhsOinstDep _lhsOmergeDep _lhsOmirage _lhsOnAutoRules _lhsOnExplicitRules _lhsOrules _lhsOvcount) <- return (inv_Production_s26 sem arg25)
return (Syn_Production _lhsOadditionalDep _lhsOaroundDep _lhsOcProduction _lhsOcons _lhsOdirectDep _lhsOerrors _lhsOinstDep _lhsOmergeDep _lhsOmirage _lhsOnAutoRules _lhsOnExplicitRules _lhsOrules _lhsOvcount)
)
-- cata
{-# INLINE sem_Production #-}
sem_Production :: Production -> T_Production
sem_Production ( Production con_ params_ constraints_ children_ rules_ typeSigs_ macro_ ) = sem_Production_Production con_ params_ constraints_ ( sem_Children children_ ) ( sem_Rules rules_ ) ( sem_TypeSigs typeSigs_ ) macro_
-- semantic domain
newtype T_Production = T_Production {
attach_T_Production :: Identity (T_Production_s26 )
}
newtype T_Production_s26 = C_Production_s26 {
inv_Production_s26 :: (T_Production_v25 )
}
data T_Production_s27 = C_Production_s27
type T_Production_v25 = (T_Production_vIn25 ) -> (T_Production_vOut25 )
data T_Production_vIn25 = T_Production_vIn25 ([Identifier]) (Map ConstructorIdent (Map Identifier [Expression])) (CVisitsMap) (Attributes) (Map Identifier Attributes) (AttrOrderMap) (Map ConstructorIdent (Map Identifier (Identifier,[Identifier]))) (Identifier) (Bool) (Bool) (Bool) (Bool) (Bool) (Bool) (Bool) (Bool) (Bool) (Options) (String) (Attributes) (Map Identifier Attributes) (Int)
data T_Production_vOut25 = T_Production_vOut25 (Seq Edge) (Seq Edge) (CProduction) ([ConstructorIdent]) (Seq Edge) (Seq Error) (Seq Edge) (Seq Edge) (Mirage.Production) (Int) (Int) (Seq (Vertex,CRule)) (Int)
{-# NOINLINE sem_Production_Production #-}
sem_Production_Production :: (ConstructorIdent) -> ([Identifier]) -> ([Type]) -> T_Children -> T_Rules -> T_TypeSigs -> (MaybeMacro) -> T_Production
sem_Production_Production arg_con_ _ _ arg_children_ arg_rules_ arg_typeSigs_ _ = T_Production (return st26) where
{-# NOINLINE st26 #-}
st26 = let
v25 :: T_Production_v25
v25 = \ (T_Production_vIn25 _lhsIallnts _lhsIaroundMap _lhsIcVisitsMap _lhsIinh _lhsIinhMap _lhsImanualAttrDepMap _lhsImergeMap _lhsInt _lhsIo_case _lhsIo_cata _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_unbox _lhsIo_wantvisit _lhsIoptions _lhsIprefix _lhsIsyn _lhsIsynMap _lhsIvcount) -> ( let
_childrenX5 = Control.Monad.Identity.runIdentity (attach_T_Children (arg_children_))
_rulesX35 = Control.Monad.Identity.runIdentity (attach_T_Rules (arg_rules_))
_typeSigsX41 = Control.Monad.Identity.runIdentity (attach_T_TypeSigs (arg_typeSigs_))
(T_Children_vOut4 _childrenIattributes _childrenIcollectChildrenInhs _childrenIcollectChildrenSyns _childrenIerrors _childrenIfields _childrenIgathAltAttrs _childrenIgathRules _childrenIinhs _childrenImirages _childrenInts _childrenIsinglevisits _childrenIterminals) = inv_Children_s5 _childrenX5 (T_Children_vIn4 _childrenOallfields _childrenOallnts _childrenOattrs _childrenOcon _childrenOinh _childrenOinhMap _childrenOmergeMap _childrenOnt _childrenOo_unbox _childrenOsyn _childrenOsynMap)
(T_Rules_vOut34 _rulesIdirectDep _rulesIerrors _rulesIgathAltAttrs _rulesIgathRules _rulesIinstDep _rulesIinstVars _rulesIlocVars _rulesImirages _rulesInAutoRules _rulesInExplicitRules) = inv_Rules_s35 _rulesX35 (T_Rules_vIn34 _rulesOallTypeSigs _rulesOallfields _rulesOallnts _rulesOaltAttrs _rulesOattrs _rulesOchildInhs _rulesOchildNts _rulesOcon _rulesOinh _rulesOinhsOfChildren _rulesOmergeMap _rulesOnt _rulesOo_case _rulesOo_cata _rulesOo_dovisit _rulesOo_newtypes _rulesOo_rename _rulesOo_sem _rulesOo_sig _rulesOo_wantvisit _rulesOoptions _rulesOprefix _rulesOsyn _rulesOsynsOfChildren)
(T_TypeSigs_vOut40 _typeSigsItypeSigs) = inv_TypeSigs_s41 _typeSigsX41 (T_TypeSigs_vIn40 _typeSigsOtypeSigs)
_childrenOcon = rule343 arg_con_
_rulesOcon = rule344 arg_con_
_gathAltAttrs = rule345 _childrenIgathAltAttrs _lhsIinh _rulesIgathAltAttrs
_altAttrs = rule346 _gathAltAttrs _lhsIvcount
_rulesOchildNts = rule347 _childrenInts
_rulesOchildInhs = rule348 _childrenIinhs
_inhRules = rule349 _lhsIinh _lhsInt arg_con_
_gathRules = rule350 _childrenIgathRules _inhRules _rulesIgathRules
_lhsOrules :: Seq (Vertex,CRule)
_lhsOrules = rule351 _gathRules _lhsIvcount
_lhsOvcount :: Int
_lhsOvcount = rule352 _gathRules _lhsIvcount
_manualDeps = rule353 _lhsImanualAttrDepMap _lhsInt arg_con_
_lhsOadditionalDep :: Seq Edge
_lhsOadditionalDep = rule354 _altAttrs _manualDeps
_rulesOsynsOfChildren = rule355 _childrenIcollectChildrenSyns
_rulesOinhsOfChildren = rule356 _childrenIcollectChildrenInhs
_mergeMap = rule357 _lhsImergeMap arg_con_
_lhsOmergeDep :: Seq Edge
_lhsOmergeDep = rule358 _mergeDep1 _mergeDep2
_mergeDep1 = rule359 _altAttrs _childrenIcollectChildrenSyns _mergeMap
_mergeDep2 = rule360 _altAttrs _childrenIcollectChildrenSyns _mergeMap
_aroundMap = rule361 _lhsIaroundMap arg_con_
_aroundDep1 = rule362 _altAttrs _aroundMap _childrenIcollectChildrenSyns
_aroundDep2 = rule363 _altAttrs _aroundMap _childrenIcollectChildrenInhs
_lhsOaroundDep :: Seq Edge
_lhsOaroundDep = rule364 _aroundDep1 _aroundDep2
_lhsOcons :: [ConstructorIdent]
_lhsOcons = rule365 arg_con_
_typeSigsOtypeSigs = rule366 ()
_rulesOallTypeSigs = rule367 _typeSigsItypeSigs
_cVisits = rule368 _childrenIsinglevisits _gathRules _lhsIcVisitsMap _lhsIinh _lhsInt _lhsIo_dovisit _lhsIsyn arg_con_
_lhsOcProduction :: CProduction
_lhsOcProduction = rule369 _cVisits _childrenIfields _childrenIterminals arg_con_
_allfields = rule370 _childrenIfields
_attrs = rule371 _childrenIattributes _inhnames _rulesIinstVars _rulesIlocVars
_inhnames = rule372 _lhsIinh
_synnames = rule373 _lhsIsyn
_lhsOmirage :: Mirage.Production
_lhsOmirage = rule374 _childrenImirages _rulesImirages arg_con_
_lhsOdirectDep :: Seq Edge
_lhsOdirectDep = rule375 _rulesIdirectDep
_lhsOerrors :: Seq Error
_lhsOerrors = rule376 _childrenIerrors _rulesIerrors
_lhsOinstDep :: Seq Edge
_lhsOinstDep = rule377 _rulesIinstDep
_lhsOnAutoRules :: Int
_lhsOnAutoRules = rule378 _rulesInAutoRules
_lhsOnExplicitRules :: Int
_lhsOnExplicitRules = rule379 _rulesInExplicitRules
_childrenOallfields = rule380 _allfields
_childrenOallnts = rule381 _lhsIallnts
_childrenOattrs = rule382 _attrs
_childrenOinh = rule383 _lhsIinh
_childrenOinhMap = rule384 _lhsIinhMap
_childrenOmergeMap = rule385 _mergeMap
_childrenOnt = rule386 _lhsInt
_childrenOo_unbox = rule387 _lhsIo_unbox
_childrenOsyn = rule388 _lhsIsyn
_childrenOsynMap = rule389 _lhsIsynMap
_rulesOallfields = rule390 _allfields
_rulesOallnts = rule391 _lhsIallnts
_rulesOaltAttrs = rule392 _altAttrs
_rulesOattrs = rule393 _attrs
_rulesOinh = rule394 _lhsIinh
_rulesOmergeMap = rule395 _mergeMap
_rulesOnt = rule396 _lhsInt
_rulesOo_case = rule397 _lhsIo_case
_rulesOo_cata = rule398 _lhsIo_cata
_rulesOo_dovisit = rule399 _lhsIo_dovisit
_rulesOo_newtypes = rule400 _lhsIo_newtypes
_rulesOo_rename = rule401 _lhsIo_rename
_rulesOo_sem = rule402 _lhsIo_sem
_rulesOo_sig = rule403 _lhsIo_sig
_rulesOo_wantvisit = rule404 _lhsIo_wantvisit
_rulesOoptions = rule405 _lhsIoptions
_rulesOprefix = rule406 _lhsIprefix
_rulesOsyn = rule407 _lhsIsyn
__result_ = T_Production_vOut25 _lhsOadditionalDep _lhsOaroundDep _lhsOcProduction _lhsOcons _lhsOdirectDep _lhsOerrors _lhsOinstDep _lhsOmergeDep _lhsOmirage _lhsOnAutoRules _lhsOnExplicitRules _lhsOrules _lhsOvcount
in __result_ )
in C_Production_s26 v25
{-# INLINE rule343 #-}
{-# LINE 93 "src-ag/Order.ag" #-}
rule343 = \ con_ ->
{-# LINE 93 "src-ag/Order.ag" #-}
con_
{-# LINE 2703 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule344 #-}
{-# LINE 95 "src-ag/Order.ag" #-}
rule344 = \ con_ ->
{-# LINE 95 "src-ag/Order.ag" #-}
con_
{-# LINE 2709 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule345 #-}
{-# LINE 175 "src-ag/Order.ag" #-}
rule345 = \ ((_childrenIgathAltAttrs) :: [AltAttr]) ((_lhsIinh) :: Attributes) ((_rulesIgathAltAttrs) :: [AltAttr]) ->
{-# LINE 175 "src-ag/Order.ag" #-}
[ AltAttr _LHS inh True | inh <- Map.keys _lhsIinh ]
++ _childrenIgathAltAttrs
++ _rulesIgathAltAttrs
{-# LINE 2717 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule346 #-}
{-# LINE 191 "src-ag/Order.ag" #-}
rule346 = \ _gathAltAttrs ((_lhsIvcount) :: Int) ->
{-# LINE 191 "src-ag/Order.ag" #-}
Map.fromList (zip _gathAltAttrs [_lhsIvcount..])
{-# LINE 2723 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule347 #-}
{-# LINE 204 "src-ag/Order.ag" #-}
rule347 = \ ((_childrenInts) :: Seq (Identifier,NontermIdent)) ->
{-# LINE 204 "src-ag/Order.ag" #-}
Map.fromList (toList _childrenInts)
{-# LINE 2729 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule348 #-}
{-# LINE 205 "src-ag/Order.ag" #-}
rule348 = \ ((_childrenIinhs) :: Seq (Identifier,Attributes)) ->
{-# LINE 205 "src-ag/Order.ag" #-}
Map.fromList (toList _childrenIinhs)
{-# LINE 2735 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule349 #-}
{-# LINE 211 "src-ag/Order.ag" #-}
rule349 = \ ((_lhsIinh) :: Attributes) ((_lhsInt) :: Identifier) con_ ->
{-# LINE 211 "src-ag/Order.ag" #-}
[ cRuleLhsInh inh _lhsInt con_ tp | (inh,tp) <- Map.assocs _lhsIinh ]
{-# LINE 2741 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule350 #-}
{-# LINE 212 "src-ag/Order.ag" #-}
rule350 = \ ((_childrenIgathRules) :: Seq CRule) _inhRules ((_rulesIgathRules) :: Seq CRule) ->
{-# LINE 212 "src-ag/Order.ag" #-}
_inhRules ++ toList (_childrenIgathRules Seq.>< _rulesIgathRules)
{-# LINE 2747 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule351 #-}
{-# LINE 264 "src-ag/Order.ag" #-}
rule351 = \ _gathRules ((_lhsIvcount) :: Int) ->
{-# LINE 264 "src-ag/Order.ag" #-}
Seq.fromList (zip [_lhsIvcount..] _gathRules)
{-# LINE 2753 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule352 #-}
{-# LINE 265 "src-ag/Order.ag" #-}
rule352 = \ _gathRules ((_lhsIvcount) :: Int) ->
{-# LINE 265 "src-ag/Order.ag" #-}
_lhsIvcount + length _gathRules
{-# LINE 2759 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule353 #-}
{-# LINE 293 "src-ag/Order.ag" #-}
rule353 = \ ((_lhsImanualAttrDepMap) :: AttrOrderMap) ((_lhsInt) :: Identifier) con_ ->
{-# LINE 293 "src-ag/Order.ag" #-}
Set.toList $ Map.findWithDefault Set.empty con_ $ Map.findWithDefault Map.empty _lhsInt _lhsImanualAttrDepMap
{-# LINE 2765 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule354 #-}
{-# LINE 296 "src-ag/Order.ag" #-}
rule354 = \ _altAttrs _manualDeps ->
{-# LINE 296 "src-ag/Order.ag" #-}
Seq.fromList [ (vertex True occA, vertex False occB)
| Dependency occA occB <- _manualDeps
, let vertex inout (OccAttr child nm)
| child == _LOC = findWithErr2 (AltAttr _LOC nm True) _altAttrs
| otherwise = findWithErr2 (AltAttr child nm inout) _altAttrs
vertex _ (OccRule nm)
= findWithErr2 (AltAttr _LOC (Ident ("_rule_" ++ show nm) (getPos nm)) True) _altAttrs
]
{-# LINE 2778 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule355 #-}
{-# LINE 342 "src-ag/Order.ag" #-}
rule355 = \ ((_childrenIcollectChildrenSyns) :: Map Identifier Attributes ) ->
{-# LINE 342 "src-ag/Order.ag" #-}
_childrenIcollectChildrenSyns
{-# LINE 2784 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule356 #-}
{-# LINE 343 "src-ag/Order.ag" #-}
rule356 = \ ((_childrenIcollectChildrenInhs) :: Map Identifier Attributes ) ->
{-# LINE 343 "src-ag/Order.ag" #-}
_childrenIcollectChildrenInhs
{-# LINE 2790 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule357 #-}
{-# LINE 361 "src-ag/Order.ag" #-}
rule357 = \ ((_lhsImergeMap) :: Map ConstructorIdent (Map Identifier (Identifier,[Identifier]))) con_ ->
{-# LINE 361 "src-ag/Order.ag" #-}
Map.findWithDefault Map.empty con_ _lhsImergeMap
{-# LINE 2796 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule358 #-}
{-# LINE 372 "src-ag/Order.ag" #-}
rule358 = \ _mergeDep1 _mergeDep2 ->
{-# LINE 372 "src-ag/Order.ag" #-}
_mergeDep1 Seq.>< _mergeDep2
{-# LINE 2802 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule359 #-}
{-# LINE 374 "src-ag/Order.ag" #-}
rule359 = \ _altAttrs ((_childrenIcollectChildrenSyns) :: Map Identifier Attributes ) _mergeMap ->
{-# LINE 374 "src-ag/Order.ag" #-}
Seq.fromList $
[ (childVert, synVert)
| childNm <- Map.keys _mergeMap
, synNm <- Map.keys (findWithErr2 childNm _childrenIcollectChildrenSyns)
, let childNm' = Ident (show childNm ++ "_merge") (getPos childNm)
childAttr = AltAttr _LOC childNm' True
synAttr = AltAttr childNm synNm True
childVert = findWithErr2 childAttr _altAttrs
synVert = findWithErr2 synAttr _altAttrs
]
{-# LINE 2817 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule360 #-}
{-# LINE 385 "src-ag/Order.ag" #-}
rule360 = \ _altAttrs ((_childrenIcollectChildrenSyns) :: Map Identifier Attributes ) _mergeMap ->
{-# LINE 385 "src-ag/Order.ag" #-}
Seq.fromList $
[ (mergedVert, sourceVert)
| (childNm, (_,cs)) <- Map.assocs _mergeMap
, c <- cs
, synNm <- Map.keys (findWithErr2 childNm _childrenIcollectChildrenSyns)
, let sourceAttr = AltAttr childNm synNm True
mergedAttr = AltAttr c synNm True
sourceVert = findWithErr2 sourceAttr _altAttrs
mergedVert = findWithErr2 mergedAttr _altAttrs
]
{-# LINE 2832 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule361 #-}
{-# LINE 414 "src-ag/Order.ag" #-}
rule361 = \ ((_lhsIaroundMap) :: Map ConstructorIdent (Map Identifier [Expression])) con_ ->
{-# LINE 414 "src-ag/Order.ag" #-}
Map.findWithDefault Map.empty con_ _lhsIaroundMap
{-# LINE 2838 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule362 #-}
{-# LINE 422 "src-ag/Order.ag" #-}
rule362 = \ _altAttrs _aroundMap ((_childrenIcollectChildrenSyns) :: Map Identifier Attributes ) ->
{-# LINE 422 "src-ag/Order.ag" #-}
Seq.fromList $
[ (childVert, synVert)
| childNm <- Map.keys _aroundMap
, synNm <- Map.keys (findWithErr2 childNm _childrenIcollectChildrenSyns)
, let childNm' = Ident (show childNm ++ "_around") (getPos childNm)
childAttr = AltAttr _LOC childNm' True
synAttr = AltAttr childNm synNm True
childVert = findWithErr2 childAttr _altAttrs
synVert = findWithErr2 synAttr _altAttrs
]
{-# LINE 2853 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule363 #-}
{-# LINE 433 "src-ag/Order.ag" #-}
rule363 = \ _altAttrs _aroundMap ((_childrenIcollectChildrenInhs) :: Map Identifier Attributes ) ->
{-# LINE 433 "src-ag/Order.ag" #-}
Seq.fromList $
[ (childVert, inhVert)
| childNm <- Map.keys _aroundMap
, inhNm <- Map.keys (findWithErr2 childNm _childrenIcollectChildrenInhs)
, let childNm' = Ident (show childNm ++ "_around") (getPos childNm)
childAttr = AltAttr _LOC childNm' True
inhAttr = AltAttr childNm inhNm False
childVert = findWithErr2 childAttr _altAttrs
inhVert = findWithErr2 inhAttr _altAttrs
]
{-# LINE 2868 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule364 #-}
{-# LINE 443 "src-ag/Order.ag" #-}
rule364 = \ _aroundDep1 _aroundDep2 ->
{-# LINE 443 "src-ag/Order.ag" #-}
_aroundDep1 Seq.>< _aroundDep2
{-# LINE 2874 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule365 #-}
{-# LINE 527 "src-ag/Order.ag" #-}
rule365 = \ con_ ->
{-# LINE 527 "src-ag/Order.ag" #-}
[con_]
{-# LINE 2880 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule366 #-}
{-# LINE 534 "src-ag/Order.ag" #-}
rule366 = \ (_ :: ()) ->
{-# LINE 534 "src-ag/Order.ag" #-}
Map.empty
{-# LINE 2886 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule367 #-}
{-# LINE 540 "src-ag/Order.ag" #-}
rule367 = \ ((_typeSigsItypeSigs) :: Map Identifier Type) ->
{-# LINE 540 "src-ag/Order.ag" #-}
_typeSigsItypeSigs
{-# LINE 2892 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule368 #-}
{-# LINE 608 "src-ag/Order.ag" #-}
rule368 = \ ((_childrenIsinglevisits) :: [CRule]) _gathRules ((_lhsIcVisitsMap) :: CVisitsMap) ((_lhsIinh) :: Attributes) ((_lhsInt) :: Identifier) ((_lhsIo_dovisit) :: Bool) ((_lhsIsyn) :: Attributes) con_ ->
{-# LINE 608 "src-ag/Order.ag" #-}
if _lhsIo_dovisit
then let prodsVisitsMap = findWithErr1 "Production.cVisits.nt" _lhsInt _lhsIcVisitsMap
visits = findWithErr1 "Production.cVisits.con" con_ prodsVisitsMap
in visits
else let vss = nubBy eqCRuleDefines _gathRules ++ _childrenIsinglevisits
in [CVisit _lhsIinh _lhsIsyn vss [] False]
{-# LINE 2903 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule369 #-}
{-# LINE 634 "src-ag/Order.ag" #-}
rule369 = \ _cVisits ((_childrenIfields) :: [(Identifier,Type,ChildKind)]) ((_childrenIterminals) :: [Identifier]) con_ ->
{-# LINE 634 "src-ag/Order.ag" #-}
CProduction con_ _cVisits _childrenIfields _childrenIterminals
{-# LINE 2909 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule370 #-}
{-# LINE 662 "src-ag/Order.ag" #-}
rule370 = \ ((_childrenIfields) :: [(Identifier,Type,ChildKind)]) ->
{-# LINE 662 "src-ag/Order.ag" #-}
_childrenIfields
{-# LINE 2915 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule371 #-}
{-# LINE 663 "src-ag/Order.ag" #-}
rule371 = \ ((_childrenIattributes) :: [(Identifier,Attributes,Attributes)]) _inhnames ((_rulesIinstVars) :: [Identifier]) ((_rulesIlocVars) :: [Identifier]) ->
{-# LINE 663 "src-ag/Order.ag" #-}
map ((,) _LOC) _rulesIlocVars ++
map ((,) _INST) _rulesIinstVars ++
map ((,) _LHS) _inhnames ++
concat [map ((,) nm) (Map.keys as) | (nm,_,as) <- _childrenIattributes]
{-# LINE 2924 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule372 #-}
{-# LINE 667 "src-ag/Order.ag" #-}
rule372 = \ ((_lhsIinh) :: Attributes) ->
{-# LINE 667 "src-ag/Order.ag" #-}
Map.keys _lhsIinh
{-# LINE 2930 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule373 #-}
{-# LINE 668 "src-ag/Order.ag" #-}
rule373 = \ ((_lhsIsyn) :: Attributes) ->
{-# LINE 668 "src-ag/Order.ag" #-}
Map.keys _lhsIsyn
{-# LINE 2936 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule374 #-}
{-# LINE 43 "src-ag/TfmToMirage.ag" #-}
rule374 = \ ((_childrenImirages) :: [Mirage.Child]) ((_rulesImirages) :: [Mirage.Rule]) con_ ->
{-# LINE 43 "src-ag/TfmToMirage.ag" #-}
Mirage.Production (getName con_) _childrenImirages _rulesImirages
{-# LINE 2942 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule375 #-}
rule375 = \ ((_rulesIdirectDep) :: Seq Edge) ->
_rulesIdirectDep
{-# INLINE rule376 #-}
rule376 = \ ((_childrenIerrors) :: Seq Error) ((_rulesIerrors) :: Seq Error) ->
_childrenIerrors Seq.>< _rulesIerrors
{-# INLINE rule377 #-}
rule377 = \ ((_rulesIinstDep) :: Seq Edge) ->
_rulesIinstDep
{-# INLINE rule378 #-}
rule378 = \ ((_rulesInAutoRules) :: Int) ->
_rulesInAutoRules
{-# INLINE rule379 #-}
rule379 = \ ((_rulesInExplicitRules) :: Int) ->
_rulesInExplicitRules
{-# INLINE rule380 #-}
rule380 = \ _allfields ->
_allfields
{-# INLINE rule381 #-}
rule381 = \ ((_lhsIallnts) :: [Identifier]) ->
_lhsIallnts
{-# INLINE rule382 #-}
rule382 = \ _attrs ->
_attrs
{-# INLINE rule383 #-}
rule383 = \ ((_lhsIinh) :: Attributes) ->
_lhsIinh
{-# INLINE rule384 #-}
rule384 = \ ((_lhsIinhMap) :: Map Identifier Attributes) ->
_lhsIinhMap
{-# INLINE rule385 #-}
rule385 = \ _mergeMap ->
_mergeMap
{-# INLINE rule386 #-}
rule386 = \ ((_lhsInt) :: Identifier) ->
_lhsInt
{-# INLINE rule387 #-}
rule387 = \ ((_lhsIo_unbox) :: Bool) ->
_lhsIo_unbox
{-# INLINE rule388 #-}
rule388 = \ ((_lhsIsyn) :: Attributes) ->
_lhsIsyn
{-# INLINE rule389 #-}
rule389 = \ ((_lhsIsynMap) :: Map Identifier Attributes) ->
_lhsIsynMap
{-# INLINE rule390 #-}
rule390 = \ _allfields ->
_allfields
{-# INLINE rule391 #-}
rule391 = \ ((_lhsIallnts) :: [Identifier]) ->
_lhsIallnts
{-# INLINE rule392 #-}
rule392 = \ _altAttrs ->
_altAttrs
{-# INLINE rule393 #-}
rule393 = \ _attrs ->
_attrs
{-# INLINE rule394 #-}
rule394 = \ ((_lhsIinh) :: Attributes) ->
_lhsIinh
{-# INLINE rule395 #-}
rule395 = \ _mergeMap ->
_mergeMap
{-# INLINE rule396 #-}
rule396 = \ ((_lhsInt) :: Identifier) ->
_lhsInt
{-# INLINE rule397 #-}
rule397 = \ ((_lhsIo_case) :: Bool) ->
_lhsIo_case
{-# INLINE rule398 #-}
rule398 = \ ((_lhsIo_cata) :: Bool) ->
_lhsIo_cata
{-# INLINE rule399 #-}
rule399 = \ ((_lhsIo_dovisit) :: Bool) ->
_lhsIo_dovisit
{-# INLINE rule400 #-}
rule400 = \ ((_lhsIo_newtypes) :: Bool) ->
_lhsIo_newtypes
{-# INLINE rule401 #-}
rule401 = \ ((_lhsIo_rename) :: Bool) ->
_lhsIo_rename
{-# INLINE rule402 #-}
rule402 = \ ((_lhsIo_sem) :: Bool) ->
_lhsIo_sem
{-# INLINE rule403 #-}
rule403 = \ ((_lhsIo_sig) :: Bool) ->
_lhsIo_sig
{-# INLINE rule404 #-}
rule404 = \ ((_lhsIo_wantvisit) :: Bool) ->
_lhsIo_wantvisit
{-# INLINE rule405 #-}
rule405 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# INLINE rule406 #-}
rule406 = \ ((_lhsIprefix) :: String) ->
_lhsIprefix
{-# INLINE rule407 #-}
rule407 = \ ((_lhsIsyn) :: Attributes) ->
_lhsIsyn
-- Productions -------------------------------------------------
-- wrapper
data Inh_Productions = Inh_Productions { allnts_Inh_Productions :: ([Identifier]), aroundMap_Inh_Productions :: (Map ConstructorIdent (Map Identifier [Expression])), cVisitsMap_Inh_Productions :: (CVisitsMap), inh_Inh_Productions :: (Attributes), inhMap_Inh_Productions :: (Map Identifier Attributes), manualAttrDepMap_Inh_Productions :: (AttrOrderMap), mergeMap_Inh_Productions :: (Map ConstructorIdent (Map Identifier (Identifier,[Identifier]))), nt_Inh_Productions :: (Identifier), o_case_Inh_Productions :: (Bool), o_cata_Inh_Productions :: (Bool), o_dovisit_Inh_Productions :: (Bool), o_newtypes_Inh_Productions :: (Bool), o_rename_Inh_Productions :: (Bool), o_sem_Inh_Productions :: (Bool), o_sig_Inh_Productions :: (Bool), o_unbox_Inh_Productions :: (Bool), o_wantvisit_Inh_Productions :: (Bool), options_Inh_Productions :: (Options), prefix_Inh_Productions :: (String), syn_Inh_Productions :: (Attributes), synMap_Inh_Productions :: (Map Identifier Attributes), vcount_Inh_Productions :: (Int) }
data Syn_Productions = Syn_Productions { additionalDep_Syn_Productions :: (Seq Edge), aroundDep_Syn_Productions :: (Seq Edge), cProductions_Syn_Productions :: (CProductions), cons_Syn_Productions :: ([ConstructorIdent]), directDep_Syn_Productions :: (Seq Edge), errors_Syn_Productions :: (Seq Error), instDep_Syn_Productions :: (Seq Edge), mergeDep_Syn_Productions :: (Seq Edge), mirages_Syn_Productions :: ([Mirage.Production]), nAutoRules_Syn_Productions :: (Int), nExplicitRules_Syn_Productions :: (Int), rules_Syn_Productions :: (Seq (Vertex,CRule)), vcount_Syn_Productions :: (Int) }
{-# INLINABLE wrap_Productions #-}
wrap_Productions :: T_Productions -> Inh_Productions -> (Syn_Productions )
wrap_Productions (T_Productions act) (Inh_Productions _lhsIallnts _lhsIaroundMap _lhsIcVisitsMap _lhsIinh _lhsIinhMap _lhsImanualAttrDepMap _lhsImergeMap _lhsInt _lhsIo_case _lhsIo_cata _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_unbox _lhsIo_wantvisit _lhsIoptions _lhsIprefix _lhsIsyn _lhsIsynMap _lhsIvcount) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg28 = T_Productions_vIn28 _lhsIallnts _lhsIaroundMap _lhsIcVisitsMap _lhsIinh _lhsIinhMap _lhsImanualAttrDepMap _lhsImergeMap _lhsInt _lhsIo_case _lhsIo_cata _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_unbox _lhsIo_wantvisit _lhsIoptions _lhsIprefix _lhsIsyn _lhsIsynMap _lhsIvcount
(T_Productions_vOut28 _lhsOadditionalDep _lhsOaroundDep _lhsOcProductions _lhsOcons _lhsOdirectDep _lhsOerrors _lhsOinstDep _lhsOmergeDep _lhsOmirages _lhsOnAutoRules _lhsOnExplicitRules _lhsOrules _lhsOvcount) <- return (inv_Productions_s29 sem arg28)
return (Syn_Productions _lhsOadditionalDep _lhsOaroundDep _lhsOcProductions _lhsOcons _lhsOdirectDep _lhsOerrors _lhsOinstDep _lhsOmergeDep _lhsOmirages _lhsOnAutoRules _lhsOnExplicitRules _lhsOrules _lhsOvcount)
)
-- cata
{-# NOINLINE sem_Productions #-}
sem_Productions :: Productions -> T_Productions
sem_Productions list = Prelude.foldr sem_Productions_Cons sem_Productions_Nil (Prelude.map sem_Production list)
-- semantic domain
newtype T_Productions = T_Productions {
attach_T_Productions :: Identity (T_Productions_s29 )
}
newtype T_Productions_s29 = C_Productions_s29 {
inv_Productions_s29 :: (T_Productions_v28 )
}
data T_Productions_s30 = C_Productions_s30
type T_Productions_v28 = (T_Productions_vIn28 ) -> (T_Productions_vOut28 )
data T_Productions_vIn28 = T_Productions_vIn28 ([Identifier]) (Map ConstructorIdent (Map Identifier [Expression])) (CVisitsMap) (Attributes) (Map Identifier Attributes) (AttrOrderMap) (Map ConstructorIdent (Map Identifier (Identifier,[Identifier]))) (Identifier) (Bool) (Bool) (Bool) (Bool) (Bool) (Bool) (Bool) (Bool) (Bool) (Options) (String) (Attributes) (Map Identifier Attributes) (Int)
data T_Productions_vOut28 = T_Productions_vOut28 (Seq Edge) (Seq Edge) (CProductions) ([ConstructorIdent]) (Seq Edge) (Seq Error) (Seq Edge) (Seq Edge) ([Mirage.Production]) (Int) (Int) (Seq (Vertex,CRule)) (Int)
{-# NOINLINE sem_Productions_Cons #-}
sem_Productions_Cons :: T_Production -> T_Productions -> T_Productions
sem_Productions_Cons arg_hd_ arg_tl_ = T_Productions (return st29) where
{-# NOINLINE st29 #-}
st29 = let
v28 :: T_Productions_v28
v28 = \ (T_Productions_vIn28 _lhsIallnts _lhsIaroundMap _lhsIcVisitsMap _lhsIinh _lhsIinhMap _lhsImanualAttrDepMap _lhsImergeMap _lhsInt _lhsIo_case _lhsIo_cata _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_unbox _lhsIo_wantvisit _lhsIoptions _lhsIprefix _lhsIsyn _lhsIsynMap _lhsIvcount) -> ( let
_hdX26 = Control.Monad.Identity.runIdentity (attach_T_Production (arg_hd_))
_tlX29 = Control.Monad.Identity.runIdentity (attach_T_Productions (arg_tl_))
(T_Production_vOut25 _hdIadditionalDep _hdIaroundDep _hdIcProduction _hdIcons _hdIdirectDep _hdIerrors _hdIinstDep _hdImergeDep _hdImirage _hdInAutoRules _hdInExplicitRules _hdIrules _hdIvcount) = inv_Production_s26 _hdX26 (T_Production_vIn25 _hdOallnts _hdOaroundMap _hdOcVisitsMap _hdOinh _hdOinhMap _hdOmanualAttrDepMap _hdOmergeMap _hdOnt _hdOo_case _hdOo_cata _hdOo_dovisit _hdOo_newtypes _hdOo_rename _hdOo_sem _hdOo_sig _hdOo_unbox _hdOo_wantvisit _hdOoptions _hdOprefix _hdOsyn _hdOsynMap _hdOvcount)
(T_Productions_vOut28 _tlIadditionalDep _tlIaroundDep _tlIcProductions _tlIcons _tlIdirectDep _tlIerrors _tlIinstDep _tlImergeDep _tlImirages _tlInAutoRules _tlInExplicitRules _tlIrules _tlIvcount) = inv_Productions_s29 _tlX29 (T_Productions_vIn28 _tlOallnts _tlOaroundMap _tlOcVisitsMap _tlOinh _tlOinhMap _tlOmanualAttrDepMap _tlOmergeMap _tlOnt _tlOo_case _tlOo_cata _tlOo_dovisit _tlOo_newtypes _tlOo_rename _tlOo_sem _tlOo_sig _tlOo_unbox _tlOo_wantvisit _tlOoptions _tlOprefix _tlOsyn _tlOsynMap _tlOvcount)
_lhsOcProductions :: CProductions
_lhsOcProductions = rule408 _hdIcProduction _tlIcProductions
_lhsOmirages :: [Mirage.Production]
_lhsOmirages = rule409 _hdImirage _tlImirages
_lhsOadditionalDep :: Seq Edge
_lhsOadditionalDep = rule410 _hdIadditionalDep _tlIadditionalDep
_lhsOaroundDep :: Seq Edge
_lhsOaroundDep = rule411 _hdIaroundDep _tlIaroundDep
_lhsOcons :: [ConstructorIdent]
_lhsOcons = rule412 _hdIcons _tlIcons
_lhsOdirectDep :: Seq Edge
_lhsOdirectDep = rule413 _hdIdirectDep _tlIdirectDep
_lhsOerrors :: Seq Error
_lhsOerrors = rule414 _hdIerrors _tlIerrors
_lhsOinstDep :: Seq Edge
_lhsOinstDep = rule415 _hdIinstDep _tlIinstDep
_lhsOmergeDep :: Seq Edge
_lhsOmergeDep = rule416 _hdImergeDep _tlImergeDep
_lhsOnAutoRules :: Int
_lhsOnAutoRules = rule417 _hdInAutoRules _tlInAutoRules
_lhsOnExplicitRules :: Int
_lhsOnExplicitRules = rule418 _hdInExplicitRules _tlInExplicitRules
_lhsOrules :: Seq (Vertex,CRule)
_lhsOrules = rule419 _hdIrules _tlIrules
_lhsOvcount :: Int
_lhsOvcount = rule420 _tlIvcount
_hdOallnts = rule421 _lhsIallnts
_hdOaroundMap = rule422 _lhsIaroundMap
_hdOcVisitsMap = rule423 _lhsIcVisitsMap
_hdOinh = rule424 _lhsIinh
_hdOinhMap = rule425 _lhsIinhMap
_hdOmanualAttrDepMap = rule426 _lhsImanualAttrDepMap
_hdOmergeMap = rule427 _lhsImergeMap
_hdOnt = rule428 _lhsInt
_hdOo_case = rule429 _lhsIo_case
_hdOo_cata = rule430 _lhsIo_cata
_hdOo_dovisit = rule431 _lhsIo_dovisit
_hdOo_newtypes = rule432 _lhsIo_newtypes
_hdOo_rename = rule433 _lhsIo_rename
_hdOo_sem = rule434 _lhsIo_sem
_hdOo_sig = rule435 _lhsIo_sig
_hdOo_unbox = rule436 _lhsIo_unbox
_hdOo_wantvisit = rule437 _lhsIo_wantvisit
_hdOoptions = rule438 _lhsIoptions
_hdOprefix = rule439 _lhsIprefix
_hdOsyn = rule440 _lhsIsyn
_hdOsynMap = rule441 _lhsIsynMap
_hdOvcount = rule442 _lhsIvcount
_tlOallnts = rule443 _lhsIallnts
_tlOaroundMap = rule444 _lhsIaroundMap
_tlOcVisitsMap = rule445 _lhsIcVisitsMap
_tlOinh = rule446 _lhsIinh
_tlOinhMap = rule447 _lhsIinhMap
_tlOmanualAttrDepMap = rule448 _lhsImanualAttrDepMap
_tlOmergeMap = rule449 _lhsImergeMap
_tlOnt = rule450 _lhsInt
_tlOo_case = rule451 _lhsIo_case
_tlOo_cata = rule452 _lhsIo_cata
_tlOo_dovisit = rule453 _lhsIo_dovisit
_tlOo_newtypes = rule454 _lhsIo_newtypes
_tlOo_rename = rule455 _lhsIo_rename
_tlOo_sem = rule456 _lhsIo_sem
_tlOo_sig = rule457 _lhsIo_sig
_tlOo_unbox = rule458 _lhsIo_unbox
_tlOo_wantvisit = rule459 _lhsIo_wantvisit
_tlOoptions = rule460 _lhsIoptions
_tlOprefix = rule461 _lhsIprefix
_tlOsyn = rule462 _lhsIsyn
_tlOsynMap = rule463 _lhsIsynMap
_tlOvcount = rule464 _hdIvcount
__result_ = T_Productions_vOut28 _lhsOadditionalDep _lhsOaroundDep _lhsOcProductions _lhsOcons _lhsOdirectDep _lhsOerrors _lhsOinstDep _lhsOmergeDep _lhsOmirages _lhsOnAutoRules _lhsOnExplicitRules _lhsOrules _lhsOvcount
in __result_ )
in C_Productions_s29 v28
{-# INLINE rule408 #-}
{-# LINE 631 "src-ag/Order.ag" #-}
rule408 = \ ((_hdIcProduction) :: CProduction) ((_tlIcProductions) :: CProductions) ->
{-# LINE 631 "src-ag/Order.ag" #-}
_hdIcProduction : _tlIcProductions
{-# LINE 3162 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule409 #-}
{-# LINE 38 "src-ag/TfmToMirage.ag" #-}
rule409 = \ ((_hdImirage) :: Mirage.Production) ((_tlImirages) :: [Mirage.Production]) ->
{-# LINE 38 "src-ag/TfmToMirage.ag" #-}
_hdImirage : _tlImirages
{-# LINE 3168 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule410 #-}
rule410 = \ ((_hdIadditionalDep) :: Seq Edge) ((_tlIadditionalDep) :: Seq Edge) ->
_hdIadditionalDep Seq.>< _tlIadditionalDep
{-# INLINE rule411 #-}
rule411 = \ ((_hdIaroundDep) :: Seq Edge) ((_tlIaroundDep) :: Seq Edge) ->
_hdIaroundDep Seq.>< _tlIaroundDep
{-# INLINE rule412 #-}
rule412 = \ ((_hdIcons) :: [ConstructorIdent]) ((_tlIcons) :: [ConstructorIdent]) ->
_hdIcons ++ _tlIcons
{-# INLINE rule413 #-}
rule413 = \ ((_hdIdirectDep) :: Seq Edge) ((_tlIdirectDep) :: Seq Edge) ->
_hdIdirectDep Seq.>< _tlIdirectDep
{-# INLINE rule414 #-}
rule414 = \ ((_hdIerrors) :: Seq Error) ((_tlIerrors) :: Seq Error) ->
_hdIerrors Seq.>< _tlIerrors
{-# INLINE rule415 #-}
rule415 = \ ((_hdIinstDep) :: Seq Edge) ((_tlIinstDep) :: Seq Edge) ->
_hdIinstDep Seq.>< _tlIinstDep
{-# INLINE rule416 #-}
rule416 = \ ((_hdImergeDep) :: Seq Edge) ((_tlImergeDep) :: Seq Edge) ->
_hdImergeDep Seq.>< _tlImergeDep
{-# INLINE rule417 #-}
rule417 = \ ((_hdInAutoRules) :: Int) ((_tlInAutoRules) :: Int) ->
_hdInAutoRules + _tlInAutoRules
{-# INLINE rule418 #-}
rule418 = \ ((_hdInExplicitRules) :: Int) ((_tlInExplicitRules) :: Int) ->
_hdInExplicitRules + _tlInExplicitRules
{-# INLINE rule419 #-}
rule419 = \ ((_hdIrules) :: Seq (Vertex,CRule)) ((_tlIrules) :: Seq (Vertex,CRule)) ->
_hdIrules Seq.>< _tlIrules
{-# INLINE rule420 #-}
rule420 = \ ((_tlIvcount) :: Int) ->
_tlIvcount
{-# INLINE rule421 #-}
rule421 = \ ((_lhsIallnts) :: [Identifier]) ->
_lhsIallnts
{-# INLINE rule422 #-}
rule422 = \ ((_lhsIaroundMap) :: Map ConstructorIdent (Map Identifier [Expression])) ->
_lhsIaroundMap
{-# INLINE rule423 #-}
rule423 = \ ((_lhsIcVisitsMap) :: CVisitsMap) ->
_lhsIcVisitsMap
{-# INLINE rule424 #-}
rule424 = \ ((_lhsIinh) :: Attributes) ->
_lhsIinh
{-# INLINE rule425 #-}
rule425 = \ ((_lhsIinhMap) :: Map Identifier Attributes) ->
_lhsIinhMap
{-# INLINE rule426 #-}
rule426 = \ ((_lhsImanualAttrDepMap) :: AttrOrderMap) ->
_lhsImanualAttrDepMap
{-# INLINE rule427 #-}
rule427 = \ ((_lhsImergeMap) :: Map ConstructorIdent (Map Identifier (Identifier,[Identifier]))) ->
_lhsImergeMap
{-# INLINE rule428 #-}
rule428 = \ ((_lhsInt) :: Identifier) ->
_lhsInt
{-# INLINE rule429 #-}
rule429 = \ ((_lhsIo_case) :: Bool) ->
_lhsIo_case
{-# INLINE rule430 #-}
rule430 = \ ((_lhsIo_cata) :: Bool) ->
_lhsIo_cata
{-# INLINE rule431 #-}
rule431 = \ ((_lhsIo_dovisit) :: Bool) ->
_lhsIo_dovisit
{-# INLINE rule432 #-}
rule432 = \ ((_lhsIo_newtypes) :: Bool) ->
_lhsIo_newtypes
{-# INLINE rule433 #-}
rule433 = \ ((_lhsIo_rename) :: Bool) ->
_lhsIo_rename
{-# INLINE rule434 #-}
rule434 = \ ((_lhsIo_sem) :: Bool) ->
_lhsIo_sem
{-# INLINE rule435 #-}
rule435 = \ ((_lhsIo_sig) :: Bool) ->
_lhsIo_sig
{-# INLINE rule436 #-}
rule436 = \ ((_lhsIo_unbox) :: Bool) ->
_lhsIo_unbox
{-# INLINE rule437 #-}
rule437 = \ ((_lhsIo_wantvisit) :: Bool) ->
_lhsIo_wantvisit
{-# INLINE rule438 #-}
rule438 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# INLINE rule439 #-}
rule439 = \ ((_lhsIprefix) :: String) ->
_lhsIprefix
{-# INLINE rule440 #-}
rule440 = \ ((_lhsIsyn) :: Attributes) ->
_lhsIsyn
{-# INLINE rule441 #-}
rule441 = \ ((_lhsIsynMap) :: Map Identifier Attributes) ->
_lhsIsynMap
{-# INLINE rule442 #-}
rule442 = \ ((_lhsIvcount) :: Int) ->
_lhsIvcount
{-# INLINE rule443 #-}
rule443 = \ ((_lhsIallnts) :: [Identifier]) ->
_lhsIallnts
{-# INLINE rule444 #-}
rule444 = \ ((_lhsIaroundMap) :: Map ConstructorIdent (Map Identifier [Expression])) ->
_lhsIaroundMap
{-# INLINE rule445 #-}
rule445 = \ ((_lhsIcVisitsMap) :: CVisitsMap) ->
_lhsIcVisitsMap
{-# INLINE rule446 #-}
rule446 = \ ((_lhsIinh) :: Attributes) ->
_lhsIinh
{-# INLINE rule447 #-}
rule447 = \ ((_lhsIinhMap) :: Map Identifier Attributes) ->
_lhsIinhMap
{-# INLINE rule448 #-}
rule448 = \ ((_lhsImanualAttrDepMap) :: AttrOrderMap) ->
_lhsImanualAttrDepMap
{-# INLINE rule449 #-}
rule449 = \ ((_lhsImergeMap) :: Map ConstructorIdent (Map Identifier (Identifier,[Identifier]))) ->
_lhsImergeMap
{-# INLINE rule450 #-}
rule450 = \ ((_lhsInt) :: Identifier) ->
_lhsInt
{-# INLINE rule451 #-}
rule451 = \ ((_lhsIo_case) :: Bool) ->
_lhsIo_case
{-# INLINE rule452 #-}
rule452 = \ ((_lhsIo_cata) :: Bool) ->
_lhsIo_cata
{-# INLINE rule453 #-}
rule453 = \ ((_lhsIo_dovisit) :: Bool) ->
_lhsIo_dovisit
{-# INLINE rule454 #-}
rule454 = \ ((_lhsIo_newtypes) :: Bool) ->
_lhsIo_newtypes
{-# INLINE rule455 #-}
rule455 = \ ((_lhsIo_rename) :: Bool) ->
_lhsIo_rename
{-# INLINE rule456 #-}
rule456 = \ ((_lhsIo_sem) :: Bool) ->
_lhsIo_sem
{-# INLINE rule457 #-}
rule457 = \ ((_lhsIo_sig) :: Bool) ->
_lhsIo_sig
{-# INLINE rule458 #-}
rule458 = \ ((_lhsIo_unbox) :: Bool) ->
_lhsIo_unbox
{-# INLINE rule459 #-}
rule459 = \ ((_lhsIo_wantvisit) :: Bool) ->
_lhsIo_wantvisit
{-# INLINE rule460 #-}
rule460 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# INLINE rule461 #-}
rule461 = \ ((_lhsIprefix) :: String) ->
_lhsIprefix
{-# INLINE rule462 #-}
rule462 = \ ((_lhsIsyn) :: Attributes) ->
_lhsIsyn
{-# INLINE rule463 #-}
rule463 = \ ((_lhsIsynMap) :: Map Identifier Attributes) ->
_lhsIsynMap
{-# INLINE rule464 #-}
rule464 = \ ((_hdIvcount) :: Int) ->
_hdIvcount
{-# NOINLINE sem_Productions_Nil #-}
sem_Productions_Nil :: T_Productions
sem_Productions_Nil = T_Productions (return st29) where
{-# NOINLINE st29 #-}
st29 = let
v28 :: T_Productions_v28
v28 = \ (T_Productions_vIn28 _lhsIallnts _lhsIaroundMap _lhsIcVisitsMap _lhsIinh _lhsIinhMap _lhsImanualAttrDepMap _lhsImergeMap _lhsInt _lhsIo_case _lhsIo_cata _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_unbox _lhsIo_wantvisit _lhsIoptions _lhsIprefix _lhsIsyn _lhsIsynMap _lhsIvcount) -> ( let
_lhsOcProductions :: CProductions
_lhsOcProductions = rule465 ()
_lhsOmirages :: [Mirage.Production]
_lhsOmirages = rule466 ()
_lhsOadditionalDep :: Seq Edge
_lhsOadditionalDep = rule467 ()
_lhsOaroundDep :: Seq Edge
_lhsOaroundDep = rule468 ()
_lhsOcons :: [ConstructorIdent]
_lhsOcons = rule469 ()
_lhsOdirectDep :: Seq Edge
_lhsOdirectDep = rule470 ()
_lhsOerrors :: Seq Error
_lhsOerrors = rule471 ()
_lhsOinstDep :: Seq Edge
_lhsOinstDep = rule472 ()
_lhsOmergeDep :: Seq Edge
_lhsOmergeDep = rule473 ()
_lhsOnAutoRules :: Int
_lhsOnAutoRules = rule474 ()
_lhsOnExplicitRules :: Int
_lhsOnExplicitRules = rule475 ()
_lhsOrules :: Seq (Vertex,CRule)
_lhsOrules = rule476 ()
_lhsOvcount :: Int
_lhsOvcount = rule477 _lhsIvcount
__result_ = T_Productions_vOut28 _lhsOadditionalDep _lhsOaroundDep _lhsOcProductions _lhsOcons _lhsOdirectDep _lhsOerrors _lhsOinstDep _lhsOmergeDep _lhsOmirages _lhsOnAutoRules _lhsOnExplicitRules _lhsOrules _lhsOvcount
in __result_ )
in C_Productions_s29 v28
{-# INLINE rule465 #-}
{-# LINE 632 "src-ag/Order.ag" #-}
rule465 = \ (_ :: ()) ->
{-# LINE 632 "src-ag/Order.ag" #-}
[]
{-# LINE 3375 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule466 #-}
{-# LINE 39 "src-ag/TfmToMirage.ag" #-}
rule466 = \ (_ :: ()) ->
{-# LINE 39 "src-ag/TfmToMirage.ag" #-}
[]
{-# LINE 3381 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule467 #-}
rule467 = \ (_ :: ()) ->
Seq.empty
{-# INLINE rule468 #-}
rule468 = \ (_ :: ()) ->
Seq.empty
{-# INLINE rule469 #-}
rule469 = \ (_ :: ()) ->
[]
{-# INLINE rule470 #-}
rule470 = \ (_ :: ()) ->
Seq.empty
{-# INLINE rule471 #-}
rule471 = \ (_ :: ()) ->
Seq.empty
{-# INLINE rule472 #-}
rule472 = \ (_ :: ()) ->
Seq.empty
{-# INLINE rule473 #-}
rule473 = \ (_ :: ()) ->
Seq.empty
{-# INLINE rule474 #-}
rule474 = \ (_ :: ()) ->
0
{-# INLINE rule475 #-}
rule475 = \ (_ :: ()) ->
0
{-# INLINE rule476 #-}
rule476 = \ (_ :: ()) ->
Seq.empty
{-# INLINE rule477 #-}
rule477 = \ ((_lhsIvcount) :: Int) ->
_lhsIvcount
-- Rule --------------------------------------------------------
-- wrapper
data Inh_Rule = Inh_Rule { allTypeSigs_Inh_Rule :: (Map Identifier Type), allfields_Inh_Rule :: ([(Identifier,Type,ChildKind)]), allnts_Inh_Rule :: ([Identifier]), altAttrs_Inh_Rule :: (Map AltAttr Vertex), attrs_Inh_Rule :: ([(Identifier,Identifier)]), childInhs_Inh_Rule :: (Map Identifier Attributes), childNts_Inh_Rule :: (Map Identifier NontermIdent), con_Inh_Rule :: (Identifier), inh_Inh_Rule :: (Attributes), inhsOfChildren_Inh_Rule :: (Map Identifier Attributes), mergeMap_Inh_Rule :: (Map Identifier (Identifier,[Identifier])), nt_Inh_Rule :: (Identifier), o_case_Inh_Rule :: (Bool), o_cata_Inh_Rule :: (Bool), o_dovisit_Inh_Rule :: (Bool), o_newtypes_Inh_Rule :: (Bool), o_rename_Inh_Rule :: (Bool), o_sem_Inh_Rule :: (Bool), o_sig_Inh_Rule :: (Bool), o_wantvisit_Inh_Rule :: (Bool), options_Inh_Rule :: (Options), prefix_Inh_Rule :: (String), syn_Inh_Rule :: (Attributes), synsOfChildren_Inh_Rule :: (Map Identifier Attributes) }
data Syn_Rule = Syn_Rule { directDep_Syn_Rule :: (Seq Edge), errors_Syn_Rule :: (Seq Error), gathAltAttrs_Syn_Rule :: ([AltAttr]), gathRules_Syn_Rule :: (Seq CRule), instDep_Syn_Rule :: (Seq Edge), instVars_Syn_Rule :: ([Identifier]), locVars_Syn_Rule :: ([Identifier]), mirage_Syn_Rule :: (Mirage.Rule), nAutoRules_Syn_Rule :: (Int), nExplicitRules_Syn_Rule :: (Int) }
{-# INLINABLE wrap_Rule #-}
wrap_Rule :: T_Rule -> Inh_Rule -> (Syn_Rule )
wrap_Rule (T_Rule act) (Inh_Rule _lhsIallTypeSigs _lhsIallfields _lhsIallnts _lhsIaltAttrs _lhsIattrs _lhsIchildInhs _lhsIchildNts _lhsIcon _lhsIinh _lhsIinhsOfChildren _lhsImergeMap _lhsInt _lhsIo_case _lhsIo_cata _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_wantvisit _lhsIoptions _lhsIprefix _lhsIsyn _lhsIsynsOfChildren) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg31 = T_Rule_vIn31 _lhsIallTypeSigs _lhsIallfields _lhsIallnts _lhsIaltAttrs _lhsIattrs _lhsIchildInhs _lhsIchildNts _lhsIcon _lhsIinh _lhsIinhsOfChildren _lhsImergeMap _lhsInt _lhsIo_case _lhsIo_cata _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_wantvisit _lhsIoptions _lhsIprefix _lhsIsyn _lhsIsynsOfChildren
(T_Rule_vOut31 _lhsOdirectDep _lhsOerrors _lhsOgathAltAttrs _lhsOgathRules _lhsOinstDep _lhsOinstVars _lhsOlocVars _lhsOmirage _lhsOnAutoRules _lhsOnExplicitRules) <- return (inv_Rule_s32 sem arg31)
return (Syn_Rule _lhsOdirectDep _lhsOerrors _lhsOgathAltAttrs _lhsOgathRules _lhsOinstDep _lhsOinstVars _lhsOlocVars _lhsOmirage _lhsOnAutoRules _lhsOnExplicitRules)
)
-- cata
{-# INLINE sem_Rule #-}
sem_Rule :: Rule -> T_Rule
sem_Rule ( Rule mbName_ pattern_ rhs_ owrt_ origin_ explicit_ pure_ identity_ mbError_ eager_ ) = sem_Rule_Rule mbName_ ( sem_Pattern pattern_ ) ( sem_Expression rhs_ ) owrt_ origin_ explicit_ pure_ identity_ mbError_ eager_
-- semantic domain
newtype T_Rule = T_Rule {
attach_T_Rule :: Identity (T_Rule_s32 )
}
newtype T_Rule_s32 = C_Rule_s32 {
inv_Rule_s32 :: (T_Rule_v31 )
}
data T_Rule_s33 = C_Rule_s33
type T_Rule_v31 = (T_Rule_vIn31 ) -> (T_Rule_vOut31 )
data T_Rule_vIn31 = T_Rule_vIn31 (Map Identifier Type) ([(Identifier,Type,ChildKind)]) ([Identifier]) (Map AltAttr Vertex) ([(Identifier,Identifier)]) (Map Identifier Attributes) (Map Identifier NontermIdent) (Identifier) (Attributes) (Map Identifier Attributes) (Map Identifier (Identifier,[Identifier])) (Identifier) (Bool) (Bool) (Bool) (Bool) (Bool) (Bool) (Bool) (Bool) (Options) (String) (Attributes) (Map Identifier Attributes)
data T_Rule_vOut31 = T_Rule_vOut31 (Seq Edge) (Seq Error) ([AltAttr]) (Seq CRule) (Seq Edge) ([Identifier]) ([Identifier]) (Mirage.Rule) (Int) (Int)
{-# NOINLINE sem_Rule_Rule #-}
sem_Rule_Rule :: (Maybe Identifier) -> T_Pattern -> T_Expression -> (Bool) -> (String) -> (Bool) -> (Bool) -> (Bool) -> (Maybe Error) -> (Bool) -> T_Rule
sem_Rule_Rule arg_mbName_ arg_pattern_ arg_rhs_ arg_owrt_ arg_origin_ arg_explicit_ _ _ _ _ = T_Rule (return st32) where
{-# NOINLINE st32 #-}
st32 = let
v31 :: T_Rule_v31
v31 = \ (T_Rule_vIn31 _lhsIallTypeSigs _lhsIallfields _lhsIallnts _lhsIaltAttrs _lhsIattrs _lhsIchildInhs _lhsIchildNts _lhsIcon _lhsIinh _lhsIinhsOfChildren _lhsImergeMap _lhsInt _lhsIo_case _lhsIo_cata _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_wantvisit _lhsIoptions _lhsIprefix _lhsIsyn _lhsIsynsOfChildren) -> ( let
_patternX20 = Control.Monad.Identity.runIdentity (attach_T_Pattern (arg_pattern_))
_rhsX8 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_rhs_))
(T_Pattern_vOut19 _patternIcopy _patternIerrors _patternIgathAltAttrs _patternIinstVars _patternIisUnderscore _patternIlocVars _patternIpatternAttrs _patternIpp) = inv_Pattern_s20 _patternX20 (T_Pattern_vIn19 _patternOallTypeSigs _patternOaltAttrs _patternObelowIrrefutable _patternOcon _patternOinh _patternOnt _patternOsyn)
(T_Expression_vOut7 _rhsIallRhsVars _rhsIcopy _rhsIerrors _rhsIlns _rhsItextLines _rhsIusedAttrs _rhsIusedFields _rhsIusedLocals) = inv_Expression_s8 _rhsX8 (T_Expression_vIn7 _rhsOallfields _rhsOallnts _rhsOattrs _rhsOcon _rhsOmergeMap _rhsOnt _rhsOoptions)
_lhsOnExplicitRules :: Int
_lhsOnExplicitRules = rule478 arg_explicit_
_lhsOnAutoRules :: Int
_lhsOnAutoRules = rule479 arg_origin_
_defines = rule480 _lhsIallTypeSigs _lhsIaltAttrs _lhsIchildInhs _lhsIsyn _patternIpatternAttrs
_gathRules = rule481 _defines _lhsIchildNts _lhsIcon _lhsInt _patternIcopy _rhsIallRhsVars _rhsItextLines arg_explicit_ arg_mbName_ arg_origin_ arg_owrt_
_lhsOdirectDep :: Seq Edge
_lhsOdirectDep = rule482 _defines _lhsIaltAttrs _rhsIusedAttrs _rhsIusedFields _rhsIusedLocals
_instDep1 = rule483 _defines _lhsIaltAttrs _lhsIsynsOfChildren
_instDep2 = rule484 _defines _lhsIaltAttrs _lhsIinhsOfChildren
_lhsOinstDep :: Seq Edge
_lhsOinstDep = rule485 _instDep1 _instDep2
_lhsOmirage :: Mirage.Rule
_lhsOmirage = rule486 _patternIpatternAttrs _patternIpp _rhsIlns _rhsIusedAttrs _rhsIusedFields _rhsIusedLocals arg_explicit_ arg_origin_
_patternObelowIrrefutable = rule487 ()
_lhsOerrors :: Seq Error
_lhsOerrors = rule488 _patternIerrors _rhsIerrors
_lhsOgathAltAttrs :: [AltAttr]
_lhsOgathAltAttrs = rule489 _patternIgathAltAttrs
_lhsOgathRules :: Seq CRule
_lhsOgathRules = rule490 _gathRules
_lhsOinstVars :: [Identifier]
_lhsOinstVars = rule491 _patternIinstVars
_lhsOlocVars :: [Identifier]
_lhsOlocVars = rule492 _patternIlocVars
_patternOallTypeSigs = rule493 _lhsIallTypeSigs
_patternOaltAttrs = rule494 _lhsIaltAttrs
_patternOcon = rule495 _lhsIcon
_patternOinh = rule496 _lhsIinh
_patternOnt = rule497 _lhsInt
_patternOsyn = rule498 _lhsIsyn
_rhsOallfields = rule499 _lhsIallfields
_rhsOallnts = rule500 _lhsIallnts
_rhsOattrs = rule501 _lhsIattrs
_rhsOcon = rule502 _lhsIcon
_rhsOmergeMap = rule503 _lhsImergeMap
_rhsOnt = rule504 _lhsInt
_rhsOoptions = rule505 _lhsIoptions
__result_ = T_Rule_vOut31 _lhsOdirectDep _lhsOerrors _lhsOgathAltAttrs _lhsOgathRules _lhsOinstDep _lhsOinstVars _lhsOlocVars _lhsOmirage _lhsOnAutoRules _lhsOnExplicitRules
in __result_ )
in C_Rule_s32 v31
{-# INLINE rule478 #-}
{-# LINE 64 "src-ag/Order.ag" #-}
rule478 = \ explicit_ ->
{-# LINE 64 "src-ag/Order.ag" #-}
if explicit_
then 1
else 0
{-# LINE 3505 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule479 #-}
{-# LINE 67 "src-ag/Order.ag" #-}
rule479 = \ origin_ ->
{-# LINE 67 "src-ag/Order.ag" #-}
if startsWith "use rule" origin_ || startsWith "copy rule" origin_
then 1
else 0
{-# LINE 3513 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule480 #-}
{-# LINE 220 "src-ag/Order.ag" #-}
rule480 = \ ((_lhsIallTypeSigs) :: Map Identifier Type) ((_lhsIaltAttrs) :: Map AltAttr Vertex) ((_lhsIchildInhs) :: Map Identifier Attributes) ((_lhsIsyn) :: Attributes) ((_patternIpatternAttrs) :: [(Identifier,Identifier,Bool)]) ->
{-# LINE 220 "src-ag/Order.ag" #-}
let tp field attr | field == _LOC || field == _INST
= Map.lookup attr _lhsIallTypeSigs
| field == _LHS = Map.lookup attr _lhsIsyn
| otherwise = Map.lookup attr (findWithErr1 "Rule.defines.tp" field _lhsIchildInhs)
typ :: Pattern -> Maybe Type
typ (Alias field attr _) = tp field attr
typ (Underscore _) = Nothing
typ _ = Nothing
in Map.fromList [ (findWithErr1 "Rule.defines" aa _lhsIaltAttrs, (field,attr,(tp field attr)))
| (field,attr,isLocalOrInst) <- _patternIpatternAttrs
, let aa = AltAttr field attr isLocalOrInst
]
{-# LINE 3530 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule481 #-}
{-# LINE 234 "src-ag/Order.ag" #-}
rule481 = \ _defines ((_lhsIchildNts) :: Map Identifier NontermIdent) ((_lhsIcon) :: Identifier) ((_lhsInt) :: Identifier) ((_patternIcopy) :: Pattern) ((_rhsIallRhsVars) :: Set (Identifier,Identifier)) ((_rhsItextLines) :: [String]) explicit_ mbName_ origin_ owrt_ ->
{-# LINE 234 "src-ag/Order.ag" #-}
let childnt field = Map.lookup field _lhsIchildNts
in Seq.fromList [ CRule attr False True _lhsInt _lhsIcon field (childnt field) tp _patternIcopy _rhsItextLines _defines owrt_ origin_ _rhsIallRhsVars explicit_ mbName_
| (field,attr,tp) <- Map.elems _defines
]
{-# LINE 3539 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule482 #-}
{-# LINE 273 "src-ag/Order.ag" #-}
rule482 = \ _defines ((_lhsIaltAttrs) :: Map AltAttr Vertex) ((_rhsIusedAttrs) :: [(Identifier,Identifier)]) ((_rhsIusedFields) :: [Identifier]) ((_rhsIusedLocals) :: [Identifier]) ->
{-# LINE 273 "src-ag/Order.ag" #-}
let defined = Map.keys _defines
used = [ Map.lookup (AltAttr field attr True) _lhsIaltAttrs | (field,attr) <- _rhsIusedAttrs]
++ [ Map.lookup (AltAttr _LOC attr True) _lhsIaltAttrs | attr <- _rhsIusedLocals ++ _rhsIusedFields ]
in Seq.fromList [ (x,y) | Just x <- used, y <- defined ]
{-# LINE 3548 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule483 #-}
{-# LINE 317 "src-ag/Order.ag" #-}
rule483 = \ _defines ((_lhsIaltAttrs) :: Map AltAttr Vertex) ((_lhsIsynsOfChildren) :: Map Identifier Attributes) ->
{-# LINE 317 "src-ag/Order.ag" #-}
Seq.fromList $
[ (instVert, synVert)
| (field,instNm,_) <- Map.elems _defines
, field == _INST
, synNm <- Map.keys (findWithErr2 instNm _lhsIsynsOfChildren)
, let instAttr = AltAttr _INST instNm True
synAttr = AltAttr instNm synNm True
instVert = findWithErr2 instAttr _lhsIaltAttrs
synVert = findWithErr2 synAttr _lhsIaltAttrs
]
{-# LINE 3563 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule484 #-}
{-# LINE 328 "src-ag/Order.ag" #-}
rule484 = \ _defines ((_lhsIaltAttrs) :: Map AltAttr Vertex) ((_lhsIinhsOfChildren) :: Map Identifier Attributes) ->
{-# LINE 328 "src-ag/Order.ag" #-}
Seq.fromList $
[ (instVert, inhVert)
| (field,instNm,_) <- Map.elems _defines
, field == _INST
, inhNm <- Map.keys (findWithErr2 instNm _lhsIinhsOfChildren)
, let instAttr = AltAttr _INST instNm True
inhAttr = AltAttr instNm inhNm False
instVert = findWithErr2 instAttr _lhsIaltAttrs
inhVert = findWithErr2 inhAttr _lhsIaltAttrs
]
{-# LINE 3578 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule485 #-}
{-# LINE 338 "src-ag/Order.ag" #-}
rule485 = \ _instDep1 _instDep2 ->
{-# LINE 338 "src-ag/Order.ag" #-}
_instDep1 Seq.>< _instDep2
{-# LINE 3584 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule486 #-}
{-# LINE 60 "src-ag/TfmToMirage.ag" #-}
rule486 = \ ((_patternIpatternAttrs) :: [(Identifier,Identifier,Bool)]) ((_patternIpp) :: PP_Doc) ((_rhsIlns) :: [String]) ((_rhsIusedAttrs) :: [(Identifier,Identifier)]) ((_rhsIusedFields) :: [Identifier]) ((_rhsIusedLocals) :: [Identifier]) explicit_ origin_ ->
{-# LINE 60 "src-ag/TfmToMirage.ag" #-}
Mirage.Rule
[Mirage.Address (getName field) (getName attr) | (field,attr,_) <- _patternIpatternAttrs]
([Mirage.Address (getName field) (getName attr) | (field,attr) <- _rhsIusedAttrs]
++ [ Mirage.Address (getName _LOC) (getName attr) | attr <- _rhsIusedLocals ++ _rhsIusedFields])
explicit_
origin_
(disp (_patternIpp >-< indent 1 (text "= " >|< vlist _rhsIlns)) 0 "")
{-# LINE 3596 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule487 #-}
{-# LINE 98 "src-ag/TfmToMirage.ag" #-}
rule487 = \ (_ :: ()) ->
{-# LINE 98 "src-ag/TfmToMirage.ag" #-}
False
{-# LINE 3602 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule488 #-}
rule488 = \ ((_patternIerrors) :: Seq Error) ((_rhsIerrors) :: Seq Error) ->
_patternIerrors Seq.>< _rhsIerrors
{-# INLINE rule489 #-}
rule489 = \ ((_patternIgathAltAttrs) :: [AltAttr]) ->
_patternIgathAltAttrs
{-# INLINE rule490 #-}
rule490 = \ _gathRules ->
_gathRules
{-# INLINE rule491 #-}
rule491 = \ ((_patternIinstVars) :: [Identifier]) ->
_patternIinstVars
{-# INLINE rule492 #-}
rule492 = \ ((_patternIlocVars) :: [Identifier]) ->
_patternIlocVars
{-# INLINE rule493 #-}
rule493 = \ ((_lhsIallTypeSigs) :: Map Identifier Type) ->
_lhsIallTypeSigs
{-# INLINE rule494 #-}
rule494 = \ ((_lhsIaltAttrs) :: Map AltAttr Vertex) ->
_lhsIaltAttrs
{-# INLINE rule495 #-}
rule495 = \ ((_lhsIcon) :: Identifier) ->
_lhsIcon
{-# INLINE rule496 #-}
rule496 = \ ((_lhsIinh) :: Attributes) ->
_lhsIinh
{-# INLINE rule497 #-}
rule497 = \ ((_lhsInt) :: Identifier) ->
_lhsInt
{-# INLINE rule498 #-}
rule498 = \ ((_lhsIsyn) :: Attributes) ->
_lhsIsyn
{-# INLINE rule499 #-}
rule499 = \ ((_lhsIallfields) :: [(Identifier,Type,ChildKind)]) ->
_lhsIallfields
{-# INLINE rule500 #-}
rule500 = \ ((_lhsIallnts) :: [Identifier]) ->
_lhsIallnts
{-# INLINE rule501 #-}
rule501 = \ ((_lhsIattrs) :: [(Identifier,Identifier)]) ->
_lhsIattrs
{-# INLINE rule502 #-}
rule502 = \ ((_lhsIcon) :: Identifier) ->
_lhsIcon
{-# INLINE rule503 #-}
rule503 = \ ((_lhsImergeMap) :: Map Identifier (Identifier,[Identifier])) ->
_lhsImergeMap
{-# INLINE rule504 #-}
rule504 = \ ((_lhsInt) :: Identifier) ->
_lhsInt
{-# INLINE rule505 #-}
rule505 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
-- Rules -------------------------------------------------------
-- wrapper
data Inh_Rules = Inh_Rules { allTypeSigs_Inh_Rules :: (Map Identifier Type), allfields_Inh_Rules :: ([(Identifier,Type,ChildKind)]), allnts_Inh_Rules :: ([Identifier]), altAttrs_Inh_Rules :: (Map AltAttr Vertex), attrs_Inh_Rules :: ([(Identifier,Identifier)]), childInhs_Inh_Rules :: (Map Identifier Attributes), childNts_Inh_Rules :: (Map Identifier NontermIdent), con_Inh_Rules :: (Identifier), inh_Inh_Rules :: (Attributes), inhsOfChildren_Inh_Rules :: (Map Identifier Attributes), mergeMap_Inh_Rules :: (Map Identifier (Identifier,[Identifier])), nt_Inh_Rules :: (Identifier), o_case_Inh_Rules :: (Bool), o_cata_Inh_Rules :: (Bool), o_dovisit_Inh_Rules :: (Bool), o_newtypes_Inh_Rules :: (Bool), o_rename_Inh_Rules :: (Bool), o_sem_Inh_Rules :: (Bool), o_sig_Inh_Rules :: (Bool), o_wantvisit_Inh_Rules :: (Bool), options_Inh_Rules :: (Options), prefix_Inh_Rules :: (String), syn_Inh_Rules :: (Attributes), synsOfChildren_Inh_Rules :: (Map Identifier Attributes) }
data Syn_Rules = Syn_Rules { directDep_Syn_Rules :: (Seq Edge), errors_Syn_Rules :: (Seq Error), gathAltAttrs_Syn_Rules :: ([AltAttr]), gathRules_Syn_Rules :: (Seq CRule), instDep_Syn_Rules :: (Seq Edge), instVars_Syn_Rules :: ([Identifier]), locVars_Syn_Rules :: ([Identifier]), mirages_Syn_Rules :: ([Mirage.Rule]), nAutoRules_Syn_Rules :: (Int), nExplicitRules_Syn_Rules :: (Int) }
{-# INLINABLE wrap_Rules #-}
wrap_Rules :: T_Rules -> Inh_Rules -> (Syn_Rules )
wrap_Rules (T_Rules act) (Inh_Rules _lhsIallTypeSigs _lhsIallfields _lhsIallnts _lhsIaltAttrs _lhsIattrs _lhsIchildInhs _lhsIchildNts _lhsIcon _lhsIinh _lhsIinhsOfChildren _lhsImergeMap _lhsInt _lhsIo_case _lhsIo_cata _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_wantvisit _lhsIoptions _lhsIprefix _lhsIsyn _lhsIsynsOfChildren) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg34 = T_Rules_vIn34 _lhsIallTypeSigs _lhsIallfields _lhsIallnts _lhsIaltAttrs _lhsIattrs _lhsIchildInhs _lhsIchildNts _lhsIcon _lhsIinh _lhsIinhsOfChildren _lhsImergeMap _lhsInt _lhsIo_case _lhsIo_cata _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_wantvisit _lhsIoptions _lhsIprefix _lhsIsyn _lhsIsynsOfChildren
(T_Rules_vOut34 _lhsOdirectDep _lhsOerrors _lhsOgathAltAttrs _lhsOgathRules _lhsOinstDep _lhsOinstVars _lhsOlocVars _lhsOmirages _lhsOnAutoRules _lhsOnExplicitRules) <- return (inv_Rules_s35 sem arg34)
return (Syn_Rules _lhsOdirectDep _lhsOerrors _lhsOgathAltAttrs _lhsOgathRules _lhsOinstDep _lhsOinstVars _lhsOlocVars _lhsOmirages _lhsOnAutoRules _lhsOnExplicitRules)
)
-- cata
{-# NOINLINE sem_Rules #-}
sem_Rules :: Rules -> T_Rules
sem_Rules list = Prelude.foldr sem_Rules_Cons sem_Rules_Nil (Prelude.map sem_Rule list)
-- semantic domain
newtype T_Rules = T_Rules {
attach_T_Rules :: Identity (T_Rules_s35 )
}
newtype T_Rules_s35 = C_Rules_s35 {
inv_Rules_s35 :: (T_Rules_v34 )
}
data T_Rules_s36 = C_Rules_s36
type T_Rules_v34 = (T_Rules_vIn34 ) -> (T_Rules_vOut34 )
data T_Rules_vIn34 = T_Rules_vIn34 (Map Identifier Type) ([(Identifier,Type,ChildKind)]) ([Identifier]) (Map AltAttr Vertex) ([(Identifier,Identifier)]) (Map Identifier Attributes) (Map Identifier NontermIdent) (Identifier) (Attributes) (Map Identifier Attributes) (Map Identifier (Identifier,[Identifier])) (Identifier) (Bool) (Bool) (Bool) (Bool) (Bool) (Bool) (Bool) (Bool) (Options) (String) (Attributes) (Map Identifier Attributes)
data T_Rules_vOut34 = T_Rules_vOut34 (Seq Edge) (Seq Error) ([AltAttr]) (Seq CRule) (Seq Edge) ([Identifier]) ([Identifier]) ([Mirage.Rule]) (Int) (Int)
{-# NOINLINE sem_Rules_Cons #-}
sem_Rules_Cons :: T_Rule -> T_Rules -> T_Rules
sem_Rules_Cons arg_hd_ arg_tl_ = T_Rules (return st35) where
{-# NOINLINE st35 #-}
st35 = let
v34 :: T_Rules_v34
v34 = \ (T_Rules_vIn34 _lhsIallTypeSigs _lhsIallfields _lhsIallnts _lhsIaltAttrs _lhsIattrs _lhsIchildInhs _lhsIchildNts _lhsIcon _lhsIinh _lhsIinhsOfChildren _lhsImergeMap _lhsInt _lhsIo_case _lhsIo_cata _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_wantvisit _lhsIoptions _lhsIprefix _lhsIsyn _lhsIsynsOfChildren) -> ( let
_hdX32 = Control.Monad.Identity.runIdentity (attach_T_Rule (arg_hd_))
_tlX35 = Control.Monad.Identity.runIdentity (attach_T_Rules (arg_tl_))
(T_Rule_vOut31 _hdIdirectDep _hdIerrors _hdIgathAltAttrs _hdIgathRules _hdIinstDep _hdIinstVars _hdIlocVars _hdImirage _hdInAutoRules _hdInExplicitRules) = inv_Rule_s32 _hdX32 (T_Rule_vIn31 _hdOallTypeSigs _hdOallfields _hdOallnts _hdOaltAttrs _hdOattrs _hdOchildInhs _hdOchildNts _hdOcon _hdOinh _hdOinhsOfChildren _hdOmergeMap _hdOnt _hdOo_case _hdOo_cata _hdOo_dovisit _hdOo_newtypes _hdOo_rename _hdOo_sem _hdOo_sig _hdOo_wantvisit _hdOoptions _hdOprefix _hdOsyn _hdOsynsOfChildren)
(T_Rules_vOut34 _tlIdirectDep _tlIerrors _tlIgathAltAttrs _tlIgathRules _tlIinstDep _tlIinstVars _tlIlocVars _tlImirages _tlInAutoRules _tlInExplicitRules) = inv_Rules_s35 _tlX35 (T_Rules_vIn34 _tlOallTypeSigs _tlOallfields _tlOallnts _tlOaltAttrs _tlOattrs _tlOchildInhs _tlOchildNts _tlOcon _tlOinh _tlOinhsOfChildren _tlOmergeMap _tlOnt _tlOo_case _tlOo_cata _tlOo_dovisit _tlOo_newtypes _tlOo_rename _tlOo_sem _tlOo_sig _tlOo_wantvisit _tlOoptions _tlOprefix _tlOsyn _tlOsynsOfChildren)
_lhsOmirages :: [Mirage.Rule]
_lhsOmirages = rule506 _hdImirage _tlImirages
_lhsOdirectDep :: Seq Edge
_lhsOdirectDep = rule507 _hdIdirectDep _tlIdirectDep
_lhsOerrors :: Seq Error
_lhsOerrors = rule508 _hdIerrors _tlIerrors
_lhsOgathAltAttrs :: [AltAttr]
_lhsOgathAltAttrs = rule509 _hdIgathAltAttrs _tlIgathAltAttrs
_lhsOgathRules :: Seq CRule
_lhsOgathRules = rule510 _hdIgathRules _tlIgathRules
_lhsOinstDep :: Seq Edge
_lhsOinstDep = rule511 _hdIinstDep _tlIinstDep
_lhsOinstVars :: [Identifier]
_lhsOinstVars = rule512 _hdIinstVars _tlIinstVars
_lhsOlocVars :: [Identifier]
_lhsOlocVars = rule513 _hdIlocVars _tlIlocVars
_lhsOnAutoRules :: Int
_lhsOnAutoRules = rule514 _hdInAutoRules _tlInAutoRules
_lhsOnExplicitRules :: Int
_lhsOnExplicitRules = rule515 _hdInExplicitRules _tlInExplicitRules
_hdOallTypeSigs = rule516 _lhsIallTypeSigs
_hdOallfields = rule517 _lhsIallfields
_hdOallnts = rule518 _lhsIallnts
_hdOaltAttrs = rule519 _lhsIaltAttrs
_hdOattrs = rule520 _lhsIattrs
_hdOchildInhs = rule521 _lhsIchildInhs
_hdOchildNts = rule522 _lhsIchildNts
_hdOcon = rule523 _lhsIcon
_hdOinh = rule524 _lhsIinh
_hdOinhsOfChildren = rule525 _lhsIinhsOfChildren
_hdOmergeMap = rule526 _lhsImergeMap
_hdOnt = rule527 _lhsInt
_hdOo_case = rule528 _lhsIo_case
_hdOo_cata = rule529 _lhsIo_cata
_hdOo_dovisit = rule530 _lhsIo_dovisit
_hdOo_newtypes = rule531 _lhsIo_newtypes
_hdOo_rename = rule532 _lhsIo_rename
_hdOo_sem = rule533 _lhsIo_sem
_hdOo_sig = rule534 _lhsIo_sig
_hdOo_wantvisit = rule535 _lhsIo_wantvisit
_hdOoptions = rule536 _lhsIoptions
_hdOprefix = rule537 _lhsIprefix
_hdOsyn = rule538 _lhsIsyn
_hdOsynsOfChildren = rule539 _lhsIsynsOfChildren
_tlOallTypeSigs = rule540 _lhsIallTypeSigs
_tlOallfields = rule541 _lhsIallfields
_tlOallnts = rule542 _lhsIallnts
_tlOaltAttrs = rule543 _lhsIaltAttrs
_tlOattrs = rule544 _lhsIattrs
_tlOchildInhs = rule545 _lhsIchildInhs
_tlOchildNts = rule546 _lhsIchildNts
_tlOcon = rule547 _lhsIcon
_tlOinh = rule548 _lhsIinh
_tlOinhsOfChildren = rule549 _lhsIinhsOfChildren
_tlOmergeMap = rule550 _lhsImergeMap
_tlOnt = rule551 _lhsInt
_tlOo_case = rule552 _lhsIo_case
_tlOo_cata = rule553 _lhsIo_cata
_tlOo_dovisit = rule554 _lhsIo_dovisit
_tlOo_newtypes = rule555 _lhsIo_newtypes
_tlOo_rename = rule556 _lhsIo_rename
_tlOo_sem = rule557 _lhsIo_sem
_tlOo_sig = rule558 _lhsIo_sig
_tlOo_wantvisit = rule559 _lhsIo_wantvisit
_tlOoptions = rule560 _lhsIoptions
_tlOprefix = rule561 _lhsIprefix
_tlOsyn = rule562 _lhsIsyn
_tlOsynsOfChildren = rule563 _lhsIsynsOfChildren
__result_ = T_Rules_vOut34 _lhsOdirectDep _lhsOerrors _lhsOgathAltAttrs _lhsOgathRules _lhsOinstDep _lhsOinstVars _lhsOlocVars _lhsOmirages _lhsOnAutoRules _lhsOnExplicitRules
in __result_ )
in C_Rules_s35 v34
{-# INLINE rule506 #-}
{-# LINE 53 "src-ag/TfmToMirage.ag" #-}
rule506 = \ ((_hdImirage) :: Mirage.Rule) ((_tlImirages) :: [Mirage.Rule]) ->
{-# LINE 53 "src-ag/TfmToMirage.ag" #-}
_hdImirage : _tlImirages
{-# LINE 3775 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule507 #-}
rule507 = \ ((_hdIdirectDep) :: Seq Edge) ((_tlIdirectDep) :: Seq Edge) ->
_hdIdirectDep Seq.>< _tlIdirectDep
{-# INLINE rule508 #-}
rule508 = \ ((_hdIerrors) :: Seq Error) ((_tlIerrors) :: Seq Error) ->
_hdIerrors Seq.>< _tlIerrors
{-# INLINE rule509 #-}
rule509 = \ ((_hdIgathAltAttrs) :: [AltAttr]) ((_tlIgathAltAttrs) :: [AltAttr]) ->
_hdIgathAltAttrs ++ _tlIgathAltAttrs
{-# INLINE rule510 #-}
rule510 = \ ((_hdIgathRules) :: Seq CRule) ((_tlIgathRules) :: Seq CRule) ->
_hdIgathRules Seq.>< _tlIgathRules
{-# INLINE rule511 #-}
rule511 = \ ((_hdIinstDep) :: Seq Edge) ((_tlIinstDep) :: Seq Edge) ->
_hdIinstDep Seq.>< _tlIinstDep
{-# INLINE rule512 #-}
rule512 = \ ((_hdIinstVars) :: [Identifier]) ((_tlIinstVars) :: [Identifier]) ->
_hdIinstVars ++ _tlIinstVars
{-# INLINE rule513 #-}
rule513 = \ ((_hdIlocVars) :: [Identifier]) ((_tlIlocVars) :: [Identifier]) ->
_hdIlocVars ++ _tlIlocVars
{-# INLINE rule514 #-}
rule514 = \ ((_hdInAutoRules) :: Int) ((_tlInAutoRules) :: Int) ->
_hdInAutoRules + _tlInAutoRules
{-# INLINE rule515 #-}
rule515 = \ ((_hdInExplicitRules) :: Int) ((_tlInExplicitRules) :: Int) ->
_hdInExplicitRules + _tlInExplicitRules
{-# INLINE rule516 #-}
rule516 = \ ((_lhsIallTypeSigs) :: Map Identifier Type) ->
_lhsIallTypeSigs
{-# INLINE rule517 #-}
rule517 = \ ((_lhsIallfields) :: [(Identifier,Type,ChildKind)]) ->
_lhsIallfields
{-# INLINE rule518 #-}
rule518 = \ ((_lhsIallnts) :: [Identifier]) ->
_lhsIallnts
{-# INLINE rule519 #-}
rule519 = \ ((_lhsIaltAttrs) :: Map AltAttr Vertex) ->
_lhsIaltAttrs
{-# INLINE rule520 #-}
rule520 = \ ((_lhsIattrs) :: [(Identifier,Identifier)]) ->
_lhsIattrs
{-# INLINE rule521 #-}
rule521 = \ ((_lhsIchildInhs) :: Map Identifier Attributes) ->
_lhsIchildInhs
{-# INLINE rule522 #-}
rule522 = \ ((_lhsIchildNts) :: Map Identifier NontermIdent) ->
_lhsIchildNts
{-# INLINE rule523 #-}
rule523 = \ ((_lhsIcon) :: Identifier) ->
_lhsIcon
{-# INLINE rule524 #-}
rule524 = \ ((_lhsIinh) :: Attributes) ->
_lhsIinh
{-# INLINE rule525 #-}
rule525 = \ ((_lhsIinhsOfChildren) :: Map Identifier Attributes) ->
_lhsIinhsOfChildren
{-# INLINE rule526 #-}
rule526 = \ ((_lhsImergeMap) :: Map Identifier (Identifier,[Identifier])) ->
_lhsImergeMap
{-# INLINE rule527 #-}
rule527 = \ ((_lhsInt) :: Identifier) ->
_lhsInt
{-# INLINE rule528 #-}
rule528 = \ ((_lhsIo_case) :: Bool) ->
_lhsIo_case
{-# INLINE rule529 #-}
rule529 = \ ((_lhsIo_cata) :: Bool) ->
_lhsIo_cata
{-# INLINE rule530 #-}
rule530 = \ ((_lhsIo_dovisit) :: Bool) ->
_lhsIo_dovisit
{-# INLINE rule531 #-}
rule531 = \ ((_lhsIo_newtypes) :: Bool) ->
_lhsIo_newtypes
{-# INLINE rule532 #-}
rule532 = \ ((_lhsIo_rename) :: Bool) ->
_lhsIo_rename
{-# INLINE rule533 #-}
rule533 = \ ((_lhsIo_sem) :: Bool) ->
_lhsIo_sem
{-# INLINE rule534 #-}
rule534 = \ ((_lhsIo_sig) :: Bool) ->
_lhsIo_sig
{-# INLINE rule535 #-}
rule535 = \ ((_lhsIo_wantvisit) :: Bool) ->
_lhsIo_wantvisit
{-# INLINE rule536 #-}
rule536 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# INLINE rule537 #-}
rule537 = \ ((_lhsIprefix) :: String) ->
_lhsIprefix
{-# INLINE rule538 #-}
rule538 = \ ((_lhsIsyn) :: Attributes) ->
_lhsIsyn
{-# INLINE rule539 #-}
rule539 = \ ((_lhsIsynsOfChildren) :: Map Identifier Attributes) ->
_lhsIsynsOfChildren
{-# INLINE rule540 #-}
rule540 = \ ((_lhsIallTypeSigs) :: Map Identifier Type) ->
_lhsIallTypeSigs
{-# INLINE rule541 #-}
rule541 = \ ((_lhsIallfields) :: [(Identifier,Type,ChildKind)]) ->
_lhsIallfields
{-# INLINE rule542 #-}
rule542 = \ ((_lhsIallnts) :: [Identifier]) ->
_lhsIallnts
{-# INLINE rule543 #-}
rule543 = \ ((_lhsIaltAttrs) :: Map AltAttr Vertex) ->
_lhsIaltAttrs
{-# INLINE rule544 #-}
rule544 = \ ((_lhsIattrs) :: [(Identifier,Identifier)]) ->
_lhsIattrs
{-# INLINE rule545 #-}
rule545 = \ ((_lhsIchildInhs) :: Map Identifier Attributes) ->
_lhsIchildInhs
{-# INLINE rule546 #-}
rule546 = \ ((_lhsIchildNts) :: Map Identifier NontermIdent) ->
_lhsIchildNts
{-# INLINE rule547 #-}
rule547 = \ ((_lhsIcon) :: Identifier) ->
_lhsIcon
{-# INLINE rule548 #-}
rule548 = \ ((_lhsIinh) :: Attributes) ->
_lhsIinh
{-# INLINE rule549 #-}
rule549 = \ ((_lhsIinhsOfChildren) :: Map Identifier Attributes) ->
_lhsIinhsOfChildren
{-# INLINE rule550 #-}
rule550 = \ ((_lhsImergeMap) :: Map Identifier (Identifier,[Identifier])) ->
_lhsImergeMap
{-# INLINE rule551 #-}
rule551 = \ ((_lhsInt) :: Identifier) ->
_lhsInt
{-# INLINE rule552 #-}
rule552 = \ ((_lhsIo_case) :: Bool) ->
_lhsIo_case
{-# INLINE rule553 #-}
rule553 = \ ((_lhsIo_cata) :: Bool) ->
_lhsIo_cata
{-# INLINE rule554 #-}
rule554 = \ ((_lhsIo_dovisit) :: Bool) ->
_lhsIo_dovisit
{-# INLINE rule555 #-}
rule555 = \ ((_lhsIo_newtypes) :: Bool) ->
_lhsIo_newtypes
{-# INLINE rule556 #-}
rule556 = \ ((_lhsIo_rename) :: Bool) ->
_lhsIo_rename
{-# INLINE rule557 #-}
rule557 = \ ((_lhsIo_sem) :: Bool) ->
_lhsIo_sem
{-# INLINE rule558 #-}
rule558 = \ ((_lhsIo_sig) :: Bool) ->
_lhsIo_sig
{-# INLINE rule559 #-}
rule559 = \ ((_lhsIo_wantvisit) :: Bool) ->
_lhsIo_wantvisit
{-# INLINE rule560 #-}
rule560 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# INLINE rule561 #-}
rule561 = \ ((_lhsIprefix) :: String) ->
_lhsIprefix
{-# INLINE rule562 #-}
rule562 = \ ((_lhsIsyn) :: Attributes) ->
_lhsIsyn
{-# INLINE rule563 #-}
rule563 = \ ((_lhsIsynsOfChildren) :: Map Identifier Attributes) ->
_lhsIsynsOfChildren
{-# NOINLINE sem_Rules_Nil #-}
sem_Rules_Nil :: T_Rules
sem_Rules_Nil = T_Rules (return st35) where
{-# NOINLINE st35 #-}
st35 = let
v34 :: T_Rules_v34
v34 = \ (T_Rules_vIn34 _lhsIallTypeSigs _lhsIallfields _lhsIallnts _lhsIaltAttrs _lhsIattrs _lhsIchildInhs _lhsIchildNts _lhsIcon _lhsIinh _lhsIinhsOfChildren _lhsImergeMap _lhsInt _lhsIo_case _lhsIo_cata _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_wantvisit _lhsIoptions _lhsIprefix _lhsIsyn _lhsIsynsOfChildren) -> ( let
_lhsOmirages :: [Mirage.Rule]
_lhsOmirages = rule564 ()
_lhsOdirectDep :: Seq Edge
_lhsOdirectDep = rule565 ()
_lhsOerrors :: Seq Error
_lhsOerrors = rule566 ()
_lhsOgathAltAttrs :: [AltAttr]
_lhsOgathAltAttrs = rule567 ()
_lhsOgathRules :: Seq CRule
_lhsOgathRules = rule568 ()
_lhsOinstDep :: Seq Edge
_lhsOinstDep = rule569 ()
_lhsOinstVars :: [Identifier]
_lhsOinstVars = rule570 ()
_lhsOlocVars :: [Identifier]
_lhsOlocVars = rule571 ()
_lhsOnAutoRules :: Int
_lhsOnAutoRules = rule572 ()
_lhsOnExplicitRules :: Int
_lhsOnExplicitRules = rule573 ()
__result_ = T_Rules_vOut34 _lhsOdirectDep _lhsOerrors _lhsOgathAltAttrs _lhsOgathRules _lhsOinstDep _lhsOinstVars _lhsOlocVars _lhsOmirages _lhsOnAutoRules _lhsOnExplicitRules
in __result_ )
in C_Rules_s35 v34
{-# INLINE rule564 #-}
{-# LINE 54 "src-ag/TfmToMirage.ag" #-}
rule564 = \ (_ :: ()) ->
{-# LINE 54 "src-ag/TfmToMirage.ag" #-}
[]
{-# LINE 3982 "src-generated/TfmToMirage.hs" #-}
{-# INLINE rule565 #-}
rule565 = \ (_ :: ()) ->
Seq.empty
{-# INLINE rule566 #-}
rule566 = \ (_ :: ()) ->
Seq.empty
{-# INLINE rule567 #-}
rule567 = \ (_ :: ()) ->
[]
{-# INLINE rule568 #-}
rule568 = \ (_ :: ()) ->
Seq.empty
{-# INLINE rule569 #-}
rule569 = \ (_ :: ()) ->
Seq.empty
{-# INLINE rule570 #-}
rule570 = \ (_ :: ()) ->
[]
{-# INLINE rule571 #-}
rule571 = \ (_ :: ()) ->
[]
{-# INLINE rule572 #-}
rule572 = \ (_ :: ()) ->
0
{-# INLINE rule573 #-}
rule573 = \ (_ :: ()) ->
0
-- TypeSig -----------------------------------------------------
-- wrapper
data Inh_TypeSig = Inh_TypeSig { typeSigs_Inh_TypeSig :: (Map Identifier Type) }
data Syn_TypeSig = Syn_TypeSig { typeSigs_Syn_TypeSig :: (Map Identifier Type) }
{-# INLINABLE wrap_TypeSig #-}
wrap_TypeSig :: T_TypeSig -> Inh_TypeSig -> (Syn_TypeSig )
wrap_TypeSig (T_TypeSig act) (Inh_TypeSig _lhsItypeSigs) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg37 = T_TypeSig_vIn37 _lhsItypeSigs
(T_TypeSig_vOut37 _lhsOtypeSigs) <- return (inv_TypeSig_s38 sem arg37)
return (Syn_TypeSig _lhsOtypeSigs)
)
-- cata
{-# INLINE sem_TypeSig #-}
sem_TypeSig :: TypeSig -> T_TypeSig
sem_TypeSig ( TypeSig name_ tp_ ) = sem_TypeSig_TypeSig name_ tp_
-- semantic domain
newtype T_TypeSig = T_TypeSig {
attach_T_TypeSig :: Identity (T_TypeSig_s38 )
}
newtype T_TypeSig_s38 = C_TypeSig_s38 {
inv_TypeSig_s38 :: (T_TypeSig_v37 )
}
data T_TypeSig_s39 = C_TypeSig_s39
type T_TypeSig_v37 = (T_TypeSig_vIn37 ) -> (T_TypeSig_vOut37 )
data T_TypeSig_vIn37 = T_TypeSig_vIn37 (Map Identifier Type)
data T_TypeSig_vOut37 = T_TypeSig_vOut37 (Map Identifier Type)
{-# NOINLINE sem_TypeSig_TypeSig #-}
sem_TypeSig_TypeSig :: (Identifier) -> (Type) -> T_TypeSig
sem_TypeSig_TypeSig arg_name_ arg_tp_ = T_TypeSig (return st38) where
{-# NOINLINE st38 #-}
st38 = let
v37 :: T_TypeSig_v37
v37 = \ (T_TypeSig_vIn37 _lhsItypeSigs) -> ( let
_lhsOtypeSigs :: Map Identifier Type
_lhsOtypeSigs = rule574 _lhsItypeSigs arg_name_ arg_tp_
__result_ = T_TypeSig_vOut37 _lhsOtypeSigs
in __result_ )
in C_TypeSig_s38 v37
{-# INLINE rule574 #-}
{-# LINE 536 "src-ag/Order.ag" #-}
rule574 = \ ((_lhsItypeSigs) :: Map Identifier Type) name_ tp_ ->
{-# LINE 536 "src-ag/Order.ag" #-}
Map.insert name_ tp_ _lhsItypeSigs
{-# LINE 4058 "src-generated/TfmToMirage.hs" #-}
-- TypeSigs ----------------------------------------------------
-- wrapper
data Inh_TypeSigs = Inh_TypeSigs { typeSigs_Inh_TypeSigs :: (Map Identifier Type) }
data Syn_TypeSigs = Syn_TypeSigs { typeSigs_Syn_TypeSigs :: (Map Identifier Type) }
{-# INLINABLE wrap_TypeSigs #-}
wrap_TypeSigs :: T_TypeSigs -> Inh_TypeSigs -> (Syn_TypeSigs )
wrap_TypeSigs (T_TypeSigs act) (Inh_TypeSigs _lhsItypeSigs) =
Control.Monad.Identity.runIdentity (
do sem <- act
let arg40 = T_TypeSigs_vIn40 _lhsItypeSigs
(T_TypeSigs_vOut40 _lhsOtypeSigs) <- return (inv_TypeSigs_s41 sem arg40)
return (Syn_TypeSigs _lhsOtypeSigs)
)
-- cata
{-# NOINLINE sem_TypeSigs #-}
sem_TypeSigs :: TypeSigs -> T_TypeSigs
sem_TypeSigs list = Prelude.foldr sem_TypeSigs_Cons sem_TypeSigs_Nil (Prelude.map sem_TypeSig list)
-- semantic domain
newtype T_TypeSigs = T_TypeSigs {
attach_T_TypeSigs :: Identity (T_TypeSigs_s41 )
}
newtype T_TypeSigs_s41 = C_TypeSigs_s41 {
inv_TypeSigs_s41 :: (T_TypeSigs_v40 )
}
data T_TypeSigs_s42 = C_TypeSigs_s42
type T_TypeSigs_v40 = (T_TypeSigs_vIn40 ) -> (T_TypeSigs_vOut40 )
data T_TypeSigs_vIn40 = T_TypeSigs_vIn40 (Map Identifier Type)
data T_TypeSigs_vOut40 = T_TypeSigs_vOut40 (Map Identifier Type)
{-# NOINLINE sem_TypeSigs_Cons #-}
sem_TypeSigs_Cons :: T_TypeSig -> T_TypeSigs -> T_TypeSigs
sem_TypeSigs_Cons arg_hd_ arg_tl_ = T_TypeSigs (return st41) where
{-# NOINLINE st41 #-}
st41 = let
v40 :: T_TypeSigs_v40
v40 = \ (T_TypeSigs_vIn40 _lhsItypeSigs) -> ( let
_hdX38 = Control.Monad.Identity.runIdentity (attach_T_TypeSig (arg_hd_))
_tlX41 = Control.Monad.Identity.runIdentity (attach_T_TypeSigs (arg_tl_))
(T_TypeSig_vOut37 _hdItypeSigs) = inv_TypeSig_s38 _hdX38 (T_TypeSig_vIn37 _hdOtypeSigs)
(T_TypeSigs_vOut40 _tlItypeSigs) = inv_TypeSigs_s41 _tlX41 (T_TypeSigs_vIn40 _tlOtypeSigs)
_lhsOtypeSigs :: Map Identifier Type
_lhsOtypeSigs = rule575 _tlItypeSigs
_hdOtypeSigs = rule576 _lhsItypeSigs
_tlOtypeSigs = rule577 _hdItypeSigs
__result_ = T_TypeSigs_vOut40 _lhsOtypeSigs
in __result_ )
in C_TypeSigs_s41 v40
{-# INLINE rule575 #-}
rule575 = \ ((_tlItypeSigs) :: Map Identifier Type) ->
_tlItypeSigs
{-# INLINE rule576 #-}
rule576 = \ ((_lhsItypeSigs) :: Map Identifier Type) ->
_lhsItypeSigs
{-# INLINE rule577 #-}
rule577 = \ ((_hdItypeSigs) :: Map Identifier Type) ->
_hdItypeSigs
{-# NOINLINE sem_TypeSigs_Nil #-}
sem_TypeSigs_Nil :: T_TypeSigs
sem_TypeSigs_Nil = T_TypeSigs (return st41) where
{-# NOINLINE st41 #-}
st41 = let
v40 :: T_TypeSigs_v40
v40 = \ (T_TypeSigs_vIn40 _lhsItypeSigs) -> ( let
_lhsOtypeSigs :: Map Identifier Type
_lhsOtypeSigs = rule578 _lhsItypeSigs
__result_ = T_TypeSigs_vOut40 _lhsOtypeSigs
in __result_ )
in C_TypeSigs_s41 v40
{-# INLINE rule578 #-}
rule578 = \ ((_lhsItypeSigs) :: Map Identifier Type) ->
_lhsItypeSigs