uuagc

Safe Haskell | Safe-Infered

Transform

# Documentation

sem_Alt :: Alt -> T_Alt

newtype T_Alt

Constructors

T_Alt (Map NontermIdent (Set ConstructorIdent) -> Set NontermIdent -> Set NontermIdent -> ([(NontermIdent, ConstructorIdent, Set Identifier)], [(NontermIdent, ConstructorIdent, [Type])], Set ConstructorIdent, [(NontermIdent, ConstructorIdent, FieldMap)], [(NontermIdent, ConstructorIdent, MaybeMacro)])) |

data Inh_Alt

Constructors

Inh_Alt |

Fields

allConstructors_Inh_Alt :: !(Map NontermIdent (Set ConstructorIdent))
allNonterminals_Inh_Alt :: !(Set NontermIdent)
nts_Inh_Alt :: !(Set NontermIdent)

data Syn_Alt

Constructors

Syn_Alt |

Fields

collectedConParams_Syn_Alt :: ![(NontermIdent, ConstructorIdent, Set Identifier)]
collectedConstraints_Syn_Alt :: ![(NontermIdent, ConstructorIdent, [Type])]
collectedConstructorNames_Syn_Alt :: !(Set ConstructorIdent)
collectedFields_Syn_Alt :: ![(NontermIdent, ConstructorIdent, FieldMap)]
collectedMacros_Syn_Alt :: ![(NontermIdent, ConstructorIdent, MaybeMacro)]

wrap_Alt :: T_Alt -> Inh_Alt -> Syn_Alt

sem_Alt_Alt :: Pos -> T_ConstructorSet -> [Identifier] -> T_Fields -> MaybeMacro -> T_Alt

sem_Alts :: Alts -> T_Alts

newtype T_Alts

Constructors

T_Alts (Map NontermIdent (Set ConstructorIdent) -> Set NontermIdent -> Set NontermIdent -> ([(NontermIdent, ConstructorIdent, Set Identifier)], [(NontermIdent, ConstructorIdent, [Type])], Set ConstructorIdent, [(NontermIdent, ConstructorIdent, FieldMap)], [(NontermIdent, ConstructorIdent, MaybeMacro)])) |

data Inh_Alts

Constructors

Inh_Alts |

Fields

allConstructors_Inh_Alts :: !(Map NontermIdent (Set ConstructorIdent))
allNonterminals_Inh_Alts :: !(Set NontermIdent)
nts_Inh_Alts :: !(Set NontermIdent)

data Syn_Alts

Constructors

Syn_Alts |

Fields

collectedConParams_Syn_Alts :: ![(NontermIdent, ConstructorIdent, Set Identifier)]
collectedConstraints_Syn_Alts :: ![(NontermIdent, ConstructorIdent, [Type])]
collectedConstructorNames_Syn_Alts :: !(Set ConstructorIdent)
collectedFields_Syn_Alts :: ![(NontermIdent, ConstructorIdent, FieldMap)]
collectedMacros_Syn_Alts :: ![(NontermIdent, ConstructorIdent, MaybeMacro)]

wrap_Alts :: T_Alts -> Inh_Alts -> Syn_Alts

sem_Alts_Cons :: T_Alt -> T_Alts -> T_Alts

sem_Alts_Nil :: T_Alts

sem_Attrs :: Attrs -> T_Attrs

newtype T_Attrs

Constructors

T_Attrs (DataTypes -> Set NontermIdent -> Map NontermIdent (Attributes, Attributes) -> Map NontermIdent (Attributes, Attributes) -> Set NontermIdent -> Options -> (Map NontermIdent (Attributes, Attributes), Map NontermIdent (Attributes, Attributes), Seq Error, Map NontermIdent (Map Identifier (String, String, String)))) |

data Inh_Attrs

Constructors

Inh_Attrs |

Fields

allFields_Inh_Attrs :: !DataTypes
allNonterminals_Inh_Attrs :: !(Set NontermIdent)
attrDecls_Inh_Attrs :: !(Map NontermIdent (Attributes, Attributes))
attrs_Inh_Attrs :: !(Map NontermIdent (Attributes, Attributes))
nts_Inh_Attrs :: !(Set NontermIdent)
options_Inh_Attrs :: !Options

data Syn_Attrs

Constructors

Syn_Attrs |

Fields

attrDecls_Syn_Attrs :: !(Map NontermIdent (Attributes, Attributes))
attrs_Syn_Attrs :: !(Map NontermIdent (Attributes, Attributes))
errors_Syn_Attrs :: !(Seq Error)
useMap_Syn_Attrs :: !(Map NontermIdent (Map Identifier (String, String, String)))

wrap_Attrs :: T_Attrs -> Inh_Attrs -> Syn_Attrs

sem_Attrs_Attrs :: Pos -> AttrNames -> AttrNames -> AttrNames -> T_Attrs

sem_ConstructorSet :: ConstructorSet -> T_ConstructorSet

newtype T_ConstructorSet

