addfile ./changelog addfile ./dependency.patch addfile ./series hunk ./changelog 1 +happy (1) unstable; urgency=low + + * Modify the package's build dependency on itself so that if happy + isn't available the ghc6 package can be substituted. This doesn't + actually work, but if you drop a happy binary into /usr/bin it will. + The actual reason happy is required for this build is because the + Cabal libraries use it, and since they are now part of GHC that means + that GHC should have a (non-build) dependency on happy. + + -- David Fox Tue, 06 May 2008 11:34:46 -0700 hunk ./dependency.patch 1 +--- happy/debian/control 2008-05-05 10:48:08.000000000 -0700 ++++ happy/debian/control 2008-05-07 09:29:31.000000000 -0700 +@@ -3,7 +3,7 @@ + Priority: optional + Maintainer: Ian Lynagh (wibble) + Standards-Version: 3.7.3 +-Build-Depends: debhelper (>= 4), docbook-utils, ghc6 (>= 6.8.2), docbook-xsl, docbook-xml, xsltproc, happy, libghc6-mtl-dev ++Build-Depends: debhelper (>= 4), docbook-utils, ghc6 (>= 6.8.2), docbook-xsl, docbook-xml, xsltproc, libghc6-mtl-dev + Homepage: http://www.haskell.org/happy + + Package: happy hunk ./series 1 +dependency.patch hunk ./changelog 1 +happy (2) unstable; urgency=low + + * Modify Setup.lhs to save the two bootstrap haskell sourcefiles + shipped in dist, otherwise they get removed on clean and the + second build (profiling?) fails. + + -- David Fox Thu, 18 Aug 2011 17:10:24 -0700 + hunk ./dependency.patch 1 ---- happy/debian/control 2008-05-05 10:48:08.000000000 -0700 -+++ happy/debian/control 2008-05-07 09:29:31.000000000 -0700 -@@ -3,7 +3,7 @@ - Priority: optional - Maintainer: Ian Lynagh (wibble) - Standards-Version: 3.7.3 --Build-Depends: debhelper (>= 4), docbook-utils, ghc6 (>= 6.8.2), docbook-xsl, docbook-xml, xsltproc, happy, libghc6-mtl-dev -+Build-Depends: debhelper (>= 4), docbook-utils, ghc6 (>= 6.8.2), docbook-xsl, docbook-xml, xsltproc, libghc6-mtl-dev - Homepage: http://www.haskell.org/happy - - Package: happy rmfile ./dependency.patch addfile ./notsoclean.diff hunk ./notsoclean.diff 1 +--- happy/Setup.lhs.orig 2011-08-18 16:49:35.303654270 -0700 ++++ happy/Setup.lhs 2011-08-18 17:01:46.554299025 -0700 +@@ -11,10 +11,11 @@ + + import System.FilePath (()) + import System.IO.Error ( try ) +-import System.Directory (removeFile) ++import System.Directory (removeFile, createDirectoryIfMissing) + + main :: IO () + main = defaultMainWithHooks defaultUserHooks{ hookedPrograms = [perlProgram], ++ postConf = myPostConf, + postBuild = myPostBuild, + postClean = myPostClean, + copyHook = myCopy, +@@ -27,6 +28,18 @@ + crazy_perl_regexp = + "s/^#\\s+(\\d+)\\s+(\"[^\"]*\")/{-# LINE \\1 \\2 #-}/g;s/\\$(Id:.*)\\$/\\1/g" + ++saveBootstrap = ++ createDirectoryIfMissing True "tmp" >> ++ readFile "dist-ghc/build/happy/happy-tmp/AttrGrammarParser.hs" >>= writeFile "tmp/AttrGrammarParser.hs" >> ++ readFile "dist-ghc/build/happy/happy-tmp/Parser.hs" >>= writeFile "tmp/Parser.hs" ++ ++restoreBootstrap = ++ createDirectoryIfMissing True "dist-ghc/build/happy/happy-tmp" >> ++ writeFile "dist-ghc/build/happy/happy-tmp/AttrGrammarParser.hs" attrGrammarParserHs >> ++ writeFile "dist-ghc/build/happy/happy-tmp/Parser.hs" parserHs ++ ++myPostConf _ _ _ _ = restoreBootstrap ++ + myPostBuild _ flags _ lbi = do + let runProgram p = rawSystemProgramConf (buildVerbose flags) p (withPrograms lbi) + cpp_template src dst opts = do +@@ -37,7 +50,7 @@ + [ cpp_template "GLR_Base.hs" ("out/" ++ dst) opts | (dst,opts) <- glr_base_templates ] ++ + [ cpp_template "GLR_Lib.hs" ("out/" ++ dst) opts | (dst,opts) <- glr_templates ]) + +-myPostClean _ _ _ _ = mapM_ (try . removeFile) all_template_files ++myPostClean _ _ _ _ = mapM_ (try . removeFile) all_template_files >> restoreBootstrap + + myInstall pkg_descr lbi hooks flags = + instHook defaultUserHooks pkg_descr' lbi hooks flags +@@ -79,4 +92,1589 @@ + ("GLR_Lib-ghc-debug" , ["-DHAPPY_GHC", "-DHAPPY_DEBUG"]) + ] + ++attrGrammarParserHs = ++ unlines ++ [ "{-# OPTIONS_GHC -w #-}" ++ , "{-# OPTIONS -fglasgow-exts -cpp #-}" ++ , "{-# OPTIONS_GHC -w #-}" ++ , "module AttrGrammarParser (agParser) where" ++ , "import ParseMonad" ++ , "import AttrGrammar" ++ , "import qualified Data.Array as Happy_Data_Array" ++ , "import qualified GHC.Exts as Happy_GHC_Exts" ++ , "" ++ , "-- parser produced by Happy Version 1.18.6" ++ , "" ++ , "newtype HappyAbsSyn = HappyAbsSyn HappyAny" ++ , "#if __GLASGOW_HASKELL__ >= 607" ++ , "type HappyAny = Happy_GHC_Exts.Any" ++ , "#else" ++ , "type HappyAny = forall a . a" ++ , "#endif" ++ , "happyIn4 :: ([AgRule]) -> (HappyAbsSyn )" ++ , "happyIn4 x = Happy_GHC_Exts.unsafeCoerce# x" ++ , "{-# INLINE happyIn4 #-}" ++ , "happyOut4 :: (HappyAbsSyn ) -> ([AgRule])" ++ , "happyOut4 x = Happy_GHC_Exts.unsafeCoerce# x" ++ , "{-# INLINE happyOut4 #-}" ++ , "happyIn5 :: ([AgRule]) -> (HappyAbsSyn )" ++ , "happyIn5 x = Happy_GHC_Exts.unsafeCoerce# x" ++ , "{-# INLINE happyIn5 #-}" ++ , "happyOut5 :: (HappyAbsSyn ) -> ([AgRule])" ++ , "happyOut5 x = Happy_GHC_Exts.unsafeCoerce# x" ++ , "{-# INLINE happyOut5 #-}" ++ , "happyIn6 :: (AgRule) -> (HappyAbsSyn )" ++ , "happyIn6 x = Happy_GHC_Exts.unsafeCoerce# x" ++ , "{-# INLINE happyIn6 #-}" ++ , "happyOut6 :: (HappyAbsSyn ) -> (AgRule)" ++ , "happyOut6 x = Happy_GHC_Exts.unsafeCoerce# x" ++ , "{-# INLINE happyOut6 #-}" ++ , "happyIn7 :: ([AgToken]) -> (HappyAbsSyn )" ++ , "happyIn7 x = Happy_GHC_Exts.unsafeCoerce# x" ++ , "{-# INLINE happyIn7 #-}" ++ , "happyOut7 :: (HappyAbsSyn ) -> ([AgToken])" ++ , "happyOut7 x = Happy_GHC_Exts.unsafeCoerce# x" ++ , "{-# INLINE happyOut7 #-}" ++ , "happyIn8 :: ([AgToken]) -> (HappyAbsSyn )" ++ , "happyIn8 x = Happy_GHC_Exts.unsafeCoerce# x" ++ , "{-# INLINE happyIn8 #-}" ++ , "happyOut8 :: (HappyAbsSyn ) -> ([AgToken])" ++ , "happyOut8 x = Happy_GHC_Exts.unsafeCoerce# x" ++ , "{-# INLINE happyOut8 #-}" ++ , "happyInTok :: (AgToken) -> (HappyAbsSyn )" ++ , "happyInTok x = Happy_GHC_Exts.unsafeCoerce# x" ++ , "{-# INLINE happyInTok #-}" ++ , "happyOutTok :: (HappyAbsSyn ) -> (AgToken)" ++ , "happyOutTok x = Happy_GHC_Exts.unsafeCoerce# x" ++ , "{-# INLINE happyOutTok #-}" ++ , "" ++ , "" ++ , "happyActOffsets :: HappyAddr" ++ , "happyActOffsets = HappyA# \"\\x0f\\x00\\x0f\\x00\\x00\\x00\\x30\\x00\\x0a\\x00\\x2e\\x00\\x2d\\x00\\x2b\\x00\\x14\\x00\\x0a\\x00\\x0a\\x00\\x0a\\x00\\x00\\x00\\x01\\x00\\x0a\\x00\\x0a\\x00\\x0a\\x00\\x0a\\x00\\x0a\\x00\\x0f\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x2c\\x00\\x01\\x00\\x01\\x00\\x01\\x00\\x01\\x00\\x01\\x00\\x0a\\x00\\x01\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x26\\x00\\x0a\\x00\\x00\\x00\\x01\\x00\\x00\\x00\\x00\\x00\"#" ++ , "" ++ , "happyGotoOffsets :: HappyAddr" ++ , "happyGotoOffsets = HappyA# \"\\x18\\x00\\x1a\\x00\\x00\\x00\\x00\\x00\\x2a\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x29\\x00\\x28\\x00\\x27\\x00\\x00\\x00\\x25\\x00\\x24\\x00\\x23\\x00\\x22\\x00\\x21\\x00\\x20\\x00\\x0b\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x1e\\x00\\x1d\\x00\\x1c\\x00\\x1b\\x00\\x19\\x00\\x0c\\x00\\xff\\xff\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x03\\x00\\x00\\x00\\xfd\\xff\\x00\\x00\\x00\\x00\"#" ++ , "" ++ , "happyDefActions :: HappyAddr" ++ , "happyDefActions = HappyA# \"\\xfb\\xff\\x00\\x00\\xfe\\xff\\xfc\\xff\\xf0\\xff\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\xf0\\xff\\xf0\\xff\\xf0\\xff\\xf7\\xff\\xe8\\xff\\xf0\\xff\\xf0\\xff\\xf0\\xff\\xf0\\xff\\xf0\\xff\\xfb\\xff\\xfd\\xff\\xf1\\xff\\xf2\\xff\\xf3\\xff\\xf4\\xff\\xf5\\xff\\x00\\x00\\xe8\\xff\\xe8\\xff\\xe8\\xff\\xe8\\xff\\xe8\\xff\\xf0\\xff\\xe8\\xff\\xfa\\xff\\xf9\\xff\\xf8\\xff\\xe9\\xff\\xea\\xff\\xeb\\xff\\xec\\xff\\xee\\xff\\xed\\xff\\x00\\x00\\xf0\\xff\\xf6\\xff\\xe8\\xff\\xef\\xff\"#" ++ , "" ++ , "happyCheck :: HappyAddr" ++ , "happyCheck = HappyA# \"\\xff\\xff\\x04\\x00\\x01\\x00\\x04\\x00\\x03\\x00\\x04\\x00\\x03\\x00\\x06\\x00\\x07\\x00\\x08\\x00\\x09\\x00\\x01\\x00\\x01\\x00\\x02\\x00\\x04\\x00\\x03\\x00\\x06\\x00\\x07\\x00\\x08\\x00\\x09\\x00\\x05\\x00\\x06\\x00\\x07\\x00\\x08\\x00\\x00\\x00\\x01\\x00\\x02\\x00\\x01\\x00\\x02\\x00\\x04\\x00\\x0a\\x00\\x04\\x00\\x04\\x00\\x04\\x00\\x04\\x00\\x03\\x00\\x03\\x00\\x03\\x00\\x03\\x00\\x03\\x00\\x02\\x00\\x04\\x00\\x03\\x00\\x03\\x00\\x03\\x00\\x03\\x00\\x02\\x00\\x04\\x00\\xff\\xff\\x04\\x00\\x04\\x00\\x03\\x00\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\"#" ++ , "" ++ , "happyTable :: HappyAddr" ++ , "happyTable = HappyA# \"\\x00\\x00\\x2f\\x00\\x1c\\x00\\x25\\x00\\x1d\\x00\\x1e\\x00\\x2d\\x00\\x1f\\x00\\x20\\x00\\x21\\x00\\x22\\x00\\x0e\\x00\\x14\\x00\\x03\\x00\\x0f\\x00\\x26\\x00\\x10\\x00\\x11\\x00\\x12\\x00\\x13\\x00\\x05\\x00\\x06\\x00\\x07\\x00\\x08\\x00\\x08\\x00\\x02\\x00\\x03\\x00\\x02\\x00\\x03\\x00\\x27\\x00\\xff\\xff\\x28\\x00\\x29\\x00\\x2a\\x00\\x2b\\x00\\x15\\x00\\x16\\x00\\x17\\x00\\x18\\x00\\x19\\x00\\x2f\\x00\\x1a\\x00\\x22\\x00\\x23\\x00\\x24\\x00\\x0c\\x00\\x2d\\x00\\x0a\\x00\\x00\\x00\\x0b\\x00\\x0c\\x00\\x14\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\"#" ++ , "" ++ , "happyReduceArr = Happy_Data_Array.array (1, 23) [" ++ , "\t(1 , happyReduce_1)," ++ , "\t(2 , happyReduce_2)," ++ , "\t(3 , happyReduce_3)," ++ , "\t(4 , happyReduce_4)," ++ , "\t(5 , happyReduce_5)," ++ , "\t(6 , happyReduce_6)," ++ , "\t(7 , happyReduce_7)," ++ , "\t(8 , happyReduce_8)," ++ , "\t(9 , happyReduce_9)," ++ , "\t(10 , happyReduce_10)," ++ , "\t(11 , happyReduce_11)," ++ , "\t(12 , happyReduce_12)," ++ , "\t(13 , happyReduce_13)," ++ , "\t(14 , happyReduce_14)," ++ , "\t(15 , happyReduce_15)," ++ , "\t(16 , happyReduce_16)," ++ , "\t(17 , happyReduce_17)," ++ , "\t(18 , happyReduce_18)," ++ , "\t(19 , happyReduce_19)," ++ , "\t(20 , happyReduce_20)," ++ , "\t(21 , happyReduce_21)," ++ , "\t(22 , happyReduce_22)," ++ , "\t(23 , happyReduce_23)" ++ , "\t]" ++ , "" ++ , "happy_n_terms = 11 :: Int" ++ , "happy_n_nonterms = 5 :: Int" ++ , "" ++ , "happyReduce_1 = happySpecReduce_1 0# happyReduction_1" ++ , "happyReduction_1 happy_x_1" ++ , "\t = case happyOut5 happy_x_1 of { happy_var_1 -> " ++ , "\thappyIn4" ++ , "\t\t (happy_var_1" ++ , "\t)}" ++ , "" ++ , "happyReduce_2 = happySpecReduce_3 1# happyReduction_2" ++ , "happyReduction_2 happy_x_3" ++ , "\thappy_x_2" ++ , "\thappy_x_1" ++ , "\t = case happyOut6 happy_x_1 of { happy_var_1 -> " ++ , "\tcase happyOut5 happy_x_3 of { happy_var_3 -> " ++ , "\thappyIn5" ++ , "\t\t (happy_var_1 : happy_var_3" ++ , "\t)}}" ++ , "" ++ , "happyReduce_3 = happySpecReduce_1 1# happyReduction_3" ++ , "happyReduction_3 happy_x_1" ++ , "\t = case happyOut6 happy_x_1 of { happy_var_1 -> " ++ , "\thappyIn5" ++ , "\t\t (happy_var_1 : []" ++ , "\t)}" ++ , "" ++ , "happyReduce_4 = happySpecReduce_0 1# happyReduction_4" ++ , "happyReduction_4 = happyIn5" ++ , "\t\t ([]" ++ , "\t)" ++ , "" ++ , "happyReduce_5 = happySpecReduce_3 2# happyReduction_5" ++ , "happyReduction_5 happy_x_3" ++ , "\thappy_x_2" ++ , "\thappy_x_1" ++ , "\t = case happyOutTok happy_x_1 of { happy_var_1 -> " ++ , "\tcase happyOut7 happy_x_3 of { happy_var_3 -> " ++ , "\thappyIn6" ++ , "\t\t (SelfAssign (selfRefVal happy_var_1) happy_var_3" ++ , "\t)}}" ++ , "" ++ , "happyReduce_6 = happySpecReduce_3 2# happyReduction_6" ++ , "happyReduction_6 happy_x_3" ++ , "\thappy_x_2" ++ , "\thappy_x_1" ++ , "\t = case happyOutTok happy_x_1 of { happy_var_1 -> " ++ , "\tcase happyOut7 happy_x_3 of { happy_var_3 -> " ++ , "\thappyIn6" ++ , "\t\t (SubAssign (subRefVal happy_var_1) happy_var_3" ++ , "\t)}}" ++ , "" ++ , "happyReduce_7 = happySpecReduce_3 2# happyReduction_7" ++ , "happyReduction_7 happy_x_3" ++ , "\thappy_x_2" ++ , "\thappy_x_1" ++ , "\t = case happyOutTok happy_x_1 of { happy_var_1 -> " ++ , "\tcase happyOut7 happy_x_3 of { happy_var_3 -> " ++ , "\thappyIn6" ++ , "\t\t (RightmostAssign (rightRefVal happy_var_1) happy_var_3" ++ , "\t)}}" ++ , "" ++ , "happyReduce_8 = happySpecReduce_2 2# happyReduction_8" ++ , "happyReduction_8 happy_x_2" ++ , "\thappy_x_1" ++ , "\t = case happyOut7 happy_x_2 of { happy_var_2 -> " ++ , "\thappyIn6" ++ , "\t\t (Conditional happy_var_2" ++ , "\t)}" ++ , "" ++ , "happyReduce_9 = happyReduce 4# 3# happyReduction_9" ++ , "happyReduction_9 (happy_x_4 `HappyStk`" ++ , "\thappy_x_3 `HappyStk`" ++ , "\thappy_x_2 `HappyStk`" ++ , "\thappy_x_1 `HappyStk`" ++ , "\thappyRest)" ++ , "\t = case happyOutTok happy_x_1 of { happy_var_1 -> " ++ , "\tcase happyOut8 happy_x_2 of { happy_var_2 -> " ++ , "\tcase happyOutTok happy_x_3 of { happy_var_3 -> " ++ , "\tcase happyOut7 happy_x_4 of { happy_var_4 -> " ++ , "\thappyIn7" ++ , "\t\t ([happy_var_1] ++ happy_var_2 ++ [happy_var_3] ++ happy_var_4" ++ , "\t) `HappyStk` happyRest}}}}" ++ , "" ++ , "happyReduce_10 = happySpecReduce_2 3# happyReduction_10" ++ , "happyReduction_10 happy_x_2" ++ , "\thappy_x_1" ++ , "\t = case happyOutTok happy_x_1 of { happy_var_1 -> " ++ , "\tcase happyOut7 happy_x_2 of { happy_var_2 -> " ++ , "\thappyIn7" ++ , "\t\t (happy_var_1 : happy_var_2" ++ , "\t)}}" ++ , "" ++ , "happyReduce_11 = happySpecReduce_2 3# happyReduction_11" ++ , "happyReduction_11 happy_x_2" ++ , "\thappy_x_1" ++ , "\t = case happyOutTok happy_x_1 of { happy_var_1 -> " ++ , "\tcase happyOut7 happy_x_2 of { happy_var_2 -> " ++ , "\thappyIn7" ++ , "\t\t (happy_var_1 : happy_var_2" ++ , "\t)}}" ++ , "" ++ , "happyReduce_12 = happySpecReduce_2 3# happyReduction_12" ++ , "happyReduction_12 happy_x_2" ++ , "\thappy_x_1" ++ , "\t = case happyOutTok happy_x_1 of { happy_var_1 -> " ++ , "\tcase happyOut7 happy_x_2 of { happy_var_2 -> " ++ , "\thappyIn7" ++ , "\t\t (happy_var_1 : happy_var_2" ++ , "\t)}}" ++ , "" ++ , "happyReduce_13 = happySpecReduce_2 3# happyReduction_13" ++ , "happyReduction_13 happy_x_2" ++ , "\thappy_x_1" ++ , "\t = case happyOutTok happy_x_1 of { happy_var_1 -> " ++ , "\tcase happyOut7 happy_x_2 of { happy_var_2 -> " ++ , "\thappyIn7" ++ , "\t\t (happy_var_1 : happy_var_2" ++ , "\t)}}" ++ , "" ++ , "happyReduce_14 = happySpecReduce_2 3# happyReduction_14" ++ , "happyReduction_14 happy_x_2" ++ , "\thappy_x_1" ++ , "\t = case happyOutTok happy_x_1 of { happy_var_1 -> " ++ , "\tcase happyOut7 happy_x_2 of { happy_var_2 -> " ++ , "\thappyIn7" ++ , "\t\t (happy_var_1 : happy_var_2" ++ , "\t)}}" ++ , "" ++ , "happyReduce_15 = happySpecReduce_0 3# happyReduction_15" ++ , "happyReduction_15 = happyIn7" ++ , "\t\t ([]" ++ , "\t)" ++ , "" ++ , "happyReduce_16 = happyReduce 4# 4# happyReduction_16" ++ , "happyReduction_16 (happy_x_4 `HappyStk`" ++ , "\thappy_x_3 `HappyStk`" ++ , "\thappy_x_2 `HappyStk`" ++ , "\thappy_x_1 `HappyStk`" ++ , "\thappyRest)" ++ , "\t = case happyOutTok happy_x_1 of { happy_var_1 -> " ++ , "\tcase happyOut8 happy_x_2 of { happy_var_2 -> " ++ , "\tcase happyOutTok happy_x_3 of { happy_var_3 -> " ++ , "\tcase happyOut8 happy_x_4 of { happy_var_4 -> " ++ , "\thappyIn8" ++ , "\t\t ([happy_var_1] ++ happy_var_2 ++ [happy_var_3] ++ happy_var_4" ++ , "\t) `HappyStk` happyRest}}}}" ++ , "" ++ , "happyReduce_17 = happySpecReduce_2 4# happyReduction_17" ++ , "happyReduction_17 happy_x_2" ++ , "\thappy_x_1" ++ , "\t = case happyOutTok happy_x_1 of { happy_var_1 -> " ++ , "\tcase happyOut8 happy_x_2 of { happy_var_2 -> " ++ , "\thappyIn8" ++ , "\t\t (happy_var_1 : happy_var_2" ++ , "\t)}}" ++ , "" ++ , "happyReduce_18 = happySpecReduce_2 4# happyReduction_18" ++ , "happyReduction_18 happy_x_2" ++ , "\thappy_x_1" ++ , "\t = case happyOutTok happy_x_1 of { happy_var_1 -> " ++ , "\tcase happyOut8 happy_x_2 of { happy_var_2 -> " ++ , "\thappyIn8" ++ , "\t\t (happy_var_1 : happy_var_2" ++ , "\t)}}" ++ , "" ++ , "happyReduce_19 = happySpecReduce_2 4# happyReduction_19" ++ , "happyReduction_19 happy_x_2" ++ , "\thappy_x_1" ++ , "\t = case happyOutTok happy_x_1 of { happy_var_1 -> " ++ , "\tcase happyOut8 happy_x_2 of { happy_var_2 -> " ++ , "\thappyIn8" ++ , "\t\t (happy_var_1 : happy_var_2" ++ , "\t)}}" ++ , "" ++ , "happyReduce_20 = happySpecReduce_2 4# happyReduction_20" ++ , "happyReduction_20 happy_x_2" ++ , "\thappy_x_1" ++ , "\t = case happyOutTok happy_x_1 of { happy_var_1 -> " ++ , "\tcase happyOut8 happy_x_2 of { happy_var_2 -> " ++ , "\thappyIn8" ++ , "\t\t (happy_var_1 : happy_var_2" ++ , "\t)}}" ++ , "" ++ , "happyReduce_21 = happySpecReduce_2 4# happyReduction_21" ++ , "happyReduction_21 happy_x_2" ++ , "\thappy_x_1" ++ , "\t = case happyOutTok happy_x_1 of { happy_var_1 -> " ++ , "\tcase happyOut7 happy_x_2 of { happy_var_2 -> " ++ , "\thappyIn8" ++ , "\t\t (happy_var_1 : happy_var_2" ++ , "\t)}}" ++ , "" ++ , "happyReduce_22 = happySpecReduce_2 4# happyReduction_22" ++ , "happyReduction_22 happy_x_2" ++ , "\thappy_x_1" ++ , "\t = case happyOutTok happy_x_1 of { happy_var_1 -> " ++ , "\tcase happyOut8 happy_x_2 of { happy_var_2 -> " ++ , "\thappyIn8" ++ , "\t\t (happy_var_1 : happy_var_2" ++ , "\t)}}" ++ , "" ++ , "happyReduce_23 = happySpecReduce_0 4# happyReduction_23" ++ , "happyReduction_23 = happyIn8" ++ , "\t\t ([]" ++ , "\t)" ++ , "" ++ , "happyNewToken action sts stk" ++ , "\t= agLexer(\\tk -> " ++ , "\tlet cont i = happyDoAction i tk action sts stk in" ++ , "\tcase tk of {" ++ , "\tAgTok_EOF -> happyDoAction 10# tk action sts stk;" ++ , "\tAgTok_LBrace -> cont 1#;" ++ , "\tAgTok_RBrace -> cont 2#;" ++ , "\tAgTok_Semicolon -> cont 3#;" ++ , "\tAgTok_Eq -> cont 4#;" ++ , "\tAgTok_Where -> cont 5#;" ++ , "\tAgTok_SelfRef _ -> cont 6#;" ++ , "\tAgTok_SubRef _ -> cont 7#;" ++ , "\tAgTok_RightmostRef _ -> cont 8#;" ++ , "\tAgTok_Unknown _ -> cont 9#;" ++ , "\t_ -> happyError' tk" ++ , "\t})" ++ , "" ++ , "happyError_ tk = happyError' tk" ++ , "" ++ , "happyThen :: () => P a -> (a -> P b) -> P b" ++ , "happyThen = (>>=)" ++ , "happyReturn :: () => a -> P a" ++ , "happyReturn = (return)" ++ , "happyThen1 = happyThen" ++ , "happyReturn1 :: () => a -> P a" ++ , "happyReturn1 = happyReturn" ++ , "happyError' :: () => (AgToken) -> P a" ++ , "happyError' tk = (\\token -> happyError) tk" ++ , "" ++ , "agParser = happySomeParser where" ++ , " happySomeParser = happyThen (happyParse 0#) (\\x -> happyReturn (happyOut4 x))" ++ , "" ++ , "happySeq = happyDontSeq" ++ , "" ++ , "" ++ , "happyError :: P a" ++ , "happyError = fail (\"Parse error\\n\")" ++ , "{-# LINE 1 \"templates/GenericTemplate.hs\" #-}" ++ , "{-# LINE 1 \"templates/GenericTemplate.hs\" #-}" ++ , "{-# LINE 1 \"\" #-}" ++ , "{-# LINE 1 \"\" #-}" ++ , "{-# LINE 1 \"templates/GenericTemplate.hs\" #-}" ++ , "-- Id: GenericTemplate.hs,v 1.26 2005/01/14 14:47:22 simonmar Exp " ++ , "" ++ , "{-# LINE 30 \"templates/GenericTemplate.hs\" #-}" ++ , "" ++ , "" ++ , "data Happy_IntList = HappyCons Happy_GHC_Exts.Int# Happy_IntList" ++ , "" ++ , "" ++ , "" ++ , "" ++ , "" ++ , "{-# LINE 51 \"templates/GenericTemplate.hs\" #-}" ++ , "" ++ , "{-# LINE 61 \"templates/GenericTemplate.hs\" #-}" ++ , "" ++ , "{-# LINE 70 \"templates/GenericTemplate.hs\" #-}" ++ , "" ++ , "infixr 9 `HappyStk`" ++ , "data HappyStk a = HappyStk a (HappyStk a)" ++ , "" ++ , "-----------------------------------------------------------------------------" ++ , "-- starting the parse" ++ , "" ++ , "happyParse start_state = happyNewToken start_state notHappyAtAll notHappyAtAll" ++ , "" ++ , "-----------------------------------------------------------------------------" ++ , "-- Accepting the parse" ++ , "" ++ , "-- If the current token is 0#, it means we've just accepted a partial" ++ , "-- parse (a %partial parser). We must ignore the saved token on the top of" ++ , "-- the stack in this case." ++ , "happyAccept 0# tk st sts (_ `HappyStk` ans `HappyStk` _) =" ++ , "\thappyReturn1 ans" ++ , "happyAccept j tk st sts (HappyStk ans _) = " ++ , "\t(happyTcHack j (happyTcHack st)) (happyReturn1 ans)" ++ , "" ++ , "-----------------------------------------------------------------------------" ++ , "-- Arrays only: do the next action" ++ , "" ++ , "" ++ , "" ++ , "happyDoAction i tk st" ++ , "\t= {- nothing -}" ++ , "" ++ , "" ++ , "\t case action of" ++ , "\t\t0#\t\t -> {- nothing -}" ++ , "\t\t\t\t happyFail i tk st" ++ , "\t\t-1# \t -> {- nothing -}" ++ , "\t\t\t\t happyAccept i tk st" ++ , "\t\tn | (n Happy_GHC_Exts.<# (0# :: Happy_GHC_Exts.Int#)) -> {- nothing -}" ++ , "" ++ , "\t\t\t\t (happyReduceArr Happy_Data_Array.! rule) i tk st" ++ , "\t\t\t\t where rule = (Happy_GHC_Exts.I# ((Happy_GHC_Exts.negateInt# ((n Happy_GHC_Exts.+# (1# :: Happy_GHC_Exts.Int#))))))" ++ , "\t\tn\t\t -> {- nothing -}" ++ , "" ++ , "" ++ , "\t\t\t\t happyShift new_state i tk st" ++ , "\t\t\t\t where (new_state) = (n Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#))" ++ , " where (off) = indexShortOffAddr happyActOffsets st" ++ , " (off_i) = (off Happy_GHC_Exts.+# i)" ++ , "\t check = if (off_i Happy_GHC_Exts.>=# (0# :: Happy_GHC_Exts.Int#))" ++ , "\t\t\tthen (indexShortOffAddr happyCheck off_i Happy_GHC_Exts.==# i)" ++ , "\t\t\telse False" ++ , " (action)" ++ , " | check = indexShortOffAddr happyTable off_i" ++ , " | otherwise = indexShortOffAddr happyDefActions st" ++ , "" ++ , "{-# LINE 130 \"templates/GenericTemplate.hs\" #-}" ++ , "" ++ , "" ++ , "indexShortOffAddr (HappyA# arr) off =" ++ , "\tHappy_GHC_Exts.narrow16Int# i" ++ , " where" ++ , " i = Happy_GHC_Exts.word2Int# (Happy_GHC_Exts.or# (Happy_GHC_Exts.uncheckedShiftL# high 8#) low)" ++ , " high = Happy_GHC_Exts.int2Word# (Happy_GHC_Exts.ord# (Happy_GHC_Exts.indexCharOffAddr# arr (off' Happy_GHC_Exts.+# 1#)))" ++ , " low = Happy_GHC_Exts.int2Word# (Happy_GHC_Exts.ord# (Happy_GHC_Exts.indexCharOffAddr# arr off'))" ++ , " off' = off Happy_GHC_Exts.*# 2#" ++ , "" ++ , "" ++ , "" ++ , "" ++ , "" ++ , "data HappyAddr = HappyA# Happy_GHC_Exts.Addr#" ++ , "" ++ , "" ++ , "" ++ , "" ++ , "-----------------------------------------------------------------------------" ++ , "-- HappyState data type (not arrays)" ++ , "" ++ , "{-# LINE 163 \"templates/GenericTemplate.hs\" #-}" ++ , "" ++ , "-----------------------------------------------------------------------------" ++ , "-- Shifting a token" ++ , "" ++ , "happyShift new_state 0# tk st sts stk@(x `HappyStk` _) =" ++ , " let (i) = (case Happy_GHC_Exts.unsafeCoerce# x of { (Happy_GHC_Exts.I# (i)) -> i }) in" ++ , "-- trace \"shifting the error token\" $" ++ , " happyDoAction i tk new_state (HappyCons (st) (sts)) (stk)" ++ , "" ++ , "happyShift new_state i tk st sts stk =" ++ , " happyNewToken new_state (HappyCons (st) (sts)) ((happyInTok (tk))`HappyStk`stk)" ++ , "" ++ , "-- happyReduce is specialised for the common cases." ++ , "" ++ , "happySpecReduce_0 i fn 0# tk st sts stk" ++ , " = happyFail 0# tk st sts stk" ++ , "happySpecReduce_0 nt fn j tk st@((action)) sts stk" ++ , " = happyGoto nt j tk st (HappyCons (st) (sts)) (fn `HappyStk` stk)" ++ , "" ++ , "happySpecReduce_1 i fn 0# tk st sts stk" ++ , " = happyFail 0# tk st sts stk" ++ , "happySpecReduce_1 nt fn j tk _ sts@((HappyCons (st@(action)) (_))) (v1`HappyStk`stk')" ++ , " = let r = fn v1 in" ++ , " happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk'))" ++ , "" ++ , "happySpecReduce_2 i fn 0# tk st sts stk" ++ , " = happyFail 0# tk st sts stk" ++ , "happySpecReduce_2 nt fn j tk _ (HappyCons (_) (sts@((HappyCons (st@(action)) (_))))) (v1`HappyStk`v2`HappyStk`stk')" ++ , " = let r = fn v1 v2 in" ++ , " happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk'))" ++ , "" ++ , "happySpecReduce_3 i fn 0# tk st sts stk" ++ , " = happyFail 0# tk st sts stk" ++ , "happySpecReduce_3 nt fn j tk _ (HappyCons (_) ((HappyCons (_) (sts@((HappyCons (st@(action)) (_))))))) (v1`HappyStk`v2`HappyStk`v3`HappyStk`stk')" ++ , " = let r = fn v1 v2 v3 in" ++ , " happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk'))" ++ , "" ++ , "happyReduce k i fn 0# tk st sts stk" ++ , " = happyFail 0# tk st sts stk" ++ , "happyReduce k nt fn j tk st sts stk" ++ , " = case happyDrop (k Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) sts of" ++ , "\t sts1@((HappyCons (st1@(action)) (_))) ->" ++ , " \tlet r = fn stk in -- it doesn't hurt to always seq here..." ++ , " \t\thappyDoSeq r (happyGoto nt j tk st1 sts1 r)" ++ , "" ++ , "happyMonadReduce k nt fn 0# tk st sts stk" ++ , " = happyFail 0# tk st sts stk" ++ , "happyMonadReduce k nt fn j tk st sts stk =" ++ , " happyThen1 (fn stk tk) (\\r -> happyGoto nt j tk st1 sts1 (r `HappyStk` drop_stk))" ++ , " where (sts1@((HappyCons (st1@(action)) (_)))) = happyDrop k (HappyCons (st) (sts))" ++ , " drop_stk = happyDropStk k stk" ++ , "" ++ , "happyMonad2Reduce k nt fn 0# tk st sts stk" ++ , " = happyFail 0# tk st sts stk" ++ , "happyMonad2Reduce k nt fn j tk st sts stk =" ++ , " happyThen1 (fn stk tk) (\\r -> happyNewToken new_state sts1 (r `HappyStk` drop_stk))" ++ , " where (sts1@((HappyCons (st1@(action)) (_)))) = happyDrop k (HappyCons (st) (sts))" ++ , " drop_stk = happyDropStk k stk" ++ , "" ++ , " (off) = indexShortOffAddr happyGotoOffsets st1" ++ , " (off_i) = (off Happy_GHC_Exts.+# nt)" ++ , " (new_state) = indexShortOffAddr happyTable off_i" ++ , "" ++ , "" ++ , "" ++ , "" ++ , "happyDrop 0# l = l" ++ , "happyDrop n (HappyCons (_) (t)) = happyDrop (n Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) t" ++ , "" ++ , "happyDropStk 0# l = l" ++ , "happyDropStk n (x `HappyStk` xs) = happyDropStk (n Happy_GHC_Exts.-# (1#::Happy_GHC_Exts.Int#)) xs" ++ , "" ++ , "-----------------------------------------------------------------------------" ++ , "-- Moving to a new state after a reduction" ++ , "" ++ , "" ++ , "happyGoto nt j tk st = " ++ , " {- nothing -}" ++ , " happyDoAction j tk new_state" ++ , " where (off) = indexShortOffAddr happyGotoOffsets st" ++ , " (off_i) = (off Happy_GHC_Exts.+# nt)" ++ , " (new_state) = indexShortOffAddr happyTable off_i" ++ , "" ++ , "" ++ , "" ++ , "" ++ , "-----------------------------------------------------------------------------" ++ , "-- Error recovery (0# is the error token)" ++ , "" ++ , "-- parse error if we are in recovery and we fail again" ++ , "happyFail 0# tk old_st _ stk =" ++ , "--\ttrace \"failing\" $ " ++ , " \thappyError_ tk" ++ , "" ++ , "{- We don't need state discarding for our restricted implementation of" ++ , " \"error\". In fact, it can cause some bogus parses, so I've disabled it" ++ , " for now --SDM" ++ , "" ++ , "-- discard a state" ++ , "happyFail 0# tk old_st (HappyCons ((action)) (sts)) " ++ , "\t\t\t\t\t\t(saved_tok `HappyStk` _ `HappyStk` stk) =" ++ , "--\ttrace (\"discarding state, depth \" ++ show (length stk)) $" ++ , "\thappyDoAction 0# tk action sts ((saved_tok`HappyStk`stk))" ++ , "-}" ++ , "" ++ , "-- Enter error recovery: generate an error token," ++ , "-- save the old token and carry on." ++ , "happyFail i tk (action) sts stk =" ++ , "-- trace \"entering error recovery\" $" ++ , "\thappyDoAction 0# tk action sts ( (Happy_GHC_Exts.unsafeCoerce# (Happy_GHC_Exts.I# (i))) `HappyStk` stk)" ++ , "" ++ , "-- Internal happy errors:" ++ , "" ++ , "notHappyAtAll :: a" ++ , "notHappyAtAll = error \"Internal Happy error\\n\"" ++ , "" ++ , "-----------------------------------------------------------------------------" ++ , "-- Hack to get the typechecker to accept our action functions" ++ , "" ++ , "" ++ , "happyTcHack :: Happy_GHC_Exts.Int# -> a -> a" ++ , "happyTcHack x y = y" ++ , "{-# INLINE happyTcHack #-}" ++ , "" ++ , "" ++ , "-----------------------------------------------------------------------------" ++ , "-- Seq-ing. If the --strict flag is given, then Happy emits " ++ , "--\thappySeq = happyDoSeq" ++ , "-- otherwise it emits" ++ , "-- \thappySeq = happyDontSeq" ++ , "" ++ , "happyDoSeq, happyDontSeq :: a -> b -> b" ++ , "happyDoSeq a b = a `seq` b" ++ , "happyDontSeq a b = b" ++ , "" ++ , "-----------------------------------------------------------------------------" ++ , "-- Don't inline any functions from the template. GHC has a nasty habit" ++ , "-- of deciding to inline happyGoto everywhere, which increases the size of" ++ , "-- the generated parser quite a bit." ++ , "" ++ , "" ++ , "{-# NOINLINE happyDoAction #-}" ++ , "{-# NOINLINE happyTable #-}" ++ , "{-# NOINLINE happyCheck #-}" ++ , "{-# NOINLINE happyActOffsets #-}" ++ , "{-# NOINLINE happyGotoOffsets #-}" ++ , "{-# NOINLINE happyDefActions #-}" ++ , "" ++ , "{-# NOINLINE happyShift #-}" ++ , "{-# NOINLINE happySpecReduce_0 #-}" ++ , "{-# NOINLINE happySpecReduce_1 #-}" ++ , "{-# NOINLINE happySpecReduce_2 #-}" ++ , "{-# NOINLINE happySpecReduce_3 #-}" ++ , "{-# NOINLINE happyReduce #-}" ++ , "{-# NOINLINE happyMonadReduce #-}" ++ , "{-# NOINLINE happyGoto #-}" ++ , "{-# NOINLINE happyFail #-}" ++ , "" ++ , "-- end of Happy Template." ] ++ ++parserHs = ++ unlines ++ [ "{-# OPTIONS_GHC -w #-}" ++ , "{-# OPTIONS -fglasgow-exts -cpp #-}" ++ , "{-# OPTIONS_GHC -w #-}" ++ , "module Parser (ourParser,AbsSyn) where" ++ , "import ParseMonad" ++ , "import AbsSyn" ++ , "import Lexer" ++ , "import qualified Data.Array as Happy_Data_Array" ++ , "import qualified GHC.Exts as Happy_GHC_Exts" ++ , "" ++ , "-- parser produced by Happy Version 1.18.6" ++ , "" ++ , "newtype HappyAbsSyn = HappyAbsSyn HappyAny" ++ , "#if __GLASGOW_HASKELL__ >= 607" ++ , "type HappyAny = Happy_GHC_Exts.Any" ++ , "#else" ++ , "type HappyAny = forall a . a" ++ , "#endif" ++ , "happyIn4 :: (AbsSyn) -> (HappyAbsSyn )" ++ , "happyIn4 x = Happy_GHC_Exts.unsafeCoerce# x" ++ , "{-# INLINE happyIn4 #-}" ++ , "happyOut4 :: (HappyAbsSyn ) -> (AbsSyn)" ++ , "happyOut4 x = Happy_GHC_Exts.unsafeCoerce# x" ++ , "{-# INLINE happyOut4 #-}" ++ , "happyIn5 :: ([Rule]) -> (HappyAbsSyn )" ++ , "happyIn5 x = Happy_GHC_Exts.unsafeCoerce# x" ++ , "{-# INLINE happyIn5 #-}" ++ , "happyOut5 :: (HappyAbsSyn ) -> ([Rule])" ++ , "happyOut5 x = Happy_GHC_Exts.unsafeCoerce# x" ++ , "{-# INLINE happyOut5 #-}" ++ , "happyIn6 :: (Rule) -> (HappyAbsSyn )" ++ , "happyIn6 x = Happy_GHC_Exts.unsafeCoerce# x" ++ , "{-# INLINE happyIn6 #-}" ++ , "happyOut6 :: (HappyAbsSyn ) -> (Rule)" ++ , "happyOut6 x = Happy_GHC_Exts.unsafeCoerce# x" ++ , "{-# INLINE happyOut6 #-}" ++ , "happyIn7 :: ([String]) -> (HappyAbsSyn )" ++ , "happyIn7 x = Happy_GHC_Exts.unsafeCoerce# x" ++ , "{-# INLINE happyIn7 #-}" ++ , "happyOut7 :: (HappyAbsSyn ) -> ([String])" ++ , "happyOut7 x = Happy_GHC_Exts.unsafeCoerce# x" ++ , "{-# INLINE happyOut7 #-}" ++ , "happyIn8 :: ([String]) -> (HappyAbsSyn )" ++ , "happyIn8 x = Happy_GHC_Exts.unsafeCoerce# x" ++ , "{-# INLINE happyIn8 #-}" ++ , "happyOut8 :: (HappyAbsSyn ) -> ([String])" ++ , "happyOut8 x = Happy_GHC_Exts.unsafeCoerce# x" ++ , "{-# INLINE happyOut8 #-}" ++ , "happyIn9 :: ([Prod]) -> (HappyAbsSyn )" ++ , "happyIn9 x = Happy_GHC_Exts.unsafeCoerce# x" ++ , "{-# INLINE happyIn9 #-}" ++ , "happyOut9 :: (HappyAbsSyn ) -> ([Prod])" ++ , "happyOut9 x = Happy_GHC_Exts.unsafeCoerce# x" ++ , "{-# INLINE happyOut9 #-}" ++ , "happyIn10 :: (Prod) -> (HappyAbsSyn )" ++ , "happyIn10 x = Happy_GHC_Exts.unsafeCoerce# x" ++ , "{-# INLINE happyIn10 #-}" ++ , "happyOut10 :: (HappyAbsSyn ) -> (Prod)" ++ , "happyOut10 x = Happy_GHC_Exts.unsafeCoerce# x" ++ , "{-# INLINE happyOut10 #-}" ++ , "happyIn11 :: (Term) -> (HappyAbsSyn )" ++ , "happyIn11 x = Happy_GHC_Exts.unsafeCoerce# x" ++ , "{-# INLINE happyIn11 #-}" ++ , "happyOut11 :: (HappyAbsSyn ) -> (Term)" ++ , "happyOut11 x = Happy_GHC_Exts.unsafeCoerce# x" ++ , "{-# INLINE happyOut11 #-}" ++ , "happyIn12 :: ([Term]) -> (HappyAbsSyn )" ++ , "happyIn12 x = Happy_GHC_Exts.unsafeCoerce# x" ++ , "{-# INLINE happyIn12 #-}" ++ , "happyOut12 :: (HappyAbsSyn ) -> ([Term])" ++ , "happyOut12 x = Happy_GHC_Exts.unsafeCoerce# x" ++ , "{-# INLINE happyOut12 #-}" ++ , "happyIn13 :: ([Term]) -> (HappyAbsSyn )" ++ , "happyIn13 x = Happy_GHC_Exts.unsafeCoerce# x" ++ , "{-# INLINE happyIn13 #-}" ++ , "happyOut13 :: (HappyAbsSyn ) -> ([Term])" ++ , "happyOut13 x = Happy_GHC_Exts.unsafeCoerce# x" ++ , "{-# INLINE happyOut13 #-}" ++ , "happyIn14 :: ([Term]) -> (HappyAbsSyn )" ++ , "happyIn14 x = Happy_GHC_Exts.unsafeCoerce# x" ++ , "{-# INLINE happyIn14 #-}" ++ , "happyOut14 :: (HappyAbsSyn ) -> ([Term])" ++ , "happyOut14 x = Happy_GHC_Exts.unsafeCoerce# x" ++ , "{-# INLINE happyOut14 #-}" ++ , "happyIn15 :: (Maybe String) -> (HappyAbsSyn )" ++ , "happyIn15 x = Happy_GHC_Exts.unsafeCoerce# x" ++ , "{-# INLINE happyIn15 #-}" ++ , "happyOut15 :: (HappyAbsSyn ) -> (Maybe String)" ++ , "happyOut15 x = Happy_GHC_Exts.unsafeCoerce# x" ++ , "{-# INLINE happyOut15 #-}" ++ , "happyIn16 :: ([Directive String]) -> (HappyAbsSyn )" ++ , "happyIn16 x = Happy_GHC_Exts.unsafeCoerce# x" ++ , "{-# INLINE happyIn16 #-}" ++ , "happyOut16 :: (HappyAbsSyn ) -> ([Directive String])" ++ , "happyOut16 x = Happy_GHC_Exts.unsafeCoerce# x" ++ , "{-# INLINE happyOut16 #-}" ++ , "happyIn17 :: (Directive String) -> (HappyAbsSyn )" ++ , "happyIn17 x = Happy_GHC_Exts.unsafeCoerce# x" ++ , "{-# INLINE happyIn17 #-}" ++ , "happyOut17 :: (HappyAbsSyn ) -> (Directive String)" ++ , "happyOut17 x = Happy_GHC_Exts.unsafeCoerce# x" ++ , "{-# INLINE happyOut17 #-}" ++ , "happyIn18 :: (Maybe String) -> (HappyAbsSyn )" ++ , "happyIn18 x = Happy_GHC_Exts.unsafeCoerce# x" ++ , "{-# INLINE happyIn18 #-}" ++ , "happyOut18 :: (HappyAbsSyn ) -> (Maybe String)" ++ , "happyOut18 x = Happy_GHC_Exts.unsafeCoerce# x" ++ , "{-# INLINE happyOut18 #-}" ++ , "happyIn19 :: ([(String,String)]) -> (HappyAbsSyn )" ++ , "happyIn19 x = Happy_GHC_Exts.unsafeCoerce# x" ++ , "{-# INLINE happyIn19 #-}" ++ , "happyOut19 :: (HappyAbsSyn ) -> ([(String,String)])" ++ , "happyOut19 x = Happy_GHC_Exts.unsafeCoerce# x" ++ , "{-# INLINE happyOut19 #-}" ++ , "happyIn20 :: ((String,String)) -> (HappyAbsSyn )" ++ , "happyIn20 x = Happy_GHC_Exts.unsafeCoerce# x" ++ , "{-# INLINE happyIn20 #-}" ++ , "happyOut20 :: (HappyAbsSyn ) -> ((String,String))" ++ , "happyOut20 x = Happy_GHC_Exts.unsafeCoerce# x" ++ , "{-# INLINE happyOut20 #-}" ++ , "happyIn21 :: ([String]) -> (HappyAbsSyn )" ++ , "happyIn21 x = Happy_GHC_Exts.unsafeCoerce# x" ++ , "{-# INLINE happyIn21 #-}" ++ , "happyOut21 :: (HappyAbsSyn ) -> ([String])" ++ , "happyOut21 x = Happy_GHC_Exts.unsafeCoerce# x" ++ , "{-# INLINE happyOut21 #-}" ++ , "happyIn22 :: (Maybe String) -> (HappyAbsSyn )" ++ , "happyIn22 x = Happy_GHC_Exts.unsafeCoerce# x" ++ , "{-# INLINE happyIn22 #-}" ++ , "happyOut22 :: (HappyAbsSyn ) -> (Maybe String)" ++ , "happyOut22 x = Happy_GHC_Exts.unsafeCoerce# x" ++ , "{-# INLINE happyOut22 #-}" ++ , "happyInTok :: (Token) -> (HappyAbsSyn )" ++ , "happyInTok x = Happy_GHC_Exts.unsafeCoerce# x" ++ , "{-# INLINE happyInTok #-}" ++ , "happyOutTok :: (HappyAbsSyn ) -> (Token)" ++ , "happyOutTok x = Happy_GHC_Exts.unsafeCoerce# x" ++ , "{-# INLINE happyOutTok #-}" ++ , "" ++ , "" ++ , "happyActOffsets :: HappyAddr" ++ , "happyActOffsets = HappyA# \"\\x70\\x00\\x70\\x00\\x22\\x00\\x00\\x00\\x67\\x00\\xff\\xff\\x00\\x00\\x6d\\x00\\x78\\x00\\x76\\x00\\x75\\x00\\x6c\\x00\\x00\\x00\\x6b\\x00\\x73\\x00\\x73\\x00\\x73\\x00\\x66\\x00\\x64\\x00\\x6f\\x00\\x62\\x00\\x00\\x00\\x61\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x6e\\x00\\x00\\x00\\x00\\x00\\x60\\x00\\x5d\\x00\\x6a\\x00\\x6a\\x00\\x00\\x00\\x69\\x00\\x5c\\x00\\x00\\x00\\x00\\x00\\x68\\x00\\x10\\x00\\x00\\x00\\x50\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x5b\\x00\\x00\\x00\\x00\\x00\\x56\\x00\\x01\\x00\\x65\\x00\\x00\\x00\\x00\\x00\\x34\\x00\\x00\\x00\\x63\\x00\\x51\\x00\\x00\\x00\\x0f\\x00\\x00\\x00\\x4e\\x00\\x00\\x00\\x55\\x00\\x5f\\x00\\x4b\\x00\\x00\\x00\\x5e\\x00\\x00\\x00\\x5a\\x00\\x00\\x00\\x4d\\x00\\x59\\x00\\x58\\x00\\x4a\\x00\\x57\\x00\\x00\\x00\\x57\\x00\\x00\\x00\\x00\\x00\\x48\\x00\\x00\\x00\\x31\\x00\\x00\\x00\\x52\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\"#" ++ , "" ++ , "happyGotoOffsets :: HappyAddr" ++ , "happyGotoOffsets = HappyA# \"\\x0b\\x00\\x40\\x00\\x3c\\x00\\x00\\x00\\x00\\x00\\x47\\x00\\x00\\x00\\x00\\x00\\x37\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x46\\x00\\x45\\x00\\x44\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x3e\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x43\\x00\\x42\\x00\\x00\\x00\\x35\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x41\\x00\\x11\\x00\\x00\\x00\\x49\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x2a\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x38\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x07\\x00\\x19\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x15\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x33\\x00\\x00\\x00\\x2e\\x00\\x00\\x00\\x12\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x17\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\"#" ++ , "" ++ , "happyDefActions :: HappyAddr" ++ , "happyDefActions = HappyA# \"\\xcb\\xff\\x00\\x00\\x00\\x00\\xcc\\xff\\x00\\x00\\x00\\x00\\xe5\\xff\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\xe0\\xff\\x00\\x00\\xcd\\xff\\xcd\\xff\\xcd\\xff\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\xd5\\xff\\x00\\x00\\xd6\\xff\\xd7\\xff\\xd9\\xff\\xcd\\xff\\xd8\\xff\\xda\\xff\\xde\\xff\\x00\\x00\\xd2\\xff\\xd2\\xff\\xe3\\xff\\xd0\\xff\\x00\\x00\\xe4\\xff\\xe6\\xff\\x00\\x00\\xcb\\xff\\xfc\\xff\\xf7\\xff\\xcf\\xff\\xd1\\xff\\xe2\\xff\\xd3\\xff\\xe1\\xff\\xdf\\xff\\xdd\\xff\\xce\\xff\\xd4\\xff\\xdc\\xff\\x00\\x00\\x00\\x00\\xfd\\xff\\xfe\\xff\\x00\\x00\\xf6\\xff\\xed\\xff\\x00\\x00\\xdb\\xff\\x00\\x00\\xf9\\xff\\xf3\\xff\\xec\\xff\\xe7\\xff\\xee\\xff\\xf0\\xff\\xf8\\xff\\x00\\x00\\xf5\\xff\\x00\\x00\\xeb\\xff\\x00\\x00\\x00\\x00\\xed\\xff\\x00\\x00\\xed\\xff\\xfb\\xff\\xed\\xff\\xf4\\xff\\xe8\\xff\\xf1\\xff\\xea\\xff\\x00\\x00\\xef\\xff\\x00\\x00\\xf2\\xff\\xfa\\xff\\xe9\\xff\"#" ++ , "" ++ , "happyCheck :: HappyAddr" ++ , "happyCheck = HappyA# \"\\xff\\xff\\x02\\x00\\x03\\x00\\x04\\x00\\x05\\x00\\x06\\x00\\x07\\x00\\x08\\x00\\x09\\x00\\x0a\\x00\\x0b\\x00\\x00\\x00\\x0d\\x00\\x0e\\x00\\x0f\\x00\\x10\\x00\\x01\\x00\\x01\\x00\\x0b\\x00\\x02\\x00\\x13\\x00\\x16\\x00\\x15\\x00\\x05\\x00\\x06\\x00\\x07\\x00\\x08\\x00\\x09\\x00\\x07\\x00\\x12\\x00\\x07\\x00\\x0a\\x00\\x07\\x00\\x11\\x00\\x13\\x00\\x12\\x00\\x02\\x00\\x03\\x00\\x04\\x00\\x05\\x00\\x06\\x00\\x07\\x00\\x08\\x00\\x09\\x00\\x0a\\x00\\x0b\\x00\\x04\\x00\\x0d\\x00\\x0e\\x00\\x0f\\x00\\x10\\x00\\x05\\x00\\x06\\x00\\x07\\x00\\x08\\x00\\x09\\x00\\x05\\x00\\x06\\x00\\x07\\x00\\x08\\x00\\x09\\x00\\x05\\x00\\x06\\x00\\x07\\x00\\x08\\x00\\x09\\x00\\x01\\x00\\x02\\x00\\x0f\\x00\\x10\\x00\\x0f\\x00\\x10\\x00\\x0c\\x00\\x0d\\x00\\x19\\x00\\x1a\\x00\\x03\\x00\\x19\\x00\\x1a\\x00\\x11\\x00\\x0e\\x00\\x0e\\x00\\x12\\x00\\x01\\x00\\x0d\\x00\\x11\\x00\\x11\\x00\\x11\\x00\\x01\\x00\\x01\\x00\\x01\\x00\\x01\\x00\\x14\\x00\\x13\\x00\\x11\\x00\\x01\\x00\\x01\\x00\\x0c\\x00\\x11\\x00\\x18\\x00\\x01\\x00\\x17\\x00\\x01\\x00\\x11\\x00\\x18\\x00\\x01\\x00\\x01\\x00\\x01\\x00\\x11\\x00\\x11\\x00\\x11\\x00\\x01\\x00\\x01\\x00\\x11\\x00\\x11\\x00\\x11\\x00\\x01\\x00\\x11\\x00\\x01\\x00\\x01\\x00\\x12\\x00\\x01\\x00\\xff\\xff\\xff\\xff\\x11\\x00\\x11\\x00\\x11\\x00\\xff\\xff\\xff\\xff\\x11\\x00\\x1b\\x00\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\"#" ++ , "" ++ , "happyTable :: HappyAddr" ++ , "happyTable = HappyA# \"\\x00\\x00\\x08\\x00\\x09\\x00\\x0a\\x00\\x0b\\x00\\x0c\\x00\\x0d\\x00\\x0e\\x00\\x0f\\x00\\x10\\x00\\x11\\x00\\x04\\x00\\x12\\x00\\x13\\x00\\x14\\x00\\x15\\x00\\x4d\\x00\\x2a\\x00\\x49\\x00\\x36\\x00\\x3b\\x00\\x27\\x00\\x3c\\x00\\x58\\x00\\x3f\\x00\\x40\\x00\\x41\\x00\\x42\\x00\\x53\\x00\\x02\\x00\\x59\\x00\\x54\\x00\\x48\\x00\\x04\\x00\\x4e\\x00\\x37\\x00\\x08\\x00\\x09\\x00\\x0a\\x00\\x0b\\x00\\x0c\\x00\\x0d\\x00\\x0e\\x00\\x0f\\x00\\x10\\x00\\x11\\x00\\x38\\x00\\x12\\x00\\x13\\x00\\x14\\x00\\x15\\x00\\x4e\\x00\\x3f\\x00\\x40\\x00\\x41\\x00\\x42\\x00\\x50\\x00\\x3f\\x00\\x40\\x00\\x41\\x00\\x42\\x00\\x3e\\x00\\x3f\\x00\\x40\\x00\\x41\\x00\\x42\\x00\\x27\\x00\\x28\\x00\\x2b\\x00\\x22\\x00\\x21\\x00\\x22\\x00\\x05\\x00\\x06\\x00\\x56\\x00\\x57\\x00\\x34\\x00\\x45\\x00\\x46\\x00\\x31\\x00\\x2c\\x00\\x2e\\x00\\x02\\x00\\x44\\x00\\x25\\x00\\x19\\x00\\x1b\\x00\\x1c\\x00\\x44\\x00\\x44\\x00\\x52\\x00\\x44\\x00\\x58\\x00\\x50\\x00\\x53\\x00\\x47\\x00\\x44\\x00\\x4b\\x00\\x3e\\x00\\x48\\x00\\x44\\x00\\x4c\\x00\\x3a\\x00\\x3d\\x00\\x36\\x00\\x2a\\x00\\x24\\x00\\x2e\\x00\\x34\\x00\\x2b\\x00\\x30\\x00\\x1b\\x00\\x17\\x00\\x31\\x00\\x33\\x00\\x16\\x00\\x1b\\x00\\x18\\x00\\x20\\x00\\x21\\x00\\x19\\x00\\x24\\x00\\x00\\x00\\x00\\x00\\x1e\\x00\\x1f\\x00\\x25\\x00\\x00\\x00\\x00\\x00\\x04\\x00\\xff\\xff\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\"#" ++ , "" ++ , "happyReduceArr = Happy_Data_Array.array (1, 52) [" ++ , "\t(1 , happyReduce_1)," ++ , "\t(2 , happyReduce_2)," ++ , "\t(3 , happyReduce_3)," ++ , "\t(4 , happyReduce_4)," ++ , "\t(5 , happyReduce_5)," ++ , "\t(6 , happyReduce_6)," ++ , "\t(7 , happyReduce_7)," ++ , "\t(8 , happyReduce_8)," ++ , "\t(9 , happyReduce_9)," ++ , "\t(10 , happyReduce_10)," ++ , "\t(11 , happyReduce_11)," ++ , "\t(12 , happyReduce_12)," ++ , "\t(13 , happyReduce_13)," ++ , "\t(14 , happyReduce_14)," ++ , "\t(15 , happyReduce_15)," ++ , "\t(16 , happyReduce_16)," ++ , "\t(17 , happyReduce_17)," ++ , "\t(18 , happyReduce_18)," ++ , "\t(19 , happyReduce_19)," ++ , "\t(20 , happyReduce_20)," ++ , "\t(21 , happyReduce_21)," ++ , "\t(22 , happyReduce_22)," ++ , "\t(23 , happyReduce_23)," ++ , "\t(24 , happyReduce_24)," ++ , "\t(25 , happyReduce_25)," ++ , "\t(26 , happyReduce_26)," ++ , "\t(27 , happyReduce_27)," ++ , "\t(28 , happyReduce_28)," ++ , "\t(29 , happyReduce_29)," ++ , "\t(30 , happyReduce_30)," ++ , "\t(31 , happyReduce_31)," ++ , "\t(32 , happyReduce_32)," ++ , "\t(33 , happyReduce_33)," ++ , "\t(34 , happyReduce_34)," ++ , "\t(35 , happyReduce_35)," ++ , "\t(36 , happyReduce_36)," ++ , "\t(37 , happyReduce_37)," ++ , "\t(38 , happyReduce_38)," ++ , "\t(39 , happyReduce_39)," ++ , "\t(40 , happyReduce_40)," ++ , "\t(41 , happyReduce_41)," ++ , "\t(42 , happyReduce_42)," ++ , "\t(43 , happyReduce_43)," ++ , "\t(44 , happyReduce_44)," ++ , "\t(45 , happyReduce_45)," ++ , "\t(46 , happyReduce_46)," ++ , "\t(47 , happyReduce_47)," ++ , "\t(48 , happyReduce_48)," ++ , "\t(49 , happyReduce_49)," ++ , "\t(50 , happyReduce_50)," ++ , "\t(51 , happyReduce_51)," ++ , "\t(52 , happyReduce_52)" ++ , "\t]" ++ , "" ++ , "happy_n_terms = 28 :: Int" ++ , "happy_n_nonterms = 19 :: Int" ++ , "" ++ , "happyReduce_1 = happyReduce 5# 0# happyReduction_1" ++ , "happyReduction_1 (happy_x_5 `HappyStk`" ++ , "\thappy_x_4 `HappyStk`" ++ , "\thappy_x_3 `HappyStk`" ++ , "\thappy_x_2 `HappyStk`" ++ , "\thappy_x_1 `HappyStk`" ++ , "\thappyRest)" ++ , "\t = case happyOut22 happy_x_1 of { happy_var_1 -> " ++ , "\tcase happyOut16 happy_x_2 of { happy_var_2 -> " ++ , "\tcase happyOut5 happy_x_4 of { happy_var_4 -> " ++ , "\tcase happyOut22 happy_x_5 of { happy_var_5 -> " ++ , "\thappyIn4" ++ , "\t\t (AbsSyn happy_var_1 (reverse happy_var_2) (reverse happy_var_4) happy_var_5" ++ , "\t) `HappyStk` happyRest}}}}" ++ , "" ++ , "happyReduce_2 = happySpecReduce_2 1# happyReduction_2" ++ , "happyReduction_2 happy_x_2" ++ , "\thappy_x_1" ++ , "\t = case happyOut5 happy_x_1 of { happy_var_1 -> " ++ , "\tcase happyOut6 happy_x_2 of { happy_var_2 -> " ++ , "\thappyIn5" ++ , "\t\t (happy_var_2 : happy_var_1" ++ , "\t)}}" ++ , "" ++ , "happyReduce_3 = happySpecReduce_1 1# happyReduction_3" ++ , "happyReduction_3 happy_x_1" ++ , "\t = case happyOut6 happy_x_1 of { happy_var_1 -> " ++ , "\thappyIn5" ++ , "\t\t ([happy_var_1]" ++ , "\t)}" ++ , "" ++ , "happyReduce_4 = happyReduce 6# 2# happyReduction_4" ++ , "happyReduction_4 (happy_x_6 `HappyStk`" ++ , "\thappy_x_5 `HappyStk`" ++ , "\thappy_x_4 `HappyStk`" ++ , "\thappy_x_3 `HappyStk`" ++ , "\thappy_x_2 `HappyStk`" ++ , "\thappy_x_1 `HappyStk`" ++ , "\thappyRest)" ++ , "\t = case happyOutTok happy_x_1 of { (TokenInfo happy_var_1 TokId) -> " ++ , "\tcase happyOut7 happy_x_2 of { happy_var_2 -> " ++ , "\tcase happyOutTok happy_x_4 of { (TokenInfo happy_var_4 TokCodeQuote) -> " ++ , "\tcase happyOut9 happy_x_6 of { happy_var_6 -> " ++ , "\thappyIn6" ++ , "\t\t ((happy_var_1,happy_var_2,happy_var_6,Just happy_var_4)" ++ , "\t) `HappyStk` happyRest}}}}" ++ , "" ++ , "happyReduce_5 = happyReduce 7# 2# happyReduction_5" ++ , "happyReduction_5 (happy_x_7 `HappyStk`" ++ , "\thappy_x_6 `HappyStk`" ++ , "\thappy_x_5 `HappyStk`" ++ , "\thappy_x_4 `HappyStk`" ++ , "\thappy_x_3 `HappyStk`" ++ , "\thappy_x_2 `HappyStk`" ++ , "\thappy_x_1 `HappyStk`" ++ , "\thappyRest)" ++ , "\t = case happyOutTok happy_x_1 of { (TokenInfo happy_var_1 TokId) -> " ++ , "\tcase happyOut7 happy_x_2 of { happy_var_2 -> " ++ , "\tcase happyOutTok happy_x_4 of { (TokenInfo happy_var_4 TokCodeQuote) -> " ++ , "\tcase happyOut9 happy_x_7 of { happy_var_7 -> " ++ , "\thappyIn6" ++ , "\t\t ((happy_var_1,happy_var_2,happy_var_7,Just happy_var_4)" ++ , "\t) `HappyStk` happyRest}}}}" ++ , "" ++ , "happyReduce_6 = happyReduce 4# 2# happyReduction_6" ++ , "happyReduction_6 (happy_x_4 `HappyStk`" ++ , "\thappy_x_3 `HappyStk`" ++ , "\thappy_x_2 `HappyStk`" ++ , "\thappy_x_1 `HappyStk`" ++ , "\thappyRest)" ++ , "\t = case happyOutTok happy_x_1 of { (TokenInfo happy_var_1 TokId) -> " ++ , "\tcase happyOut7 happy_x_2 of { happy_var_2 -> " ++ , "\tcase happyOut9 happy_x_4 of { happy_var_4 -> " ++ , "\thappyIn6" ++ , "\t\t ((happy_var_1,happy_var_2,happy_var_4,Nothing)" ++ , "\t) `HappyStk` happyRest}}}" ++ , "" ++ , "happyReduce_7 = happySpecReduce_3 3# happyReduction_7" ++ , "happyReduction_7 happy_x_3" ++ , "\thappy_x_2" ++ , "\thappy_x_1" ++ , "\t = case happyOut8 happy_x_2 of { happy_var_2 -> " ++ , "\thappyIn7" ++ , "\t\t (reverse happy_var_2" ++ , "\t)}" ++ , "" ++ , "happyReduce_8 = happySpecReduce_0 3# happyReduction_8" ++ , "happyReduction_8 = happyIn7" ++ , "\t\t ([]" ++ , "\t)" ++ , "" ++ , "happyReduce_9 = happySpecReduce_1 4# happyReduction_9" ++ , "happyReduction_9 happy_x_1" ++ , "\t = case happyOutTok happy_x_1 of { (TokenInfo happy_var_1 TokId) -> " ++ , "\thappyIn8" ++ , "\t\t ([happy_var_1]" ++ , "\t)}" ++ , "" ++ , "happyReduce_10 = happySpecReduce_3 4# happyReduction_10" ++ , "happyReduction_10 happy_x_3" ++ , "\thappy_x_2" ++ , "\thappy_x_1" ++ , "\t = case happyOut8 happy_x_1 of { happy_var_1 -> " ++ , "\tcase happyOutTok happy_x_3 of { (TokenInfo happy_var_3 TokId) -> " ++ , "\thappyIn8" ++ , "\t\t (happy_var_3 : happy_var_1" ++ , "\t)}}" ++ , "" ++ , "happyReduce_11 = happySpecReduce_3 5# happyReduction_11" ++ , "happyReduction_11 happy_x_3" ++ , "\thappy_x_2" ++ , "\thappy_x_1" ++ , "\t = case happyOut10 happy_x_1 of { happy_var_1 -> " ++ , "\tcase happyOut9 happy_x_3 of { happy_var_3 -> " ++ , "\thappyIn9" ++ , "\t\t (happy_var_1 : happy_var_3" ++ , "\t)}}" ++ , "" ++ , "happyReduce_12 = happySpecReduce_1 5# happyReduction_12" ++ , "happyReduction_12 happy_x_1" ++ , "\t = case happyOut10 happy_x_1 of { happy_var_1 -> " ++ , "\thappyIn9" ++ , "\t\t ([happy_var_1]" ++ , "\t)}" ++ , "" ++ , "happyReduce_13 = happyMonadReduce 4# 6# happyReduction_13" ++ , "happyReduction_13 (happy_x_4 `HappyStk`" ++ , "\thappy_x_3 `HappyStk`" ++ , "\thappy_x_2 `HappyStk`" ++ , "\thappy_x_1 `HappyStk`" ++ , "\thappyRest) tk" ++ , "\t = happyThen (case happyOut12 happy_x_1 of { happy_var_1 -> " ++ , "\tcase happyOut15 happy_x_2 of { happy_var_2 -> " ++ , "\tcase happyOutTok happy_x_3 of { (TokenInfo happy_var_3 TokCodeQuote) -> " ++ , "\t( lineP >>= \\l -> return (happy_var_1,happy_var_3,l,happy_var_2))}}}" ++ , "\t) (\\r -> happyReturn (happyIn10 r))" ++ , "" ++ , "happyReduce_14 = happyMonadReduce 3# 6# happyReduction_14" ++ , "happyReduction_14 (happy_x_3 `HappyStk`" ++ , "\thappy_x_2 `HappyStk`" ++ , "\thappy_x_1 `HappyStk`" ++ , "\thappyRest) tk" ++ , "\t = happyThen (case happyOut12 happy_x_1 of { happy_var_1 -> " ++ , "\tcase happyOut15 happy_x_2 of { happy_var_2 -> " ++ , "\tcase happyOutTok happy_x_3 of { (TokenInfo happy_var_3 TokCodeQuote) -> " ++ , "\t( lineP >>= \\l -> return (happy_var_1,happy_var_3,l,happy_var_2))}}}" ++ , "\t) (\\r -> happyReturn (happyIn10 r))" ++ , "" ++ , "happyReduce_15 = happySpecReduce_1 7# happyReduction_15" ++ , "happyReduction_15 happy_x_1" ++ , "\t = case happyOutTok happy_x_1 of { (TokenInfo happy_var_1 TokId) -> " ++ , "\thappyIn11" ++ , "\t\t (App happy_var_1 []" ++ , "\t)}" ++ , "" ++ , "happyReduce_16 = happyReduce 4# 7# happyReduction_16" ++ , "happyReduction_16 (happy_x_4 `HappyStk`" ++ , "\thappy_x_3 `HappyStk`" ++ , "\thappy_x_2 `HappyStk`" ++ , "\thappy_x_1 `HappyStk`" ++ , "\thappyRest)" ++ , "\t = case happyOutTok happy_x_1 of { (TokenInfo happy_var_1 TokId) -> " ++ , "\tcase happyOut14 happy_x_3 of { happy_var_3 -> " ++ , "\thappyIn11" ++ , "\t\t (App happy_var_1 (reverse happy_var_3)" ++ , "\t) `HappyStk` happyRest}}" ++ , "" ++ , "happyReduce_17 = happySpecReduce_1 8# happyReduction_17" ++ , "happyReduction_17 happy_x_1" ++ , "\t = case happyOut13 happy_x_1 of { happy_var_1 -> " ++ , "\thappyIn12" ++ , "\t\t (reverse happy_var_1" ++ , "\t)}" ++ , "" ++ , "happyReduce_18 = happySpecReduce_0 8# happyReduction_18" ++ , "happyReduction_18 = happyIn12" ++ , "\t\t ([]" ++ , "\t)" ++ , "" ++ , "happyReduce_19 = happySpecReduce_1 9# happyReduction_19" ++ , "happyReduction_19 happy_x_1" ++ , "\t = case happyOut11 happy_x_1 of { happy_var_1 -> " ++ , "\thappyIn13" ++ , "\t\t ([happy_var_1]" ++ , "\t)}" ++ , "" ++ , "happyReduce_20 = happySpecReduce_2 9# happyReduction_20" ++ , "happyReduction_20 happy_x_2" ++ , "\thappy_x_1" ++ , "\t = case happyOut13 happy_x_1 of { happy_var_1 -> " ++ , "\tcase happyOut11 happy_x_2 of { happy_var_2 -> " ++ , "\thappyIn13" ++ , "\t\t (happy_var_2 : happy_var_1" ++ , "\t)}}" ++ , "" ++ , "happyReduce_21 = happySpecReduce_1 10# happyReduction_21" ++ , "happyReduction_21 happy_x_1" ++ , "\t = case happyOut11 happy_x_1 of { happy_var_1 -> " ++ , "\thappyIn14" ++ , "\t\t ([happy_var_1]" ++ , "\t)}" ++ , "" ++ , "happyReduce_22 = happySpecReduce_3 10# happyReduction_22" ++ , "happyReduction_22 happy_x_3" ++ , "\thappy_x_2" ++ , "\thappy_x_1" ++ , "\t = case happyOut14 happy_x_1 of { happy_var_1 -> " ++ , "\tcase happyOut11 happy_x_3 of { happy_var_3 -> " ++ , "\thappyIn14" ++ , "\t\t (happy_var_3 : happy_var_1" ++ , "\t)}}" ++ , "" ++ , "happyReduce_23 = happySpecReduce_2 11# happyReduction_23" ++ , "happyReduction_23 happy_x_2" ++ , "\thappy_x_1" ++ , "\t = case happyOutTok happy_x_2 of { (TokenInfo happy_var_2 TokId) -> " ++ , "\thappyIn15" ++ , "\t\t (Just happy_var_2" ++ , "\t)}" ++ , "" ++ , "happyReduce_24 = happySpecReduce_0 11# happyReduction_24" ++ , "happyReduction_24 = happyIn15" ++ , "\t\t (Nothing" ++ , "\t)" ++ , "" ++ , "happyReduce_25 = happySpecReduce_2 12# happyReduction_25" ++ , "happyReduction_25 happy_x_2" ++ , "\thappy_x_1" ++ , "\t = case happyOut16 happy_x_1 of { happy_var_1 -> " ++ , "\tcase happyOut17 happy_x_2 of { happy_var_2 -> " ++ , "\thappyIn16" ++ , "\t\t (happy_var_2 : happy_var_1" ++ , "\t)}}" ++ , "" ++ , "happyReduce_26 = happySpecReduce_1 12# happyReduction_26" ++ , "happyReduction_26 happy_x_1" ++ , "\t = case happyOut17 happy_x_1 of { happy_var_1 -> " ++ , "\thappyIn16" ++ , "\t\t ([happy_var_1]" ++ , "\t)}" ++ , "" ++ , "happyReduce_27 = happySpecReduce_2 13# happyReduction_27" ++ , "happyReduction_27 happy_x_2" ++ , "\thappy_x_1" ++ , "\t = case happyOutTok happy_x_2 of { (TokenInfo happy_var_2 TokCodeQuote) -> " ++ , "\thappyIn17" ++ , "\t\t (TokenType happy_var_2" ++ , "\t)}" ++ , "" ++ , "happyReduce_28 = happySpecReduce_2 13# happyReduction_28" ++ , "happyReduction_28 happy_x_2" ++ , "\thappy_x_1" ++ , "\t = case happyOut19 happy_x_2 of { happy_var_2 -> " ++ , "\thappyIn17" ++ , "\t\t (TokenSpec happy_var_2" ++ , "\t)}" ++ , "" ++ , "happyReduce_29 = happySpecReduce_3 13# happyReduction_29" ++ , "happyReduction_29 happy_x_3" ++ , "\thappy_x_2" ++ , "\thappy_x_1" ++ , "\t = case happyOutTok happy_x_2 of { (TokenInfo happy_var_2 TokId) -> " ++ , "\tcase happyOut18 happy_x_3 of { happy_var_3 -> " ++ , "\thappyIn17" ++ , "\t\t (TokenName happy_var_2 happy_var_3 False" ++ , "\t)}}" ++ , "" ++ , "happyReduce_30 = happySpecReduce_3 13# happyReduction_30" ++ , "happyReduction_30 happy_x_3" ++ , "\thappy_x_2" ++ , "\thappy_x_1" ++ , "\t = case happyOutTok happy_x_2 of { (TokenInfo happy_var_2 TokId) -> " ++ , "\tcase happyOut18 happy_x_3 of { happy_var_3 -> " ++ , "\thappyIn17" ++ , "\t\t (TokenName happy_var_2 happy_var_3 True" ++ , "\t)}}" ++ , "" ++ , "happyReduce_31 = happySpecReduce_1 13# happyReduction_31" ++ , "happyReduction_31 happy_x_1" ++ , "\t = happyIn17" ++ , "\t\t (TokenImportedIdentity" ++ , "\t)" ++ , "" ++ , "happyReduce_32 = happySpecReduce_3 13# happyReduction_32" ++ , "happyReduction_32 happy_x_3" ++ , "\thappy_x_2" ++ , "\thappy_x_1" ++ , "\t = case happyOutTok happy_x_2 of { (TokenInfo happy_var_2 TokCodeQuote) -> " ++ , "\tcase happyOutTok happy_x_3 of { (TokenInfo happy_var_3 TokCodeQuote) -> " ++ , "\thappyIn17" ++ , "\t\t (TokenLexer happy_var_2 happy_var_3" ++ , "\t)}}" ++ , "" ++ , "happyReduce_33 = happySpecReduce_2 13# happyReduction_33" ++ , "happyReduction_33 happy_x_2" ++ , "\thappy_x_1" ++ , "\t = case happyOutTok happy_x_2 of { (TokenInfo happy_var_2 TokCodeQuote) -> " ++ , "\thappyIn17" ++ , "\t\t (TokenMonad \"()\" happy_var_2 \">>=\" \"return\"" ++ , "\t)}" ++ , "" ++ , "happyReduce_34 = happySpecReduce_3 13# happyReduction_34" ++ , "happyReduction_34 happy_x_3" ++ , "\thappy_x_2" ++ , "\thappy_x_1" ++ , "\t = case happyOutTok happy_x_2 of { (TokenInfo happy_var_2 TokCodeQuote) -> " ++ , "\tcase happyOutTok happy_x_3 of { (TokenInfo happy_var_3 TokCodeQuote) -> " ++ , "\thappyIn17" ++ , "\t\t (TokenMonad happy_var_2 happy_var_3 \">>=\" \"return\"" ++ , "\t)}}" ++ , "" ++ , "happyReduce_35 = happyReduce 4# 13# happyReduction_35" ++ , "happyReduction_35 (happy_x_4 `HappyStk`" ++ , "\thappy_x_3 `HappyStk`" ++ , "\thappy_x_2 `HappyStk`" ++ , "\thappy_x_1 `HappyStk`" ++ , "\thappyRest)" ++ , "\t = case happyOutTok happy_x_2 of { (TokenInfo happy_var_2 TokCodeQuote) -> " ++ , "\tcase happyOutTok happy_x_3 of { (TokenInfo happy_var_3 TokCodeQuote) -> " ++ , "\tcase happyOutTok happy_x_4 of { (TokenInfo happy_var_4 TokCodeQuote) -> " ++ , "\thappyIn17" ++ , "\t\t (TokenMonad \"()\" happy_var_2 happy_var_3 happy_var_4" ++ , "\t) `HappyStk` happyRest}}}" ++ , "" ++ , "happyReduce_36 = happyReduce 5# 13# happyReduction_36" ++ , "happyReduction_36 (happy_x_5 `HappyStk`" ++ , "\thappy_x_4 `HappyStk`" ++ , "\thappy_x_3 `HappyStk`" ++ , "\thappy_x_2 `HappyStk`" ++ , "\thappy_x_1 `HappyStk`" ++ , "\thappyRest)" ++ , "\t = case happyOutTok happy_x_2 of { (TokenInfo happy_var_2 TokCodeQuote) -> " ++ , "\tcase happyOutTok happy_x_3 of { (TokenInfo happy_var_3 TokCodeQuote) -> " ++ , "\tcase happyOutTok happy_x_4 of { (TokenInfo happy_var_4 TokCodeQuote) -> " ++ , "\tcase happyOutTok happy_x_5 of { (TokenInfo happy_var_5 TokCodeQuote) -> " ++ , "\thappyIn17" ++ , "\t\t (TokenMonad happy_var_2 happy_var_3 happy_var_4 happy_var_5" ++ , "\t) `HappyStk` happyRest}}}}" ++ , "" ++ , "happyReduce_37 = happySpecReduce_2 13# happyReduction_37" ++ , "happyReduction_37 happy_x_2" ++ , "\thappy_x_1" ++ , "\t = case happyOut21 happy_x_2 of { happy_var_2 -> " ++ , "\thappyIn17" ++ , "\t\t (TokenNonassoc happy_var_2" ++ , "\t)}" ++ , "" ++ , "happyReduce_38 = happySpecReduce_2 13# happyReduction_38" ++ , "happyReduction_38 happy_x_2" ++ , "\thappy_x_1" ++ , "\t = case happyOut21 happy_x_2 of { happy_var_2 -> " ++ , "\thappyIn17" ++ , "\t\t (TokenRight happy_var_2" ++ , "\t)}" ++ , "" ++ , "happyReduce_39 = happySpecReduce_2 13# happyReduction_39" ++ , "happyReduction_39 happy_x_2" ++ , "\thappy_x_1" ++ , "\t = case happyOut21 happy_x_2 of { happy_var_2 -> " ++ , "\thappyIn17" ++ , "\t\t (TokenLeft happy_var_2" ++ , "\t)}" ++ , "" ++ , "happyReduce_40 = happySpecReduce_2 13# happyReduction_40" ++ , "happyReduction_40 happy_x_2" ++ , "\thappy_x_1" ++ , "\t = case happyOutTok happy_x_2 of { (TokenNum happy_var_2 TokNum) -> " ++ , "\thappyIn17" ++ , "\t\t (TokenExpect happy_var_2" ++ , "\t)}" ++ , "" ++ , "happyReduce_41 = happySpecReduce_2 13# happyReduction_41" ++ , "happyReduction_41 happy_x_2" ++ , "\thappy_x_1" ++ , "\t = case happyOutTok happy_x_2 of { (TokenInfo happy_var_2 TokCodeQuote) -> " ++ , "\thappyIn17" ++ , "\t\t (TokenError happy_var_2" ++ , "\t)}" ++ , "" ++ , "happyReduce_42 = happySpecReduce_2 13# happyReduction_42" ++ , "happyReduction_42 happy_x_2" ++ , "\thappy_x_1" ++ , "\t = case happyOutTok happy_x_2 of { (TokenInfo happy_var_2 TokCodeQuote) -> " ++ , "\thappyIn17" ++ , "\t\t (TokenAttributetype happy_var_2" ++ , "\t)}" ++ , "" ++ , "happyReduce_43 = happySpecReduce_3 13# happyReduction_43" ++ , "happyReduction_43 happy_x_3" ++ , "\thappy_x_2" ++ , "\thappy_x_1" ++ , "\t = case happyOutTok happy_x_2 of { (TokenInfo happy_var_2 TokId) -> " ++ , "\tcase happyOutTok happy_x_3 of { (TokenInfo happy_var_3 TokCodeQuote) -> " ++ , "\thappyIn17" ++ , "\t\t (TokenAttribute happy_var_2 happy_var_3" ++ , "\t)}}" ++ , "" ++ , "happyReduce_44 = happySpecReduce_1 14# happyReduction_44" ++ , "happyReduction_44 happy_x_1" ++ , "\t = case happyOutTok happy_x_1 of { (TokenInfo happy_var_1 TokId) -> " ++ , "\thappyIn18" ++ , "\t\t (Just happy_var_1" ++ , "\t)}" ++ , "" ++ , "happyReduce_45 = happySpecReduce_0 14# happyReduction_45" ++ , "happyReduction_45 = happyIn18" ++ , "\t\t (Nothing" ++ , "\t)" ++ , "" ++ , "happyReduce_46 = happySpecReduce_2 15# happyReduction_46" ++ , "happyReduction_46 happy_x_2" ++ , "\thappy_x_1" ++ , "\t = case happyOut20 happy_x_1 of { happy_var_1 -> " ++ , "\tcase happyOut19 happy_x_2 of { happy_var_2 -> " ++ , "\thappyIn19" ++ , "\t\t (happy_var_1:happy_var_2" ++ , "\t)}}" ++ , "" ++ , "happyReduce_47 = happySpecReduce_1 15# happyReduction_47" ++ , "happyReduction_47 happy_x_1" ++ , "\t = case happyOut20 happy_x_1 of { happy_var_1 -> " ++ , "\thappyIn19" ++ , "\t\t ([happy_var_1]" ++ , "\t)}" ++ , "" ++ , "happyReduce_48 = happySpecReduce_2 16# happyReduction_48" ++ , "happyReduction_48 happy_x_2" ++ , "\thappy_x_1" ++ , "\t = case happyOutTok happy_x_1 of { (TokenInfo happy_var_1 TokId) -> " ++ , "\tcase happyOutTok happy_x_2 of { (TokenInfo happy_var_2 TokCodeQuote) -> " ++ , "\thappyIn20" ++ , "\t\t ((happy_var_1,happy_var_2)" ++ , "\t)}}" ++ , "" ++ , "happyReduce_49 = happySpecReduce_2 17# happyReduction_49" ++ , "happyReduction_49 happy_x_2" ++ , "\thappy_x_1" ++ , "\t = case happyOutTok happy_x_1 of { (TokenInfo happy_var_1 TokId) -> " ++ , "\tcase happyOut21 happy_x_2 of { happy_var_2 -> " ++ , "\thappyIn21" ++ , "\t\t (happy_var_1 : happy_var_2" ++ , "\t)}}" ++ , "" ++ , "happyReduce_50 = happySpecReduce_0 17# happyReduction_50" ++ , "happyReduction_50 = happyIn21" ++ , "\t\t ([]" ++ , "\t)" ++ , "" ++ , "happyReduce_51 = happySpecReduce_1 18# happyReduction_51" ++ , "happyReduction_51 happy_x_1" ++ , "\t = case happyOutTok happy_x_1 of { (TokenInfo happy_var_1 TokCodeQuote) -> " ++ , "\thappyIn22" ++ , "\t\t (Just happy_var_1" ++ , "\t)}" ++ , "" ++ , "happyReduce_52 = happySpecReduce_0 18# happyReduction_52" ++ , "happyReduction_52 = happyIn22" ++ , "\t\t (Nothing" ++ , "\t)" ++ , "" ++ , "happyNewToken action sts stk" ++ , "\t= lexer(\\tk -> " ++ , "\tlet cont i = happyDoAction i tk action sts stk in" ++ , "\tcase tk of {" ++ , "\tTokenEOF -> happyDoAction 27# tk action sts stk;" ++ , "\tTokenInfo happy_dollar_dollar TokId -> cont 1#;" ++ , "\tTokenKW TokSpecId_TokenType -> cont 2#;" ++ , "\tTokenKW TokSpecId_Token -> cont 3#;" ++ , "\tTokenKW TokSpecId_Name -> cont 4#;" ++ , "\tTokenKW TokSpecId_Partial -> cont 5#;" ++ , "\tTokenKW TokSpecId_Lexer -> cont 6#;" ++ , "\tTokenKW TokSpecId_ImportedIdentity -> cont 7#;" ++ , "\tTokenKW TokSpecId_Monad -> cont 8#;" ++ , "\tTokenKW TokSpecId_Nonassoc -> cont 9#;" ++ , "\tTokenKW TokSpecId_Left -> cont 10#;" ++ , "\tTokenKW TokSpecId_Right -> cont 11#;" ++ , "\tTokenKW TokSpecId_Prec -> cont 12#;" ++ , "\tTokenKW TokSpecId_Expect -> cont 13#;" ++ , "\tTokenKW TokSpecId_Error -> cont 14#;" ++ , "\tTokenKW TokSpecId_Attribute -> cont 15#;" ++ , "\tTokenKW TokSpecId_Attributetype -> cont 16#;" ++ , "\tTokenInfo happy_dollar_dollar TokCodeQuote -> cont 17#;" ++ , "\tTokenNum happy_dollar_dollar TokNum -> cont 18#;" ++ , "\tTokenKW TokColon -> cont 19#;" ++ , "\tTokenKW TokSemiColon -> cont 20#;" ++ , "\tTokenKW TokDoubleColon -> cont 21#;" ++ , "\tTokenKW TokDoublePercent -> cont 22#;" ++ , "\tTokenKW TokBar -> cont 23#;" ++ , "\tTokenKW TokParenL -> cont 24#;" ++ , "\tTokenKW TokParenR -> cont 25#;" ++ , "\tTokenKW TokComma -> cont 26#;" ++ , "\t_ -> happyError' tk" ++ , "\t})" ++ , "" ++ , "happyError_ tk = happyError' tk" ++ , "" ++ , "happyThen :: () => P a -> (a -> P b) -> P b" ++ , "happyThen = (>>=)" ++ , "happyReturn :: () => a -> P a" ++ , "happyReturn = (return)" ++ , "happyThen1 = happyThen" ++ , "happyReturn1 :: () => a -> P a" ++ , "happyReturn1 = happyReturn" ++ , "happyError' :: () => (Token) -> P a" ++ , "happyError' tk = (\\token -> happyError) tk" ++ , "" ++ , "ourParser = happySomeParser where" ++ , " happySomeParser = happyThen (happyParse 0#) (\\x -> happyReturn (happyOut4 x))" ++ , "" ++ , "happySeq = happyDontSeq" ++ , "" ++ , "" ++ , "happyError :: P a" ++ , "happyError = lineP >>= \\l -> fail (show l ++ \": Parse error\\n\")" ++ , "{-# LINE 1 \"templates/GenericTemplate.hs\" #-}" ++ , "{-# LINE 1 \"templates/GenericTemplate.hs\" #-}" ++ , "{-# LINE 1 \"\" #-}" ++ , "{-# LINE 1 \"\" #-}" ++ , "{-# LINE 1 \"templates/GenericTemplate.hs\" #-}" ++ , "-- Id: GenericTemplate.hs,v 1.26 2005/01/14 14:47:22 simonmar Exp " ++ , "" ++ , "{-# LINE 30 \"templates/GenericTemplate.hs\" #-}" ++ , "" ++ , "" ++ , "data Happy_IntList = HappyCons Happy_GHC_Exts.Int# Happy_IntList" ++ , "" ++ , "" ++ , "" ++ , "" ++ , "" ++ , "{-# LINE 51 \"templates/GenericTemplate.hs\" #-}" ++ , "" ++ , "{-# LINE 61 \"templates/GenericTemplate.hs\" #-}" ++ , "" ++ , "{-# LINE 70 \"templates/GenericTemplate.hs\" #-}" ++ , "" ++ , "infixr 9 `HappyStk`" ++ , "data HappyStk a = HappyStk a (HappyStk a)" ++ , "" ++ , "-----------------------------------------------------------------------------" ++ , "-- starting the parse" ++ , "" ++ , "happyParse start_state = happyNewToken start_state notHappyAtAll notHappyAtAll" ++ , "" ++ , "-----------------------------------------------------------------------------" ++ , "-- Accepting the parse" ++ , "" ++ , "-- If the current token is 0#, it means we've just accepted a partial" ++ , "-- parse (a %partial parser). We must ignore the saved token on the top of" ++ , "-- the stack in this case." ++ , "happyAccept 0# tk st sts (_ `HappyStk` ans `HappyStk` _) =" ++ , "\thappyReturn1 ans" ++ , "happyAccept j tk st sts (HappyStk ans _) = " ++ , "\t(happyTcHack j (happyTcHack st)) (happyReturn1 ans)" ++ , "" ++ , "-----------------------------------------------------------------------------" ++ , "-- Arrays only: do the next action" ++ , "" ++ , "" ++ , "" ++ , "happyDoAction i tk st" ++ , "\t= {- nothing -}" ++ , "" ++ , "" ++ , "\t case action of" ++ , "\t\t0#\t\t -> {- nothing -}" ++ , "\t\t\t\t happyFail i tk st" ++ , "\t\t-1# \t -> {- nothing -}" ++ , "\t\t\t\t happyAccept i tk st" ++ , "\t\tn | (n Happy_GHC_Exts.<# (0# :: Happy_GHC_Exts.Int#)) -> {- nothing -}" ++ , "" ++ , "\t\t\t\t (happyReduceArr Happy_Data_Array.! rule) i tk st" ++ , "\t\t\t\t where rule = (Happy_GHC_Exts.I# ((Happy_GHC_Exts.negateInt# ((n Happy_GHC_Exts.+# (1# :: Happy_GHC_Exts.Int#))))))" ++ , "\t\tn\t\t -> {- nothing -}" ++ , "" ++ , "" ++ , "\t\t\t\t happyShift new_state i tk st" ++ , "\t\t\t\t where (new_state) = (n Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#))" ++ , " where (off) = indexShortOffAddr happyActOffsets st" ++ , " (off_i) = (off Happy_GHC_Exts.+# i)" ++ , "\t check = if (off_i Happy_GHC_Exts.>=# (0# :: Happy_GHC_Exts.Int#))" ++ , "\t\t\tthen (indexShortOffAddr happyCheck off_i Happy_GHC_Exts.==# i)" ++ , "\t\t\telse False" ++ , " (action)" ++ , " | check = indexShortOffAddr happyTable off_i" ++ , " | otherwise = indexShortOffAddr happyDefActions st" ++ , "" ++ , "{-# LINE 130 \"templates/GenericTemplate.hs\" #-}" ++ , "" ++ , "" ++ , "indexShortOffAddr (HappyA# arr) off =" ++ , "\tHappy_GHC_Exts.narrow16Int# i" ++ , " where" ++ , " i = Happy_GHC_Exts.word2Int# (Happy_GHC_Exts.or# (Happy_GHC_Exts.uncheckedShiftL# high 8#) low)" ++ , " high = Happy_GHC_Exts.int2Word# (Happy_GHC_Exts.ord# (Happy_GHC_Exts.indexCharOffAddr# arr (off' Happy_GHC_Exts.+# 1#)))" ++ , " low = Happy_GHC_Exts.int2Word# (Happy_GHC_Exts.ord# (Happy_GHC_Exts.indexCharOffAddr# arr off'))" ++ , " off' = off Happy_GHC_Exts.*# 2#" ++ , "" ++ , "" ++ , "" ++ , "" ++ , "" ++ , "data HappyAddr = HappyA# Happy_GHC_Exts.Addr#" ++ , "" ++ , "" ++ , "" ++ , "" ++ , "-----------------------------------------------------------------------------" ++ , "-- HappyState data type (not arrays)" ++ , "" ++ , "{-# LINE 163 \"templates/GenericTemplate.hs\" #-}" ++ , "" ++ , "-----------------------------------------------------------------------------" ++ , "-- Shifting a token" ++ , "" ++ , "happyShift new_state 0# tk st sts stk@(x `HappyStk` _) =" ++ , " let (i) = (case Happy_GHC_Exts.unsafeCoerce# x of { (Happy_GHC_Exts.I# (i)) -> i }) in" ++ , "-- trace \"shifting the error token\" $" ++ , " happyDoAction i tk new_state (HappyCons (st) (sts)) (stk)" ++ , "" ++ , "happyShift new_state i tk st sts stk =" ++ , " happyNewToken new_state (HappyCons (st) (sts)) ((happyInTok (tk))`HappyStk`stk)" ++ , "" ++ , "-- happyReduce is specialised for the common cases." ++ , "" ++ , "happySpecReduce_0 i fn 0# tk st sts stk" ++ , " = happyFail 0# tk st sts stk" ++ , "happySpecReduce_0 nt fn j tk st@((action)) sts stk" ++ , " = happyGoto nt j tk st (HappyCons (st) (sts)) (fn `HappyStk` stk)" ++ , "" ++ , "happySpecReduce_1 i fn 0# tk st sts stk" ++ , " = happyFail 0# tk st sts stk" ++ , "happySpecReduce_1 nt fn j tk _ sts@((HappyCons (st@(action)) (_))) (v1`HappyStk`stk')" ++ , " = let r = fn v1 in" ++ , " happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk'))" ++ , "" ++ , "happySpecReduce_2 i fn 0# tk st sts stk" ++ , " = happyFail 0# tk st sts stk" ++ , "happySpecReduce_2 nt fn j tk _ (HappyCons (_) (sts@((HappyCons (st@(action)) (_))))) (v1`HappyStk`v2`HappyStk`stk')" ++ , " = let r = fn v1 v2 in" ++ , " happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk'))" ++ , "" ++ , "happySpecReduce_3 i fn 0# tk st sts stk" ++ , " = happyFail 0# tk st sts stk" ++ , "happySpecReduce_3 nt fn j tk _ (HappyCons (_) ((HappyCons (_) (sts@((HappyCons (st@(action)) (_))))))) (v1`HappyStk`v2`HappyStk`v3`HappyStk`stk')" ++ , " = let r = fn v1 v2 v3 in" ++ , " happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk'))" ++ , "" ++ , "happyReduce k i fn 0# tk st sts stk" ++ , " = happyFail 0# tk st sts stk" ++ , "happyReduce k nt fn j tk st sts stk" ++ , " = case happyDrop (k Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) sts of" ++ , "\t sts1@((HappyCons (st1@(action)) (_))) ->" ++ , " \tlet r = fn stk in -- it doesn't hurt to always seq here..." ++ , " \t\thappyDoSeq r (happyGoto nt j tk st1 sts1 r)" ++ , "" ++ , "happyMonadReduce k nt fn 0# tk st sts stk" ++ , " = happyFail 0# tk st sts stk" ++ , "happyMonadReduce k nt fn j tk st sts stk =" ++ , " happyThen1 (fn stk tk) (\\r -> happyGoto nt j tk st1 sts1 (r `HappyStk` drop_stk))" ++ , " where (sts1@((HappyCons (st1@(action)) (_)))) = happyDrop k (HappyCons (st) (sts))" ++ , " drop_stk = happyDropStk k stk" ++ , "" ++ , "happyMonad2Reduce k nt fn 0# tk st sts stk" ++ , " = happyFail 0# tk st sts stk" ++ , "happyMonad2Reduce k nt fn j tk st sts stk =" ++ , " happyThen1 (fn stk tk) (\\r -> happyNewToken new_state sts1 (r `HappyStk` drop_stk))" ++ , " where (sts1@((HappyCons (st1@(action)) (_)))) = happyDrop k (HappyCons (st) (sts))" ++ , " drop_stk = happyDropStk k stk" ++ , "" ++ , " (off) = indexShortOffAddr happyGotoOffsets st1" ++ , " (off_i) = (off Happy_GHC_Exts.+# nt)" ++ , " (new_state) = indexShortOffAddr happyTable off_i" ++ , "" ++ , "" ++ , "" ++ , "" ++ , "happyDrop 0# l = l" ++ , "happyDrop n (HappyCons (_) (t)) = happyDrop (n Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) t" ++ , "" ++ , "happyDropStk 0# l = l" ++ , "happyDropStk n (x `HappyStk` xs) = happyDropStk (n Happy_GHC_Exts.-# (1#::Happy_GHC_Exts.Int#)) xs" ++ , "" ++ , "-----------------------------------------------------------------------------" ++ , "-- Moving to a new state after a reduction" ++ , "" ++ , "" ++ , "happyGoto nt j tk st = " ++ , " {- nothing -}" ++ , " happyDoAction j tk new_state" ++ , " where (off) = indexShortOffAddr happyGotoOffsets st" ++ , " (off_i) = (off Happy_GHC_Exts.+# nt)" ++ , " (new_state) = indexShortOffAddr happyTable off_i" ++ , "" ++ , "" ++ , "" ++ , "" ++ , "-----------------------------------------------------------------------------" ++ , "-- Error recovery (0# is the error token)" ++ , "" ++ , "-- parse error if we are in recovery and we fail again" ++ , "happyFail 0# tk old_st _ stk =" ++ , "--\ttrace \"failing\" $ " ++ , " \thappyError_ tk" ++ , "" ++ , "{- We don't need state discarding for our restricted implementation of" ++ , " \"error\". In fact, it can cause some bogus parses, so I've disabled it" ++ , " for now --SDM" ++ , "" ++ , "-- discard a state" ++ , "happyFail 0# tk old_st (HappyCons ((action)) (sts)) " ++ , "\t\t\t\t\t\t(saved_tok `HappyStk` _ `HappyStk` stk) =" ++ , "--\ttrace (\"discarding state, depth \" ++ show (length stk)) $" ++ , "\thappyDoAction 0# tk action sts ((saved_tok`HappyStk`stk))" ++ , "-}" ++ , "" ++ , "-- Enter error recovery: generate an error token," ++ , "-- save the old token and carry on." ++ , "happyFail i tk (action) sts stk =" ++ , "-- trace \"entering error recovery\" $" ++ , "\thappyDoAction 0# tk action sts ( (Happy_GHC_Exts.unsafeCoerce# (Happy_GHC_Exts.I# (i))) `HappyStk` stk)" ++ , "" ++ , "-- Internal happy errors:" ++ , "" ++ , "notHappyAtAll :: a" ++ , "notHappyAtAll = error \"Internal Happy error\\n\"" ++ , "" ++ , "-----------------------------------------------------------------------------" ++ , "-- Hack to get the typechecker to accept our action functions" ++ , "" ++ , "" ++ , "happyTcHack :: Happy_GHC_Exts.Int# -> a -> a" ++ , "happyTcHack x y = y" ++ , "{-# INLINE happyTcHack #-}" ++ , "" ++ , "" ++ , "-----------------------------------------------------------------------------" ++ , "-- Seq-ing. If the --strict flag is given, then Happy emits " ++ , "--\thappySeq = happyDoSeq" ++ , "-- otherwise it emits" ++ , "-- \thappySeq = happyDontSeq" ++ , "" ++ , "happyDoSeq, happyDontSeq :: a -> b -> b" ++ , "happyDoSeq a b = a `seq` b" ++ , "happyDontSeq a b = b" ++ , "" ++ , "-----------------------------------------------------------------------------" ++ , "-- Don't inline any functions from the template. GHC has a nasty habit" ++ , "-- of deciding to inline happyGoto everywhere, which increases the size of" ++ , "-- the generated parser quite a bit." ++ , "" ++ , "" ++ , "{-# NOINLINE happyDoAction #-}" ++ , "{-# NOINLINE happyTable #-}" ++ , "{-# NOINLINE happyCheck #-}" ++ , "{-# NOINLINE happyActOffsets #-}" ++ , "{-# NOINLINE happyGotoOffsets #-}" ++ , "{-# NOINLINE happyDefActions #-}" ++ , "" ++ , "{-# NOINLINE happyShift #-}" ++ , "{-# NOINLINE happySpecReduce_0 #-}" ++ , "{-# NOINLINE happySpecReduce_1 #-}" ++ , "{-# NOINLINE happySpecReduce_2 #-}" ++ , "{-# NOINLINE happySpecReduce_3 #-}" ++ , "{-# NOINLINE happyReduce #-}" ++ , "{-# NOINLINE happyMonadReduce #-}" ++ , "{-# NOINLINE happyGoto #-}" ++ , "{-# NOINLINE happyFail #-}" ++ , "" ++ , "-- end of Happy Template." ] ++ + \end{code} hunk ./series 1 -dependency.patch +notsoclean.diff