Productions( Production("AG","{options:=Options}","{blocks:=Blocks,errors:=Seq Error,trans:=Grammar}", Alternatives( Alternative("AG", Children( Child("elems","Elems","{attrDecls:=Map Nonterminal (Attributes, Attributes),attributes:=Map Nonterminal (Attributes, Attributes),datas:=DataTypes,datatypes:=DataTypes,defSets:=Map Name (Set Nonterminal,Set Name),definedSets:=DefinedSets,nonterminals:=Set Nonterminal,ruleMap:=RuleMap,withSelf:=Bool}","{attrDecls:=Map Nonterminal (Attributes, Attributes),blocks:=Blocks,datas:=DataTypes,defSets:=Map Name (Set Nonterminal,Set Name),defined_nts:=Set Nonterminal,derivings:=Derivings,errors:=Seq Error,ruleMap:=RuleMap,typeSyns:=TypeSyns,useMap:=Map Nonterminal (Map Name (String,String)),wrappers:=Set Nonterminal}", Rules( Rule("withSelf", Pattern( Var("Transform.ag(line 31, column 8)","elems.withSelf")), Expression("Transform.ag(line 31, column 25)","withSelf @lhs.options\n")), Rule("datas", Pattern( Var("Transform.ag(line 128, column 8)","elems.datas")), Expression("Transform.ag(line 128, column 22)","Map.empty\n")), Rule("datatypes", Pattern( Var("Transform.ag(line 129, column 8)","elems.datatypes")), Expression("Transform.ag(line 129, column 26)","@elems.datas\n")), Rule("attributes", Pattern( Var("Transform.ag(line 130, column 8)","elems.attributes")), Expression("Transform.ag(line 130, column 27)","@elems.attrDecls\n")), Rule("defSets", Pattern( Var("Transform.ag(line 194, column 8)","elems.defSets")), Expression("Transform.ag(line 194, column 24)","Map.mapWithKey (\\key _ -> (Set.single key, Set.empty)) @elems.datas\n")), Rule("definedSets", Pattern( Var("Transform.ag(line 194, column 8)","elems.definedSets")), Expression("Transform.ag(line 195, column 28)","Map.map fst @elems.defSets\n")), Rule("attrDecls", Pattern( Var("Transform.ag(line 322, column 8)","elems.attrDecls")), Expression("Transform.ag(line 322, column 26)","Map.empty\n")), Rule("ruleMap", Pattern( Var("Transform.ag(line 378, column 8)","elems.ruleMap")), Expression("Transform.ag(line 378, column 24)","Map.empty\n")), Rule("nonterminals", Pattern( Var("./ConcreteSyntax.ag(line 19, column 25)","elems.nonterminals")), Expression("","@nonterminals"))))), Rules( Rule("trans", Pattern( Var("Transform.ag(line 434, column 8)","lhs.trans")), Expression("Transform.ag(line 434, column 20)","let ws = if wrappers @lhs.options\n then @loc.nonterminals\n else @elems.wrappers\nin constructGrammar @loc.nonterminals @elems.datas @elems.attrDecls @elems.useMap\n @elems.derivings ws @elems.ruleMap @elems.typeSyns\n")), Rule("errors", Pattern( Var("","lhs.errors")), Expression("","@elems.errors")), Rule("blocks", Pattern( Var("","lhs.blocks")), Expression("","@elems.blocks"))), LocRules( LocRule("nonterminals", Pattern( Var("Transform.ag(line 131, column 8)","loc.nonterminals")), Expression("Transform.ag(line 131, column 27)","@elems.defined_nts\n"),"False"))))), Production("Alt","{nonterminals:=Set Nonterminal,nt:=Nonterminal}","{dataAlt:=(Constructor,FieldMap ),errors:=Seq Error}", Alternatives( Alternative("Alt", Children( Child("pos","Pos","{}","{}", Rules()), Child("name","Constructor","{}","{}", Rules()), Child("fields","Fields","{}","{}", Rules())), Rules( Rule("dataAlt", Pattern( Var("Transform.ag(line 109, column 9)","lhs.dataAlt")), Expression("Transform.ag(line 109, column 33)","(@name, @fieldMap)\n")), Rule("errors", Pattern( Var("","lhs.errors")), Expression("","@errors"))), LocRules( LocRule("_tup1", Pattern( Var("","loc._tup1")), Expression("Transform.ag(line 106, column 33)","let fields = [ (n,makeType @lhs.nonterminals t) | (n,t) <- @fields ]\n (_,errs) = checkDuplicates (DupChild @lhs.nt @name) fields Map.empty\nin (fields,errs)\n"),"False"), LocRule("fieldMap", Pattern( Product("Transform.ag(line 106, column 13)", Patterns( Pattern( Var("Transform.ag(line 106, column 9)","loc.fieldMap")), Pattern( Underscore("Transform.ag(line 106, column 13)"))))), Expression("Transform.ag(line 106, column 13)","@_tup1"),"False"), LocRule("errors", Pattern( Product("Transform.ag(line 106, column 13)", Patterns( Pattern( Underscore("Transform.ag(line 106, column 13)")), Pattern( Var("Transform.ag(line 106, column 9)","loc.errors"))))), Expression("Transform.ag(line 106, column 13)","@_tup1"),"False"))))), Production("Alts","{nonterminals:=Set Nonterminal,nt:=Nonterminal}","{dataAlts:=[(Constructor,FieldMap )],errors:=Seq Error}", Alternatives( Alternative("Cons", Children( Child("hd","Alt","{nonterminals:=Set Nonterminal,nt:=Nonterminal}","{dataAlt:=(Constructor,FieldMap ),errors:=Seq Error}", Rules( Rule("nonterminals", Pattern( Var("./ConcreteSyntax.ag(line 14, column 1)","hd.nonterminals")), Expression("","@lhs.nonterminals")), Rule("nt", Pattern( Var("./ConcreteSyntax.ag(line 14, column 1)","hd.nt")), Expression("","@lhs.nt")))), Child("tl","Alts","{nonterminals:=Set Nonterminal,nt:=Nonterminal}","{dataAlts:=[(Constructor,FieldMap )],errors:=Seq Error}", Rules( Rule("nonterminals", Pattern( Var("./ConcreteSyntax.ag(line 14, column 1)","tl.nonterminals")), Expression("","@lhs.nonterminals")), Rule("nt", Pattern( Var("./ConcreteSyntax.ag(line 14, column 1)","tl.nt")), Expression("","@lhs.nt"))))), Rules( Rule("dataAlts", Pattern( Var("Transform.ag(line 112, column 10)","lhs.dataAlts")), Expression("Transform.ag(line 112, column 25)","@hd.dataAlt : @tl.dataAlts\n")), Rule("errors", Pattern( Var("","lhs.errors")), Expression("","@hd.errors Seq.<> @tl.errors"))), LocRules()), Alternative("Nil", Children(), Rules( Rule("dataAlts", Pattern( Var("Transform.ag(line 113, column 10)","lhs.dataAlts")), Expression("Transform.ag(line 113, column 25)","[]\n")), Rule("errors", Pattern( Var("","lhs.errors")), Expression("","Seq.empty"))), LocRules()))), Production("Attrs","{attrDecls:=Map Nonterminal (Attributes, Attributes),datatypes:=DataTypes,nonterminals:=Set Nonterminal,nts:=Set Nonterminal}","{attrDecls:=Map Nonterminal (Attributes, Attributes),errors:=Seq Error,useMap:=Map Nonterminal (Map Name (String,String))}", Alternatives( Alternative("Attrs", Children( Child("pos","Pos","{}","{}", Rules()), Child("inh","AttrNames","{}","{}", Rules()), Child("chn","AttrNames","{}","{}", Rules()), Child("syn","AttrNames","{}","{}", Rules())), Rules( Rule("useMap", Pattern( Var("Transform.ag(line 339, column 11)","lhs.useMap")), Expression("Transform.ag(line 339, column 24)","Map.fromList (zip (Set.toList @lhs.nts) (repeat @useMap))\n")), Rule("errors", Pattern( Var("","lhs.errors")), Expression("","@errors")), Rule("attrDecls", Pattern( Var("","lhs.attrDecls")), Expression("","@attrDecls"))), LocRules( LocRule("_tup2", Pattern( Var("","loc._tup2")), Expression("Transform.ag(line 330, column 36)","checkAttrs @lhs.datatypes (Set.toList @lhs.nts) @inherited @synthesized @lhs.attrDecls\n"),"False"), LocRule("attrDecls", Pattern( Product("Transform.ag(line 330, column 15)", Patterns( Pattern( Var("Transform.ag(line 330, column 11)","loc.attrDecls")), Pattern( Underscore("Transform.ag(line 330, column 15)"))))), Expression("Transform.ag(line 330, column 15)","@_tup2"),"False"), LocRule("errors", Pattern( Product("Transform.ag(line 330, column 15)", Patterns( Pattern( Underscore("Transform.ag(line 330, column 15)")), Pattern( Var("Transform.ag(line 330, column 11)","loc.errors"))))), Expression("Transform.ag(line 330, column 15)","@_tup2"),"False"), LocRule("_tup3", Pattern( Var("","loc._tup3")), Expression("Transform.ag(line 332, column 48)","let splitAttrs xs = unzip [ ((n,makeType @lhs.nonterminals t),(n,(c,d)))\n | (n,t,(c,d)) <- xs ]\n (inh,_) = splitAttrs @inh\n (chn,uses1) = splitAttrs @chn\n (syn,uses2) = splitAttrs @syn\n isUse (n,(e1,e2)) = not (null e1 || null e2)\nin (inh++chn,chn++syn, Map.fromList (Prelude.filter isUse (uses1++uses2)))\n"),"False"), LocRule("inherited", Pattern( Product("Transform.ag(line 332, column 15)", Patterns( Pattern( Var("Transform.ag(line 330, column 11)","loc.inherited")), Pattern( Underscore("Transform.ag(line 332, column 15)")), Pattern( Underscore("Transform.ag(line 332, column 15)"))))), Expression("Transform.ag(line 332, column 15)","@_tup3"),"False"), LocRule("synthesized", Pattern( Product("Transform.ag(line 332, column 15)", Patterns( Pattern( Underscore("Transform.ag(line 332, column 15)")), Pattern( Var("Transform.ag(line 330, column 11)","loc.synthesized")), Pattern( Underscore("Transform.ag(line 332, column 15)"))))), Expression("Transform.ag(line 332, column 15)","@_tup3"),"False"), LocRule("useMap", Pattern( Product("Transform.ag(line 332, column 15)", Patterns( Pattern( Underscore("Transform.ag(line 332, column 15)")), Pattern( Underscore("Transform.ag(line 332, column 15)")), Pattern( Var("Transform.ag(line 330, column 11)","loc.useMap"))))), Expression("Transform.ag(line 332, column 15)","@_tup3"),"False"))))), Production("ConstructorSet","{definedConstructors:=Set.Set Constructor,nt:=Nonterminal}","{constructors:=Set.Set Constructor,errors:=Seq Error}", Alternatives( Alternative("CAll", Children(), Rules( Rule("constructors", Pattern( Var("Transform.ag(line 282, column 17)","lhs.constructors")), Expression("Transform.ag(line 282, column 36)","@lhs.definedConstructors\n")), Rule("errors", Pattern( Var("","lhs.errors")), Expression("","Seq.empty"))), LocRules()), Alternative("CDifference", Children( Child("set1","ConstructorSet","{definedConstructors:=Set.Set Constructor,nt:=Nonterminal}","{constructors:=Set.Set Constructor,errors:=Seq Error}", Rules( Rule("definedConstructors", Pattern( Var("./ConcreteSyntax.ag(line 70, column 18)","set1.definedConstructors")), Expression("","@lhs.definedConstructors")), Rule("nt", Pattern( Var("./ConcreteSyntax.ag(line 70, column 18)","set1.nt")), Expression("","@lhs.nt")))), Child("set2","ConstructorSet","{definedConstructors:=Set.Set Constructor,nt:=Nonterminal}","{constructors:=Set.Set Constructor,errors:=Seq Error}", Rules( Rule("definedConstructors", Pattern( Var("./ConcreteSyntax.ag(line 70, column 23)","set2.definedConstructors")), Expression("","@lhs.definedConstructors")), Rule("nt", Pattern( Var("./ConcreteSyntax.ag(line 70, column 23)","set2.nt")), Expression("","@lhs.nt"))))), Rules( Rule("constructors", Pattern( Var("Transform.ag(line 281, column 17)","lhs.constructors")), Expression("Transform.ag(line 281, column 36)","@set1.constructors `Set.difference` @set2.constructors\n")), Rule("errors", Pattern( Var("","lhs.errors")), Expression("","@set1.errors Seq.<> @set2.errors"))), LocRules()), Alternative("CName", Children( Child("name","Constructor","{}","{}", Rules())), Rules( Rule("errors", Pattern( Product("Transform.ag(line 275, column 15)", Patterns( Pattern( Var("Transform.ag(line 275, column 11)","lhs.errors")), Pattern( Underscore("Transform.ag(line 275, column 15)"))))), Expression("Transform.ag(line 275, column 15)","@_tup4")), Rule("constructors", Pattern( Product("Transform.ag(line 275, column 15)", Patterns( Pattern( Underscore("Transform.ag(line 275, column 15)")), Pattern( Var("Transform.ag(line 275, column 11)","lhs.constructors"))))), Expression("Transform.ag(line 275, column 15)","@_tup4"))), LocRules( LocRule("_tup4", Pattern( Var("","loc._tup4")), Expression("Transform.ag(line 275, column 39)","if @name `Set.member` @lhs.definedConstructors\n then (Seq.empty, Set.single @name)\n else (Seq.single (UndefAlt @lhs.nt @name)\n , Set.empty\n )\n"),"False"))), Alternative("CUnion", Children( Child("set1","ConstructorSet","{definedConstructors:=Set.Set Constructor,nt:=Nonterminal}","{constructors:=Set.Set Constructor,errors:=Seq Error}", Rules( Rule("definedConstructors", Pattern( Var("./ConcreteSyntax.ag(line 69, column 13)","set1.definedConstructors")), Expression("","@lhs.definedConstructors")), Rule("nt", Pattern( Var("./ConcreteSyntax.ag(line 69, column 13)","set1.nt")), Expression("","@lhs.nt")))), Child("set2","ConstructorSet","{definedConstructors:=Set.Set Constructor,nt:=Nonterminal}","{constructors:=Set.Set Constructor,errors:=Seq Error}", Rules( Rule("definedConstructors", Pattern( Var("./ConcreteSyntax.ag(line 69, column 18)","set2.definedConstructors")), Expression("","@lhs.definedConstructors")), Rule("nt", Pattern( Var("./ConcreteSyntax.ag(line 69, column 18)","set2.nt")), Expression("","@lhs.nt"))))), Rules( Rule("constructors", Pattern( Var("Transform.ag(line 280, column 12)","lhs.constructors")), Expression("Transform.ag(line 280, column 31)","@set1.constructors `Set.union` @set2.constructors\n")), Rule("errors", Pattern( Var("","lhs.errors")), Expression("","@set1.errors Seq.<> @set2.errors"))), LocRules()))), Production("Elem","{attrDecls:=Map Nonterminal (Attributes, Attributes),attributes:=Map Nonterminal (Attributes, Attributes),blocks:=Blocks,datas:=DataTypes,datatypes:=DataTypes,defSets:=Map Name (Set Nonterminal,Set Name),definedSets:=DefinedSets,nonterminals:=Set Nonterminal,ruleMap:=RuleMap,withSelf:=Bool}","{attrDecls:=Map Nonterminal (Attributes, Attributes),blocks:=Blocks,datas:=DataTypes,defSets:=Map Name (Set Nonterminal,Set Name),defined_nts:=Set Nonterminal,derivings:=Derivings,errors:=Seq Error,ruleMap:=RuleMap,typeSyns:=TypeSyns,useMap:=Map Nonterminal (Map Name (String,String)),wrappers:=Set Nonterminal}", Alternatives( Alternative("Attr", Children( Child("pos","Pos","{}","{}", Rules()), Child("names","NontSet","{datatypes:=DataTypes,definedSets:=DefinedSets,nonterminals:=Set Nonterminal}","{errors:=Seq Error,nontSet:=Set Nonterminal,usedNames:=Set Name}", Rules( Rule("datatypes", Pattern( Var("./ConcreteSyntax.ag(line 33, column 25)","names.datatypes")), Expression("","@lhs.datatypes")), Rule("definedSets", Pattern( Var("./ConcreteSyntax.ag(line 33, column 25)","names.definedSets")), Expression("","@lhs.definedSets")), Rule("nonterminals", Pattern( Var("./ConcreteSyntax.ag(line 33, column 25)","names.nonterminals")), Expression("","@lhs.nonterminals")))), Child("attrs","Attrs","{attrDecls:=Map Nonterminal (Attributes, Attributes),datatypes:=DataTypes,nonterminals:=Set Nonterminal,nts:=Set Nonterminal}","{attrDecls:=Map Nonterminal (Attributes, Attributes),errors:=Seq Error,useMap:=Map Nonterminal (Map Name (String,String))}", Rules( Rule("nts", Pattern( Var("Transform.ag(line 326, column 10)","attrs.nts")), Expression("Transform.ag(line 326, column 22)","@names.nontSet\n")), Rule("attrDecls", Pattern( Var("./ConcreteSyntax.ag(line 34, column 25)","attrs.attrDecls")), Expression("","@lhs.attrDecls")), Rule("datatypes", Pattern( Var("./ConcreteSyntax.ag(line 34, column 25)","attrs.datatypes")), Expression("","@lhs.datatypes")), Rule("nonterminals", Pattern( Var("./ConcreteSyntax.ag(line 34, column 25)","attrs.nonterminals")), Expression("","@lhs.nonterminals"))))), Rules( Rule("defined_nts", Pattern( Var("","lhs.defined_nts")), Expression("","Set.empty")), Rule("derivings", Pattern( Var("","lhs.derivings")), Expression("","Map.empty")), Rule("errors", Pattern( Var("","lhs.errors")), Expression("","@names.errors Seq.<> @attrs.errors")), Rule("typeSyns", Pattern( Var("","lhs.typeSyns")), Expression("","[]")), Rule("useMap", Pattern( Var("","lhs.useMap")), Expression("","@attrs.useMap")), Rule("wrappers", Pattern( Var("","lhs.wrappers")), Expression("","Set.empty")), Rule("attrDecls", Pattern( Var("","lhs.attrDecls")), Expression("","@attrs.attrDecls")), Rule("blocks", Pattern( Var("","lhs.blocks")), Expression("","@lhs.blocks")), Rule("datas", Pattern( Var("","lhs.datas")), Expression("","@lhs.datas")), Rule("defSets", Pattern( Var("","lhs.defSets")), Expression("","@lhs.defSets")), Rule("ruleMap", Pattern( Var("","lhs.ruleMap")), Expression("","@lhs.ruleMap"))), LocRules()), Alternative("Data", Children( Child("pos","Pos","{}","{}", Rules()), Child("name","Nonterminal","{}","{}", Rules()), Child("attrs","Attrs","{attrDecls:=Map Nonterminal (Attributes, Attributes),datatypes:=DataTypes,nonterminals:=Set Nonterminal,nts:=Set Nonterminal}","{attrDecls:=Map Nonterminal (Attributes, Attributes),errors:=Seq Error,useMap:=Map Nonterminal (Map Name (String,String))}", Rules( Rule("nts", Pattern( Var("Transform.ag(line 325, column 10)","attrs.nts")), Expression("Transform.ag(line 325, column 22)","Set.single @name\n")), Rule("attrDecls", Pattern( Var("Transform.ag(line 426, column 10)","attrs.attrDecls")), Expression("Transform.ag(line 426, column 28)","if @lhs.withSelf then addSelf @name @lhs.attrDecls else @lhs.attrDecls\n")), Rule("datatypes", Pattern( Var("./ConcreteSyntax.ag(line 24, column 25)","attrs.datatypes")), Expression("","@lhs.datatypes")), Rule("nonterminals", Pattern( Var("./ConcreteSyntax.ag(line 24, column 25)","attrs.nonterminals")), Expression("","@lhs.nonterminals")))), Child("alts","Alts","{nonterminals:=Set Nonterminal,nt:=Nonterminal}","{dataAlts:=[(Constructor,FieldMap )],errors:=Seq Error}", Rules( Rule("nt", Pattern( Var("Transform.ag(line 43, column 10)","alts.nt")), Expression("Transform.ag(line 43, column 20)","@name\n")), Rule("nonterminals", Pattern( Var("./ConcreteSyntax.ag(line 25, column 25)","alts.nonterminals")), Expression("","@lhs.nonterminals")))), Child("ext","Bool","{}","{}", Rules())), Rules( Rule("defined_nts", Pattern( Var("Transform.ag(line 124, column 10)","lhs.defined_nts")), Expression("Transform.ag(line 124, column 28)","Set.single @name\n")), Rule("datas", Pattern( Var("Transform.ag(line 135, column 10)","lhs.datas")), Expression("Transform.ag(line 135, column 23)","Map.insert @name @alternatives2 @lhs.datas\n")), Rule("errors", Pattern( Var("Transform.ag(line 136, column 10)","lhs.errors")), Expression("Transform.ag(line 136, column 23)","@attrs.errors <> @errs <> @alts.errors\n")), Rule("derivings", Pattern( Var("","lhs.derivings")), Expression("","Map.empty")), Rule("typeSyns", Pattern( Var("","lhs.typeSyns")), Expression("","[]")), Rule("useMap", Pattern( Var("","lhs.useMap")), Expression("","@attrs.useMap")), Rule("wrappers", Pattern( Var("","lhs.wrappers")), Expression("","Set.empty")), Rule("attrDecls", Pattern( Var("","lhs.attrDecls")), Expression("","@attrs.attrDecls")), Rule("blocks", Pattern( Var("","lhs.blocks")), Expression("","@lhs.blocks")), Rule("defSets", Pattern( Var("","lhs.defSets")), Expression("","@lhs.defSets")), Rule("ruleMap", Pattern( Var("","lhs.ruleMap")), Expression("","@lhs.ruleMap"))), LocRules( LocRule("_tup5", Pattern( Var("","loc._tup5")), Expression("Transform.ag(line 133, column 37)","checkDuplicates (DupAlt @name) @alts.dataAlts @alternatives\n"),"False"), LocRule("alternatives2", Pattern( Product("Transform.ag(line 133, column 14)", Patterns( Pattern( Var("Transform.ag(line 133, column 10)","loc.alternatives2")), Pattern( Underscore("Transform.ag(line 133, column 14)"))))), Expression("Transform.ag(line 133, column 14)","@_tup5"),"False"), LocRule("errs", Pattern( Product("Transform.ag(line 133, column 14)", Patterns( Pattern( Underscore("Transform.ag(line 133, column 14)")), Pattern( Var("Transform.ag(line 133, column 10)","loc.errs"))))), Expression("Transform.ag(line 133, column 14)","@_tup5"),"False"), LocRule("alternatives", Pattern( Var("Transform.ag(line 133, column 10)","loc.alternatives")), Expression("Transform.ag(line 134, column 29)","Map.findWithDefault Map.empty @name @lhs.datas\n"),"False"))), Alternative("Deriving", Children( Child("pos","Pos","{}","{}", Rules()), Child("set","NontSet","{datatypes:=DataTypes,definedSets:=DefinedSets,nonterminals:=Set Nonterminal}","{errors:=Seq Error,nontSet:=Set Nonterminal,usedNames:=Set Name}", Rules( Rule("datatypes", Pattern( Var("./ConcreteSyntax.ag(line 48, column 27)","set.datatypes")), Expression("","@lhs.datatypes")), Rule("definedSets", Pattern( Var("./ConcreteSyntax.ag(line 48, column 27)","set.definedSets")), Expression("","@lhs.definedSets")), Rule("nonterminals", Pattern( Var("./ConcreteSyntax.ag(line 48, column 27)","set.nonterminals")), Expression("","@lhs.nonterminals")))), Child("classes","[Name]","{}","{}", Rules())), Rules( Rule("derivings", Pattern( Var("Transform.ag(line 304, column 14)","lhs.derivings")), Expression("Transform.ag(line 304, column 30)","Map.fromList [(nt,Set.fromList @classes) | nt <- Set.toList @set.nontSet]\n")), Rule("defined_nts", Pattern( Var("","lhs.defined_nts")), Expression("","Set.empty")), Rule("errors", Pattern( Var("","lhs.errors")), Expression("","@set.errors")), Rule("typeSyns", Pattern( Var("","lhs.typeSyns")), Expression("","[]")), Rule("useMap", Pattern( Var("","lhs.useMap")), Expression("","Map.empty")), Rule("wrappers", Pattern( Var("","lhs.wrappers")), Expression("","Set.empty")), Rule("attrDecls", Pattern( Var("","lhs.attrDecls")), Expression("","@lhs.attrDecls")), Rule("blocks", Pattern( Var("","lhs.blocks")), Expression("","@lhs.blocks")), Rule("datas", Pattern( Var("","lhs.datas")), Expression("","@lhs.datas")), Rule("defSets", Pattern( Var("","lhs.defSets")), Expression("","@lhs.defSets")), Rule("ruleMap", Pattern( Var("","lhs.ruleMap")), Expression("","@lhs.ruleMap"))), LocRules()), Alternative("Sem", Children( Child("pos","Pos","{}","{}", Rules()), Child("name","Nonterminal","{}","{}", Rules()), Child("attrs","Attrs","{attrDecls:=Map Nonterminal (Attributes, Attributes),datatypes:=DataTypes,nonterminals:=Set Nonterminal,nts:=Set Nonterminal}","{attrDecls:=Map Nonterminal (Attributes, Attributes),errors:=Seq Error,useMap:=Map Nonterminal (Map Name (String,String))}", Rules( Rule("nts", Pattern( Var("Transform.ag(line 327, column 10)","attrs.nts")), Expression("Transform.ag(line 327, column 22)","Set.single @name\n")), Rule("attrDecls", Pattern( Var("./ConcreteSyntax.ag(line 38, column 25)","attrs.attrDecls")), Expression("","@lhs.attrDecls")), Rule("datatypes", Pattern( Var("./ConcreteSyntax.ag(line 38, column 25)","attrs.datatypes")), Expression("","@lhs.datatypes")), Rule("nonterminals", Pattern( Var("./ConcreteSyntax.ag(line 38, column 25)","attrs.nonterminals")), Expression("","@lhs.nonterminals")))), Child("alts","SemAlts","{alternatives:=DataAlts,attributes:=Map Nonterminal (Attributes, Attributes),nt:=Nonterminal,ruleMapAlt:=RuleMapAlt}","{errors:=Seq Error,ruleMapAlt:=RuleMapAlt}", Rules( Rule("nt", Pattern( Var("Transform.ag(line 44, column 10)","alts.nt")), Expression("Transform.ag(line 44, column 20)","@name\n")), Rule("ruleMapAlt", Pattern( Var("Transform.ag(line 381, column 9)","alts.ruleMapAlt")), Expression("Transform.ag(line 381, column 37)","Map.findWithDefault Map.empty @name @lhs.ruleMap\n")), Rule("alternatives", Pattern( Var("Transform.ag(line 381, column 9)","alts.alternatives")), Expression("Transform.ag(line 382, column 37)","Map.findWithDefault Map.empty @name @lhs.datatypes\n")), Rule("attributes", Pattern( Var("./ConcreteSyntax.ag(line 39, column 25)","alts.attributes")), Expression("","@lhs.attributes"))))), Rules( Rule("errors", Pattern( Var("Transform.ag(line 383, column 9)","lhs.errors")), Expression("Transform.ag(line 383, column 37)","let es = checkUndef UndefNont @name @lhs.datatypes @alts.errors\nin if null (Seq.toList es) then @attrs.errors else es\n")), Rule("ruleMap", Pattern( Var("Transform.ag(line 385, column 9)","lhs.ruleMap")), Expression("Transform.ag(line 385, column 37)","Map.insert @name @alts.ruleMapAlt @lhs.ruleMap\n")), Rule("defined_nts", Pattern( Var("","lhs.defined_nts")), Expression("","Set.empty")), Rule("derivings", Pattern( Var("","lhs.derivings")), Expression("","Map.empty")), Rule("typeSyns", Pattern( Var("","lhs.typeSyns")), Expression("","[]")), Rule("useMap", Pattern( Var("","lhs.useMap")), Expression("","@attrs.useMap")), Rule("wrappers", Pattern( Var("","lhs.wrappers")), Expression("","Set.empty")), Rule("attrDecls", Pattern( Var("","lhs.attrDecls")), Expression("","@attrs.attrDecls")), Rule("blocks", Pattern( Var("","lhs.blocks")), Expression("","@lhs.blocks")), Rule("datas", Pattern( Var("","lhs.datas")), Expression("","@lhs.datas")), Rule("defSets", Pattern( Var("","lhs.defSets")), Expression("","@lhs.defSets"))), LocRules()), Alternative("Set", Children( Child("pos","Pos","{}","{}", Rules()), Child("name","Name","{}","{}", Rules()), Child("set","NontSet","{datatypes:=DataTypes,definedSets:=DefinedSets,nonterminals:=Set Nonterminal}","{errors:=Seq Error,nontSet:=Set Nonterminal,usedNames:=Set Name}", Rules( Rule("datatypes", Pattern( Var("./ConcreteSyntax.ag(line 46, column 25)","set.datatypes")), Expression("","@lhs.datatypes")), Rule("definedSets", Pattern( Var("./ConcreteSyntax.ag(line 46, column 25)","set.definedSets")), Expression("","@lhs.definedSets")), Rule("nonterminals", Pattern( Var("./ConcreteSyntax.ag(line 46, column 25)","set.nonterminals")), Expression("","@lhs.nonterminals"))))), Rules( Rule("defSets", Pattern( Var("Transform.ag(line 209, column 9)","lhs.defSets")), Expression("Transform.ag(line 209, column 31)","@defSets'\n")), Rule("errors", Pattern( Var("Transform.ag(line 209, column 9)","lhs.errors")), Expression("Transform.ag(line 210, column 31)","@errs Seq.<> @set.errors\n")), Rule("defined_nts", Pattern( Var("","lhs.defined_nts")), Expression("","Set.empty")), Rule("derivings", Pattern( Var("","lhs.derivings")), Expression("","Map.empty")), Rule("typeSyns", Pattern( Var("","lhs.typeSyns")), Expression("","[]")), Rule("useMap", Pattern( Var("","lhs.useMap")), Expression("","Map.empty")), Rule("wrappers", Pattern( Var("","lhs.wrappers")), Expression("","Set.empty")), Rule("attrDecls", Pattern( Var("","lhs.attrDecls")), Expression("","@lhs.attrDecls")), Rule("blocks", Pattern( Var("","lhs.blocks")), Expression("","@lhs.blocks")), Rule("datas", Pattern( Var("","lhs.datas")), Expression("","@lhs.datas")), Rule("ruleMap", Pattern( Var("","lhs.ruleMap")), Expression("","@lhs.ruleMap"))), LocRules( LocRule("_tup6", Pattern( Var("","loc._tup6")), Expression("Transform.ag(line 199, column 31)","let allUsedNames = Set.unions [ ns\n | n <- Set.toList @set.usedNames\n , let ns = maybe (Set.single n) snd\n (Map.lookup n @lhs.defSets)\n ]\n (nontSet,e1) | Set.member @name allUsedNames\n = (Set.empty, Seq.single(CyclicSet @name))\n | otherwise = (@set.nontSet, Seq.empty)\n (res, e2) = checkDuplicate DupSet @name (nontSet,Set.insert @name allUsedNames) @lhs.defSets\nin (res, e1 Seq.<> e2)\n"),"False"), LocRule("defSets'", Pattern( Product("Transform.ag(line 199, column 13)", Patterns( Pattern( Var("Transform.ag(line 199, column 9)","loc.defSets'")), Pattern( Underscore("Transform.ag(line 199, column 13)"))))), Expression("Transform.ag(line 199, column 13)","@_tup6"),"False"), LocRule("errs", Pattern( Product("Transform.ag(line 199, column 13)", Patterns( Pattern( Underscore("Transform.ag(line 199, column 13)")), Pattern( Var("Transform.ag(line 199, column 9)","loc.errs"))))), Expression("Transform.ag(line 199, column 13)","@_tup6"),"False"))), Alternative("Txt", Children( Child("pos","Pos","{}","{}", Rules()), Child("name","Name","{}","{}", Rules()), Child("lines","[String]","{}","{}", Rules())), Rules( Rule("blocks", Pattern( Var("Transform.ag(line 71, column 11)","lhs.blocks")), Expression("Transform.ag(line 71, column 25)","Map.insertWith (++) @name @lines @lhs.blocks\n")), Rule("defined_nts", Pattern( Var("","lhs.defined_nts")), Expression("","Set.empty")), Rule("derivings", Pattern( Var("","lhs.derivings")), Expression("","Map.empty")), Rule("errors", Pattern( Var("","lhs.errors")), Expression("","Seq.empty")), Rule("typeSyns", Pattern( Var("","lhs.typeSyns")), Expression("","[]")), Rule("useMap", Pattern( Var("","lhs.useMap")), Expression("","Map.empty")), Rule("wrappers", Pattern( Var("","lhs.wrappers")), Expression("","Set.empty")), Rule("attrDecls", Pattern( Var("","lhs.attrDecls")), Expression("","@lhs.attrDecls")), Rule("datas", Pattern( Var("","lhs.datas")), Expression("","@lhs.datas")), Rule("defSets", Pattern( Var("","lhs.defSets")), Expression("","@lhs.defSets")), Rule("ruleMap", Pattern( Var("","lhs.ruleMap")), Expression("","@lhs.ruleMap"))), LocRules()), Alternative("Type", Children( Child("pos","Pos","{}","{}", Rules()), Child("name","Nonterminal","{}","{}", Rules()), Child("type","ComplexType","{}","{}", Rules())), Rules( Rule("defined_nts", Pattern( Var("Transform.ag(line 125, column 10)","lhs.defined_nts")), Expression("Transform.ag(line 125, column 28)","Set.single @name\n")), Rule("typeSyns", Pattern( Var("Transform.ag(line 181, column 11)","lhs.typeSyns")), Expression("Transform.ag(line 181, column 32)","if Map.member @name @lhs.datas\n then []\n else [(@name,@argType)]\n")), Rule("attrDecls", Pattern( Var("Transform.ag(line 427, column 10)","lhs.attrDecls")), Expression("Transform.ag(line 427, column 28)","if @lhs.withSelf then addSelf @name @lhs.attrDecls else @lhs.attrDecls\n")), Rule("derivings", Pattern( Var("","lhs.derivings")), Expression("","Map.empty")), Rule("errors", Pattern( Var("","lhs.errors")), Expression("","@errors")), Rule("useMap", Pattern( Var("","lhs.useMap")), Expression("","Map.empty")), Rule("wrappers", Pattern( Var("","lhs.wrappers")), Expression("","Set.empty")), Rule("blocks", Pattern( Var("","lhs.blocks")), Expression("","@lhs.blocks")), Rule("datas", Pattern( Var("","lhs.datas")), Expression("","@datas")), Rule("defSets", Pattern( Var("","lhs.defSets")), Expression("","@lhs.defSets")), Rule("ruleMap", Pattern( Var("","lhs.ruleMap")), Expression("","@lhs.ruleMap"))), LocRules( LocRule("_tup7", Pattern( Var("","loc._tup7")), Expression("Transform.ag(line 162, column 32)","let expanded\n = case @argType of\n List tp -> [(Ident \"Cons\" @pos, [(Ident \"hd\" @pos, tp)\n ,(Ident \"tl\" @pos, NT @name)\n ]\n )\n ,(Ident \"Nil\" @pos, [])\n ]\n Maybe tp -> [(Ident \"Just\" @pos, [(Ident \"just\" @pos, tp)\n ]\n )\n ,(Ident \"Nothing\" @pos, [])\n ]\n Tuple xs -> [(Ident \"Tuple\" @pos, xs)]\nin checkDuplicate DupSynonym @name (Map.fromList expanded) @lhs.datas\n"),"False"), LocRule("datas", Pattern( Product("Transform.ag(line 162, column 15)", Patterns( Pattern( Var("Transform.ag(line 162, column 11)","loc.datas")), Pattern( Underscore("Transform.ag(line 162, column 15)"))))), Expression("Transform.ag(line 162, column 15)","@_tup7"),"False"), LocRule("errors", Pattern( Product("Transform.ag(line 162, column 15)", Patterns( Pattern( Underscore("Transform.ag(line 162, column 15)")), Pattern( Var("Transform.ag(line 162, column 11)","loc.errors"))))), Expression("Transform.ag(line 162, column 15)","@_tup7"),"False"), LocRule("argType", Pattern( Var("Transform.ag(line 177, column 11)","loc.argType")), Expression("Transform.ag(line 177, column 32)","case @type of\n Maybe tp -> Maybe (makeType @lhs.nonterminals tp)\n List tp -> List (makeType @lhs.nonterminals tp)\n Tuple xs -> Tuple [(f,makeType @lhs.nonterminals tp) | (f,tp) <- xs]\n"),"False"))), Alternative("Wrapper", Children( Child("pos","Pos","{}","{}", Rules()), Child("set","NontSet","{datatypes:=DataTypes,definedSets:=DefinedSets,nonterminals:=Set Nonterminal}","{errors:=Seq Error,nontSet:=Set Nonterminal,usedNames:=Set Name}", Rules( Rule("datatypes", Pattern( Var("./ConcreteSyntax.ag(line 51, column 27)","set.datatypes")), Expression("","@lhs.datatypes")), Rule("definedSets", Pattern( Var("./ConcreteSyntax.ag(line 51, column 27)","set.definedSets")), Expression("","@lhs.definedSets")), Rule("nonterminals", Pattern( Var("./ConcreteSyntax.ag(line 51, column 27)","set.nonterminals")), Expression("","@lhs.nonterminals"))))), Rules( Rule("wrappers", Pattern( Var("Transform.ag(line 291, column 13)","lhs.wrappers")), Expression("Transform.ag(line 291, column 28)","@set.nontSet\n")), Rule("defined_nts", Pattern( Var("","lhs.defined_nts")), Expression("","Set.empty")), Rule("derivings", Pattern( Var("","lhs.derivings")), Expression("","Map.empty")), Rule("errors", Pattern( Var("","lhs.errors")), Expression("","@set.errors")), Rule("typeSyns", Pattern( Var("","lhs.typeSyns")), Expression("","[]")), Rule("useMap", Pattern( Var("","lhs.useMap")), Expression("","Map.empty")), Rule("attrDecls", Pattern( Var("","lhs.attrDecls")), Expression("","@lhs.attrDecls")), Rule("blocks", Pattern( Var("","lhs.blocks")), Expression("","@lhs.blocks")), Rule("datas", Pattern( Var("","lhs.datas")), Expression("","@lhs.datas")), Rule("defSets", Pattern( Var("","lhs.defSets")), Expression("","@lhs.defSets")), Rule("ruleMap", Pattern( Var("","lhs.ruleMap")), Expression("","@lhs.ruleMap"))), LocRules()))), Production("Elems","{attrDecls:=Map Nonterminal (Attributes, Attributes),attributes:=Map Nonterminal (Attributes, Attributes),datas:=DataTypes,datatypes:=DataTypes,defSets:=Map Name (Set Nonterminal,Set Name),definedSets:=DefinedSets,nonterminals:=Set Nonterminal,ruleMap:=RuleMap,withSelf:=Bool}","{attrDecls:=Map Nonterminal (Attributes, Attributes),blocks:=Blocks,datas:=DataTypes,defSets:=Map Name (Set Nonterminal,Set Name),defined_nts:=Set Nonterminal,derivings:=Derivings,errors:=Seq Error,ruleMap:=RuleMap,typeSyns:=TypeSyns,useMap:=Map Nonterminal (Map Name (String,String)),wrappers:=Set Nonterminal}", Alternatives( Alternative("Cons", Children( Child("hd","Elem","{attrDecls:=Map Nonterminal (Attributes, Attributes),attributes:=Map Nonterminal (Attributes, Attributes),blocks:=Blocks,datas:=DataTypes,datatypes:=DataTypes,defSets:=Map Name (Set Nonterminal,Set Name),definedSets:=DefinedSets,nonterminals:=Set Nonterminal,ruleMap:=RuleMap,withSelf:=Bool}","{attrDecls:=Map Nonterminal (Attributes, Attributes),blocks:=Blocks,datas:=DataTypes,defSets:=Map Name (Set Nonterminal,Set Name),defined_nts:=Set Nonterminal,derivings:=Derivings,errors:=Seq Error,ruleMap:=RuleMap,typeSyns:=TypeSyns,useMap:=Map Nonterminal (Map Name (String,String)),wrappers:=Set Nonterminal}", Rules( Rule("blocks", Pattern( Var("Transform.ag(line 64, column 10)","hd.blocks")), Expression("Transform.ag(line 64, column 23)","@tl.blocks\n")), Rule("ruleMap", Pattern( Var("Transform.ag(line 372, column 10)","hd.ruleMap")), Expression("Transform.ag(line 372, column 24)","@tl.ruleMap\n")), Rule("attrDecls", Pattern( Var("./ConcreteSyntax.ag(line 12, column 1)","hd.attrDecls")), Expression("","@lhs.attrDecls")), Rule("attributes", Pattern( Var("./ConcreteSyntax.ag(line 12, column 1)","hd.attributes")), Expression("","@lhs.attributes")), Rule("datas", Pattern( Var("./ConcreteSyntax.ag(line 12, column 1)","hd.datas")), Expression("","@lhs.datas")), Rule("datatypes", Pattern( Var("./ConcreteSyntax.ag(line 12, column 1)","hd.datatypes")), Expression("","@lhs.datatypes")), Rule("defSets", Pattern( Var("./ConcreteSyntax.ag(line 12, column 1)","hd.defSets")), Expression("","@lhs.defSets")), Rule("definedSets", Pattern( Var("./ConcreteSyntax.ag(line 12, column 1)","hd.definedSets")), Expression("","@lhs.definedSets")), Rule("nonterminals", Pattern( Var("./ConcreteSyntax.ag(line 12, column 1)","hd.nonterminals")), Expression("","@lhs.nonterminals")), Rule("withSelf", Pattern( Var("./ConcreteSyntax.ag(line 12, column 1)","hd.withSelf")), Expression("","@lhs.withSelf")))), Child("tl","Elems","{attrDecls:=Map Nonterminal (Attributes, Attributes),attributes:=Map Nonterminal (Attributes, Attributes),datas:=DataTypes,datatypes:=DataTypes,defSets:=Map Name (Set Nonterminal,Set Name),definedSets:=DefinedSets,nonterminals:=Set Nonterminal,ruleMap:=RuleMap,withSelf:=Bool}","{attrDecls:=Map Nonterminal (Attributes, Attributes),blocks:=Blocks,datas:=DataTypes,defSets:=Map Name (Set Nonterminal,Set Name),defined_nts:=Set Nonterminal,derivings:=Derivings,errors:=Seq Error,ruleMap:=RuleMap,typeSyns:=TypeSyns,useMap:=Map Nonterminal (Map Name (String,String)),wrappers:=Set Nonterminal}", Rules( Rule("ruleMap", Pattern( Var("Transform.ag(line 373, column 10)","tl.ruleMap")), Expression("Transform.ag(line 373, column 24)","@lhs.ruleMap\n")), Rule("attrDecls", Pattern( Var("./ConcreteSyntax.ag(line 12, column 1)","tl.attrDecls")), Expression("","@hd.attrDecls")), Rule("attributes", Pattern( Var("./ConcreteSyntax.ag(line 12, column 1)","tl.attributes")), Expression("","@lhs.attributes")), Rule("datas", Pattern( Var("./ConcreteSyntax.ag(line 12, column 1)","tl.datas")), Expression("","@hd.datas")), Rule("datatypes", Pattern( Var("./ConcreteSyntax.ag(line 12, column 1)","tl.datatypes")), Expression("","@lhs.datatypes")), Rule("defSets", Pattern( Var("./ConcreteSyntax.ag(line 12, column 1)","tl.defSets")), Expression("","@hd.defSets")), Rule("definedSets", Pattern( Var("./ConcreteSyntax.ag(line 12, column 1)","tl.definedSets")), Expression("","@lhs.definedSets")), Rule("nonterminals", Pattern( Var("./ConcreteSyntax.ag(line 12, column 1)","tl.nonterminals")), Expression("","@lhs.nonterminals")), Rule("withSelf", Pattern( Var("./ConcreteSyntax.ag(line 12, column 1)","tl.withSelf")), Expression("","@lhs.withSelf"))))), Rules( Rule("blocks", Pattern( Var("Transform.ag(line 65, column 10)","lhs.blocks")), Expression("Transform.ag(line 65, column 23)","@hd.blocks\n")), Rule("ruleMap", Pattern( Var("Transform.ag(line 371, column 10)","lhs.ruleMap")), Expression("Transform.ag(line 371, column 24)","@hd.ruleMap\n")), Rule("defined_nts", Pattern( Var("","lhs.defined_nts")), Expression("","@hd.defined_nts `Set.union` @tl.defined_nts")), Rule("derivings", Pattern( Var("","lhs.derivings")), Expression("","@hd.derivings `mergeDerivings` @tl.derivings")), Rule("errors", Pattern( Var("","lhs.errors")), Expression("","@hd.errors Seq.<> @tl.errors")), Rule("typeSyns", Pattern( Var("","lhs.typeSyns")), Expression("","@hd.typeSyns ++ @tl.typeSyns")), Rule("useMap", Pattern( Var("","lhs.useMap")), Expression("","@hd.useMap `merge` @tl.useMap")), Rule("wrappers", Pattern( Var("","lhs.wrappers")), Expression("","@hd.wrappers `Set.union` @tl.wrappers")), Rule("attrDecls", Pattern( Var("","lhs.attrDecls")), Expression("","@tl.attrDecls")), Rule("datas", Pattern( Var("","lhs.datas")), Expression("","@tl.datas")), Rule("defSets", Pattern( Var("","lhs.defSets")), Expression("","@tl.defSets"))), LocRules()), Alternative("Nil", Children(), Rules( Rule("blocks", Pattern( Var("Transform.ag(line 66, column 10)","lhs.blocks")), Expression("Transform.ag(line 66, column 23)","Map.empty\n")), Rule("defined_nts", Pattern( Var("","lhs.defined_nts")), Expression("","Set.empty")), Rule("derivings", Pattern( Var("","lhs.derivings")), Expression("","Map.empty")), Rule("errors", Pattern( Var("","lhs.errors")), Expression("","Seq.empty")), Rule("typeSyns", Pattern( Var("","lhs.typeSyns")), Expression("","[]")), Rule("useMap", Pattern( Var("","lhs.useMap")), Expression("","Map.empty")), Rule("wrappers", Pattern( Var("","lhs.wrappers")), Expression("","Set.empty")), Rule("attrDecls", Pattern( Var("","lhs.attrDecls")), Expression("","@lhs.attrDecls")), Rule("datas", Pattern( Var("","lhs.datas")), Expression("","@lhs.datas")), Rule("defSets", Pattern( Var("","lhs.defSets")), Expression("","@lhs.defSets")), Rule("ruleMap", Pattern( Var("","lhs.ruleMap")), Expression("","@lhs.ruleMap"))), LocRules()))), Production("NontSet","{datatypes:=DataTypes,definedSets:=DefinedSets,nonterminals:=Set Nonterminal}","{errors:=Seq Error,nontSet:=Set Nonterminal,usedNames:=Set Name}", Alternatives( Alternative("All", Children(), Rules( Rule("nontSet", Pattern( Var("Transform.ag(line 223, column 16)","lhs.nontSet")), Expression("Transform.ag(line 223, column 30)","@lhs.nonterminals\n")), Rule("errors", Pattern( Var("","lhs.errors")), Expression("","Seq.empty")), Rule("usedNames", Pattern( Var("","lhs.usedNames")), Expression("","Set.empty"))), LocRules()), Alternative("Difference", Children( Child("set1","NontSet","{datatypes:=DataTypes,definedSets:=DefinedSets,nonterminals:=Set Nonterminal}","{errors:=Seq Error,nontSet:=Set Nonterminal,usedNames:=Set Name}", Rules( Rule("datatypes", Pattern( Var("./ConcreteSyntax.ag(line 77, column 29)","set1.datatypes")), Expression("","@lhs.datatypes")), Rule("definedSets", Pattern( Var("./ConcreteSyntax.ag(line 77, column 29)","set1.definedSets")), Expression("","@lhs.definedSets")), Rule("nonterminals", Pattern( Var("./ConcreteSyntax.ag(line 77, column 29)","set1.nonterminals")), Expression("","@lhs.nonterminals")))), Child("set2","NontSet","{datatypes:=DataTypes,definedSets:=DefinedSets,nonterminals:=Set Nonterminal}","{errors:=Seq Error,nontSet:=Set Nonterminal,usedNames:=Set Name}", Rules( Rule("datatypes", Pattern( Var("./ConcreteSyntax.ag(line 77, column 34)","set2.datatypes")), Expression("","@lhs.datatypes")), Rule("definedSets", Pattern( Var("./ConcreteSyntax.ag(line 77, column 34)","set2.definedSets")), Expression("","@lhs.definedSets")), Rule("nonterminals", Pattern( Var("./ConcreteSyntax.ag(line 77, column 34)","set2.nonterminals")), Expression("","@lhs.nonterminals"))))), Rules( Rule("nontSet", Pattern( Var("Transform.ag(line 230, column 16)","lhs.nontSet")), Expression("Transform.ag(line 230, column 30)","Set.difference @set1.nontSet @set2.nontSet\n")), Rule("errors", Pattern( Var("","lhs.errors")), Expression("","@set1.errors Seq.<> @set2.errors")), Rule("usedNames", Pattern( Var("","lhs.usedNames")), Expression("","@set1.usedNames `Set.union` @set2.usedNames"))), LocRules()), Alternative("Intersect", Children( Child("set1","NontSet","{datatypes:=DataTypes,definedSets:=DefinedSets,nonterminals:=Set Nonterminal}","{errors:=Seq Error,nontSet:=Set Nonterminal,usedNames:=Set Name}", Rules( Rule("datatypes", Pattern( Var("./ConcreteSyntax.ag(line 76, column 28)","set1.datatypes")), Expression("","@lhs.datatypes")), Rule("definedSets", Pattern( Var("./ConcreteSyntax.ag(line 76, column 28)","set1.definedSets")), Expression("","@lhs.definedSets")), Rule("nonterminals", Pattern( Var("./ConcreteSyntax.ag(line 76, column 28)","set1.nonterminals")), Expression("","@lhs.nonterminals")))), Child("set2","NontSet","{datatypes:=DataTypes,definedSets:=DefinedSets,nonterminals:=Set Nonterminal}","{errors:=Seq Error,nontSet:=Set Nonterminal,usedNames:=Set Name}", Rules( Rule("datatypes", Pattern( Var("./ConcreteSyntax.ag(line 76, column 33)","set2.datatypes")), Expression("","@lhs.datatypes")), Rule("definedSets", Pattern( Var("./ConcreteSyntax.ag(line 76, column 33)","set2.definedSets")), Expression("","@lhs.definedSets")), Rule("nonterminals", Pattern( Var("./ConcreteSyntax.ag(line 76, column 33)","set2.nonterminals")), Expression("","@lhs.nonterminals"))))), Rules( Rule("nontSet", Pattern( Var("Transform.ag(line 229, column 16)","lhs.nontSet")), Expression("Transform.ag(line 229, column 30)","Set.intersection @set1.nontSet @set2.nontSet\n")), Rule("errors", Pattern( Var("","lhs.errors")), Expression("","@set1.errors Seq.<> @set2.errors")), Rule("usedNames", Pattern( Var("","lhs.usedNames")), Expression("","@set1.usedNames `Set.union` @set2.usedNames"))), LocRules()), Alternative("NamedSet", Children( Child("name","Nonterminal","{}","{}", Rules())), Rules( Rule("usedNames", Pattern( Var("Transform.ag(line 220, column 16)","lhs.usedNames")), Expression("Transform.ag(line 220, column 32)","Set.single @name\n")), Rule("errors", Pattern( Var("","lhs.errors")), Expression("","@errors")), Rule("nontSet", Pattern( Var("","lhs.nontSet")), Expression("","@nontSet"))), LocRules( LocRule("_tup8", Pattern( Var("","loc._tup8")), Expression("Transform.ag(line 224, column 39)","case Map.lookup @name @lhs.definedSets of\n Nothing -> (Set.empty, Seq.single (UndefNont @name))\n Just set -> (set, Seq.empty)\n"),"False"), LocRule("nontSet", Pattern( Product("Transform.ag(line 224, column 20)", Patterns( Pattern( Var("Transform.ag(line 224, column 16)","loc.nontSet")), Pattern( Underscore("Transform.ag(line 224, column 20)"))))), Expression("Transform.ag(line 224, column 20)","@_tup8"),"False"), LocRule("errors", Pattern( Product("Transform.ag(line 224, column 20)", Patterns( Pattern( Underscore("Transform.ag(line 224, column 20)")), Pattern( Var("Transform.ag(line 224, column 16)","loc.errors"))))), Expression("Transform.ag(line 224, column 20)","@_tup8"),"False"))), Alternative("Path", Children( Child("from","Nonterminal","{}","{}", Rules()), Child("to","Nonterminal","{}","{}", Rules())), Rules( Rule("nontSet", Pattern( Var("Transform.ag(line 231, column 16)","lhs.nontSet")), Expression("Transform.ag(line 231, column 30)","let table = flattenDatas @lhs.datatypes\nin path table @from @to\n")), Rule("errors", Pattern( Var("Transform.ag(line 235, column 16)","lhs.errors")), Expression("Transform.ag(line 235, column 29)","let check name | Set.member name @lhs.nonterminals\n = Seq.empty\n | otherwise = Seq.single (UndefNont name)\nin check @from <> check @to\n")), Rule("usedNames", Pattern( Var("","lhs.usedNames")), Expression("","Set.empty"))), LocRules()), Alternative("Union", Children( Child("set1","NontSet","{datatypes:=DataTypes,definedSets:=DefinedSets,nonterminals:=Set Nonterminal}","{errors:=Seq Error,nontSet:=Set Nonterminal,usedNames:=Set Name}", Rules( Rule("datatypes", Pattern( Var("./ConcreteSyntax.ag(line 75, column 24)","set1.datatypes")), Expression("","@lhs.datatypes")), Rule("definedSets", Pattern( Var("./ConcreteSyntax.ag(line 75, column 24)","set1.definedSets")), Expression("","@lhs.definedSets")), Rule("nonterminals", Pattern( Var("./ConcreteSyntax.ag(line 75, column 24)","set1.nonterminals")), Expression("","@lhs.nonterminals")))), Child("set2","NontSet","{datatypes:=DataTypes,definedSets:=DefinedSets,nonterminals:=Set Nonterminal}","{errors:=Seq Error,nontSet:=Set Nonterminal,usedNames:=Set Name}", Rules( Rule("datatypes", Pattern( Var("./ConcreteSyntax.ag(line 75, column 29)","set2.datatypes")), Expression("","@lhs.datatypes")), Rule("definedSets", Pattern( Var("./ConcreteSyntax.ag(line 75, column 29)","set2.definedSets")), Expression("","@lhs.definedSets")), Rule("nonterminals", Pattern( Var("./ConcreteSyntax.ag(line 75, column 29)","set2.nonterminals")), Expression("","@lhs.nonterminals"))))), Rules( Rule("nontSet", Pattern( Var("Transform.ag(line 228, column 16)","lhs.nontSet")), Expression("Transform.ag(line 228, column 30)","Set.union @set1.nontSet @set2.nontSet\n")), Rule("errors", Pattern( Var("","lhs.errors")), Expression("","@set1.errors Seq.<> @set2.errors")), Rule("usedNames", Pattern( Var("","lhs.usedNames")), Expression("","@set1.usedNames `Set.union` @set2.usedNames"))), LocRules()))), Production("SemAlt","{alternatives:=DataAlts,attributes:=Map Nonterminal (Attributes, Attributes),nt:=Nonterminal,ruleMapAlt:=RuleMapAlt}","{errors:=Seq Error,ruleMapAlt:=RuleMapAlt}", Alternatives( Alternative("SemAlt", Children( Child("pos","Pos","{}","{}", Rules()), Child("constructorSet","ConstructorSet","{definedConstructors:=Set.Set Constructor,nt:=Nonterminal}","{constructors:=Set.Set Constructor,errors:=Seq Error}", Rules( Rule("definedConstructors", Pattern( Var("Transform.ag(line 395, column 12)","constructorSet.definedConstructors")), Expression("Transform.ag(line 395, column 49)","@constructors\n")), Rule("nt", Pattern( Var("./ConcreteSyntax.ag(line 63, column 25)","constructorSet.nt")), Expression("","@lhs.nt")))), Child("rules","SemDefs","{}","{}", Rules())), Rules( Rule("ruleMapAlt", Pattern( Var("Transform.ag(line 393, column 12)","lhs.ruleMapAlt")), Expression("Transform.ag(line 393, column 37)","foldr (\\(con,rules) rsMap ->Map.insert con rules rsMap) @lhs.ruleMapAlt @ruless\n")), Rule("errors", Pattern( Var("Transform.ag(line 393, column 12)","lhs.errors")), Expression("Transform.ag(line 394, column 37)","@constructorSet.errors <> foldr (Seq.<>) Seq.empty @errors\n"))), LocRules( LocRule("constructors", Pattern( Var("Transform.ag(line 396, column 12)","loc.constructors")), Expression("Transform.ag(line 396, column 31)","Set.fromList (Map.keys @lhs.alternatives )\n"),"False"), LocRule("_tup9", Pattern( Var("","loc._tup9")), Expression("Transform.ag(line 399, column 16)","unzip (map rules (Set.toList @constructorSet.constructors))\n where rules con = let rules = Map.findWithDefault ([],Map.empty) con @lhs.ruleMapAlt\n fieldMap = Map.findWithDefault [] con @lhs.alternatives\n inherited = SemRules.Inh_SemDefs\n { SemRules.attributes_Inh_SemDefs = @lhs.attributes\n , SemRules.con_Inh_SemDefs = con\n , SemRules.fieldMap_Inh_SemDefs = fieldMap\n , SemRules.nt_Inh_SemDefs = @lhs.nt\n , SemRules.rules_Inh_SemDefs = rules\n }\n result = semDefs inherited\n in ( SemRules.errors_Syn_SemDefs result\n Seq.<> checkUndef (UndefAlt @lhs.nt) con @lhs.alternatives Seq.empty\n , (con,SemRules.rules_Syn_SemDefs result)\n )\n semDefs = SemRules.wrap_SemDefs (SemRules.sem_SemDefs @rules)\n"),"False"), LocRule("errors", Pattern( Product("Transform.ag(line 398, column 16)", Patterns( Pattern( Var("Transform.ag(line 398, column 12)","loc.errors")), Pattern( Underscore("Transform.ag(line 398, column 16)"))))), Expression("Transform.ag(line 398, column 16)","@_tup9"),"False"), LocRule("ruless", Pattern( Product("Transform.ag(line 398, column 16)", Patterns( Pattern( Underscore("Transform.ag(line 398, column 16)")), Pattern( Var("Transform.ag(line 398, column 12)","loc.ruless"))))), Expression("Transform.ag(line 398, column 16)","@_tup9"),"False"))))), Production("SemAlts","{alternatives:=DataAlts,attributes:=Map Nonterminal (Attributes, Attributes),nt:=Nonterminal,ruleMapAlt:=RuleMapAlt}","{errors:=Seq Error,ruleMapAlt:=RuleMapAlt}", Alternatives( Alternative("Cons", Children( Child("hd","SemAlt","{alternatives:=DataAlts,attributes:=Map Nonterminal (Attributes, Attributes),nt:=Nonterminal,ruleMapAlt:=RuleMapAlt}","{errors:=Seq Error,ruleMapAlt:=RuleMapAlt}", Rules( Rule("ruleMapAlt", Pattern( Var("Transform.ag(line 389, column 10)","hd.ruleMapAlt")), Expression("Transform.ag(line 389, column 27)","@tl.ruleMapAlt\n")), Rule("alternatives", Pattern( Var("./ConcreteSyntax.ag(line 16, column 1)","hd.alternatives")), Expression("","@lhs.alternatives")), Rule("attributes", Pattern( Var("./ConcreteSyntax.ag(line 16, column 1)","hd.attributes")), Expression("","@lhs.attributes")), Rule("nt", Pattern( Var("./ConcreteSyntax.ag(line 16, column 1)","hd.nt")), Expression("","@lhs.nt")))), Child("tl","SemAlts","{alternatives:=DataAlts,attributes:=Map Nonterminal (Attributes, Attributes),nt:=Nonterminal,ruleMapAlt:=RuleMapAlt}","{errors:=Seq Error,ruleMapAlt:=RuleMapAlt}", Rules( Rule("ruleMapAlt", Pattern( Var("Transform.ag(line 390, column 10)","tl.ruleMapAlt")), Expression("Transform.ag(line 390, column 27)","@lhs.ruleMapAlt\n")), Rule("alternatives", Pattern( Var("./ConcreteSyntax.ag(line 16, column 1)","tl.alternatives")), Expression("","@lhs.alternatives")), Rule("attributes", Pattern( Var("./ConcreteSyntax.ag(line 16, column 1)","tl.attributes")), Expression("","@lhs.attributes")), Rule("nt", Pattern( Var("./ConcreteSyntax.ag(line 16, column 1)","tl.nt")), Expression("","@lhs.nt"))))), Rules( Rule("ruleMapAlt", Pattern( Var("Transform.ag(line 388, column 10)","lhs.ruleMapAlt")), Expression("Transform.ag(line 388, column 27)","@hd.ruleMapAlt\n")), Rule("errors", Pattern( Var("","lhs.errors")), Expression("","@hd.errors Seq.<> @tl.errors"))), LocRules()), Alternative("Nil", Children(), Rules( Rule("errors", Pattern( Var("","lhs.errors")), Expression("","Seq.empty")), Rule("ruleMapAlt", Pattern( Var("","lhs.ruleMapAlt")), Expression("","@lhs.ruleMapAlt"))), LocRules()))))