Constructors

T_ConstructorSet (Set ConstructorIdent, Set ConstructorIdent -> Set ConstructorIdent, Seq Error) |

data Inh_ConstructorSet

Constructors

Inh_ConstructorSet |

data Syn_ConstructorSet

Constructors

Syn_ConstructorSet |

Fields

collectedConstructorNames_Syn_ConstructorSet :: !(Set ConstructorIdent)
constructors_Syn_ConstructorSet :: !(Set ConstructorIdent -> Set ConstructorIdent)
errors_Syn_ConstructorSet :: !(Seq Error)

wrap_ConstructorSet :: T_ConstructorSet -> Inh_ConstructorSet -> Syn_ConstructorSet

sem_ConstructorSet_CAll :: T_ConstructorSet

sem_ConstructorSet_CDifference :: T_ConstructorSet -> T_ConstructorSet -> T_ConstructorSet

sem_ConstructorSet_CName :: ConstructorIdent -> T_ConstructorSet

sem_ConstructorSet_CUnion :: T_ConstructorSet -> T_ConstructorSet -> T_ConstructorSet

sem_Elem :: Elem -> T_Elem

newtype T_Elem

Constructors

T_Elem (Map NontermIdent (Attributes, Attributes) -> Map NontermIdent (Attributes, Attributes) -> Map NontermIdent (Set ConstructorIdent) -> DataTypes -> Set NontermIdent -> Map NontermIdent (Attributes, Attributes) -> Map NontermIdent (Attributes, Attributes) -> Map Identifier (Set NontermIdent, Set Identifier) -> DefinedSets -> Options -> (Map NontermIdent (Attributes, Attributes), AttrOrderMap, Map NontermIdent (Attributes, Attributes), Blocks, [(NontermIdent, ConstructorIdent, [AroundInfo])], [(NontermIdent, ConstructorIdent, [AugmentInfo])], [(NontermIdent, ConstructorIdent, Set Identifier)], [(NontermIdent, ConstructorIdent, [Type])], Map NontermIdent (Set ConstructorIdent), [(NontermIdent, ConstructorIdent, FieldMap)], [(NontermIdent, ConstructorIdent, [Identifier])], [(NontermIdent, ConstructorIdent, MaybeMacro)], [(NontermIdent, ConstructorIdent, [MergeInfo])], Set Identifier, [(NontermIdent, ConstructorIdent, RuleInfo)], Set Identifier, [(NontermIdent, ConstructorIdent, SigInfo)], [(NontermIdent, ConstructorIdent, [UniqueInfo])], ContextMap, Map Identifier (Set NontermIdent, Set Identifier), Derivings, Seq Error, Maybe (String, String, String), ParamMap, Options -> Options, QuantMap, PragmaMap, TypeSyns, Map NontermIdent (Map Identifier (String, String, String)), Set NontermIdent))

data Inh_Elem

Constructors

Inh_Elem |

Fields

allAttrDecls_Inh_Elem :: !(Map NontermIdent (Attributes, Attributes))
allAttrs_Inh_Elem :: !(Map NontermIdent (Attributes, Attributes))
allConstructors_Inh_Elem :: !(Map NontermIdent (Set ConstructorIdent))
allFields_Inh_Elem :: !DataTypes
allNonterminals_Inh_Elem :: !(Set NontermIdent)
attrDecls_Inh_Elem :: !(Map NontermIdent (Attributes, Attributes))
attrs_Inh_Elem :: !(Map NontermIdent (Attributes, Attributes))
defSets_Inh_Elem :: !(Map Identifier (Set NontermIdent, Set Identifier))
definedSets_Inh_Elem :: !DefinedSets
options_Inh_Elem :: !Options

data Syn_Elem

Constructors

Syn_Elem |

Fields

