uuagc-0.9.23: src-derived/CodeSyntaxDump.hs
-- UUAGC 0.9.22 (CodeSyntaxDump.ag)
module CodeSyntaxDump where
{-# LINE 5 "CodeSyntaxDump.ag" #-}
import Data.List
import qualified Data.Map as Map
import Pretty
import PPUtil
import CodeSyntax
{-# LINE 15 "../src-derived/CodeSyntaxDump.hs" #-}
{-# LINE 2 "./CodeSyntax.ag" #-}
import Patterns
import CommonTypes
import Data.Map(Map)
import Data.Set(Set)
{-# LINE 23 "../src-derived/CodeSyntaxDump.hs" #-}
{-# LINE 2 "./Patterns.ag" #-}
-- Patterns.ag imports
import UU.Scanner.Position(Pos)
import CommonTypes (ConstructorIdent,Identifier)
{-# LINE 30 "../src-derived/CodeSyntaxDump.hs" #-}
{-# LINE 15 "CodeSyntaxDump.ag" #-}
ppChild :: (Identifier,Type,Bool) -> PP_Doc
ppChild (nm,tp,b)
= pp nm >#< "::" >#< pp (show tp) >#< "<" >|< ppBool b >|< ">"
ppVertexMap :: Map Int (Identifier,Identifier,Maybe Type) -> PP_Doc
ppVertexMap m
= ppVList [ ppF (show k) $ ppAttr v | (k,v) <- Map.toList m ]
ppAttr :: (Identifier,Identifier,Maybe Type) -> PP_Doc
ppAttr (fld,nm,mTp)
= pp fld >|< "." >|< pp nm >#<
case mTp of
Just tp -> pp "::" >#< show tp
Nothing -> empty
ppBool :: Bool -> PP_Doc
ppBool True = pp "T"
ppBool False = pp "F"
ppMaybeShow :: Show a => Maybe a -> PP_Doc
ppMaybeShow (Just x) = pp (show x)
ppMaybeShow Nothing = pp "_"
ppStrings :: [String] -> PP_Doc
ppStrings = vlist
{-# LINE 58 "../src-derived/CodeSyntaxDump.hs" #-}
-- CGrammar ----------------------------------------------------
{-
visit 0:
synthesized attribute:
pp : PP_Doc
alternatives:
alternative CGrammar:
child typeSyns : {TypeSyns}
child derivings : {Derivings}
child wrappers : {Set NontermIdent}
child nonts : CNonterminals
child pragmas : {PragmaMap}
child paramMap : {ParamMap}
child contextMap : {ContextMap}
child aroundsMap : {Map NontermIdent (Map ConstructorIdent (Set Identifier))}
-}
-- cata
sem_CGrammar :: CGrammar ->
T_CGrammar
sem_CGrammar (CGrammar _typeSyns _derivings _wrappers _nonts _pragmas _paramMap _contextMap _aroundsMap ) =
(sem_CGrammar_CGrammar _typeSyns _derivings _wrappers (sem_CNonterminals _nonts ) _pragmas _paramMap _contextMap _aroundsMap )
-- semantic domain
newtype T_CGrammar = T_CGrammar (( PP_Doc))
data Inh_CGrammar = Inh_CGrammar {}
data Syn_CGrammar = Syn_CGrammar {pp_Syn_CGrammar :: PP_Doc}
wrap_CGrammar :: T_CGrammar ->
Inh_CGrammar ->
Syn_CGrammar
wrap_CGrammar (T_CGrammar sem ) (Inh_CGrammar ) =
(let ( _lhsOpp) =
(sem )
in (Syn_CGrammar _lhsOpp ))
sem_CGrammar_CGrammar :: TypeSyns ->
Derivings ->
(Set NontermIdent) ->
T_CNonterminals ->
PragmaMap ->
ParamMap ->
ContextMap ->
(Map NontermIdent (Map ConstructorIdent (Set Identifier))) ->
T_CGrammar
sem_CGrammar_CGrammar typeSyns_ derivings_ wrappers_ (T_CNonterminals nonts_ ) pragmas_ paramMap_ contextMap_ aroundsMap_ =
(T_CGrammar (let _lhsOpp :: PP_Doc
_nontsIpp :: PP_Doc
_nontsIppL :: ([PP_Doc])
-- "CodeSyntaxDump.ag"(line 47, column 21)
_lhsOpp =
({-# LINE 47 "CodeSyntaxDump.ag" #-}
ppNestInfo ["CGrammar","CGrammar"] []
[ ppF "typeSyns" $ ppAssocL typeSyns_
, ppF "derivings" $ ppMap $ derivings_
, ppF "nonts" $ ppVList _nontsIppL
] []
{-# LINE 112 "CodeSyntaxDump.hs" #-})
( _nontsIpp,_nontsIppL) =
(nonts_ )
in ( _lhsOpp)) )
-- CInterface --------------------------------------------------
{-
visit 0:
synthesized attribute:
pp : PP_Doc
alternatives:
alternative CInterface:
child seg : CSegments
-}
-- cata
sem_CInterface :: CInterface ->
T_CInterface
sem_CInterface (CInterface _seg ) =
(sem_CInterface_CInterface (sem_CSegments _seg ) )
-- semantic domain
newtype T_CInterface = T_CInterface (( PP_Doc))
data Inh_CInterface = Inh_CInterface {}
data Syn_CInterface = Syn_CInterface {pp_Syn_CInterface :: PP_Doc}
wrap_CInterface :: T_CInterface ->
Inh_CInterface ->
Syn_CInterface
wrap_CInterface (T_CInterface sem ) (Inh_CInterface ) =
(let ( _lhsOpp) =
(sem )
in (Syn_CInterface _lhsOpp ))
sem_CInterface_CInterface :: T_CSegments ->
T_CInterface
sem_CInterface_CInterface (T_CSegments seg_ ) =
(T_CInterface (let _lhsOpp :: PP_Doc
_segIpp :: PP_Doc
_segIppL :: ([PP_Doc])
-- "CodeSyntaxDump.ag"(line 57, column 21)
_lhsOpp =
({-# LINE 57 "CodeSyntaxDump.ag" #-}
ppNestInfo ["CInterface","CInterface"] [] [ppF "seg" $ ppVList _segIppL] []
{-# LINE 151 "CodeSyntaxDump.hs" #-})
( _segIpp,_segIppL) =
(seg_ )
in ( _lhsOpp)) )
-- CNonterminal ------------------------------------------------
{-
visit 0:
synthesized attribute:
pp : PP_Doc
alternatives:
alternative CNonterminal:
child nt : {NontermIdent}
child params : {[Identifier]}
child inh : {Attributes}
child syn : {Attributes}
child prods : CProductions
child inter : CInterface
-}
-- cata
sem_CNonterminal :: CNonterminal ->
T_CNonterminal
sem_CNonterminal (CNonterminal _nt _params _inh _syn _prods _inter ) =
(sem_CNonterminal_CNonterminal _nt _params _inh _syn (sem_CProductions _prods ) (sem_CInterface _inter ) )
-- semantic domain
newtype T_CNonterminal = T_CNonterminal (( PP_Doc))
data Inh_CNonterminal = Inh_CNonterminal {}
data Syn_CNonterminal = Syn_CNonterminal {pp_Syn_CNonterminal :: PP_Doc}
wrap_CNonterminal :: T_CNonterminal ->
Inh_CNonterminal ->
Syn_CNonterminal
wrap_CNonterminal (T_CNonterminal sem ) (Inh_CNonterminal ) =
(let ( _lhsOpp) =
(sem )
in (Syn_CNonterminal _lhsOpp ))
sem_CNonterminal_CNonterminal :: NontermIdent ->
([Identifier]) ->
Attributes ->
Attributes ->
T_CProductions ->
T_CInterface ->
T_CNonterminal
sem_CNonterminal_CNonterminal nt_ params_ inh_ syn_ (T_CProductions prods_ ) (T_CInterface inter_ ) =
(T_CNonterminal (let _lhsOpp :: PP_Doc
_prodsIpp :: PP_Doc
_prodsIppL :: ([PP_Doc])
_interIpp :: PP_Doc
-- "CodeSyntaxDump.ag"(line 54, column 33)
_lhsOpp =
({-# LINE 54 "CodeSyntaxDump.ag" #-}
ppNestInfo ["CNonterminal","CNonterminal"] (pp nt_ : map pp params_) [ppF "inh" $ ppMap inh_, ppF "syn" $ ppMap syn_, ppF "prods" $ ppVList _prodsIppL, ppF "inter" _interIpp] []
{-# LINE 201 "CodeSyntaxDump.hs" #-})
( _prodsIpp,_prodsIppL) =
(prods_ )
( _interIpp) =
(inter_ )
in ( _lhsOpp)) )
-- CNonterminals -----------------------------------------------
{-
visit 0:
synthesized attributes:
pp : PP_Doc
ppL : [PP_Doc]
alternatives:
alternative Cons:
child hd : CNonterminal
child tl : CNonterminals
alternative Nil:
-}
-- cata
sem_CNonterminals :: CNonterminals ->
T_CNonterminals
sem_CNonterminals list =
(Prelude.foldr sem_CNonterminals_Cons sem_CNonterminals_Nil (Prelude.map sem_CNonterminal list) )
-- semantic domain
newtype T_CNonterminals = T_CNonterminals (( PP_Doc,([PP_Doc])))
data Inh_CNonterminals = Inh_CNonterminals {}
data Syn_CNonterminals = Syn_CNonterminals {pp_Syn_CNonterminals :: PP_Doc,ppL_Syn_CNonterminals :: ([PP_Doc])}
wrap_CNonterminals :: T_CNonterminals ->
Inh_CNonterminals ->
Syn_CNonterminals
wrap_CNonterminals (T_CNonterminals sem ) (Inh_CNonterminals ) =
(let ( _lhsOpp,_lhsOppL) =
(sem )
in (Syn_CNonterminals _lhsOpp _lhsOppL ))
sem_CNonterminals_Cons :: T_CNonterminal ->
T_CNonterminals ->
T_CNonterminals
sem_CNonterminals_Cons (T_CNonterminal hd_ ) (T_CNonterminals tl_ ) =
(T_CNonterminals (let _lhsOppL :: ([PP_Doc])
_lhsOpp :: PP_Doc
_hdIpp :: PP_Doc
_tlIpp :: PP_Doc
_tlIppL :: ([PP_Doc])
-- "CodeSyntaxDump.ag"(line 102, column 33)
_lhsOppL =
({-# LINE 102 "CodeSyntaxDump.ag" #-}
_hdIpp : _tlIppL
{-# LINE 248 "CodeSyntaxDump.hs" #-})
-- use rule "CodeSyntaxDump.ag"(line 44, column 40)
_lhsOpp =
({-# LINE 44 "CodeSyntaxDump.ag" #-}
_hdIpp >-< _tlIpp
{-# LINE 253 "CodeSyntaxDump.hs" #-})
( _hdIpp) =
(hd_ )
( _tlIpp,_tlIppL) =
(tl_ )
in ( _lhsOpp,_lhsOppL)) )
sem_CNonterminals_Nil :: T_CNonterminals
sem_CNonterminals_Nil =
(T_CNonterminals (let _lhsOppL :: ([PP_Doc])
_lhsOpp :: PP_Doc
-- "CodeSyntaxDump.ag"(line 103, column 33)
_lhsOppL =
({-# LINE 103 "CodeSyntaxDump.ag" #-}
[]
{-# LINE 267 "CodeSyntaxDump.hs" #-})
-- use rule "CodeSyntaxDump.ag"(line 44, column 40)
_lhsOpp =
({-# LINE 44 "CodeSyntaxDump.ag" #-}
empty
{-# LINE 272 "CodeSyntaxDump.hs" #-})
in ( _lhsOpp,_lhsOppL)) )
-- CProduction -------------------------------------------------
{-
visit 0:
synthesized attribute:
pp : PP_Doc
alternatives:
alternative CProduction:
child con : {ConstructorIdent}
child visits : CVisits
child children : {[(Identifier,Type,Bool)]}
child terminals : {[Identifier]}
-}
-- cata
sem_CProduction :: CProduction ->
T_CProduction
sem_CProduction (CProduction _con _visits _children _terminals ) =
(sem_CProduction_CProduction _con (sem_CVisits _visits ) _children _terminals )
-- semantic domain
newtype T_CProduction = T_CProduction (( PP_Doc))
data Inh_CProduction = Inh_CProduction {}
data Syn_CProduction = Syn_CProduction {pp_Syn_CProduction :: PP_Doc}
wrap_CProduction :: T_CProduction ->
Inh_CProduction ->
Syn_CProduction
wrap_CProduction (T_CProduction sem ) (Inh_CProduction ) =
(let ( _lhsOpp) =
(sem )
in (Syn_CProduction _lhsOpp ))
sem_CProduction_CProduction :: ConstructorIdent ->
T_CVisits ->
([(Identifier,Type,Bool)]) ->
([Identifier]) ->
T_CProduction
sem_CProduction_CProduction con_ (T_CVisits visits_ ) children_ terminals_ =
(T_CProduction (let _lhsOpp :: PP_Doc
_visitsIpp :: PP_Doc
_visitsIppL :: ([PP_Doc])
-- "CodeSyntaxDump.ag"(line 63, column 17)
_lhsOpp =
({-# LINE 63 "CodeSyntaxDump.ag" #-}
ppNestInfo ["CProduction","CProduction"] [pp con_] [ppF "visits" $ ppVList _visitsIppL, ppF "children" $ ppVList (map ppChild children_),ppF "terminals" $ ppVList (map ppShow terminals_)] []
{-# LINE 315 "CodeSyntaxDump.hs" #-})
( _visitsIpp,_visitsIppL) =
(visits_ )
in ( _lhsOpp)) )
-- CProductions ------------------------------------------------
{-
visit 0:
synthesized attributes:
pp : PP_Doc
ppL : [PP_Doc]
alternatives:
alternative Cons:
child hd : CProduction
child tl : CProductions
alternative Nil:
-}
-- cata
sem_CProductions :: CProductions ->
T_CProductions
sem_CProductions list =
(Prelude.foldr sem_CProductions_Cons sem_CProductions_Nil (Prelude.map sem_CProduction list) )
-- semantic domain
newtype T_CProductions = T_CProductions (( PP_Doc,([PP_Doc])))
data Inh_CProductions = Inh_CProductions {}
data Syn_CProductions = Syn_CProductions {pp_Syn_CProductions :: PP_Doc,ppL_Syn_CProductions :: ([PP_Doc])}
wrap_CProductions :: T_CProductions ->
Inh_CProductions ->
Syn_CProductions
wrap_CProductions (T_CProductions sem ) (Inh_CProductions ) =
(let ( _lhsOpp,_lhsOppL) =
(sem )
in (Syn_CProductions _lhsOpp _lhsOppL ))
sem_CProductions_Cons :: T_CProduction ->
T_CProductions ->
T_CProductions
sem_CProductions_Cons (T_CProduction hd_ ) (T_CProductions tl_ ) =
(T_CProductions (let _lhsOppL :: ([PP_Doc])
_lhsOpp :: PP_Doc
_hdIpp :: PP_Doc
_tlIpp :: PP_Doc
_tlIppL :: ([PP_Doc])
-- "CodeSyntaxDump.ag"(line 94, column 33)
_lhsOppL =
({-# LINE 94 "CodeSyntaxDump.ag" #-}
_hdIpp : _tlIppL
{-# LINE 360 "CodeSyntaxDump.hs" #-})
-- use rule "CodeSyntaxDump.ag"(line 44, column 40)
_lhsOpp =
({-# LINE 44 "CodeSyntaxDump.ag" #-}
_hdIpp >-< _tlIpp
{-# LINE 365 "CodeSyntaxDump.hs" #-})
( _hdIpp) =
(hd_ )
( _tlIpp,_tlIppL) =
(tl_ )
in ( _lhsOpp,_lhsOppL)) )
sem_CProductions_Nil :: T_CProductions
sem_CProductions_Nil =
(T_CProductions (let _lhsOppL :: ([PP_Doc])
_lhsOpp :: PP_Doc
-- "CodeSyntaxDump.ag"(line 95, column 33)
_lhsOppL =
({-# LINE 95 "CodeSyntaxDump.ag" #-}
[]
{-# LINE 379 "CodeSyntaxDump.hs" #-})
-- use rule "CodeSyntaxDump.ag"(line 44, column 40)
_lhsOpp =
({-# LINE 44 "CodeSyntaxDump.ag" #-}
empty
{-# LINE 384 "CodeSyntaxDump.hs" #-})
in ( _lhsOpp,_lhsOppL)) )
-- CRule -------------------------------------------------------
{-
visit 0:
synthesized attribute:
pp : PP_Doc
alternatives:
alternative CChildVisit:
child name : {Identifier}
child nt : {NontermIdent}
child nr : {Int}
child inh : {Attributes}
child syn : {Attributes}
child isLast : {Bool}
alternative CRule:
child name : {Identifier}
child isIn : {Bool}
child hasCode : {Bool}
child nt : {NontermIdent}
child con : {ConstructorIdent}
child field : {Identifier}
child childnt : {Maybe NontermIdent}
child tp : {Maybe Type}
child pattern : Pattern
child rhs : {[String]}
child defines : {Map Int (Identifier,Identifier,Maybe Type)}
child owrt : {Bool}
child origin : {String}
child uses : {Set (Identifier, Identifier)}
child explicit : {Bool}
child mbNamed : {Maybe Identifier}
-}
-- cata
sem_CRule :: CRule ->
T_CRule
sem_CRule (CChildVisit _name _nt _nr _inh _syn _isLast ) =
(sem_CRule_CChildVisit _name _nt _nr _inh _syn _isLast )
sem_CRule (CRule _name _isIn _hasCode _nt _con _field _childnt _tp _pattern _rhs _defines _owrt _origin _uses _explicit _mbNamed ) =
(sem_CRule_CRule _name _isIn _hasCode _nt _con _field _childnt _tp (sem_Pattern _pattern ) _rhs _defines _owrt _origin _uses _explicit _mbNamed )
-- semantic domain
newtype T_CRule = T_CRule (( PP_Doc))
data Inh_CRule = Inh_CRule {}
data Syn_CRule = Syn_CRule {pp_Syn_CRule :: PP_Doc}
wrap_CRule :: T_CRule ->
Inh_CRule ->
Syn_CRule
wrap_CRule (T_CRule sem ) (Inh_CRule ) =
(let ( _lhsOpp) =
(sem )
in (Syn_CRule _lhsOpp ))
sem_CRule_CChildVisit :: Identifier ->
NontermIdent ->
Int ->
Attributes ->
Attributes ->
Bool ->
T_CRule
sem_CRule_CChildVisit name_ nt_ nr_ inh_ syn_ isLast_ =
(T_CRule (let _lhsOpp :: PP_Doc
-- "CodeSyntaxDump.ag"(line 70, column 21)
_lhsOpp =
({-# LINE 70 "CodeSyntaxDump.ag" #-}
ppNestInfo ["CRule","CChildVisit"] [pp name_] [ppF "nt" $ pp nt_, ppF "nr" $ ppShow nr_, ppF "inh" $ ppMap inh_, ppF "syn" $ ppMap syn_, ppF "last" $ ppBool isLast_] []
{-# LINE 448 "CodeSyntaxDump.hs" #-})
in ( _lhsOpp)) )
sem_CRule_CRule :: Identifier ->
Bool ->
Bool ->
NontermIdent ->
ConstructorIdent ->
Identifier ->
(Maybe NontermIdent) ->
(Maybe Type) ->
T_Pattern ->
([String]) ->
(Map Int (Identifier,Identifier,Maybe Type)) ->
Bool ->
String ->
(Set (Identifier, Identifier)) ->
Bool ->
(Maybe Identifier) ->
T_CRule
sem_CRule_CRule name_ isIn_ hasCode_ nt_ con_ field_ childnt_ tp_ (T_Pattern pattern_ ) rhs_ defines_ owrt_ origin_ uses_ explicit_ mbNamed_ =
(T_CRule (let _lhsOpp :: PP_Doc
_patternIcopy :: Pattern
_patternIpp :: PP_Doc
-- "CodeSyntaxDump.ag"(line 69, column 33)
_lhsOpp =
({-# LINE 69 "CodeSyntaxDump.ag" #-}
ppNestInfo ["CRule","CRule"] [pp name_] [ppF "isIn" $ ppBool isIn_, ppF "hasCode" $ ppBool hasCode_, ppF "nt" $ pp nt_, ppF "con" $ pp con_, ppF "field" $ pp field_, ppF "childnt" $ ppMaybeShow childnt_, ppF "tp" $ ppMaybeShow tp_, ppF "pattern" $ if isIn_ then pp "<no pat because In>" else _patternIpp, ppF "rhs" $ ppStrings rhs_, ppF "defines" $ ppVertexMap defines_, ppF "owrt" $ ppBool owrt_, ppF "origin" $ pp origin_] []
{-# LINE 475 "CodeSyntaxDump.hs" #-})
( _patternIcopy,_patternIpp) =
(pattern_ )
in ( _lhsOpp)) )
-- CSegment ----------------------------------------------------
{-
visit 0:
synthesized attribute:
pp : PP_Doc
alternatives:
alternative CSegment:
child inh : {Attributes}
child syn : {Attributes}
-}
-- cata
sem_CSegment :: CSegment ->
T_CSegment
sem_CSegment (CSegment _inh _syn ) =
(sem_CSegment_CSegment _inh _syn )
-- semantic domain
newtype T_CSegment = T_CSegment (( PP_Doc))
data Inh_CSegment = Inh_CSegment {}
data Syn_CSegment = Syn_CSegment {pp_Syn_CSegment :: PP_Doc}
wrap_CSegment :: T_CSegment ->
Inh_CSegment ->
Syn_CSegment
wrap_CSegment (T_CSegment sem ) (Inh_CSegment ) =
(let ( _lhsOpp) =
(sem )
in (Syn_CSegment _lhsOpp ))
sem_CSegment_CSegment :: Attributes ->
Attributes ->
T_CSegment
sem_CSegment_CSegment inh_ syn_ =
(T_CSegment (let _lhsOpp :: PP_Doc
-- "CodeSyntaxDump.ag"(line 60, column 21)
_lhsOpp =
({-# LINE 60 "CodeSyntaxDump.ag" #-}
ppNestInfo ["CSegment","CSegment"] [] [ppF "inh" $ ppMap inh_, ppF "syn" $ ppMap syn_] []
{-# LINE 514 "CodeSyntaxDump.hs" #-})
in ( _lhsOpp)) )
-- CSegments ---------------------------------------------------
{-
visit 0:
synthesized attributes:
pp : PP_Doc
ppL : [PP_Doc]
alternatives:
alternative Cons:
child hd : CSegment
child tl : CSegments
alternative Nil:
-}
-- cata
sem_CSegments :: CSegments ->
T_CSegments
sem_CSegments list =
(Prelude.foldr sem_CSegments_Cons sem_CSegments_Nil (Prelude.map sem_CSegment list) )
-- semantic domain
newtype T_CSegments = T_CSegments (( PP_Doc,([PP_Doc])))
data Inh_CSegments = Inh_CSegments {}
data Syn_CSegments = Syn_CSegments {pp_Syn_CSegments :: PP_Doc,ppL_Syn_CSegments :: ([PP_Doc])}
wrap_CSegments :: T_CSegments ->
Inh_CSegments ->
Syn_CSegments
wrap_CSegments (T_CSegments sem ) (Inh_CSegments ) =
(let ( _lhsOpp,_lhsOppL) =
(sem )
in (Syn_CSegments _lhsOpp _lhsOppL ))
sem_CSegments_Cons :: T_CSegment ->
T_CSegments ->
T_CSegments
sem_CSegments_Cons (T_CSegment hd_ ) (T_CSegments tl_ ) =
(T_CSegments (let _lhsOppL :: ([PP_Doc])
_lhsOpp :: PP_Doc
_hdIpp :: PP_Doc
_tlIpp :: PP_Doc
_tlIppL :: ([PP_Doc])
-- "CodeSyntaxDump.ag"(line 98, column 33)
_lhsOppL =
({-# LINE 98 "CodeSyntaxDump.ag" #-}
_hdIpp : _tlIppL
{-# LINE 557 "CodeSyntaxDump.hs" #-})
-- use rule "CodeSyntaxDump.ag"(line 44, column 40)
_lhsOpp =
({-# LINE 44 "CodeSyntaxDump.ag" #-}
_hdIpp >-< _tlIpp
{-# LINE 562 "CodeSyntaxDump.hs" #-})
( _hdIpp) =
(hd_ )
( _tlIpp,_tlIppL) =
(tl_ )
in ( _lhsOpp,_lhsOppL)) )
sem_CSegments_Nil :: T_CSegments
sem_CSegments_Nil =
(T_CSegments (let _lhsOppL :: ([PP_Doc])
_lhsOpp :: PP_Doc
-- "CodeSyntaxDump.ag"(line 99, column 33)
_lhsOppL =
({-# LINE 99 "CodeSyntaxDump.ag" #-}
[]
{-# LINE 576 "CodeSyntaxDump.hs" #-})
-- use rule "CodeSyntaxDump.ag"(line 44, column 40)
_lhsOpp =
({-# LINE 44 "CodeSyntaxDump.ag" #-}
empty
{-# LINE 581 "CodeSyntaxDump.hs" #-})
in ( _lhsOpp,_lhsOppL)) )
-- CVisit ------------------------------------------------------
{-
visit 0:
synthesized attribute:
pp : PP_Doc
alternatives:
alternative CVisit:
child inh : {Attributes}
child syn : {Attributes}
child vss : Sequence
child intra : Sequence
child ordered : {Bool}
-}
-- cata
sem_CVisit :: CVisit ->
T_CVisit
sem_CVisit (CVisit _inh _syn _vss _intra _ordered ) =
(sem_CVisit_CVisit _inh _syn (sem_Sequence _vss ) (sem_Sequence _intra ) _ordered )
-- semantic domain
newtype T_CVisit = T_CVisit (( PP_Doc))
data Inh_CVisit = Inh_CVisit {}
data Syn_CVisit = Syn_CVisit {pp_Syn_CVisit :: PP_Doc}
wrap_CVisit :: T_CVisit ->
Inh_CVisit ->
Syn_CVisit
wrap_CVisit (T_CVisit sem ) (Inh_CVisit ) =
(let ( _lhsOpp) =
(sem )
in (Syn_CVisit _lhsOpp ))
sem_CVisit_CVisit :: Attributes ->
Attributes ->
T_Sequence ->
T_Sequence ->
Bool ->
T_CVisit
sem_CVisit_CVisit inh_ syn_ (T_Sequence vss_ ) (T_Sequence intra_ ) ordered_ =
(T_CVisit (let _lhsOpp :: PP_Doc
_vssIppL :: ([PP_Doc])
_intraIppL :: ([PP_Doc])
-- "CodeSyntaxDump.ag"(line 66, column 21)
_lhsOpp =
({-# LINE 66 "CodeSyntaxDump.ag" #-}
ppNestInfo ["CVisit","CVisit"] [] [ppF "inh" $ ppMap inh_, ppF "syn" $ ppMap syn_, ppF "sequence" $ ppVList _vssIppL, ppF "intra" $ ppVList _intraIppL, ppF "ordered" $ ppBool ordered_] []
{-# LINE 626 "CodeSyntaxDump.hs" #-})
( _vssIppL) =
(vss_ )
( _intraIppL) =
(intra_ )
in ( _lhsOpp)) )
-- CVisits -----------------------------------------------------
{-
visit 0:
synthesized attributes:
pp : PP_Doc
ppL : [PP_Doc]
alternatives:
alternative Cons:
child hd : CVisit
child tl : CVisits
alternative Nil:
-}
-- cata
sem_CVisits :: CVisits ->
T_CVisits
sem_CVisits list =
(Prelude.foldr sem_CVisits_Cons sem_CVisits_Nil (Prelude.map sem_CVisit list) )
-- semantic domain
newtype T_CVisits = T_CVisits (( PP_Doc,([PP_Doc])))
data Inh_CVisits = Inh_CVisits {}
data Syn_CVisits = Syn_CVisits {pp_Syn_CVisits :: PP_Doc,ppL_Syn_CVisits :: ([PP_Doc])}
wrap_CVisits :: T_CVisits ->
Inh_CVisits ->
Syn_CVisits
wrap_CVisits (T_CVisits sem ) (Inh_CVisits ) =
(let ( _lhsOpp,_lhsOppL) =
(sem )
in (Syn_CVisits _lhsOpp _lhsOppL ))
sem_CVisits_Cons :: T_CVisit ->
T_CVisits ->
T_CVisits
sem_CVisits_Cons (T_CVisit hd_ ) (T_CVisits tl_ ) =
(T_CVisits (let _lhsOppL :: ([PP_Doc])
_lhsOpp :: PP_Doc
_hdIpp :: PP_Doc
_tlIpp :: PP_Doc
_tlIppL :: ([PP_Doc])
-- "CodeSyntaxDump.ag"(line 90, column 33)
_lhsOppL =
({-# LINE 90 "CodeSyntaxDump.ag" #-}
_hdIpp : _tlIppL
{-# LINE 673 "CodeSyntaxDump.hs" #-})
-- use rule "CodeSyntaxDump.ag"(line 44, column 40)
_lhsOpp =
({-# LINE 44 "CodeSyntaxDump.ag" #-}
_hdIpp >-< _tlIpp
{-# LINE 678 "CodeSyntaxDump.hs" #-})
( _hdIpp) =
(hd_ )
( _tlIpp,_tlIppL) =
(tl_ )
in ( _lhsOpp,_lhsOppL)) )
sem_CVisits_Nil :: T_CVisits
sem_CVisits_Nil =
(T_CVisits (let _lhsOppL :: ([PP_Doc])
_lhsOpp :: PP_Doc
-- "CodeSyntaxDump.ag"(line 91, column 33)
_lhsOppL =
({-# LINE 91 "CodeSyntaxDump.ag" #-}
[]
{-# LINE 692 "CodeSyntaxDump.hs" #-})
-- use rule "CodeSyntaxDump.ag"(line 44, column 40)
_lhsOpp =
({-# LINE 44 "CodeSyntaxDump.ag" #-}
empty
{-# LINE 697 "CodeSyntaxDump.hs" #-})
in ( _lhsOpp,_lhsOppL)) )
-- Pattern -----------------------------------------------------
{-
visit 0:
synthesized attributes:
copy : SELF
pp : PP_Doc
alternatives:
alternative Alias:
child field : {Identifier}
child attr : {Identifier}
child pat : Pattern
child parts : Patterns
visit 0:
local copy : _
alternative Constr:
child name : {ConstructorIdent}
child pats : Patterns
visit 0:
local copy : _
alternative Irrefutable:
child pat : Pattern
visit 0:
local copy : _
alternative Product:
child pos : {Pos}
child pats : Patterns
visit 0:
local copy : _
alternative Underscore:
child pos : {Pos}
visit 0:
local copy : _
-}
-- cata
sem_Pattern :: Pattern ->
T_Pattern
sem_Pattern (Alias _field _attr _pat _parts ) =
(sem_Pattern_Alias _field _attr (sem_Pattern _pat ) (sem_Patterns _parts ) )
sem_Pattern (Constr _name _pats ) =
(sem_Pattern_Constr _name (sem_Patterns _pats ) )
sem_Pattern (Irrefutable _pat ) =
(sem_Pattern_Irrefutable (sem_Pattern _pat ) )
sem_Pattern (Product _pos _pats ) =
(sem_Pattern_Product _pos (sem_Patterns _pats ) )
sem_Pattern (Underscore _pos ) =
(sem_Pattern_Underscore _pos )
-- semantic domain
newtype T_Pattern = T_Pattern (( Pattern ,PP_Doc))
data Inh_Pattern = Inh_Pattern {}
data Syn_Pattern = Syn_Pattern {copy_Syn_Pattern :: Pattern ,pp_Syn_Pattern :: PP_Doc}
wrap_Pattern :: T_Pattern ->
Inh_Pattern ->
Syn_Pattern
wrap_Pattern (T_Pattern sem ) (Inh_Pattern ) =
(let ( _lhsOcopy,_lhsOpp) =
(sem )
in (Syn_Pattern _lhsOcopy _lhsOpp ))
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 _lhsOpp :: PP_Doc
_lhsOcopy :: Pattern
_patIcopy :: Pattern
_patIpp :: PP_Doc
_partsIcopy :: Patterns
_partsIpp :: PP_Doc
_partsIppL :: ([PP_Doc])
-- "CodeSyntaxDump.ag"(line 75, column 33)
_lhsOpp =
({-# LINE 75 "CodeSyntaxDump.ag" #-}
ppNestInfo ["Pattern","Alias"] [pp field_, pp attr_] [ppF "pat" $ _patIpp] []
{-# LINE 773 "CodeSyntaxDump.hs" #-})
-- self rule
_copy =
({-# LINE 23 "./Patterns.ag" #-}
Alias field_ attr_ _patIcopy _partsIcopy
{-# LINE 778 "CodeSyntaxDump.hs" #-})
-- self rule
_lhsOcopy =
({-# LINE 23 "./Patterns.ag" #-}
_copy
{-# LINE 783 "CodeSyntaxDump.hs" #-})
( _patIcopy,_patIpp) =
(pat_ )
( _partsIcopy,_partsIpp,_partsIppL) =
(parts_ )
in ( _lhsOcopy,_lhsOpp)) )
sem_Pattern_Constr :: ConstructorIdent ->
T_Patterns ->
T_Pattern
sem_Pattern_Constr name_ (T_Patterns pats_ ) =
(T_Pattern (let _lhsOpp :: PP_Doc
_lhsOcopy :: Pattern
_patsIcopy :: Patterns
_patsIpp :: PP_Doc
_patsIppL :: ([PP_Doc])
-- "CodeSyntaxDump.ag"(line 73, column 33)
_lhsOpp =
({-# LINE 73 "CodeSyntaxDump.ag" #-}
ppNestInfo ["Pattern","Constr"] [pp name_] [ppF "pats" $ ppVList _patsIppL] []
{-# LINE 802 "CodeSyntaxDump.hs" #-})
-- self rule
_copy =
({-# LINE 23 "./Patterns.ag" #-}
Constr name_ _patsIcopy
{-# LINE 807 "CodeSyntaxDump.hs" #-})
-- self rule
_lhsOcopy =
({-# LINE 23 "./Patterns.ag" #-}
_copy
{-# LINE 812 "CodeSyntaxDump.hs" #-})
( _patsIcopy,_patsIpp,_patsIppL) =
(pats_ )
in ( _lhsOcopy,_lhsOpp)) )
sem_Pattern_Irrefutable :: T_Pattern ->
T_Pattern
sem_Pattern_Irrefutable (T_Pattern pat_ ) =
(T_Pattern (let _lhsOpp :: PP_Doc
_lhsOcopy :: Pattern
_patIcopy :: Pattern
_patIpp :: PP_Doc
-- use rule "CodeSyntaxDump.ag"(line 44, column 40)
_lhsOpp =
({-# LINE 44 "CodeSyntaxDump.ag" #-}
_patIpp
{-# LINE 827 "CodeSyntaxDump.hs" #-})
-- self rule
_copy =
({-# LINE 23 "./Patterns.ag" #-}
Irrefutable _patIcopy
{-# LINE 832 "CodeSyntaxDump.hs" #-})
-- self rule
_lhsOcopy =
({-# LINE 23 "./Patterns.ag" #-}
_copy
{-# LINE 837 "CodeSyntaxDump.hs" #-})
( _patIcopy,_patIpp) =
(pat_ )
in ( _lhsOcopy,_lhsOpp)) )
sem_Pattern_Product :: Pos ->
T_Patterns ->
T_Pattern
sem_Pattern_Product pos_ (T_Patterns pats_ ) =
(T_Pattern (let _lhsOpp :: PP_Doc
_lhsOcopy :: Pattern
_patsIcopy :: Patterns
_patsIpp :: PP_Doc
_patsIppL :: ([PP_Doc])
-- "CodeSyntaxDump.ag"(line 74, column 33)
_lhsOpp =
({-# LINE 74 "CodeSyntaxDump.ag" #-}
ppNestInfo ["Pattern","Product"] [ppShow pos_] [ppF "pats" $ ppVList _patsIppL] []
{-# LINE 854 "CodeSyntaxDump.hs" #-})
-- self rule
_copy =
({-# LINE 23 "./Patterns.ag" #-}
Product pos_ _patsIcopy
{-# LINE 859 "CodeSyntaxDump.hs" #-})
-- self rule
_lhsOcopy =
({-# LINE 23 "./Patterns.ag" #-}
_copy
{-# LINE 864 "CodeSyntaxDump.hs" #-})
( _patsIcopy,_patsIpp,_patsIppL) =
(pats_ )
in ( _lhsOcopy,_lhsOpp)) )
sem_Pattern_Underscore :: Pos ->
T_Pattern
sem_Pattern_Underscore pos_ =
(T_Pattern (let _lhsOpp :: PP_Doc
_lhsOcopy :: Pattern
-- "CodeSyntaxDump.ag"(line 76, column 25)
_lhsOpp =
({-# LINE 76 "CodeSyntaxDump.ag" #-}
ppNestInfo ["Pattern","Underscore"] [ppShow pos_] [] []
{-# LINE 877 "CodeSyntaxDump.hs" #-})
-- self rule
_copy =
({-# LINE 23 "./Patterns.ag" #-}
Underscore pos_
{-# LINE 882 "CodeSyntaxDump.hs" #-})
-- self rule
_lhsOcopy =
({-# LINE 23 "./Patterns.ag" #-}
_copy
{-# LINE 887 "CodeSyntaxDump.hs" #-})
in ( _lhsOcopy,_lhsOpp)) )
-- Patterns ----------------------------------------------------
{-
visit 0:
synthesized attributes:
copy : SELF
pp : PP_Doc
ppL : [PP_Doc]
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 ,PP_Doc,([PP_Doc])))
data Inh_Patterns = Inh_Patterns {}
data Syn_Patterns = Syn_Patterns {copy_Syn_Patterns :: Patterns ,pp_Syn_Patterns :: PP_Doc,ppL_Syn_Patterns :: ([PP_Doc])}
wrap_Patterns :: T_Patterns ->
Inh_Patterns ->
Syn_Patterns
wrap_Patterns (T_Patterns sem ) (Inh_Patterns ) =
(let ( _lhsOcopy,_lhsOpp,_lhsOppL) =
(sem )
in (Syn_Patterns _lhsOcopy _lhsOpp _lhsOppL ))
sem_Patterns_Cons :: T_Pattern ->
T_Patterns ->
T_Patterns
sem_Patterns_Cons (T_Pattern hd_ ) (T_Patterns tl_ ) =
(T_Patterns (let _lhsOppL :: ([PP_Doc])
_lhsOpp :: PP_Doc
_lhsOcopy :: Patterns
_hdIcopy :: Pattern
_hdIpp :: PP_Doc
_tlIcopy :: Patterns
_tlIpp :: PP_Doc
_tlIppL :: ([PP_Doc])
-- "CodeSyntaxDump.ag"(line 82, column 33)
_lhsOppL =
({-# LINE 82 "CodeSyntaxDump.ag" #-}
_hdIpp : _tlIppL
{-# LINE 938 "CodeSyntaxDump.hs" #-})
-- use rule "CodeSyntaxDump.ag"(line 44, column 40)
_lhsOpp =
({-# LINE 44 "CodeSyntaxDump.ag" #-}
_hdIpp >-< _tlIpp
{-# LINE 943 "CodeSyntaxDump.hs" #-})
-- self rule
_copy =
({-# LINE 23 "./Patterns.ag" #-}
(:) _hdIcopy _tlIcopy
{-# LINE 948 "CodeSyntaxDump.hs" #-})
-- self rule
_lhsOcopy =
({-# LINE 23 "./Patterns.ag" #-}
_copy
{-# LINE 953 "CodeSyntaxDump.hs" #-})
( _hdIcopy,_hdIpp) =
(hd_ )
( _tlIcopy,_tlIpp,_tlIppL) =
(tl_ )
in ( _lhsOcopy,_lhsOpp,_lhsOppL)) )
sem_Patterns_Nil :: T_Patterns
sem_Patterns_Nil =
(T_Patterns (let _lhsOppL :: ([PP_Doc])
_lhsOpp :: PP_Doc
_lhsOcopy :: Patterns
-- "CodeSyntaxDump.ag"(line 83, column 33)
_lhsOppL =
({-# LINE 83 "CodeSyntaxDump.ag" #-}
[]
{-# LINE 968 "CodeSyntaxDump.hs" #-})
-- use rule "CodeSyntaxDump.ag"(line 44, column 40)
_lhsOpp =
({-# LINE 44 "CodeSyntaxDump.ag" #-}
empty
{-# LINE 973 "CodeSyntaxDump.hs" #-})
-- self rule
_copy =
({-# LINE 23 "./Patterns.ag" #-}
[]
{-# LINE 978 "CodeSyntaxDump.hs" #-})
-- self rule
_lhsOcopy =
({-# LINE 23 "./Patterns.ag" #-}
_copy
{-# LINE 983 "CodeSyntaxDump.hs" #-})
in ( _lhsOcopy,_lhsOpp,_lhsOppL)) )
-- Sequence ----------------------------------------------------
{-
visit 0:
synthesized attribute:
ppL : [PP_Doc]
alternatives:
alternative Cons:
child hd : CRule
child tl : Sequence
alternative Nil:
-}
-- cata
sem_Sequence :: Sequence ->
T_Sequence
sem_Sequence list =
(Prelude.foldr sem_Sequence_Cons sem_Sequence_Nil (Prelude.map sem_CRule list) )
-- semantic domain
newtype T_Sequence = T_Sequence (( ([PP_Doc])))
data Inh_Sequence = Inh_Sequence {}
data Syn_Sequence = Syn_Sequence {ppL_Syn_Sequence :: ([PP_Doc])}
wrap_Sequence :: T_Sequence ->
Inh_Sequence ->
Syn_Sequence
wrap_Sequence (T_Sequence sem ) (Inh_Sequence ) =
(let ( _lhsOppL) =
(sem )
in (Syn_Sequence _lhsOppL ))
sem_Sequence_Cons :: T_CRule ->
T_Sequence ->
T_Sequence
sem_Sequence_Cons (T_CRule hd_ ) (T_Sequence tl_ ) =
(T_Sequence (let _lhsOppL :: ([PP_Doc])
_hdIpp :: PP_Doc
_tlIppL :: ([PP_Doc])
-- "CodeSyntaxDump.ag"(line 86, column 33)
_lhsOppL =
({-# LINE 86 "CodeSyntaxDump.ag" #-}
_hdIpp : _tlIppL
{-# LINE 1023 "CodeSyntaxDump.hs" #-})
( _hdIpp) =
(hd_ )
( _tlIppL) =
(tl_ )
in ( _lhsOppL)) )
sem_Sequence_Nil :: T_Sequence
sem_Sequence_Nil =
(T_Sequence (let _lhsOppL :: ([PP_Doc])
-- "CodeSyntaxDump.ag"(line 87, column 33)
_lhsOppL =
({-# LINE 87 "CodeSyntaxDump.ag" #-}
[]
{-# LINE 1036 "CodeSyntaxDump.hs" #-})
in ( _lhsOppL)) )