uuagc-0.9.38.4: src-derived/KWOrder.hs
-- UUAGC 0.9.38.1 (KWOrder.ag)
module KWOrder where
{-# LINE 6 "KWOrder.ag" #-}
import AbstractSyntax
import HsToken
import Expression
import Patterns
import Options
import PPUtil
import Pretty
import Knuth1
import KennedyWarren
import Maybe
import qualified Data.Set as Set
import qualified Data.Map as Map
{-# LINE 20 "../src-derived/KWOrder.hs" #-}
{-# LINE 2 "./AbstractSyntax.ag" #-}
-- AbstractSyntax.ag imports
import Data.Set(Set)
import Data.Map(Map)
import Patterns (Pattern(..),Patterns)
import Expression (Expression(..))
import CommonTypes
{-# LINE 30 "../src-derived/KWOrder.hs" #-}
{-# LINE 2 "./HsToken.ag" #-}
import CommonTypes
import UU.Scanner.Position(Pos)
{-# LINE 36 "../src-derived/KWOrder.hs" #-}
{-# LINE 2 "./Expression.ag" #-}
import UU.Scanner.Position(Pos)
import HsToken
{-# LINE 42 "../src-derived/KWOrder.hs" #-}
{-# LINE 2 "./Patterns.ag" #-}
-- Patterns.ag imports
import UU.Scanner.Position(Pos)
import CommonTypes (ConstructorIdent,Identifier)
{-# LINE 49 "../src-derived/KWOrder.hs" #-}
-- Child -------------------------------------------------------
{-
visit 0:
synthesized attributes:
edges : Set.Set Edge
nontnames : [(Identifier, Identifier)]
vertices : Set.Set Vertex
alternatives:
alternative Child:
child name : {Identifier}
child tp : {Type}
child inh : {Attributes}
child syn : {Attributes}
child virtual : {Maybe (Maybe Type)}
visit 0:
local vertex : _
local synvertices : _
local inhvertices : _
local edgesout : _
local edgesin : _
-}
-- cata
sem_Child :: Child ->
T_Child
sem_Child (Child _name _tp _inh _syn _virtual ) =
(sem_Child_Child _name _tp _inh _syn _virtual )
-- semantic domain
newtype T_Child = T_Child (( (Set.Set Edge),([(Identifier, Identifier)]),(Set.Set Vertex)))
data Inh_Child = Inh_Child {}
data Syn_Child = Syn_Child {edges_Syn_Child :: (Set.Set Edge),nontnames_Syn_Child :: ([(Identifier, Identifier)]),vertices_Syn_Child :: (Set.Set Vertex)}
wrap_Child :: T_Child ->
Inh_Child ->
Syn_Child
wrap_Child (T_Child sem ) (Inh_Child ) =
(let ( _lhsOedges,_lhsOnontnames,_lhsOvertices) = sem
in (Syn_Child _lhsOedges _lhsOnontnames _lhsOvertices ))
sem_Child_Child :: Identifier ->
Type ->
Attributes ->
Attributes ->
(Maybe (Maybe Type)) ->
T_Child
sem_Child_Child name_ tp_ inh_ syn_ virtual_ =
(T_Child (let _lhsOvertices :: (Set.Set Vertex)
_lhsOedges :: (Set.Set Edge)
_lhsOnontnames :: ([(Identifier, Identifier)])
-- "KWOrder.ag"(line 76, column 12)
_vertex =
({-# LINE 76 "KWOrder.ag" #-}
VChild name_
{-# LINE 100 "KWOrder.hs" #-}
)
-- "KWOrder.ag"(line 77, column 12)
_synvertices =
({-# LINE 77 "KWOrder.ag" #-}
map (VAttr Syn name_) . Map.keys $ syn_
{-# LINE 106 "KWOrder.hs" #-}
)
-- "KWOrder.ag"(line 78, column 12)
_inhvertices =
({-# LINE 78 "KWOrder.ag" #-}
map (VAttr Inh name_) . Map.keys $ inh_
{-# LINE 112 "KWOrder.hs" #-}
)
-- "KWOrder.ag"(line 79, column 12)
_lhsOvertices =
({-# LINE 79 "KWOrder.ag" #-}
case tp_ of
NT _ _ -> Set.insert _vertex (Set.fromList $ _synvertices ++ _inhvertices )
_ -> Set.empty
{-# LINE 120 "KWOrder.hs" #-}
)
-- "KWOrder.ag"(line 104, column 12)
_edgesout =
({-# LINE 104 "KWOrder.ag" #-}
[]
{-# LINE 126 "KWOrder.hs" #-}
)
-- "KWOrder.ag"(line 105, column 12)
_edgesin =
({-# LINE 105 "KWOrder.ag" #-}
map (flip (,) _vertex ) _synvertices
{-# LINE 132 "KWOrder.hs" #-}
)
-- "KWOrder.ag"(line 106, column 12)
_lhsOedges =
({-# LINE 106 "KWOrder.ag" #-}
Set.fromList $ _edgesout ++ _edgesin
{-# LINE 138 "KWOrder.hs" #-}
)
-- "KWOrder.ag"(line 116, column 12)
_lhsOnontnames =
({-# LINE 116 "KWOrder.ag" #-}
case tp_ of
NT nont _ -> [(name_, nont)]
_ -> []
{-# LINE 146 "KWOrder.hs" #-}
)
in ( _lhsOedges,_lhsOnontnames,_lhsOvertices)) )
-- Children ----------------------------------------------------
{-
visit 0:
synthesized attributes:
edges : Set.Set Edge
nontnames : [(Identifier, Identifier)]
vertices : Set.Set Vertex
alternatives:
alternative Cons:
child hd : Child
child tl : Children
alternative Nil:
-}
-- cata
sem_Children :: Children ->
T_Children
sem_Children list =
(Prelude.foldr sem_Children_Cons sem_Children_Nil (Prelude.map sem_Child list) )
-- semantic domain
newtype T_Children = T_Children (( (Set.Set Edge),([(Identifier, Identifier)]),(Set.Set Vertex)))
data Inh_Children = Inh_Children {}
data Syn_Children = Syn_Children {edges_Syn_Children :: (Set.Set Edge),nontnames_Syn_Children :: ([(Identifier, Identifier)]),vertices_Syn_Children :: (Set.Set Vertex)}
wrap_Children :: T_Children ->
Inh_Children ->
Syn_Children
wrap_Children (T_Children sem ) (Inh_Children ) =
(let ( _lhsOedges,_lhsOnontnames,_lhsOvertices) = sem
in (Syn_Children _lhsOedges _lhsOnontnames _lhsOvertices ))
sem_Children_Cons :: T_Child ->
T_Children ->
T_Children
sem_Children_Cons (T_Child hd_ ) (T_Children tl_ ) =
(T_Children (let _lhsOedges :: (Set.Set Edge)
_lhsOnontnames :: ([(Identifier, Identifier)])
_lhsOvertices :: (Set.Set Vertex)
_hdIedges :: (Set.Set Edge)
_hdInontnames :: ([(Identifier, Identifier)])
_hdIvertices :: (Set.Set Vertex)
_tlIedges :: (Set.Set Edge)
_tlInontnames :: ([(Identifier, Identifier)])
_tlIvertices :: (Set.Set Vertex)
-- use rule "KWOrder.ag"(line 94, column 33)
_lhsOedges =
({-# LINE 94 "KWOrder.ag" #-}
_hdIedges `Set.union` _tlIedges
{-# LINE 194 "KWOrder.hs" #-}
)
-- use rule "KWOrder.ag"(line 113, column 37)
_lhsOnontnames =
({-# LINE 113 "KWOrder.ag" #-}
_hdInontnames ++ _tlInontnames
{-# LINE 200 "KWOrder.hs" #-}
)
-- use rule "KWOrder.ag"(line 52, column 36)
_lhsOvertices =
({-# LINE 52 "KWOrder.ag" #-}
_hdIvertices `Set.union` _tlIvertices
{-# LINE 206 "KWOrder.hs" #-}
)
( _hdIedges,_hdInontnames,_hdIvertices) =
hd_
( _tlIedges,_tlInontnames,_tlIvertices) =
tl_
in ( _lhsOedges,_lhsOnontnames,_lhsOvertices)) )
sem_Children_Nil :: T_Children
sem_Children_Nil =
(T_Children (let _lhsOedges :: (Set.Set Edge)
_lhsOnontnames :: ([(Identifier, Identifier)])
_lhsOvertices :: (Set.Set Vertex)
-- use rule "KWOrder.ag"(line 94, column 33)
_lhsOedges =
({-# LINE 94 "KWOrder.ag" #-}
Set.empty
{-# LINE 222 "KWOrder.hs" #-}
)
-- use rule "KWOrder.ag"(line 113, column 37)
_lhsOnontnames =
({-# LINE 113 "KWOrder.ag" #-}
[]
{-# LINE 228 "KWOrder.hs" #-}
)
-- use rule "KWOrder.ag"(line 52, column 36)
_lhsOvertices =
({-# LINE 52 "KWOrder.ag" #-}
Set.empty
{-# LINE 234 "KWOrder.hs" #-}
)
in ( _lhsOedges,_lhsOnontnames,_lhsOvertices)) )
-- Expression --------------------------------------------------
{-
visit 0:
synthesized attribute:
vertices : Set.Set Vertex
alternatives:
alternative Expression:
child pos : {Pos}
child tks : {[HsToken]}
-}
-- cata
sem_Expression :: Expression ->
T_Expression
sem_Expression (Expression _pos _tks ) =
(sem_Expression_Expression _pos _tks )
-- semantic domain
newtype T_Expression = T_Expression (( (Set.Set Vertex)))
data Inh_Expression = Inh_Expression {}
data Syn_Expression = Syn_Expression {vertices_Syn_Expression :: (Set.Set Vertex)}
wrap_Expression :: T_Expression ->
Inh_Expression ->
Syn_Expression
wrap_Expression (T_Expression sem ) (Inh_Expression ) =
(let ( _lhsOvertices) = sem
in (Syn_Expression _lhsOvertices ))
sem_Expression_Expression :: Pos ->
([HsToken]) ->
T_Expression
sem_Expression_Expression pos_ tks_ =
(T_Expression (let _lhsOvertices :: (Set.Set Vertex)
-- "KWOrder.ag"(line 63, column 17)
_lhsOvertices =
({-# LINE 63 "KWOrder.ag" #-}
Set.unions $ map (\tok -> vertices_Syn_HsToken
(wrap_HsToken (sem_HsToken tok) Inh_HsToken)) tks_
{-# LINE 272 "KWOrder.hs" #-}
)
in ( _lhsOvertices)) )
-- Grammar -----------------------------------------------------
{-
visit 0:
inherited attribute:
options : Options
synthesized attribute:
debugoutput : PP_Doc
alternatives:
alternative Grammar:
child typeSyns : {TypeSyns}
child useMap : {UseMap}
child derivings : {Derivings}
child wrappers : {Set NontermIdent}
child nonts : Nonterminals
child pragmas : {PragmaMap}
child manualAttrOrderMap : {AttrOrderMap}
child paramMap : {ParamMap}
child contextMap : {ContextMap}
child quantMap : {QuantMap}
child uniqueMap : {UniqueMap}
child augmentsMap : {Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))}
child aroundsMap : {Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))}
child mergeMap : {Map NontermIdent (Map ConstructorIdent (Map Identifier (Identifier, [Identifier], Expression)))}
-}
-- cata
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 (Options ->
( PP_Doc))
data Inh_Grammar = Inh_Grammar {options_Inh_Grammar :: Options}
data Syn_Grammar = Syn_Grammar {debugoutput_Syn_Grammar :: PP_Doc}
wrap_Grammar :: T_Grammar ->
Inh_Grammar ->
Syn_Grammar
wrap_Grammar (T_Grammar sem ) (Inh_Grammar _lhsIoptions ) =
(let ( _lhsOdebugoutput) = sem _lhsIoptions
in (Syn_Grammar _lhsOdebugoutput ))
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 typeSyns_ useMap_ derivings_ wrappers_ (T_Nonterminals nonts_ ) pragmas_ manualAttrOrderMap_ paramMap_ contextMap_ quantMap_ uniqueMap_ augmentsMap_ aroundsMap_ mergeMap_ =
(T_Grammar (\ _lhsIoptions ->
(let _nontsOrulenumber :: Int
_lhsOdebugoutput :: PP_Doc
_nontsIdepinfo :: ([NontDependencyInformation])
_nontsIrulenumber :: Int
-- "KWOrder.ag"(line 39, column 14)
_nontsOrulenumber =
({-# LINE 39 "KWOrder.ag" #-}
0
{-# LINE 340 "KWOrder.hs" #-}
)
-- "KWOrder.ag"(line 160, column 14)
_lhsOdebugoutput =
({-# LINE 160 "KWOrder.ag" #-}
kennedyWarrenIO _nontsIdepinfo
{-# LINE 346 "KWOrder.hs" #-}
)
( _nontsIdepinfo,_nontsIrulenumber) =
nonts_ _nontsOrulenumber
in ( _lhsOdebugoutput))) )
-- HsToken -----------------------------------------------------
{-
visit 0:
synthesized attribute:
vertices : Set.Set Vertex
alternatives:
alternative AGField:
child field : {Identifier}
child attr : {Identifier}
child pos : {Pos}
child rdesc : {Maybe String}
alternative AGLocal:
child var : {Identifier}
child pos : {Pos}
child rdesc : {Maybe String}
alternative CharToken:
child value : {String}
child pos : {Pos}
alternative Err:
child mesg : {String}
child pos : {Pos}
alternative HsToken:
child value : {String}
child pos : {Pos}
alternative StrToken:
child value : {String}
child pos : {Pos}
-}
-- cata
sem_HsToken :: HsToken ->
T_HsToken
sem_HsToken (AGField _field _attr _pos _rdesc ) =
(sem_HsToken_AGField _field _attr _pos _rdesc )
sem_HsToken (AGLocal _var _pos _rdesc ) =
(sem_HsToken_AGLocal _var _pos _rdesc )
sem_HsToken (CharToken _value _pos ) =
(sem_HsToken_CharToken _value _pos )
sem_HsToken (Err _mesg _pos ) =
(sem_HsToken_Err _mesg _pos )
sem_HsToken (HsToken _value _pos ) =
(sem_HsToken_HsToken _value _pos )
sem_HsToken (StrToken _value _pos ) =
(sem_HsToken_StrToken _value _pos )
-- semantic domain
newtype T_HsToken = T_HsToken (( (Set.Set Vertex)))
data Inh_HsToken = Inh_HsToken {}
data Syn_HsToken = Syn_HsToken {vertices_Syn_HsToken :: (Set.Set Vertex)}
wrap_HsToken :: T_HsToken ->
Inh_HsToken ->
Syn_HsToken
wrap_HsToken (T_HsToken sem ) (Inh_HsToken ) =
(let ( _lhsOvertices) = sem
in (Syn_HsToken _lhsOvertices ))
sem_HsToken_AGField :: Identifier ->
Identifier ->
Pos ->
(Maybe String) ->
T_HsToken
sem_HsToken_AGField field_ attr_ pos_ rdesc_ =
(T_HsToken (let _lhsOvertices :: (Set.Set Vertex)
-- "KWOrder.ag"(line 57, column 14)
_lhsOvertices =
({-# LINE 57 "KWOrder.ag" #-}
Set.singleton $ VAttr (if field_ == _LHS then Inh
else if field_ == _LOC then Loc
else Syn) field_ attr_
{-# LINE 417 "KWOrder.hs" #-}
)
in ( _lhsOvertices)) )
sem_HsToken_AGLocal :: Identifier ->
Pos ->
(Maybe String) ->
T_HsToken
sem_HsToken_AGLocal var_ pos_ rdesc_ =
(T_HsToken (let _lhsOvertices :: (Set.Set Vertex)
-- "KWOrder.ag"(line 56, column 14)
_lhsOvertices =
({-# LINE 56 "KWOrder.ag" #-}
Set.singleton $ VAttr Loc _LOC var_
{-# LINE 430 "KWOrder.hs" #-}
)
in ( _lhsOvertices)) )
sem_HsToken_CharToken :: String ->
Pos ->
T_HsToken
sem_HsToken_CharToken value_ pos_ =
(T_HsToken (let _lhsOvertices :: (Set.Set Vertex)
-- use rule "KWOrder.ag"(line 52, column 36)
_lhsOvertices =
({-# LINE 52 "KWOrder.ag" #-}
Set.empty
{-# LINE 442 "KWOrder.hs" #-}
)
in ( _lhsOvertices)) )
sem_HsToken_Err :: String ->
Pos ->
T_HsToken
sem_HsToken_Err mesg_ pos_ =
(T_HsToken (let _lhsOvertices :: (Set.Set Vertex)
-- use rule "KWOrder.ag"(line 52, column 36)
_lhsOvertices =
({-# LINE 52 "KWOrder.ag" #-}
Set.empty
{-# LINE 454 "KWOrder.hs" #-}
)
in ( _lhsOvertices)) )
sem_HsToken_HsToken :: String ->
Pos ->
T_HsToken
sem_HsToken_HsToken value_ pos_ =
(T_HsToken (let _lhsOvertices :: (Set.Set Vertex)
-- use rule "KWOrder.ag"(line 52, column 36)
_lhsOvertices =
({-# LINE 52 "KWOrder.ag" #-}
Set.empty
{-# LINE 466 "KWOrder.hs" #-}
)
in ( _lhsOvertices)) )
sem_HsToken_StrToken :: String ->
Pos ->
T_HsToken
sem_HsToken_StrToken value_ pos_ =
(T_HsToken (let _lhsOvertices :: (Set.Set Vertex)
-- use rule "KWOrder.ag"(line 52, column 36)
_lhsOvertices =
({-# LINE 52 "KWOrder.ag" #-}
Set.empty
{-# LINE 478 "KWOrder.hs" #-}
)
in ( _lhsOvertices)) )
-- HsTokens ----------------------------------------------------
{-
alternatives:
alternative Cons:
child hd : HsToken
child tl : HsTokens
alternative Nil:
-}
-- cata
sem_HsTokens :: HsTokens ->
T_HsTokens
sem_HsTokens list =
(Prelude.foldr sem_HsTokens_Cons sem_HsTokens_Nil (Prelude.map sem_HsToken list) )
-- semantic domain
newtype T_HsTokens = T_HsTokens (( ))
data Inh_HsTokens = Inh_HsTokens {}
data Syn_HsTokens = Syn_HsTokens {}
wrap_HsTokens :: T_HsTokens ->
Inh_HsTokens ->
Syn_HsTokens
wrap_HsTokens (T_HsTokens sem ) (Inh_HsTokens ) =
(let ( ) = sem
in (Syn_HsTokens ))
sem_HsTokens_Cons :: T_HsToken ->
T_HsTokens ->
T_HsTokens
sem_HsTokens_Cons (T_HsToken hd_ ) (T_HsTokens tl_ ) =
(T_HsTokens (let _hdIvertices :: (Set.Set Vertex)
( _hdIvertices) =
hd_
in ( )) )
sem_HsTokens_Nil :: T_HsTokens
sem_HsTokens_Nil =
(T_HsTokens (let
in ( )) )
-- HsTokensRoot ------------------------------------------------
{-
alternatives:
alternative HsTokensRoot:
child tokens : HsTokens
-}
-- cata
sem_HsTokensRoot :: HsTokensRoot ->
T_HsTokensRoot
sem_HsTokensRoot (HsTokensRoot _tokens ) =
(sem_HsTokensRoot_HsTokensRoot (sem_HsTokens _tokens ) )
-- semantic domain
newtype T_HsTokensRoot = T_HsTokensRoot (( ))
data Inh_HsTokensRoot = Inh_HsTokensRoot {}
data Syn_HsTokensRoot = Syn_HsTokensRoot {}
wrap_HsTokensRoot :: T_HsTokensRoot ->
Inh_HsTokensRoot ->
Syn_HsTokensRoot
wrap_HsTokensRoot (T_HsTokensRoot sem ) (Inh_HsTokensRoot ) =
(let ( ) = sem
in (Syn_HsTokensRoot ))
sem_HsTokensRoot_HsTokensRoot :: T_HsTokens ->
T_HsTokensRoot
sem_HsTokensRoot_HsTokensRoot (T_HsTokens tokens_ ) =
(T_HsTokensRoot (let
in ( )) )
-- Nonterminal -------------------------------------------------
{-
visit 0:
chained attribute:
rulenumber : Int
synthesized attribute:
depinfo : NontDependencyInformation
alternatives:
alternative Nonterminal:
child nt : {NontermIdent}
child params : {[Identifier]}
child inh : {Attributes}
child syn : {Attributes}
child prods : Productions
visit 0:
local synvertices : _
local inhvertices : _
local vertices : _
local nontgraph : _
-}
-- cata
sem_Nonterminal :: Nonterminal ->
T_Nonterminal
sem_Nonterminal (Nonterminal _nt _params _inh _syn _prods ) =
(sem_Nonterminal_Nonterminal _nt _params _inh _syn (sem_Productions _prods ) )
-- semantic domain
newtype T_Nonterminal = T_Nonterminal (Int ->
( NontDependencyInformation,Int))
data Inh_Nonterminal = Inh_Nonterminal {rulenumber_Inh_Nonterminal :: Int}
data Syn_Nonterminal = Syn_Nonterminal {depinfo_Syn_Nonterminal :: NontDependencyInformation,rulenumber_Syn_Nonterminal :: Int}
wrap_Nonterminal :: T_Nonterminal ->
Inh_Nonterminal ->
Syn_Nonterminal
wrap_Nonterminal (T_Nonterminal sem ) (Inh_Nonterminal _lhsIrulenumber ) =
(let ( _lhsOdepinfo,_lhsOrulenumber) = sem _lhsIrulenumber
in (Syn_Nonterminal _lhsOdepinfo _lhsOrulenumber ))
sem_Nonterminal_Nonterminal :: NontermIdent ->
([Identifier]) ->
Attributes ->
Attributes ->
T_Productions ->
T_Nonterminal
sem_Nonterminal_Nonterminal nt_ params_ inh_ syn_ (T_Productions prods_ ) =
(T_Nonterminal (\ _lhsIrulenumber ->
(let _lhsOdepinfo :: NontDependencyInformation
_lhsOrulenumber :: Int
_prodsOrulenumber :: Int
_prodsIdepgraph :: ([ProdDependencyGraph])
_prodsIrulenumber :: Int
-- "KWOrder.ag"(line 136, column 18)
_synvertices =
({-# LINE 136 "KWOrder.ag" #-}
map (VAttr Syn nt_) . Map.keys $ syn_
{-# LINE 595 "KWOrder.hs" #-}
)
-- "KWOrder.ag"(line 137, column 18)
_inhvertices =
({-# LINE 137 "KWOrder.ag" #-}
map (VAttr Inh nt_) . Map.keys $ inh_
{-# LINE 601 "KWOrder.hs" #-}
)
-- "KWOrder.ag"(line 138, column 18)
_vertices =
({-# LINE 138 "KWOrder.ag" #-}
_synvertices ++ _inhvertices
{-# LINE 607 "KWOrder.hs" #-}
)
-- "KWOrder.ag"(line 142, column 18)
_nontgraph =
({-# LINE 142 "KWOrder.ag" #-}
NontDependencyGraph { ndgVertices = _vertices
, ndgEdges = [] }
{-# LINE 614 "KWOrder.hs" #-}
)
-- "KWOrder.ag"(line 150, column 18)
_lhsOdepinfo =
({-# LINE 150 "KWOrder.ag" #-}
NontDependencyInformation { ndiNonterminal = nt_
, ndiInh = Map.keys inh_
, ndiSyn = Map.keys syn_
, ndiDepGraph = _nontgraph
, ndiProds = _prodsIdepgraph }
{-# LINE 624 "KWOrder.hs" #-}
)
-- copy rule (up)
_lhsOrulenumber =
({-# LINE 36 "KWOrder.ag" #-}
_prodsIrulenumber
{-# LINE 630 "KWOrder.hs" #-}
)
-- copy rule (down)
_prodsOrulenumber =
({-# LINE 36 "KWOrder.ag" #-}
_lhsIrulenumber
{-# LINE 636 "KWOrder.hs" #-}
)
( _prodsIdepgraph,_prodsIrulenumber) =
prods_ _prodsOrulenumber
in ( _lhsOdepinfo,_lhsOrulenumber))) )
-- Nonterminals ------------------------------------------------
{-
visit 0:
chained attribute:
rulenumber : Int
synthesized attribute:
depinfo : [NontDependencyInformation]
alternatives:
alternative Cons:
child hd : Nonterminal
child tl : Nonterminals
alternative Nil:
-}
-- cata
sem_Nonterminals :: Nonterminals ->
T_Nonterminals
sem_Nonterminals list =
(Prelude.foldr sem_Nonterminals_Cons sem_Nonterminals_Nil (Prelude.map sem_Nonterminal list) )
-- semantic domain
newtype T_Nonterminals = T_Nonterminals (Int ->
( ([NontDependencyInformation]),Int))
data Inh_Nonterminals = Inh_Nonterminals {rulenumber_Inh_Nonterminals :: Int}
data Syn_Nonterminals = Syn_Nonterminals {depinfo_Syn_Nonterminals :: ([NontDependencyInformation]),rulenumber_Syn_Nonterminals :: Int}
wrap_Nonterminals :: T_Nonterminals ->
Inh_Nonterminals ->
Syn_Nonterminals
wrap_Nonterminals (T_Nonterminals sem ) (Inh_Nonterminals _lhsIrulenumber ) =
(let ( _lhsOdepinfo,_lhsOrulenumber) = sem _lhsIrulenumber
in (Syn_Nonterminals _lhsOdepinfo _lhsOrulenumber ))
sem_Nonterminals_Cons :: T_Nonterminal ->
T_Nonterminals ->
T_Nonterminals
sem_Nonterminals_Cons (T_Nonterminal hd_ ) (T_Nonterminals tl_ ) =
(T_Nonterminals (\ _lhsIrulenumber ->
(let _lhsOdepinfo :: ([NontDependencyInformation])
_lhsOrulenumber :: Int
_hdOrulenumber :: Int
_tlOrulenumber :: Int
_hdIdepinfo :: NontDependencyInformation
_hdIrulenumber :: Int
_tlIdepinfo :: ([NontDependencyInformation])
_tlIrulenumber :: Int
-- use rule "KWOrder.ag"(line 147, column 33)
_lhsOdepinfo =
({-# LINE 147 "KWOrder.ag" #-}
_hdIdepinfo : _tlIdepinfo
{-# LINE 687 "KWOrder.hs" #-}
)
-- copy rule (up)
_lhsOrulenumber =
({-# LINE 36 "KWOrder.ag" #-}
_tlIrulenumber
{-# LINE 693 "KWOrder.hs" #-}
)
-- copy rule (down)
_hdOrulenumber =
({-# LINE 36 "KWOrder.ag" #-}
_lhsIrulenumber
{-# LINE 699 "KWOrder.hs" #-}
)
-- copy rule (chain)
_tlOrulenumber =
({-# LINE 36 "KWOrder.ag" #-}
_hdIrulenumber
{-# LINE 705 "KWOrder.hs" #-}
)
( _hdIdepinfo,_hdIrulenumber) =
hd_ _hdOrulenumber
( _tlIdepinfo,_tlIrulenumber) =
tl_ _tlOrulenumber
in ( _lhsOdepinfo,_lhsOrulenumber))) )
sem_Nonterminals_Nil :: T_Nonterminals
sem_Nonterminals_Nil =
(T_Nonterminals (\ _lhsIrulenumber ->
(let _lhsOdepinfo :: ([NontDependencyInformation])
_lhsOrulenumber :: Int
-- use rule "KWOrder.ag"(line 147, column 33)
_lhsOdepinfo =
({-# LINE 147 "KWOrder.ag" #-}
[]
{-# LINE 721 "KWOrder.hs" #-}
)
-- copy rule (chain)
_lhsOrulenumber =
({-# LINE 36 "KWOrder.ag" #-}
_lhsIrulenumber
{-# LINE 727 "KWOrder.hs" #-}
)
in ( _lhsOdepinfo,_lhsOrulenumber))) )
-- Pattern -----------------------------------------------------
{-
visit 0:
synthesized attributes:
copy : SELF
vertices : Set.Set Vertex
alternatives:
alternative Alias:
child field : {Identifier}
child attr : {Identifier}
child pat : Pattern
child parts : Patterns
visit 0:
local vertex : _
local copy : _
alternative Constr:
child name : {ConstructorIdent}
child pats : Patterns
visit 0:
local copy : _
alternative Irrefutable:
child pat : Pattern
visit 0:
local copy : _
alternative Product:
child pos : {Pos}
child pats : Patterns
visit 0:
local copy : _
alternative Underscore:
child pos : {Pos}
visit 0:
local copy : _
-}
-- cata
sem_Pattern :: Pattern ->
T_Pattern
sem_Pattern (Alias _field _attr _pat _parts ) =
(sem_Pattern_Alias _field _attr (sem_Pattern _pat ) (sem_Patterns _parts ) )
sem_Pattern (Constr _name _pats ) =
(sem_Pattern_Constr _name (sem_Patterns _pats ) )
sem_Pattern (Irrefutable _pat ) =
(sem_Pattern_Irrefutable (sem_Pattern _pat ) )
sem_Pattern (Product _pos _pats ) =
(sem_Pattern_Product _pos (sem_Patterns _pats ) )
sem_Pattern (Underscore _pos ) =
(sem_Pattern_Underscore _pos )
-- semantic domain
newtype T_Pattern = T_Pattern (( Pattern ,(Set.Set Vertex)))
data Inh_Pattern = Inh_Pattern {}
data Syn_Pattern = Syn_Pattern {copy_Syn_Pattern :: Pattern ,vertices_Syn_Pattern :: (Set.Set Vertex)}
wrap_Pattern :: T_Pattern ->
Inh_Pattern ->
Syn_Pattern
wrap_Pattern (T_Pattern sem ) (Inh_Pattern ) =
(let ( _lhsOcopy,_lhsOvertices) = sem
in (Syn_Pattern _lhsOcopy _lhsOvertices ))
sem_Pattern_Alias :: Identifier ->
Identifier ->
T_Pattern ->
T_Patterns ->
T_Pattern
sem_Pattern_Alias field_ attr_ (T_Pattern pat_ ) (T_Patterns parts_ ) =
(T_Pattern (let _lhsOvertices :: (Set.Set Vertex)
_lhsOcopy :: Pattern
_patIcopy :: Pattern
_patIvertices :: (Set.Set Vertex)
_partsIcopy :: Patterns
_partsIvertices :: (Set.Set Vertex)
-- "KWOrder.ag"(line 68, column 12)
_vertex =
({-# LINE 68 "KWOrder.ag" #-}
if field_ == _INST then VChild attr_
else VAttr (if field_ == _LHS then Syn
else if field_ == _LOC then Loc
else Inh) field_ attr_
{-# LINE 806 "KWOrder.hs" #-}
)
-- "KWOrder.ag"(line 72, column 12)
_lhsOvertices =
({-# LINE 72 "KWOrder.ag" #-}
Set.insert _vertex $ _partsIvertices `Set.union` _patIvertices
{-# LINE 812 "KWOrder.hs" #-}
)
-- self rule
_copy =
({-# LINE 23 "./Patterns.ag" #-}
Alias field_ attr_ _patIcopy _partsIcopy
{-# LINE 818 "KWOrder.hs" #-}
)
-- self rule
_lhsOcopy =
({-# LINE 23 "./Patterns.ag" #-}
_copy
{-# LINE 824 "KWOrder.hs" #-}
)
( _patIcopy,_patIvertices) =
pat_
( _partsIcopy,_partsIvertices) =
parts_
in ( _lhsOcopy,_lhsOvertices)) )
sem_Pattern_Constr :: ConstructorIdent ->
T_Patterns ->
T_Pattern
sem_Pattern_Constr name_ (T_Patterns pats_ ) =
(T_Pattern (let _lhsOvertices :: (Set.Set Vertex)
_lhsOcopy :: Pattern
_patsIcopy :: Patterns
_patsIvertices :: (Set.Set Vertex)
-- use rule "KWOrder.ag"(line 52, column 36)
_lhsOvertices =
({-# LINE 52 "KWOrder.ag" #-}
_patsIvertices
{-# LINE 843 "KWOrder.hs" #-}
)
-- self rule
_copy =
({-# LINE 23 "./Patterns.ag" #-}
Constr name_ _patsIcopy
{-# LINE 849 "KWOrder.hs" #-}
)
-- self rule
_lhsOcopy =
({-# LINE 23 "./Patterns.ag" #-}
_copy
{-# LINE 855 "KWOrder.hs" #-}
)
( _patsIcopy,_patsIvertices) =
pats_
in ( _lhsOcopy,_lhsOvertices)) )
sem_Pattern_Irrefutable :: T_Pattern ->
T_Pattern
sem_Pattern_Irrefutable (T_Pattern pat_ ) =
(T_Pattern (let _lhsOvertices :: (Set.Set Vertex)
_lhsOcopy :: Pattern
_patIcopy :: Pattern
_patIvertices :: (Set.Set Vertex)
-- use rule "KWOrder.ag"(line 52, column 36)
_lhsOvertices =
({-# LINE 52 "KWOrder.ag" #-}
_patIvertices
{-# LINE 871 "KWOrder.hs" #-}
)
-- self rule
_copy =
({-# LINE 23 "./Patterns.ag" #-}
Irrefutable _patIcopy
{-# LINE 877 "KWOrder.hs" #-}
)
-- self rule
_lhsOcopy =
({-# LINE 23 "./Patterns.ag" #-}
_copy
{-# LINE 883 "KWOrder.hs" #-}
)
( _patIcopy,_patIvertices) =
pat_
in ( _lhsOcopy,_lhsOvertices)) )
sem_Pattern_Product :: Pos ->
T_Patterns ->
T_Pattern
sem_Pattern_Product pos_ (T_Patterns pats_ ) =
(T_Pattern (let _lhsOvertices :: (Set.Set Vertex)
_lhsOcopy :: Pattern
_patsIcopy :: Patterns
_patsIvertices :: (Set.Set Vertex)
-- use rule "KWOrder.ag"(line 52, column 36)
_lhsOvertices =
({-# LINE 52 "KWOrder.ag" #-}
_patsIvertices
{-# LINE 900 "KWOrder.hs" #-}
)
-- self rule
_copy =
({-# LINE 23 "./Patterns.ag" #-}
Product pos_ _patsIcopy
{-# LINE 906 "KWOrder.hs" #-}
)
-- self rule
_lhsOcopy =
({-# LINE 23 "./Patterns.ag" #-}
_copy
{-# LINE 912 "KWOrder.hs" #-}
)
( _patsIcopy,_patsIvertices) =
pats_
in ( _lhsOcopy,_lhsOvertices)) )
sem_Pattern_Underscore :: Pos ->
T_Pattern
sem_Pattern_Underscore pos_ =
(T_Pattern (let _lhsOvertices :: (Set.Set Vertex)
_lhsOcopy :: Pattern
-- use rule "KWOrder.ag"(line 52, column 36)
_lhsOvertices =
({-# LINE 52 "KWOrder.ag" #-}
Set.empty
{-# LINE 926 "KWOrder.hs" #-}
)
-- self rule
_copy =
({-# LINE 23 "./Patterns.ag" #-}
Underscore pos_
{-# LINE 932 "KWOrder.hs" #-}
)
-- self rule
_lhsOcopy =
({-# LINE 23 "./Patterns.ag" #-}
_copy
{-# LINE 938 "KWOrder.hs" #-}
)
in ( _lhsOcopy,_lhsOvertices)) )
-- Patterns ----------------------------------------------------
{-
visit 0:
synthesized attributes:
copy : SELF
vertices : Set.Set Vertex
alternatives:
alternative Cons:
child hd : Pattern
child tl : Patterns
visit 0:
local copy : _
alternative Nil:
visit 0:
local copy : _
-}
-- cata
sem_Patterns :: Patterns ->
T_Patterns
sem_Patterns list =
(Prelude.foldr sem_Patterns_Cons sem_Patterns_Nil (Prelude.map sem_Pattern list) )
-- semantic domain
newtype T_Patterns = T_Patterns (( Patterns ,(Set.Set Vertex)))
data Inh_Patterns = Inh_Patterns {}
data Syn_Patterns = Syn_Patterns {copy_Syn_Patterns :: Patterns ,vertices_Syn_Patterns :: (Set.Set Vertex)}
wrap_Patterns :: T_Patterns ->
Inh_Patterns ->
Syn_Patterns
wrap_Patterns (T_Patterns sem ) (Inh_Patterns ) =
(let ( _lhsOcopy,_lhsOvertices) = sem
in (Syn_Patterns _lhsOcopy _lhsOvertices ))
sem_Patterns_Cons :: T_Pattern ->
T_Patterns ->
T_Patterns
sem_Patterns_Cons (T_Pattern hd_ ) (T_Patterns tl_ ) =
(T_Patterns (let _lhsOvertices :: (Set.Set Vertex)
_lhsOcopy :: Patterns
_hdIcopy :: Pattern
_hdIvertices :: (Set.Set Vertex)
_tlIcopy :: Patterns
_tlIvertices :: (Set.Set Vertex)
-- use rule "KWOrder.ag"(line 52, column 36)
_lhsOvertices =
({-# LINE 52 "KWOrder.ag" #-}
_hdIvertices `Set.union` _tlIvertices
{-# LINE 986 "KWOrder.hs" #-}
)
-- self rule
_copy =
({-# LINE 23 "./Patterns.ag" #-}
(:) _hdIcopy _tlIcopy
{-# LINE 992 "KWOrder.hs" #-}
)
-- self rule
_lhsOcopy =
({-# LINE 23 "./Patterns.ag" #-}
_copy
{-# LINE 998 "KWOrder.hs" #-}
)
( _hdIcopy,_hdIvertices) =
hd_
( _tlIcopy,_tlIvertices) =
tl_
in ( _lhsOcopy,_lhsOvertices)) )
sem_Patterns_Nil :: T_Patterns
sem_Patterns_Nil =
(T_Patterns (let _lhsOvertices :: (Set.Set Vertex)
_lhsOcopy :: Patterns
-- use rule "KWOrder.ag"(line 52, column 36)
_lhsOvertices =
({-# LINE 52 "KWOrder.ag" #-}
Set.empty
{-# LINE 1013 "KWOrder.hs" #-}
)
-- self rule
_copy =
({-# LINE 23 "./Patterns.ag" #-}
[]
{-# LINE 1019 "KWOrder.hs" #-}
)
-- self rule
_lhsOcopy =
({-# LINE 23 "./Patterns.ag" #-}
_copy
{-# LINE 1025 "KWOrder.hs" #-}
)
in ( _lhsOcopy,_lhsOvertices)) )
-- Production --------------------------------------------------
{-
visit 0:
chained attribute:
rulenumber : Int
synthesized attribute:
depgraph : ProdDependencyGraph
alternatives:
alternative Production:
child con : {ConstructorIdent}
child children : Children
child rules : Rules
child typeSigs : TypeSigs
visit 0:
local vertices : _
local edges : _
-}
-- cata
sem_Production :: Production ->
T_Production
sem_Production (Production _con _children _rules _typeSigs ) =
(sem_Production_Production _con (sem_Children _children ) (sem_Rules _rules ) (sem_TypeSigs _typeSigs ) )
-- semantic domain
newtype T_Production = T_Production (Int ->
( ProdDependencyGraph,Int))
data Inh_Production = Inh_Production {rulenumber_Inh_Production :: Int}
data Syn_Production = Syn_Production {depgraph_Syn_Production :: ProdDependencyGraph,rulenumber_Syn_Production :: Int}
wrap_Production :: T_Production ->
Inh_Production ->
Syn_Production
wrap_Production (T_Production sem ) (Inh_Production _lhsIrulenumber ) =
(let ( _lhsOdepgraph,_lhsOrulenumber) = sem _lhsIrulenumber
in (Syn_Production _lhsOdepgraph _lhsOrulenumber ))
sem_Production_Production :: ConstructorIdent ->
T_Children ->
T_Rules ->
T_TypeSigs ->
T_Production
sem_Production_Production con_ (T_Children children_ ) (T_Rules rules_ ) (T_TypeSigs typeSigs_ ) =
(T_Production (\ _lhsIrulenumber ->
(let _lhsOdepgraph :: ProdDependencyGraph
_lhsOrulenumber :: Int
_rulesOrulenumber :: Int
_childrenIedges :: (Set.Set Edge)
_childrenInontnames :: ([(Identifier, Identifier)])
_childrenIvertices :: (Set.Set Vertex)
_rulesIedges :: (Set.Set Edge)
_rulesIrulenumber :: Int
_rulesIvertices :: (Set.Set Vertex)
-- "KWOrder.ag"(line 90, column 17)
_vertices =
({-# LINE 90 "KWOrder.ag" #-}
_rulesIvertices `Set.union` _childrenIvertices
{-# LINE 1081 "KWOrder.hs" #-}
)
-- "KWOrder.ag"(line 110, column 17)
_edges =
({-# LINE 110 "KWOrder.ag" #-}
_rulesIedges `Set.union` _childrenIedges
{-# LINE 1087 "KWOrder.hs" #-}
)
-- "KWOrder.ag"(line 125, column 17)
_lhsOdepgraph =
({-# LINE 125 "KWOrder.ag" #-}
ProdDependencyGraph { pdgVertices = Set.toList _vertices
, pdgEdges = Set.toList _edges
, pdgProduction = con_
, pdgChildMap = _childrenInontnames }
{-# LINE 1096 "KWOrder.hs" #-}
)
-- copy rule (up)
_lhsOrulenumber =
({-# LINE 36 "KWOrder.ag" #-}
_rulesIrulenumber
{-# LINE 1102 "KWOrder.hs" #-}
)
-- copy rule (down)
_rulesOrulenumber =
({-# LINE 36 "KWOrder.ag" #-}
_lhsIrulenumber
{-# LINE 1108 "KWOrder.hs" #-}
)
( _childrenIedges,_childrenInontnames,_childrenIvertices) =
children_
( _rulesIedges,_rulesIrulenumber,_rulesIvertices) =
rules_ _rulesOrulenumber
in ( _lhsOdepgraph,_lhsOrulenumber))) )
-- Productions -------------------------------------------------
{-
visit 0:
chained attribute:
rulenumber : Int
synthesized attribute:
depgraph : [ProdDependencyGraph]
alternatives:
alternative Cons:
child hd : Production
child tl : Productions
alternative Nil:
-}
-- cata
sem_Productions :: Productions ->
T_Productions
sem_Productions list =
(Prelude.foldr sem_Productions_Cons sem_Productions_Nil (Prelude.map sem_Production list) )
-- semantic domain
newtype T_Productions = T_Productions (Int ->
( ([ProdDependencyGraph]),Int))
data Inh_Productions = Inh_Productions {rulenumber_Inh_Productions :: Int}
data Syn_Productions = Syn_Productions {depgraph_Syn_Productions :: ([ProdDependencyGraph]),rulenumber_Syn_Productions :: Int}
wrap_Productions :: T_Productions ->
Inh_Productions ->
Syn_Productions
wrap_Productions (T_Productions sem ) (Inh_Productions _lhsIrulenumber ) =
(let ( _lhsOdepgraph,_lhsOrulenumber) = sem _lhsIrulenumber
in (Syn_Productions _lhsOdepgraph _lhsOrulenumber ))
sem_Productions_Cons :: T_Production ->
T_Productions ->
T_Productions
sem_Productions_Cons (T_Production hd_ ) (T_Productions tl_ ) =
(T_Productions (\ _lhsIrulenumber ->
(let _lhsOdepgraph :: ([ProdDependencyGraph])
_lhsOrulenumber :: Int
_hdOrulenumber :: Int
_tlOrulenumber :: Int
_hdIdepgraph :: ProdDependencyGraph
_hdIrulenumber :: Int
_tlIdepgraph :: ([ProdDependencyGraph])
_tlIrulenumber :: Int
-- use rule "KWOrder.ag"(line 122, column 33)
_lhsOdepgraph =
({-# LINE 122 "KWOrder.ag" #-}
_hdIdepgraph : _tlIdepgraph
{-# LINE 1161 "KWOrder.hs" #-}
)
-- copy rule (up)
_lhsOrulenumber =
({-# LINE 36 "KWOrder.ag" #-}
_tlIrulenumber
{-# LINE 1167 "KWOrder.hs" #-}
)
-- copy rule (down)
_hdOrulenumber =
({-# LINE 36 "KWOrder.ag" #-}
_lhsIrulenumber
{-# LINE 1173 "KWOrder.hs" #-}
)
-- copy rule (chain)
_tlOrulenumber =
({-# LINE 36 "KWOrder.ag" #-}
_hdIrulenumber
{-# LINE 1179 "KWOrder.hs" #-}
)
( _hdIdepgraph,_hdIrulenumber) =
hd_ _hdOrulenumber
( _tlIdepgraph,_tlIrulenumber) =
tl_ _tlOrulenumber
in ( _lhsOdepgraph,_lhsOrulenumber))) )
sem_Productions_Nil :: T_Productions
sem_Productions_Nil =
(T_Productions (\ _lhsIrulenumber ->
(let _lhsOdepgraph :: ([ProdDependencyGraph])
_lhsOrulenumber :: Int
-- use rule "KWOrder.ag"(line 122, column 33)
_lhsOdepgraph =
({-# LINE 122 "KWOrder.ag" #-}
[]
{-# LINE 1195 "KWOrder.hs" #-}
)
-- copy rule (chain)
_lhsOrulenumber =
({-# LINE 36 "KWOrder.ag" #-}
_lhsIrulenumber
{-# LINE 1201 "KWOrder.hs" #-}
)
in ( _lhsOdepgraph,_lhsOrulenumber))) )
-- Rule --------------------------------------------------------
{-
visit 0:
chained attribute:
rulenumber : Int
synthesized attributes:
edges : Set.Set Edge
vertices : Set.Set Vertex
alternatives:
alternative Rule:
child mbName : {Maybe Identifier}
child pattern : Pattern
child rhs : Expression
child owrt : {Bool}
child origin : {String}
child explicit : {Bool}
visit 0:
local rulename : _
local vertex : _
local edgesout : _
local edgesin : _
-}
-- cata
sem_Rule :: Rule ->
T_Rule
sem_Rule (Rule _mbName _pattern _rhs _owrt _origin _explicit ) =
(sem_Rule_Rule _mbName (sem_Pattern _pattern ) (sem_Expression _rhs ) _owrt _origin _explicit )
-- semantic domain
newtype T_Rule = T_Rule (Int ->
( (Set.Set Edge),Int,(Set.Set Vertex)))
data Inh_Rule = Inh_Rule {rulenumber_Inh_Rule :: Int}
data Syn_Rule = Syn_Rule {edges_Syn_Rule :: (Set.Set Edge),rulenumber_Syn_Rule :: Int,vertices_Syn_Rule :: (Set.Set Vertex)}
wrap_Rule :: T_Rule ->
Inh_Rule ->
Syn_Rule
wrap_Rule (T_Rule sem ) (Inh_Rule _lhsIrulenumber ) =
(let ( _lhsOedges,_lhsOrulenumber,_lhsOvertices) = sem _lhsIrulenumber
in (Syn_Rule _lhsOedges _lhsOrulenumber _lhsOvertices ))
sem_Rule_Rule :: (Maybe Identifier) ->
T_Pattern ->
T_Expression ->
Bool ->
String ->
Bool ->
T_Rule
sem_Rule_Rule mbName_ (T_Pattern pattern_ ) (T_Expression rhs_ ) owrt_ origin_ explicit_ =
(T_Rule (\ _lhsIrulenumber ->
(let _lhsOrulenumber :: Int
_lhsOvertices :: (Set.Set Vertex)
_lhsOedges :: (Set.Set Edge)
_patternIcopy :: Pattern
_patternIvertices :: (Set.Set Vertex)
_rhsIvertices :: (Set.Set Vertex)
-- "KWOrder.ag"(line 42, column 11)
_lhsOrulenumber =
({-# LINE 42 "KWOrder.ag" #-}
_lhsIrulenumber + 1
{-# LINE 1261 "KWOrder.hs" #-}
)
-- "KWOrder.ag"(line 43, column 11)
_rulename =
({-# LINE 43 "KWOrder.ag" #-}
maybe (identifier $ "rule" ++ show _lhsIrulenumber) id mbName_
{-# LINE 1267 "KWOrder.hs" #-}
)
-- "KWOrder.ag"(line 85, column 11)
_vertex =
({-# LINE 85 "KWOrder.ag" #-}
VRule _rulename
{-# LINE 1273 "KWOrder.hs" #-}
)
-- "KWOrder.ag"(line 86, column 11)
_lhsOvertices =
({-# LINE 86 "KWOrder.ag" #-}
Set.insert _vertex $ _patternIvertices `Set.union` _rhsIvertices
{-# LINE 1279 "KWOrder.hs" #-}
)
-- "KWOrder.ag"(line 98, column 11)
_edgesout =
({-# LINE 98 "KWOrder.ag" #-}
map ((,) _vertex ) (Set.toList _rhsIvertices)
{-# LINE 1285 "KWOrder.hs" #-}
)
-- "KWOrder.ag"(line 99, column 11)
_edgesin =
({-# LINE 99 "KWOrder.ag" #-}
map (flip (,) _vertex ) (Set.toList _patternIvertices)
{-# LINE 1291 "KWOrder.hs" #-}
)
-- "KWOrder.ag"(line 100, column 11)
_lhsOedges =
({-# LINE 100 "KWOrder.ag" #-}
Set.fromList $ _edgesout ++ _edgesin
{-# LINE 1297 "KWOrder.hs" #-}
)
( _patternIcopy,_patternIvertices) =
pattern_
( _rhsIvertices) =
rhs_
in ( _lhsOedges,_lhsOrulenumber,_lhsOvertices))) )
-- Rules -------------------------------------------------------
{-
visit 0:
chained attribute:
rulenumber : Int
synthesized attributes:
edges : Set.Set Edge
vertices : Set.Set Vertex
alternatives:
alternative Cons:
child hd : Rule
child tl : Rules
alternative Nil:
-}
-- cata
sem_Rules :: Rules ->
T_Rules
sem_Rules list =
(Prelude.foldr sem_Rules_Cons sem_Rules_Nil (Prelude.map sem_Rule list) )
-- semantic domain
newtype T_Rules = T_Rules (Int ->
( (Set.Set Edge),Int,(Set.Set Vertex)))
data Inh_Rules = Inh_Rules {rulenumber_Inh_Rules :: Int}
data Syn_Rules = Syn_Rules {edges_Syn_Rules :: (Set.Set Edge),rulenumber_Syn_Rules :: Int,vertices_Syn_Rules :: (Set.Set Vertex)}
wrap_Rules :: T_Rules ->
Inh_Rules ->
Syn_Rules
wrap_Rules (T_Rules sem ) (Inh_Rules _lhsIrulenumber ) =
(let ( _lhsOedges,_lhsOrulenumber,_lhsOvertices) = sem _lhsIrulenumber
in (Syn_Rules _lhsOedges _lhsOrulenumber _lhsOvertices ))
sem_Rules_Cons :: T_Rule ->
T_Rules ->
T_Rules
sem_Rules_Cons (T_Rule hd_ ) (T_Rules tl_ ) =
(T_Rules (\ _lhsIrulenumber ->
(let _lhsOedges :: (Set.Set Edge)
_lhsOvertices :: (Set.Set Vertex)
_lhsOrulenumber :: Int
_hdOrulenumber :: Int
_tlOrulenumber :: Int
_hdIedges :: (Set.Set Edge)
_hdIrulenumber :: Int
_hdIvertices :: (Set.Set Vertex)
_tlIedges :: (Set.Set Edge)
_tlIrulenumber :: Int
_tlIvertices :: (Set.Set Vertex)
-- use rule "KWOrder.ag"(line 94, column 33)
_lhsOedges =
({-# LINE 94 "KWOrder.ag" #-}
_hdIedges `Set.union` _tlIedges
{-# LINE 1354 "KWOrder.hs" #-}
)
-- use rule "KWOrder.ag"(line 52, column 36)
_lhsOvertices =
({-# LINE 52 "KWOrder.ag" #-}
_hdIvertices `Set.union` _tlIvertices
{-# LINE 1360 "KWOrder.hs" #-}
)
-- copy rule (up)
_lhsOrulenumber =
({-# LINE 36 "KWOrder.ag" #-}
_tlIrulenumber
{-# LINE 1366 "KWOrder.hs" #-}
)
-- copy rule (down)
_hdOrulenumber =
({-# LINE 36 "KWOrder.ag" #-}
_lhsIrulenumber
{-# LINE 1372 "KWOrder.hs" #-}
)
-- copy rule (chain)
_tlOrulenumber =
({-# LINE 36 "KWOrder.ag" #-}
_hdIrulenumber
{-# LINE 1378 "KWOrder.hs" #-}
)
( _hdIedges,_hdIrulenumber,_hdIvertices) =
hd_ _hdOrulenumber
( _tlIedges,_tlIrulenumber,_tlIvertices) =
tl_ _tlOrulenumber
in ( _lhsOedges,_lhsOrulenumber,_lhsOvertices))) )
sem_Rules_Nil :: T_Rules
sem_Rules_Nil =
(T_Rules (\ _lhsIrulenumber ->
(let _lhsOedges :: (Set.Set Edge)
_lhsOvertices :: (Set.Set Vertex)
_lhsOrulenumber :: Int
-- use rule "KWOrder.ag"(line 94, column 33)
_lhsOedges =
({-# LINE 94 "KWOrder.ag" #-}
Set.empty
{-# LINE 1395 "KWOrder.hs" #-}
)
-- use rule "KWOrder.ag"(line 52, column 36)
_lhsOvertices =
({-# LINE 52 "KWOrder.ag" #-}
Set.empty
{-# LINE 1401 "KWOrder.hs" #-}
)
-- copy rule (chain)
_lhsOrulenumber =
({-# LINE 36 "KWOrder.ag" #-}
_lhsIrulenumber
{-# LINE 1407 "KWOrder.hs" #-}
)
in ( _lhsOedges,_lhsOrulenumber,_lhsOvertices))) )
-- TypeSig -----------------------------------------------------
{-
alternatives:
alternative TypeSig:
child name : {Identifier}
child tp : {Type}
-}
-- cata
sem_TypeSig :: TypeSig ->
T_TypeSig
sem_TypeSig (TypeSig _name _tp ) =
(sem_TypeSig_TypeSig _name _tp )
-- semantic domain
newtype T_TypeSig = T_TypeSig (( ))
data Inh_TypeSig = Inh_TypeSig {}
data Syn_TypeSig = Syn_TypeSig {}
wrap_TypeSig :: T_TypeSig ->
Inh_TypeSig ->
Syn_TypeSig
wrap_TypeSig (T_TypeSig sem ) (Inh_TypeSig ) =
(let ( ) = sem
in (Syn_TypeSig ))
sem_TypeSig_TypeSig :: Identifier ->
Type ->
T_TypeSig
sem_TypeSig_TypeSig name_ tp_ =
(T_TypeSig (let
in ( )) )
-- TypeSigs ----------------------------------------------------
{-
alternatives:
alternative Cons:
child hd : TypeSig
child tl : TypeSigs
alternative Nil:
-}
-- cata
sem_TypeSigs :: TypeSigs ->
T_TypeSigs
sem_TypeSigs list =
(Prelude.foldr sem_TypeSigs_Cons sem_TypeSigs_Nil (Prelude.map sem_TypeSig list) )
-- semantic domain
newtype T_TypeSigs = T_TypeSigs (( ))
data Inh_TypeSigs = Inh_TypeSigs {}
data Syn_TypeSigs = Syn_TypeSigs {}
wrap_TypeSigs :: T_TypeSigs ->
Inh_TypeSigs ->
Syn_TypeSigs
wrap_TypeSigs (T_TypeSigs sem ) (Inh_TypeSigs ) =
(let ( ) = sem
in (Syn_TypeSigs ))
sem_TypeSigs_Cons :: T_TypeSig ->
T_TypeSigs ->
T_TypeSigs
sem_TypeSigs_Cons (T_TypeSig hd_ ) (T_TypeSigs tl_ ) =
(T_TypeSigs (let
in ( )) )
sem_TypeSigs_Nil :: T_TypeSigs
sem_TypeSigs_Nil =
(T_TypeSigs (let
in ( )) )