attrDecls_Syn_Elem :: !(Map NontermIdent (Attributes, Attributes))
attrOrderCollect_Syn_Elem :: !AttrOrderMap
attrs_Syn_Elem :: !(Map NontermIdent (Attributes, Attributes))
blocks_Syn_Elem :: !Blocks
collectedArounds_Syn_Elem :: ![(NontermIdent, ConstructorIdent, [AroundInfo])]
collectedAugments_Syn_Elem :: ![(NontermIdent, ConstructorIdent, [AugmentInfo])]
collectedConParams_Syn_Elem :: ![(NontermIdent, ConstructorIdent, Set Identifier)]
collectedConstraints_Syn_Elem :: ![(NontermIdent, ConstructorIdent, [Type])]
collectedConstructorsMap_Syn_Elem :: !(Map NontermIdent (Set ConstructorIdent))
collectedFields_Syn_Elem :: ![(NontermIdent, ConstructorIdent, FieldMap)]
collectedInsts_Syn_Elem :: ![(NontermIdent, ConstructorIdent, [Identifier])]
collectedMacros_Syn_Elem :: ![(NontermIdent, ConstructorIdent, MaybeMacro)]
collectedMerges_Syn_Elem :: ![(NontermIdent, ConstructorIdent, [MergeInfo])]
collectedNames_Syn_Elem :: !(Set Identifier)
collectedRules_Syn_Elem :: ![(NontermIdent, ConstructorIdent, RuleInfo)]
collectedSetNames_Syn_Elem :: !(Set Identifier)
collectedSigs_Syn_Elem :: ![(NontermIdent, ConstructorIdent, SigInfo)]
collectedUniques_Syn_Elem :: ![(NontermIdent, ConstructorIdent, [UniqueInfo])]
ctxCollect_Syn_Elem :: !ContextMap
defSets_Syn_Elem :: !(Map Identifier (Set NontermIdent, Set Identifier))
derivings_Syn_Elem :: !Derivings
errors_Syn_Elem :: !(Seq Error)
moduleDecl_Syn_Elem :: !(Maybe (String, String, String))
paramsCollect_Syn_Elem :: !ParamMap
pragmas_Syn_Elem :: !(Options -> Options)
quantCollect_Syn_Elem :: !QuantMap
semPragmasCollect_Syn_Elem :: !PragmaMap
typeSyns_Syn_Elem :: !TypeSyns
useMap_Syn_Elem :: !(Map NontermIdent (Map Identifier (String, String, String)))
wrappers_Syn_Elem :: !(Set NontermIdent)

wrap_Elem :: T_Elem -> Inh_Elem -> Syn_Elem

sem_Elem_Attr :: Pos -> ClassContext -> T_NontSet -> [String] -> T_Attrs -> T_Elem

sem_Elem_Data :: Pos -> ClassContext -> T_NontSet -> [Identifier] -> T_Attrs -> T_Alts -> Bool -> T_Elem

sem_Elem_Deriving :: Pos -> T_NontSet -> [NontermIdent] -> T_Elem

sem_Elem_Module :: Pos -> String -> String -> String -> T_Elem

sem_Elem_Nocatas :: Pos -> T_NontSet -> T_Elem

sem_Elem_Pragma :: Pos -> [NontermIdent] -> T_Elem

sem_Elem_Sem :: Pos -> ClassContext -> T_NontSet -> T_Attrs -> [String] -> T_SemAlts -> T_Elem

sem_Elem_Set :: Pos -> NontermIdent -> Bool -> T_NontSet -> T_Elem

sem_Elem_Txt :: Pos -> BlockKind -> Maybe NontermIdent -> [String] -> T_Elem

sem_Elem_Type :: Pos -> ClassContext -> NontermIdent -> [Identifier] -> ComplexType -> T_Elem

sem_Elem_Wrapper :: Pos -> T_NontSet -> T_Elem

sem_Elems :: Elems -> T_Elems

newtype T_Elems

Constructors

T_Elems (Map NontermIdent (Attributes, Attributes) -> Map NontermIdent (Attributes, Attributes) -> Map NontermIdent (Set ConstructorIdent) -> DataTypes -> Set NontermIdent -> Map NontermIdent (Attributes, Attributes) -> Map NontermIdent (Attributes, Attributes) -> Map Identifier (Set NontermIdent, Set Identifier) -> DefinedSets -> Options -> (Map NontermIdent (Attributes, Attributes), AttrOrderMap, Map NontermIdent (Attributes, Attributes), Blocks, [(NontermIdent, ConstructorIdent, [AroundInfo])], [(NontermIdent, ConstructorIdent, [AugmentInfo])], [(NontermIdent, ConstructorIdent, Set Identifier)], [(NontermIdent, ConstructorIdent, [Type])], Map NontermIdent (Set ConstructorIdent), [(NontermIdent, ConstructorIdent, FieldMap)], [(NontermIdent, ConstructorIdent, [Identifier])], [(NontermIdent, ConstructorIdent, MaybeMacro)], [(NontermIdent, ConstructorIdent, [MergeInfo])], Set Identifier, [(NontermIdent, ConstructorIdent, RuleInfo)], Set Identifier, [(NontermIdent, ConstructorIdent, SigInfo)], [(NontermIdent, ConstructorIdent, [UniqueInfo])], ContextMap, Map Identifier (Set NontermIdent, Set Identifier), Derivings, Seq Error, Maybe (String, String, String), ParamMap, Options -> Options, QuantMap, PragmaMap, TypeSyns, Map NontermIdent (Map Identifier (String, String, String)), Set NontermIdent))

data Inh_Elems

Constructors

Inh_Elems |

Fields

allAttrDecls_Inh_Elems :: !(Map NontermIdent (Attributes, Attributes))
allAttrs_Inh_Elems :: !(Map NontermIdent (Attributes, Attributes))
allConstructors_Inh_Elems :: !(Map NontermIdent (Set ConstructorIdent))
allFields_Inh_Elems :: !DataTypes
allNonterminals_Inh_Elems :: !(Set NontermIdent)
attrDecls_Inh_Elems :: !(Map NontermIdent (Attributes, Attributes))
attrs_Inh_Elems :: !(Map NontermIdent (Attributes, Attributes))
defSets_Inh_Elems :: !(Map Identifier (Set NontermIdent, Set Identifier))
definedSets_Inh_Elems :: !DefinedSets
options_Inh_Elems :: !Options

