Productions( Production("Alternative","{down:=[UseStream],inh:=Attributes,nt:=Identifier,nts':=[Name],o_cata:=Bool,o_newtypes:=Bool,o_pretty:=Bool,o_rename:=Bool,o_sem:=Bool,o_sig:=Bool,prefix:=String,syn:=Attributes}","{cataAlt:=Decl,comment:=Decl,dataAlt:=DataAlt,errors:=Seq Error,nrChildren:=Int,semFun:=Decls,smCataAlt:=Decl,smCompDyn:=(String,(String,[String])),smConstructor:=(String,(String,[String])),smDynSels:=[(String,(String,String,[String]))],smDynSemFuns:=[(String,(String,[String]))],smInputDyn:=(String,(String,String)),smInsDyns:=[(String,(String,Code.Type))],smPrimTypes:=[String],smSelFun:=Decls,smSemFun:=Decls,smTypeCons:=[String],up:=[UseStream],valt:=VisageAlternative}", Alternatives( Alternative("Alternative", Children( Child("con","Constructor","{}","{}", Rules()), Child("children","Children","{attrs:=[(Name,Name)],con:=Identifier,def_namespace:=[(Name,(Int, Int))],down:=[UseStream],fieldnames:=[Name],inh:=Attributes,nt:=Identifier,nts':=[Name],o_rename:=Bool,prefix:=String,rulemap:=VisageRuleMap}","{attributes:=[(Name,Attributes,Attributes)],decls:=Decls,errors:=Seq Error,fields:=[(Name,Type)],smInhAttrNames:=[[String]],smInhFnames:=[String],smInhInsDyns:=[(String,(String,Code.Type))],smInhInserters:=Decls,smSynAttrNames:=[[String]],up:=[UseStream],vchildren:=[VisageChild]}", Rules( Rule("con", Pattern( Var("GenerateCode.ag(line 57, column 17)","children.con")), Expression("GenerateCode.ag(line 57, column 34)","@con\n")), Rule("def_namespace", Pattern( Var("./GenerateCodeSM.ag(line 375, column 19)","children.def_namespace")), Expression("./GenerateCodeSM.ag(line 375, column 44)","let n = length @children.fields\n chnames = map fst @children.fields\n f name i = (name, (n, i))\nin zipWith f chnames [1..n]\n")), Rule("rulemap", Pattern( Var("./TfmToVisage.ag(line 99, column 17)","children.rulemap")), Expression("./TfmToVisage.ag(line 99, column 36)","@splitVRules\n")), Rule("attrs", Pattern( Var("./AbstractSyntax.ag(line 31, column 33)","children.attrs")), Expression("","@attrs")), Rule("down", Pattern( Var("./AbstractSyntax.ag(line 31, column 33)","children.down")), Expression("","@lhs.down")), Rule("fieldnames", Pattern( Var("./AbstractSyntax.ag(line 31, column 33)","children.fieldnames")), Expression("","@fieldnames")), Rule("inh", Pattern( Var("./AbstractSyntax.ag(line 31, column 33)","children.inh")), Expression("","@lhs.inh")), Rule("nt", Pattern( Var("./AbstractSyntax.ag(line 31, column 33)","children.nt")), Expression("","@lhs.nt")), Rule("nts'", Pattern( Var("./AbstractSyntax.ag(line 31, column 33)","children.nts'")), Expression("","@lhs.nts'")), Rule("o_rename", Pattern( Var("./AbstractSyntax.ag(line 31, column 33)","children.o_rename")), Expression("","@lhs.o_rename")), Rule("prefix", Pattern( Var("./AbstractSyntax.ag(line 31, column 33)","children.prefix")), Expression("","@lhs.prefix")))), Child("rules","Rules","{attrs:=[(Name,Name)],con:=Identifier,down:=[UseStream],fieldnames:=[Name],fields:=[(Name,Type)],nt:=Identifier,o_pretty:=Bool}","{decls:=Decls,decls':=Decls,errors:=Seq Error,locVars:=[Name],up:=[UseStream],vrules:=[VisageRule]}", Rules( Rule("con", Pattern( Var("GenerateCode.ag(line 59, column 17)","rules.con")), Expression("GenerateCode.ag(line 59, column 31)","@con\n")), Rule("attrs", Pattern( Var("./AbstractSyntax.ag(line 32, column 33)","rules.attrs")), Expression("","@attrs")), Rule("down", Pattern( Var("./AbstractSyntax.ag(line 32, column 33)","rules.down")), Expression("","@lhs.down")), Rule("fieldnames", Pattern( Var("./AbstractSyntax.ag(line 32, column 33)","rules.fieldnames")), Expression("","@fieldnames")), Rule("fields", Pattern( Var("./AbstractSyntax.ag(line 32, column 33)","rules.fields")), Expression("","@children.fields")), Rule("nt", Pattern( Var("./AbstractSyntax.ag(line 32, column 33)","rules.nt")), Expression("","@lhs.nt")), Rule("o_pretty", Pattern( Var("./AbstractSyntax.ag(line 32, column 33)","rules.o_pretty")), Expression("","@lhs.o_pretty"))))), Rules( Rule("dataAlt", Pattern( Var("GenerateCode.ag(line 233, column 17)","lhs.dataAlt")), Expression("GenerateCode.ag(line 233, column 33)","DataAlt (conname @lhs.o_rename @lhs.nt @con) (map (typeToString @lhs.nt .snd) @children.fields)\n")), Rule("cataAlt", Pattern( Var("GenerateCode.ag(line 256, column 17)","lhs.cataAlt")), Expression("GenerateCode.ag(line 256, column 31)","let lhs = Fun (cataname @lhs.prefix @lhs.nt) [lhs_pat]\n lhs_pat = App (conname @lhs.o_rename @lhs.nt @con)\n (map (SimpleExpr . locname . fst) @children.fields)\n rhs = App (semname @lhs.prefix @lhs.nt @con)\n (map argument @children.fields)\n argument (nm,NT tp) = App (cataname @lhs.prefix tp)\n [SimpleExpr (locname nm)]\n argument (nm, _) = SimpleExpr (locname nm)\nin Decl lhs rhs\n")), Rule("semFun", Pattern( Var("GenerateCode.ag(line 318, column 17)","lhs.semFun")), Expression("GenerateCode.ag(line 318, column 30)","let tsig = TSig (semname @lhs.prefix @lhs.nt @con) semType\n semType = foldr argType\n (SimpleType (sdtype @lhs.nt))\n (map snd @children.fields)\n argType (NT tp) rec = SimpleType (sdtype tp) `Arr` rec\n argType tp rec = SimpleType (typeToString @lhs.nt tp) `Arr` rec\nin if @lhs.o_sig\n then [tsig,@loc.sFun]\n else [@loc.sFun]\n")), Rule("comment", Pattern( Var("./Comments.ag(line 41, column 17)","lhs.comment")), Expression("./Comments.ag(line 41, column 31)","Comment . unlines $\n [ replicate 3 ' ' ++ \"local variables for \" ++ getName @lhs.nt ++ \".\" ++ getName @con ++ \":\"\n , unlines . map ((replicate 6 ' ')++) $ map getName @rules.locVars\n ]\n")), Rule("up", Pattern( Var("./Dep.ag(line 98, column 17)","lhs.up")), Expression("./Dep.ag(line 98, column 26)","@up ++ @rules.up ++ @children.up\n")), Rule("smCataAlt", Pattern( Var("./GenerateCodeSM.ag(line 323, column 17)","lhs.smCataAlt")), Expression("./GenerateCodeSM.ag(line 323, column 33)","let lhs = Fun (smcataname @lhs.prefix @lhs.nt) [lhs_pat]\n lhs_pat = App (conname @lhs.o_rename @lhs.nt @con)\n (map (SimpleExpr . locname . fst) @children.fields)\n rhs = App fknit ([smsem, children_cata])\n smsem = App (smcompname @lhs.prefix @lhs.nt @con) [(SimpleExpr unit)]\n children_cata = if (not . null) @children.fields\n then foldr1 (\\l r -> TupleExpr [l,r]) (map argument @children.fields)\n else Lambda [unit] (SimpleExpr unit)\n argument (nm,NT tp) = App (smcataname @lhs.prefix tp)\n [SimpleExpr (locname nm)]\n argument (nm,_) = Lambda [unit] (TupleExpr [SimpleExpr (locname nm), SimpleExpr unit])\nin Decl lhs rhs\n")), Rule("smConstructor", Pattern( Var("./GenerateCodeSM.ag(line 335, column 17)","lhs.smConstructor")), Expression("./GenerateCodeSM.ag(line 335, column 37)","let constr = conname @lhs.o_rename @lhs.nt @con\n chs = map snd @children.fields\n fargs = (map (typeToString @lhs.nt) chs ++ [getName @lhs.nt])\nin (constr, (constr, fargs))\n")), Rule("smTypeCons", Pattern( Var("./GenerateCodeSM.ag(line 364, column 17)","lhs.smTypeCons")), Expression("./GenerateCodeSM.ag(line 364, column 34)","let mkTpNm post = smsdtype2 @lhs.nt @con post\nin [mkTpNm \"input\", mkTpNm \"f\"]\n")), Rule("smCompDyn", Pattern( Var("./GenerateCodeSM.ag(line 366, column 17)","lhs.smCompDyn")), Expression("./GenerateCodeSM.ag(line 366, column 33)","let nm = smcompname @lhs.prefix @lhs.nt @con\nin (conname @lhs.o_rename @lhs.nt @con,(nm,[smsdtype2 @lhs.nt @con \"f\"]))\n")), Rule("smInputDyn", Pattern( Var("./GenerateCodeSM.ag(line 368, column 17)","lhs.smInputDyn")), Expression("./GenerateCodeSM.ag(line 368, column 33)","let nm = conname @lhs.o_rename @lhs.nt @con\n varnm = \"_gen_var\" ++ map toLower nm\n tpnm = smsdtype2 @lhs.nt @con \"input\"\nin (nm, (varnm,tpnm))\n")), Rule("smPrimTypes", Pattern( Var("./GenerateCodeSM.ag(line 372, column 17)","lhs.smPrimTypes")), Expression("./GenerateCodeSM.ag(line 372, column 35)","if null @children.fields\nthen [unittp]\nelse [t | Haskell t <- map snd @children.fields]\n")), Rule("nrChildren", Pattern( Var("./GenerateCodeSM.ag(line 379, column 17)","lhs.nrChildren")), Expression("./GenerateCodeSM.ag(line 379, column 34)","length @children.fields\n")), Rule("smSemFun", Pattern( Var("./GenerateCodeSM.ag(line 422, column 17)","lhs.smSemFun")), Expression("./GenerateCodeSM.ag(line 422, column 32)","@smTpSigs++[@loc.smCompTpSig, @smComputation]\n")), Rule("smSelFun", Pattern( Var("./GenerateCodeSM.ag(line 651, column 17)","lhs.smSelFun")), Expression("./GenerateCodeSM.ag(line 651, column 32)","@loc.smpCataAlt : @loc.mkSemFun : @loc.childSelectors ++ @loc.inhSelectors ++\n@loc.synInserters ++ @children.smInhInserters\n")), Rule("smDynSels", Pattern( Var("./GenerateCodeSM.ag(line 653, column 17)","lhs.smDynSels")), Expression("./GenerateCodeSM.ag(line 653, column 33)","@loc.smChSelDyns ++ @loc.smInhSelDyns\n")), Rule("smDynSemFuns", Pattern( Var("./GenerateCodeSM.ag(line 654, column 17)","lhs.smDynSemFuns")), Expression("./GenerateCodeSM.ag(line 654, column 36)","[@loc.dynSemFun]\n")), Rule("smInsDyns", Pattern( Var("./GenerateCodeSM.ag(line 655, column 17)","lhs.smInsDyns")), Expression("./GenerateCodeSM.ag(line 655, column 33)","@children.smInhInsDyns ++ @loc.synInsDyns\n")), Rule("valt", Pattern( Var("./TfmToVisage.ag(line 95, column 17)","lhs.valt")), Expression("./TfmToVisage.ag(line 95, column 36)","VAlternative @con @children.vchildren @lhsrules @locrules\n")), Rule("errors", Pattern( Var("","lhs.errors")), Expression("","@children.errors Seq.<> @rules.errors"))), LocRules( LocRule("sFun", Pattern( Var("GenerateCode.ag(line 278, column 17)","loc.sFun")), Expression("GenerateCode.ag(line 278, column 28)","let lhs = Fun (semname @lhs.prefix @lhs.nt @con) lhs_args\n lhs_args = map field @children.fields\n field (name,NT tp) = let unwrap | @lhs.o_newtypes = \\x -> App (sdtype tp) [x]\n | otherwise = id\n in unwrap (SimpleExpr (fieldname name))\n field (name,_) = SimpleExpr (fieldname name)\n mkLambda [] e = e\n mkLambda xs e = Lambda xs e\n wrap = if @lhs.o_newtypes then \\x -> App (sdtype @lhs.nt) [x] else id\n rhs = wrap\n (mkLambda [lhsname True x | x <- Map.keys @lhs.inh]\n ( Let (typeSigs ++ @children.decls ++ @rules.decls)\n (TupleExpr $ map (SimpleExpr . lhsname False ) @synnames)\n )\n )\n typeSigs | @lhs.o_sig =\n let findType nm = Map.findWithDefault @lhs.nt nm\n (Map.fromList ((_LHS,@lhs.nt)\n : [(nm,nt)\n | (nm, NT nt) <- @children.fields\n ]\n )\n )\n lhs = attribute False (_LHS,@lhs.syn)\n children = concatMap (\\(nm,inh,syn) -> attribute True (nm,syn)\n ++ attribute False (nm,inh)\n )\n @children.attributes\n attribute isIn (nm,as) =\n let nont = (findType nm)\n in [TSig (attrname isIn nm a)\n (SimpleType (typeToString nont tp))\n |(a,tp) <- Map.toList as\n ]\n in lhs++children\n | otherwise = []\n in Decl lhs rhs\n"),"False"), LocRule("fieldnames", Pattern( Var("GenerateCode.ag(line 357, column 17)","loc.fieldnames")), Expression("GenerateCode.ag(line 357, column 34)","map fst @children.fields\n"),"False"), LocRule("attrs", Pattern( Var("GenerateCode.ag(line 357, column 17)","loc.attrs")), Expression("GenerateCode.ag(line 358, column 34)","map ((,) _LOC) @rules.locVars ++\nmap ((,) _LHS) @inhnames ++\nconcat [map ((,) nm) (Map.keys as) | (nm,_,as) <- @children.attributes]\n"),"False"), LocRule("inhnames", Pattern( Var("GenerateCode.ag(line 357, column 17)","loc.inhnames")), Expression("GenerateCode.ag(line 361, column 34)","Map.keys @lhs.inh\n"),"False"), LocRule("synnames", Pattern( Var("GenerateCode.ag(line 357, column 17)","loc.synnames")), Expression("GenerateCode.ag(line 362, column 34)","Map.keys @lhs.syn\n"),"False"), LocRule("up", Pattern( Var("./Dep.ag(line 95, column 17)","loc.up")), Expression("./Dep.ag(line 95, column 26)","[ ( LHSInh @lhs.nt @con inh, stStart _LHS inh)\n| inh <- @inhnames\n]\n"),"False"), LocRule("smComputation", Pattern( Var("./GenerateCodeSM.ag(line 423, column 17)","loc.smComputation")), Expression("./GenerateCodeSM.ag(line 423, column 37)","let comp_input = let ch = tupnest' (map (tupnest . (map SimpleExpr)) @children.smSynAttrNames)\n loc = tupnest []\n pi = tupnest (map (SimpleExpr . lhsname True) @inhnames)\n in App lazytilde [TupleExpr [ch,loc,pi]]\n comp_output = let ch = tupnest' (map (tupnest . (map SimpleExpr)) @children.smInhAttrNames)\n loc = tupnest []\n pi = tupnest (map (SimpleExpr . lhsname False) @synnames)\n in App \"const\" [TupleExpr [ch,loc,pi]]\n lhs = Fun (smcompname @lhs.prefix @lhs.nt @con) ([SimpleExpr underscore, comp_input])\n rhs = Let @rules.decls comp_output\nin Decl lhs rhs\n"),"False"), LocRule("smCompTpSig", Pattern( Var("./GenerateCodeSM.ag(line 434, column 17)","loc.smCompTpSig")), Expression("./GenerateCodeSM.ag(line 434, column 35)","TSig (smcompname @lhs.prefix @lhs.nt @con)\n (SimpleType (smsdtype2 @lhs.nt @con \"f\"))\n"),"False"), LocRule("smTpSigs", Pattern( Var("./GenerateCodeSM.ag(line 436, column 17)","loc.smTpSigs")), Expression("./GenerateCodeSM.ag(line 436, column 32)","let unitTp = SimpleType unit\n inputTp = TupleType [ch_synTp, locTp, inhTp]\n outputTp = TupleType [ch_inhTp, locTp, synTp]\n emptyTp = TupleType [ ch_emptyTp, unitTp, unitTp]\n ch_emptyTp = tupnestTp' (map (const unitTp) @children.fields)\n ch_synTp = tupnestTp' ((map (\\tup -> argTypeSyn (snd tup) \"syn\")) @children.fields)\n ch_inhTp = tupnestTp' ((map (\\tup -> argTypeInh (snd tup) \"inh\")) @children.fields)\n argTypeSyn tp post = case tp of\n NT nt -> SimpleType (smsdtype nt post)\n _ -> TupleType [SimpleType (typeToString @lhs.nt tp), SimpleType unit]\n argTypeInh tp post = case tp of\n NT nt -> SimpleType (smsdtype nt post)\n _ -> SimpleType unit\n locTp = SimpleType (smsdtype @lhs.nt \"loc\")\n inhTp = SimpleType (smsdtype @lhs.nt \"inh\")\n synTp = SimpleType (smsdtype @lhs.nt \"syn\")\n semType = foldr1 Arr [unitTp, inputTp, emptyTp, outputTp]\nin [ Code.Type (smsdtype2 @lhs.nt @con \"input\") inputTp\n , Code.Type (smsdtype2 @lhs.nt @con \"output\") outputTp\n , Code.Type (smsdtype2 @lhs.nt @con \"f\") semType\n ]\n"),"False"), LocRule("childSelectors", Pattern( Var("./GenerateCodeSM.ag(line 585, column 17)","loc.childSelectors")), Expression("./GenerateCodeSM.ag(line 585, column 38)","let chnames = map fst @children.fields\n inputPat = TupleExpr [tupnest' (map (SimpleExpr . getName) chnames), SimpleExpr \"_loc_\", SimpleExpr \"_inh_\"]\n mklhs ch = Fun (selectnm @lhs.nt @con ch)\n [inputPat]\n mkrhs ch = SimpleExpr (getName ch)\nin map (\\ch -> Decl (mklhs ch) (mkrhs ch)) chnames\n"),"False"), LocRule("smChSelDyns", Pattern( Var("./GenerateCodeSM.ag(line 591, column 17)","loc.smChSelDyns")), Expression("./GenerateCodeSM.ag(line 591, column 38)","let fident (ch,tp) = (conname @lhs.o_rename @lhs.nt @con) ++ \"_\" ++ getName ch\n fnm (ch,tp) = selectnm @lhs.nt @con ch\n fargs (ch,tp) = [(smsdtype2 @lhs.nt @con \"input\"),\n (smsdtype tp \"syn\")]\n fchSelDyn tup@(ch,tp) = (fident tup, (getName tp, fnm tup, fargs tup))\nin map fchSelDyn [ (ch, tp) | (ch,NT tp)<- @children.fields]\n"),"False"), LocRule("inhSelectors", Pattern( Var("./GenerateCodeSM.ag(line 597, column 17)","loc.inhSelectors")), Expression("./GenerateCodeSM.ag(line 597, column 38)","let inputPat = TupleExpr [SimpleExpr \"_chsyn_\", SimpleExpr \"_loc_\", SimpleExpr \"_inh_\"]\n lhs = Fun (selectnm @lhs.nt @con (identifier \"inh\" ))\n [inputPat]\n rhs = SimpleExpr \"_inh_\"\nin [Decl lhs rhs]\n"),"False"), LocRule("smInhSelDyns", Pattern( Var("./GenerateCodeSM.ag(line 602, column 17)","loc.smInhSelDyns")), Expression("./GenerateCodeSM.ag(line 602, column 38)","let ident = (conname @lhs.o_rename @lhs.nt @con) ++ \"_lhs\"\n nm = selectnm @lhs.nt @con (identifier \"inh\")\n args = [(smsdtype2 @lhs.nt @con \"input\"),\n (smsdtype @lhs.nt \"inh\")]\nin [(ident,(getName @lhs.nt,nm,args))]\n"),"False"), LocRule("synInserters", Pattern( Var("./GenerateCodeSM.ag(line 607, column 17)","loc.synInserters")), Expression("./GenerateCodeSM.ag(line 607, column 38)","let insm syn = insertnm @lhs.nt @con syn\n insm' syn = insertnm @lhs.nt nullIdent syn\nin map (\\syn -> mkExtendExpr (insm syn) syn_def (insm' syn)) @synnames\n"),"False"), LocRule("synInsDyns", Pattern( Var("./GenerateCodeSM.ag(line 610, column 17)","loc.synInsDyns")), Expression("./GenerateCodeSM.ag(line 610, column 38)","let synAttrs = Map.toList @lhs.syn\n ident a = (conname @lhs.o_rename @lhs.nt @con) ++ \"_lhs_\" ++ getName a\n fname a = insertnm @lhs.nt @con a\n inpArg t = let tp = typeToString @lhs.nt t\n in Arr (SimpleType (smsdtype2 @lhs.nt @con \"input\"))\n (SimpleType tp)\n arg tp = let btp = SimpleType (smsdtype2 @lhs.nt @con \"f\")\n in Arr (inpArg tp) (Arr btp btp)\nin map (\\(s,tp) -> (ident s, (fname s, arg tp))) synAttrs\n"),"False"), LocRule("smpCataAlt", Pattern( Var("./GenerateCodeSM.ag(line 619, column 17)","loc.smpCataAlt")), Expression("./GenerateCodeSM.ag(line 619, column 33)","let lhs = Fun (smpcataname @lhs.prefix @lhs.nt @con) lhs_pat\n lhs_pat = (map (SimpleExpr . locname . fst) @children.fields)\n rhs = App fknit ([smsem, children_args])\n smsem = App (smcompname @lhs.prefix @lhs.nt @con) [(SimpleExpr unit)]\n children_args = if (not . null) @children.fields\n then foldr1 (\\l r -> TupleExpr [l,r]) (map argument @children.fields)\n else Lambda [unit] (SimpleExpr unit)\n argument (nm,NT tp) = SimpleExpr (locname nm)\n argument (nm,_) = Lambda [unit] (TupleExpr [SimpleExpr (locname nm), SimpleExpr unit])\nin Decl lhs rhs\n"),"False"), LocRule("mkSemFun", Pattern( Var("./GenerateCodeSM.ag(line 629, column 17)","loc.mkSemFun")), Expression("./GenerateCodeSM.ag(line 629, column 38)","let newcomp = SimpleExpr \"_newcomp_\"\n lhs = Fun (makesemnm @lhs.nt @con) [newcomp]\n ch_names = if null @children.fields then [unit]\n else map (locname . fst) @children.fields\n newcompapp = App \"_newcomp_\" [SimpleExpr unit]\n knitapp = App fknit [newcompapp, children_args]\n children_args = if (not . null) @children.fields\n then foldr1 (\\l r -> TupleExpr [l,r]) (map argument @children.fields)\n else Lambda [unit] (SimpleExpr unit)\n argument (nm,NT tp) = SimpleExpr (locname nm)\n argument (nm,_) = Lambda [unit] (TupleExpr [SimpleExpr (locname nm), SimpleExpr unit])\n rhs = Lambda ch_names knitapp\nin Decl lhs rhs\n"),"False"), LocRule("dynSemFun", Pattern( Var("./GenerateCodeSM.ag(line 642, column 17)","loc.dynSemFun")), Expression("./GenerateCodeSM.ag(line 642, column 38)","let nm = (makesemnm @lhs.nt @con)\n ident = conname @lhs.o_rename @lhs.nt @con\n compnm = smsdtype2 @lhs.nt @con \"f\"\n chargs = if null @children.fields then [unittp]\n else map argument @children.fields\n argument (_,NT tp) = smsdtype tp \"\"\n argument (_,Haskell t) = t\n args = compnm : (chargs ++ [smsdtype @lhs.nt \"\"])\nin (ident,(nm,args))\n"),"False"), LocRule("splitVRules", Pattern( Var("./TfmToVisage.ag(line 96, column 17)","loc.splitVRules")), Expression("./TfmToVisage.ag(line 96, column 36)","splitVRules @rules.vrules\n"),"False"), LocRule("locrules", Pattern( Var("./TfmToVisage.ag(line 97, column 17)","loc.locrules")), Expression("./TfmToVisage.ag(line 97, column 36)","getForField \"loc\" @splitVRules\n"),"False"), LocRule("lhsrules", Pattern( Var("./TfmToVisage.ag(line 98, column 17)","loc.lhsrules")), Expression("./TfmToVisage.ag(line 98, column 36)","getForField \"lhs\" @splitVRules\n"),"False"))))), Production("Alternatives","{down:=[UseStream],inh:=Attributes,nt:=Identifier,nts':=[Name],o_cata:=Bool,o_newtypes:=Bool,o_pretty:=Bool,o_rename:=Bool,o_sem:=Bool,o_sig:=Bool,prefix:=String,syn:=Attributes}","{cataAlts:=Decls,comments:=Decls,dataAlts:=DataAlts,errors:=Seq Error,nrChildren:=Int,semFuns:=Decls,smCataAlts:=Decls,smCompDyns:=[(String,(String,[String]))],smConstructors:=[(String,(String,[String]))],smDynSels:=[(String,(String,String,[String]))],smDynSemFuns:=[(String,(String,[String]))],smInputDyns:=[(String,(String,String))],smInsDyns:=[(String,(String,Code.Type))],smPrimTypes:=[String],smSelFuns:=Decls,smSemFuns:=Decls,smTypeCons:=[String],up:=[UseStream],valts:=[VisageAlternative]}", Alternatives( Alternative("Cons", Children( Child("hd","Alternative","{down:=[UseStream],inh:=Attributes,nt:=Identifier,nts':=[Name],o_cata:=Bool,o_newtypes:=Bool,o_pretty:=Bool,o_rename:=Bool,o_sem:=Bool,o_sig:=Bool,prefix:=String,syn:=Attributes}","{cataAlt:=Decl,comment:=Decl,dataAlt:=DataAlt,errors:=Seq Error,nrChildren:=Int,semFun:=Decls,smCataAlt:=Decl,smCompDyn:=(String,(String,[String])),smConstructor:=(String,(String,[String])),smDynSels:=[(String,(String,String,[String]))],smDynSemFuns:=[(String,(String,[String]))],smInputDyn:=(String,(String,String)),smInsDyns:=[(String,(String,Code.Type))],smPrimTypes:=[String],smSelFun:=Decls,smSemFun:=Decls,smTypeCons:=[String],up:=[UseStream],valt:=VisageAlternative}", Rules( Rule("down", Pattern( Var("./AbstractSyntax.ag(line 19, column 1)","hd.down")), Expression("","@lhs.down")), Rule("inh", Pattern( Var("./AbstractSyntax.ag(line 19, column 1)","hd.inh")), Expression("","@lhs.inh")), Rule("nt", Pattern( Var("./AbstractSyntax.ag(line 19, column 1)","hd.nt")), Expression("","@lhs.nt")), Rule("nts'", Pattern( Var("./AbstractSyntax.ag(line 19, column 1)","hd.nts'")), Expression("","@lhs.nts'")), Rule("o_cata", Pattern( Var("./AbstractSyntax.ag(line 19, column 1)","hd.o_cata")), Expression("","@lhs.o_cata")), Rule("o_newtypes", Pattern( Var("./AbstractSyntax.ag(line 19, column 1)","hd.o_newtypes")), Expression("","@lhs.o_newtypes")), Rule("o_pretty", Pattern( Var("./AbstractSyntax.ag(line 19, column 1)","hd.o_pretty")), Expression("","@lhs.o_pretty")), Rule("o_rename", Pattern( Var("./AbstractSyntax.ag(line 19, column 1)","hd.o_rename")), Expression("","@lhs.o_rename")), Rule("o_sem", Pattern( Var("./AbstractSyntax.ag(line 19, column 1)","hd.o_sem")), Expression("","@lhs.o_sem")), Rule("o_sig", Pattern( Var("./AbstractSyntax.ag(line 19, column 1)","hd.o_sig")), Expression("","@lhs.o_sig")), Rule("prefix", Pattern( Var("./AbstractSyntax.ag(line 19, column 1)","hd.prefix")), Expression("","@lhs.prefix")), Rule("syn", Pattern( Var("./AbstractSyntax.ag(line 19, column 1)","hd.syn")), Expression("","@lhs.syn")))), Child("tl","Alternatives","{down:=[UseStream],inh:=Attributes,nt:=Identifier,nts':=[Name],o_cata:=Bool,o_newtypes:=Bool,o_pretty:=Bool,o_rename:=Bool,o_sem:=Bool,o_sig:=Bool,prefix:=String,syn:=Attributes}","{cataAlts:=Decls,comments:=Decls,dataAlts:=DataAlts,errors:=Seq Error,nrChildren:=Int,semFuns:=Decls,smCataAlts:=Decls,smCompDyns:=[(String,(String,[String]))],smConstructors:=[(String,(String,[String]))],smDynSels:=[(String,(String,String,[String]))],smDynSemFuns:=[(String,(String,[String]))],smInputDyns:=[(String,(String,String))],smInsDyns:=[(String,(String,Code.Type))],smPrimTypes:=[String],smSelFuns:=Decls,smSemFuns:=Decls,smTypeCons:=[String],up:=[UseStream],valts:=[VisageAlternative]}", Rules( Rule("down", Pattern( Var("./AbstractSyntax.ag(line 19, column 1)","tl.down")), Expression("","@lhs.down")), Rule("inh", Pattern( Var("./AbstractSyntax.ag(line 19, column 1)","tl.inh")), Expression("","@lhs.inh")), Rule("nt", Pattern( Var("./AbstractSyntax.ag(line 19, column 1)","tl.nt")), Expression("","@lhs.nt")), Rule("nts'", Pattern( Var("./AbstractSyntax.ag(line 19, column 1)","tl.nts'")), Expression("","@lhs.nts'")), Rule("o_cata", Pattern( Var("./AbstractSyntax.ag(line 19, column 1)","tl.o_cata")), Expression("","@lhs.o_cata")), Rule("o_newtypes", Pattern( Var("./AbstractSyntax.ag(line 19, column 1)","tl.o_newtypes")), Expression("","@lhs.o_newtypes")), Rule("o_pretty", Pattern( Var("./AbstractSyntax.ag(line 19, column 1)","tl.o_pretty")), Expression("","@lhs.o_pretty")), Rule("o_rename", Pattern( Var("./AbstractSyntax.ag(line 19, column 1)","tl.o_rename")), Expression("","@lhs.o_rename")), Rule("o_sem", Pattern( Var("./AbstractSyntax.ag(line 19, column 1)","tl.o_sem")), Expression("","@lhs.o_sem")), Rule("o_sig", Pattern( Var("./AbstractSyntax.ag(line 19, column 1)","tl.o_sig")), Expression("","@lhs.o_sig")), Rule("prefix", Pattern( Var("./AbstractSyntax.ag(line 19, column 1)","tl.prefix")), Expression("","@lhs.prefix")), Rule("syn", Pattern( Var("./AbstractSyntax.ag(line 19, column 1)","tl.syn")), Expression("","@lhs.syn"))))), Rules( Rule("dataAlts", Pattern( Var("GenerateCode.ag(line 229, column 17)","lhs.dataAlts")), Expression("GenerateCode.ag(line 229, column 33)","@hd.dataAlt : @tl.dataAlts\n")), Rule("cataAlts", Pattern( Var("GenerateCode.ag(line 252, column 10)","lhs.cataAlts")), Expression("GenerateCode.ag(line 252, column 25)","@hd.cataAlt : @tl.cataAlts\n")), Rule("semFuns", Pattern( Var("GenerateCode.ag(line 274, column 10)","lhs.semFuns")), Expression("GenerateCode.ag(line 274, column 24)","@hd.semFun ++ @tl.semFuns\n")), Rule("comments", Pattern( Var("./Comments.ag(line 37, column 10)","lhs.comments")), Expression("./Comments.ag(line 37, column 25)","@hd.comment : @tl.comments\n")), Rule("smCataAlts", Pattern( Var("./GenerateCodeSM.ag(line 317, column 10)","lhs.smCataAlts")), Expression("./GenerateCodeSM.ag(line 317, column 27)","@hd.smCataAlt : @tl.smCataAlts\n")), Rule("smConstructors", Pattern( Var("./GenerateCodeSM.ag(line 318, column 10)","lhs.smConstructors")), Expression("./GenerateCodeSM.ag(line 318, column 31)","@hd.smConstructor : @tl.smConstructors\n")), Rule("smSemFuns", Pattern( Var("./GenerateCodeSM.ag(line 354, column 10)","lhs.smSemFuns")), Expression("./GenerateCodeSM.ag(line 354, column 26)","@hd.smSemFun ++ @tl.smSemFuns\n")), Rule("smCompDyns", Pattern( Var("./GenerateCodeSM.ag(line 355, column 10)","lhs.smCompDyns")), Expression("./GenerateCodeSM.ag(line 355, column 26)","@hd.smCompDyn : @tl.smCompDyns\n")), Rule("smInputDyns", Pattern( Var("./GenerateCodeSM.ag(line 356, column 10)","lhs.smInputDyns")), Expression("./GenerateCodeSM.ag(line 356, column 27)","@hd.smInputDyn : @tl.smInputDyns\n")), Rule("nrChildren", Pattern( Var("./GenerateCodeSM.ag(line 357, column 10)","lhs.nrChildren")), Expression("./GenerateCodeSM.ag(line 357, column 27)","@hd.nrChildren `max` @tl.nrChildren\n")), Rule("smSelFuns", Pattern( Var("./GenerateCodeSM.ag(line 581, column 10)","lhs.smSelFuns")), Expression("./GenerateCodeSM.ag(line 581, column 26)","@hd.smSelFun ++ @tl.smSelFuns\n")), Rule("valts", Pattern( Var("./TfmToVisage.ag(line 91, column 17)","lhs.valts")), Expression("./TfmToVisage.ag(line 91, column 29)","@hd.valt : @tl.valts\n")), Rule("errors", Pattern( Var("","lhs.errors")), Expression("","@hd.errors Seq.<> @tl.errors")), Rule("smDynSels", Pattern( Var("","lhs.smDynSels")), Expression("","@hd.smDynSels ++ @tl.smDynSels")), Rule("smDynSemFuns", Pattern( Var("","lhs.smDynSemFuns")), Expression("","@hd.smDynSemFuns ++ @tl.smDynSemFuns")), Rule("smInsDyns", Pattern( Var("","lhs.smInsDyns")), Expression("","@hd.smInsDyns ++ @tl.smInsDyns")), Rule("smPrimTypes", Pattern( Var("","lhs.smPrimTypes")), Expression("","@hd.smPrimTypes ++ @tl.smPrimTypes")), Rule("smTypeCons", Pattern( Var("","lhs.smTypeCons")), Expression("","@hd.smTypeCons ++ @tl.smTypeCons")), Rule("up", Pattern( Var("","lhs.up")), Expression("","@hd.up ++ @tl.up"))), LocRules()), Alternative("Nil", Children(), Rules( Rule("dataAlts", Pattern( Var("GenerateCode.ag(line 230, column 17)","lhs.dataAlts")), Expression("GenerateCode.ag(line 230, column 33)","[]\n")), Rule("cataAlts", Pattern( Var("GenerateCode.ag(line 253, column 10)","lhs.cataAlts")), Expression("GenerateCode.ag(line 253, column 25)","[]\n")), Rule("semFuns", Pattern( Var("GenerateCode.ag(line 275, column 10)","lhs.semFuns")), Expression("GenerateCode.ag(line 275, column 24)","[]\n")), Rule("comments", Pattern( Var("./Comments.ag(line 38, column 10)","lhs.comments")), Expression("./Comments.ag(line 38, column 25)","[]\n")), Rule("smCataAlts", Pattern( Var("./GenerateCodeSM.ag(line 319, column 10)","lhs.smCataAlts")), Expression("./GenerateCodeSM.ag(line 319, column 27)","[]\n")), Rule("smConstructors", Pattern( Var("./GenerateCodeSM.ag(line 320, column 10)","lhs.smConstructors")), Expression("./GenerateCodeSM.ag(line 320, column 31)","[]\n")), Rule("smSemFuns", Pattern( Var("./GenerateCodeSM.ag(line 358, column 10)","lhs.smSemFuns")), Expression("./GenerateCodeSM.ag(line 358, column 26)","[]\n")), Rule("smCompDyns", Pattern( Var("./GenerateCodeSM.ag(line 359, column 10)","lhs.smCompDyns")), Expression("./GenerateCodeSM.ag(line 359, column 26)","[]\n")), Rule("smInputDyns", Pattern( Var("./GenerateCodeSM.ag(line 360, column 10)","lhs.smInputDyns")), Expression("./GenerateCodeSM.ag(line 360, column 28)","[]\n")), Rule("nrChildren", Pattern( Var("./GenerateCodeSM.ag(line 361, column 10)","lhs.nrChildren")), Expression("./GenerateCodeSM.ag(line 361, column 27)","0\n")), Rule("smSelFuns", Pattern( Var("./GenerateCodeSM.ag(line 582, column 10)","lhs.smSelFuns")), Expression("./GenerateCodeSM.ag(line 582, column 26)","[]\n")), Rule("valts", Pattern( Var("./TfmToVisage.ag(line 92, column 17)","lhs.valts")), Expression("./TfmToVisage.ag(line 92, column 29)","[]\n")), Rule("errors", Pattern( Var("","lhs.errors")), Expression("","Seq.empty")), Rule("smDynSels", Pattern( Var("","lhs.smDynSels")), Expression("","[]")), Rule("smDynSemFuns", Pattern( Var("","lhs.smDynSemFuns")), Expression("","[]")), Rule("smInsDyns", Pattern( Var("","lhs.smInsDyns")), Expression("","[]")), Rule("smPrimTypes", Pattern( Var("","lhs.smPrimTypes")), Expression("","[]")), Rule("smTypeCons", Pattern( Var("","lhs.smTypeCons")), Expression("","[]")), Rule("up", Pattern( Var("","lhs.up")), Expression("","[]"))), LocRules()))), Production("Child","{attrs:=[(Name,Name)],con:=Identifier,def_namespace:=[(Name,(Int,Int))],down:=[UseStream],fieldnames:=[Name],nt:=Identifier,nts':=[Name],o_rename:=Bool,prefix:=String,rulemap:=VisageRuleMap}","{attributes:=[(Name,Attributes,Attributes)],decls:=Decls,errors:=Seq Error,field:=(Name,Type),smInhAttrNames:=[String],smInhFnames:=[String],smInhInsDyns:=[(String,(String,Code.Type))],smInhInserters:=Decls,smSynAttrNames:=[String],up:=[UseStream],vchild:=VisageChild}", Alternatives( Alternative("Child", Children( Child("name","Name","{}","{}", Rules()), Child("tp","Type","{}","{}", Rules()), Child("inh","Attributes","{}","{}", Rules()), Child("syn","Attributes","{}","{}", Rules())), Rules( Rule("field", Pattern( Var("GenerateCode.ag(line 237, column 11)","lhs.field")), Expression("GenerateCode.ag(line 237, column 23)","(@name, @tp)\n")), Rule("decls", Pattern( Var("GenerateCode.ag(line 339, column 11)","lhs.decls")), Expression("GenerateCode.ag(line 339, column 24)","let syn = Map.keys @syn\n inh = Map.keys @inh\n decl = Decl (TupleLhs [ (attrname True @name a) | a <- syn ])\n (App (fieldname @name) [SimpleExpr (attrname False @name a) | a <- inh ])\n decls = case @tp of\n NT nt | not(null syn) -> [decl]\n _ -> []\nin decls\n")), Rule("attributes", Pattern( Var("GenerateCode.ag(line 366, column 11)","lhs.attributes")), Expression("GenerateCode.ag(line 366, column 28)","[(@name, @inh, @syn)]\n")), Rule("up", Pattern( Var("./Dep.ag(line 117, column 11)","lhs.up")), Expression("./Dep.ag(line 117, column 20)","if null ((Map.keys @syn) ++ (Map.keys @inh))\n then [(Local @lhs.nt @lhs.con @name,stEmpty)]\n else [ let stInit = stStart @name syn\n stCopy = ports2stream\n (NTSyn (getNonterminalName @tp) syn)\n [RHSInh (getNonterminalName @tp) @lhs.nt @lhs.con @name inh | inh<-(Map.keys @inh)]\n (@lhs.down)\n stream = stUnion stInit stCopy\n in (RHSSyn (getNonterminalName @tp) @lhs.nt @lhs.con @name syn,stream)\n | syn<-(Map.keys @syn)\n ]\n")), Rule("smSynAttrNames", Pattern( Var("./GenerateCodeSM.ag(line 524, column 11)","lhs.smSynAttrNames")), Expression("./GenerateCodeSM.ag(line 524, column 32)","case @tp of\n NT nt -> map (attrname True @name) (Map.keys @syn)\n _ -> [fieldname @name]\n")), Rule("smInhAttrNames", Pattern( Var("./GenerateCodeSM.ag(line 528, column 11)","lhs.smInhAttrNames")), Expression("./GenerateCodeSM.ag(line 528, column 32)","case @tp of\n NT nt -> map (attrname False @name) (Map.keys @inh)\n _ -> []\n")), Rule("smInhFnames", Pattern( Var("./GenerateCodeSM.ag(line 548, column 11)","lhs.smInhFnames")), Expression("./GenerateCodeSM.ag(line 548, column 29)","let inhAttrs = Map.keys @inh\nin map (\\inh -> smattrcompnamein @lhs.prefix @lhs.nt @lhs.con inh @name) inhAttrs\n")), Rule("smInhInserters", Pattern( Var("./GenerateCodeSM.ag(line 550, column 11)","lhs.smInhInserters")), Expression("./GenerateCodeSM.ag(line 550, column 32)","let inhAttrs = Map.keys @inh\n insm inh = insertinhnm @lhs.nt @lhs.con @name inh\n insm' inh = insertnm (case @tp of NT t -> t ; Haskell t -> identifier t) nullIdent inh\nin map (\\inh -> mkExtendExpr (insm inh) @loc.defname (insm' inh)) inhAttrs\n")), Rule("smInhInsDyns", Pattern( Var("./GenerateCodeSM.ag(line 554, column 11)","lhs.smInhInsDyns")), Expression("./GenerateCodeSM.ag(line 554, column 32)","let inhAttrs = Map.toList @inh\n ident a = (conname @lhs.o_rename @lhs.nt @lhs.con) ++ \"_\" ++ getName @name ++ \"_\" ++ getName a\n fname a = insertinhnm @lhs.nt @lhs.con @name a\n inpArg t = let tp = typeToString @lhs.nt t\n in Arr (SimpleType (smsdtype2 @lhs.nt @lhs.con \"input\"))\n (SimpleType tp)\n arg tp = let btp = SimpleType (smsdtype2 @lhs.nt @lhs.con \"f\")\n in Arr (inpArg tp) (Arr btp btp)\nin map (\\(s,tp) -> (ident s, (fname s, arg tp))) inhAttrs\n")), Rule("vchild", Pattern( Var("./TfmToVisage.ag(line 106, column 11)","lhs.vchild")), Expression("./TfmToVisage.ag(line 106, column 24)","VChild @name @tp @inh @syn (getForField (getName @name) @lhs.rulemap)\n")), Rule("errors", Pattern( Var("","lhs.errors")), Expression("","Seq.empty"))), LocRules( LocRule("defname", Pattern( Var("./GenerateCodeSM.ag(line 545, column 11)","loc.defname")), Expression("./GenerateCodeSM.ag(line 545, column 25)","let impossible = error $ \"This should not happen: child not found \"\n ++ getName @name\n in maybe impossible (uncurry mk_def_name) $ lookup @name @lhs.def_namespace\n"),"False"))))), Production("Children","{attrs:=[(Name,Name)],con:=Identifier,def_namespace:=[(Name,(Int, Int))],down:=[UseStream],fieldnames:=[Name],inh:=Attributes,nt:=Identifier,nts':=[Name],o_rename:=Bool,prefix:=String,rulemap:=VisageRuleMap}","{attributes:=[(Name,Attributes,Attributes)],decls:=Decls,errors:=Seq Error,fields:=[(Name,Type)],smInhAttrNames:=[[String]],smInhFnames:=[String],smInhInsDyns:=[(String,(String,Code.Type))],smInhInserters:=Decls,smSynAttrNames:=[[String]],up:=[UseStream],vchildren:=[VisageChild]}", Alternatives( Alternative("Cons", Children( Child("hd","Child","{attrs:=[(Name,Name)],con:=Identifier,def_namespace:=[(Name,(Int,Int))],down:=[UseStream],fieldnames:=[Name],nt:=Identifier,nts':=[Name],o_rename:=Bool,prefix:=String,rulemap:=VisageRuleMap}","{attributes:=[(Name,Attributes,Attributes)],decls:=Decls,errors:=Seq Error,field:=(Name,Type),smInhAttrNames:=[String],smInhFnames:=[String],smInhInsDyns:=[(String,(String,Code.Type))],smInhInserters:=Decls,smSynAttrNames:=[String],up:=[UseStream],vchild:=VisageChild}", Rules( Rule("attrs", Pattern( Var("./AbstractSyntax.ag(line 21, column 1)","hd.attrs")), Expression("","@lhs.attrs")), Rule("con", Pattern( Var("./AbstractSyntax.ag(line 21, column 1)","hd.con")), Expression("","@lhs.con")), Rule("def_namespace", Pattern( Var("./AbstractSyntax.ag(line 21, column 1)","hd.def_namespace")), Expression("","@lhs.def_namespace")), Rule("down", Pattern( Var("./AbstractSyntax.ag(line 21, column 1)","hd.down")), Expression("","@lhs.down")), Rule("fieldnames", Pattern( Var("./AbstractSyntax.ag(line 21, column 1)","hd.fieldnames")), Expression("","@lhs.fieldnames")), Rule("nt", Pattern( Var("./AbstractSyntax.ag(line 21, column 1)","hd.nt")), Expression("","@lhs.nt")), Rule("nts'", Pattern( Var("./AbstractSyntax.ag(line 21, column 1)","hd.nts'")), Expression("","@lhs.nts'")), Rule("o_rename", Pattern( Var("./AbstractSyntax.ag(line 21, column 1)","hd.o_rename")), Expression("","@lhs.o_rename")), Rule("prefix", Pattern( Var("./AbstractSyntax.ag(line 21, column 1)","hd.prefix")), Expression("","@lhs.prefix")), Rule("rulemap", Pattern( Var("./AbstractSyntax.ag(line 21, column 1)","hd.rulemap")), Expression("","@lhs.rulemap")))), Child("tl","Children","{attrs:=[(Name,Name)],con:=Identifier,def_namespace:=[(Name,(Int, Int))],down:=[UseStream],fieldnames:=[Name],inh:=Attributes,nt:=Identifier,nts':=[Name],o_rename:=Bool,prefix:=String,rulemap:=VisageRuleMap}","{attributes:=[(Name,Attributes,Attributes)],decls:=Decls,errors:=Seq Error,fields:=[(Name,Type)],smInhAttrNames:=[[String]],smInhFnames:=[String],smInhInsDyns:=[(String,(String,Code.Type))],smInhInserters:=Decls,smSynAttrNames:=[[String]],up:=[UseStream],vchildren:=[VisageChild]}", Rules( Rule("attrs", Pattern( Var("./AbstractSyntax.ag(line 21, column 1)","tl.attrs")), Expression("","@lhs.attrs")), Rule("con", Pattern( Var("./AbstractSyntax.ag(line 21, column 1)","tl.con")), Expression("","@lhs.con")), Rule("def_namespace", Pattern( Var("./AbstractSyntax.ag(line 21, column 1)","tl.def_namespace")), Expression("","@lhs.def_namespace")), Rule("down", Pattern( Var("./AbstractSyntax.ag(line 21, column 1)","tl.down")), Expression("","@lhs.down")), Rule("fieldnames", Pattern( Var("./AbstractSyntax.ag(line 21, column 1)","tl.fieldnames")), Expression("","@lhs.fieldnames")), Rule("inh", Pattern( Var("./AbstractSyntax.ag(line 21, column 1)","tl.inh")), Expression("","@lhs.inh")), Rule("nt", Pattern( Var("./AbstractSyntax.ag(line 21, column 1)","tl.nt")), Expression("","@lhs.nt")), Rule("nts'", Pattern( Var("./AbstractSyntax.ag(line 21, column 1)","tl.nts'")), Expression("","@lhs.nts'")), Rule("o_rename", Pattern( Var("./AbstractSyntax.ag(line 21, column 1)","tl.o_rename")), Expression("","@lhs.o_rename")), Rule("prefix", Pattern( Var("./AbstractSyntax.ag(line 21, column 1)","tl.prefix")), Expression("","@lhs.prefix")), Rule("rulemap", Pattern( Var("./AbstractSyntax.ag(line 21, column 1)","tl.rulemap")), Expression("","@lhs.rulemap"))))), Rules( Rule("fields", Pattern( Var("GenerateCode.ag(line 240, column 11)","lhs.fields")), Expression("GenerateCode.ag(line 240, column 24)","@hd.field : @tl.fields\n")), Rule("smSynAttrNames", Pattern( Var("./GenerateCodeSM.ag(line 519, column 10)","lhs.smSynAttrNames")), Expression("./GenerateCodeSM.ag(line 519, column 31)","@hd.smSynAttrNames : @tl.smSynAttrNames\n")), Rule("smInhAttrNames", Pattern( Var("./GenerateCodeSM.ag(line 520, column 10)","lhs.smInhAttrNames")), Expression("./GenerateCodeSM.ag(line 520, column 31)","@hd.smInhAttrNames : @tl.smInhAttrNames\n")), Rule("vchildren", Pattern( Var("./TfmToVisage.ag(line 102, column 17)","lhs.vchildren")), Expression("./TfmToVisage.ag(line 102, column 33)","@hd.vchild : @tl.vchildren\n")), Rule("attributes", Pattern( Var("","lhs.attributes")), Expression("","@hd.attributes ++ @tl.attributes")), Rule("decls", Pattern( Var("","lhs.decls")), Expression("","@hd.decls ++ @tl.decls")), Rule("errors", Pattern( Var("","lhs.errors")), Expression("","@hd.errors Seq.<> @tl.errors")), Rule("smInhFnames", Pattern( Var("","lhs.smInhFnames")), Expression("","@hd.smInhFnames ++ @tl.smInhFnames")), Rule("smInhInsDyns", Pattern( Var("","lhs.smInhInsDyns")), Expression("","@hd.smInhInsDyns ++ @tl.smInhInsDyns")), Rule("smInhInserters", Pattern( Var("","lhs.smInhInserters")), Expression("","@hd.smInhInserters ++ @tl.smInhInserters")), Rule("up", Pattern( Var("","lhs.up")), Expression("","@hd.up ++ @tl.up"))), LocRules()), Alternative("Nil", Children(), Rules( Rule("fields", Pattern( Var("GenerateCode.ag(line 241, column 11)","lhs.fields")), Expression("GenerateCode.ag(line 241, column 24)","[]\n")), Rule("smSynAttrNames", Pattern( Var("./GenerateCodeSM.ag(line 521, column 10)","lhs.smSynAttrNames")), Expression("./GenerateCodeSM.ag(line 521, column 31)","[]\n")), Rule("smInhAttrNames", Pattern( Var("./GenerateCodeSM.ag(line 522, column 10)","lhs.smInhAttrNames")), Expression("./GenerateCodeSM.ag(line 522, column 31)","[]\n")), Rule("vchildren", Pattern( Var("./TfmToVisage.ag(line 103, column 17)","lhs.vchildren")), Expression("./TfmToVisage.ag(line 103, column 33)","[]\n")), Rule("attributes", Pattern( Var("","lhs.attributes")), Expression("","[]")), Rule("decls", Pattern( Var("","lhs.decls")), Expression("","[]")), Rule("errors", Pattern( Var("","lhs.errors")), Expression("","Seq.empty")), Rule("smInhFnames", Pattern( Var("","lhs.smInhFnames")), Expression("","[]")), Rule("smInhInsDyns", Pattern( Var("","lhs.smInhInsDyns")), Expression("","[]")), Rule("smInhInserters", Pattern( Var("","lhs.smInhInserters")), Expression("","[]")), Rule("up", Pattern( Var("","lhs.up")), Expression("","[]"))), LocRules()))), Production("Expression","{attrs:=[(Name,Name)],con:=Name,fieldnames:=[Name],nt:=Name}","{errors:=Seq Error,pos:=Pos,pp:=PP_Doc,self:=SELF,usedAttrs:=[(Name,Name)],usedLocals:=[Name],vexpression:=Expression}", Alternatives( Alternative("Expression", Children( Child("pos","Pos","{}","{}", Rules()), Child("txt","String","{}","{}", Rules())), Rules( Rule("pos", Pattern( Var("./Dep.ag(line 182, column 16)","lhs.pos")), Expression("./Dep.ag(line 182, column 26)","@pos\n")), Rule("vexpression", Pattern( Var("./TfmToVisage.ag(line 116, column 17)","lhs.vexpression")), Expression("./TfmToVisage.ag(line 116, column 35)","@self\n")), Rule("self", Pattern( Var("","lhs.self")), Expression("","@self")), Rule("errors", Pattern( Var("","lhs.errors")), Expression("","@errors")), Rule("pp", Pattern( Var("","lhs.pp")), Expression("","@pp")), Rule("usedAttrs", Pattern( Var("","lhs.usedAttrs")), Expression("","@usedAttrs")), Rule("usedLocals", Pattern( Var("","lhs.usedLocals")), Expression("","@usedLocals"))), LocRules( LocRule("_tup1", Pattern( Var("","loc._tup1")), Expression("./ExpressionAttr.ag(line 30, column 31)","let inherited = Inh_HsTokensRoot\n { attrs_Inh_HsTokensRoot = @lhs.attrs\n , con_Inh_HsTokensRoot = @lhs.con\n , fieldnames_Inh_HsTokensRoot = @lhs.fieldnames\n , nt_Inh_HsTokensRoot = @lhs.nt\n }\n synthesized = wrap_HsTokensRoot (sem_HsTokensRoot (HsTokensRoot $ lexTokens @pos @txt)) inherited\nin case synthesized of\n Syn_HsTokensRoot\n { errors_Syn_HsTokensRoot = errors\n , pp_Syn_HsTokensRoot = pp\n , usedAttrs_Syn_HsTokensRoot = usedAttrs\n , usedLocals_Syn_HsTokensRoot = usedLocals\n } -> (errors,pp,usedAttrs,usedLocals)\n"),"False"), LocRule("errors", Pattern( Product("./ExpressionAttr.ag(line 29, column 21)", Patterns( Pattern( Var("./ExpressionAttr.ag(line 29, column 17)","loc.errors")), Pattern( Underscore("./ExpressionAttr.ag(line 29, column 21)")), Pattern( Underscore("./ExpressionAttr.ag(line 29, column 21)")), Pattern( Underscore("./ExpressionAttr.ag(line 29, column 21)"))))), Expression("./ExpressionAttr.ag(line 29, column 21)","@_tup1"),"False"), LocRule("pp", Pattern( Product("./ExpressionAttr.ag(line 29, column 21)", Patterns( Pattern( Underscore("./ExpressionAttr.ag(line 29, column 21)")), Pattern( Var("./ExpressionAttr.ag(line 29, column 17)","loc.pp")), Pattern( Underscore("./ExpressionAttr.ag(line 29, column 21)")), Pattern( Underscore("./ExpressionAttr.ag(line 29, column 21)"))))), Expression("./ExpressionAttr.ag(line 29, column 21)","@_tup1"),"False"), LocRule("usedAttrs", Pattern( Product("./ExpressionAttr.ag(line 29, column 21)", Patterns( Pattern( Underscore("./ExpressionAttr.ag(line 29, column 21)")), Pattern( Underscore("./ExpressionAttr.ag(line 29, column 21)")), Pattern( Var("./ExpressionAttr.ag(line 29, column 17)","loc.usedAttrs")), Pattern( Underscore("./ExpressionAttr.ag(line 29, column 21)"))))), Expression("./ExpressionAttr.ag(line 29, column 21)","@_tup1"),"False"), LocRule("usedLocals", Pattern( Product("./ExpressionAttr.ag(line 29, column 21)", Patterns( Pattern( Underscore("./ExpressionAttr.ag(line 29, column 21)")), Pattern( Underscore("./ExpressionAttr.ag(line 29, column 21)")), Pattern( Underscore("./ExpressionAttr.ag(line 29, column 21)")), Pattern( Var("./ExpressionAttr.ag(line 29, column 17)","loc.usedLocals"))))), Expression("./ExpressionAttr.ag(line 29, column 21)","@_tup1"),"False"), LocRule("self", Pattern( Var("","loc.self")), Expression("","Expression @pos @txt"),"False"))))), Production("Grammar","{options:=Options}","{errors:=Seq Error,prog:=Program,smdynlists:=([String], [String]),visage:=VisageGrammar}", Alternatives( Alternative("Grammar", Children( Child("typeSyns","TypeSyns","{}","{}", Rules()), Child("useMap","UseMap","{}","{}", Rules()), Child("derivings","Derivings","{}","{}", Rules()), Child("wrappers","Set Nonterminal","{}","{}", Rules()), Child("prods","Productions","{derivings:=Derivings,down:=[UseStream],nts':=[Name],o_cata:=Bool,o_data:=Bool,o_newtypes:=Bool,o_pretty:=Bool,o_rename:=Bool,o_sem:=Bool,o_sig:=Bool,prefix:=String,typeSyns:=TypeSyns,wrappers:=Set Nonterminal}","{decls:=Decls,errors:=Seq Error,nrChildren:=Int,nts:=[Name],smCompDyns:=[(String,(String,[String]))],smConstructors:=[(String,(String,[String]))],smDynSels:=[(String,(String,String,[String]))],smDynSemFuns:=[(String,(String,[String]))],smInputDyns:=[(String,(String,String))],smInsDynsFuns:=[(String, (String,Code.Type))],smPrimTypes:=[String],smSelDynVals:=[(String,(String,[String]))],smTypeCons:=[String],smTypeConsTop:=[String],smdecls:=Decls,up:=[UseStream],vprods:=[VisageProduction]}", Rules( Rule("o_cata", Pattern( Var("GenerateCode.ag(line 78, column 17)","prods.o_cata")), Expression("GenerateCode.ag(line 78, column 35)","folds @lhs.options\n")), Rule("o_data", Pattern( Var("GenerateCode.ag(line 78, column 17)","prods.o_data")), Expression("GenerateCode.ag(line 79, column 35)","dataTypes @lhs.options\n")), Rule("o_sig", Pattern( Var("GenerateCode.ag(line 78, column 17)","prods.o_sig")), Expression("GenerateCode.ag(line 80, column 35)","typeSigs @lhs.options\n")), Rule("o_sem", Pattern( Var("GenerateCode.ag(line 78, column 17)","prods.o_sem")), Expression("GenerateCode.ag(line 81, column 35)","semfuns @lhs.options\n")), Rule("o_rename", Pattern( Var("GenerateCode.ag(line 78, column 17)","prods.o_rename")), Expression("GenerateCode.ag(line 82, column 35)","rename @lhs.options\n")), Rule("o_newtypes", Pattern( Var("GenerateCode.ag(line 78, column 17)","prods.o_newtypes")), Expression("GenerateCode.ag(line 83, column 35)","newtypes @lhs.options\n")), Rule("prefix", Pattern( Var("GenerateCode.ag(line 78, column 17)","prods.prefix")), Expression("GenerateCode.ag(line 84, column 35)","prefix @lhs.options\n")), Rule("typeSyns", Pattern( Var("GenerateCode.ag(line 146, column 13)","prods.typeSyns")), Expression("GenerateCode.ag(line 146, column 33)","@typeSyns\n")), Rule("derivings", Pattern( Var("GenerateCode.ag(line 146, column 13)","prods.derivings")), Expression("GenerateCode.ag(line 147, column 33)","@derivings\n")), Rule("wrappers", Pattern( Var("GenerateCode.ag(line 146, column 13)","prods.wrappers")), Expression("GenerateCode.ag(line 148, column 33)","@wrappers\n")), Rule("nts'", Pattern( Var("GenerateCode.ag(line 379, column 17)","prods.nts'")), Expression("GenerateCode.ag(line 379, column 30)","@prods.nts\n")), Rule("down", Pattern( Var("./Dep.ag(line 52, column 13)","prods.down")), Expression("./Dep.ag(line 52, column 26)","@prods.up\n")), Rule("o_pretty", Pattern( Var("./AbstractSyntax.ag(line 15, column 29)","prods.o_pretty")), Expression("","@o_pretty"))))), Rules( Rule("prog", Pattern( Var("GenerateCode.ag(line 94, column 16)","lhs.prog")), Expression("GenerateCode.ag(line 94, column 27)","if smacro @lhs.options\n then Program (@prods.decls ++ @loc.smUnitDecl ++ @prods.smdecls ++ @loc.defnmdecls)\n else Program @prods.decls\n")), Rule("errors", Pattern( Var("./Dep.ag(line 59, column 13)","lhs.errors")), Expression("./Dep.ag(line 59, column 36)","@errors Seq.<> @prods.errors\n")), Rule("smdynlists", Pattern( Var("./GenerateCodeSM.ag(line 202, column 16)","lhs.smdynlists")), Expression("./GenerateCodeSM.ag(line 202, column 33)","if smacro @lhs.options\nthen (@loc.imports, @loc.smTypeReps ++ @loc.smDefinitions)\nelse ([],[])\n")), Rule("visage", Pattern( Var("./TfmToVisage.ag(line 81, column 17)","lhs.visage")), Expression("./TfmToVisage.ag(line 81, column 30)","VGrammar @prods.vprods\n"))), LocRules( LocRule("o_pretty", Pattern( Var("./Comments.ag(line 15, column 17)","loc.o_pretty")), Expression("./Comments.ag(line 15, column 32)","attrInfo @lhs.options\n"),"False"), LocRule("errors", Pattern( Var("./Dep.ag(line 53, column 13)","loc.errors")), Expression("./Dep.ag(line 53, column 36)","if withCycle @lhs.options\n then getResult\n . transpose\n . map (\\(vertex,stream) -> zip (repeat vertex) stream)\n $ @prods.up\n else Seq.empty\n"),"False"), LocRule("smPrimTypes", Pattern( Var("./GenerateCodeSM.ag(line 157, column 16)","loc.smPrimTypes")), Expression("./GenerateCodeSM.ag(line 157, column 34)","nub (unittp : @prods.smPrimTypes)\n"),"False"), LocRule("smUnitDecl", Pattern( Var("./GenerateCodeSM.ag(line 157, column 16)","loc.smUnitDecl")), Expression("./GenerateCodeSM.ag(line 158, column 34)","[Code.Type unittp (SimpleType unit)]\n"),"False"), LocRule("allTypesTop", Pattern( Var("./GenerateCodeSM.ag(line 157, column 16)","loc.allTypesTop")), Expression("./GenerateCodeSM.ag(line 159, column 34)","nub (@loc.smPrimTypes ++ @prods.smTypeConsTop)\n"),"False"), LocRule("allTypes", Pattern( Var("./GenerateCodeSM.ag(line 157, column 16)","loc.allTypes")), Expression("./GenerateCodeSM.ag(line 160, column 34)","nub (@loc.smPrimTypes ++ @prods.smTypeCons)\n"),"False"), LocRule("imports", Pattern( Var("./GenerateCodeSM.ag(line 157, column 16)","loc.imports")), Expression("./GenerateCodeSM.ag(line 161, column 34)","[\"import DynamicTyping (Equal(..), TypeDescr(..), ShowF(..), Dynamic((:::))\"\n,\" , (.->.), equal, Type(..),transInv)\"\n,\"import SimpleStuff(Id (Id), Exists(E))\"\n,\"import UU.Pretty\"\n,\"import KnitCartNested\"\n]\n"),"False"), LocRule("constructors", Pattern( Var("./GenerateCodeSM.ag(line 157, column 16)","loc.constructors")), Expression("./GenerateCodeSM.ag(line 167, column 35)","mkDynValList \"constructors\" ((unit, (unit, [unittp])) : @prods.smConstructors)\n"),"False"), LocRule("compDyns", Pattern( Var("./GenerateCodeSM.ag(line 157, column 16)","loc.compDyns")), Expression("./GenerateCodeSM.ag(line 168, column 35)","mkDynValList \"attr_computations\" @prods.smCompDyns\n"),"False"), LocRule("inputDyns", Pattern( Var("./GenerateCodeSM.ag(line 157, column 16)","loc.inputDyns")), Expression("./GenerateCodeSM.ag(line 169, column 35)","mkExistList \"comp_inputs\" @prods.smInputDyns\n"),"False"), LocRule("selDyns", Pattern( Var("./GenerateCodeSM.ag(line 157, column 16)","loc.selDyns")), Expression("./GenerateCodeSM.ag(line 170, column 35)","mkDynValListExt \"input_selectors\" @prods.smDynSels\n"),"False"), LocRule("selDynVals", Pattern( Var("./GenerateCodeSM.ag(line 157, column 16)","loc.selDynVals")), Expression("./GenerateCodeSM.ag(line 171, column 35)","mkDynValList \"attr_selectors\" @prods.smSelDynVals\n"),"False"), LocRule("dynSemFuns", Pattern( Var("./GenerateCodeSM.ag(line 157, column 16)","loc.dynSemFuns")), Expression("./GenerateCodeSM.ag(line 172, column 35)","mkDynValList \"sem_constructors\" @prods.smDynSemFuns\n"),"False"), LocRule("dynInsFuns", Pattern( Var("./GenerateCodeSM.ag(line 157, column 16)","loc.dynInsFuns")), Expression("./GenerateCodeSM.ag(line 173, column 35)","mkDynValList' \"attr_inserters\" @prods.smInsDynsFuns\n"),"False"), LocRule("types", Pattern( Var("./GenerateCodeSM.ag(line 157, column 16)","loc.types")), Expression("./GenerateCodeSM.ag(line 174, column 34)","let datatype tp = \"(\" ++ show tp ++ \", \" ++ \"E tp_\" ++ argument tp ++ \")\"\n argument tp | identifier tp `elem` @prods.nts = smsdtype (identifier tp) \"\"\n | otherwise = tp\nin \"types =\"\n : spindent 4 (showAsList (map datatype @loc.allTypesTop))\n"),"False"), LocRule("dataTypeCon", Pattern( Var("./GenerateCodeSM.ag(line 157, column 16)","loc.dataTypeCon")), Expression("./GenerateCodeSM.ag(line 179, column 37)","let datatype tp = tp++\"_tp\" ++ \" (Equal a \" ++ tpName tp ++ \")\"\n toText alts = let sp = map (const ' ') dataTp\n dataTp = \"data TypeCon a \"\n in printList dataTp (dataTp ++ \"= \") \"\" (sp ++ \"| \") alts\n tpName tp = tp\nin toText (map datatype @loc.allTypes)\n"),"False"), LocRule("instanceTypeDescr", Pattern( Var("./GenerateCodeSM.ag(line 157, column 16)","loc.instanceTypeDescr")), Expression("./GenerateCodeSM.ag(line 185, column 40)","let datatype tp = \" match (\" ++ tp ++ \"_tp x) (\" ++ tp ++ \"_tp y) = Just (transInv x y)\"\n inst = \"instance TypeDescr TypeCon where\"\n noMatch = \" match _ _ = Nothing\"\nin inst : (map datatype @loc.allTypes ++ [noMatch])\n"),"False"), LocRule("instanceShowF", Pattern( Var("./GenerateCodeSM.ag(line 157, column 16)","loc.instanceShowF")), Expression("./GenerateCodeSM.ag(line 189, column 39)","let datatype tp = \" showF (\" ++ tp ++ \"_tp _) = \" ++ show tp\n inst = \"instance ShowF TypeCon where\"\nin inst : map datatype @loc.allTypes\n"),"False"), LocRule("tpConstants", Pattern( Var("./GenerateCodeSM.ag(line 157, column 16)","loc.tpConstants")), Expression("./GenerateCodeSM.ag(line 192, column 39)","let datatype tp = \"tp_\" ++ tp ++ \" = \" ++ \"TpCon (\" ++ tp ++ \"_tp equal)\"\nin map datatype @loc.allTypes\n"),"False"), LocRule("defnmdecls", Pattern( Var("./GenerateCodeSM.ag(line 157, column 16)","loc.defnmdecls")), Expression("./GenerateCodeSM.ag(line 194, column 38)","let n = @prods.nrChildren\nin concat (map mk_def_nm_decls [1..n])\n"),"False"), LocRule("smTypeReps", Pattern( Var("./GenerateCodeSM.ag(line 197, column 16)","loc.smTypeReps")), Expression("./GenerateCodeSM.ag(line 197, column 34)","@loc.types ++ @loc.dataTypeCon ++ @loc.instanceTypeDescr\n ++ @loc.instanceShowF ++ @loc.tpConstants\n"),"False"), LocRule("smDefinitions", Pattern( Var("./GenerateCodeSM.ag(line 199, column 16)","loc.smDefinitions")), Expression("./GenerateCodeSM.ag(line 199, column 36)","@loc.constructors ++ @loc.compDyns ++ @loc.inputDyns\n ++ @loc.selDyns ++ @loc.selDynVals ++ @loc.dynSemFuns\n ++ @loc.dynInsFuns\n"),"False"))))), Production("Pattern","{con:=Identifier,fields:=[(Name,Type)],nt:=Identifier}","{errors:=Seq Error,fieldattrs:= [(Name,Name)] ,locVars:=[Name],pp:=PP_Doc,pp':=PP_Doc,self:=SELF,vertices:=[Vertex],vpat:=VisagePattern}", Alternatives( Alternative("Alias", Children( Child("field","Name","{}","{}", Rules()), Child("attr","Name","{}","{}", Rules()), Child("pat","Pattern","{con:=Identifier,fields:=[(Name,Type)],nt:=Identifier}","{errors:=Seq Error,fieldattrs:= [(Name,Name)] ,locVars:=[Name],pp:=PP_Doc,pp':=PP_Doc,self:=SELF,vertices:=[Vertex],vpat:=VisagePattern}", Rules( Rule("con", Pattern( Var("./Patterns.ag(line 15, column 30)","pat.con")), Expression("","@lhs.con")), Rule("fields", Pattern( Var("./Patterns.ag(line 15, column 30)","pat.fields")), Expression("","@lhs.fields")), Rule("nt", Pattern( Var("./Patterns.ag(line 15, column 30)","pat.nt")), Expression("","@lhs.nt"))))), Rules( Rule("pp", Pattern( Var("GenerateCode.ag(line 392, column 13)","lhs.pp")), Expression("GenerateCode.ag(line 392, column 26)","attrname False @field @attr >|< \"@\" >|< @pat.pp\n")), Rule("locVars", Pattern( Var("./Comments.ag(line 51, column 14)","lhs.locVars")), Expression("./Comments.ag(line 51, column 30)","if @field == _LOC\n then [@attr]\n else []\n")), Rule("vertices", Pattern( Var("./Dep.ag(line 169, column 12)","lhs.vertices")), Expression("./Dep.ag(line 169, column 27)","let vertex | @field==_LHS = LHSSyn @lhs.nt @lhs.con @attr\n | @field==_LOC || @field == nullIdent = Local @lhs.nt @lhs.con @attr\n | otherwise = RHSInh fieldType @lhs.nt @lhs.con @field @attr\n fieldType = maybe nullIdent getNonterminalName (lookup @field @lhs.fields)\nin [vertex]\n")), Rule("pp'", Pattern( Var("./GenerateCodeSM.ag(line 411, column 13)","lhs.pp'")), Expression("./GenerateCodeSM.ag(line 411, column 27)","let attribute | @field == _LOC || @field == nullIdent = locname' @attr\n | otherwise = attrname False @field @attr\nin attribute >|< \"@\" >|< @pat.pp'\n")), Rule("vpat", Pattern( Var("./TfmToVisage.ag(line 125, column 17)","lhs.vpat")), Expression("./TfmToVisage.ag(line 125, column 28)","if (isVar @self)\nthen VVar @field @attr\nelse VAlias @field @attr @pat.vpat\n")), Rule("fieldattrs", Pattern( Var("./TfmToVisage.ag(line 134, column 17)","lhs.fieldattrs")), Expression("./TfmToVisage.ag(line 134, column 34)","[(@field, @attr)]\n")), Rule("errors", Pattern( Var("","lhs.errors")), Expression("","@pat.errors")), Rule("self", Pattern( Var("","lhs.self")), Expression("","@self"))), LocRules( LocRule("self", Pattern( Var("","loc.self")), Expression("","Alias @field @attr @pat.self"),"False"))), Alternative("Constr", Children( Child("name","Constructor","{}","{}", Rules()), Child("pats","Patterns","{con:=Identifier,fields:=[(Name,Type)],nt:=Identifier}","{errors:=Seq Error,fieldattrs:= [(Name,Name)] ,locVars:=[Name],pps:=[PP_Doc],pps':=[PP_Doc],self:=SELF,vertices:=[Vertex],vpats:=[VisagePattern]}", Rules( Rule("con", Pattern( Var("./Patterns.ag(line 10, column 30)","pats.con")), Expression("","@lhs.con")), Rule("fields", Pattern( Var("./Patterns.ag(line 10, column 30)","pats.fields")), Expression("","@lhs.fields")), Rule("nt", Pattern( Var("./Patterns.ag(line 10, column 30)","pats.nt")), Expression("","@lhs.nt"))))), Rules( Rule("pp", Pattern( Var("GenerateCode.ag(line 390, column 13)","lhs.pp")), Expression("GenerateCode.ag(line 390, column 26)","pp_parens $ @name >#< hv (map pp_parens @pats.pps)\n")), Rule("pp'", Pattern( Var("./GenerateCodeSM.ag(line 409, column 13)","lhs.pp'")), Expression("./GenerateCodeSM.ag(line 409, column 27)","pp_parens $ @name >#< hv (map pp_parens @pats.pps')\n")), Rule("vpat", Pattern( Var("./TfmToVisage.ag(line 123, column 17)","lhs.vpat")), Expression("./TfmToVisage.ag(line 123, column 28)","VConstr @name @pats.vpats\n")), Rule("errors", Pattern( Var("","lhs.errors")), Expression("","@pats.errors")), Rule("fieldattrs", Pattern( Var("","lhs.fieldattrs")), Expression("","@pats.fieldattrs")), Rule("locVars", Pattern( Var("","lhs.locVars")), Expression("","@pats.locVars")), Rule("vertices", Pattern( Var("","lhs.vertices")), Expression("","@pats.vertices")), Rule("self", Pattern( Var("","lhs.self")), Expression("","@self"))), LocRules( LocRule("self", Pattern( Var("","loc.self")), Expression("","Constr @name @pats.self"),"False"))), Alternative("Product", Children( Child("pos","Pos","{}","{}", Rules()), Child("pats","Patterns","{con:=Identifier,fields:=[(Name,Type)],nt:=Identifier}","{errors:=Seq Error,fieldattrs:= [(Name,Name)] ,locVars:=[Name],pps:=[PP_Doc],pps':=[PP_Doc],self:=SELF,vertices:=[Vertex],vpats:=[VisagePattern]}", Rules( Rule("con", Pattern( Var("./Patterns.ag(line 12, column 30)","pats.con")), Expression("","@lhs.con")), Rule("fields", Pattern( Var("./Patterns.ag(line 12, column 30)","pats.fields")), Expression("","@lhs.fields")), Rule("nt", Pattern( Var("./Patterns.ag(line 12, column 30)","pats.nt")), Expression("","@lhs.nt"))))), Rules( Rule("pp", Pattern( Var("GenerateCode.ag(line 391, column 13)","lhs.pp")), Expression("GenerateCode.ag(line 391, column 26)","pp_block \"(\" \")\" \",\" @pats.pps\n")), Rule("pp'", Pattern( Var("./GenerateCodeSM.ag(line 410, column 13)","lhs.pp'")), Expression("./GenerateCodeSM.ag(line 410, column 27)","pp_block \"(\" \")\" \",\" @pats.pps'\n")), Rule("vpat", Pattern( Var("./TfmToVisage.ag(line 124, column 17)","lhs.vpat")), Expression("./TfmToVisage.ag(line 124, column 28)","VProduct @pos @pats.vpats\n")), Rule("errors", Pattern( Var("","lhs.errors")), Expression("","@pats.errors")), Rule("fieldattrs", Pattern( Var("","lhs.fieldattrs")), Expression("","@pats.fieldattrs")), Rule("locVars", Pattern( Var("","lhs.locVars")), Expression("","@pats.locVars")), Rule("vertices", Pattern( Var("","lhs.vertices")), Expression("","@pats.vertices")), Rule("self", Pattern( Var("","lhs.self")), Expression("","@self"))), LocRules( LocRule("self", Pattern( Var("","loc.self")), Expression("","Product @pos @pats.self"),"False"))), Alternative("Underscore", Children( Child("pos","Pos","{}","{}", Rules())), Rules( Rule("pp", Pattern( Var("GenerateCode.ag(line 393, column 16)","lhs.pp")), Expression("GenerateCode.ag(line 393, column 26)","text \"_\"\n")), Rule("pp'", Pattern( Var("./GenerateCodeSM.ag(line 414, column 16)","lhs.pp'")), Expression("./GenerateCodeSM.ag(line 414, column 27)","text \"_\"\n")), Rule("vpat", Pattern( Var("./TfmToVisage.ag(line 128, column 17)","lhs.vpat")), Expression("./TfmToVisage.ag(line 128, column 28)","VUnderscore @pos\n")), Rule("errors", Pattern( Var("","lhs.errors")), Expression("","Seq.empty")), Rule("fieldattrs", Pattern( Var("","lhs.fieldattrs")), Expression(""," [] ")), Rule("locVars", Pattern( Var("","lhs.locVars")), Expression("","[]")), Rule("vertices", Pattern( Var("","lhs.vertices")), Expression("","[]")), Rule("self", Pattern( Var("","lhs.self")), Expression("","@self"))), LocRules( LocRule("self", Pattern( Var("","loc.self")), Expression("","Underscore @pos"),"False"))))), Production("Patterns","{con:=Identifier,fields:=[(Name,Type)],nt:=Identifier}","{errors:=Seq Error,fieldattrs:= [(Name,Name)] ,locVars:=[Name],pps:=[PP_Doc],pps':=[PP_Doc],self:=SELF,vertices:=[Vertex],vpats:=[VisagePattern]}", Alternatives( Alternative("Cons", Children( Child("hd","Pattern","{con:=Identifier,fields:=[(Name,Type)],nt:=Identifier}","{errors:=Seq Error,fieldattrs:= [(Name,Name)] ,locVars:=[Name],pp:=PP_Doc,pp':=PP_Doc,self:=SELF,vertices:=[Vertex],vpat:=VisagePattern}", Rules( Rule("con", Pattern( Var("./Patterns.ag(line 7, column 1)","hd.con")), Expression("","@lhs.con")), Rule("fields", Pattern( Var("./Patterns.ag(line 7, column 1)","hd.fields")), Expression("","@lhs.fields")), Rule("nt", Pattern( Var("./Patterns.ag(line 7, column 1)","hd.nt")), Expression("","@lhs.nt")))), Child("tl","Patterns","{con:=Identifier,fields:=[(Name,Type)],nt:=Identifier}","{errors:=Seq Error,fieldattrs:= [(Name,Name)] ,locVars:=[Name],pps:=[PP_Doc],pps':=[PP_Doc],self:=SELF,vertices:=[Vertex],vpats:=[VisagePattern]}", Rules( Rule("con", Pattern( Var("./Patterns.ag(line 7, column 1)","tl.con")), Expression("","@lhs.con")), Rule("fields", Pattern( Var("./Patterns.ag(line 7, column 1)","tl.fields")), Expression("","@lhs.fields")), Rule("nt", Pattern( Var("./Patterns.ag(line 7, column 1)","tl.nt")), Expression("","@lhs.nt"))))), Rules( Rule("pps", Pattern( Var("GenerateCode.ag(line 386, column 10)","lhs.pps")), Expression("GenerateCode.ag(line 386, column 20)","@hd.pp : @tl.pps\n")), Rule("pps'", Pattern( Var("./GenerateCodeSM.ag(line 405, column 10)","lhs.pps'")), Expression("./GenerateCodeSM.ag(line 405, column 21)","@hd.pp' : @tl.pps'\n")), Rule("vpats", Pattern( Var("./TfmToVisage.ag(line 119, column 17)","lhs.vpats")), Expression("./TfmToVisage.ag(line 119, column 29)","@hd.vpat : @tl.vpats\n")), Rule("errors", Pattern( Var("","lhs.errors")), Expression("","@hd.errors Seq.<> @tl.errors")), Rule("fieldattrs", Pattern( Var("","lhs.fieldattrs")), Expression("","@hd.fieldattrs ++ @tl.fieldattrs")), Rule("locVars", Pattern( Var("","lhs.locVars")), Expression("","@hd.locVars ++ @tl.locVars")), Rule("vertices", Pattern( Var("","lhs.vertices")), Expression("","@hd.vertices ++ @tl.vertices")), Rule("self", Pattern( Var("","lhs.self")), Expression("","@self"))), LocRules( LocRule("self", Pattern( Var("","loc.self")), Expression("","(:) @hd.self @tl.self"),"False"))), Alternative("Nil", Children(), Rules( Rule("pps", Pattern( Var("GenerateCode.ag(line 387, column 10)","lhs.pps")), Expression("GenerateCode.ag(line 387, column 20)","[]\n")), Rule("pps'", Pattern( Var("./GenerateCodeSM.ag(line 406, column 10)","lhs.pps'")), Expression("./GenerateCodeSM.ag(line 406, column 21)","[]\n")), Rule("vpats", Pattern( Var("./TfmToVisage.ag(line 120, column 17)","lhs.vpats")), Expression("./TfmToVisage.ag(line 120, column 29)","[]\n")), Rule("errors", Pattern( Var("","lhs.errors")), Expression("","Seq.empty")), Rule("fieldattrs", Pattern( Var("","lhs.fieldattrs")), Expression(""," [] ")), Rule("locVars", Pattern( Var("","lhs.locVars")), Expression("","[]")), Rule("vertices", Pattern( Var("","lhs.vertices")), Expression("","[]")), Rule("self", Pattern( Var("","lhs.self")), Expression("","@self"))), LocRules( LocRule("self", Pattern( Var("","loc.self")), Expression("","[] "),"False"))))), Production("Production","{derivings:=Derivings,down:=[UseStream],nts':=[Name],o_cata:=Bool,o_data:=Bool,o_newtypes:=Bool,o_pretty:=Bool,o_rename:=Bool,o_sem:=Bool,o_sig:=Bool,prefix:=String,typeSyns:=TypeSyns,wrappers:=Set Nonterminal}","{decls:=Decls,errors:=Seq Error,nrChildren:=Int,nts:=[Name],smCompDyns:=[(String,(String,[String]))],smConstructors:=[(String,(String,[String]))],smDynSels:=[(String,(String,String,[String]))],smDynSemFuns:=[(String,(String,[String]))],smInputDyns:=[(String,(String,String))],smInsDynsFuns:=[(String, (String,Code.Type))],smPrimTypes:=[String],smSelDynVals:=[(String,(String,[String]))],smTypeCons:=[String],smTypeConsTop:=[String],smdecls:=Decls,up:=[UseStream],vprod:=VisageProduction}", Alternatives( Alternative("Production", Children( Child("nt","Nonterminal","{}","{}", Rules()), Child("inh","Attributes","{}","{}", Rules()), Child("syn","Attributes","{}","{}", Rules()), Child("alts","Alternatives","{down:=[UseStream],inh:=Attributes,nt:=Identifier,nts':=[Name],o_cata:=Bool,o_newtypes:=Bool,o_pretty:=Bool,o_rename:=Bool,o_sem:=Bool,o_sig:=Bool,prefix:=String,syn:=Attributes}","{cataAlts:=Decls,comments:=Decls,dataAlts:=DataAlts,errors:=Seq Error,nrChildren:=Int,semFuns:=Decls,smCataAlts:=Decls,smCompDyns:=[(String,(String,[String]))],smConstructors:=[(String,(String,[String]))],smDynSels:=[(String,(String,String,[String]))],smDynSemFuns:=[(String,(String,[String]))],smInputDyns:=[(String,(String,String))],smInsDyns:=[(String,(String,Code.Type))],smPrimTypes:=[String],smSelFuns:=Decls,smSemFuns:=Decls,smTypeCons:=[String],up:=[UseStream],valts:=[VisageAlternative]}", Rules( Rule("nt", Pattern( Var("GenerateCode.ag(line 61, column 16)","alts.nt")), Expression("GenerateCode.ag(line 61, column 28)","@nt\n")), Rule("inh", Pattern( Var("GenerateCode.ag(line 65, column 16)","alts.inh")), Expression("GenerateCode.ag(line 65, column 28)","@inh\n")), Rule("syn", Pattern( Var("GenerateCode.ag(line 66, column 16)","alts.syn")), Expression("GenerateCode.ag(line 66, column 28)","@syn\n")), Rule("down", Pattern( Var("./AbstractSyntax.ag(line 28, column 32)","alts.down")), Expression("","@lhs.down")), Rule("nts'", Pattern( Var("./AbstractSyntax.ag(line 28, column 32)","alts.nts'")), Expression("","@lhs.nts'")), Rule("o_cata", Pattern( Var("./AbstractSyntax.ag(line 28, column 32)","alts.o_cata")), Expression("","@lhs.o_cata")), Rule("o_newtypes", Pattern( Var("./AbstractSyntax.ag(line 28, column 32)","alts.o_newtypes")), Expression("","@lhs.o_newtypes")), Rule("o_pretty", Pattern( Var("./AbstractSyntax.ag(line 28, column 32)","alts.o_pretty")), Expression("","@lhs.o_pretty")), Rule("o_rename", Pattern( Var("./AbstractSyntax.ag(line 28, column 32)","alts.o_rename")), Expression("","@lhs.o_rename")), Rule("o_sem", Pattern( Var("./AbstractSyntax.ag(line 28, column 32)","alts.o_sem")), Expression("","@lhs.o_sem")), Rule("o_sig", Pattern( Var("./AbstractSyntax.ag(line 28, column 32)","alts.o_sig")), Expression("","@lhs.o_sig")), Rule("prefix", Pattern( Var("./AbstractSyntax.ag(line 28, column 32)","alts.prefix")), Expression("","@lhs.prefix"))))), Rules( Rule("decls", Pattern( Var("GenerateCode.ag(line 100, column 17)","lhs.decls")), Expression("GenerateCode.ag(line 100, column 29)","Comment (getName @nt ++ \" \" ++ replicate (60 - length (getName @nt)) '-') :\n(if @lhs.o_pretty then @loc.comment : @alts.comments else []) ++\n(if @lhs.o_data then [@loc.dataDef] else []) ++\n(if @lhs.o_sig || @lhs.o_sem then @loc.semDom else []) ++\n(if @lhs.o_cata then @loc.cataFun else []) ++\n(if Set.member @nt @lhs.wrappers then @loc.semWrapper else []) ++\n(if @lhs.o_sem then @alts.semFuns else [])\n")), Rule("nts", Pattern( Var("GenerateCode.ag(line 376, column 17)","lhs.nts")), Expression("GenerateCode.ag(line 376, column 30)","[@nt]\n")), Rule("up", Pattern( Var("./Dep.ag(line 81, column 16)","lhs.up")), Expression("./Dep.ag(line 81, column 25)","@alts.up ++ @is ++ @si\n")), Rule("smdecls", Pattern( Var("./GenerateCodeSM.ag(line 237, column 17)","lhs.smdecls")), Expression("./GenerateCodeSM.ag(line 237, column 31)","Comment (getName @nt ++ \" \" ++ replicate (60 - length (getName @nt)) '-') :\n(@loc.smCataFun) ++\n(@alts.smSemFuns) ++\n(@loc.smSemDom) ++\n[Comment (getName @nt ++ \" SM Functions\" ++ replicate (60 - length (getName @nt)) '-')] ++\n(@loc.smSelInsFuns)\n")), Rule("smTypeCons", Pattern( Var("./GenerateCodeSM.ag(line 262, column 17)","lhs.smTypeCons")), Expression("./GenerateCodeSM.ag(line 262, column 34)","@loc.smTpCons ++ @alts.smTypeCons ++ map (typeToString @nt)(Map.elems @syn ++ Map.elems @inh)\n")), Rule("smTypeConsTop", Pattern( Var("./GenerateCodeSM.ag(line 263, column 17)","lhs.smTypeConsTop")), Expression("./GenerateCodeSM.ag(line 263, column 37)","getName @nt : map (typeToString @nt) (Map.elems @syn ++ Map.elems @inh)\n")), Rule("smPrimTypes", Pattern( Var("./GenerateCodeSM.ag(line 264, column 17)","lhs.smPrimTypes")), Expression("./GenerateCodeSM.ag(line 264, column 35)","@alts.smPrimTypes\n")), Rule("smInputDyns", Pattern( Var("./GenerateCodeSM.ag(line 782, column 16)","lhs.smInputDyns")), Expression("./GenerateCodeSM.ag(line 782, column 34)","@loc.smInputDyn : @alts.smInputDyns\n")), Rule("smDynSels", Pattern( Var("./GenerateCodeSM.ag(line 786, column 28)","lhs.smDynSels")), Expression("./GenerateCodeSM.ag(line 786, column 44)","@loc.smSynSelDyn : @loc.smInhSelDyn : @alts.smDynSels\n")), Rule("smSelDynVals", Pattern( Var("./GenerateCodeSM.ag(line 787, column 16)","lhs.smSelDynVals")), Expression("./GenerateCodeSM.ag(line 787, column 35)","@loc.inhSelDynVals ++ @loc.synSelDynVals\n")), Rule("smInsDynsFuns", Pattern( Var("./GenerateCodeSM.ag(line 788, column 28)","lhs.smInsDynsFuns")), Expression("./GenerateCodeSM.ag(line 788, column 48)","@alts.smInsDyns ++ @loc.inhInsDyns ++ @loc.synInsDyns\n")), Rule("vprod", Pattern( Var("./TfmToVisage.ag(line 88, column 17)","lhs.vprod")), Expression("./TfmToVisage.ag(line 88, column 29)","VProduction @nt @inh @syn @alts.valts\n")), Rule("errors", Pattern( Var("","lhs.errors")), Expression("","@alts.errors")), Rule("nrChildren", Pattern( Var("","lhs.nrChildren")), Expression("","@alts.nrChildren")), Rule("smCompDyns", Pattern( Var("","lhs.smCompDyns")), Expression("","@alts.smCompDyns")), Rule("smConstructors", Pattern( Var("","lhs.smConstructors")), Expression("","@alts.smConstructors")), Rule("smDynSemFuns", Pattern( Var("","lhs.smDynSemFuns")), Expression("","@alts.smDynSemFuns"))), LocRules( LocRule("semWrapper", Pattern( Var("GenerateCode.ag(line 117, column 16)","loc.semWrapper")), Expression("GenerateCode.ag(line 118, column 22)","let inhAttrs = Map.toList @inh\n synAttrs = Map.toList @syn\n inhNT = \"Inh\" ++ \"_\" ++ getName @nt\n synNT = \"Syn\" ++ \"_\" ++ getName @nt\n wrapNT = \"wrap\" ++ \"_\" ++ getName @nt\n mkdata n attrs = Data n [Record n [(getName f++\"_\"++n,typeToString @nt t) | (f,t) <- attrs]] []\n datas = [mkdata inhNT inhAttrs, mkdata synNT synAttrs]\n typeSig = TSig wrapNT (SimpleType (sdtype @nt) `Arr` (SimpleType inhNT `Arr` SimpleType synNT))\n function = let var = \"sem\"\n varPat = if @lhs.o_newtypes\n then App (sdtype @nt) [SimpleExpr var]\n else SimpleExpr var\n inhVars = [ SimpleExpr (\"i\" ++ show x) | x <- take (length inhAttrs) [1..]]\n synVarsN = [ (\"s\" ++ show x) | x <- take (length synAttrs) [1..]]\n synVarsE = map SimpleExpr synVarsN\n in Decl (Fun wrapNT [varPat, App inhNT inhVars])\n (Let [Decl (TupleLhs synVarsN) (App var inhVars) | not(null synVarsN)]\n (App synNT synVarsE))\nin datas ++ (if @lhs.o_sig then [typeSig] else []) ++ [function]\n"),"False"), LocRule("dataDef", Pattern( Var("GenerateCode.ag(line 151, column 16)","loc.dataDef")), Expression("GenerateCode.ag(line 151, column 30)","let typeSyn tp = let theType =\n case tp of\n CommonTypes.Maybe t -> SimpleType (\"Maybe (\" ++ typeToString @nt t ++\")\")\n CommonTypes.List t -> Code.List $ SimpleType (typeToString @nt t)\n CommonTypes.Tuple ts -> Code.TupleType [SimpleType (typeToString @nt t)\n | (_,t) <- ts\n ]\n in Code.Type (getName @nt) theType\n derivings = maybe [] (map getName . Set.toList) (Map.lookup @nt @lhs.derivings)\n dataDef = Data (getName @nt) @alts.dataAlts derivings\nin maybe dataDef typeSyn $ lookup @nt @lhs.typeSyns\n"),"False"), LocRule("semDom", Pattern( Var("GenerateCode.ag(line 168, column 17)","loc.semDom")), Expression("GenerateCode.ag(line 168, column 30)","let tp = foldr Arr synTps inhTps\n synTps = TupleType [SimpleType (typeToString @nt tp) | tp <- Map.elems @syn]\n inhTps = [SimpleType (typeToString @nt tp) | tp <- Map.elems @inh]\nin if @lhs.o_sig || @lhs.o_newtypes\n then\n [ Comment \"semantic domain\"\n , if @lhs.o_newtypes\n then NewType (sdtype @nt) (sdtype @nt) tp\n else Code.Type (sdtype @nt) tp\n ]\n else []\n"),"False"), LocRule("cataFun", Pattern( Var("GenerateCode.ag(line 183, column 16)","loc.cataFun")), Expression("GenerateCode.ag(line 183, column 31)","let tSig = TSig (cataname @lhs.prefix @nt)\n (SimpleType (getName @nt) `Arr` SimpleType (sdtype @nt))\n special typ = case typ of\n CommonTypes.List tp ->\n let cons = SimpleExpr (semname @lhs.prefix @nt (identifier \"Cons\"))\n nil = SimpleExpr (semname @lhs.prefix @nt (identifier \"Nil\" ))\n arg = SimpleExpr \"list\"\n rarg = case tp of\n NT t -> SimpleExpr (\"(Prelude.map \" ++ (cataname @lhs.prefix t) ++ \" list)\")\n _ -> arg\n lhs = Fun (cataname @lhs.prefix @nt) [arg]\n rhs = (App \"Prelude.foldr\" [cons,nil,rarg])\n in [Decl lhs rhs]\n CommonTypes.Maybe tp ->\n let just = semname @lhs.prefix @nt (identifier \"Just\")\n nothing = semname @lhs.prefix @nt (identifier \"Nothing\" )\n arg = SimpleExpr \"x\"\n rarg = case tp of\n NT t -> App (cataname @lhs.prefix t) [arg]\n _ -> arg\n lhs a = Fun (cataname @lhs.prefix @nt) [a]\n in [Decl (lhs (App \"Prelude.Just\" [arg])) (App just [rarg])\n ,Decl (lhs (SimpleExpr \"Prelude.Nothing\")) (SimpleExpr nothing)\n ]\n CommonTypes.Tuple tps ->\n let con = semname @lhs.prefix @nt (identifier \"Tuple\")\n tps' = [ (SimpleExpr (getName x),y) | (x,y) <- tps]\n rargs = map rarg tps'\n rarg (n, tp) = case tp of\n NT t -> App (cataname @lhs.prefix t) [n]\n _ -> n\n lhs = Fun (cataname @lhs.prefix @nt) [TupleExpr (map fst tps')]\n rhs = App con rargs\n in [Decl lhs rhs]\nin Comment \"cata\" :\n (if @lhs.o_sig then [tSig] else []) ++\n maybe @alts.cataAlts special (lookup @nt @lhs.typeSyns)\n"),"False"), LocRule("comment", Pattern( Var("./Comments.ag(line 18, column 17)","loc.comment")), Expression("./Comments.ag(line 18, column 31)","let syn' = map toString (Map.toList @syn)\n inh' = map toString (Map.toList @inh)\n toString (a,t) = (getName a, case t of (NT nt) -> getName nt; Haskell t -> t)\n chnn = inh' `intersect` syn'\n inhn = inh' \\\\ chnn\n synn = syn' \\\\ chnn\nin Comment . unlines $\n [ replicate 3 ' ' ++ \"inherited attributes:\"\n , unlines . map ((replicate 6 ' ')++) .\n map (\\(x,y) -> x ++ replicate ((20 - length x) `max` 0) ' ' ++ \" : \" ++ y) $ inhn\n , replicate 3 ' ' ++ \"chained attributes:\"\n , unlines . map ((replicate 6 ' ')++) .\n map (\\(x,y) -> x ++ replicate ((20 - length x) `max` 0) ' ' ++ \" : \" ++ y) $ chnn\n , replicate 3 ' ' ++ \"synthesised attributes:\"\n , unlines . map ((replicate 6 ' ')++) .\n map (\\(x,y) -> x ++ replicate ((20 - length x) `max` 0) ' ' ++ \" : \" ++ y) $ synn\n ]\n"),"False"), LocRule("is", Pattern( Var("./Dep.ag(line 79, column 16)","loc.is")), Expression("./Dep.ag(line 79, column 25)","[let v = NTSyn @nt syn in (v, prod2stream v @lhs.down) | syn<-(Map.keys @syn)]\n"),"False"), LocRule("si", Pattern( Var("./Dep.ag(line 79, column 16)","loc.si")), Expression("./Dep.ag(line 80, column 25)","[let v = NTInh @nt inh in (v, prod2stream v @lhs.down) | inh<-(Map.keys @inh)]\n"),"False"), LocRule("smSemDom", Pattern( Var("./GenerateCodeSM.ag(line 248, column 17)","loc.smSemDom")), Expression("./GenerateCodeSM.ag(line 248, column 32)","let tp = Arr inhTps synTps\n synTps = tupnestTp [SimpleType (typeToString @nt tp) | tp <- Map.elems @syn]\n inhTps = tupnestTp [SimpleType (typeToString @nt tp) | tp <- Map.elems @inh]\n inputTp = TupleType [inhTps, synTps]\n mkTp tp post = Code.Type (smsdtype @nt post) tp\nin [ Comment \"sm semantic domain\"\n , mkTp tp \"\"\n , mkTp synTps \"syn\"\n , mkTp inhTps \"inh\"\n , mkTp inputTp \"input\"\n , mkTp (SimpleType unit) \"loc\"\n ]\n"),"False"), LocRule("smTpCons", Pattern( Var("./GenerateCodeSM.ag(line 260, column 17)","loc.smTpCons")), Expression("./GenerateCodeSM.ag(line 260, column 32)","let mkTpNm post = smsdtype @nt post\nin [mkTpNm \"syn\", mkTpNm \"inh\", mkTpNm \"input\", mkTpNm \"\", getName @nt]\n"),"False"), LocRule("smCataFun", Pattern( Var("./GenerateCodeSM.ag(line 270, column 16)","loc.smCataFun")), Expression("./GenerateCodeSM.ag(line 270, column 33)","let tSig = TSig (smcataname @lhs.prefix @nt)\n (SimpleType (getName @nt) `Arr` SimpleType (smsdtype @nt \"\"))\n special typ = case typ of\n CommonTypes.List tp ->\n let cons = SimpleExpr (semname @lhs.prefix @nt (identifier \"Cons\"))\n nil = SimpleExpr (semname @lhs.prefix @nt (identifier \"Nil\" ))\n arg = SimpleExpr \"list\"\n rarg = case tp of\n NT t -> SimpleExpr (\"(map \" ++ (smcataname @lhs.prefix t) ++ \" list)\")\n _ -> arg\n lhs = Fun (smcataname @lhs.prefix @nt) [arg]\n rhs = (App \"foldr\" [cons,nil,rarg])\n in [Decl lhs rhs]\n CommonTypes.Maybe tp ->\n let just = semname @lhs.prefix @nt (identifier \"Just\")\n nothing = semname @lhs.prefix @nt (identifier \"Nothing\" )\n arg = SimpleExpr \"x\"\n rarg = case tp of\n NT t -> App (smcataname @lhs.prefix t) [arg]\n _ -> arg\n lhs a = Fun (smcataname @lhs.prefix @nt) [a]\n in [Decl (lhs (App \"Just\" [arg])) (App just [rarg])\n ,Decl (lhs (SimpleExpr \"Nothing\")) (SimpleExpr nothing)\n ]\n CommonTypes.Tuple tps ->\n let con = semname @lhs.prefix @nt (identifier \"Tuple\")\n tps' = [ (SimpleExpr (getName x),y) | (x,y) <- tps]\n rargs = map rarg tps'\n rarg (n, tp) = case tp of\n NT t -> App (smcataname @lhs.prefix t) [n]\n _ -> n\n lhs = Fun (smcataname @lhs.prefix @nt) [TupleExpr (map fst tps')]\n rhs = App con rargs\n in [Decl lhs rhs]\nin Comment \"sm cata\" :\n (if @lhs.o_sig then [tSig] else []) ++\n maybe @alts.smCataAlts special (lookup @nt @lhs.typeSyns)\n"),"False"), LocRule("synIns", Pattern( Var("./GenerateCodeSM.ag(line 658, column 16)","loc.synIns")), Expression("./GenerateCodeSM.ag(line 658, column 29)","let mklhs syn = Fun (insertnm @nt nullIdent syn) funargs\n synAttrs = Map.keys @syn\n nestedProd = tupnest (map (SimpleExpr . getName) synAttrs)\n funargs = [ SimpleExpr \"_syn_\", nestedProd ]\n mkrhs syn = tupnest (map (\\syn' -> if syn == syn'\n then SimpleExpr \"_syn_\"\n else SimpleExpr (getName syn'))\n synAttrs)\nin map (\\s -> Decl (mklhs s) (mkrhs s)) synAttrs\n"),"False"), LocRule("inhIns", Pattern( Var("./GenerateCodeSM.ag(line 667, column 16)","loc.inhIns")), Expression("./GenerateCodeSM.ag(line 667, column 29)","let mklhs inh = Fun (insertnm @nt nullIdent inh) funargs\n inhAttrs = Map.keys @inh\n nestedProd = tupnest (map (SimpleExpr . getName) inhAttrs)\n funargs = [ SimpleExpr \"_inh_\", nestedProd ]\n mkrhs inh = tupnest (map (\\inh' -> if inh == inh'\n then SimpleExpr \"_inh_\"\n else SimpleExpr (getName inh'))\n inhAttrs)\nin map (\\s -> Decl (mklhs s) (mkrhs s)) inhAttrs\n"),"False"), LocRule("synSel", Pattern( Var("./GenerateCodeSM.ag(line 676, column 16)","loc.synSel")), Expression("./GenerateCodeSM.ag(line 676, column 29)","let mklhs syn = Fun (selectnm @nt nullIdent syn) funargs\n synAttrs = Map.keys @syn\n nestedProd = tupnest (map (SimpleExpr . getName) synAttrs)\n funargs = [ nestedProd ]\n mkrhs syn = SimpleExpr (getName syn)\nin map (\\s -> Decl (mklhs s) (mkrhs s)) synAttrs\n"),"False"), LocRule("inhSel", Pattern( Var("./GenerateCodeSM.ag(line 682, column 16)","loc.inhSel")), Expression("./GenerateCodeSM.ag(line 682, column 29)","let mklhs inh = Fun (selectnm @nt nullIdent inh) funargs\n inhAttrs = Map.keys @inh\n nestedProd = tupnest (map (SimpleExpr . getName) inhAttrs)\n funargs = [ nestedProd ]\n mkrhs inh = SimpleExpr (getName inh)\nin map (\\s -> Decl (mklhs s) (mkrhs s)) inhAttrs\n"),"False"), LocRule("synSelDynVals", Pattern( Var("./GenerateCodeSM.ag(line 688, column 16)","loc.synSelDynVals")), Expression("./GenerateCodeSM.ag(line 688, column 36)","let fident a = getName @nt ++ \"_\" ++ getName a\n fnm a = selectnm @nt nullIdent a\n fargs atp = [smsdtype @nt \"syn\",\n (typeToString @nt atp)]\n fdyn (a,atp) = (fident a, (fnm a, fargs atp))\n synAttrs = zip (Map.keys @syn) (Map.elems @syn)\n in map fdyn synAttrs\n"),"False"), LocRule("inhSelDynVals", Pattern( Var("./GenerateCodeSM.ag(line 695, column 16)","loc.inhSelDynVals")), Expression("./GenerateCodeSM.ag(line 695, column 36)","let fident a = getName @nt ++ \"_\" ++ getName a\n fnm a = selectnm @nt nullIdent a\n fargs atp = [smsdtype @nt \"inh\",\n (typeToString @nt atp)]\n fdyn (a,atp) = (fident a, (fnm a, fargs atp))\n inhAttrs = zip (Map.keys @inh) (Map.elems @inh)\n in map fdyn inhAttrs\n"),"False"), LocRule("inhTupSel", Pattern( Var("./GenerateCodeSM.ag(line 702, column 16)","loc.inhTupSel")), Expression("./GenerateCodeSM.ag(line 702, column 32)","let lhs = Fun (selectnm @nt nullIdent (identifier \"inhAttrTuple\")) []\n rhs = SimpleExpr \"fst\"\nin [Decl lhs rhs]\n"),"False"), LocRule("synTupSel", Pattern( Var("./GenerateCodeSM.ag(line 705, column 16)","loc.synTupSel")), Expression("./GenerateCodeSM.ag(line 705, column 32)","let lhs = Fun (selectnm @nt nullIdent (identifier \"synAttrTuple\")) []\n rhs = SimpleExpr \"snd\"\nin [Decl lhs rhs]\n"),"False"), LocRule("smSynSelDyn", Pattern( Var("./GenerateCodeSM.ag(line 708, column 16)","loc.smSynSelDyn")), Expression("./GenerateCodeSM.ag(line 708, column 36)","let ident = (smsdtype @nt \"\") ++ \"_syn\"\n nm = selectnm @nt nullIdent (identifier \"synAttrTuple\")\n args = [(smsdtype @nt \"input\"),\n (smsdtype @nt \"syn\")]\nin (ident,(getName @nt,nm,args))\n"),"False"), LocRule("smInhSelDyn", Pattern( Var("./GenerateCodeSM.ag(line 713, column 16)","loc.smInhSelDyn")), Expression("./GenerateCodeSM.ag(line 713, column 36)","let ident = (smsdtype @nt \"\") ++ \"_inh\"\n nm = selectnm @nt nullIdent (identifier \"inhAttrTuple\")\n args = [(smsdtype @nt \"input\"),\n (smsdtype @nt \"inh\")]\nin (ident,(getName @nt,nm,args))\n"),"False"), LocRule("inhInsComp", Pattern( Var("./GenerateCodeSM.ag(line 718, column 16)","loc.inhInsComp")), Expression("./GenerateCodeSM.ag(line 718, column 33)","let mklhs inh = Fun (insertnm @nt (identifier \"comp\") inh) funargs\n inhAttrs = Map.keys @inh\n inhsyn = \"_inh2syn_\"\n funargs = [ SimpleExpr \"_inh_\", SimpleExpr inhsyn ]\n mkrhs inh = let rhsbody = Let [decl, decl'] letbody\n decl = Decl (Fun inh' [])\n (App (insertnm @nt nullIdent inh)\n [ App \"_inh_\"\n [TupleExpr [ SimpleExpr pi\n , SimpleExpr syn'\n ]\n ]\n , SimpleExpr pi]\n )\n decl' = Decl (Fun syn' [])\n (App inhsyn [SimpleExpr pi])\n letbody = App inhsyn [SimpleExpr inh']\n inh' = \"_inh_new\"\n syn' = \"_syn_old\"\n pi = \"_parent_in\"\n in Lambda [pi] rhsbody\nin map (\\s -> Decl (mklhs s) (mkrhs s)) inhAttrs\n"),"False"), LocRule("synInsComp", Pattern( Var("./GenerateCodeSM.ag(line 740, column 16)","loc.synInsComp")), Expression("./GenerateCodeSM.ag(line 740, column 33)","let mklhs syn = Fun (insertnm @nt (identifier \"comp\") syn) funargs\n synAttrs = Map.keys @syn\n inhsyn = \"_inh2syn_\"\n funargs = [ SimpleExpr \"_syn_\", SimpleExpr inhsyn ]\n mkrhs syn = let rhsbody = Let [decl] letbody\n decl = Decl (Fun syn' [])\n (App inhsyn [SimpleExpr pi])\n letbody = App (insertnm @nt nullIdent syn)\n [ App \"_syn_\"\n [TupleExpr [ SimpleExpr pi\n , SimpleExpr syn'\n ]\n ]\n , SimpleExpr syn'\n ]\n syn' = \"_syn_new\"\n pi = \"_parent_in\"\n in Lambda [pi] rhsbody\nin map (\\s -> Decl (mklhs s) (mkrhs s)) synAttrs\n"),"False"), LocRule("synInsDyns", Pattern( Var("./GenerateCodeSM.ag(line 759, column 17)","loc.synInsDyns")), Expression("./GenerateCodeSM.ag(line 759, column 38)","let synAttrs = zip (Map.keys @syn) (Map.elems @syn)\n ident a = (smsdtype @nt \"\") ++ \"_lhs_\" ++ getName a\n fname a = insertnm @nt (identifier \"comp\") a\n inpArg t = let tp = typeToString @nt t\n in Arr (SimpleType (smsdtype @nt \"input\"))\n (SimpleType tp)\n arg tp = let btp = SimpleType (smsdtype @nt \"\")\n in Arr (inpArg tp) (Arr btp btp)\nin map (\\(s,tp) -> (ident s, (fname s, arg tp))) synAttrs\n"),"False"), LocRule("inhInsDyns", Pattern( Var("./GenerateCodeSM.ag(line 768, column 17)","loc.inhInsDyns")), Expression("./GenerateCodeSM.ag(line 768, column 38)","let inhAttrs = zip (Map.keys @inh) (Map.elems @inh)\n ident a = (smsdtype @nt \"\") ++ \"_inh_\" ++ getName a\n fname a = insertnm @nt (identifier \"comp\") a\n inpArg t = let tp = typeToString @nt t\n in Arr (SimpleType (smsdtype @nt \"input\"))\n (SimpleType tp)\n arg tp = let btp = SimpleType (smsdtype @nt \"\")\n in Arr (inpArg tp) (Arr btp btp)\nin map (\\(s,tp) -> (ident s, (fname s, arg tp))) inhAttrs\n"),"False"), LocRule("smInputDyn", Pattern( Var("./GenerateCodeSM.ag(line 778, column 16)","loc.smInputDyn")), Expression("./GenerateCodeSM.ag(line 778, column 32)","let nm = smsdtype @nt \"\"\n varnm = \"_gen_var_prod_\" ++ map toLower nm\n tpnm = smsdtype @nt \"input\"\n in (nm, (varnm,tpnm))\n"),"False"), LocRule("smSelInsFuns", Pattern( Var("./GenerateCodeSM.ag(line 783, column 16)","loc.smSelInsFuns")), Expression("./GenerateCodeSM.ag(line 783, column 35)","@loc.inhTupSel ++ @loc.synTupSel ++ @loc.synInsComp ++\n@loc.inhInsComp ++ @loc.synIns ++ @loc.inhIns ++ @loc.synSel\n ++ @loc.inhSel ++ @alts.smSelFuns\n"),"False"))))), Production("Productions","{derivings:=Derivings,down:=[UseStream],nts':=[Name],o_cata:=Bool,o_data:=Bool,o_newtypes:=Bool,o_pretty:=Bool,o_rename:=Bool,o_sem:=Bool,o_sig:=Bool,prefix:=String,typeSyns:=TypeSyns,wrappers:=Set Nonterminal}","{decls:=Decls,errors:=Seq Error,nrChildren:=Int,nts:=[Name],smCompDyns:=[(String,(String,[String]))],smConstructors:=[(String,(String,[String]))],smDynSels:=[(String,(String,String,[String]))],smDynSemFuns:=[(String,(String,[String]))],smInputDyns:=[(String,(String,String))],smInsDynsFuns:=[(String, (String,Code.Type))],smPrimTypes:=[String],smSelDynVals:=[(String,(String,[String]))],smTypeCons:=[String],smTypeConsTop:=[String],smdecls:=Decls,up:=[UseStream],vprods:=[VisageProduction]}", Alternatives( Alternative("Cons", Children( Child("hd","Production","{derivings:=Derivings,down:=[UseStream],nts':=[Name],o_cata:=Bool,o_data:=Bool,o_newtypes:=Bool,o_pretty:=Bool,o_rename:=Bool,o_sem:=Bool,o_sig:=Bool,prefix:=String,typeSyns:=TypeSyns,wrappers:=Set Nonterminal}","{decls:=Decls,errors:=Seq Error,nrChildren:=Int,nts:=[Name],smCompDyns:=[(String,(String,[String]))],smConstructors:=[(String,(String,[String]))],smDynSels:=[(String,(String,String,[String]))],smDynSemFuns:=[(String,(String,[String]))],smInputDyns:=[(String,(String,String))],smInsDynsFuns:=[(String, (String,Code.Type))],smPrimTypes:=[String],smSelDynVals:=[(String,(String,[String]))],smTypeCons:=[String],smTypeConsTop:=[String],smdecls:=Decls,up:=[UseStream],vprod:=VisageProduction}", Rules( Rule("derivings", Pattern( Var("./AbstractSyntax.ag(line 17, column 1)","hd.derivings")), Expression("","@lhs.derivings")), Rule("down", Pattern( Var("./AbstractSyntax.ag(line 17, column 1)","hd.down")), Expression("","@lhs.down")), Rule("nts'", Pattern( Var("./AbstractSyntax.ag(line 17, column 1)","hd.nts'")), Expression("","@lhs.nts'")), Rule("o_cata", Pattern( Var("./AbstractSyntax.ag(line 17, column 1)","hd.o_cata")), Expression("","@lhs.o_cata")), Rule("o_data", Pattern( Var("./AbstractSyntax.ag(line 17, column 1)","hd.o_data")), Expression("","@lhs.o_data")), Rule("o_newtypes", Pattern( Var("./AbstractSyntax.ag(line 17, column 1)","hd.o_newtypes")), Expression("","@lhs.o_newtypes")), Rule("o_pretty", Pattern( Var("./AbstractSyntax.ag(line 17, column 1)","hd.o_pretty")), Expression("","@lhs.o_pretty")), Rule("o_rename", Pattern( Var("./AbstractSyntax.ag(line 17, column 1)","hd.o_rename")), Expression("","@lhs.o_rename")), Rule("o_sem", Pattern( Var("./AbstractSyntax.ag(line 17, column 1)","hd.o_sem")), Expression("","@lhs.o_sem")), Rule("o_sig", Pattern( Var("./AbstractSyntax.ag(line 17, column 1)","hd.o_sig")), Expression("","@lhs.o_sig")), Rule("prefix", Pattern( Var("./AbstractSyntax.ag(line 17, column 1)","hd.prefix")), Expression("","@lhs.prefix")), Rule("typeSyns", Pattern( Var("./AbstractSyntax.ag(line 17, column 1)","hd.typeSyns")), Expression("","@lhs.typeSyns")), Rule("wrappers", Pattern( Var("./AbstractSyntax.ag(line 17, column 1)","hd.wrappers")), Expression("","@lhs.wrappers")))), Child("tl","Productions","{derivings:=Derivings,down:=[UseStream],nts':=[Name],o_cata:=Bool,o_data:=Bool,o_newtypes:=Bool,o_pretty:=Bool,o_rename:=Bool,o_sem:=Bool,o_sig:=Bool,prefix:=String,typeSyns:=TypeSyns,wrappers:=Set Nonterminal}","{decls:=Decls,errors:=Seq Error,nrChildren:=Int,nts:=[Name],smCompDyns:=[(String,(String,[String]))],smConstructors:=[(String,(String,[String]))],smDynSels:=[(String,(String,String,[String]))],smDynSemFuns:=[(String,(String,[String]))],smInputDyns:=[(String,(String,String))],smInsDynsFuns:=[(String, (String,Code.Type))],smPrimTypes:=[String],smSelDynVals:=[(String,(String,[String]))],smTypeCons:=[String],smTypeConsTop:=[String],smdecls:=Decls,up:=[UseStream],vprods:=[VisageProduction]}", Rules( Rule("derivings", Pattern( Var("./AbstractSyntax.ag(line 17, column 1)","tl.derivings")), Expression("","@lhs.derivings")), Rule("down", Pattern( Var("./AbstractSyntax.ag(line 17, column 1)","tl.down")), Expression("","@lhs.down")), Rule("nts'", Pattern( Var("./AbstractSyntax.ag(line 17, column 1)","tl.nts'")), Expression("","@lhs.nts'")), Rule("o_cata", Pattern( Var("./AbstractSyntax.ag(line 17, column 1)","tl.o_cata")), Expression("","@lhs.o_cata")), Rule("o_data", Pattern( Var("./AbstractSyntax.ag(line 17, column 1)","tl.o_data")), Expression("","@lhs.o_data")), Rule("o_newtypes", Pattern( Var("./AbstractSyntax.ag(line 17, column 1)","tl.o_newtypes")), Expression("","@lhs.o_newtypes")), Rule("o_pretty", Pattern( Var("./AbstractSyntax.ag(line 17, column 1)","tl.o_pretty")), Expression("","@lhs.o_pretty")), Rule("o_rename", Pattern( Var("./AbstractSyntax.ag(line 17, column 1)","tl.o_rename")), Expression("","@lhs.o_rename")), Rule("o_sem", Pattern( Var("./AbstractSyntax.ag(line 17, column 1)","tl.o_sem")), Expression("","@lhs.o_sem")), Rule("o_sig", Pattern( Var("./AbstractSyntax.ag(line 17, column 1)","tl.o_sig")), Expression("","@lhs.o_sig")), Rule("prefix", Pattern( Var("./AbstractSyntax.ag(line 17, column 1)","tl.prefix")), Expression("","@lhs.prefix")), Rule("typeSyns", Pattern( Var("./AbstractSyntax.ag(line 17, column 1)","tl.typeSyns")), Expression("","@lhs.typeSyns")), Rule("wrappers", Pattern( Var("./AbstractSyntax.ag(line 17, column 1)","tl.wrappers")), Expression("","@lhs.wrappers"))))), Rules( Rule("nrChildren", Pattern( Var("./GenerateCodeSM.ag(line 232, column 10)","lhs.nrChildren")), Expression("./GenerateCodeSM.ag(line 232, column 27)","@hd.nrChildren `max` @tl.nrChildren\n")), Rule("vprods", Pattern( Var("./TfmToVisage.ag(line 84, column 17)","lhs.vprods")), Expression("./TfmToVisage.ag(line 84, column 30)","@hd.vprod : @tl.vprods\n")), Rule("decls", Pattern( Var("","lhs.decls")), Expression("","@hd.decls ++ @tl.decls")), Rule("errors", Pattern( Var("","lhs.errors")), Expression("","@hd.errors Seq.<> @tl.errors")), Rule("nts", Pattern( Var("","lhs.nts")), Expression("","@hd.nts ++ @tl.nts")), Rule("smCompDyns", Pattern( Var("","lhs.smCompDyns")), Expression("","@hd.smCompDyns ++ @tl.smCompDyns")), Rule("smConstructors", Pattern( Var("","lhs.smConstructors")), Expression("","@hd.smConstructors ++ @tl.smConstructors")), Rule("smDynSels", Pattern( Var("","lhs.smDynSels")), Expression("","@hd.smDynSels ++ @tl.smDynSels")), Rule("smDynSemFuns", Pattern( Var("","lhs.smDynSemFuns")), Expression("","@hd.smDynSemFuns ++ @tl.smDynSemFuns")), Rule("smInputDyns", Pattern( Var("","lhs.smInputDyns")), Expression("","@hd.smInputDyns ++ @tl.smInputDyns")), Rule("smInsDynsFuns", Pattern( Var("","lhs.smInsDynsFuns")), Expression("","@hd.smInsDynsFuns ++ @tl.smInsDynsFuns")), Rule("smPrimTypes", Pattern( Var("","lhs.smPrimTypes")), Expression("","@hd.smPrimTypes ++ @tl.smPrimTypes")), Rule("smSelDynVals", Pattern( Var("","lhs.smSelDynVals")), Expression("","@hd.smSelDynVals ++ @tl.smSelDynVals")), Rule("smTypeCons", Pattern( Var("","lhs.smTypeCons")), Expression("","@hd.smTypeCons ++ @tl.smTypeCons")), Rule("smTypeConsTop", Pattern( Var("","lhs.smTypeConsTop")), Expression("","@hd.smTypeConsTop ++ @tl.smTypeConsTop")), Rule("smdecls", Pattern( Var("","lhs.smdecls")), Expression("","@hd.smdecls ++ @tl.smdecls")), Rule("up", Pattern( Var("","lhs.up")), Expression("","@hd.up ++ @tl.up"))), LocRules()), Alternative("Nil", Children(), Rules( Rule("nrChildren", Pattern( Var("./GenerateCodeSM.ag(line 233, column 10)","lhs.nrChildren")), Expression("./GenerateCodeSM.ag(line 233, column 27)","0\n")), Rule("vprods", Pattern( Var("./TfmToVisage.ag(line 85, column 17)","lhs.vprods")), Expression("./TfmToVisage.ag(line 85, column 30)","[]\n")), Rule("decls", Pattern( Var("","lhs.decls")), Expression("","[]")), Rule("errors", Pattern( Var("","lhs.errors")), Expression("","Seq.empty")), Rule("nts", Pattern( Var("","lhs.nts")), Expression("","[]")), Rule("smCompDyns", Pattern( Var("","lhs.smCompDyns")), Expression("","[]")), Rule("smConstructors", Pattern( Var("","lhs.smConstructors")), Expression("","[]")), Rule("smDynSels", Pattern( Var("","lhs.smDynSels")), Expression("","[]")), Rule("smDynSemFuns", Pattern( Var("","lhs.smDynSemFuns")), Expression("","[]")), Rule("smInputDyns", Pattern( Var("","lhs.smInputDyns")), Expression("","[]")), Rule("smInsDynsFuns", Pattern( Var("","lhs.smInsDynsFuns")), Expression("","[]")), Rule("smPrimTypes", Pattern( Var("","lhs.smPrimTypes")), Expression("","[]")), Rule("smSelDynVals", Pattern( Var("","lhs.smSelDynVals")), Expression("","[]")), Rule("smTypeCons", Pattern( Var("","lhs.smTypeCons")), Expression("","[]")), Rule("smTypeConsTop", Pattern( Var("","lhs.smTypeConsTop")), Expression("","[]")), Rule("smdecls", Pattern( Var("","lhs.smdecls")), Expression("","[]")), Rule("up", Pattern( Var("","lhs.up")), Expression("","[]"))), LocRules()))), Production("Rule","{attrs:=[(Name,Name)],con:=Identifier,down:=[UseStream],fieldnames:=[Name],fields:=[(Name,Type)],nt:=Identifier,o_pretty:=Bool}","{decl:=Decls,decls':=Decls,errors:=Seq Error,locVars:=[Name],self:=SELF,up:=[UseStream],vrule:=VisageRule}", Alternatives( Alternative("Rule", Children( Child("pattern","Pattern","{con:=Identifier,fields:=[(Name,Type)],nt:=Identifier}","{errors:=Seq Error,fieldattrs:= [(Name,Name)] ,locVars:=[Name],pp:=PP_Doc,pp':=PP_Doc,self:=SELF,vertices:=[Vertex],vpat:=VisagePattern}", Rules( Rule("con", Pattern( Var("./AbstractSyntax.ag(line 40, column 29)","pattern.con")), Expression("","@lhs.con")), Rule("fields", Pattern( Var("./AbstractSyntax.ag(line 40, column 29)","pattern.fields")), Expression("","@lhs.fields")), Rule("nt", Pattern( Var("./AbstractSyntax.ag(line 40, column 29)","pattern.nt")), Expression("","@lhs.nt")))), Child("rhs","Expression","{attrs:=[(Name,Name)],con:=Name,fieldnames:=[Name],nt:=Name}","{errors:=Seq Error,pos:=Pos,pp:=PP_Doc,self:=SELF,usedAttrs:=[(Name,Name)],usedLocals:=[Name],vexpression:=Expression}", Rules( Rule("attrs", Pattern( Var("./AbstractSyntax.ag(line 41, column 29)","rhs.attrs")), Expression("","@lhs.attrs")), Rule("con", Pattern( Var("./AbstractSyntax.ag(line 41, column 29)","rhs.con")), Expression("","@lhs.con")), Rule("fieldnames", Pattern( Var("./AbstractSyntax.ag(line 41, column 29)","rhs.fieldnames")), Expression("","@lhs.fieldnames")), Rule("nt", Pattern( Var("./AbstractSyntax.ag(line 41, column 29)","rhs.nt")), Expression("","@lhs.nt")))), Child("owrt","Bool","{}","{}", Rules()), Child("origin","String","{}","{}", Rules())), Rules( Rule("decl", Pattern( Var("GenerateCode.ag(line 333, column 10)","lhs.decl")), Expression("GenerateCode.ag(line 333, column 22)","(if @lhs.o_pretty then (Comment @origin:) else id)\n [Decl (Pattern @pattern.pp) (PP @rhs.pp)]\n")), Rule("decls'", Pattern( Var("./GenerateCodeSM.ag(line 398, column 10)","lhs.decls'")), Expression("./GenerateCodeSM.ag(line 398, column 24)","(if @lhs.o_pretty then (Comment @origin:) else id)\n [Decl (Pattern @pattern.pp') (PP @rhs.pp)]\n")), Rule("vrule", Pattern( Var("./TfmToVisage.ag(line 113, column 11)","lhs.vrule")), Expression("./TfmToVisage.ag(line 113, column 24)","VRule @pattern.fieldattrs @pattern.vpat @rhs.self @owrt @self\n")), Rule("errors", Pattern( Var("","lhs.errors")), Expression("","@pattern.errors Seq.<> @rhs.errors")), Rule("locVars", Pattern( Var("","lhs.locVars")), Expression("","@pattern.locVars")), Rule("self", Pattern( Var("","lhs.self")), Expression("","@self")), Rule("up", Pattern( Var("","lhs.up")), Expression("","@up"))), LocRules( LocRule("_tup2", Pattern( Var("","loc._tup2")), Expression("./Dep.ag(line 135, column 47)","let (locs,rest) = partition (\\(fld,attr) -> fld==_LOC) @rhs.usedAttrs\nin (map snd locs, partition (\\(fld,attr) -> fld==_LHS) rest)\n"),"False"), LocRule("locAttrs", Pattern( Product("./Dep.ag(line 135, column 14)", Patterns( Pattern( Var("./Dep.ag(line 135, column 10)","loc.locAttrs")), Pattern( Underscore("./Dep.ag(line 135, column 14)"))))), Expression("./Dep.ag(line 135, column 14)","@_tup2"),"False"), LocRule("_tup3", Pattern( Product("./Dep.ag(line 135, column 14)", Patterns( Pattern( Underscore("./Dep.ag(line 135, column 14)")), Pattern( Var("","loc._tup3"))))), Expression("./Dep.ag(line 135, column 14)","@_tup2"),"False"), LocRule("inAttrs", Pattern( Product("./Dep.ag(line 135, column 25)", Patterns( Pattern( Var("./Dep.ag(line 135, column 10)","loc.inAttrs")), Pattern( Underscore("./Dep.ag(line 135, column 25)"))))), Expression("./Dep.ag(line 135, column 25)","@_tup3"),"False"), LocRule("outAttrs", Pattern( Product("./Dep.ag(line 135, column 25)", Patterns( Pattern( Underscore("./Dep.ag(line 135, column 25)")), Pattern( Var("./Dep.ag(line 135, column 10)","loc.outAttrs"))))), Expression("./Dep.ag(line 135, column 25)","@_tup3"),"False"), LocRule("usedLocals", Pattern( Var("./Dep.ag(line 135, column 10)","loc.usedLocals")), Expression("./Dep.ag(line 137, column 38)","map (\\attr -> Local @lhs.nt @lhs.con attr) (@locAttrs ++ @rhs.usedLocals)\n"),"False"), LocRule("usedOutAttrs", Pattern( Var("./Dep.ag(line 135, column 10)","loc.usedOutAttrs")), Expression("./Dep.ag(line 138, column 38)","map (\\(fld,attr) -> ShRHSSyn @lhs.nt @lhs.con fld attr) @outAttrs\n"),"False"), LocRule("usedInAttrs", Pattern( Var("./Dep.ag(line 135, column 10)","loc.usedInAttrs")), Expression("./Dep.ag(line 139, column 38)","map (\\(fld,attr) -> LHSInh @lhs.nt @lhs.con attr) @inAttrs\n"),"False"), LocRule("up", Pattern( Var("./Dep.ag(line 135, column 10)","loc.up")), Expression("./Dep.ag(line 140, column 38)","[ let (nt2,field)= case vertex of\n Local _ _ _ -> (nullIdent,nullIdent)\n LHSSyn nt _ _ -> (nt ,_LHS)\n RHSInh nt _ _ f _ -> (nt ,f)\n rhsstreams = [ addTraceElem\n (TE { lineNr = line @rhs.pos\n , nt = @lhs.nt\n , prod = @lhs.con\n , lhsNt = nt2\n , lhsFld = field\n , lhsAttr = getAttr vertex\n , rhsFld = getField usedVertex\n , rhsAttr = getAttr usedVertex\n }\n )\n (getStream usedVertex @lhs.down)\n | usedVertex <- (@usedLocals ++ @usedOutAttrs ++ @usedInAttrs)\n ]\n in (vertex,([],[]) : (foldr stUnion stEmpty rhsstreams))\n| vertex <- (@pattern.vertices)\n]\n"),"False"), LocRule("self", Pattern( Var("","loc.self")), Expression("","Rule @pattern.self @rhs.self @owrt @origin"),"False"))))), Production("Rules","{attrs:=[(Name,Name)],con:=Identifier,down:=[UseStream],fieldnames:=[Name],fields:=[(Name,Type)],nt:=Identifier,o_pretty:=Bool}","{decls:=Decls,decls':=Decls,errors:=Seq Error,locVars:=[Name],up:=[UseStream],vrules:=[VisageRule]}", Alternatives( Alternative("Cons", Children( Child("hd","Rule","{attrs:=[(Name,Name)],con:=Identifier,down:=[UseStream],fieldnames:=[Name],fields:=[(Name,Type)],nt:=Identifier,o_pretty:=Bool}","{decl:=Decls,decls':=Decls,errors:=Seq Error,locVars:=[Name],self:=SELF,up:=[UseStream],vrule:=VisageRule}", Rules( Rule("attrs", Pattern( Var("./AbstractSyntax.ag(line 23, column 1)","hd.attrs")), Expression("","@lhs.attrs")), Rule("con", Pattern( Var("./AbstractSyntax.ag(line 23, column 1)","hd.con")), Expression("","@lhs.con")), Rule("down", Pattern( Var("./AbstractSyntax.ag(line 23, column 1)","hd.down")), Expression("","@lhs.down")), Rule("fieldnames", Pattern( Var("./AbstractSyntax.ag(line 23, column 1)","hd.fieldnames")), Expression("","@lhs.fieldnames")), Rule("fields", Pattern( Var("./AbstractSyntax.ag(line 23, column 1)","hd.fields")), Expression("","@lhs.fields")), Rule("nt", Pattern( Var("./AbstractSyntax.ag(line 23, column 1)","hd.nt")), Expression("","@lhs.nt")), Rule("o_pretty", Pattern( Var("./AbstractSyntax.ag(line 23, column 1)","hd.o_pretty")), Expression("","@lhs.o_pretty")))), Child("tl","Rules","{attrs:=[(Name,Name)],con:=Identifier,down:=[UseStream],fieldnames:=[Name],fields:=[(Name,Type)],nt:=Identifier,o_pretty:=Bool}","{decls:=Decls,decls':=Decls,errors:=Seq Error,locVars:=[Name],up:=[UseStream],vrules:=[VisageRule]}", Rules( Rule("attrs", Pattern( Var("./AbstractSyntax.ag(line 23, column 1)","tl.attrs")), Expression("","@lhs.attrs")), Rule("con", Pattern( Var("./AbstractSyntax.ag(line 23, column 1)","tl.con")), Expression("","@lhs.con")), Rule("down", Pattern( Var("./AbstractSyntax.ag(line 23, column 1)","tl.down")), Expression("","@lhs.down")), Rule("fieldnames", Pattern( Var("./AbstractSyntax.ag(line 23, column 1)","tl.fieldnames")), Expression("","@lhs.fieldnames")), Rule("fields", Pattern( Var("./AbstractSyntax.ag(line 23, column 1)","tl.fields")), Expression("","@lhs.fields")), Rule("nt", Pattern( Var("./AbstractSyntax.ag(line 23, column 1)","tl.nt")), Expression("","@lhs.nt")), Rule("o_pretty", Pattern( Var("./AbstractSyntax.ag(line 23, column 1)","tl.o_pretty")), Expression("","@lhs.o_pretty"))))), Rules( Rule("decls", Pattern( Var("GenerateCode.ag(line 329, column 10)","lhs.decls")), Expression("GenerateCode.ag(line 329, column 22)","@hd.decl ++ @tl.decls\n")), Rule("vrules", Pattern( Var("./TfmToVisage.ag(line 109, column 17)","lhs.vrules")), Expression("./TfmToVisage.ag(line 109, column 30)","@hd.vrule : @tl.vrules\n")), Rule("decls'", Pattern( Var("","lhs.decls'")), Expression("","@hd.decls' ++ @tl.decls'")), Rule("errors", Pattern( Var("","lhs.errors")), Expression("","@hd.errors Seq.<> @tl.errors")), Rule("locVars", Pattern( Var("","lhs.locVars")), Expression("","@hd.locVars ++ @tl.locVars")), Rule("up", Pattern( Var("","lhs.up")), Expression("","@hd.up ++ @tl.up"))), LocRules()), Alternative("Nil", Children(), Rules( Rule("decls", Pattern( Var("GenerateCode.ag(line 330, column 10)","lhs.decls")), Expression("GenerateCode.ag(line 330, column 22)","[]\n")), Rule("vrules", Pattern( Var("./TfmToVisage.ag(line 110, column 17)","lhs.vrules")), Expression("./TfmToVisage.ag(line 110, column 30)","[]\n")), Rule("decls'", Pattern( Var("","lhs.decls'")), Expression("","[]")), Rule("errors", Pattern( Var("","lhs.errors")), Expression("","Seq.empty")), Rule("locVars", Pattern( Var("","lhs.locVars")), Expression("","[]")), Rule("up", Pattern( Var("","lhs.up")), Expression("","[]"))), LocRules()))), Production("VisageAlternative","{}","{}", Alternatives( Alternative("VAlternative", Children( Child("con","Constructor","{}","{}", Rules()), Child("children","VisageChildren","{}","{}", Rules()), Child("rules","VisageRules","{}","{}", Rules()), Child("locrules","VisageRules","{}","{}", Rules())), Rules(), LocRules()))), Production("VisageAlternatives","{}","{}", Alternatives( Alternative("Cons", Children( Child("hd","VisageAlternative","{}","{}", Rules()), Child("tl","VisageAlternatives","{}","{}", Rules())), Rules(), LocRules()), Alternative("Nil", Children(), Rules(), LocRules()))), Production("VisageChild","{}","{}", Alternatives( Alternative("VChild", Children( Child("name","Name","{}","{}", Rules()), Child("tp","Type","{}","{}", Rules()), Child("inh","Attributes","{}","{}", Rules()), Child("syn","Attributes","{}","{}", Rules()), Child("rules","VisageRules","{}","{}", Rules())), Rules(), LocRules()))), Production("VisageChildren","{}","{}", Alternatives( Alternative("Cons", Children( Child("hd","VisageChild","{}","{}", Rules()), Child("tl","VisageChildren","{}","{}", Rules())), Rules(), LocRules()), Alternative("Nil", Children(), Rules(), LocRules()))), Production("VisageGrammar","{}","{}", Alternatives( Alternative("VGrammar", Children( Child("prods","VisageProductions","{}","{}", Rules())), Rules(), LocRules()))), Production("VisagePattern","{}","{}", Alternatives( Alternative("VAlias", Children( Child("field","Name","{}","{}", Rules()), Child("attr","Name","{}","{}", Rules()), Child("pat","VisagePattern","{}","{}", Rules())), Rules(), LocRules()), Alternative("VConstr", Children( Child("name","Constructor","{}","{}", Rules()), Child("pats","VisagePatterns","{}","{}", Rules())), Rules(), LocRules()), Alternative("VProduct", Children( Child("pos","Pos","{}","{}", Rules()), Child("pats","VisagePatterns","{}","{}", Rules())), Rules(), LocRules()), Alternative("VUnderscore", Children( Child("pos","Pos","{}","{}", Rules())), Rules(), LocRules()), Alternative("VVar", Children( Child("field","Name","{}","{}", Rules()), Child("attr","Name","{}","{}", Rules())), Rules(), LocRules()))), Production("VisagePatterns","{}","{}", Alternatives( Alternative("Cons", Children( Child("hd","VisagePattern","{}","{}", Rules()), Child("tl","VisagePatterns","{}","{}", Rules())), Rules(), LocRules()), Alternative("Nil", Children(), Rules(), LocRules()))), Production("VisageProduction","{}","{}", Alternatives( Alternative("VProduction", Children( Child("nt","Nonterminal","{}","{}", Rules()), Child("inh","Attributes","{}","{}", Rules()), Child("syn","Attributes","{}","{}", Rules()), Child("alts","VisageAlternatives","{}","{}", Rules())), Rules(), LocRules()))), Production("VisageProductions","{}","{}", Alternatives( Alternative("Cons", Children( Child("hd","VisageProduction","{}","{}", Rules()), Child("tl","VisageProductions","{}","{}", Rules())), Rules(), LocRules()), Alternative("Nil", Children(), Rules(), LocRules()))), Production("VisageRule","{}","{}", Alternatives( Alternative("VRule", Children( Child("fieldattrs","[(Name,Name)]","{}","{}", Rules()), Child("pat","VisagePattern","{}","{}", Rules()), Child("rhs","Expression","{attrs:=[(Name,Name)],con:=Name,fieldnames:=[Name],nt:=Name}","{errors:=Seq Error,pos:=Pos,pp:=PP_Doc,self:=SELF,usedAttrs:=[(Name,Name)],usedLocals:=[Name],vexpression:=Expression}", Rules( Rule("attrs", Pattern( Var("./VisageSyntax.ag(line 42, column 36)","rhs.attrs")), Expression("","error \"missing rule: VisageRule.VRule.rhs.attrs\"")), Rule("con", Pattern( Var("./VisageSyntax.ag(line 42, column 36)","rhs.con")), Expression("","error \"missing rule: VisageRule.VRule.rhs.con\"")), Rule("fieldnames", Pattern( Var("./VisageSyntax.ag(line 42, column 36)","rhs.fieldnames")), Expression("","error \"missing rule: VisageRule.VRule.rhs.fieldnames\"")), Rule("nt", Pattern( Var("./VisageSyntax.ag(line 42, column 36)","rhs.nt")), Expression("","error \"missing rule: VisageRule.VRule.rhs.nt\"")))), Child("owrt","Bool","{}","{}", Rules()), Child("rule","Rule","{attrs:=[(Name,Name)],con:=Identifier,down:=[UseStream],fieldnames:=[Name],fields:=[(Name,Type)],nt:=Identifier,o_pretty:=Bool}","{decl:=Decls,decls':=Decls,errors:=Seq Error,locVars:=[Name],self:=SELF,up:=[UseStream],vrule:=VisageRule}", Rules( Rule("attrs", Pattern( Var("./VisageSyntax.ag(line 44, column 36)","rule.attrs")), Expression("","error \"missing rule: VisageRule.VRule.rule.attrs\"")), Rule("con", Pattern( Var("./VisageSyntax.ag(line 44, column 36)","rule.con")), Expression("","error \"missing rule: VisageRule.VRule.rule.con\"")), Rule("down", Pattern( Var("./VisageSyntax.ag(line 44, column 36)","rule.down")), Expression("","error \"missing rule: VisageRule.VRule.rule.down\"")), Rule("fieldnames", Pattern( Var("./VisageSyntax.ag(line 44, column 36)","rule.fieldnames")), Expression("","error \"missing rule: VisageRule.VRule.rule.fieldnames\"")), Rule("fields", Pattern( Var("./VisageSyntax.ag(line 44, column 36)","rule.fields")), Expression("","error \"missing rule: VisageRule.VRule.rule.fields\"")), Rule("nt", Pattern( Var("./VisageSyntax.ag(line 44, column 36)","rule.nt")), Expression("","error \"missing rule: VisageRule.VRule.rule.nt\"")), Rule("o_pretty", Pattern( Var("./VisageSyntax.ag(line 44, column 36)","rule.o_pretty")), Expression("","error \"missing rule: VisageRule.VRule.rule.o_pretty\""))))), Rules(), LocRules()))), Production("VisageRules","{}","{}", Alternatives( Alternative("Cons", Children( Child("hd","VisageRule","{}","{}", Rules()), Child("tl","VisageRules","{}","{}", Rules())), Rules(), LocRules()), Alternative("Nil", Children(), Rules(), LocRules()))))