uuagc-bootstrap-0.9.38.6.2: src-derived/KWOrder.hs
-- UUAGC 0.9.38.6 (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 ExecutionPlan
import Data.Maybe
import Debug.Trace
import qualified Data.Set as Set
import qualified Data.Map as Map
{-# LINE 22 "../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 32 "../src-derived/KWOrder.hs" #-}
{-# LINE 2 "./HsToken.ag" #-}
import CommonTypes
import UU.Scanner.Position(Pos)
{-# LINE 38 "../src-derived/KWOrder.hs" #-}
{-# LINE 2 "./Expression.ag" #-}
import UU.Scanner.Position(Pos)
import HsToken
{-# LINE 44 "../src-derived/KWOrder.hs" #-}
{-# LINE 2 "./Patterns.ag" #-}
-- Patterns.ag imports
import UU.Scanner.Position(Pos)
import CommonTypes (ConstructorIdent,Identifier)
{-# LINE 51 "../src-derived/KWOrder.hs" #-}
-- Child -------------------------------------------------------
{-
visit 0:
synthesized attributes:
echilds : EChild
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 (( EChild,(Set.Set Edge),([(Identifier, Identifier)]),(Set.Set Vertex)))
data Inh_Child = Inh_Child {}
data Syn_Child = Syn_Child {echilds_Syn_Child :: EChild,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 ( _lhsOechilds,_lhsOedges,_lhsOnontnames,_lhsOvertices) = sem
in (Syn_Child _lhsOechilds _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 _lhsOechilds :: EChild
_lhsOvertices :: (Set.Set Vertex)
_lhsOedges :: (Set.Set Edge)
_lhsOnontnames :: ([(Identifier, Identifier)])
-- "KWOrder.ag"(line 67, column 11)
_lhsOechilds =
({-# LINE 67 "KWOrder.ag" #-}
EChild name_ tp_ virtual_
{-# LINE 104 "KWOrder.hs" #-}
)
-- "KWOrder.ag"(line 100, column 12)
_vertex =
({-# LINE 100 "KWOrder.ag" #-}
VChild name_
{-# LINE 110 "KWOrder.hs" #-}
)
-- "KWOrder.ag"(line 101, column 12)
_synvertices =
({-# LINE 101 "KWOrder.ag" #-}
map (VAttr Syn name_) . Map.keys $ syn_
{-# LINE 116 "KWOrder.hs" #-}
)
-- "KWOrder.ag"(line 102, column 12)
_inhvertices =
({-# LINE 102 "KWOrder.ag" #-}
map (VAttr Inh name_) . Map.keys $ inh_
{-# LINE 122 "KWOrder.hs" #-}
)
-- "KWOrder.ag"(line 103, column 12)
_lhsOvertices =
({-# LINE 103 "KWOrder.ag" #-}
case tp_ of
NT _ _ -> Set.insert _vertex (Set.fromList $ _synvertices ++ _inhvertices )
_ -> Set.empty
{-# LINE 130 "KWOrder.hs" #-}
)
-- "KWOrder.ag"(line 128, column 12)
_edgesout =
({-# LINE 128 "KWOrder.ag" #-}
[]
{-# LINE 136 "KWOrder.hs" #-}
)
-- "KWOrder.ag"(line 129, column 12)
_edgesin =
({-# LINE 129 "KWOrder.ag" #-}
map (flip (,) _vertex ) _synvertices
{-# LINE 142 "KWOrder.hs" #-}
)
-- "KWOrder.ag"(line 130, column 12)
_lhsOedges =
({-# LINE 130 "KWOrder.ag" #-}
Set.fromList $ _edgesout ++ _edgesin
{-# LINE 148 "KWOrder.hs" #-}
)
-- "KWOrder.ag"(line 140, column 12)
_lhsOnontnames =
({-# LINE 140 "KWOrder.ag" #-}
case tp_ of
NT nont _ -> [(name_, nont)]
_ -> []
{-# LINE 156 "KWOrder.hs" #-}
)
in ( _lhsOechilds,_lhsOedges,_lhsOnontnames,_lhsOvertices)) )
-- Children ----------------------------------------------------
{-
visit 0:
synthesized attributes:
echilds : EChildren
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 (( EChildren,(Set.Set Edge),([(Identifier, Identifier)]),(Set.Set Vertex)))
data Inh_Children = Inh_Children {}
data Syn_Children = Syn_Children {echilds_Syn_Children :: EChildren,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 ( _lhsOechilds,_lhsOedges,_lhsOnontnames,_lhsOvertices) = sem
in (Syn_Children _lhsOechilds _lhsOedges _lhsOnontnames _lhsOvertices ))
sem_Children_Cons :: T_Child ->
T_Children ->
T_Children
sem_Children_Cons (T_Child hd_ ) (T_Children tl_ ) =
(T_Children (let _lhsOechilds :: EChildren
_lhsOedges :: (Set.Set Edge)
_lhsOnontnames :: ([(Identifier, Identifier)])
_lhsOvertices :: (Set.Set Vertex)
_hdIechilds :: EChild
_hdIedges :: (Set.Set Edge)
_hdInontnames :: ([(Identifier, Identifier)])
_hdIvertices :: (Set.Set Vertex)
_tlIechilds :: EChildren
_tlIedges :: (Set.Set Edge)
_tlInontnames :: ([(Identifier, Identifier)])
_tlIvertices :: (Set.Set Vertex)
-- use rule "KWOrder.ag"(line 64, column 29)
_lhsOechilds =
({-# LINE 64 "KWOrder.ag" #-}
_hdIechilds : _tlIechilds
{-# LINE 208 "KWOrder.hs" #-}
)
-- use rule "KWOrder.ag"(line 118, column 33)
_lhsOedges =
({-# LINE 118 "KWOrder.ag" #-}
_hdIedges `Set.union` _tlIedges
{-# LINE 214 "KWOrder.hs" #-}
)
-- use rule "KWOrder.ag"(line 137, column 37)
_lhsOnontnames =
({-# LINE 137 "KWOrder.ag" #-}
_hdInontnames ++ _tlInontnames
{-# LINE 220 "KWOrder.hs" #-}
)
-- use rule "KWOrder.ag"(line 76, column 36)
_lhsOvertices =
({-# LINE 76 "KWOrder.ag" #-}
_hdIvertices `Set.union` _tlIvertices
{-# LINE 226 "KWOrder.hs" #-}
)
( _hdIechilds,_hdIedges,_hdInontnames,_hdIvertices) =
hd_
( _tlIechilds,_tlIedges,_tlInontnames,_tlIvertices) =
tl_
in ( _lhsOechilds,_lhsOedges,_lhsOnontnames,_lhsOvertices)) )
sem_Children_Nil :: T_Children
sem_Children_Nil =
(T_Children (let _lhsOechilds :: EChildren
_lhsOedges :: (Set.Set Edge)
_lhsOnontnames :: ([(Identifier, Identifier)])
_lhsOvertices :: (Set.Set Vertex)
-- use rule "KWOrder.ag"(line 64, column 29)
_lhsOechilds =
({-# LINE 64 "KWOrder.ag" #-}
[]
{-# LINE 243 "KWOrder.hs" #-}
)
-- use rule "KWOrder.ag"(line 118, column 33)
_lhsOedges =
({-# LINE 118 "KWOrder.ag" #-}
Set.empty
{-# LINE 249 "KWOrder.hs" #-}
)
-- use rule "KWOrder.ag"(line 137, column 37)
_lhsOnontnames =
({-# LINE 137 "KWOrder.ag" #-}
[]
{-# LINE 255 "KWOrder.hs" #-}
)
-- use rule "KWOrder.ag"(line 76, column 36)
_lhsOvertices =
({-# LINE 76 "KWOrder.ag" #-}
Set.empty
{-# LINE 261 "KWOrder.hs" #-}
)
in ( _lhsOechilds,_lhsOedges,_lhsOnontnames,_lhsOvertices)) )
-- Expression --------------------------------------------------
{-
visit 0:
synthesized attributes:
copy : SELF
vertices : Set.Set Vertex
alternatives:
alternative Expression:
child pos : {Pos}
child tks : {[HsToken]}
visit 0:
local copy : _
-}
-- cata
sem_Expression :: Expression ->
T_Expression
sem_Expression (Expression _pos _tks ) =
(sem_Expression_Expression _pos _tks )
-- semantic domain
newtype T_Expression = T_Expression (( Expression ,(Set.Set Vertex)))
data Inh_Expression = Inh_Expression {}
data Syn_Expression = Syn_Expression {copy_Syn_Expression :: Expression ,vertices_Syn_Expression :: (Set.Set Vertex)}
wrap_Expression :: T_Expression ->
Inh_Expression ->
Syn_Expression
wrap_Expression (T_Expression sem ) (Inh_Expression ) =
(let ( _lhsOcopy,_lhsOvertices) = sem
in (Syn_Expression _lhsOcopy _lhsOvertices ))
sem_Expression_Expression :: Pos ->
([HsToken]) ->
T_Expression
sem_Expression_Expression pos_ tks_ =
(T_Expression (let _lhsOvertices :: (Set.Set Vertex)
_lhsOcopy :: Expression
-- "KWOrder.ag"(line 87, column 17)
_lhsOvertices =
({-# LINE 87 "KWOrder.ag" #-}
Set.unions $ map (\tok -> vertices_Syn_HsToken
(wrap_HsToken (sem_HsToken tok) Inh_HsToken)) tks_
{-# LINE 303 "KWOrder.hs" #-}
)
-- self rule
_copy =
({-# LINE 45 "KWOrder.ag" #-}
Expression pos_ tks_
{-# LINE 309 "KWOrder.hs" #-}
)
-- self rule
_lhsOcopy =
({-# LINE 45 "KWOrder.ag" #-}
_copy
{-# LINE 315 "KWOrder.hs" #-}
)
in ( _lhsOcopy,_lhsOvertices)) )
-- Grammar -----------------------------------------------------
{-
visit 0:
inherited attribute:
options : Options
synthesized attributes:
depgraphs : PP_Doc
inhmap : Map.Map NontermIdent Attributes
output : ExecutionPlan
synmap : Map.Map NontermIdent Attributes
visitgraph : 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,(Map.Map NontermIdent Attributes),ExecutionPlan,(Map.Map NontermIdent Attributes),PP_Doc))
data Inh_Grammar = Inh_Grammar {options_Inh_Grammar :: Options}
data Syn_Grammar = Syn_Grammar {depgraphs_Syn_Grammar :: PP_Doc,inhmap_Syn_Grammar :: (Map.Map NontermIdent Attributes),output_Syn_Grammar :: ExecutionPlan,synmap_Syn_Grammar :: (Map.Map NontermIdent Attributes),visitgraph_Syn_Grammar :: PP_Doc}
wrap_Grammar :: T_Grammar ->
Inh_Grammar ->
Syn_Grammar
wrap_Grammar (T_Grammar sem ) (Inh_Grammar _lhsIoptions ) =
(let ( _lhsOdepgraphs,_lhsOinhmap,_lhsOoutput,_lhsOsynmap,_lhsOvisitgraph) = sem _lhsIoptions
in (Syn_Grammar _lhsOdepgraphs _lhsOinhmap _lhsOoutput _lhsOsynmap _lhsOvisitgraph ))
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
_lhsOoutput :: ExecutionPlan
_lhsOdepgraphs :: PP_Doc
_lhsOvisitgraph :: PP_Doc
_lhsOinhmap :: (Map.Map NontermIdent Attributes)
_lhsOsynmap :: (Map.Map NontermIdent Attributes)
_nontsIdepinfo :: ([NontDependencyInformation])
_nontsIinhmap :: (Map.Map NontermIdent Attributes)
_nontsIrulenumber :: Int
_nontsIsynmap :: (Map.Map NontermIdent Attributes)
-- "KWOrder.ag"(line 36, column 14)
_nontsOrulenumber =
({-# LINE 36 "KWOrder.ag" #-}
0
{-# LINE 393 "KWOrder.hs" #-}
)
-- "KWOrder.ag"(line 191, column 15)
(Just (_lhsOoutput,_lhsOdepgraphs,_lhsOvisitgraph) ) =
({-# LINE 191 "KWOrder.ag" #-}
kennedyWarrenOrder wrappers_ _nontsIdepinfo typeSyns_ derivings_
{-# LINE 399 "KWOrder.hs" #-}
)
-- use rule "KWOrder.ag"(line 198, column 33)
_lhsOinhmap =
({-# LINE 198 "KWOrder.ag" #-}
_nontsIinhmap
{-# LINE 405 "KWOrder.hs" #-}
)
-- use rule "KWOrder.ag"(line 199, column 33)
_lhsOsynmap =
({-# LINE 199 "KWOrder.ag" #-}
_nontsIsynmap
{-# LINE 411 "KWOrder.hs" #-}
)
( _nontsIdepinfo,_nontsIinhmap,_nontsIrulenumber,_nontsIsynmap) =
nonts_ _nontsOrulenumber
in ( _lhsOdepgraphs,_lhsOinhmap,_lhsOoutput,_lhsOsynmap,_lhsOvisitgraph))) )
-- 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 81, column 14)
_lhsOvertices =
({-# LINE 81 "KWOrder.ag" #-}
Set.singleton $ VAttr (if field_ == _LHS then Inh
else if field_ == _LOC then Loc
else Syn) field_ attr_
{-# LINE 482 "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 80, column 14)
_lhsOvertices =
({-# LINE 80 "KWOrder.ag" #-}
Set.singleton $ VAttr Loc _LOC var_
{-# LINE 495 "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 76, column 36)
_lhsOvertices =
({-# LINE 76 "KWOrder.ag" #-}
Set.empty
{-# LINE 507 "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 76, column 36)
_lhsOvertices =
({-# LINE 76 "KWOrder.ag" #-}
Set.empty
{-# LINE 519 "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 76, column 36)
_lhsOvertices =
({-# LINE 76 "KWOrder.ag" #-}
Set.empty
{-# LINE 531 "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 76, column 36)
_lhsOvertices =
({-# LINE 76 "KWOrder.ag" #-}
Set.empty
{-# LINE 543 "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 attributes:
depinfo : NontDependencyInformation
inhmap : Map.Map NontermIdent Attributes
synmap : Map.Map NontermIdent Attributes
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,(Map.Map NontermIdent Attributes),Int,(Map.Map NontermIdent Attributes)))
data Inh_Nonterminal = Inh_Nonterminal {rulenumber_Inh_Nonterminal :: Int}
data Syn_Nonterminal = Syn_Nonterminal {depinfo_Syn_Nonterminal :: NontDependencyInformation,inhmap_Syn_Nonterminal :: (Map.Map NontermIdent Attributes),rulenumber_Syn_Nonterminal :: Int,synmap_Syn_Nonterminal :: (Map.Map NontermIdent Attributes)}
wrap_Nonterminal :: T_Nonterminal ->
Inh_Nonterminal ->
Syn_Nonterminal
wrap_Nonterminal (T_Nonterminal sem ) (Inh_Nonterminal _lhsIrulenumber ) =
(let ( _lhsOdepinfo,_lhsOinhmap,_lhsOrulenumber,_lhsOsynmap) = sem _lhsIrulenumber
in (Syn_Nonterminal _lhsOdepinfo _lhsOinhmap _lhsOrulenumber _lhsOsynmap ))
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
_lhsOinhmap :: (Map.Map NontermIdent Attributes)
_lhsOsynmap :: (Map.Map NontermIdent Attributes)
_lhsOrulenumber :: Int
_prodsOrulenumber :: Int
_prodsIdepgraph :: ([ProdDependencyGraph])
_prodsIrulenumber :: Int
-- "KWOrder.ag"(line 162, column 18)
_synvertices =
({-# LINE 162 "KWOrder.ag" #-}
map (VAttr Syn nt_) . Map.keys $ syn_
{-# LINE 664 "KWOrder.hs" #-}
)
-- "KWOrder.ag"(line 163, column 18)
_inhvertices =
({-# LINE 163 "KWOrder.ag" #-}
map (VAttr Inh nt_) . Map.keys $ inh_
{-# LINE 670 "KWOrder.hs" #-}
)
-- "KWOrder.ag"(line 164, column 18)
_vertices =
({-# LINE 164 "KWOrder.ag" #-}
_synvertices ++ _inhvertices
{-# LINE 676 "KWOrder.hs" #-}
)
-- "KWOrder.ag"(line 168, column 18)
_nontgraph =
({-# LINE 168 "KWOrder.ag" #-}
NontDependencyGraph { ndgVertices = _vertices
, ndgEdges = [] }
{-# LINE 683 "KWOrder.hs" #-}
)
-- "KWOrder.ag"(line 176, column 18)
_lhsOdepinfo =
({-# LINE 176 "KWOrder.ag" #-}
NontDependencyInformation { ndiNonterminal = nt_
, ndiParams = params_
, ndiInh = Map.keys inh_
, ndiSyn = Map.keys syn_
, ndiDepGraph = _nontgraph
, ndiProds = _prodsIdepgraph }
{-# LINE 694 "KWOrder.hs" #-}
)
-- "KWOrder.ag"(line 204, column 17)
_lhsOinhmap =
({-# LINE 204 "KWOrder.ag" #-}
Map.singleton nt_ inh_
{-# LINE 700 "KWOrder.hs" #-}
)
-- "KWOrder.ag"(line 205, column 17)
_lhsOsynmap =
({-# LINE 205 "KWOrder.ag" #-}
Map.singleton nt_ syn_
{-# LINE 706 "KWOrder.hs" #-}
)
-- copy rule (up)
_lhsOrulenumber =
({-# LINE 33 "KWOrder.ag" #-}
_prodsIrulenumber
{-# LINE 712 "KWOrder.hs" #-}
)
-- copy rule (down)
_prodsOrulenumber =
({-# LINE 33 "KWOrder.ag" #-}
_lhsIrulenumber
{-# LINE 718 "KWOrder.hs" #-}
)
( _prodsIdepgraph,_prodsIrulenumber) =
prods_ _prodsOrulenumber
in ( _lhsOdepinfo,_lhsOinhmap,_lhsOrulenumber,_lhsOsynmap))) )
-- Nonterminals ------------------------------------------------
{-
visit 0:
chained attribute:
rulenumber : Int
synthesized attributes:
depinfo : [NontDependencyInformation]
inhmap : Map.Map NontermIdent Attributes
synmap : Map.Map NontermIdent Attributes
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]),(Map.Map NontermIdent Attributes),Int,(Map.Map NontermIdent Attributes)))
data Inh_Nonterminals = Inh_Nonterminals {rulenumber_Inh_Nonterminals :: Int}
data Syn_Nonterminals = Syn_Nonterminals {depinfo_Syn_Nonterminals :: ([NontDependencyInformation]),inhmap_Syn_Nonterminals :: (Map.Map NontermIdent Attributes),rulenumber_Syn_Nonterminals :: Int,synmap_Syn_Nonterminals :: (Map.Map NontermIdent Attributes)}
wrap_Nonterminals :: T_Nonterminals ->
Inh_Nonterminals ->
Syn_Nonterminals
wrap_Nonterminals (T_Nonterminals sem ) (Inh_Nonterminals _lhsIrulenumber ) =
(let ( _lhsOdepinfo,_lhsOinhmap,_lhsOrulenumber,_lhsOsynmap) = sem _lhsIrulenumber
in (Syn_Nonterminals _lhsOdepinfo _lhsOinhmap _lhsOrulenumber _lhsOsynmap ))
sem_Nonterminals_Cons :: T_Nonterminal ->
T_Nonterminals ->
T_Nonterminals
sem_Nonterminals_Cons (T_Nonterminal hd_ ) (T_Nonterminals tl_ ) =
(T_Nonterminals (\ _lhsIrulenumber ->
(let _lhsOdepinfo :: ([NontDependencyInformation])
_lhsOinhmap :: (Map.Map NontermIdent Attributes)
_lhsOsynmap :: (Map.Map NontermIdent Attributes)
_lhsOrulenumber :: Int
_hdOrulenumber :: Int
_tlOrulenumber :: Int
_hdIdepinfo :: NontDependencyInformation
_hdIinhmap :: (Map.Map NontermIdent Attributes)
_hdIrulenumber :: Int
_hdIsynmap :: (Map.Map NontermIdent Attributes)
_tlIdepinfo :: ([NontDependencyInformation])
_tlIinhmap :: (Map.Map NontermIdent Attributes)
_tlIrulenumber :: Int
_tlIsynmap :: (Map.Map NontermIdent Attributes)
-- use rule "KWOrder.ag"(line 173, column 33)
_lhsOdepinfo =
({-# LINE 173 "KWOrder.ag" #-}
_hdIdepinfo : _tlIdepinfo
{-# LINE 777 "KWOrder.hs" #-}
)
-- use rule "KWOrder.ag"(line 198, column 33)
_lhsOinhmap =
({-# LINE 198 "KWOrder.ag" #-}
_hdIinhmap `Map.union` _tlIinhmap
{-# LINE 783 "KWOrder.hs" #-}
)
-- use rule "KWOrder.ag"(line 199, column 33)
_lhsOsynmap =
({-# LINE 199 "KWOrder.ag" #-}
_hdIsynmap `Map.union` _tlIsynmap
{-# LINE 789 "KWOrder.hs" #-}
)
-- copy rule (up)
_lhsOrulenumber =
({-# LINE 33 "KWOrder.ag" #-}
_tlIrulenumber
{-# LINE 795 "KWOrder.hs" #-}
)
-- copy rule (down)
_hdOrulenumber =
({-# LINE 33 "KWOrder.ag" #-}
_lhsIrulenumber
{-# LINE 801 "KWOrder.hs" #-}
)
-- copy rule (chain)
_tlOrulenumber =
({-# LINE 33 "KWOrder.ag" #-}
_hdIrulenumber
{-# LINE 807 "KWOrder.hs" #-}
)
( _hdIdepinfo,_hdIinhmap,_hdIrulenumber,_hdIsynmap) =
hd_ _hdOrulenumber
( _tlIdepinfo,_tlIinhmap,_tlIrulenumber,_tlIsynmap) =
tl_ _tlOrulenumber
in ( _lhsOdepinfo,_lhsOinhmap,_lhsOrulenumber,_lhsOsynmap))) )
sem_Nonterminals_Nil :: T_Nonterminals
sem_Nonterminals_Nil =
(T_Nonterminals (\ _lhsIrulenumber ->
(let _lhsOdepinfo :: ([NontDependencyInformation])
_lhsOinhmap :: (Map.Map NontermIdent Attributes)
_lhsOsynmap :: (Map.Map NontermIdent Attributes)
_lhsOrulenumber :: Int
-- use rule "KWOrder.ag"(line 173, column 33)
_lhsOdepinfo =
({-# LINE 173 "KWOrder.ag" #-}
[]
{-# LINE 825 "KWOrder.hs" #-}
)
-- use rule "KWOrder.ag"(line 198, column 33)
_lhsOinhmap =
({-# LINE 198 "KWOrder.ag" #-}
Map.empty
{-# LINE 831 "KWOrder.hs" #-}
)
-- use rule "KWOrder.ag"(line 199, column 33)
_lhsOsynmap =
({-# LINE 199 "KWOrder.ag" #-}
Map.empty
{-# LINE 837 "KWOrder.hs" #-}
)
-- copy rule (chain)
_lhsOrulenumber =
({-# LINE 33 "KWOrder.ag" #-}
_lhsIrulenumber
{-# LINE 843 "KWOrder.hs" #-}
)
in ( _lhsOdepinfo,_lhsOinhmap,_lhsOrulenumber,_lhsOsynmap))) )
-- 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 92, column 12)
_vertex =
({-# LINE 92 "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 922 "KWOrder.hs" #-}
)
-- "KWOrder.ag"(line 96, column 12)
_lhsOvertices =
({-# LINE 96 "KWOrder.ag" #-}
Set.insert _vertex $ _partsIvertices `Set.union` _patIvertices
{-# LINE 928 "KWOrder.hs" #-}
)
-- self rule
_copy =
({-# LINE 23 "./Patterns.ag" #-}
Alias field_ attr_ _patIcopy _partsIcopy
{-# LINE 934 "KWOrder.hs" #-}
)
-- self rule
_lhsOcopy =
({-# LINE 23 "./Patterns.ag" #-}
_copy
{-# LINE 940 "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 76, column 36)
_lhsOvertices =
({-# LINE 76 "KWOrder.ag" #-}
_patsIvertices
{-# LINE 959 "KWOrder.hs" #-}
)
-- self rule
_copy =
({-# LINE 23 "./Patterns.ag" #-}
Constr name_ _patsIcopy
{-# LINE 965 "KWOrder.hs" #-}
)
-- self rule
_lhsOcopy =
({-# LINE 23 "./Patterns.ag" #-}
_copy
{-# LINE 971 "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 76, column 36)
_lhsOvertices =
({-# LINE 76 "KWOrder.ag" #-}
_patIvertices
{-# LINE 987 "KWOrder.hs" #-}
)
-- self rule
_copy =
({-# LINE 23 "./Patterns.ag" #-}
Irrefutable _patIcopy
{-# LINE 993 "KWOrder.hs" #-}
)
-- self rule
_lhsOcopy =
({-# LINE 23 "./Patterns.ag" #-}
_copy
{-# LINE 999 "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 76, column 36)
_lhsOvertices =
({-# LINE 76 "KWOrder.ag" #-}
_patsIvertices
{-# LINE 1016 "KWOrder.hs" #-}
)
-- self rule
_copy =
({-# LINE 23 "./Patterns.ag" #-}
Product pos_ _patsIcopy
{-# LINE 1022 "KWOrder.hs" #-}
)
-- self rule
_lhsOcopy =
({-# LINE 23 "./Patterns.ag" #-}
_copy
{-# LINE 1028 "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 76, column 36)
_lhsOvertices =
({-# LINE 76 "KWOrder.ag" #-}
Set.empty
{-# LINE 1042 "KWOrder.hs" #-}
)
-- self rule
_copy =
({-# LINE 23 "./Patterns.ag" #-}
Underscore pos_
{-# LINE 1048 "KWOrder.hs" #-}
)
-- self rule
_lhsOcopy =
({-# LINE 23 "./Patterns.ag" #-}
_copy
{-# LINE 1054 "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 76, column 36)
_lhsOvertices =
({-# LINE 76 "KWOrder.ag" #-}
_hdIvertices `Set.union` _tlIvertices
{-# LINE 1102 "KWOrder.hs" #-}
)
-- self rule
_copy =
({-# LINE 23 "./Patterns.ag" #-}
(:) _hdIcopy _tlIcopy
{-# LINE 1108 "KWOrder.hs" #-}
)
-- self rule
_lhsOcopy =
({-# LINE 23 "./Patterns.ag" #-}
_copy
{-# LINE 1114 "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 76, column 36)
_lhsOvertices =
({-# LINE 76 "KWOrder.ag" #-}
Set.empty
{-# LINE 1129 "KWOrder.hs" #-}
)
-- self rule
_copy =
({-# LINE 23 "./Patterns.ag" #-}
[]
{-# LINE 1135 "KWOrder.hs" #-}
)
-- self rule
_lhsOcopy =
({-# LINE 23 "./Patterns.ag" #-}
_copy
{-# LINE 1141 "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
_childrenIechilds :: EChildren
_childrenIedges :: (Set.Set Edge)
_childrenInontnames :: ([(Identifier, Identifier)])
_childrenIvertices :: (Set.Set Vertex)
_rulesIedges :: (Set.Set Edge)
_rulesIerules :: ERules
_rulesIrulenumber :: Int
_rulesIvertices :: (Set.Set Vertex)
-- "KWOrder.ag"(line 114, column 17)
_vertices =
({-# LINE 114 "KWOrder.ag" #-}
_rulesIvertices `Set.union` _childrenIvertices
{-# LINE 1199 "KWOrder.hs" #-}
)
-- "KWOrder.ag"(line 134, column 17)
_edges =
({-# LINE 134 "KWOrder.ag" #-}
_rulesIedges `Set.union` _childrenIedges
{-# LINE 1205 "KWOrder.hs" #-}
)
-- "KWOrder.ag"(line 149, column 17)
_lhsOdepgraph =
({-# LINE 149 "KWOrder.ag" #-}
ProdDependencyGraph { pdgVertices = Set.toList _vertices
, pdgEdges = Set.toList _edges
, pdgRules = _rulesIerules
, pdgChilds = _childrenIechilds
, pdgProduction = con_
, pdgChildMap = _childrenInontnames }
{-# LINE 1216 "KWOrder.hs" #-}
)
-- copy rule (up)
_lhsOrulenumber =
({-# LINE 33 "KWOrder.ag" #-}
_rulesIrulenumber
{-# LINE 1222 "KWOrder.hs" #-}
)
-- copy rule (down)
_rulesOrulenumber =
({-# LINE 33 "KWOrder.ag" #-}
_lhsIrulenumber
{-# LINE 1228 "KWOrder.hs" #-}
)
( _childrenIechilds,_childrenIedges,_childrenInontnames,_childrenIvertices) =
children_
( _rulesIedges,_rulesIerules,_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 146, column 33)
_lhsOdepgraph =
({-# LINE 146 "KWOrder.ag" #-}
_hdIdepgraph : _tlIdepgraph
{-# LINE 1281 "KWOrder.hs" #-}
)
-- copy rule (up)
_lhsOrulenumber =
({-# LINE 33 "KWOrder.ag" #-}
_tlIrulenumber
{-# LINE 1287 "KWOrder.hs" #-}
)
-- copy rule (down)
_hdOrulenumber =
({-# LINE 33 "KWOrder.ag" #-}
_lhsIrulenumber
{-# LINE 1293 "KWOrder.hs" #-}
)
-- copy rule (chain)
_tlOrulenumber =
({-# LINE 33 "KWOrder.ag" #-}
_hdIrulenumber
{-# LINE 1299 "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 146, column 33)
_lhsOdepgraph =
({-# LINE 146 "KWOrder.ag" #-}
[]
{-# LINE 1315 "KWOrder.hs" #-}
)
-- copy rule (chain)
_lhsOrulenumber =
({-# LINE 33 "KWOrder.ag" #-}
_lhsIrulenumber
{-# LINE 1321 "KWOrder.hs" #-}
)
in ( _lhsOdepgraph,_lhsOrulenumber))) )
-- Rule --------------------------------------------------------
{-
visit 0:
chained attribute:
rulenumber : Int
synthesized attributes:
edges : Set.Set Edge
erules : ERule
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),ERule,Int,(Set.Set Vertex)))
data Inh_Rule = Inh_Rule {rulenumber_Inh_Rule :: Int}
data Syn_Rule = Syn_Rule {edges_Syn_Rule :: (Set.Set Edge),erules_Syn_Rule :: ERule,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,_lhsOerules,_lhsOrulenumber,_lhsOvertices) = sem _lhsIrulenumber
in (Syn_Rule _lhsOedges _lhsOerules _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
_lhsOerules :: ERule
_lhsOvertices :: (Set.Set Vertex)
_lhsOedges :: (Set.Set Edge)
_patternIcopy :: Pattern
_patternIvertices :: (Set.Set Vertex)
_rhsIcopy :: Expression
_rhsIvertices :: (Set.Set Vertex)
-- "KWOrder.ag"(line 39, column 11)
_lhsOrulenumber =
({-# LINE 39 "KWOrder.ag" #-}
_lhsIrulenumber + 1
{-# LINE 1384 "KWOrder.hs" #-}
)
-- "KWOrder.ag"(line 40, column 11)
_rulename =
({-# LINE 40 "KWOrder.ag" #-}
maybe (identifier $ "rule" ++ show _lhsIrulenumber) id mbName_
{-# LINE 1390 "KWOrder.hs" #-}
)
-- "KWOrder.ag"(line 51, column 10)
_lhsOerules =
({-# LINE 51 "KWOrder.ag" #-}
ERule _rulename
_patternIcopy
_rhsIcopy
owrt_
origin_
explicit_
{-# LINE 1401 "KWOrder.hs" #-}
)
-- "KWOrder.ag"(line 109, column 11)
_vertex =
({-# LINE 109 "KWOrder.ag" #-}
VRule _rulename
{-# LINE 1407 "KWOrder.hs" #-}
)
-- "KWOrder.ag"(line 110, column 11)
_lhsOvertices =
({-# LINE 110 "KWOrder.ag" #-}
Set.insert _vertex $ _patternIvertices `Set.union` _rhsIvertices
{-# LINE 1413 "KWOrder.hs" #-}
)
-- "KWOrder.ag"(line 122, column 11)
_edgesout =
({-# LINE 122 "KWOrder.ag" #-}
map ((,) _vertex ) (Set.toList _rhsIvertices)
{-# LINE 1419 "KWOrder.hs" #-}
)
-- "KWOrder.ag"(line 123, column 11)
_edgesin =
({-# LINE 123 "KWOrder.ag" #-}
map (flip (,) _vertex ) (Set.toList _patternIvertices)
{-# LINE 1425 "KWOrder.hs" #-}
)
-- "KWOrder.ag"(line 124, column 11)
_lhsOedges =
({-# LINE 124 "KWOrder.ag" #-}
Set.fromList $ _edgesout ++ _edgesin
{-# LINE 1431 "KWOrder.hs" #-}
)
( _patternIcopy,_patternIvertices) =
pattern_
( _rhsIcopy,_rhsIvertices) =
rhs_
in ( _lhsOedges,_lhsOerules,_lhsOrulenumber,_lhsOvertices))) )
-- Rules -------------------------------------------------------
{-
visit 0:
chained attribute:
rulenumber : Int
synthesized attributes:
edges : Set.Set Edge
erules : ERules
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),ERules,Int,(Set.Set Vertex)))
data Inh_Rules = Inh_Rules {rulenumber_Inh_Rules :: Int}
data Syn_Rules = Syn_Rules {edges_Syn_Rules :: (Set.Set Edge),erules_Syn_Rules :: ERules,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,_lhsOerules,_lhsOrulenumber,_lhsOvertices) = sem _lhsIrulenumber
in (Syn_Rules _lhsOedges _lhsOerules _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)
_lhsOerules :: ERules
_lhsOvertices :: (Set.Set Vertex)
_lhsOrulenumber :: Int
_hdOrulenumber :: Int
_tlOrulenumber :: Int
_hdIedges :: (Set.Set Edge)
_hdIerules :: ERule
_hdIrulenumber :: Int
_hdIvertices :: (Set.Set Vertex)
_tlIedges :: (Set.Set Edge)
_tlIerules :: ERules
_tlIrulenumber :: Int
_tlIvertices :: (Set.Set Vertex)
-- use rule "KWOrder.ag"(line 118, column 33)
_lhsOedges =
({-# LINE 118 "KWOrder.ag" #-}
_hdIedges `Set.union` _tlIedges
{-# LINE 1492 "KWOrder.hs" #-}
)
-- use rule "KWOrder.ag"(line 48, column 25)
_lhsOerules =
({-# LINE 48 "KWOrder.ag" #-}
_hdIerules : _tlIerules
{-# LINE 1498 "KWOrder.hs" #-}
)
-- use rule "KWOrder.ag"(line 76, column 36)
_lhsOvertices =
({-# LINE 76 "KWOrder.ag" #-}
_hdIvertices `Set.union` _tlIvertices
{-# LINE 1504 "KWOrder.hs" #-}
)
-- copy rule (up)
_lhsOrulenumber =
({-# LINE 33 "KWOrder.ag" #-}
_tlIrulenumber
{-# LINE 1510 "KWOrder.hs" #-}
)
-- copy rule (down)
_hdOrulenumber =
({-# LINE 33 "KWOrder.ag" #-}
_lhsIrulenumber
{-# LINE 1516 "KWOrder.hs" #-}
)
-- copy rule (chain)
_tlOrulenumber =
({-# LINE 33 "KWOrder.ag" #-}
_hdIrulenumber
{-# LINE 1522 "KWOrder.hs" #-}
)
( _hdIedges,_hdIerules,_hdIrulenumber,_hdIvertices) =
hd_ _hdOrulenumber
( _tlIedges,_tlIerules,_tlIrulenumber,_tlIvertices) =
tl_ _tlOrulenumber
in ( _lhsOedges,_lhsOerules,_lhsOrulenumber,_lhsOvertices))) )
sem_Rules_Nil :: T_Rules
sem_Rules_Nil =
(T_Rules (\ _lhsIrulenumber ->
(let _lhsOedges :: (Set.Set Edge)
_lhsOerules :: ERules
_lhsOvertices :: (Set.Set Vertex)
_lhsOrulenumber :: Int
-- use rule "KWOrder.ag"(line 118, column 33)
_lhsOedges =
({-# LINE 118 "KWOrder.ag" #-}
Set.empty
{-# LINE 1540 "KWOrder.hs" #-}
)
-- use rule "KWOrder.ag"(line 48, column 25)
_lhsOerules =
({-# LINE 48 "KWOrder.ag" #-}
[]
{-# LINE 1546 "KWOrder.hs" #-}
)
-- use rule "KWOrder.ag"(line 76, column 36)
_lhsOvertices =
({-# LINE 76 "KWOrder.ag" #-}
Set.empty
{-# LINE 1552 "KWOrder.hs" #-}
)
-- copy rule (chain)
_lhsOrulenumber =
({-# LINE 33 "KWOrder.ag" #-}
_lhsIrulenumber
{-# LINE 1558 "KWOrder.hs" #-}
)
in ( _lhsOedges,_lhsOerules,_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 ( )) )