data Syn_Elems

Constructors

Syn_Elems |

Fields

attrDecls_Syn_Elems :: !(Map NontermIdent (Attributes, Attributes))
attrOrderCollect_Syn_Elems :: !AttrOrderMap
attrs_Syn_Elems :: !(Map NontermIdent (Attributes, Attributes))
blocks_Syn_Elems :: !Blocks
collectedArounds_Syn_Elems :: ![(NontermIdent, ConstructorIdent, [AroundInfo])]
collectedAugments_Syn_Elems :: ![(NontermIdent, ConstructorIdent, [AugmentInfo])]
collectedConParams_Syn_Elems :: ![(NontermIdent, ConstructorIdent, Set Identifier)]
collectedConstraints_Syn_Elems :: ![(NontermIdent, ConstructorIdent, [Type])]
collectedConstructorsMap_Syn_Elems :: !(Map NontermIdent (Set ConstructorIdent))
collectedFields_Syn_Elems :: ![(NontermIdent, ConstructorIdent, FieldMap)]
collectedInsts_Syn_Elems :: ![(NontermIdent, ConstructorIdent, [Identifier])]
collectedMacros_Syn_Elems :: ![(NontermIdent, ConstructorIdent, MaybeMacro)]
collectedMerges_Syn_Elems :: ![(NontermIdent, ConstructorIdent, [MergeInfo])]
collectedNames_Syn_Elems :: !(Set Identifier)
collectedRules_Syn_Elems :: ![(NontermIdent, ConstructorIdent, RuleInfo)]
collectedSetNames_Syn_Elems :: !(Set Identifier)
collectedSigs_Syn_Elems :: ![(NontermIdent, ConstructorIdent, SigInfo)]
collectedUniques_Syn_Elems :: ![(NontermIdent, ConstructorIdent, [UniqueInfo])]
ctxCollect_Syn_Elems :: !ContextMap
defSets_Syn_Elems :: !(Map Identifier (Set NontermIdent, Set Identifier))
derivings_Syn_Elems :: !Derivings
errors_Syn_Elems :: !(Seq Error)
moduleDecl_Syn_Elems :: !(Maybe (String, String, String))
paramsCollect_Syn_Elems :: !ParamMap
pragmas_Syn_Elems :: !(Options -> Options)
quantCollect_Syn_Elems :: !QuantMap
semPragmasCollect_Syn_Elems :: !PragmaMap
typeSyns_Syn_Elems :: !TypeSyns
useMap_Syn_Elems :: !(Map NontermIdent (Map Identifier (String, String, String)))
wrappers_Syn_Elems :: !(Set NontermIdent)

wrap_Elems :: T_Elems -> Inh_Elems -> Syn_Elems

sem_Elems_Cons :: T_Elem -> T_Elems -> T_Elems

sem_Elems_Nil :: T_Elems

sem_Field :: Field -> T_Field

newtype T_Field

Constructors

T_Field (Set NontermIdent -> ([Type], [(Identifier, Type)])) |

data Inh_Field

Constructors

Inh_Field |

Fields

allNonterminals_Inh_Field :: !(Set NontermIdent)

data Syn_Field

Constructors

Syn_Field |

Fields

collectedConstraints_Syn_Field :: ![Type]
collectedFields_Syn_Field :: ![(Identifier, Type)]

wrap_Field :: T_Field -> Inh_Field -> Syn_Field

sem_Field_FChild :: Identifier -> Type -> T_Field

sem_Field_FCtx :: [Type] -> T_Field

sem_Fields :: Fields -> T_Fields

newtype T_Fields

Constructors

T_Fields (Set NontermIdent -> ([Type], [(Identifier, Type)])) |

data Inh_Fields

Constructors

Inh_Fields |

Fields

allNonterminals_Inh_Fields :: !(Set NontermIdent)

data Syn_Fields

Constructors

Syn_Fields |

Fields

collectedConstraints_Syn_Fields :: ![Type]
collectedFields_Syn_Fields :: ![(Identifier, Type)]

wrap_Fields :: T_Fields -> Inh_Fields -> Syn_Fields

sem_Fields_Cons :: T_Field -> T_Fields -> T_Fields

sem_Fields_Nil :: T_Fields

sem_NontSet :: NontSet -> T_NontSet

newtype T_NontSet

Constructors

T_NontSet (DataTypes -> Set NontermIdent -> DefinedSets -> (Set Identifier, Seq Error, Set NontermIdent)) |

data Inh_NontSet

Constructors

Inh_NontSet |

Fields

allFields_Inh_NontSet :: !DataTypes
allNonterminals_Inh_NontSet :: !(Set NontermIdent)
definedSets_Inh_NontSet :: !DefinedSets

data Syn_NontSet

Constructors

Syn_NontSet |

Fields

collectedNames_Syn_NontSet :: !(Set Identifier)
errors_Syn_NontSet :: !(Seq Error)
nontSet_Syn_NontSet :: !(Set NontermIdent)

wrap_NontSet :: T_NontSet -> Inh_NontSet -> Syn_NontSet

sem_NontSet_All :: T_NontSet

sem_NontSet_Difference :: T_NontSet -> T_NontSet -> T_NontSet

sem_NontSet_Intersect :: T_NontSet -> T_NontSet -> T_NontSet

sem_NontSet_NamedSet :: NontermIdent -> T_NontSet

sem_NontSet_Path :: NontermIdent -> NontermIdent -> T_NontSet

sem_NontSet_Union :: T_NontSet -> T_NontSet -> T_NontSet

sem_Pattern :: Pattern -> T_Pattern

newtype T_Pattern

Constructors

T_Pattern (Pattern, [AttrName], [Identifier], [AttrName] -> Pattern, Pos) |

data Inh_Pattern

Constructors

Inh_Pattern |

data Syn_Pattern

Constructors

Syn_Pattern |

Fields

copy_Syn_Pattern :: !Pattern
definedAttrs_Syn_Pattern :: ![AttrName]
definedInsts_Syn_Pattern :: ![Identifier]
patunder_Syn_Pattern :: !([AttrName] -> Pattern)
stpos_Syn_Pattern :: !Pos

wrap_Pattern :: T_Pattern -> Inh_Pattern -> Syn_Pattern

sem_Pattern_Alias :: Identifier -> Identifier -> T_Pattern -> T_Pattern

sem_Pattern_Constr :: ConstructorIdent -> T_Patterns -> T_Pattern

sem_Pattern_Irrefutable :: T_Pattern -> T_Pattern

sem_Pattern_Product :: Pos -> T_Patterns -> T_Pattern

sem_Pattern_Underscore :: Pos -> T_Pattern

sem_Patterns :: Patterns -> T_Patterns

newtype T_Patterns

Constructors

T_Patterns (Patterns, [AttrName], [Identifier], [AttrName] -> Patterns) |

data Inh_Patterns

Constructors

Inh_Patterns |

data Syn_Patterns

Constructors

Syn_Patterns |

Fields

copy_Syn_Patterns :: !Patterns
definedAttrs_Syn_Patterns :: ![AttrName]
definedInsts_Syn_Patterns :: ![Identifier]
patunder_Syn_Patterns :: !([AttrName] -> Patterns)

wrap_Patterns :: T_Patterns -> Inh_Patterns -> Syn_Patterns

sem_Patterns_Cons :: T_Pattern -> T_Patterns -> T_Patterns

sem_Patterns_Nil :: T_Patterns

sem_SemAlt :: SemAlt -> T_SemAlt

newtype T_SemAlt

Constructors

T_SemAlt (Map NontermIdent (Attributes, Attributes) -> Map NontermIdent (Attributes, Attributes) -> DataTypes -> Set NontermIdent -> Options -> (AttrOrderMap, [(NontermIdent, ConstructorIdent, [AroundInfo])], [(NontermIdent, ConstructorIdent, [AugmentInfo])], [(NontermIdent, ConstructorIdent, [Identifier])], [(NontermIdent, ConstructorIdent, [MergeInfo])], [(NontermIdent, ConstructorIdent, RuleInfo)], [(NontermIdent, ConstructorIdent, SigInfo)], [(NontermIdent, ConstructorIdent, [UniqueInfo])], Seq Error, PragmaMap))

data Inh_SemAlt

Constructors

Inh_SemAlt |

Fields

allAttrDecls_Inh_SemAlt :: !(Map NontermIdent (Attributes, Attributes))
allAttrs_Inh_SemAlt :: !(Map NontermIdent (Attributes, Attributes))
allFields_Inh_SemAlt :: !DataTypes
nts_Inh_SemAlt :: !(Set NontermIdent)
options_Inh_SemAlt :: !Options

data Syn_SemAlt

Constructors

Syn_SemAlt |

Fields

attrOrderCollect_Syn_SemAlt :: !AttrOrderMap
collectedArounds_Syn_SemAlt :: ![(NontermIdent, ConstructorIdent, [AroundInfo])]
collectedAugments_Syn_SemAlt :: ![(NontermIdent, ConstructorIdent, [AugmentInfo])]
collectedInsts_Syn_SemAlt :: ![(NontermIdent, ConstructorIdent, [Identifier])]
collectedMerges_Syn_SemAlt :: ![(NontermIdent, ConstructorIdent, [MergeInfo])]
collectedRules_Syn_SemAlt :: ![(NontermIdent, ConstructorIdent, RuleInfo)]
collectedSigs_Syn_SemAlt :: ![(NontermIdent, ConstructorIdent, SigInfo)]
collectedUniques_Syn_SemAlt :: ![(NontermIdent, ConstructorIdent, [UniqueInfo])]
errors_Syn_SemAlt :: !(Seq Error)
semPragmasCollect_Syn_SemAlt :: !PragmaMap

wrap_SemAlt :: T_SemAlt -> Inh_SemAlt -> Syn_SemAlt

sem_SemAlt_SemAlt :: Pos -> T_ConstructorSet -> T_SemDefs -> T_SemAlt

sem_SemAlts :: SemAlts -> T_SemAlts

newtype T_SemAlts

Constructors

T_SemAlts (Map NontermIdent (Attributes, Attributes) -> Map NontermIdent (Attributes, Attributes) -> DataTypes -> Set NontermIdent -> Options -> (AttrOrderMap, [(NontermIdent, ConstructorIdent, [AroundInfo])], [(NontermIdent, ConstructorIdent, [AugmentInfo])], [(NontermIdent, ConstructorIdent, [Identifier])], [(NontermIdent, ConstructorIdent, [MergeInfo])], [(NontermIdent, ConstructorIdent, RuleInfo)], [(NontermIdent, ConstructorIdent, SigInfo)], [(NontermIdent, ConstructorIdent, [UniqueInfo])], Seq Error, PragmaMap))

data Inh_SemAlts

Constructors

Inh_SemAlts |

Fields

allAttrDecls_Inh_SemAlts :: !(Map NontermIdent (Attributes, Attributes))
allAttrs_Inh_SemAlts :: !(Map NontermIdent (Attributes, Attributes))
allFields_Inh_SemAlts :: !DataTypes
nts_Inh_SemAlts :: !(Set NontermIdent)
options_Inh_SemAlts :: !Options

data Syn_SemAlts

Constructors

Syn_SemAlts |

Fields

attrOrderCollect_Syn_SemAlts :: !AttrOrderMap
collectedArounds_Syn_SemAlts :: ![(NontermIdent, ConstructorIdent, [AroundInfo])]
collectedAugments_Syn_SemAlts :: ![(NontermIdent, ConstructorIdent, [AugmentInfo])]
collectedInsts_Syn_SemAlts :: ![(NontermIdent, ConstructorIdent, [Identifier])]
collectedMerges_Syn_SemAlts :: ![(NontermIdent, ConstructorIdent, [MergeInfo])]
collectedRules_Syn_SemAlts :: ![(NontermIdent, ConstructorIdent, RuleInfo)]
collectedSigs_Syn_SemAlts :: ![(NontermIdent, ConstructorIdent, SigInfo)]
collectedUniques_Syn_SemAlts :: ![(NontermIdent, ConstructorIdent, [UniqueInfo])]
errors_Syn_SemAlts :: !(Seq Error)
semPragmasCollect_Syn_SemAlts :: !PragmaMap

wrap_SemAlts :: T_SemAlts -> Inh_SemAlts -> Syn_SemAlts

sem_SemAlts_Cons :: T_SemAlt -> T_SemAlts -> T_SemAlts

sem_SemAlts_Nil :: T_SemAlts

sem_SemDef :: SemDef -> T_SemDef

newtype T_SemDef

Constructors

T_SemDef (Options -> ([AroundInfo], [AugmentInfo], [Identifier], Seq Error, [MergeInfo], Set Dependency, [Identifier], [RuleInfo], [SigInfo], [UniqueInfo])) |

data Inh_SemDef

Constructors

Inh_SemDef |

Fields

options_Inh_SemDef :: !Options

data Syn_SemDef

Constructors

Syn_SemDef |

Fields

aroundInfos_Syn_SemDef :: ![AroundInfo]
augmentInfos_Syn_SemDef :: ![AugmentInfo]
definedInsts_Syn_SemDef :: ![Identifier]
errors_Syn_SemDef :: !(Seq Error)
mergeInfos_Syn_SemDef :: ![MergeInfo]
orderDepsCollect_Syn_SemDef :: !(Set Dependency)
pragmaNamesCollect_Syn_SemDef :: ![Identifier]
ruleInfos_Syn_SemDef :: ![RuleInfo]
sigInfos_Syn_SemDef :: ![SigInfo]
uniqueInfos_Syn_SemDef :: ![UniqueInfo]

wrap_SemDef :: T_SemDef -> Inh_SemDef -> Syn_SemDef

sem_SemDef_AroundDef :: Identifier -> Expression -> T_SemDef

sem_SemDef_AttrOrderBefore :: [Occurrence] -> [Occurrence] -> T_SemDef

sem_SemDef_AugmentDef :: Identifier -> Expression -> T_SemDef

sem_SemDef_Def :: Pos -> Maybe Identifier -> T_Pattern -> Expression -> Bool -> Bool -> Bool -> T_SemDef

sem_SemDef_MergeDef :: Identifier -> Identifier -> [Identifier] -> Expression -> T_SemDef

sem_SemDef_SemPragma :: [NontermIdent] -> T_SemDef

sem_SemDef_TypeDef :: Pos -> Identifier -> Type -> T_SemDef

sem_SemDef_UniqueDef :: Identifier -> Identifier -> T_SemDef

sem_SemDefs :: SemDefs -> T_SemDefs

newtype T_SemDefs

Constructors

T_SemDefs (Options -> ([AroundInfo], [AugmentInfo], [Identifier], Seq Error, [MergeInfo], Set Dependency, [Identifier], [RuleInfo], [SigInfo], [UniqueInfo])) |

data Inh_SemDefs

Constructors

Inh_SemDefs |

Fields

options_Inh_SemDefs :: !Options

data Syn_SemDefs

Constructors

Syn_SemDefs |

Fields

aroundInfos_Syn_SemDefs :: ![AroundInfo]
augmentInfos_Syn_SemDefs :: ![AugmentInfo]
definedInsts_Syn_SemDefs :: ![Identifier]
errors_Syn_SemDefs :: !(Seq Error)
mergeInfos_Syn_SemDefs :: ![MergeInfo]
orderDepsCollect_Syn_SemDefs :: !(Set Dependency)
pragmaNamesCollect_Syn_SemDefs :: ![Identifier]
ruleInfos_Syn_SemDefs :: ![RuleInfo]
sigInfos_Syn_SemDefs :: ![SigInfo]
uniqueInfos_Syn_SemDefs :: ![UniqueInfo]

wrap_SemDefs :: T_SemDefs -> Inh_SemDefs -> Syn_SemDefs

sem_SemDefs_Cons :: T_SemDef -> T_SemDefs -> T_SemDefs

sem_SemDefs_Nil :: T_SemDefs

sem_AG :: AG -> T_AG

newtype T_AG

Constructors

T_AG (Options -> ((Set NontermIdent, DataTypes, Map NontermIdent (Attributes, Attributes)), Blocks, Seq Error, Maybe (String, String, String), Grammar, Options -> Options)) |

data Inh_AG

Constructors

Inh_AG |

Fields

options_Inh_AG :: !Options

data Syn_AG

Constructors

Syn_AG |

Fields

agi_Syn_AG :: !(Set NontermIdent, DataTypes, Map NontermIdent (Attributes, Attributes))
blocks_Syn_AG :: !Blocks
errors_Syn_AG :: !(Seq Error)
moduleDecl_Syn_AG :: !(Maybe (String, String, String))
output_Syn_AG :: !Grammar
pragmas_Syn_AG :: !(Options -> Options)

wrap_AG :: T_AG -> Inh_AG -> Syn_AG

sem_AG_AG :: T_Elems -> T_AG

type DefinedSets = Map Identifier (Set NontermIdent)

type FieldMap = [(Identifier, Type)]

type DataTypes = Map NontermIdent (Map ConstructorIdent FieldMap)

type AttrName = (Identifier, Identifier)

type RuleInfo = (Maybe Identifier, [AttrName] -> Pattern, Expression, [AttrName], Bool, String, Bool, Bool)

type SigInfo = (Identifier, Type)

type UniqueInfo = (Identifier, Identifier)

type AugmentInfo = (Identifier, Expression)

type AroundInfo = (Identifier, Expression)

type MergeInfo = (Identifier, Identifier, [Identifier], Expression)

checkDuplicate :: (Identifier -> Identifier -> Error) -> Identifier -> val -> Map Identifier val -> (Map Identifier val, Seq Error)

checkDuplicates :: (Identifier -> Identifier -> Error) -> [(Identifier, val)] -> Map Identifier val -> (Map Identifier val, Seq Error)

foldErrors :: (b -> t -> (t, Seq a)) -> t -> [b] -> (t, Seq a)

checkForDuplicates :: (Identifier -> Identifier -> Error) -> [Identifier] -> [Error]

equalId :: Identifier -> Identifier -> Bool

type RulesAndErrors = ([Rule], Seq Error)

type SigsAndErrors = ([TypeSig], Seq Error)

type InstsAndErrors = ([(Identifier, Type)], Seq Error)

type UniquesAndErrors = (Map Identifier Identifier, Seq Error)

type AugmentsAndErrors = (Map Identifier [Expression], Seq Error)

type AroundsAndErrors = (Map Identifier [Expression], Seq Error)

type MergesAndErrors = (Map Identifier (Identifier, [Identifier], Expression), Seq Error)

type AttrOverwrite = Map AttrName Bool

type AccumRuleCheck = (RulesAndErrors, AttrOverwrite)

type AccumDefiCheck = (Seq Error, AttrOverwrite, [AttrName], [AttrName])

checkRules :: Map NontermIdent (Attributes, Attributes) -> Map NontermIdent (Map ConstructorIdent FieldMap) -> Map NontermIdent (Map ConstructorIdent [Identifier]) -> Map NontermIdent (Map ConstructorIdent [SigInfo]) -> Map NontermIdent (Map ConstructorIdent [MergeInfo]) -> NontermIdent -> ConstructorIdent -> [RuleInfo] -> RulesAndErrors

checkRuleNames :: NontermIdent -> ConstructorIdent -> [RuleInfo] -> Seq Error

checkSigs :: NontermIdent -> ConstructorIdent -> [SigInfo] -> SigsAndErrors

checkInsts :: Set NontermIdent -> Map NontermIdent (Map ConstructorIdent [SigInfo]) -> Map NontermIdent (Map ConstructorIdent [(Identifier, Type)]) -> NontermIdent -> ConstructorIdent -> [Identifier] -> InstsAndErrors

checkUniques :: Map NontermIdent (Attributes, Attributes) -> NontermIdent -> ConstructorIdent -> [UniqueInfo] -> UniquesAndErrors

checkAugments :: Map NontermIdent (Attributes, Attributes) -> NontermIdent -> ConstructorIdent -> [AugmentInfo] -> AugmentsAndErrors

checkArounds :: Map NontermIdent (Map ConstructorIdent [(Identifier, Type)]) -> NontermIdent -> ConstructorIdent -> [AroundInfo] -> AroundsAndErrors

checkMerges :: Set NontermIdent -> Map NontermIdent (Map ConstructorIdent [Identifier]) -> Map NontermIdent (Map ConstructorIdent [(Identifier, Type)]) -> NontermIdent -> ConstructorIdent -> [MergeInfo] -> MergesAndErrors

unionunionplusplus :: Map NontermIdent (Map ConstructorIdent [a]) -> Map NontermIdent (Map ConstructorIdent [a]) -> Map NontermIdent (Map ConstructorIdent [a])

mkUniqueRules :: Options -> Map NontermIdent (Map ConstructorIdent [RuleInfo]) -> Map NontermIdent (Map ConstructorIdent [(Identifier, Type)]) -> Map NontermIdent (Map ConstructorIdent [(Identifier, Type)]) -> Map NontermIdent (Attributes, Attributes) -> NontermIdent -> ConstructorIdent -> Map Identifier Identifier -> [Rule]

flattenDatas :: DataTypes -> Map NontermIdent (Set NontermIdent)

reachableFrom :: Map NontermIdent (Set NontermIdent) -> Set NontermIdent -> Set NontermIdent

invert :: Map NontermIdent (Set NontermIdent) -> Map NontermIdent (Set NontermIdent)

path :: Map NontermIdent (Set NontermIdent) -> NontermIdent -> NontermIdent -> Set NontermIdent

extract :: [Char] -> [[Char]]

isSeparator :: Char -> Bool

pragmaMapUnion :: PragmaMap -> PragmaMap -> PragmaMap

pragmaMapSingle :: NontermIdent -> ConstructorIdent -> Set Identifier -> PragmaMap

orderMapUnion :: AttrOrderMap -> AttrOrderMap -> AttrOrderMap

orderMapSingle :: NontermIdent -> ConstructorIdent -> Set Dependency -> AttrOrderMap

mergeParams :: ParamMap -> ParamMap -> ParamMap

mergeCtx :: ContextMap -> ContextMap -> ContextMap

mergeQuant :: QuantMap -> QuantMap -> QuantMap

mergeDerivings :: (Ord a, Ord k) => Map k (Set a) -> Map k (Set a) -> Map k (Set a)

merge :: (Ord k, Ord k1) => Map k (Map k1 a) -> Map k (Map k1 a) -> Map k (Map k1 a)

checkAttrs :: Map NontermIdent a -> [NontermIdent] -> [(Identifier, val)] -> [(Identifier, val1)] -> Map NontermIdent (Map Identifier val, Map Identifier val1) -> (Map NontermIdent (Map Identifier val, Map Identifier val1), Seq Error)

addSelf :: Ord k1 => k1 -> Map k1 (Map k a, Map Identifier Type) -> Map k1 (Map k a, Map Identifier Type)

makeType :: Set NontermIdent -> Type -> Type

constructGrammar :: Set NontermIdent -> ParamMap -> Map NontermIdent (Map ConstructorIdent (Set Identifier)) -> DataTypes -> Map NontermIdent (Map ConstructorIdent [Type]) -> Map NontermIdent (Attributes, Attributes) -> Map NontermIdent (Map Identifier (String, String, String)) -> Derivings -> Set NontermIdent -> Map NontermIdent (Map ConstructorIdent [Rule]) -> Map NontermIdent (Map ConstructorIdent [TypeSig]) -> Map NontermIdent (Map ConstructorIdent [(Identifier, Type)]) -> TypeSyns -> PragmaMap -> AttrOrderMap -> ContextMap -> 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))) -> Map NontermIdent (Map ConstructorIdent MaybeMacro) -> Grammar

mapUnionWithSetUnion :: Map NontermIdent (Set ConstructorIdent) -> Map NontermIdent (Set ConstructorIdent) -> Map NontermIdent (Set ConstructorIdent)

mapUnionWithPlusPlus :: Map BlockInfo [a] -> Map BlockInfo [a] -> Map BlockInfo [a]