Eliminate trailing whitespace
authorMatthew Pickering <matthewtpickering@gmail.com>
Sat, 16 Jun 2018 16:37:26 +0000 (12:37 -0400)
committerBen Gamari <ben@smart-cactus.org>
Sat, 16 Jun 2018 16:37:26 +0000 (12:37 -0400)
Reviewers: michalt, bgamari, O26 nofib, goldfire

Reviewed By: michalt, O26 nofib

Differential Revision: https://phabricator.haskell.org/D4045

421 files changed:
gc/cacheprof/Arch_x86.hs
gc/cacheprof/Generics.hs
gc/cacheprof/Main.hs
gc/circsim/Main.lhs
gc/constraints/Main.hs
gc/fibheaps/Main.lhs
gc/fulsom/Csg.hs
gc/fulsom/Interval.hs
gc/fulsom/Kolor.hs
gc/fulsom/Main.hs
gc/fulsom/Matrix.hs
gc/fulsom/Oct.hs
gc/fulsom/Patchlevel.hs
gc/fulsom/Quad.hs
gc/fulsom/Raster.hs
gc/fulsom/Shapes.hs
gc/fulsom/Types.hs
gc/fulsom/Vector.hs
gc/gc_bench/gc_bench.hs
gc/happy/AbsSyn.lhs
gc/happy/AttrGrammar.lhs
gc/happy/AttrGrammarParser.hs
gc/happy/First.lhs
gc/happy/GenUtils.lhs
gc/happy/Grammar.lhs
gc/happy/Info.lhs
gc/happy/LALR.lhs
gc/happy/Lexer.lhs
gc/happy/Parser.hs
gc/happy/ProduceCode.lhs
gc/happy/ProduceGLRCode.lhs
gc/happy/Set.hs
gc/happy/TestInput.hs
gc/happy/happy.lhs
gc/hash/HashTable.hs
gc/lcss/Main.hs
gc/linear/AbsCg.lhs
gc/linear/AbsDensematrix.lhs
gc/linear/Cg.lhs
gc/linear/Densematrix.lhs
gc/linear/Input.lhs
gc/linear/Matlib.lhs
gc/linear/Matrix.lhs
gc/linear/Misc.lhs
gc/linear/Utils.lhs
gc/linear/linear.lhs
gc/mutstore1/Main.hs
gc/mutstore2/Main.hs
gc/power/Main.hs
gc/treejoin/Main.hs
imaginary/bernouilli/Main.hs
imaginary/digits-of-e1/Main.lhs
imaginary/digits-of-e2/Main.lhs
imaginary/exp3_8/Main.hs
imaginary/gen_regexps/Main.hs
imaginary/integrate/Main.hs
imaginary/paraffins/Main.hs
imaginary/tak/Main.hs
imaginary/wheel-sieve1/Main.hs
imaginary/wheel-sieve2/Main.hs
nofib-analyse/Main.hs
nofib-analyse/Slurp.hs
parallel/OLD/NESL/GranRandom.hs
parallel/OLD/NESL/Strategies.lhs
parallel/OLD/NESL/fft.lhs
parallel/OLD/NESL/integrate.lhs
parallel/OLD/NESL/matrix-inverse.lhs
parallel/OLD/NESL/quick_hull.lhs
parallel/OLD/NESL/sieve.lhs
parallel/OLD/bom/GranRandom.hs
parallel/OLD/bom/Strategies.lhs
parallel/OLD/bom/bom.hs
parallel/OLD/bom/dateNaiveAhead.hs
parallel/OLD/bom/dateNaiveChunk.hs
parallel/OLD/parfact/parfact.hs
parallel/OLD/soda/Main.hs
parallel/OLD/soda7/Main.hs
parallel/blackscholes/blackscholes.hs
parallel/cfd/C_matrix.hs
parallel/cfd/Data8.hs
parallel/cfd/Gen_net.hs
parallel/cfd/S_Array.hs
parallel/coins/coins.hs
parallel/dcbm/DCBM.hs
parallel/dcbm/Fwif.hs
parallel/dcbm/Types.hs
parallel/gray/Data.hs
parallel/gray/Eval.hs
parallel/gray/Geometry.hs
parallel/gray/Illumination.hs
parallel/gray/Intersections.hs
parallel/gray/Parse.hs
parallel/linsolv/CRA.hs
parallel/linsolv/Main.hs
parallel/linsolv/Matrix.hs
parallel/linsolv/ModArithm.hs
parallel/matmult/MatMult.hs
parallel/minimax/Board.hs
parallel/minimax/Game.hs
parallel/minimax/Prog.hs
parallel/minimax/Wins.hs
parallel/nbody/nbody.hs
parallel/partak/Main.hs
parallel/partree/Tree.hs
parallel/partree/partree.hs
parallel/queens/Main.hs
parallel/ray/Main.lhs
parallel/sumeuler/SumEuler.hs
parallel/transclos/Main.hs
parallel/transclos/TransClos.hs
parallel/warshall/warshall.hs
real/anna/AbsConc3.hs
real/anna/AbstractEval2.hs
real/anna/AbstractMisc.hs
real/anna/AbstractVals2.hs
real/anna/Apply.hs
real/anna/BarakiConc3.hs
real/anna/BarakiMeet.hs
real/anna/BaseDefs.hs
real/anna/Constructors.hs
real/anna/Dependancy.hs
real/anna/DomainExpr.hs
real/anna/EtaAbstract.hs
real/anna/FrontierDATAFN2.hs
real/anna/FrontierGENERIC2.hs
real/anna/FrontierMisc2.hs
real/anna/Inverse.hs
real/anna/LambdaLift5.hs
real/anna/Main.hs
real/anna/MakeDomains.hs
real/anna/Monster.hs
real/anna/MyUtils.hs
real/anna/Parser2.hs
real/anna/PrettyPrint.hs
real/anna/PrintResults.hs
real/anna/ReadTable.hs
real/anna/Simplify.hs
real/anna/SmallerLattice.hs
real/anna/StrictAn6.hs
real/anna/SuccsAndPreds2.hs
real/anna/TExpr2DExpr.hs
real/anna/TypeCheck5.hs
real/anna/Utils.hs
real/bspt/BSPT.lhs
real/bspt/Euclid.lhs
real/bspt/EuclidGMS.lhs
real/bspt/GeomNum.lhs
real/bspt/Init.lhs
real/bspt/Input.lhs
real/bspt/Interface.lhs
real/bspt/Interpret.lhs
real/bspt/Libfuns.lhs
real/bspt/MGRlib.lhs
real/bspt/Merge.lhs
real/bspt/Params.lhs
real/bspt/Prog.lhs
real/bspt/Rationals.lhs
real/bspt/Render.lhs
real/bspt/Stdlib.lhs
real/cacheprof/Arch_x86.hs
real/cacheprof/Generics.hs
real/cacheprof/Main.hs
real/compress/BinConv.hs
real/compress/Decode.hs
real/compress/Encode.hs
real/compress/Lzw.hs
real/compress/Lzw2.hs
real/compress/Main.hs
real/compress/PTTrees.hs
real/compress/Uncompress.hs
real/compress2/Encode.hs
real/compress2/Main.hs
real/fem/Assemble_loadvec.hs
real/fem/Assemble_stiffness.hs
real/fem/DB_interface.hs
real/fem/Database.hs
real/fem/Degrees.hs
real/fem/Displacement.hs
real/fem/Elemforce.hs
real/fem/Elemstif.hs
real/fem/Main.hs
real/fem/Matrix.hs
real/fem/Pre_assemble.hs
real/fem/PrintSource.hs
real/fem/Printuvwforce.hs
real/fem/VBlldecomp.hs
real/fem/VBmatrix.hs
real/fem/Vector.hs
real/fluid/C_matrix.hs
real/fluid/Chl_decomp.hs
real/fluid/Chl_method.hs
real/fluid/Chl_routs.hs
real/fluid/Elefac.hs
real/fluid/Input_proc.hs
real/fluid/Jcb_method.hs
real/fluid/Min_degree.hs
real/fulsom/Csg.hs
real/fulsom/Interval.hs
real/fulsom/Kolor.hs
real/fulsom/Main.hs
real/fulsom/Matrix.hs
real/fulsom/Oct.hs
real/fulsom/Patchlevel.hs
real/fulsom/Quad.hs
real/fulsom/Raster.hs
real/fulsom/Shapes.hs
real/fulsom/Types.hs
real/fulsom/Vector.hs
real/gamteb/Compton.hs
real/gamteb/Consts.hs
real/gamteb/Distance.hs
real/gamteb/GamtebMain.hs
real/gamteb/GamtebType.hs
real/gamteb/InitTable.hs
real/gamteb/Main.hs
real/gamteb/Output.hs
real/gamteb/Pair.hs
real/gamteb/PhotoElec.hs
real/gamteb/RoulSplit.hs
real/gamteb/TransPort.hs
real/gamteb/Utils.hs
real/gg/Activity.hs
real/gg/GRIP.hs
real/gg/Graph.hs
real/gg/Main.hs
real/gg/PSlib.hs
real/gg/Pool.hs
real/gg/Spark.hs
real/gg/StdLib.hs
real/grep/Main.lhs
real/grep/Parsers.hs
real/grep/StringMatch.hs
real/hidden/Main.hs
real/hidden/MyIO.hs
real/hpg/Env.lhs
real/hpg/GenType.lhs
real/infer/Parse.hs
real/infer/Substitution.hs
real/lift/LambdaLift.lhs
real/lift/Main.lhs
real/lift/Print.lhs
real/lift/Utilities.lhs
real/linear/AbsCg.lhs
real/linear/AbsDensematrix.lhs
real/linear/Cg.lhs
real/linear/Densematrix.lhs
real/linear/Input.lhs
real/linear/Main.lhs
real/linear/Matlib.lhs
real/linear/Matrix.lhs
real/linear/Misc.lhs
real/linear/Utils.lhs
real/maillist/Main.hs
real/mkhprog/Main.lhs
real/parser/Main.hs
real/parser/big_big_test.hs
real/pic/ChargeDensity.hs
real/pic/ElecField.hs
real/pic/Main.hs
real/pic/Pic.hs
real/pic/PicType.hs
real/pic/Potential.hs
real/pic/PushParticle.hs
real/pic/Utils.hs
real/prolog/Engine.hs
real/prolog/Interact.hs
real/prolog/Parse.hs
real/prolog/PureEngine.hs
real/prolog/StackEngine.hs
real/prolog/Subst.hs
real/reptile/Auxprogfuns.hs
real/reptile/Drawfuns.hs
real/reptile/Geomfuns.hs
real/reptile/Help.hs
real/reptile/Layout.hs
real/reptile/Main.hs
real/reptile/Mgrfuns.hs
real/reptile/Progfuns.hs
real/reptile/Psfuns.hs
real/reptile/Rational.hs
real/reptile/Tilefuns.hs
real/rsa/Main.hs
real/rsa/Rsa.hs
real/scs/Main.hs
real/scs/RandomFix.hs
real/scs/Simulate.hs
real/symalg/BasicNumber.hs
real/symalg/BasicNumberApprox.hs
real/symalg/Eval.hs
real/symalg/Lexer.hs
real/symalg/Main.hs
real/symalg/Parser.hs
real/symalg/Print.hs
real/symalg/RealM.hs
real/veritas/Auto.hs
real/veritas/Build_Tm.lhs
real/veritas/Build_itrm.lhs
real/veritas/Core_database.hs
real/veritas/Core_datatype.hs
real/veritas/Dcore.hs
real/veritas/DerivedRules.hs
real/veritas/Display.hs
real/veritas/Editor.hs
real/veritas/Edlib.lhs
real/veritas/Getops.hs
real/veritas/Goals.hs
real/veritas/Kernel.hs
real/veritas/Lookup.hs
real/veritas/Main.hs
real/veritas/Parse.lhs
real/veritas/Sub_Core1.hs
real/veritas/Sub_Core2.hs
real/veritas/Sub_Core3.hs
real/veritas/Sub_Core4.hs
real/veritas/Tacticals.hs
real/veritas/Tactics.hs
real/veritas/Tags.hs
real/veritas/ThmTactics.hs
real/veritas/Token.lhs
real/veritas/Tree.hs
real/veritas/Type_defs.lhs
real/veritas/Unparse.lhs
real/veritas/Vtslib.hs
real/veritas/X_interface.hs
shootout/binary-trees/Main.hs
shootout/fannkuch-redux/Main.hs
shootout/fasta/Main.hs
shootout/k-nucleotide/Main.hs
shootout/n-body/Main.hs
shootout/reverse-complement/Main.hs
shootout/spectral-norm/Main.hs
smp/chan/chan.hs
smp/sieve/sieve.hs
smp/stm002/StmTest2.hs
smp/systolic/Main.hs
smp/tchan/tchan.hs
smp/threads001/Main.hs
smp/threads002/Main.hs
smp/threads003/Main.hs
smp/threads004/Main.hs
smp/threads005/Main.hs
smp/threads006/Main.hs
smp/threads007/Main.hs
spectral/ansi/Main.hs
spectral/atom/Main.hs
spectral/awards/Main.hs
spectral/awards/QSort.hs
spectral/boyer/Main.lhs
spectral/boyer2/Checker.hs
spectral/boyer2/Lisplikefns.hs
spectral/boyer2/Main.hs
spectral/boyer2/Rewritefns.hs
spectral/calendar/Main.hs
spectral/cichelli/Auxil.hs
spectral/cichelli/Key.lhs
spectral/cichelli/Prog.hs
spectral/circsim/Main.lhs
spectral/clausify/Main.hs
spectral/constraints/Main.hs
spectral/cryptarithm1/Main.hs
spectral/cryptarithm2/Main.hs
spectral/cse/Main.hs
spectral/eliza/Main.hs
spectral/exact-reals/Era.hs
spectral/fft2/Complex_Vectors.lhs
spectral/fft2/Fourier.lhs
spectral/fft2/Main.lhs
spectral/fibheaps/Main.lhs
spectral/fish/Main.hs
spectral/gcd/Main.hs
spectral/hartel/comp_lab_zift/Main.hs
spectral/hartel/event/Main.hs
spectral/hartel/fft/Main.hs
spectral/hartel/genfft/Main.hs
spectral/hartel/ida/Main.hs
spectral/hartel/listcompr/Main.hs
spectral/hartel/listcopy/Main.hs
spectral/hartel/nucleic2/Main.hs
spectral/hartel/nucleic2/RA.hs
spectral/hartel/nucleic2/RC.hs
spectral/hartel/nucleic2/RG.hs
spectral/hartel/nucleic2/RU.hs
spectral/hartel/parstof/Main.hs
spectral/hartel/sched/Main.hs
spectral/hartel/solid/Main.hs
spectral/hartel/transform/Main.hs
spectral/hartel/typecheck/Main.hs
spectral/hartel/wang/Main.hs
spectral/hartel/wave4main/Main.hs
spectral/integer/Main.hs
spectral/knights/ChessSetArray.lhs
spectral/knights/ChessSetList.lhs
spectral/knights/KnightHeuristic.lhs
spectral/knights/Main.lhs
spectral/knights/Queue.lhs
spectral/knights/Sort.lhs
spectral/lambda/Main.hs
spectral/last-piece/Main.hs
spectral/lcss/Main.hs
spectral/life/Main.hs
spectral/mandel/MandelOld.lhs
spectral/mandel2/Main.hs
spectral/mate/Board.hs
spectral/mate/Main.hs
spectral/mate/Move.hs
spectral/mate/Problem.hs
spectral/mate/Solution.hs
spectral/minimax/Board.hs
spectral/minimax/Prog.hs
spectral/minimax/Wins.hs
spectral/multiplier/Main.hs
spectral/para/Main.lhs
spectral/power/Main.hs
spectral/pretty/Pretty.hs
spectral/primetest/IntLib.lhs
spectral/primetest/Main.lhs
spectral/rewrite/Main.lhs
spectral/secretary/Main.lhs
spectral/simple/Main.hs
spectral/sphere/Main.lhs
spectral/treejoin/Main.hs

index f1c4334..fc2f2f2 100644 (file)
@@ -3,11 +3,11 @@
 {--- Beginnings of X86 specific stuff                Arch_X86.hs      ---}
 {------------------------------------------------------------------------}
 
-{- 
+{-
    This file is part of Cacheprof, a profiling tool for finding
    sources of cache misses in programs.
 
-   Copyright (C) 1999 Julian Seward (jseward@acm.org) 
+   Copyright (C) 1999 Julian Seward (jseward@acm.org)
    Home page: http://www.cacheprof.org
 
    This program is free software; you can redistribute it and/or
@@ -38,11 +38,11 @@ module Arch_x86 (
 
 where
 
-data Opcode 
+data Opcode
    = O_movl | O_movw | O_movb
-   | O_movzbw | O_movzbl | O_movzwl 
-   | O_movsbw | O_movsbl | O_movswl 
-   | O_pushl | O_popl 
+   | O_movzbw | O_movzbl | O_movzwl
+   | O_movsbw | O_movsbl | O_movswl
+   | O_pushl | O_popl
    | O_pushfl | O_popfl
    | O_notl | O_notw | O_notb
    | O_sall | O_salw | O_salb
@@ -75,8 +75,8 @@ data Opcode
    | O_stosl | O_stosw | O_stosb
 
    | O_leave | O_ret | O_call | O_jmp
-   | O_je | O_jne 
-   | O_jl | O_jle 
+   | O_je | O_jne
+   | O_jl | O_jle
    | O_jg | O_jge
    | O_js | O_jns
    | O_jz | O_jnz
@@ -98,7 +98,7 @@ data Opcode
    | O_cbtw
    | O_rep | O_repz | O_repnz
    | O_fild | O_fildl | O_fildll
-   | O_fsubp | O_fsubr | O_fsubrp | O_fsubrl | O_fsubrs 
+   | O_fsubp | O_fsubr | O_fsubrp | O_fsubrl | O_fsubrs
              | O_fsubs | O_fsubl | O_fsub
    | O_faddp | O_fadds | O_faddl | O_fadd | O_fiaddl
    | O_fmul | O_fmuls | O_fmull | O_fmulp
@@ -130,7 +130,7 @@ data Opcode
 
 
 x86info :: [(Opcode, OperandInfo)]
-x86info 
+x86info
   = [
       (O_movl,    OI [OE_RW 4 4]),
       (O_movw,    OI [OE_RW 2 2]),
@@ -430,8 +430,8 @@ nonJumpyOpcodes
         ,O_shrl ,O_shrw ,O_shrb
         ,O_sarl
         ,O_leal
-        ,O_movzbw ,O_movzbl ,O_movzwl 
-        ,O_movsbw ,O_movsbl ,O_movswl 
+        ,O_movzbw ,O_movzbl ,O_movzwl
+        ,O_movsbw ,O_movsbl ,O_movswl
 
         , O_seta , O_setae
         , O_setb , O_setbe
index f169700..ff86b6f 100644 (file)
@@ -3,11 +3,11 @@
 {--- Generic stuff for all architectures.                 Generics.hs ---}
 {------------------------------------------------------------------------}
 
-{- 
+{-
    This file is part of Cacheprof, a profiling tool for finding
    sources of cache misses in programs.
 
-   Copyright (C) 1999 Julian Seward (jseward@acm.org) 
+   Copyright (C) 1999 Julian Seward (jseward@acm.org)
    Home page: http://www.cacheprof.org
 
    This program is free software; you can redistribute it and/or
@@ -33,7 +33,7 @@ module Generics where
 internal msg
    = error ("\ncacheann: Internal error: " ++ msg ++ "\n")
 incomplete msg
-   = error ("\ncacheann: Unhandled instruction set artefact:\n   " 
+   = error ("\ncacheann: Unhandled instruction set artefact:\n   "
             ++ msg ++ "\n")
 inputerr msg
    = error ("\ncacheann: Bad input: " ++ msg ++ "\n")
@@ -105,14 +105,14 @@ pApply f p ts
    = case p ts of
         PFail -> PFail
         POk x uu -> POk (f x) uu
-   
+
 
 pName :: String -> a -> Parser a
 pName w x ((LName w2):lxs)
    = if w == w2 then POk x lxs else PFail
 pName w x _ = PFail
 
-p2 :: (a -> b -> c) 
+p2 :: (a -> b -> c)
       -> Parser a -> Parser b -> Parser c
 p2 f p1 p2 ts1
    = case p1 ts1 of { PFail -> PFail ; POk x1 uu1 ->
@@ -120,7 +120,7 @@ p2 f p1 p2 ts1
      POk (f x1 x2) uu2
      }}
 
-p3 :: (a -> b -> c -> d) 
+p3 :: (a -> b -> c -> d)
       -> Parser a -> Parser b -> Parser c -> Parser d
 p3 f p1 p2 p3 ts1
    = case p1 ts1 of { PFail -> PFail ; POk x1 uu1 ->
index 7964034..b19868d 100644 (file)
@@ -4,7 +4,7 @@
 {---                                                      CacheAnn.hs ---}
 {------------------------------------------------------------------------}
 
-{- 
+{-
    This file is part of Cacheprof, a profiling tool for finding
    sources of cache misses in programs.
 
@@ -51,7 +51,7 @@ import Generics
 --    an instruction (Real)
 --    anything else (Pseudo)
 -- If instruction counting is to work properly,
--- labels should not be concealed inside Pseudos. 
+-- labels should not be concealed inside Pseudos.
 
 data PreLine
    = PrePseudo Int String
@@ -66,17 +66,17 @@ instance PP PreLine where
 
 -- section-main
 preparse :: String -> [PreLine]
-preparse  
+preparse
    = concatMap preparseLine . zip [1..] . lines
 
 
 preparseLine :: (Int, String) -> [PreLine]
 preparseLine (line_number,s)
-   | null cleaned 
+   | null cleaned
    = []
    | looks_like_label cleaned
    = case span isLabelIsh cleaned of
-        (label_name, rest) 
+        (label_name, rest)
            -> (PreLabel line_number (label_name ++ [head rest]))
               : preparseLine (line_number, tail rest)
    | head cleaned `elem` ".#"
@@ -92,12 +92,12 @@ preparseLine (line_number,s)
         untabbed x = not (null x) && head x /= '\t'
 
         looks_like_label :: String -> Bool
-        looks_like_label x 
+        looks_like_label x
            = case span isLabelIsh x of
-                (label_name, rest) 
-                   -> not (null label_name) 
+                (label_name, rest)
+                   -> not (null label_name)
                       && take 1 rest == ":"
-                      && (null (tail rest) 
+                      && (null (tail rest)
                           || isSpace (head (tail rest)))
 
 
@@ -108,7 +108,7 @@ preparseLine (line_number,s)
 -- Turn the list of PreLines into Lines by parsing
 -- the instructions.
 
-data PPM 
+data PPM
    = PPM_Debug | PPM_User
      deriving Eq
 
@@ -123,7 +123,7 @@ class PP a where
    ppl m = concat . intersperse "," . map (pp m)
 
 
-data Line 
+data Line
    = Pseudo Int String
    | Label  Int String
    | Real   Int CC Insn
@@ -135,11 +135,11 @@ instance PP Line where
    pp PPM_User  (Label ln s)      = s
    pp PPM_Debug (Label ln s)      = "L: " ++ s
 
-   pp PPM_User  (Real ln cc insn) 
+   pp PPM_User  (Real ln cc insn)
       = "\t" ++ pp PPM_User insn
-   pp PPM_Debug (Real ln cc insn) 
+   pp PPM_Debug (Real ln cc insn)
       = "R:        " ++ pp PPM_Debug insn ++
-       if   isNoCC cc 
+       if   isNoCC cc
        then ""
        else "\n             CC = " ++ pp PPM_Debug cc
 
@@ -183,20 +183,20 @@ ccGetFuncNm (CC filenm ln funcnm) = funcnm
 
 -- section-main
 parse :: [PreLine] -> [Line]
-parse 
+parse
    = map f
-     where 
+     where
         f (PrePseudo ln s) = Pseudo ln s
         f (PreLabel  ln s) = Label  ln s
         f (PreReal   ln s)
            = case pInsn (olex s) of
                 POk i [] -> Real ln NoCC i
                 _        -> bomb ln s
-   
+
         bomb ln s
            = inputerr ("(stdin):" ++ show ln
                        ++ ": syntax error on `" ++ s ++ "'\n" )
+
 
 {-------------------------------------------}
 {--- an lexer for x86,                   ---}
@@ -218,9 +218,9 @@ olex (c:cs)
    | c == '#'  = []   -- comment; arch specific
 
    | c == '%'
-   = case span isAlpha cs of 
+   = case span isAlpha cs of
         (rname, rest)
-           | rname == "st" && not (null rest) 
+           | rname == "st" && not (null rest)
              && head rest == '('
            -> case span (`elem` "(01234567)") rest of
                  (frname,rest2) -> (LReg (c:rname++frname)) : olex rest2
@@ -229,7 +229,7 @@ olex (c:cs)
            | otherwise
            -> barf (c:cs)
    | isDigit c
-   = case span isDigitish cs of 
+   = case span isDigitish cs of
         (num, rest) -> (LNum (c:num)) : olex rest
    | isAlpha c || c == '_'
    = case span isNameIsh cs of
@@ -265,9 +265,9 @@ barf s = inputerr ( "lexical error on: `" ++ s ++ "'")
    amode ::= (reg)          -- B
            | (reg,reg)      -- B I
            | (,reg,num)     -- I S
-           | (reg,reg,num)  -- B I S 
+           | (reg,reg,num)  -- B I S
 
-   const  ::= (OPTIONAL '-') const_factor 
+   const  ::= (OPTIONAL '-') const_factor
                              (ZEROORMORE signed_const_factor)
 
    signed_const_factor ::=   + const_factor
@@ -315,7 +315,7 @@ getAnns (SomeAnns anns) = anns
 isDontAnnMe DontAnnMe = True
 isDontAnnMe _         = False
 
-data Insn 
+data Insn
    = Insn Anns Opcode [Operand]
      deriving (Show, Eq)
 
@@ -332,7 +332,7 @@ data Operand
      deriving (Show, Eq)
 
 data AMode
-   = AM_B   Reg  
+   = AM_B   Reg
    | AM_BI  Reg Reg
    | AM_IS  Reg String
    | AM_BIS Reg Reg String
@@ -340,7 +340,7 @@ data AMode
 
 
 
-newtype Const 
+newtype Const
    = Const [SignedFactor]
      deriving (Show, Eq)
 
@@ -348,18 +348,18 @@ data SignedFactor  = Neg UnsignedFactor | Pos UnsignedFactor
      deriving (Show, Eq)
 
 data UnsignedFactor
-   = UF_NUM String  
-   | UF_NAME String 
+   = UF_NUM String
+   | UF_NAME String
    | UF_LABEL String
    | UF_TIMES UnsignedFactor UnsignedFactor
      deriving (Show, Eq)
 
-data Reg 
+data Reg
    = EAX | EBX | ECX | EDX | EDI | ESI | EBP | ESP
    | AX | BX | CX | DX | SI | DI | BP
    | AL | BL | CL | DL
    | AH | BH | CH | DH
-   | ST_0 | ST_1 | ST_2 | ST_3 
+   | ST_0 | ST_1 | ST_2 | ST_3
    | ST_4 | ST_5 | ST_6 | ST_7
      deriving (Show, Eq)
 
@@ -368,7 +368,7 @@ pOpcode
    = pAlts (map (\o -> pName (drop 2 (show (fst o))) (fst o)) x86info)
 
 pInsn :: Parser Insn
-pInsn 
+pInsn
    = p2 (Insn (SomeAnns [])) pOpcode (pStarComma pOperand)
 
 pOperand :: Parser Operand
@@ -421,7 +421,7 @@ pConst
    = pAlts [
         p2 (\  ca cas -> Const ((Pos ca):cas))
            pUnsignedF (pStar pSignedF),
-        p3 (\_ ca cas -> Const ((Neg ca):cas)) 
+        p3 (\_ ca cas -> Const ((Neg ca):cas))
            pLMinus pUnsignedF (pStar pSignedF)
      ]
 
@@ -444,14 +444,14 @@ reg_map
    = [("%eax",EAX),("%ebx",EBX),("%ecx",ECX),("%edx",EDX),
       ("%edi",EDI),("%esi",ESI),("%ebp",EBP),("%esp",ESP),
 
-      ("%ax",AX), ("%bx",BX), ("%cx",CX), ("%dx",DX), 
+      ("%ax",AX), ("%bx",BX), ("%cx",CX), ("%dx",DX),
       ("%si",SI), ("%di",DI), ("%bp",BP),
 
       ("%al",AL), ("%bl",BL), ("%cl",CL), ("%dl",DL),
       ("%ah",AH), ("%bh",BH), ("%ch",CH), ("%dh",DH),
 
-      ("%st", ST_0), ("%st(0)", ST_0), 
-      ("%st(1)", ST_1), ("%st(2)", ST_2), ("%st(3)", ST_3), 
+      ("%st", ST_0), ("%st(0)", ST_0),
+      ("%st(1)", ST_1), ("%st(2)", ST_2), ("%st(3)", ST_3),
       ("%st(4)", ST_4), ("%st(5)", ST_5), ("%st(6)", ST_6),
       ("%st(7)", ST_7)
      ]
@@ -464,20 +464,20 @@ reg_names
 
 instance PP Insn where
    pp ppm insn@(Insn ann opcode operands)
-      = main_part 
+      = main_part
         ++ (if   ppm == PPM_User
                  || null (getAnns ann)
-            then [] 
+            then []
             else take (max 0 (36 - length main_part)) (repeat ' ')
-                 ++ (if hasRealAnns insn 
-                     then " # ANN " else " #     ") 
+                 ++ (if hasRealAnns insn
+                     then " # ANN " else " #     ")
                  ++ ppl ppm (getAnns ann)
            )
         where
            main_part
-              = pp ppm opcode 
-                ++ (if   null operands 
-                    then [] 
+              = pp ppm opcode
+                ++ (if   null operands
+                    then []
                     else " " ++ ppl ppm operands)
 
 instance PP Annot where
@@ -499,7 +499,7 @@ instance PP AMode where
    pp ppm (AM_B r1)        = paren (pp ppm r1)
    pp ppm (AM_BI r1 r2)    = paren (pp ppm r1 ++ "," ++ pp ppm r2)
    pp ppm (AM_IS r1  n)    = paren ("," ++ pp ppm r1 ++ "," ++ n)
-   pp ppm (AM_BIS r1 r2 n) 
+   pp ppm (AM_BIS r1 r2 n)
       = paren (pp ppm r1 ++ "," ++ pp ppm r2 ++ "," ++ n)
 
 instance PP Const where
@@ -550,7 +550,7 @@ simpl_wrk lc []
 
 simpl_wrk lc ((Real ln cc (Insn (SomeAnns []) O_rep [])) :
               (Real _   _ (Insn (SomeAnns []) o_op [])) : lines)
-   | o_op `elem` [O_movsl, O_movsw, O_movsb, 
+   | o_op `elem` [O_movsl, O_movsw, O_movsb,
                   O_stosl, O_stosw, O_stosb]
    = let (l1,l2)
             = (lc,lc+1)
@@ -564,7 +564,7 @@ simpl_wrk lc ((Real ln cc (Insn (SomeAnns []) O_rep [])) :
          mkLabelD ln
             = Pseudo ln (mk_arch_label_def (labelName ln))
          mkLabelU ln
-            = OP_D (Const [Pos (UF_LABEL 
+            = OP_D (Const [Pos (UF_LABEL
                                (mk_arch_label_use (labelName ln)))])
      in
          [mkInsn   O_pushfl  [],
@@ -589,7 +589,7 @@ simpl_wrk lc ((Real ln cc (Insn (SomeAnns []) o_reppy [])) :
             | o_reppy `elem` [O_repz]
             = O_jnz
             | otherwise
-            = incomplete ("simpl_wrk rep: can't handle " 
+            = incomplete ("simpl_wrk rep: can't handle "
                           ++ show (o_reppy, o_op) ++ "\n")
          (l1,l2,l3)
             = (lc,lc+1,lc+2)
@@ -604,7 +604,7 @@ simpl_wrk lc ((Real ln cc (Insn (SomeAnns []) o_reppy [])) :
          mkLabelD ln
             = Pseudo ln (mk_arch_label_def (labelName ln))
          mkLabelU ln
-            = OP_D (Const [Pos (UF_LABEL 
+            = OP_D (Const [Pos (UF_LABEL
                                (mk_arch_label_use (labelName ln)))])
 
 
@@ -647,7 +647,7 @@ newtype BB = BB [Line]
 
 instance PP BB where
    pp ppm (BB ls)
-      = "{ -- basic block\n" 
+      = "{ -- basic block\n"
         ++ unlines (map (pp ppm) ls)
         ++ "}"
 
@@ -659,9 +659,9 @@ identify_bbs = map (\line -> BB [line])
 -}
 
 -- something a bit better
--- It could still be improved.  
+-- It could still be improved.
 -- Use --ddump-ident-bbs to get ideas.
-identify_bbs 
+identify_bbs
    = merge_bbs . map (\line -> BB [line])
      where
         merge_bbs []   = []
@@ -672,7 +672,7 @@ identify_bbs
            = let bigger_bb = BB (lines1++[line])
              in  merge_bbs (bigger_bb : bbs)
 
-           | isOriginalInsn line 
+           | isOriginalInsn line
              && any isReal lines1
              && isOriginalInsn last_Real_lines1
              && opcodeOfInsn (insnOfLine last_Real_lines1)
@@ -743,7 +743,7 @@ annotate_insn insn@(Insn old_ann opcode operands)
    | isDontAnnMe old_ann
    = insn
    | otherwise
-   = Insn (SomeAnns (filter (isMemOp.getAnnOp) 
+   = Insn (SomeAnns (filter (isMemOp.getAnnOp)
                             (annsOf opcode operands)))
           opcode operands
 
@@ -765,7 +765,7 @@ annsOf opcode operands
    = let opInfo
             = getOperandInfo opcode
          no_applicable_info
-            = incomplete ("operand info (" 
+            = incomplete ("operand info ("
                      ++ show opInfo
                      ++ ") doesn't match operand(s): "
                      ++ ppd (Insn mkNoAnns opcode operands))
@@ -778,38 +778,38 @@ annsOf opcode operands
                     Nothing   -> no_applicable_info
 
            OI_Jumpy
-              -> case operands of 
-                    [op1] -> case op1 of 
+              -> case operands of
+                    [op1] -> case op1 of
                                 { OP_STAR o -> [AnnR 4 o]; _ -> [] }
                     other -> no_applicable_info
 
            OI_NoEffect
               -> []
-   
+
            OI_Error
               -> internal ( "unsimplified opcode: "
                             ++ ppd (Insn mkNoAnns opcode operands))
-   
+
            OI_Special
               |  opcode == O_pushl
-              -> case operands of 
+              -> case operands of
                     [op1] -> [AnnR 4 op1, AnnW 4 the_sp_plus_4]
                     other -> no_applicable_info
-   
+
               |  opcode == O_call
-              -> case operands of 
+              -> case operands of
                     [op1] -> case op1 of
                        OP_STAR o -> [AnnR 4 o, AnnW 4 the_sp_plus_4]
                        direct    -> [AnnW 4 the_sp_plus_4]
                     other -> no_applicable_info
 
               |  opcode == O_popl
-              -> case operands of 
+              -> case operands of
                     [op1] -> [AnnR 4 the_sp_plus_8, AnnW 4 op1]
-   
+
               |  opcode == O_ret
               -> [AnnR 4 the_sp_plus_8]
-   
+
               |  opcode == O_scasb
               -> [AnnR 1 the_edi]
               |  opcode == O_cmpsb
@@ -827,9 +827,9 @@ annsOf opcode operands
               |  opcode == O_stosb
               -> [AnnW 1 the_edi]  -- a guess
            other
-              -> incomplete ("\nunclassifiable opcode: " 
+              -> incomplete ("\nunclassifiable opcode: "
                              ++ ppd (Insn mkNoAnns opcode operands) )
-     
+
 
 annsFromEffects :: [OperandEffect] -> [Operand] -> Maybe [Annot]
 annsFromEffects effects operands
@@ -841,42 +841,42 @@ annsFromEffects effects operands
      case head effects of
 
         OE_RR s1 s2
-           -> case operands of 
+           -> case operands of
                  [op1, op2] -> Just [AnnR s1 op1, AnnR s2 op2]
                  other      -> mismatch
 
         OE_RM s1 s2
-           -> case operands of 
+           -> case operands of
                  [op1, op2] -> Just [AnnR s1 op1, AnnM s2 op2]
                  other      -> mismatch
 
         OE_RW s1 s2
-           -> case operands of 
+           -> case operands of
                  [op1, op2] -> Just [AnnR s1 op1, AnnW s2 op2]
                  other      -> mismatch
-   
+
         OE_R s1
-           -> case operands of 
+           -> case operands of
                  [op1] -> Just [AnnR s1 op1]
                  other -> mismatch
-   
+
         OE_M s1
-           -> case operands of 
+           -> case operands of
                  [op1] -> Just [AnnM s1 op1]
                  other -> mismatch
-   
+
         OE_W s1
-           -> case operands of 
+           -> case operands of
                  [op1] -> Just [AnnW s1 op1]
                  other -> mismatch
-      
+
         OE_nW s2
-           -> case operands of 
+           -> case operands of
                  [op1,op2] -> Just [AnnW s2 op2]
                  other     -> mismatch
-   
+
         OE_RRM s1 s2 s3
-           -> case operands of 
+           -> case operands of
                  [op1,op2,op3] -> Just [AnnR s1 op1, AnnR s2 op2,
                                                      AnnM s3 op3]
                  other         -> mismatch
@@ -886,7 +886,7 @@ getOperandInfo :: Opcode -> OperandInfo
 getOperandInfo opcR
    = case [oi | (opc, oi) <- x86info, opc == opcR] of
         [oi] -> oi
-        _    -> incomplete ("getOperandInfo: no info for: " 
+        _    -> incomplete ("getOperandInfo: no info for: "
                             ++ show opcR ++ "\n")
 
 
@@ -900,9 +900,9 @@ getOperandInfo opcR
 
 -- section-main
 addCCs :: [Line] -> [Line]
-addCCs 
+addCCs
    = addCCs_wrk (Guessed "_unknown_file_")
-                0 
+                0
                 (Guessed "_unknown_function_")
 
 data PossiblyString
@@ -916,7 +916,7 @@ getTheString (Guessed s) = s
 -- file name, line number, function name
 addCCs_wrk :: PossiblyString -> Int -> PossiblyString
               -> [Line] -> [Line]
-addCCs_wrk inm lno fnm [] 
+addCCs_wrk inm lno fnm []
    = []
 addCCs_wrk inm lno fnm (l:ls)
    = case l of
@@ -935,7 +935,7 @@ addCCs_wrk inm lno fnm (l:ls)
                  (inm2, lno2, fnm2)
                     -> l : addCCs_wrk inm2 lno2 fnm2 ls
      where
-        updCC s 
+        updCC s
             = upd2 (words (dropWhile isSpace s))
 
         upd2 (".stabn" : args : _)
@@ -949,11 +949,11 @@ addCCs_wrk inm lno fnm (l:ls)
                                   -> (Stated (deQuote filenm), lno, fnm)
                  (filenm:"132":_) -> (Stated (deQuote filenm), lno, fnm)
                  (fnnm:"36":_)    |  (not.null.deQuote) fnnm
-                                  -> (inm, lno, 
-                                      Stated (deQuote 
+                                  -> (inm, lno,
+                                      Stated (deQuote
                                                 (takeWhile (/=':') fnnm)))
                  _                -> (inm, lno, fnm)
+
         upd2 [".file", filenm]
            | isGuessed inm && isQuoted filenm
            = (Guessed (deQuote filenm), lno, fnm)
@@ -969,7 +969,7 @@ addCCs_wrk inm lno fnm (l:ls)
             = (inm, lno, Guessed (init cleaned))
             | otherwise
             = (inm, lno, fnm)
-              where 
+              where
                  cleaned = dropWhile isSpace label_text
 
         splitArgs = breakOnComma . zapCIQ
@@ -992,7 +992,7 @@ addCCs_wrk inm lno fnm (l:ls)
 
         isQuoted s
            = length s >= 2 && head s == '"' && last s == '"'
-        deQuote s 
+        deQuote s
            = filter (/= '"') s    -- " fool Haskell-mode highlighting
 
 
@@ -1009,7 +1009,7 @@ addCCs_wrk inm lno fnm (l:ls)
     1.  Round up the CCs that Stage 7a attached.
 
     2.  Condense them into a convenient form
-        holding the names of source files, source functions 
+        holding the names of source files, source functions
         and sourcepoints mentioned in this file.
         (this is makeCCdescriptors)
 
@@ -1066,7 +1066,7 @@ makeCCdescriptors allCcs
 
          -- the filenames
          filenames = nub (map ccGetFileNm ccs)
-         
+
          -- make a map from each function to its
          -- canonical name, by adding the name of the
          -- function in which it first appears
@@ -1101,12 +1101,12 @@ makeCCdescriptors allCcs
 
          indent s = "   " ++ s
          indexOf xs y
-            = f 0 xs 
+            = f 0 xs
               where
                  f n [] = internal ("indexOf: " ++ show y ++ "\n")
                  f n (z:zs) = if y == z then n else f (n+1) zs
      in
-         (debugging_text, 
+         (debugging_text,
           filenames,
           canonical_fn_map_snds,
           srcPoints)
@@ -1148,13 +1148,13 @@ mk_arch_label_use s = ".L" ++ s
 tABLE_START_STRING  = "cacheprof_magic_table"
 bUCKETS_START_STRING = "cacheprof_magic_buckets"
 
-useCCdescriptors :: ([String],[String],[String],[(Int,Int,Int)]) 
+useCCdescriptors :: ([String],[String],[String],[(Int,Int,Int)])
                     -> [Line]
 useCCdescriptors (debugging_text, filenames, funcnames, points)
    = let length_words
             = [mk_comment "number of filenames, funcnames, points, cc addr"]
-              ++ map mk_word [length filenames, 
-                              length funcnames, 
+              ++ map mk_word [length filenames,
+                              length funcnames,
                               length points]
               ++ [mk_word_l bUCKETS_START_STRING]
          strings
@@ -1188,7 +1188,7 @@ useCCdescriptors (debugging_text, filenames, funcnames, points)
          mk_align       = ["\t.align 4"]
      in
          map mk_Pseudo (
-            concat [pre_comments, comments, 
+            concat [pre_comments, comments,
                     preamble,
                     [mk_label_def tABLE_START_STRING],
                     length_words, string_bytes,
@@ -1205,9 +1205,9 @@ useCCdescriptors (debugging_text, filenames, funcnames, points)
 {-------------------------------------------}
 
 synthLine :: Int -> Line -> (Int, [Line])
-synthLine nextcc (Pseudo ln stuff) 
+synthLine nextcc (Pseudo ln stuff)
    = (nextcc, [Pseudo ln stuff])
-synthLine nextcc (Label ln stuff) 
+synthLine nextcc (Label ln stuff)
    = (nextcc, [Label ln stuff])
 synthLine nextcc (Real ln cc insn)
    | hasRealAnns insn
@@ -1233,47 +1233,47 @@ std_postamble
    = [insn_popl EBX, insn_popl EAX]
 
 useAnnot :: Int -> Annot -> [Insn]
-useAnnot ccid (AnnC c) 
+useAnnot ccid (AnnC c)
    = internal "useAnnot on comment annotation"
 
 useAnnot ccid (AnnR sz op)
-   = std_preamble 
+   = std_preamble
      ++
-     [ Insn (mkAnnC "rd-1") O_leal 
+     [ Insn (mkAnnC "rd-1") O_leal
                             [op, OP_REG EAX],
-       Insn (mkAnnC "rd-2") O_movl 
+       Insn (mkAnnC "rd-2") O_movl
                             [mk_bucket_addr ccid, OP_REG EBX],
-       Insn (mkAnnC "rd-3") O_call 
+       Insn (mkAnnC "rd-3") O_call
                             [OP_D (Const [Pos (mk_rd_hook_name sz)])]
      ]
      ++ std_postamble
 
 useAnnot ccid (AnnM sz op)
-   = std_preamble 
+   = std_preamble
      ++
-     [ Insn (mkAnnC "mo-1") O_leal 
+     [ Insn (mkAnnC "mo-1") O_leal
                             [op, OP_REG EAX],
-       Insn (mkAnnC "mo-2") O_movl 
+       Insn (mkAnnC "mo-2") O_movl
                             [mk_bucket_addr ccid, OP_REG EBX],
-       Insn (mkAnnC "mo-3") O_call 
+       Insn (mkAnnC "mo-3") O_call
                             [OP_D (Const [Pos (mk_mo_hook_name sz)])]
      ]
      ++ std_postamble
 
 useAnnot ccid (AnnW sz op)
    = std_preamble
-     ++ 
-     [ Insn (mkAnnC "wr-1") O_leal 
+     ++
+     [ Insn (mkAnnC "wr-1") O_leal
                             [op, OP_REG EAX],
-       Insn (mkAnnC "wr-2") O_movl 
+       Insn (mkAnnC "wr-2") O_movl
                             [mk_bucket_addr ccid, OP_REG EBX],
-       Insn (mkAnnC "wr-3") O_call 
+       Insn (mkAnnC "wr-3") O_call
                             [OP_D (Const [Pos (mk_wr_hook_name sz)])]
      ]
      ++ std_postamble
 
 mk_bucket_addr ccid
-   = OP_D (Const [Pos (UF_LABEL 
+   = OP_D (Const [Pos (UF_LABEL
                          ("$" ++ mk_arch_label_use bUCKETS_START_STRING)),
                   Pos (UF_NUM (show (28 * ccid)))])
 
@@ -1298,9 +1298,9 @@ synth_1 :: [Line] -> [Line]
 synth_1 = concatMap synth_1_wrk
 
 synth_1_wrk :: Line -> [Line]
-synth_1_wrk (Pseudo ln stuff) 
+synth_1_wrk (Pseudo ln stuff)
    = [Pseudo ln stuff]
-synth_1_wrk (Label ln stuff) 
+synth_1_wrk (Label ln stuff)
    = [Label ln stuff]
 synth_1_wrk line@(Real ln cc insn@(Insn ann opcode operands))
    | hasRealAnns insn
@@ -1346,7 +1346,7 @@ incSequence k name
         addl $1,cacheprof_level1_writes
         adcl $0,4+cacheprof_level1_writes
         popfl
-   into 
+   into
         pushfl
         addl $3,cacheprof_icount
         adcl $0,4+cacheprof_icount
@@ -1365,7 +1365,7 @@ peephole ( line1@(Real ln1 cc1 insn1) :
            line5@(Real ln5 cc5 insn5) :
            line6@(Real ln6 cc6 insn6) :
            the_rest )
-   | incs_a_counter insn1 insn2 
+   | incs_a_counter insn1 insn2
      && incs_a_counter insn5 insn6
    = peephole (line1 : line2 : line5 : line6 : the_rest)
 
@@ -1400,7 +1400,7 @@ final_cleanup :: [Line] -> String
 final_cleanup
    = unlines . map ppu . filter (not.isStabLine)
      where
-        isStabLine (Pseudo ln s) 
+        isStabLine (Pseudo ln s)
            = take 5 (dropWhile isSpace s) == ".stab"
         isStabLine other
            = False
@@ -1418,17 +1418,17 @@ main = seq stderr (       -- avoid bug in ghc-4.04
                  = if "--level0" `elem` args then 0
                    else if "--level1" `elem` args then 1
                    else if "--level2" `elem` args then 2
-                   else internal 
+                   else internal
                            "profiling level not supplied by `cacheprof'"
 
           let bad_ddump_flags
-                 = filter (`notElem` ddump_flags) 
+                 = filter (`notElem` ddump_flags)
                       (filter ((== "--ddump-") . take 8) args)
 
           if (not (null bad_ddump_flags))
            then do hPutStr stderr (
-                        "cacheann: bad debugging flag(s): " ++ 
-                        unwords bad_ddump_flags ++ 
+                        "cacheann: bad debugging flag(s): " ++
+                        unwords bad_ddump_flags ++
                         "\n   valid debugging flags are\n" ++
                         unlines (map ("      "++) ddump_flags)
                       )
@@ -1449,7 +1449,7 @@ main = seq stderr (       -- avoid bug in ghc-4.04
        )
 
 ifVerb :: [String] -> IO () -> IO ()
-ifVerb flags ioact 
+ifVerb flags ioact
    = if "-v" `elem` flags then ioact else return ()
 
 doFile :: Int -> [String] -> String -> IO String
@@ -1482,10 +1482,10 @@ doFile prof_level args input_text
                  ifopt [0,1,2] ddump_peephole   peepholed
 
          ifopt valid_levels flag stuff
-            | prof_level `elem` valid_levels 
+            | prof_level `elem` valid_levels
               && flag `elem` args
             = hPutStr stderr (
-                 "\n\n-------- DEBUGGING OUTPUT FOR " 
+                 "\n\n-------- DEBUGGING OUTPUT FOR "
                  ++ flag ++ ":\n\n"
                  ++ unlines (map ppd stuff)
                  ++ "\n\n" )
index 6d18dd5..d153777 100644 (file)
@@ -140,10 +140,10 @@ Basic circuit components
 >      = None  -- no component
 >      | Inp   -- input to the entire circuit
 >      | Outp  -- output from the entire circuit
->      | Dff   -- delay flip flop  
->      | Inv   -- inverter         
->      | And2  -- 2-input and gate 
->      | Or2   -- 2-input or gate  
+>      | Dff   -- delay flip flop
+>      | Inv   -- inverter
+>      | And2  -- 2-input and gate
+>      | Or2   -- 2-input or gate
 >      | Xor   -- exclusive or gate
 >      deriving (Eq, Show)
 
@@ -165,12 +165,12 @@ a is the type of a signal (the value on a wire)
 >    a)                -- latch to hold the input signal value
 
 > type OutPort a =
->      (Int,   -- output port number for the signal value      
->      a,      -- latch to hold the signal value               
->      Bool,   -- need to send it to the left?                 
->      Int,    -- distance to send to the left                 
->      Bool,   -- need to send it to the right?                
->      Int)    -- distance to send to the right                
+>      (Int,   -- output port number for the signal value
+>      a,      -- latch to hold the signal value
+>      Bool,   -- need to send it to the left?
+>      Int,    -- distance to send to the left
+>      Bool,   -- need to send it to the right?
+>      Int)    -- distance to send to the right
 
 
 
@@ -235,9 +235,9 @@ a power of two
 
 
 > emptyState :: Signal a => State a
-> emptyState = PS {    pid = -1, 
->                      compType = None, 
->                      pathDepth = -1, 
+> emptyState = PS {    pid = -1,
+>                      compType = None,
+>                      pathDepth = -1,
 >                      inports = [],
 >                      outports = []}
 
@@ -274,12 +274,12 @@ Packets are just OutPorts with a pid
 
 > type Packet a =
 >      (Pid,   -- id of this packet
->      Int,    -- output port number for the signal value      
->      a,      -- latch to hold the signal value               
->      Bool,   -- need to send it to the left?                 
->      Int,    -- distance to send to the left                 
->      Bool,   -- need to send it to the right?                
->      Int,    -- distance to send to the right  
+>      Int,    -- output port number for the signal value
+>      a,      -- latch to hold the signal value
+>      Bool,   -- need to send it to the left?
+>      Int,    -- distance to send to the left
+>      Bool,   -- need to send it to the right?
+>      Int,    -- distance to send to the right
 >      Int)    -- extent
 
 
@@ -388,7 +388,7 @@ need to restore them to there original values.
 > restore_requests old_states new_states
 >              = zipWith restore old_states new_states
 >      where
->      restore os ns = ns { outports = zipWith restore_outport (outports os) 
+>      restore os ns = ns { outports = zipWith restore_outport (outports os)
 >                                                  (outports ns) }
 >      restore_outport (p,_,ql,dl,qr,dq) (_,m,_,_,_,_) = (p,m,ql,dl,qr,dq)
 
@@ -427,10 +427,10 @@ Update both the inports and outports of a state
 > update_io :: Signal a => Int -> [(Packet a,Packet a)] -> State a -> State a
 > update_io d lrps state = update_os (update_is state)
 >     where
->      update_is state = state { inports = foldr update_i 
+>      update_is state = state { inports = foldr update_i
 >                                                     (inports state) lrps }
 >      update_os state = if pathDepth state == d
->                          then state { outports = zipWith update_o 
+>                          then state { outports = zipWith update_o
 >                                                      lrps (outports state) }
 >                          else state
 
@@ -529,7 +529,7 @@ Place input values into circuit's input components
 > store_inputs :: Signal a => [(Label,a)] -> State a -> State a
 > store_inputs label_inputs state@(PS {compType=Inp})
 >      = head [ update_outports state value
->                      | ((label, input_pid), value) <- label_inputs,  
+>                      | ((label, input_pid), value) <- label_inputs,
 >                                              pid state == input_pid ]
 > store_inputs label_inputs state = state
 
@@ -593,7 +593,7 @@ Circuit example -- a register
 >                      compType  = Inp,
 >                      pathDepth = 0,
 >                      inports    = [],
->                      outports   = [(0, zeroS, False, 
+>                      outports   = [(0, zeroS, False,
 >                                     0, True, 8*(bits-1)+5)]
 >              }
 
index 33f5351..d792bd6 100644 (file)
@@ -29,7 +29,7 @@ data Assign = Var := Value deriving (Eq, Ord, Show)
 
 type Relation = Assign -> Assign -> Bool
 
-data CSP = CSP { vars, vals :: Int, rel :: Relation } 
+data CSP = CSP { vars, vals :: Int, rel :: Relation }
 
 type State = [Assign]
 
@@ -111,18 +111,18 @@ data Maybe a = Just a | Nothing deriving Eq
 
 earliestInconsistency :: CSP -> State -> Maybe (Var,Var)
 earliestInconsistency CSP{rel=rel} [] = Nothing
-earliestInconsistency CSP{rel=rel} (a:as) = 
+earliestInconsistency CSP{rel=rel} (a:as) =
         case filter (not . rel a) (reverse as) of
           [] -> Nothing
           (b:_) -> Just (level a, level b)
 
 labelInconsistencies :: CSP -> Transform State (State,Maybe (Var,Var))
-labelInconsistencies csp = mapTree f 
+labelInconsistencies csp = mapTree f
     where f s = (s,earliestInconsistency csp s)
 
 btsolver0 :: CSP -> [State]
 btsolver0 csp =
-  (filter (complete csp) . leaves . (mapTree fst) . prune ((/= Nothing) . snd) 
+  (filter (complete csp) . leaves . (mapTree fst) . prune ((/= Nothing) . snd)
                                             . (labelInconsistencies csp) .  mkTree) csp
 
 -----------------------------------------------
@@ -150,7 +150,7 @@ search labeler csp =
 
 bt :: Labeler
 bt csp = mapTree f
-      where f s = (s, 
+      where f s = (s,
                    case earliestInconsistency csp s of
                      Nothing    -> checkComplete csp s
                      Just (a,b) -> Known [a,b])
@@ -211,14 +211,14 @@ fillTable :: State -> CSP -> Table -> Table
 fillTable [] csp tbl = tbl
 fillTable ((var' := val'):as) CSP{vars=vars,vals=vals,rel=rel} tbl =
     zipWith (zipWith f) tbl [[(var,val) | val <- [1..vals]] | var <- [var'+1..vars]]
-          where f cs (var,val) = if cs == Unknown && not (rel (var' := val') (var := val)) then 
-                                   Known [var',var] 
+          where f cs (var,val) = if cs == Unknown && not (rel (var' := val') (var := val)) then
+                                   Known [var',var]
                                  else cs
 
 lookupCache :: CSP -> Transform (State, Table) ((State, ConflictSet), Table)
 lookupCache csp t = mapTree f t
   where f ([], tbl)      = (([], Unknown), tbl)
-        f (s@(a:_), tbl) = ((s, cs), tbl) 
+        f (s@(a:_), tbl) = ((s, cs), tbl)
             where cs = if tableEntry == Unknown then checkComplete csp s else tableEntry
                    tableEntry = (head tbl)!!(value a-1)
 
@@ -233,18 +233,18 @@ bjbt' :: Labeler
 bjbt' csp = bj' csp . bt csp
 
 bj :: CSP -> Transform (State, ConflictSet) (State, ConflictSet)
-bj csp = foldTree f 
+bj csp = foldTree f
   where f (a, Known cs) chs = Node (a,Known cs) chs
         f (a, Unknown)  chs = Node (a,Known cs') chs
           where cs' = combine (map label chs) []
 
 combine :: [(State, ConflictSet)] -> [Var] -> [Var]
-combine []                 acc = acc 
+combine []                 acc = acc
 combine ((s, Known cs):css) acc =
   if maxLevel s `notElem` cs then cs else combine css (cs `union` acc)
 
 bj' :: CSP -> Transform (State, ConflictSet) (State, ConflictSet)
-bj' csp = foldTree f 
+bj' csp = foldTree f
   where f (a, Known cs) chs = Node (a,Known cs) chs
         f (a, Unknown) chs = if knownConflict cs' then Node (a,cs') [] else Node (a,cs') chs
            where cs' = Known (combine (map label chs) [])
@@ -262,8 +262,8 @@ collect (Known cs:css) = cs `union` (collect css)
 
 domainWipeOut :: CSP -> Transform ((State, ConflictSet), Table) (State, ConflictSet)
 domainWipeOut CSP{vars=vars} t = mapTree f t
-  where f ((as, cs), tbl) = (as, cs')  
-          where wipedDomains = ([vs | vs <- tbl, all (knownConflict) vs]) 
+  where f ((as, cs), tbl) = (as, cs')
+          where wipedDomains = ([vs | vs <- tbl, all (knownConflict) vs])
                 cs' = if null wipedDomains then cs else Known (collect (head wipedDomains))
 
 
index 245335d..d0da7bd 100644 (file)
@@ -4,7 +4,7 @@ To:      simonpj@dcs.gla.ac.uk
 Subject: Fibonacci Heaps
 
 As I promised at the Haskell Workshop, here is a sample program
-using encapsulated state.  I've translated this from SML, but 
+using encapsulated state.  I've translated this from SML, but
 in doing so, I noticed that in fact accumArray is all the
 encapsulated state you really need for this application.  In SML,
 we are forced to use mutable arrays because we don't have such
@@ -65,13 +65,13 @@ binomial trees.
 
 >data Tree a = Node a [Tree a]
 
-The degree of a binomial tree is equal to its number of children.  
+The degree of a binomial tree is equal to its number of children.
 Every binomial tree of degree k has binomial trees of degrees
 k-1...0 as children, in that order.  It is easy to show that
 a binomial tree of degree k has size 2^k.
 
 The fundamental operation on binomial trees is linking, which compares
-the roots of two binomial trees and makes the larger a child of the 
+the roots of two binomial trees and makes the larger a child of the
 smaller (thus bumping its degree by one).  It is essential that this
 only be called on binomial trees of equal degree.
 
@@ -135,10 +135,10 @@ with a forest of trees summing to the correct size.
 >type Forest a = Bag (TaggedTree a)
 
 In binomial queues, this forest must be maintained in strictly increasing
-order of degree.  For Fibonacci heaps, we adopt a more relaxed attitude: 
+order of degree.  For Fibonacci heaps, we adopt a more relaxed attitude:
 degrees may be repeated and order does not matter.
 
-To be able to find the minimum element quickly, we keep the tree with the 
+To be able to find the minimum element quickly, we keep the tree with the
 minimum root outside of the bag.  In addition, at the top level of each heap,
 we store the total size of the heap.
 
@@ -182,7 +182,7 @@ the other using accumArray.
 
 In the first implementation, there are three steps.
   1. Allocate an array indexed by degrees.
-  2. Insert every tree into this array.  If, when inserting a tree of 
+  2. Insert every tree into this array.  If, when inserting a tree of
      degree k, there already exists a tree of degree k, link the
      two trees and reinsert the new larger tree.
   3. Transfer the trees into a bag, keeping track of the minimum tree.
@@ -222,8 +222,8 @@ the highest slot of the array.
 >                       getMin' a mini mint (ConsBag (i, t) b) (i+1)
 >                     else
 >                       getMin' a i t (ConsBag (mini, mint) b) (i+1)
->            
->  in 
+>
+>  in
 >    runST (newArray (0,d) Zero >>= \a ->
 >           applyToAll (ins a) f >>
 >           sequence (map (ins a) (getChildren tt)) >>
@@ -233,7 +233,7 @@ the highest slot of the array.
                          --------------------
 
 The second version of deleteMin uses accumArray to group trees of like
-size.  It then performs the linking and all remaining steps purely 
+size.  It then performs the linking and all remaining steps purely
 functionally.
 
 >deleteMinFH' EmptyFH = error "deleteMinFH EmptyFH"
index 850f47c..8699de9 100644 (file)
@@ -3,16 +3,16 @@
  -
  -  Copyright 1990,1991,1992,1993 Duncan Sinclair
  -
- - Permissiom to use, copy, modify, and distribute this software for any 
+ - Permissiom to use, copy, modify, and distribute this software for any
  - purpose and without fee is hereby granted, provided that the above
  - copyright notice and this permission notice appear in all copies, and
  - that my name not be used in advertising or publicity pertaining to this
  - software without specific, written prior permission.  I makes no
  - representations about the suitability of this software for any purpose.
  - It is provided ``as is'' without express or implied warranty.
- - 
+ -
  - Duncan Sinclair 1993.
- - 
+ -
  - CSG evaluation engine.
  -
  -}
index 81921f6..04c4de6 100644 (file)
@@ -3,16 +3,16 @@
  -
  -  Copyright 1990,1991,1992,1993 Duncan Sinclair
  -
- - Permissiom to use, copy, modify, and distribute this software for any 
+ - Permissiom to use, copy, modify, and distribute this software for any
  - purpose and without fee is hereby granted, provided that the above
  - copyright notice and this permission notice appear in all copies, and
  - that my name not be used in advertising or publicity pertaining to this
  - software without specific, written prior permission.  I makes no
  - representations about the suitability of this software for any purpose.
  - It is provided ``as is'' without express or implied warranty.
- - 
+ -
  - Duncan Sinclair 1993.
- - 
+ -
  - Interval arithmetic package.
  -
  -}
index b19ca2d..6dfff7f 100644 (file)
@@ -3,16 +3,16 @@
  -
  -  Copyright 1990,1991,1992,1993 Duncan Sinclair
  -
- - Permissiom to use, copy, modify, and distribute this software for any 
+ - Permissiom to use, copy, modify, and distribute this software for any
  - purpose and without fee is hereby granted, provided that the above
  - copyright notice and this permission notice appear in all copies, and
  - that my name not be used in advertising or publicity pertaining to this
  - software without specific, written prior permission.  I makes no
  - representations about the suitability of this software for any purpose.
  - It is provided ``as is'' without express or implied warranty.
- - 
+ -
  - Duncan Sinclair 1993.
- - 
+ -
  - Colour definitions.
  -
  - (The information is this file is derived from the rgb database
index b8d0585..96c0a8e 100644 (file)
@@ -3,16 +3,16 @@
  -
  -  Copyright 1990,1991,1992,1993 Duncan Sinclair
  -
- - Permission to use, copy, modify, and distribute this software for any 
+ - Permission to use, copy, modify, and distribute this software for any
  - purpose and without fee is hereby granted, provided that the above
  - copyright notice and this permission notice appear in all copies, and
  - that my name not be used in advertising or publicity pertaining to this
  - software without specific, written prior permission.  I makes no
  - representations about the suitability of this software for any purpose.
  - It is provided ``as is'' without express or implied warranty.
- - 
+ -
  - Duncan Sinclair 1993.
- - 
+ -
  - Main program.
  -
  -}
index 0fd4ca8..3c2845e 100644 (file)
@@ -3,16 +3,16 @@
  -
  -  Copyright 1990,1991,1992,1993 Duncan Sinclair
  -
- - Permissiom to use, copy, modify, and distribute this software for any 
+ - Permissiom to use, copy, modify, and distribute this software for any
  - purpose and without fee is hereby granted, provided that the above
  - copyright notice and this permission notice appear in all copies, and
  - that my name not be used in advertising or publicity pertaining to this
  - software without specific, written prior permission.  I makes no
  - representations about the suitability of this software for any purpose.
  - It is provided ``as is'' without express or implied warranty.
- - 
+ -
  - Duncan Sinclair 1993.
- - 
+ -
  - Matrix arithmetic functions.
  -
  -}
@@ -30,7 +30,7 @@ mat4x1 (r1,r2,r3) xyz = (x,y,z)
                              z = dorow r3 xyz
 
 dorow :: (Fractional a) => Row -> R3 a -> a
-dorow (m11,m12,m13,m14) (x,y,z) 
+dorow (m11,m12,m13,m14) (x,y,z)
     = case  (m1 * x) + (m2 * y) + (m3 * z) + m4 of n -> n
        where
         m1 = realToFrac m11
@@ -46,7 +46,7 @@ mat4x1' (r1,r2,r3) xyz = (x,y,z)
                              z = dorow r3 xyz
 
 dorow' :: (Fractional a) => Row -> R3 a -> a
-dorow' (m11,m12,m13,m14) (x,y,z) 
+dorow' (m11,m12,m13,m14) (x,y,z)
     = case (m1 * x) + (m2 * y) + (m3 * z) of n -> n
        where
         m1 = realToFrac m11
index 8e4725f..d835ee7 100644 (file)
@@ -3,16 +3,16 @@
  -
  -  Copyright 1990,1991,1992,1993 Duncan Sinclair
  -
- - Permissiom to use, copy, modify, and distribute this software for any 
+ - Permissiom to use, copy, modify, and distribute this software for any
  - purpose and without fee is hereby granted, provided that the above
  - copyright notice and this permission notice appear in all copies, and
  - that my name not be used in advertising or publicity pertaining to this
  - software without specific, written prior permission.  I makes no
  - representations about the suitability of this software for any purpose.
  - It is provided ``as is'' without express or implied warranty.
- - 
+ -
  - Duncan Sinclair 1993.
- - 
+ -
  - Csg to Oct-tree processing.
  -
  -}
@@ -46,7 +46,7 @@ makeoct csg = octer 1 csg xyz
 -- octer :: Int -> Csg -> (R3 BI) -> Oct
 octer nn csg xyz
     = case (calc csg white xyz) of
-       (res,newc',rgb,new) -> 
+       (res,newc',rgb,new) ->
          let
           newc = if new then newc' else csg
           c = light rgb (calcn newc xyz)
index 72dadb2..50463d5 100644 (file)
@@ -3,16 +3,16 @@
  -
  -  Copyright 1990,1991,1992,1993 Duncan Sinclair
  -
- - Permissiom to use, copy, modify, and distribute this software for any 
+ - Permissiom to use, copy, modify, and distribute this software for any
  - purpose and without fee is hereby granted, provided that the above
  - copyright notice and this permission notice appear in all copies, and
  - that my name not be used in advertising or publicity pertaining to this
  - software without specific, written prior permission.  I makes no
  - representations about the suitability of this software for any purpose.
  - It is provided ``as is'' without express or implied warranty.
- - 
+ -
  - Duncan Sinclair 1993.
- - 
+ -
  - Version information.
  -
  -}
index 34685ef..3138c20 100644 (file)
@@ -3,16 +3,16 @@
  -
  -  Copyright 1990,1991,1992,1993 Duncan Sinclair
  -
- - Permissiom to use, copy, modify, and distribute this software for any 
+ - Permissiom to use, copy, modify, and distribute this software for any
  - purpose and without fee is hereby granted, provided that the above
  - copyright notice and this permission notice appear in all copies, and
  - that my name not be used in advertising or publicity pertaining to this
  - software without specific, written prior permission.  I makes no
  - representations about the suitability of this software for any purpose.
  - It is provided ``as is'' without express or implied warranty.
- - 
+ -
  - Duncan Sinclair 1993.
- - 
+ -
  - Oct-tree to Quad-tree processing.
  -
  -}
index d83efe6..5b2fade 100644 (file)
@@ -3,16 +3,16 @@
  -
  -  Copyright 1990,1991,1992,1993 Duncan Sinclair
  -
- - Permissiom to use, copy, modify, and distribute this software for any 
+ - Permissiom to use, copy, modify, and distribute this software for any
  - purpose and without fee is hereby granted, provided that the above
  - copyright notice and this permission notice appear in all copies, and
  - that my name not be used in advertising or publicity pertaining to this
  - software without specific, written prior permission.  I makes no
  - representations about the suitability of this software for any purpose.
  - It is provided ``as is'' without express or implied warranty.
- - 
+ -
  - Duncan Sinclair 1993.
- - 
+ -
  - Quad-tree to raster-format processing.
  -
  -}
index 9e8a774..a51b0e2 100644 (file)
@@ -3,16 +3,16 @@
  -
  -  Copyright 1990,1991,1992,1993 Duncan Sinclair
  -
- - Permissiom to use, copy, modify, and distribute this software for any 
+ - Permissiom to use, copy, modify, and distribute this software for any
  - purpose and without fee is hereby granted, provided that the above
  - copyright notice and this permission notice appear in all copies, and
  - that my name not be used in advertising or publicity pertaining to this
  - software without specific, written prior permission.  I makes no
  - representations about the suitability of this software for any purpose.
  - It is provided ``as is'' without express or implied warranty.
- - 
+ -
  - Duncan Sinclair 1993.
- - 
+ -
  - Library of CSG shapes.
  -
  -}
index 83774fe..933769e 100644 (file)
@@ -3,16 +3,16 @@
  -
  -  Copyright 1990,1991,1992,1993 Duncan Sinclair
  -
- - Permissiom to use, copy, modify, and distribute this software for any 
+ - Permissiom to use, copy, modify, and distribute this software for any
  - purpose and without fee is hereby granted, provided that the above
  - copyright notice and this permission notice appear in all copies, and
  - that my name not be used in advertising or publicity pertaining to this
  - software without specific, written prior permission.  I makes no
  - representations about the suitability of this software for any purpose.
  - It is provided ``as is'' without express or implied warranty.
- - 
+ -
  - Duncan Sinclair 1993.
- - 
+ -
  - All major types declared here.
  -
  -}
index ea7f80e..d36d3e0 100644 (file)
@@ -3,16 +3,16 @@
  -
  -  Copyright 1990,1991,1992,1993 Duncan Sinclair
  -
- - Permissiom to use, copy, modify, and distribute this software for any 
+ - Permissiom to use, copy, modify, and distribute this software for any
  - purpose and without fee is hereby granted, provided that the above
  - copyright notice and this permission notice appear in all copies, and
  - that my name not be used in advertising or publicity pertaining to this
  - software without specific, written prior permission.  I makes no
  - representations about the suitability of this software for any purpose.
  - It is provided ``as is'' without express or implied warranty.
- - 
+ -
  - Duncan Sinclair 1993.
- - 
+ -
  - Vector arithmetic routines.
  -
  -}
index 1a4e9f7..ac78cce 100644 (file)
@@ -69,7 +69,7 @@ public class GCBench {
                 return 2 * TreeSize(kStretchTreeDepth) / TreeSize(i);
         }
 
-       // Build tree top down, assigning to older objects. 
+       // Build tree top down, assigning to older objects.
        static void Populate(int iDepth, Node thisNode) {
                if (iDepth<=0) {
                        return;
@@ -221,7 +221,7 @@ newMutNode x = do
   r <- newIORef MutEmpty
   return (MutNode l r x)
 
--- Build tree top down, assigning to older objects. 
+-- Build tree top down, assigning to older objects.
 populate 0 node = return ()
 populate iDepth (MutNode lref rref i) = do
   l <- newMutNode iDepth
@@ -257,9 +257,9 @@ timeConstruction max depth = do
 
 main = do
   args <- getArgs
-  let 
-    [kLongLivedTreeDepth, 
-     kArraySize, 
+  let
+    [kLongLivedTreeDepth,
+     kArraySize,
      kMinTreeDepth,
      kMaxTreeDepth] = map read args :: [Int]
 
@@ -277,10 +277,10 @@ main = do
   populate kLongLivedTreeDepth longLivedTree2
 
   -- Create long-lived array, filling half of it
---  printf " Creating a long-lived array of %d doubles\n" kArraySize 
+--  printf " Creating a long-lived array of %d doubles\n" kArraySize
   array <- newArray (1,kArraySize) 0.0
   let _ = array :: IOArray Int Double
-  sequence_ [ writeArray array i (1.0 / fromIntegral i) 
+  sequence_ [ writeArray array i (1.0 / fromIntegral i)
            | i <- [ 1 .. kArraySize `quot` 2 ] ]
 
   sequence_ [ timeConstruction kMaxTreeDepth d
index 0cb12ee..3f8a0ee 100644 (file)
@@ -47,7 +47,7 @@ generate some error messages.
 >       | TokenError    String                  -- %error
 >       | TokenAttributetype String             -- %attributetype
 >       | TokenAttribute String String          -- %attribute
+
 
 #ifdef DEBUG
 
@@ -55,27 +55,27 @@ generate some error messages.
 
 #endif
 
-> getTokenType ds 
->      = case [ t | (TokenType t) <- ds ] of 
+> getTokenType ds
+>      = case [ t | (TokenType t) <- ds ] of
 >              [t] -> t
 >              []  -> error "no token type given"
 >              _   -> error "multiple token types"
 
 > getParserNames ds = [ t | t@(TokenName _ _ _) <- ds ]
 
-> getLexer ds 
+> getLexer ds
 >      = case [ (a,b) | (TokenLexer a b) <- ds ] of
 >              [t] -> Just t
 >              []  -> Nothing
 >              _   -> error "multiple lexer directives"
 
-> getImportedIdentity ds 
+> getImportedIdentity ds
 >      = case [ (()) | TokenImportedIdentity <- ds ] of
 >              [_] -> True
 >              []  -> False
 >              _   -> error "multiple importedidentity directives"
 
-> getMonad ds 
+> getMonad ds
 >      = case [ (True,a,b,c,d) | (TokenMonad a b c d) <- ds ] of
 >              [t] -> t
 >              []  -> (False,"()","HappyIdentity",">>=","return")
@@ -101,7 +101,7 @@ generate some error messages.
 >                 []  -> Nothing
 >                 _   -> error "multiple expect directives"
 
-> getError ds 
+> getError ds
 >      = case [ a | (TokenError a) <- ds ] of
 >              [t] -> Just t
 >              []  -> Nothing
index ed0a985..cca226f 100644 (file)
@@ -1,4 +1,4 @@
-> module AttrGrammar 
+> module AttrGrammar
 > ( AgToken (..)
 > , AgRule (..)
 > , agLexAll
@@ -11,7 +11,7 @@
 > import Data.Char
 > import ParseMonad
 
-> data AgToken 
+> data AgToken
 >   = AgTok_LBrace
 >   | AgTok_RBrace
 >   | AgTok_Where
@@ -77,7 +77,7 @@
 > agLexer' cont ('$':'>':rest) = agLexAttribute cont (\a -> AgTok_RightmostRef a) rest
 > agLexer' cont s@('$':rest) =
 >     let (n,rest') = span isDigit rest
->     in if null n 
+>     in if null n
 >           then agLexUnknown cont s
 >          else agLexAttribute cont (\a -> AgTok_SubRef (read n,a)) rest'
 > agLexer' cont s@(c:rest)
@@ -95,7 +95,7 @@
 >           | otherwise                    = aux (c:t) cs
 
 > agLexAttribute :: (AgToken -> Pfunc a) -> (String -> AgToken) -> Pfunc a
-> agLexAttribute cont k ('.':x:xs) 
+> agLexAttribute cont k ('.':x:xs)
 >       | isLower x = let (id,rest) = span (\x -> isAlphaNum x || x == '\'') xs in cont (k (x:id)) rest
 >       | otherwise = \_ -> FailP "bad attribute identifier"
 > agLexAttribute cont k rest = cont (k "") rest
index 729d9c5..d0fc859 100644 (file)
@@ -4,19 +4,19 @@ import AttrGrammar
 
 -- parser produced by Happy Version 1.16
 
-data HappyAbsSyn 
+data HappyAbsSyn
        = HappyTerminal AgToken
        | HappyErrorToken Int
        | HappyAbsSyn4 ([AgRule])
        | HappyAbsSyn6 (AgRule)
        | HappyAbsSyn7 ([AgToken])
 
-type HappyReduction m = 
-          Int 
+type HappyReduction m =
+          Int
        -> (AgToken)
        -> HappyState (AgToken) (HappyStk HappyAbsSyn -> m HappyAbsSyn)
-       -> [HappyState (AgToken) (HappyStk HappyAbsSyn -> m HappyAbsSyn)] 
-       -> HappyStk HappyAbsSyn 
+       -> [HappyState (AgToken) (HappyStk HappyAbsSyn -> m HappyAbsSyn)]
+       -> HappyStk HappyAbsSyn
        -> m HappyAbsSyn
 
 action_0,
@@ -360,7 +360,7 @@ happyReduction_1 (HappyAbsSyn4  happy_var_1)
         =  HappyAbsSyn4
                 (happy_var_1
        )
-happyReduction_1 _  = notHappyAtAll 
+happyReduction_1 _  = notHappyAtAll
 
 happyReduce_2 = happySpecReduce_3  5 happyReduction_2
 happyReduction_2 (HappyAbsSyn4  happy_var_3)
@@ -369,14 +369,14 @@ happyReduction_2 (HappyAbsSyn4  happy_var_3)
         =  HappyAbsSyn4
                 (happy_var_1 : happy_var_3
        )
-happyReduction_2 _ _ _  = notHappyAtAll 
+happyReduction_2 _ _ _  = notHappyAtAll
 
 happyReduce_3 = happySpecReduce_1  5 happyReduction_3
 happyReduction_3 (HappyAbsSyn6  happy_var_1)
         =  HappyAbsSyn4
                 (happy_var_1 : []
        )
-happyReduction_3 _  = notHappyAtAll 
+happyReduction_3 _  = notHappyAtAll
 
 happyReduce_4 = happySpecReduce_0  5 happyReduction_4
 happyReduction_4  =  HappyAbsSyn4
@@ -390,7 +390,7 @@ happyReduction_5 (HappyAbsSyn7  happy_var_3)
         =  HappyAbsSyn6
                 (SelfAssign (selfRefVal happy_var_1) happy_var_3
        )
-happyReduction_5 _ _ _  = notHappyAtAll 
+happyReduction_5 _ _ _  = notHappyAtAll
 
 happyReduce_6 = happySpecReduce_3  6 happyReduction_6
 happyReduction_6 (HappyAbsSyn7  happy_var_3)
@@ -399,7 +399,7 @@ happyReduction_6 (HappyAbsSyn7  happy_var_3)
         =  HappyAbsSyn6
                 (SubAssign (subRefVal happy_var_1) happy_var_3
        )
-happyReduction_6 _ _ _  = notHappyAtAll 
+happyReduction_6 _ _ _  = notHappyAtAll
 
 happyReduce_7 = happySpecReduce_3  6 happyReduction_7
 happyReduction_7 (HappyAbsSyn7  happy_var_3)
@@ -408,7 +408,7 @@ happyReduction_7 (HappyAbsSyn7  happy_var_3)
         =  HappyAbsSyn6
                 (RightmostAssign (rightRefVal happy_var_1) happy_var_3
        )
-happyReduction_7 _ _ _  = notHappyAtAll 
+happyReduction_7 _ _ _  = notHappyAtAll
 
 happyReduce_8 = happySpecReduce_2  6 happyReduction_8
 happyReduction_8 (HappyAbsSyn7  happy_var_2)
@@ -416,7 +416,7 @@ happyReduction_8 (HappyAbsSyn7  happy_var_2)
         =  HappyAbsSyn6
                 (Conditional happy_var_2
        )
-happyReduction_8 _ _  = notHappyAtAll 
+happyReduction_8 _ _  = notHappyAtAll
 
 happyReduce_9 = happyReduce 4 7 happyReduction_9
 happyReduction_9 ((HappyAbsSyn7  happy_var_4) `HappyStk`
@@ -434,7 +434,7 @@ happyReduction_10 (HappyAbsSyn7  happy_var_2)
         =  HappyAbsSyn7
                 (happy_var_1 : happy_var_2
        )
-happyReduction_10 _ _  = notHappyAtAll 
+happyReduction_10 _ _  = notHappyAtAll
 
 happyReduce_11 = happySpecReduce_2  7 happyReduction_11
 happyReduction_11 (HappyAbsSyn7  happy_var_2)
@@ -442,7 +442,7 @@ happyReduction_11 (HappyAbsSyn7  happy_var_2)
         =  HappyAbsSyn7
                 (happy_var_1 : happy_var_2
        )
-happyReduction_11 _ _  = notHappyAtAll 
+happyReduction_11 _ _  = notHappyAtAll
 
 happyReduce_12 = happySpecReduce_2  7 happyReduction_12
 happyReduction_12 (HappyAbsSyn7  happy_var_2)
@@ -450,7 +450,7 @@ happyReduction_12 (HappyAbsSyn7  happy_var_2)
         =  HappyAbsSyn7
                 (happy_var_1 : happy_var_2
        )
-happyReduction_12 _ _  = notHappyAtAll 
+happyReduction_12 _ _  = notHappyAtAll
 
 happyReduce_13 = happySpecReduce_2  7 happyReduction_13
 happyReduction_13 (HappyAbsSyn7  happy_var_2)
@@ -458,7 +458,7 @@ happyReduction_13 (HappyAbsSyn7  happy_var_2)
         =  HappyAbsSyn7
                 (happy_var_1 : happy_var_2
        )
-happyReduction_13 _ _  = notHappyAtAll 
+happyReduction_13 _ _  = notHappyAtAll
 
 happyReduce_14 = happySpecReduce_2  7 happyReduction_14
 happyReduction_14 (HappyAbsSyn7  happy_var_2)
@@ -466,7 +466,7 @@ happyReduction_14 (HappyAbsSyn7  happy_var_2)
         =  HappyAbsSyn7
                 (happy_var_1 : happy_var_2
        )
-happyReduction_14 _ _  = notHappyAtAll 
+happyReduction_14 _ _  = notHappyAtAll
 
 happyReduce_15 = happySpecReduce_0  7 happyReduction_15
 happyReduction_15  =  HappyAbsSyn7
@@ -489,7 +489,7 @@ happyReduction_17 (HappyAbsSyn7  happy_var_2)
         =  HappyAbsSyn7
                 (happy_var_1 : happy_var_2
        )
-happyReduction_17 _ _  = notHappyAtAll 
+happyReduction_17 _ _  = notHappyAtAll
 
 happyReduce_18 = happySpecReduce_2  8 happyReduction_18
 happyReduction_18 (HappyAbsSyn7  happy_var_2)
@@ -497,7 +497,7 @@ happyReduction_18 (HappyAbsSyn7  happy_var_2)
         =  HappyAbsSyn7
                 (happy_var_1 : happy_var_2
        )
-happyReduction_18 _ _  = notHappyAtAll 
+happyReduction_18 _ _  = notHappyAtAll
 
 happyReduce_19 = happySpecReduce_2  8 happyReduction_19
 happyReduction_19 (HappyAbsSyn7  happy_var_2)
@@ -505,7 +505,7 @@ happyReduction_19 (HappyAbsSyn7  happy_var_2)
         =  HappyAbsSyn7
                 (happy_var_1 : happy_var_2
        )
-happyReduction_19 _ _  = notHappyAtAll 
+happyReduction_19 _ _  = notHappyAtAll
 
 happyReduce_20 = happySpecReduce_2  8 happyReduction_20
 happyReduction_20 (HappyAbsSyn7  happy_var_2)
@@ -513,7 +513,7 @@ happyReduction_20 (HappyAbsSyn7  happy_var_2)
         =  HappyAbsSyn7
                 (happy_var_1 : happy_var_2
        )
-happyReduction_20 _ _  = notHappyAtAll 
+happyReduction_20 _ _  = notHappyAtAll
 
 happyReduce_21 = happySpecReduce_2  8 happyReduction_21
 happyReduction_21 (HappyAbsSyn7  happy_var_2)
@@ -521,7 +521,7 @@ happyReduction_21 (HappyAbsSyn7  happy_var_2)
         =  HappyAbsSyn7
                 (happy_var_1 : happy_var_2
        )
-happyReduction_21 _ _  = notHappyAtAll 
+happyReduction_21 _ _  = notHappyAtAll
 
 happyReduce_22 = happySpecReduce_2  8 happyReduction_22
 happyReduction_22 (HappyAbsSyn7  happy_var_2)
@@ -529,7 +529,7 @@ happyReduction_22 (HappyAbsSyn7  happy_var_2)
         =  HappyAbsSyn7
                 (happy_var_1 : happy_var_2
        )
-happyReduction_22 _ _  = notHappyAtAll 
+happyReduction_22 _ _  = notHappyAtAll
 
 happyReduce_23 = happySpecReduce_0  8 happyReduction_23
 happyReduction_23  =  HappyAbsSyn7
@@ -537,7 +537,7 @@ happyReduction_23  =  HappyAbsSyn7
        )
 
 happyNewToken action sts stk
-       = agLexer(\tk -> 
+       = agLexer(\tk ->
        let cont i = action i i tk (HappyState action) sts stk in
        case tk of {
        AgTok_EOF -> action 18 18 tk (HappyState action) sts stk;
@@ -577,7 +577,7 @@ happyError = fail ("Parse error\n")
 {-# LINE 1 "<built-in>" #-}
 {-# LINE 1 "<command line>" #-}
 {-# LINE 1 "GenericTemplate.hs" #-}
--- Id: GenericTemplate.hs,v 1.26 2005/01/14 14:47:22 simonmar Exp 
+-- Id: GenericTemplate.hs,v 1.26 2005/01/14 14:47:22 simonmar Exp
 
 {-# LINE 28 "GenericTemplate.hs" #-}
 
@@ -610,7 +610,7 @@ happyParse start_state = happyNewToken start_state notHappyAtAll notHappyAtAll
 -- the stack in this case.
 happyAccept (1) tk st sts (_ `HappyStk` ans `HappyStk` _) =
        happyReturn1 ans
-happyAccept j tk st sts (HappyStk ans _) = 
+happyAccept j tk st sts (HappyStk ans _) =
         (happyReturn1 ans)
 
 -----------------------------------------------------------------------------
@@ -716,7 +716,7 @@ happyGoto action j tk st = action j j tk (HappyState action)
 
 -- parse error if we are in recovery and we fail again
 happyFail  (1) tk old_st _ stk =
---     trace "failing" $ 
+--     trace "failing" $
        happyError_ tk
 
 {-  We don't need state discarding for our restricted implementation of
@@ -724,7 +724,7 @@ happyFail  (1) tk old_st _ stk =
     for now --SDM
 
 -- discard a state
-happyFail  (1) tk old_st (((HappyState (action))):(sts)) 
+happyFail  (1) tk old_st (((HappyState (action))):(sts))
                                                (saved_tok `HappyStk` _ `HappyStk` stk) =
 --     trace ("discarding state, depth " ++ show (length stk))  $
        action (1) (1) tk (HappyState (action)) sts ((saved_tok`HappyStk`stk))
@@ -750,7 +750,7 @@ notHappyAtAll = error "Internal Happy error\n"
 
 
 -----------------------------------------------------------------------------
--- Seq-ing.  If the --strict flag is given, then Happy emits 
+-- Seq-ing.  If the --strict flag is given, then Happy emits
 --     happySeq = happyDoSeq
 -- otherwise it emits
 --     happySeq = happyDontSeq
index b02710c..4f2d9f0 100644 (file)
@@ -14,7 +14,7 @@ Implementation of FIRST
 \subsection{Utilities}
 
 > joinSymSets :: (a -> Set Name) -> [a] -> Set Name
-> joinSymSets f = foldr 
+> joinSymSets f = foldr
 >       (\ h b -> let
 >                   h' = f h
 >                 in
@@ -43,9 +43,9 @@ Does the Set include the $\epsilon$ symbol ?
 >       env = mkClosure (==) (getNext fst_term prodNo prodsOfName)
 >               [ (name,Set.empty) | name <- nts ]
 
-> getNext fst_term prodNo prodsOfName env = 
+> getNext fst_term prodNo prodsOfName env =
 >              [ (nm, next nm) | (nm,_) <- env ]
->    where 
+>    where
 >      fn t | t == errorTok || t >= fst_term = Set.singleton t
 >      fn x = case lookup x env of
 >                      Just t -> t
@@ -53,9 +53,9 @@ Does the Set include the $\epsilon$ symbol ?
 
 >      next :: Name -> Set Name
 >      next t | t >= fst_term = Set.singleton t
->      next n = 
->              foldb Set.union 
->                      [ joinSymSets fn (snd4 (prodNo rl)) | 
+>      next n =
+>              foldb Set.union
+>                      [ joinSymSets fn (snd4 (prodNo rl)) |
 >                              rl <- prodsOfName n ]
 
 My little hack
index a23fb39..e808174 100644 (file)
@@ -6,7 +6,7 @@ All the code below is understood to be in the public domain.
 
 > module GenUtils (
 
->       partition', tack, 
+>       partition', tack,
 >       assocMaybeErr,
 >       arrElem,
 >       memoise,
@@ -24,7 +24,7 @@ All the code below is understood to be in the public domain.
 >       space,
 >       copy,
 >      combinePairs,
->      --trace,                -- re-export it 
+>      --trace,                -- re-export it
 >      fst3,
 >      snd3,
 >      thd3,
@@ -41,7 +41,7 @@ All the code below is understood to be in the public domain.
 
 %------------------------------------------------------------------------------
 
-Here are two defs that everyone seems to define ... 
+Here are two defs that everyone seems to define ...
 HBC has it in one of its builtin modules
 
 > mapMaybe :: (a -> Maybe b) -> [a] -> [b]
@@ -54,7 +54,7 @@ HBC has it in one of its builtin modules
 > maybeMap f (Just a) = Just (f a)
 > maybeMap f Nothing  = Nothing
 
-> joinMaybe :: (a -> a -> a) -> Maybe a -> Maybe a -> Maybe a 
+> joinMaybe :: (a -> a -> a) -> Maybe a -> Maybe a -> Maybe a
 > joinMaybe _ Nothing  Nothing  = Nothing
 > joinMaybe _ (Just g) Nothing  = Just g
 > joinMaybe _ Nothing  (Just g) = Just g
@@ -62,8 +62,8 @@ HBC has it in one of its builtin modules
 
 > data MaybeErr a err = Succeeded a | Failed err deriving (Eq,Show)
 
-@mkClosure@ makes a closure, when given a comparison and iteration loop. 
-Be careful, because if the functional always makes the object different, 
+@mkClosure@ makes a closure, when given a comparison and iteration loop.
+Be careful, because if the functional always makes the object different,
 This will never terminate.
 
 > mkClosure :: (a -> a -> Bool) -> (a -> a) -> a -> a
@@ -76,7 +76,7 @@ This will never terminate.
 > foldb f [] = error "can't reduce an empty list using foldb"
 > foldb f [x] = x
 > foldb f l  = foldb f (foldb' l)
->    where 
+>    where
 >       foldb' (x:y:x':y':xs) = f (f x y) (f x' y') : foldb' xs
 >       foldb' (x:y:xs) = f x y : foldb' xs
 >       foldb' xs = xs
@@ -88,7 +88,7 @@ This will never terminate.
 > handleMaybe m k = case m of
 >                Nothing -> k
 >                _ -> m
+
 > findJust :: (a -> Maybe b) -> [a] -> Maybe b
 > findJust f = foldr handleMaybe Nothing . map f
 
@@ -115,33 +115,33 @@ Gofer-like stuff:
 > partition' :: (Eq b) => (a -> b) -> [a] -> [[a]]
 > partition' f [] = []
 > partition' f [x] = [[x]]
-> partition' f (x:x':xs) | f x == f x' 
+> partition' f (x:x':xs) | f x == f x'
 >    = tack x (partition' f (x':xs))
->                       | otherwise 
+>                       | otherwise
 >    = [x] : partition' f (x':xs)
 
 > tack x xss = (x : head xss) : tail xss
 
 > combinePairs :: (Ord a) => [(a,b)] -> [(a,[b])]
-> combinePairs xs = 
+> combinePairs xs =
 >      combine [ (a,[b]) | (a,b) <- sortBy (\ (a,_) (b,_) -> compare a b) xs]
 >  where
 >      combine [] = []
 >      combine ((a,b):(c,d):r) | a == c = combine ((a,b++d) : r)
 >      combine (a:r) = a : combine r
-> 
+>
 
 > assocMaybeErr :: (Eq a) => [(a,b)] -> a -> MaybeErr b String
 > assocMaybeErr env k = case [ val | (key,val) <- env, k == key] of
 >                        [] -> Failed "assoc: "
 >                        (val:vs) -> Succeeded val
-> 
+>
 
 Now some utilties involving arrays.  Here is a version of @elem@ that
 uses partial application to optimise lookup.
 
 > arrElem :: (Ix a, Ord a) => [a] -> a -> Bool
-> arrElem obj = \x -> inRange size x && arr ! x 
+> arrElem obj = \x -> inRange size x && arr ! x
 >   where
 >       obj' = sort obj
 >       size = (head obj',last obj')
@@ -164,7 +164,7 @@ will give a very efficent variation of the fib function.
 >   where arr = array bds [ (t, f t) | t <- range bds ]
 
 > listArray' :: (Int,Int) -> [a] -> Array Int a
-> listArray' (low,up) elems = 
+> listArray' (low,up) elems =
 >      if length elems /= up-low+1 then error "wibble" else
 >      listArray (low,up) elems
 
@@ -191,12 +191,12 @@ Replace $$ with an arbitrary string, being careful to avoid ".." and '.'.
 
 
 %-------------------------------------------------------------------------------
-Fast string-building functions. 
+Fast string-building functions.
 
 > str = showString
 > char c = (c :)
 > interleave s = foldr (\a b -> a . str s . b) id
-> interleave' s = foldr1 (\a b -> a . str s . b) 
+> interleave' s = foldr1 (\a b -> a . str s . b)
 
 > strspace = char ' '
 > nl = char '\n'
index 03d7497..d990a33 100644 (file)
@@ -7,7 +7,7 @@ The Grammar data type.
 Here is our mid-section datatype
 
 > module Grammar (
->      Name, isEmpty, 
+>      Name, isEmpty,
 >      
 >      Production, Grammar(..), mangler,
 >      
@@ -39,7 +39,7 @@ Here is our mid-section datatype
 
 > type Production = (Name,[Name],(String,[Int]),Priority)
 
-> data Grammar 
+> data Grammar
 >       = Grammar {
 >              productions       :: [Production],
 >              lookupProdNo      :: Int -> Production,
@@ -67,7 +67,7 @@ Here is our mid-section datatype
 #ifdef DEBUG
 
 > instance Show Grammar where
->       showsPrec _ (Grammar 
+>       showsPrec _ (Grammar
 >              { productions           = p
 >              , token_specs           = t
 >               , terminals            = ts
@@ -164,14 +164,14 @@ In hindsight, this was probably a bad idea.
 
 This bit is a real mess, mainly because of the error message support.
 
-> m `thenE` k 
+> m `thenE` k
 >      = case m of
 >              Failed e    -> Failed e
 >              Succeeded a -> case k a of
 >                              Failed e -> Failed e
 >                              Succeeded b -> Succeeded b
 
-> m `parE` k 
+> m `parE` k
 >      = case m of
 >              Failed e    -> case k (error "parE") of
 >                              Failed e' -> Failed (e ++ e')
@@ -192,7 +192,7 @@ This bit is a real mess, mainly because of the error message support.
 
 
 > mangler :: FilePath -> AbsSyn -> MaybeErr Grammar [String]
-> mangler file (AbsSyn hd dirs rules tl) = 
+> mangler file (AbsSyn hd dirs rules tl) =
 
 >        -- add filename to all error messages
 >      failMap (\s -> file ++ ": " ++ s) $
@@ -233,7 +233,7 @@ Build up a mapping from name values to strings.
 >      lookupName :: String -> [Name]
 >      lookupName n = [ t | (t,r) <- name_env, r == n ]
 
->       mapToName str = 
+>       mapToName str =
 >             case lookupName str  of
 >                [a] -> Succeeded a
 >                []  -> Failed ["unknown identifier `" ++ str ++ "'"]
@@ -271,7 +271,7 @@ Deal with priorities...
 
 Translate the rules from string to name-based.
 
->      convNT (nt, prods, ty) 
+>      convNT (nt, prods, ty)
 >        = mapToName nt `thenE` \nt' ->
 >          Succeeded (nt', prods, ty)
 >
@@ -306,7 +306,7 @@ Translate the rules from string to name-based.
 >      parEs (map transRule rules1) `thenE` \rules2 ->
 
 >      let
->      tys = accumArray (\a b -> b) Nothing (first_nt, last_nt) 
+>      tys = accumArray (\a b -> b) Nothing (first_nt, last_nt)
 >                      [ (nm, Just ty) | (nm, _, Just ty) <- rules1 ]
 
 >      env_array :: Array Int String
@@ -315,7 +315,7 @@ Translate the rules from string to name-based.
 
 Get the token specs in terms of Names.
 
->      let 
+>      let
 >      fixTokenSpec (a,b) = mapToName a `thenE` \a -> Succeeded (a,b)
 >      in
 >       parEs (map fixTokenSpec (getTokenSpec dirs)) `thenE` \tokspec ->
@@ -371,7 +371,7 @@ So is this.
 
 > checkRules (name:rest) above nonterms
 >       | name == above = checkRules rest name nonterms
->       | name `elem` nonterms 
+>       | name `elem` nonterms
 >              = Failed ["Multiple rules for `" ++ name ++ "'"]
 >       | otherwise = checkRules rest name (name : nonterms)
 
@@ -409,12 +409,12 @@ So is this.
 
    now check that $i references are in range
 
->            in parEs (map checkArity (mentionedProductions rules)) `thenE` \prods -> 
+>            in parEs (map checkArity (mentionedProductions rules)) `thenE` \prods ->
 
    and output the rules
 
->                formatRules arity attrNames defaultAttr 
->                            allSubProductions selfRules 
+>                formatRules arity attrNames defaultAttr
+>                            allSubProductions selfRules
 >                            subRules conditions `thenE` \rulesStr ->
 
    return the munged code body and all sub-productions mentioned
@@ -436,7 +436,7 @@ So is this.
 >          getTokens (SubAssign _ toks)       = toks
 >          getTokens (Conditional toks)       = toks
 >          getTokens (RightmostAssign _ toks) = toks
->           
+>
 >          checkArity x = if x <= arity then Succeeded x else Failed [show x++" out of range"]
 
 
@@ -445,8 +445,8 @@ So is this.
 -- Actually emit the code for the record bindings and conditionals
 --
 
-> formatRules :: Int -> [String] -> String -> [Name] 
->             -> [AgRule] -> [AgRule] -> [AgRule] 
+> formatRules :: Int -> [String] -> String -> [Name]
+>             -> [AgRule] -> [AgRule] -> [AgRule]
 >             -> MaybeErr String [String]
 
 > formatRules arity attrNames defaultAttr prods selfRules subRules conditions = Succeeded $
@@ -472,7 +472,7 @@ So is this.
 
 >        subProductionRules = concat $ map formatSubRules prods
 
->        formatSubRules i = 
+>        formatSubRules i =
 >           let attrs = fromMaybe [] . lookup i $ subRulesMap
 >               attrUpdates' = concat $ intersperse ", " $ map (formatSubRule i) attrs
 >               attrUpdates  = case attrUpdates' of [] -> []; x -> "{ "++x++" }"
@@ -480,7 +480,7 @@ So is this.
 >                     ," happyEmptyAttrs"
 >                     , attrUpdates
 >                     ]
->         
+>
 >        formattedConditions = concat $ intersperse "++" $ localConditions : (map (\i -> "happyConditions_"++(show i)) prods)
 >        localConditions = "["++(concat $ intersperse ", " $ map formatCondition conditions)++"]"
 >        formatCondition (Conditional toks) = formatTokens toks
@@ -498,10 +498,10 @@ So is this.
 >        formatToken (AgTok_SelfRef [])     = "("++defaultAttr++" happySelfAttrs) "
 >        formatToken (AgTok_SelfRef x)      = "("++x++" happySelfAttrs) "
 >        formatToken (AgTok_RightmostRef x) = formatToken (AgTok_SubRef (arity,x))
->        formatToken (AgTok_SubRef (i,[])) 
+>        formatToken (AgTok_SubRef (i,[]))
 >            | i `elem` prods = "("++defaultAttr++" happySubAttrs_"++(show i)++") "
 >            | otherwise      = mkHappyVar i ++ " "
->        formatToken (AgTok_SubRef (i,x)) 
+>        formatToken (AgTok_SubRef (i,x))
 >            | i `elem` prods = "("++x++" happySubAttrs_"++(show i)++") "
 >            | otherwise      = error "lhs "++(show i)++" is not a non-terminal"
 >        formatToken (AgTok_Unknown x)     = x++" "
@@ -529,19 +529,19 @@ So is this.
 >              '\\':'$':r -> go r ('$':acc) used
 >
 >              '$':'>':r -- the "rightmost token"
->                      | arity == 0 -> Failed [ "$> in empty rule" ] 
+>                      | arity == 0 -> Failed [ "$> in empty rule" ]
 >                      | otherwise  -> go r (reverse (mkHappyVar arity) ++ acc)
 >                                       (arity : used)
 >
->              '$':r@(i:_) | isDigit i -> 
+>              '$':r@(i:_) | isDigit i ->
 >                      case reads r :: [(Int,String)] of
->                        (j,r):_ -> 
->                           if j > arity 
->                                then Failed [ '$': show j ++ " out of range" ] 
+>                        (j,r):_ ->
+>                           if j > arity
+>                                then Failed [ '$': show j ++ " out of range" ]
 >                                      `parE` \_ -> go r acc used
->                                else go r (reverse (mkHappyVar j) ++ acc) 
+>                                else go r (reverse (mkHappyVar j) ++ acc)
 >                                       (j : used)
->                        
+>                      
 >              c:r  -> go r (c:acc) used
 
 > mkHappyVar n         = "happy_var_" ++ show n
@@ -567,15 +567,15 @@ So is this.
 
 > type ActionTable = Array Int{-state-} (Array Int{-terminal#-} LRAction)
 
- instance Text LRAction where 
+ instance Text LRAction where
    showsPrec _ (LR'Shift i _)  = showString ("s" ++ show i)
-   showsPrec _ (LR'Reduce i _) 
+   showsPrec _ (LR'Reduce i _)
        = showString ("r" ++ show i)
    showsPrec _ (LR'Accept)     = showString ("acc")
    showsPrec _ (LR'Fail)       = showString (" ")
- instance Eq LRAction where { (==) = primGenericEq } 
+ instance Eq LRAction where { (==) = primGenericEq }
 
-> data Goto = Goto Int | NoGoto 
+> data Goto = Goto Int | NoGoto
 >       deriving(Eq
 
 #ifdef DEBUG
index f2012dd..373a4b8 100644 (file)
@@ -31,7 +31,7 @@ Produce a file of parser information, useful for debugging the parser.
 >      -> [String]                     -- unused terminals
 >      -> String
 
-> genInfoFile items 
+> genInfoFile items
 >      (Grammar { productions = prods
 >               , lookupProdNo = lookupProd
 >               , lookupProdsOfName = lookupProdNos
@@ -45,16 +45,16 @@ Produce a file of parser information, useful for debugging the parser.
 >      = (showHeader
 >      . showConflicts
 >      . showUnused
->      . showProductions 
->      . showTerminals 
->      . showNonTerminals 
+>      . showProductions
+>      . showTerminals
+>      . showNonTerminals
 >      . showStates
 >      . showStats
 >      ) ""
 >   where
 
->   showHeader 
->      = banner ("Info file generated by Happy Version " ++ 
+>   showHeader
+>      = banner ("Info file generated by Happy Version " ++
 >                showVersion version ++ " from " ++ filename)
 
 >   showConflicts
@@ -68,7 +68,7 @@ Produce a file of parser information, useful for debugging the parser.
 >      . shows state
 >      . str " contains "
 >      . interleave' " and " (
->              (if sr /= 0 
+>              (if sr /= 0
 >                      then [ shows sr . str " shift/reduce conflicts" ]
 >                      else []) ++
 >               if rr /= 0
@@ -80,25 +80,25 @@ Produce a file of parser information, useful for debugging the parser.
 >        (case unused_rules of
 >          [] -> id
 >          _  ->   interleave "\n" (
->                      map (\r ->   str "rule " 
->                                 . shows r 
+>                      map (\r ->   str "rule "
+>                                 . shows r
 >                                 . str " is unused")
 >                              unused_rules)
 >                . str "\n")
 >      . (case unused_terminals of
 >          [] -> id
 >          _  ->   interleave "\n" (
->                      map (\t ->   str "terminal " 
->                                 . str t 
+>                      map (\t ->   str "terminal "
+>                                 . str t
 >                                 . str " is unused")
 >                              unused_terminals)
 >                . str "\n")
 
->   showProductions = 
+>   showProductions =
 >        banner "Grammar"
 >      . interleave "\n" (zipWith showProduction prods [ 0 :: Int .. ])
 >      . str "\n"
-  
+
 >   showProduction (nt, toks, sem, prec) i
 >      = ljuststr 50 (
 >        str "\t"
@@ -109,7 +109,7 @@ Produce a file of parser information, useful for debugging the parser.
 
 >   showStates =
 >        banner "States"
->      . interleave "\n" (zipWith showState 
+>      . interleave "\n" (zipWith showState
 >              (map Set.toAscList items) [ 0 :: Int .. ])
 
 >   showState state n
@@ -155,8 +155,8 @@ Produce a file of parser information, useful for debugging the parser.
 >   showAction' (LR'Multiple as a)
 >      = showAction' a
 >      . str "\n"
->      . interleave "\n" 
->              (map (\a -> str "\t\t\t(" . showAction' a . str ")") 
+>      . interleave "\n"
+>              (map (\a -> str "\t\t\t(" . showAction' a . str ")")
 >               (nub (filter (/= a) as)))
 
 >   showGoto (nt, NoGoto)
@@ -192,7 +192,7 @@ Produce a file of parser information, useful for debugging the parser.
 >      . foldr1 (\a b -> a . str ", " . b) nt_rules
 >      where nt_rules = map shows (lookupProdNos nt)
 
->   showStats 
+>   showStats
 >      = banner "Grammar Totals"
 >      . str   "Number of rules: " . shows (length prods)
 >      . str "\nNumber of terminals: " . shows (length tokens)
@@ -206,7 +206,7 @@ Produce a file of parser information, useful for debugging the parser.
 
 > ljuststr n s = str (ljustify n (s ""))
 
-> banner s 
+> banner s
 >      = str "-----------------------------------------------------------------------------\n"
 >      . str s
 >      . str "\n-----------------------------------------------------------------------------\n"
index 08a99b3..fa217d3 100644 (file)
@@ -39,7 +39,7 @@ Precalculate the rule closure for each non-terminal in the grammar,
 using a memo table so that no work is repeated.
 
 > precalcClosure0 :: Grammar -> Name -> RuleList
-> precalcClosure0 g = 
+> precalcClosure0 g =
 >      \n -> case lookup n info' of
 >              Nothing -> []
 >              Just c  -> c
@@ -56,7 +56,7 @@ using a memo table so that no work is repeated.
 >      follow f (nt,rules) = (nt, unionMap (followNT f) rules `Set.union` rules)
 
 >      followNT :: [(Name, Set Int)] -> Int -> Set Int
->      followNT f rule = 
+>      followNT f rule =
 >              case findRule g rule 0 of
 >                      Just nt | nt >= firstStartTok && nt < fst_term ->
 >                              case lookup nt f of
@@ -72,10 +72,10 @@ using a memo table so that no work is repeated.
 >    where
 >      fst_term = first_term g
 >      addRules rule set = Set.union (Set.fromList (rule : closureOfRule rule)) set
-> 
->      closureOfRule (rule,dot) = 
->           case findRule g rule dot of 
->              (Just nt) | nt >= firstStartTok && nt < fst_term 
+>
+>      closureOfRule (rule,dot) =
+>           case findRule g rule dot of
+>              (Just nt) | nt >= firstStartTok && nt < fst_term
 >                 -> closureOfNT nt
 >               _  -> []
 
@@ -92,7 +92,7 @@ Generating the closure of a set of LR(1) items
 >      addItems (old_items, new_items) = (new_old_items, new_new_items)
 >        where
 >              new_old_items = new_items `union_items` old_items
->              new_new_items = subtract_items 
+>              new_new_items = subtract_items
 >                                 (foldr union_items [] (map fn new_items))
 >                                      new_old_items
 
@@ -101,7 +101,7 @@ Generating the closure of a set of LR(1) items
 >                  case lookupProdNo g rule of { (name,lhs,_,_) ->
 >                  case drop dot lhs of
 >                      (b:beta) | b >= firstStartTok && b < fst_term ->
->                          let terms = unionMap 
+>                          let terms = unionMap
 >                                              (\a -> first (beta ++ [a])) as
 >                          in
 >                          [ (rule,0,terms) | rule <- lookupProdsOfName g b ]
@@ -162,7 +162,7 @@ items for the set of items goto(I,X)
 >       fn (rule_no,dot) =
 >          case findRule gram rule_no dot of
 >               Just t | x == t -> Set.singleton (rule_no,dot+1)
->               _ -> Set.empty           
+>               _ -> Set.empty
 
 -----------------------------------------------------------------------------
 Generating LR0 Item sets
@@ -192,7 +192,7 @@ information about which sets were generated by which others.
 
 >    addItems :: ([ItemSetWithGotos], [Set Lr0Item])
 >            -> ([ItemSetWithGotos], [Set Lr0Item])
->            
+>      
 >    addItems (oldSets,newSets) = (newOldSets, reverse newNewSets)
 >     where
 >      
@@ -222,8 +222,8 @@ numberSets.
 numberSets is built this way so we can use it quite neatly with a foldr.
 Unfortunately, the code's a little opaque.
 
->      numberSets 
->              :: [(Name,Set Lr0Item)] 
+>      numberSets
+>              :: [(Name,Set Lr0Item)]
 >              -> (Int,
 >                  [[(Name,Int)]],
 >                  [Set Lr0Item])
@@ -254,7 +254,7 @@ Computing propagation of lookaheads
 ToDo: generate this info into an array to be used in the subsequent
 calcLookaheads pass.
 
-> propLookaheads 
+> propLookaheads
 >      :: Grammar
 >      -> [(Set Lr0Item,[(Name,Int)])]         -- LR(0) kernel sets
 >      -> ([Name] -> Set Name)                 -- First function
@@ -263,7 +263,7 @@ calcLookaheads pass.
 >              Array Int [(Lr0Item, Int, Lr0Item)]     -- propagated lookaheads
 >         )
 
-> propLookaheads gram sets first = (concat s, array (0,length sets - 1) 
+> propLookaheads gram sets first = (concat s, array (0,length sets - 1)
 >                      [ (a,b) | (a,b) <- p ])
 >   where
 
@@ -280,9 +280,9 @@ calcLookaheads pass.
 >        start_info = starts gram      
 
 >        start_spont :: [(Int, Lr0Item ,Set Name)]
->        start_spont   = [ (start, (start,0), 
+>        start_spont   = [ (start, (start,0),
 >                           Set.singleton (startLookahead gram partial))
->                        | (start, (_,_,_,partial)) <- 
+>                        | (start, (_,_,_,partial)) <-
 >                              zip [ 0 .. length start_info - 1] start_info]
 
 >        propLAItem :: Lr0Item -> ([(Int, Lr0Item, Set Name)], [(Lr0Item, Int, Lr0Item)])
@@ -292,7 +292,7 @@ calcLookaheads pass.
 >              j = closure1 gram first [(rule,dot,Set.singleton dummyTok)]
 
 >              spontaneous :: [(Int, Lr0Item, Set Name)]
->              spontaneous = concat [ 
+>              spontaneous = concat [
 >               (case findRule gram rule dot of
 >                   Nothing -> []
 >                   Just x  -> case lookup x goto of
@@ -342,9 +342,9 @@ Special version using a mutable array:
 >      propagate :: STArray s Int [(Lr0Item, Set Name)]
 >                       -> [(Int, Lr0Item, Set Name)] -> ST s ()
 >      propagate array []  = return ()
->      propagate array new = do 
+>      propagate array new = do
 >              let
->                 items = [ (i,item'',s) | (j,item,s) <- new, 
+>                 items = [ (i,item'',s) | (j,item,s) <- new,
 >                                          (item',i,item'') <- prop ! j,
 >                                          item == item' ]
 >              new_new <- get_new array items []
@@ -381,7 +381,7 @@ the spontaneous lookaheads in the right form to begin with (ToDo).
 >              let s'' = Set.filter (\x -> not (Set.member x s')) s in
 >              if Set.null s'' then new else
 >              ((i,item,s''):new)
->      | otherwise = 
+>      | otherwise =
 >              get_new' l las new
 
 > fold_lookahead :: (Int,Lr0Item,Set Name) -> [(Int,Lr0Item,Set Name)]
@@ -409,9 +409,9 @@ calcLookaheads n_states spont prop
         rebuildArray xs = accumArray (++) [] (0,n_states-1)
                      [ (a, [(b,c)]) | (a,b,c) <- xs ]
 
-        propagate (las,new) = 
+        propagate (las,new) =
        let
-          items = [ (i,item'',s) | (j,item,s) <- new, 
+          items = [ (i,item'',s) | (j,item,s) <- new,
                               (item',i,item'') <- prop ! j,
                               item == item' ]
           new_new = foldr (\i new -> getNew i las new) [] items
@@ -431,7 +431,7 @@ getNew :: (Int,Lr0Item,Set Name) -> [(Int,Lr0Item,Set Name)]
       -> [(Int,Lr0Item,Set Name)] -> [(Int,Lr0Item,Set Name)]
 getNew l [] new = l:new
 getNew l@(i,item,s) (m@(i',item',s'):las) new
-       | i == i' && item == item' = 
+       | i == i' && item == item' =
        let s'' = filter (`notElem` s') s in
        if null s'' then new else
        ((i,item,s''):new)
@@ -484,7 +484,7 @@ Generating the goto table doesn't need lookahead info.
 >      -- goto array doesn't include %start symbols
 >       gotoTable  = listArray (0,length sets-1)
 >         [
->           (array (fst_nonterm, fst_term-1) [ 
+>           (array (fst_nonterm, fst_term-1) [
 >              (n, case lookup n goto of
 >                      Nothing -> NoGoto
 >                      Just s  -> Goto s)
@@ -510,13 +510,13 @@ Generate the action table
 >       term_lim = (head terms,last terms)
 >       actionTable = array (0,length sets-1)
 >             [ (set_no, accumArray res
->                               LR'Fail term_lim 
+>                               LR'Fail term_lim
 >                              (possActions goto set))
 >                   | ((set,goto),set_no) <- zip sets [0..] ]
 
->       possAction goto set (rule,pos,la) = 
+>       possAction goto set (rule,pos,la) =
 >          case findRule g rule pos of
->               Just t | t >= fst_term || t == errorTok -> 
+>               Just t | t >= fst_term || t == errorTok ->
 >                      case lookup t goto of
 >                              Nothing -> []
 >                               Just j  ->
@@ -527,12 +527,12 @@ Generate the action table
 >                 | isStartRule rule
 >                 -> let (_,_,_,partial) = starts !! rule in
 >                    [ (startLookahead g partial, LR'Accept{-'-}) ]
->                  | otherwise   
+>                  | otherwise
 >                 -> case lookupProdNo g rule of
 >                          (_,_,_,p) -> zip (Set.toAscList la) (repeat (LR'Reduce rule p))
 >               _ -> []
 
->      possActions goto coll = 
+>      possActions goto coll =
 >              (concat [ possAction goto coll item |
 >                              item <- closure1 g first coll ])
 
@@ -562,8 +562,8 @@ NOTE: on (LR'Multiple as a) handling
         * the winning action appears only once, in the "a" slot
        * only reductions appear in the "as" list
        * there are no duplications
-      This removes complications elsewhere, where LR'Multiples were 
-      building up tree structures... 
+      This removes complications elsewhere, where LR'Multiples were
+      building up tree structures...
 
 >       res LR'Fail x = x
 >       res x LR'Fail = x
@@ -578,18 +578,18 @@ NOTE: on (LR'Multiple as a) handling
 >              -- merge dropped reductions for identical action
 
 >      res a@(LR'Multiple as x) b@(LR'Multiple bs x')
->             = case res x x' of 
->                 LR'Multiple cs a 
+>             = case res x x' of
+>                 LR'Multiple cs a
 >                   | a == x    -> LR'Multiple (nub $ x' : as ++ bs ++ cs) x
 >                   | a == x'   -> LR'Multiple (nub $ x  : as ++ bs ++ cs) x'
 >                   | otherwise -> error "failed invariant in resolve"
 >                              -- last means an unexpected change
 >                 other -> other
->              -- merge dropped reductions for clashing actions, but only 
+>              -- merge dropped reductions for clashing actions, but only
 >              -- if they were S/R or R/R
 
 >      res a@(LR'Multiple _ _) b = res a (LR'Multiple [] b)
->      res a b@(LR'Multiple _ _) = res (LR'Multiple [] a) b 
+>      res a b@(LR'Multiple _ _) = res (LR'Multiple [] a) b
 >        -- leave cases above to do the appropriate merging
 
 >       res a@(LR'Shift s p) b@(LR'Reduce s' p') = res b a
@@ -622,18 +622,18 @@ Count the conflicts
 > countConflicts :: ActionTable -> (Array Int (Int,Int), (Int,Int))
 > countConflicts action
 >   = (conflictArray, foldr (\(a,b) (c,d) -> (a+c, b+d)) (0,0) conflictList)
->   
+>
 >   where
->         
+>      
 >      conflictArray = listArray (Array.bounds action) conflictList
 >      conflictList  = map countConflictsState (assocs action)
 >
->      countConflictsState (state, actions) 
+>      countConflictsState (state, actions)
 >        = foldr countMultiples (0,0) (elems actions)
 >        where
->          countMultiples (LR'Multiple (_:_) (LR'Shift{})) (sr,rr) 
+>          countMultiples (LR'Multiple (_:_) (LR'Shift{})) (sr,rr)
 >              = (sr + 1, rr)
->          countMultiples (LR'Multiple (_:_) (LR'Reduce{})) (sr,rr) 
+>          countMultiples (LR'Multiple (_:_) (LR'Reduce{})) (sr,rr)
 >              = (sr, rr + 1)
 >          countMultiples (LR'Multiple as a) (sr,rr)
 >              = error "bad conflict representation"
@@ -642,7 +642,7 @@ Count the conflicts
 -----------------------------------------------------------------------------
 
 > findRule :: Grammar -> Int -> Int -> Maybe Name
-> findRule g rule dot = 
+> findRule g rule dot =
 >      case lookupProdNo g rule of
 >         (_,lhs,_,_) -> case drop dot lhs of
 >                          (a:_) -> Just a
index dcbc3fb..bc6b2c8 100644 (file)
@@ -9,11 +9,11 @@ The lexer.
 >       TokenId(..),
 >       lexer ) where
 
-> import ParseMonad        
+> import ParseMonad
 
 > import Data.Char ( isSpace, isAlphaNum, isDigit, digitToInt )
 
-> data Token 
+> data Token
 >       = TokenInfo String TokenId
 >       | TokenNum  Int    TokenId
 >       | TokenKW          TokenId
@@ -30,7 +30,7 @@ The lexer.
 > instance Ord Token where
 >       i <= i' = tokenToId i <= tokenToId i'
 
-> data TokenId 
+> data TokenId
 >       = TokId                 -- words and symbols
 >       | TokSpecId_TokenType   -- %tokentype
 >       | TokSpecId_Token       -- %token
@@ -88,17 +88,17 @@ ToDo: proper text instance here, for use in parser error messages.
 >      '{'     -> lexCode cont
 >      c       
 >        | isSpace c -> runP (lexer cont)
->        |  c >= 'a' && c <= 'z' 
+>        |  c >= 'a' && c <= 'z'
 >           || c >= 'A' && c <= 'Z' -> lexId cont c
 >         | isDigit c -> lexNum cont c
 >      c       -> lexError ("lexical error before `" ++ c : "'")
 
-Percents come in two forms, in pairs, or 
+Percents come in two forms, in pairs, or
 followed by a special identifier.
 
 > lexPercent cont s = case s of
 >      '%':rest -> returnToken cont (TokenKW TokDoublePercent) rest
->      't':'o':'k':'e':'n':'t':'y':'p':'e':rest -> 
+>      't':'o':'k':'e':'n':'t':'y':'p':'e':rest ->
 >              returnToken cont (TokenKW TokSpecId_TokenType) rest
 >      't':'o':'k':'e':'n':rest ->
 >              returnToken cont (TokenKW TokSpecId_Token) rest
@@ -128,29 +128,29 @@ followed by a special identifier.
 >               returnToken cont (TokenKW TokSpecId_Attributetype) rest
 >       'a':'t':'t':'r':'i':'b':'u':'t':'e':rest ->
 >               returnToken cont (TokenKW TokSpecId_Attribute) rest
->      _ -> lexError ("unrecognised directive: %" ++ 
+>      _ -> lexError ("unrecognised directive: %" ++
 >                              takeWhile (not.isSpace) s) s
 
 > lexColon cont (':':rest) = returnToken cont (TokenKW TokDoubleColon) rest
 > lexColon cont rest       = returnToken cont (TokenKW TokColon) rest
 
-> lexId cont c rest = 
+> lexId cont c rest =
 >      readId rest (\ id rest' -> returnToken cont (TokenInfo (c:id) TokId) rest')
 
-> lexChar cont rest = lexReadChar rest 
+> lexChar cont rest = lexReadChar rest
 >      (\ id -> returnToken cont (TokenInfo ("'" ++ id ++ "'") TokId))
 
-> lexString cont rest = lexReadString rest 
+> lexString cont rest = lexReadString rest
 >      (\ id -> returnToken cont (TokenInfo ("\"" ++ id ++ "\"") TokId))
 
 > lexCode cont rest = lexReadCode rest 0 "" cont
 
-> lexNum cont c rest = 
->        readNum rest (\ num rest' -> 
+> lexNum cont c rest =
+>        readNum rest (\ num rest' ->
 >                         returnToken cont (TokenNum (stringToInt (c:num)) TokNum) rest')
 >  where stringToInt = foldl (\n c -> digitToInt c + 10*n) 0
 
-> cleanupCode s = 
+> cleanupCode s =
 >    dropWhile isSpace (reverse (dropWhile isSpace (reverse s)))
 
 This has to match for @}@ that are {\em not} in strings.  The code
@@ -166,12 +166,12 @@ here is a bit tricky, but should work in most cases.
 >                              cleanupCode (reverse c)) TokCodeQuote) r
 >              | otherwise -> lexReadCode r (n-1) ('}':c)
 >
->      '"'{-"-}:r -> lexReadString r (\ str r' -> 
+>      '"'{-"-}:r -> lexReadString r (\ str r' ->
 >                    lexReadCode r' n ('"' : (reverse str) ++ '"' : c))
 >
 >      a: '\'':r | isAlphaNum a -> lexReadCode r n ('\'':a:c)
 >
->      '\'' :r -> lexReadChar r (\ str r' -> 
+>      '\'' :r -> lexReadChar r (\ str r' ->
 >                 lexReadCode r' n ('\'' : (reverse str) ++ '\'' : c))
 >
 >      ch:r -> lexReadCode r n (ch:c)
@@ -190,9 +190,9 @@ Utilities that read the rest of a token.
 
 > isIdPart :: Char -> Bool
 > isIdPart c =
->         c >= 'a' && c <= 'z' 
->      || c >= 'A' && c <= 'Z' 
->      || c >= '0' && c <= '9' 
+>         c >= 'a' && c <= 'z'
+>      || c >= 'A' && c <= 'Z'
+>      || c >= '0' && c <= '9'
 >      || c == '_'
 
 > lexReadChar :: String -> (String -> String -> a) -> a
@@ -211,10 +211,10 @@ Utilities that read the rest of a token.
 
 > lexError err = runP (lineP >>= \l -> fail (show l ++ ": " ++ err ++ "\n"))
 
-> lexNestedComment l cont r = 
+> lexNestedComment l cont r =
 >   case r of
 >      '-':'}':r -> cont r
->      '{':'-':r -> \line -> lexNestedComment line 
+>      '{':'-':r -> \line -> lexNestedComment line
 >                      (\r -> lexNestedComment l cont r) r line
 >      '\n':r    -> \line -> lexNestedComment l cont r (line+1)
 >      c:r       -> lexNestedComment l cont r
index d4e1f48..c3bde90 100644 (file)
@@ -5,7 +5,7 @@ import Lexer
 
 -- parser produced by Happy Version 1.16
 
-data HappyAbsSyn 
+data HappyAbsSyn
        = HappyTerminal Token
        | HappyErrorToken Int
        | HappyAbsSyn4 (AbsSyn)
@@ -20,12 +20,12 @@ data HappyAbsSyn
        | HappyAbsSyn14 ((String,String))
        | HappyAbsSyn15 ([String])
 
-type HappyReduction m = 
-          Int 
+type HappyReduction m =
+          Int
        -> (Token)
        -> HappyState (Token) (HappyStk HappyAbsSyn -> m HappyAbsSyn)
-       -> [HappyState (Token) (HappyStk HappyAbsSyn -> m HappyAbsSyn)] 
-       -> HappyStk HappyAbsSyn 
+       -> [HappyState (Token) (HappyStk HappyAbsSyn -> m HappyAbsSyn)]
+       -> HappyStk HappyAbsSyn
        -> m HappyAbsSyn
 
 action_0,
@@ -412,14 +412,14 @@ happyReduction_2 (HappyAbsSyn6  happy_var_2)
         =  HappyAbsSyn5
                 (happy_var_2 : happy_var_1
        )
-happyReduction_2 _ _  = notHappyAtAll 
+happyReduction_2 _ _  = notHappyAtAll
 
 happyReduce_3 = happySpecReduce_1  5 happyReduction_3
 happyReduction_3 (HappyAbsSyn6  happy_var_1)
         =  HappyAbsSyn5
                 ([happy_var_1]
        )
-happyReduction_3 _  = notHappyAtAll 
+happyReduction_3 _  = notHappyAtAll
 
 happyReduce_4 = happyReduce 5 6 happyReduction_4
 happyReduction_4 ((HappyAbsSyn7  happy_var_5) `HappyStk`
@@ -451,7 +451,7 @@ happyReduction_6 (HappyAbsSyn7  happy_var_3)
         =  HappyAbsSyn6
                 ((happy_var_1,happy_var_3,Nothing)
        )
-happyReduction_6 _ _ _  = notHappyAtAll 
+happyReduction_6 _ _ _  = notHappyAtAll
 
 happyReduce_7 = happySpecReduce_3  7 happyReduction_7
 happyReduction_7 (HappyAbsSyn7  happy_var_3)
@@ -460,14 +460,14 @@ happyReduction_7 (HappyAbsSyn7  happy_var_3)
         =  HappyAbsSyn7
                 (happy_var_1 : happy_var_3
        )
-happyReduction_7 _ _ _  = notHappyAtAll 
+happyReduction_7 _ _ _  = notHappyAtAll
 
 happyReduce_8 = happySpecReduce_1  7 happyReduction_8
 happyReduction_8 (HappyAbsSyn8  happy_var_1)
         =  HappyAbsSyn7
                 ([happy_var_1]
        )
-happyReduction_8 _  = notHappyAtAll 
+happyReduction_8 _  = notHappyAtAll
 
 happyReduce_9 = happyMonadReduce 4 8 happyReduction_9
 happyReduction_9 (_ `HappyStk`
@@ -492,7 +492,7 @@ happyReduction_11 (HappyTerminal (TokenInfo happy_var_2 TokId))
         =  HappyAbsSyn9
                 (Just happy_var_2
        )
-happyReduction_11 _ _  = notHappyAtAll 
+happyReduction_11 _ _  = notHappyAtAll
 
 happyReduce_12 = happySpecReduce_0  9 happyReduction_12
 happyReduction_12  =  HappyAbsSyn9
@@ -505,14 +505,14 @@ happyReduction_13 (HappyAbsSyn11  happy_var_2)
         =  HappyAbsSyn10
                 (happy_var_2 : happy_var_1
        )
-happyReduction_13 _ _  = notHappyAtAll 
+happyReduction_13 _ _  = notHappyAtAll
 
 happyReduce_14 = happySpecReduce_1  10 happyReduction_14
 happyReduction_14 (HappyAbsSyn11  happy_var_1)
         =  HappyAbsSyn10
                 ([happy_var_1]
        )
-happyReduction_14 _  = notHappyAtAll 
+happyReduction_14 _  = notHappyAtAll
 
 happyReduce_15 = happySpecReduce_2  11 happyReduction_15
 happyReduction_15 (HappyTerminal (TokenInfo happy_var_2 TokCodeQuote))
@@ -520,7 +520,7 @@ happyReduction_15 (HappyTerminal (TokenInfo happy_var_2 TokCodeQuote))
         =  HappyAbsSyn11
                 (TokenType happy_var_2
        )
-happyReduction_15 _ _  = notHappyAtAll 
+happyReduction_15 _ _  = notHappyAtAll
 
 happyReduce_16 = happySpecReduce_2  11 happyReduction_16
 happyReduction_16 (HappyAbsSyn13  happy_var_2)
@@ -528,7 +528,7 @@ happyReduction_16 (HappyAbsSyn13  happy_var_2)
         =  HappyAbsSyn11
                 (TokenSpec happy_var_2
        )
-happyReduction_16 _ _  = notHappyAtAll 
+happyReduction_16 _ _  = notHappyAtAll
 
 happyReduce_17 = happySpecReduce_3  11 happyReduction_17
 happyReduction_17 (HappyAbsSyn9  happy_var_3)
@@ -537,7 +537,7 @@ happyReduction_17 (HappyAbsSyn9  happy_var_3)
         =  HappyAbsSyn11
                 (TokenName happy_var_2 happy_var_3 False
        )
-happyReduction_17 _ _ _  = notHappyAtAll 
+happyReduction_17 _ _ _  = notHappyAtAll
 
 happyReduce_18 = happySpecReduce_3  11 happyReduction_18
 happyReduction_18 (HappyAbsSyn9  happy_var_3)
@@ -546,7 +546,7 @@ happyReduction_18 (HappyAbsSyn9  happy_var_3)
         =  HappyAbsSyn11
                 (TokenName happy_var_2 happy_var_3 True
        )
-happyReduction_18 _ _ _  = notHappyAtAll 
+happyReduction_18 _ _ _  = notHappyAtAll
 
 happyReduce_19 = happySpecReduce_1  11 happyReduction_19
 happyReduction_19 _
@@ -561,7 +561,7 @@ happyReduction_20 (HappyTerminal (TokenInfo happy_var_3 TokCodeQuote))
         =  HappyAbsSyn11
                 (TokenLexer happy_var_2 happy_var_3
        )
-happyReduction_20 _ _ _  = notHappyAtAll 
+happyReduction_20 _ _ _  = notHappyAtAll
 
 happyReduce_21 = happySpecReduce_2  11 happyReduction_21
 happyReduction_21 (HappyTerminal (TokenInfo happy_var_2 TokCodeQuote))
@@ -569,7 +569,7 @@ happyReduction_21 (HappyTerminal (TokenInfo happy_var_2 TokCodeQuote))
         =  HappyAbsSyn11
                 (TokenMonad "()" happy_var_2 ">>=" "return"
        )
-happyReduction_21 _ _  = notHappyAtAll 
+happyReduction_21 _ _  = notHappyAtAll
 
 happyReduce_22 = happySpecReduce_3  11 happyReduction_22
 happyReduction_22 (HappyTerminal (TokenInfo happy_var_3 TokCodeQuote))
@@ -578,7 +578,7 @@ happyReduction_22 (HappyTerminal (TokenInfo happy_var_3 TokCodeQuote))
         =  HappyAbsSyn11
                 (TokenMonad happy_var_2 happy_var_3 ">>=" "return"
        )
-happyReduction_22 _ _ _  = notHappyAtAll 
+happyReduction_22 _ _ _  = notHappyAtAll
 
 happyReduce_23 = happyReduce 4 11 happyReduction_23
 happyReduction_23 ((HappyTerminal (TokenInfo happy_var_4 TokCodeQuote)) `HappyStk`
@@ -607,7 +607,7 @@ happyReduction_25 (HappyAbsSyn15  happy_var_2)
         =  HappyAbsSyn11
                 (TokenNonassoc happy_var_2
        )
-happyReduction_25 _ _  = notHappyAtAll 
+happyReduction_25 _ _  = notHappyAtAll
 
 happyReduce_26 = happySpecReduce_2  11 happyReduction_26
 happyReduction_26 (HappyAbsSyn15  happy_var_2)
@@ -615,7 +615,7 @@ happyReduction_26 (HappyAbsSyn15  happy_var_2)
         =  HappyAbsSyn11
                 (TokenRight happy_var_2
        )
-happyReduction_26 _ _  = notHappyAtAll 
+happyReduction_26 _ _  = notHappyAtAll
 
 happyReduce_27 = happySpecReduce_2  11 happyReduction_27
 happyReduction_27 (HappyAbsSyn15  happy_var_2)
@@ -623,7 +623,7 @@ happyReduction_27 (HappyAbsSyn15  happy_var_2)
         =  HappyAbsSyn11
                 (TokenLeft happy_var_2
        )
-happyReduction_27 _ _  = notHappyAtAll 
+happyReduction_27 _ _  = notHappyAtAll
 
 happyReduce_28 = happySpecReduce_2  11 happyReduction_28
 happyReduction_28 (HappyTerminal (TokenNum happy_var_2  TokNum))
@@ -631,7 +631,7 @@ happyReduction_28 (HappyTerminal (TokenNum happy_var_2  TokNum))
         =  HappyAbsSyn11
                 (TokenExpect happy_var_2
        )
-happyReduction_28 _ _  = notHappyAtAll 
+happyReduction_28 _ _  = notHappyAtAll
 
 happyReduce_29 = happySpecReduce_2  11 happyReduction_29
 happyReduction_29 (HappyTerminal (TokenInfo happy_var_2 TokCodeQuote))
@@ -639,7 +639,7 @@ happyReduction_29 (HappyTerminal (TokenInfo happy_var_2 TokCodeQuote))
         =  HappyAbsSyn11
                 (TokenError happy_var_2
        )
-happyReduction_29 _ _  = notHappyAtAll 
+happyReduction_29 _ _  = notHappyAtAll
 
 happyReduce_30 = happySpecReduce_2  11 happyReduction_30
 happyReduction_30 (HappyTerminal (TokenInfo happy_var_2 TokCodeQuote))
@@ -647,7 +647,7 @@ happyReduction_30 (HappyTerminal (TokenInfo happy_var_2 TokCodeQuote))
         =  HappyAbsSyn11
                 (TokenAttributetype happy_var_2
        )
-happyReduction_30 _ _  = notHappyAtAll 
+happyReduction_30 _ _  = notHappyAtAll
 
 happyReduce_31 = happySpecReduce_3  11 happyReduction_31
 happyReduction_31 (HappyTerminal (TokenInfo happy_var_3 TokCodeQuote))
@@ -656,14 +656,14 @@ happyReduction_31 (HappyTerminal (TokenInfo happy_var_3 TokCodeQuote))
         =  HappyAbsSyn11
                 (TokenAttribute happy_var_2 happy_var_3
        )
-happyReduction_31 _ _ _  = notHappyAtAll 
+happyReduction_31 _ _ _  = notHappyAtAll
 
 happyReduce_32 = happySpecReduce_1  12 happyReduction_32
 happyReduction_32 (HappyTerminal (TokenInfo happy_var_1 TokId))
         =  HappyAbsSyn9
                 (Just happy_var_1
        )
-happyReduction_32 _  = notHappyAtAll 
+happyReduction_32 _  = notHappyAtAll
 
 happyReduce_33 = happySpecReduce_0  12 happyReduction_33
 happyReduction_33  =  HappyAbsSyn9
@@ -676,14 +676,14 @@ happyReduction_34 (HappyAbsSyn13  happy_var_2)
         =  HappyAbsSyn13
                 (happy_var_1:happy_var_2
        )
-happyReduction_34 _ _  = notHappyAtAll 
+happyReduction_34 _ _  = notHappyAtAll
 
 happyReduce_35 = happySpecReduce_1  13 happyReduction_35
 happyReduction_35 (HappyAbsSyn14  happy_var_1)
         =  HappyAbsSyn13
                 ([happy_var_1]
        )
-happyReduction_35 _  = notHappyAtAll 
+happyReduction_35 _  = notHappyAtAll
 
 happyReduce_36 = happySpecReduce_2  14 happyReduction_36
 happyReduction_36 (HappyTerminal (TokenInfo happy_var_2 TokCodeQuote))
@@ -691,7 +691,7 @@ happyReduction_36 (HappyTerminal (TokenInfo happy_var_2 TokCodeQuote))
         =  HappyAbsSyn14
                 ((happy_var_1,happy_var_2)
        )
-happyReduction_36 _ _  = notHappyAtAll 
+happyReduction_36 _ _  = notHappyAtAll
 
 happyReduce_37 = happySpecReduce_2  15 happyReduction_37
 happyReduction_37 (HappyAbsSyn15  happy_var_2)
@@ -699,7 +699,7 @@ happyReduction_37 (HappyAbsSyn15  happy_var_2)
         =  HappyAbsSyn15
                 (happy_var_1 : happy_var_2
        )
-happyReduction_37 _ _  = notHappyAtAll 
+happyReduction_37 _ _  = notHappyAtAll
 
 happyReduce_38 = happySpecReduce_0  15 happyReduction_38
 happyReduction_38  =  HappyAbsSyn15
@@ -711,7 +711,7 @@ happyReduction_39 (HappyTerminal (TokenInfo happy_var_1 TokCodeQuote))
         =  HappyAbsSyn9
                 (Just happy_var_1
        )
-happyReduction_39 _  = notHappyAtAll 
+happyReduction_39 _  = notHappyAtAll
 
 happyReduce_40 = happySpecReduce_0  16 happyReduction_40
 happyReduction_40  =  HappyAbsSyn9
@@ -719,7 +719,7 @@ happyReduction_40  =  HappyAbsSyn9
        )
 
 happyNewToken action sts stk
-       = lexer(\tk -> 
+       = lexer(\tk ->
        let cont i = action i i tk (HappyState action) sts stk in
        case tk of {
        TokenEOF -> action 40 40 tk (HappyState action) sts stk;
@@ -773,7 +773,7 @@ happyError = lineP >>= \l -> fail (show l ++ ": Parse error\n")
 {-# LINE 1 "<built-in>" #-}
 {-# LINE 1 "<command line>" #-}
 {-# LINE 1 "GenericTemplate.hs" #-}
--- Id: GenericTemplate.hs,v 1.26 2005/01/14 14:47:22 simonmar Exp 
+-- Id: GenericTemplate.hs,v 1.26 2005/01/14 14:47:22 simonmar Exp
 
 {-# LINE 28 "GenericTemplate.hs" #-}
 
@@ -806,7 +806,7 @@ happyParse start_state = happyNewToken start_state notHappyAtAll notHappyAtAll
 -- the stack in this case.
 happyAccept (1) tk st sts (_ `HappyStk` ans `HappyStk` _) =
        happyReturn1 ans
-happyAccept j tk st sts (HappyStk ans _) = 
+happyAccept j tk st sts (HappyStk ans _) =
         (happyReturn1 ans)
 
 -----------------------------------------------------------------------------
@@ -912,7 +912,7 @@ happyGoto action j tk st = action j j tk (HappyState action)
 
 -- parse error if we are in recovery and we fail again
 happyFail  (1) tk old_st _ stk =
---     trace "failing" $ 
+--     trace "failing" $
        happyError_ tk
 
 {-  We don't need state discarding for our restricted implementation of
@@ -920,7 +920,7 @@ happyFail  (1) tk old_st _ stk =
     for now --SDM
 
 -- discard a state
-happyFail  (1) tk old_st (((HappyState (action))):(sts)) 
+happyFail  (1) tk old_st (((HappyState (action))):(sts))
                                                (saved_tok `HappyStk` _ `HappyStk` stk) =
 --     trace ("discarding state, depth " ++ show (length stk))  $
        action (1) (1) tk (HappyState (action)) sts ((saved_tok`HappyStk`stk))
@@ -946,7 +946,7 @@ notHappyAtAll = error "Internal Happy error\n"
 
 
 -----------------------------------------------------------------------------
--- Seq-ing.  If the --strict flag is given, then Happy emits 
+-- Seq-ing.  If the --strict flag is given, then Happy emits
 --     happySeq = happyDoSeq
 -- otherwise it emits
 --     happySeq = happyDontSeq
index 0c0dcc5..159e5cd 100644 (file)
@@ -12,7 +12,7 @@ The code generator.
 > import Grammar
 > import Target                        ( Target(..) )
 > import GenUtils              ( mapDollarDollar, str, char, nl, strspace,
->                                 interleave, interleave', maybestr, 
+>                                 interleave, interleave', maybestr,
 >                                 brack, brack' )
 
 > import Data.Maybe            ( isJust, isNothing )
@@ -24,7 +24,7 @@ The code generator.
 > import Data.Array.ST      ( STUArray )
 > import Data.Array.Unboxed ( UArray )
 > import Data.Array.MArray
-> import Data.Array.IArray 
+> import Data.Array.IArray
 
 %-----------------------------------------------------------------------------
 Produce the complete output file.
@@ -41,7 +41,7 @@ Produce the complete output file.
 >              -> Bool                         -- strict parser
 >              -> String
 
-> produceParser (Grammar 
+> produceParser (Grammar
 >              { productions = prods
 >              , lookupProdNo = lookupProd
 >              , lookupProdsOfName = lookupProdNos
@@ -62,7 +62,7 @@ Produce the complete output file.
 >               , attributetype = attributetype
 >               , attributes = attributes
 >              })
->              action goto top_options module_header module_trailer 
+>              action goto top_options module_header module_trailer
 >              target coerce ghc strict
 >     =        ( top_opts
 >      . maybestr module_header . nl
@@ -84,7 +84,7 @@ Produce the complete output file.
 >  where
 >    n_starts = length starts
 >
->    top_opts = 
+>    top_opts =
 >      case top_options of
 >          "" -> str ""
 >          _  -> str (unwords [ "{-# OPTIONS"
@@ -101,7 +101,7 @@ data HappyAbsSyn a t1 .. tn
        ...
        | HappyAbsSynn tn
 
->    produceAbsSynDecl 
+>    produceAbsSynDecl
 
 If we're using coercions, we need to generate the injections etc.
 
@@ -118,7 +118,7 @@ If we're using coercions, we need to generate the injections etc.
        happyOut<n> x = unsafeCoerce# x
        {-# INLINE happyOut<n> #-}
 
->     | coerce 
+>     | coerce
 >      = let
 >            happy_item = str "HappyAbsSyn " . str_tyvars
 >            bhappy_item = brack' happy_item
@@ -136,7 +136,7 @@ If we're using coercions, we need to generate the injections etc.
 >              . str "{-# INLINE " . mkHappyOut n . str " #-}"
 >        in
 >          str "newtype " . happy_item . str " = HappyAbsSyn (() -> ())\n" -- see NOTE below
->        . interleave "\n" 
+>        . interleave "\n"
 >          [ inject n ty . nl . extract n ty | (n,ty) <- assocs nt_types ]
 >        -- token injector
 >        . str "happyInTok :: " . str token_type . str " -> " . bhappy_item
@@ -152,7 +152,7 @@ Because when the --strict flag is used, we need to seq these values,
 and GHC can be persuaded to use a polymorphic seq if it thinks the
 thing it is seqing has function type - otherwise it might use a
 vectored return, which will lead to disaster if the object in question
-doesn't have a vectored return convention.  
+doesn't have a vectored return convention.
 
 Also, note that we must use a newtype instead of just a type synonym,
 because the otherwise the type arguments to the HappyAbsSyn type
@@ -165,9 +165,9 @@ example where this matters.
 >      = str "data HappyAbsSyn " . str_tyvars
 >      . str "\n\t= HappyTerminal " . str token_type
 >      . str "\n\t| HappyErrorToken Int\n"
->      . interleave "\n" 
+>      . interleave "\n"
 >         [ str "\t| " . makeAbsSynCon n . strspace . type_param n ty
->         | (n, ty) <- assocs nt_types, 
+>         | (n, ty) <- assocs nt_types,
 >          (nt_types_index ! n) == n]
 
 >     where all_tyvars = [ 't':show n | (n, Nothing) <- assocs nt_types ]
@@ -177,13 +177,13 @@ example where this matters.
 Type declarations of the form:
 
 type HappyReduction a b = ....
-action_0, action_1 :: Int -> HappyReduction a b 
-reduction_1, ...   :: HappyReduction a b 
+action_0, action_1 :: Int -> HappyReduction a b
+reduction_1, ...   :: HappyReduction a b
 
 These are only generated if types for *all* rules are given (and not for array
 based parsers -- types aren't as important there).
 
->    produceTypes 
+>    produceTypes
 >     | target == TargetArrayBased = id
 
 >     | all isJust (elems nt_types) =
@@ -202,24 +202,24 @@ based parsers -- types aren't as important there).
 >     . tokens
 >     . result
 >     . str "\n\n"
->     . interleave' ",\n " 
->             [ mkActionName i | (i,action) <- zip [ 0 :: Int .. ] 
+>     . interleave' ",\n "
+>             [ mkActionName i | (i,action) <- zip [ 0 :: Int .. ]
 >                                             (assocs action) ]
 >     . str " :: " . str monad_context . str " => "
 >     . intMaybeHash
 >     . str " -> HappyReduction (" . str monad_tycon . str ")\n\n"
->     . interleave' ",\n " 
->             [ mkReduceFun i | 
+>     . interleave' ",\n "
+>             [ mkReduceFun i |
 >                     (i,action) <- zip [ n_starts :: Int .. ]
 >                                       (drop n_starts prods) ]
->     . str " :: " . str monad_context . str " => HappyReduction (" . str monad_tycon . str ")\n\n" 
+>     . str " :: " . str monad_context . str " => HappyReduction (" . str monad_tycon . str ")\n\n"
 
 >     | otherwise = id
 
 >      where intMaybeHash | ghc       = str "Int#"
 >                         | otherwise = str "Int"
 >            token = brack token_type
->            tokens = 
+>            tokens =
 >              case lexer of
 >                      Nothing -> char '[' . token . str "] -> "
 >                      Just _ -> id
@@ -254,7 +254,7 @@ the whole thing is one recursive group, we'd need a type signature on
 happyMonadReduce to get polymorphic recursion.  Sigh.
 
 >    produceReductions =
->      interleave "\n\n" 
+>      interleave "\n\n"
 >         (zipWith produceReduction (drop n_starts prods) [ n_starts .. ])
 
 >    produceReduction (nt, toks, (code,vars_used), _) i
@@ -272,7 +272,7 @@ happyMonadReduce to get polymorphic recursion.  Sigh.
 >      . interleave "\n\t" tokPatterns
 >      . str " =  "
 >      . tokLets (
->          this_absSynCon . str "\n\t\t " 
+>          this_absSynCon . str "\n\t\t "
 >          . char '(' . str code' . str "\n\t)"
 >        )
 >      . (if coerce || null toks || null vars_used then
@@ -287,13 +287,13 @@ happyMonadReduce to get polymorphic recursion.  Sigh.
 >      . char '(' . interleave " `HappyStk`\n\t" tokPatterns
 >      . str "happyRest)\n\t = "
 >      . tokLets
->         ( this_absSynCon . str "\n\t\t " 
+>         ( this_absSynCon . str "\n\t\t "
 >         . char '(' . str code'. str "\n\t) `HappyStk` happyRest"
 >         )
 
->       where 
->              (code', is_monad_prod, monad_pass_token, monad_reduce) 
->                     = case code of 
+>       where
+>              (code', is_monad_prod, monad_pass_token, monad_reduce)
+>                     = case code of
 >                        '%':'%':code1 -> (code1, True, True, "happyMonad2Reduce")
 >                        '%':'^':code1 -> (code1, True, True, "happyMonadReduce")
 >                        '%':code1     -> (code1, True, False, "happyMonadReduce")
@@ -304,21 +304,21 @@ happyMonadReduce to get polymorphic recursion.  Sigh.
 >              adjusted_nt | target == TargetArrayBased = nt - first_nonterm
 >                          | otherwise                  = nt
 >
->              mkReductionHdr lt s = 
+>              mkReductionHdr lt s =
 >                      mkReduceFun i . str " = "
 >                      . str s . strspace . lt . strspace . showInt adjusted_nt
->                      . strspace . reductionFun . nl 
+>                      . strspace . reductionFun . nl
 >                      . reductionFun . strspace
-> 
+>
 >              reductionFun = str "happyReduction_" . shows i
 >
->              tokPatterns 
+>              tokPatterns
 >               | coerce = reverse (map mkDummyVar [1 .. length toks])
 >               | otherwise = reverse (zipWith tokPattern [1..] toks)
-> 
+>
 >              tokPattern n _ | n `notElem` vars_used = char '_'
 >              tokPattern n t | t >= firstStartTok && t < fst_term
->                      = if coerce 
+>                      = if coerce
 >                              then mkHappyVar n
 >                              else brack' (
 >                                   makeAbsSynCon t . str "  " . mkHappyVar n
@@ -326,12 +326,12 @@ happyMonadReduce to get polymorphic recursion.  Sigh.
 >              tokPattern n t
 >                      = if coerce
 >                              then mkHappyTerminalVar n t
->                              else str "(HappyTerminal " 
+>                              else str "(HappyTerminal "
 >                                 . mkHappyTerminalVar n t
 >                                 . char ')'
 >              
 >              tokLets code
->                 | coerce && not (null cases) 
+>                 | coerce && not (null cases)
 >                      = interleave "\n\t" cases
 >                      . code . str (take (length cases) (repeat '}'))
 >                 | otherwise = code
@@ -353,8 +353,8 @@ happyMonadReduce to get polymorphic recursion.  Sigh.
 The token conversion function.
 
 >    produceTokenConverter
->      = case lexer of { 
-> 
+>      = case lexer of {
+>
 >      Nothing ->
 >        str "happyNewToken action sts stk [] =\n\t"
 >      . eofAction "notHappyAtAll"
@@ -383,7 +383,7 @@ The token conversion function.
 >       . str "happyError_ tk = happyError' tk\n";
 >      }
 
->      where 
+>      where
 
 >        eofAction tk =
 >          (case target of
@@ -398,10 +398,10 @@ The token conversion function.
 >        doAction = case target of
 >          TargetArrayBased -> str "happyDoAction i tk action"
 >          _   -> str "action i i tk (HappyState action)"
-> 
->        doToken (i,tok) 
+>
+>        doToken (i,tok)
 >              = str (removeDollarDollar tok)
->              . str " -> cont " 
+>              . str " -> cont "
 >              . showInt (tokIndex i)
 
 Use a variable rather than '_' to replace '$$', so we can use it on
@@ -412,9 +412,9 @@ the left hand side of '@'.
 >                                 Just fn -> fn "happy_dollar_dollar"
 
 >    mkHappyTerminalVar :: Int -> Int -> String -> String
->    mkHappyTerminalVar i t = 
+>    mkHappyTerminalVar i t =
 >     case tok_str_fn of
->      Nothing -> pat 
+>      Nothing -> pat
 >      Just fn -> brack (fn (pat []))
 >     where
 >        tok_str_fn = case lookup t token_rep of
@@ -422,7 +422,7 @@ the left hand side of '@'.
 >                    Just str -> mapDollarDollar str
 >        pat = mkHappyVar i
 
->    tokIndex 
+>    tokIndex
 >      = case target of
 >              TargetHaskell    -> id
 >              TargetArrayBased -> \i -> i - n_nonterminals - n_starts - 2
@@ -460,7 +460,7 @@ State 345
 
 we should make reduce_212 the default reduction here.  So the rules become:
 
-   * if there is a production 
+   * if there is a production
        error -> reduce_n
      then make reduce_n the default action.
    * if there is a non-reduce action for the error token, the default action
@@ -476,7 +476,7 @@ straight back to a state where the error token can be shifted, or if
 none exists, we'll get a parse error.  In theory, we won't need the
 machinery to discard states in the parser...
 
->    produceActionTable TargetHaskell 
+>    produceActionTable TargetHaskell
 >      = foldr (.) id (map (produceStateFunction goto) (assocs action))
 >      
 >    produceActionTable TargetArrayBased
@@ -510,7 +510,7 @@ machinery to discard states in the parser...
 >              = actionFunction t
 >              . str "happyGoto " . mkActionName i . str "\n"
 >            produceGotos (t, NoGoto) = id
->            
+>      
 >            actionFunction t
 >              = mkActionName state . strspace
 >              . ('(' :) . showInt t
@@ -551,31 +551,31 @@ action array indexed by (terminal * last_state) + state
 
 >      | otherwise
 >          = str "happyActOffsets :: Array Int Int\n"
->          . str "happyActOffsets = listArray (0," 
+>          . str "happyActOffsets = listArray (0,"
 >              . shows (n_states) . str ") (["
 >          . interleave' "," (map shows act_offs)
 >          . str "\n\t])\n\n"
 >      
 >          . str "happyGotoOffsets :: Array Int Int\n"
->          . str "happyGotoOffsets = listArray (0," 
+>          . str "happyGotoOffsets = listArray (0,"
 >              . shows (n_states) . str ") (["
 >          . interleave' "," (map shows goto_offs)
 >          . str "\n\t])\n\n"
 >      
 >          . str "happyDefActions :: Array Int Int\n"
->          . str "happyDefActions = listArray (0," 
+>          . str "happyDefActions = listArray (0,"
 >              . shows (n_states) . str ") (["
 >          . interleave' "," (map shows defaults)
 >          . str "\n\t])\n\n"
 >      
 >          . str "happyCheck :: Array Int Int\n"
->          . str "happyCheck = listArray (0," 
+>          . str "happyCheck = listArray (0,"
 >              . shows table_size . str ") (["
 >          . interleave' "," (map shows check)
 >          . str "\n\t])\n\n"
 >      
 >          . str "happyTable :: Array Int Int\n"
->          . str "happyTable = listArray (0," 
+>          . str "happyTable = listArray (0,"
 >              . shows table_size . str ") (["
 >          . interleave' "," (map shows table)
 >          . str "\n\t])\n\n"
@@ -585,7 +585,7 @@ action array indexed by (terminal * last_state) + state
 >    n_terminals = length terms
 >    n_nonterminals = length nonterms - n_starts -- lose %starts
 >
->    (act_offs,goto_offs,table,defaults,check) 
+>    (act_offs,goto_offs,table,defaults,check)
 >      = mkTables action goto first_nonterm fst_term
 >              n_terminals n_nonterminals n_starts
 >
@@ -628,7 +628,7 @@ for types that have alphas in them. Maybe we should
 outlaw them inside { }
 
 >    nt_types_index :: Array Int Int
->    nt_types_index = array (bounds nt_types) 
+>    nt_types_index = array (bounds nt_types)
 >                      [ (a, fn a b) | (a, b) <- assocs nt_types ]
 >     where
 >      fn n Nothing = n
@@ -688,7 +688,7 @@ MonadStuff:
 >         . str "happyReturn = " . brack monad_return . nl
 >         . case lexer of
 >              Nothing ->
->                 str "happyThen1 m k tks = (" . str monad_then 
+>                 str "happyThen1 m k tks = (" . str monad_then
 >               . str ") m (\\a -> k a tks)\n"
 >               . str "happyReturn1 :: " . pcont . str " => a -> b -> " . pty . str " a\n"
 >               . str "happyReturn1 = \\a tks -> " . brack monad_return
@@ -707,7 +707,7 @@ MonadStuff:
 >               . str "happyReturn1 :: " . pcont . str " => a -> " . pty . str " a\n"
 >               . str "happyReturn1 = happyReturn\n"
 >               . str "happyError' :: " . str monad_context . str " => "
->                                       . str token_type . str " -> " 
+>                                       . str token_type . str " -> "
 >               . str monad_tycon
 >               . str " a\n"
 >               . str "happyError' tk = "
@@ -719,10 +719,10 @@ An error handler specified with %error is passed the current token
 when used with %lexer, but happyError (the old way but kept for
 compatibility) is not passed the current token.
 
->    errorHandler = 
+>    errorHandler =
 >      case error_handler of
 >              Just h  -> str h
->              Nothing -> case lexer of 
+>              Nothing -> case lexer of
 >                              Nothing -> str "happyError"
 >                              Just _  -> str "(\\token -> happyError)"
 
@@ -751,10 +751,10 @@ compatibility) is not passed the current token.
 >               | otherwise -> shows no                        
 >      . maybe_tks
 >      . str ") "
->      . brack' (if coerce 
->                   then str "\\x -> happyReturn (happyOut" 
+>      . brack' (if coerce
+>                   then str "\\x -> happyReturn (happyOut"
 >                      . shows accept_nonterm . str " x)"
->                   else str "\\x -> case x of {HappyAbsSyn" 
+>                   else str "\\x -> case x of {HappyAbsSyn"
 >                      . shows (nt_types_index ! accept_nonterm)
 >                      . str " z -> happyReturn z; _other -> notHappyAtAll }"
 >               )
@@ -776,7 +776,7 @@ compatibility) is not passed the current token.
 >       defaultAttr = fst (head attributes)
 >
 >       monadAndLexerAE name
->         = str name . str " = " 
+>         = str name . str " = "
 >         . str "do { "
 >         . str "f <- do_" . str name . str "; "
 >         . str "let { (conds,attrs) = f happyEmptyAttrs } in do { "
@@ -801,7 +801,7 @@ compatibility) is not passed the current token.
 -- Produce attributes declaration for attribute grammars
 
 > produceAttributes [] _ = id
-> produceAttributes attrs attributeType 
+> produceAttributes attrs attributeType
 >     = str "data " . attrHeader . str " = HappyAttributes {" . attributes . str "}" . nl
 >     . str "happyEmptyAttrs = HappyAttributes {" . attrsErrors . str "}" . nl
 
@@ -837,7 +837,7 @@ vars used in this piece of code.
 > gotoVal :: Goto -> Int
 > gotoVal (Goto i)             = i
 > gotoVal NoGoto               = 0
-  
+
 > mkAction (LR'Shift i _)      = str "happyShift " . mkActionName i
 > mkAction LR'Accept           = str "happyAccept"
 > mkAction LR'Fail             = str "happyFail"
@@ -866,7 +866,7 @@ See notes under "Action Tables" above for some subtleties in this function.
 >                    [] -> LR'Fail
 >                    (act:_) -> act    -- pick the first one we see for now
 >
->   where reduces 
+>   where reduces
 >          =  [ act | (_,act@(LR'Reduce _ _)) <- actions ]
 >          ++ [ act | (_,(LR'Multiple _ act@(LR'Reduce _ _))) <- actions ]
 
@@ -916,7 +916,7 @@ See notes under "Action Tables" above for some subtleties in this function.
 -- from above.
 
 
-> mkTables 
+> mkTables
 >       :: ActionTable -> GotoTable -> Name -> Int -> Int -> Int -> Int ->
 >       ([Int]         -- happyActOffsets
 >       ,[Int]         -- happyGotoOffsets
@@ -925,30 +925,30 @@ See notes under "Action Tables" above for some subtleties in this function.
 >       ,[Int]         -- happyCheck
 >       )
 >
-> mkTables action goto first_nonterm fst_term 
+> mkTables action goto first_nonterm fst_term
 >              n_terminals n_nonterminals n_starts
->  = ( elems act_offs, 
->      elems goto_offs, 
+>  = ( elems act_offs,
+>      elems goto_offs,
 >      take max_off (elems table),
->      def_actions, 
+>      def_actions,
 >      take max_off (elems check)
 >   )
->  where 
+>  where
 >
->       (table,check,act_offs,goto_offs,max_off) 
+>       (table,check,act_offs,goto_offs,max_off)
 >               = runST (genTables (length actions) max_token sorted_actions)
->       
+>      
 >       -- the maximum token number used in the parser
 >       max_token = max n_terminals (n_starts+n_nonterminals) - 1
 >
 >       def_actions = map (\(_,_,def,_,_,_) -> def) actions
 >
 >       actions :: [TableEntry]
->       actions = 
+>       actions =
 >               [ (ActionEntry,
 >                  state,
 >                  actionVal default_act,
->                  if null acts'' then 0 
+>                  if null acts'' then 0
 >                       else fst (last acts'') - fst (head acts''),
 >                  length acts'',
 >                  acts'')
@@ -965,15 +965,15 @@ See notes under "Action Tables" above for some subtleties in this function.
 >       adjust token | token == errorTok = 0
 >                    | otherwise         = token - fst_term + 1
 >
->       mkActVals assocs default_act = 
->               [ (adjust token, actionVal act) 
+>       mkActVals assocs default_act =
+>               [ (adjust token, actionVal act)
 >               | (token, act) <- assocs
 >               , act /= default_act ]
 >
 >       gotos :: [TableEntry]
 >       gotos = [ (GotoEntry,
->                  state, 0, 
->                  if null goto_vals then 0 
+>                  state, 0,
+>                  if null goto_vals then 0
 >                       else fst (last goto_vals) - fst (head goto_vals),
 >                  length goto_vals,
 >                  goto_vals
@@ -1020,7 +1020,7 @@ See notes under "Action Tables" above for some subtleties in this function.
 >   goto_offs  <- newArray (0, n_actions) 0
 >   off_arr    <- newArray (-max_token, mAX_TABLE_SIZE) 0
 >
->   max_off <- genTables' table check act_offs goto_offs 
+>   max_off <- genTables' table check act_offs goto_offs
 >                      off_arr entries max_token
 >
 >   table'     <- freeze table
@@ -1063,7 +1063,7 @@ See notes under "Action Tables" above for some subtleties in this function.
 >         | acts == acts' = do writeArray (which_off e) no off
 >                              same_states s ss' off
 >         | otherwise = return ss
->  
+>
 >       which_off ActionEntry = act_offs
 >       which_off GotoEntry   = goto_offs
 >
@@ -1072,7 +1072,7 @@ See notes under "Action Tables" above for some subtleties in this function.
 >       -- entry in the table (used to speed up the lookups a bit).
 >       fit (_,_,_,_,_,[]) max_off fst_zero = return (0,max_off,fst_zero)
 >
->       fit (act_or_goto, state_no, deflt, _, _, state@((t,_):_)) 
+>       fit (act_or_goto, state_no, deflt, _, _, state@((t,_):_))
 >          max_off fst_zero = do
 >               -- start at offset 1 in the table: all the empty states
 >               -- (states with just a default reduction) are mapped to
@@ -1092,7 +1092,7 @@ See notes under "Action Tables" above for some subtleties in this function.
 When looking for a free offest in the table, we use the 'check' table
 rather than the main table.  The check table starts off with (-1) in
 every slot, because that's the only thing that doesn't overlap with
-any tokens (non-terminals start at 0, terminals start at 1).  
+any tokens (non-terminals start at 0, terminals start at 1).
 
 Because we use 0 for LR'MustFail as well as LR'Fail, we can't check
 for free offsets in the main table because we can't tell whether a
@@ -1139,7 +1139,7 @@ slot is free or not.
 -----------------------------------------------------------------------------
 -- Misc.
 
-> comment = 
+> comment =
 >        "-- parser produced by Happy Version " ++ showVersion version ++ "\n\n"
 
 > mkAbsSynCon fx t     = str "HappyAbsSyn"   . shows (fx ! t)
index 07a9176..d67e544 100644 (file)
@@ -2,7 +2,7 @@ Module for producing GLR (Tomita) parsing code.
 This module is designed as an extension to the Haskell parser generator Happy.
 
 (c) University of Durham, Ben Medlock 2001
-       -- initial code, for structure parsing 
+       -- initial code, for structure parsing
 (c) University of Durham, Paul Callaghan 2004
        -- extension to semantic rules, and various optimisations
 %-----------------------------------------------------------------------------
@@ -40,7 +40,7 @@ prefix for production names, to avoid name clashes
 This type represents choice of decoding style for the result
 
 > data DecodeOption
->  = TreeDecode 
+>  = TreeDecode
 >  | LabelDecode
 
 ---
@@ -78,7 +78,7 @@ Main exported function
 >        :: FilePath     -- Output file name
 >       -> String        -- Templates directory
 >       -> ActionTable   -- LR tables
->       -> GotoTable     -- LR tables 
+>       -> GotoTable     -- LR tables
 >       -> Maybe String  -- Module header
 >       -> Maybe String  -- User-defined stuff (token DT, lexer etc.)
 >       -> (DebugMode,Options)       -- selecting code-gen style
@@ -91,7 +91,7 @@ Main exported function
 >     let tbls  = (action,goto)
 >     (parseName,_,_,_) <- case starts g of
 >                          [s] -> return s
->                          s:_ -> do 
+>                          s:_ -> do
 >                                    putStrLn "GLR-Happy doesn't support multiple start points (yet)"
 >                                    putStrLn "Defaulting to first start point."
 >                                    return s
@@ -100,12 +100,12 @@ Main exported function
 
 %-----------------------------------------------------------------------------
 "mkFiles" generates the files containing the Tomita parsing code.
-It produces two files - one for the data (small template), and one for 
+It produces two files - one for the data (small template), and one for
 the driver and data strs (large template).
 
-> mkFiles :: FilePath    -- Root of Output file name 
+> mkFiles :: FilePath    -- Root of Output file name
 >       -> (ActionTable
->           ,GotoTable)   -- LR tables 
+>           ,GotoTable)   -- LR tables
 >       -> String        -- Start parse function name
 >       -> String        -- Templates directory
 >       -> Maybe String  -- Module header
@@ -117,7 +117,7 @@ the driver and data strs (large template).
 > mkFiles basename tables start templdir header trailer (debug,options) g
 >  = do
 >      let debug_ext = if debug then "-debug" else ""
->      let (ext,imps,opts) = case thd3 options of 
+>      let (ext,imps,opts) = case thd3 options of
 >                              UseGhcExts is os -> ("-ghc", is, os)
 >                              _                -> ("", "", "")
 >      base <- readFile (base_template templdir)
@@ -133,22 +133,22 @@ the driver and data strs (large template).
 >   (sem_def, sem_info) = mkGSemType options g
 >   table_text = mkTbls tables sem_info (thd3 options) g
 
->   header_parts = fmap (span (\x -> take 3 (dropWhile isSpace x) == "{-#") 
->                                  . lines) 
+>   header_parts = fmap (span (\x -> take 3 (dropWhile isSpace x) == "{-#")
+>                                  . lines)
 >                       header
 >      -- Split off initial options, if they are present
->      -- Assume these options ONLY related to code which is in 
+>      -- Assume these options ONLY related to code which is in
 >      --   parser tail or in sem. rules
-  
->   content base_defs opts 
->    = str ("{-# OPTIONS " ++ opts ++ " #-}")    .nl 
+
+>   content base_defs opts
+>    = str ("{-# OPTIONS " ++ opts ++ " #-}")    .nl
 >    . str (unlines $ maybe [] fst header_parts) .nl
 >    . nl
 >    . str (comment "data")                      .nl .nl
->    . str ("module " ++ data_mod ++ " where")   .nl 
+>    . str ("module " ++ data_mod ++ " where")   .nl
 
 >     . nl
->     . maybestr (fmap (unlines.snd) header_parts) .nl 
+>     . maybestr (fmap (unlines.snd) header_parts) .nl
 >     . nl
 >     . str base_defs .nl
 >     . nl
@@ -158,19 +158,19 @@ the driver and data strs (large template).
 >                        + count_nls base_defs
 >                        + 10                          -- for the other stuff
 >          post_trailer  = pre_trailer + maybe 0 count_nls trailer + 4
->      in 
+>      in
 >         str ("{-# LINE " ++ show pre_trailer ++ " "
->                         ++ show (basename ++ "Data.hs") ++ "#-}") 
+>                         ++ show (basename ++ "Data.hs") ++ "#-}")
 >              -- This should show a location in basename.y -- but Happy
 >              -- doesn't pass this info through. But we still avoid being
->              -- told a location in GLR_Base! 
+>              -- told a location in GLR_Base!
 >       . nl
 >       . nl
->       . maybestr trailer 
+>       . maybestr trailer
 >       .nl
 >       .nl
 >       . str ("{-# LINE " ++ show post_trailer ++ " "
->                         ++ show (basename ++ "Data.hs") ++ "#-}") 
+>                         ++ show (basename ++ "Data.hs") ++ "#-}")
 >       . nl
 >       . nl
 
@@ -188,11 +188,11 @@ the driver and data strs (large template).
 
 >   lib_content imps opts lib_text
 >    = let (pre,drop_me:post) = break (== "fakeimport DATA") $ lines lib_text
->      in 
+>      in
 >      unlines [ "{-# OPTIONS " ++ opts ++ " #-}\n"
 >             , comment "driver" ++ "\n"
 >             , "module " ++ mod_name ++ "("
->             , case lexer g of 
+>             , case lexer g of
 >                  Nothing     -> ""
 >                  Just (lf,_) -> "\t" ++ lf ++ ","
 >             , "\t" ++ start
@@ -200,7 +200,7 @@ the driver and data strs (large template).
 >             , unlines pre
 >             , imps
 >             , "import " ++ data_mod
->             , start ++ " = glr_parse " 
+>             , start ++ " = glr_parse "
 >             , "use_filtering = " ++ show use_filtering
 >             , "top_symbol = " ++ prefix ++ start_prod
 >             , unlines post
@@ -210,7 +210,7 @@ the driver and data strs (large template).
 >                                   _                   -> False
 
 > comment which
->  = "-- parser (" ++ which ++ ") produced by Happy (GLR) Version " ++ 
+>  = "-- parser (" ++ which ++ ") produced by Happy (GLR) Version " ++
 >      showVersion version
 
 > user_def_token_code token_type
@@ -232,9 +232,9 @@ Formats the tables as code.
 >       -> ShowS
 >
 > mkTbls (action,goto) sem_info exts g
->  = let gsMap = mkGSymMap g 
+>  = let gsMap = mkGSymMap g
 >        semfn_map = mk_semfn_map sem_info
->    in 
+>    in
 >      writeActionTbl action gsMap (semfn_map !) exts g
 >    . writeGotoTbl   goto   gsMap exts
 
@@ -245,22 +245,22 @@ that will be used for them in the GLR parser.
 
 > mkGSymMap :: Grammar -> [(Name,String)]
 > mkGSymMap g
->  =   [ -- (errorTok, prefix ++ "Error") 
+>  =   [ -- (errorTok, prefix ++ "Error")
 >       ]
->    ++ [ (i, prefix ++ (token_names g) ! i) 
+>    ++ [ (i, prefix ++ (token_names g) ! i)
 >      | i <- user_non_terminals g ]   -- Non-terminals
 >    ++ [ (i, "HappyTok (" ++ mkMatch tok ++ ")")
 >      | (i,tok) <- token_specs g ]    -- Tokens (terminals)
 >    ++ [(eof_term g,"HappyEOF")]      -- EOF symbol (internal terminal)
 >  where
->   mkMatch tok = case mapDollarDollar tok of 
+>   mkMatch tok = case mapDollarDollar tok of
 >                   Nothing -> tok
 >                   Just fn -> fn "_"
 
-> toGSym gsMap i 
+> toGSym gsMap i
 >  = case lookup i gsMap of
 >     Nothing -> error $ "No representation for symbol " ++ show i
->     Just g  -> g 
+>     Just g  -> g
 
 
 %-----------------------------------------------------------------------------
@@ -268,18 +268,18 @@ Take the ActionTable from Happy and turn it into a String representing a
 function that can be included as the action table in the GLR parser.
 It also shares identical reduction values as CAFs
 
-> writeActionTbl 
->  :: ActionTable -> [(Int,String)] -> (Name->String) 
+> writeActionTbl
+>  :: ActionTable -> [(Int,String)] -> (Name->String)
 >                                      -> GhcExts -> Grammar -> ShowS
 > writeActionTbl acTbl gsMap semfn_map exts g
->  = interleave "\n" 
->  $ map str 
+>  = interleave "\n"
+>  $ map str
 >  $ mkLines ++ [errorLine] ++ mkReductions
 >  where
 >   name      = "action"
 >   mkLines   = concatMap (mkState) (assocs acTbl)
->   errorLine = name ++ " _ _ = Error" 
->   mkState (i,arr) 
+>   errorLine = name ++ " _ _ = Error"
+>   mkState (i,arr)
 >    = filter (/="") $ map (mkLine i) (assocs arr)
 >
 >   mkLine state (symInt,action)
@@ -291,7 +291,7 @@ It also shares identical reduction values as CAFs
 >       LR'MustFail -> ""
 >       _          -> unwords [ startLine , mkAct action ]
 >    where
->     startLine 
+>     startLine
 >      = unwords [ name , show_st exts state, "(" , getTok , ") =" ]
 >     getTok = let tok = toGSym gsMap symInt
 >              in case mapDollarDollar tok of
@@ -300,9 +300,9 @@ It also shares identical reduction values as CAFs
 >   mkAct act
 >    = case act of
 >       LR'Shift newSt _ -> "Shift " ++ show newSt ++ " []"
->       LR'Reduce r    _ -> "Reduce " ++ "[" ++ mkRed r ++ "]" 
+>       LR'Reduce r    _ -> "Reduce " ++ "[" ++ mkRed r ++ "]"
 >       LR'Accept       -> "Accept"
->       LR'Multiple rs (LR'Shift st _) 
+>       LR'Multiple rs (LR'Shift st _)
 >                       -> "Shift " ++ show st ++ " " ++ mkReds rs
 >       LR'Multiple rs r@(LR'Reduce{})
 >                       -> "Reduce " ++ mkReds (r:rs)
@@ -311,7 +311,7 @@ It also shares identical reduction values as CAFs
 >     mkReds rs = "[" ++ tail (concat [ "," ++ mkRed r | LR'Reduce r _ <- rs ]) ++ "]"
 
 >   mkRed r = "red_" ++ show r
->   mkReductions = [ mkRedDefn p | p@(_,(n,_,_,_)) <- zip [0..] $ productions g 
+>   mkReductions = [ mkRedDefn p | p@(_,(n,_,_,_)) <- zip [0..] $ productions g
 >                                , n `notElem` start_productions g ]
 
 >   mkRedDefn (r, (lhs_id, rhs_ids, (code,dollar_vars), _))
@@ -331,10 +331,10 @@ Do the same with the Happy goto table.
 >  . str errorLine . nl
 >  where
 >   name    = "goto"
->   errorLine = "goto _ _ = " ++ show_st exts (negate 1) 
->   mkLines = map mkState (assocs goTbl) 
+>   errorLine = "goto _ _ = " ++ show_st exts (negate 1)
+>   mkLines = map mkState (assocs goTbl)
 >
->   mkState (i,arr) 
+>   mkState (i,arr)
 >    = unlines $ filter (/="") $ map (mkLine i) (assocs arr)
 >
 >   mkLine state (ntInt,goto)
@@ -342,7 +342,7 @@ Do the same with the Happy goto table.
 >       NoGoto  -> ""
 >       Goto st -> unwords [ startLine , show_st exts st ]
 >    where
->     startLine 
+>     startLine
 >      = unwords [ name , show_st exts state, getGSym , "=" ]
 >     getGSym = toGSym gsMap ntInt
 
@@ -351,46 +351,46 @@ Do the same with the Happy goto table.
 Create the 'GSymbol' ADT for the symbols in the grammar
 
 > mkGSymbols :: Grammar -> ShowS
-> mkGSymbols g 
->  = str dec 
+> mkGSymbols g
+>  = str dec
 >  . str eof
 >  . str tok   
->  . interleave "\n" [ str " | " . str prefix . str sym . str " " 
->                    | sym <- syms ] 
->  . str der 
+>  . interleave "\n" [ str " | " . str prefix . str sym . str " "
+>                    | sym <- syms ]
+>  . str der
 >    -- ++ eq_inst
 >    -- ++ ord_inst
 >  where
 >   dec  = "data GSymbol"
->   eof  = " = HappyEOF" 
+>   eof  = " = HappyEOF"
 >   tok  = " | HappyTok {-!Int-} (" ++ token_type g ++ ")"
 >   der  = "   deriving (Show,Eq,Ord)"
 >   syms = [ token_names g ! i | i <- user_non_terminals g ]
 
-NOTES: 
+NOTES:
 Was considering avoiding use of Eq/Ord over tokens, but this then means
 hand-coding the Eq/Ord classes since we're over-riding the usual order
-except in one case. 
+except in one case.
 
 maybe possible to form a union and do some juggling, but this isn't that
-easy, eg input type of "action". 
+easy, eg input type of "action".
 
 plus, issues about how token info gets into TreeDecode sem values - which
 might be tricky to arrange.
-<>   eq_inst = "instance Eq GSymbol where" 
-<>           : "\tHappyTok i _ == HappyTok j _ = i == j" 
-<>           : [ "\ti == j = fromEnum i == fromEnum j" 
+<>   eq_inst = "instance Eq GSymbol where"
+<>           : "\tHappyTok i _ == HappyTok j _ = i == j"
+<>           : [ "\ti == j = fromEnum i == fromEnum j"
 
 
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 Semantic actions on rules.
 
-These are stored in a union type "GSem", and the semantic values are held 
-on the branches created at the appropriate reduction. 
+These are stored in a union type "GSem", and the semantic values are held
+on the branches created at the appropriate reduction.
 
 "GSem" type has one constructor per distinct type of semantic action and
-pattern of child usage. 
+pattern of child usage.
 
 
 %-----------------------------------------------------------------------------
@@ -398,11 +398,11 @@ Creating a type for storing semantic rules
  - also collects information on code structure and constructor names, for
    use in later stages.
 
-> type SemInfo 
+> type SemInfo
 >  = [(String, String, [Int], [((Int,Int), ([(Int,String)],String), [Int])])]
 
 > mkGSemType :: Options -> Grammar -> (ShowS, SemInfo)
-> mkGSemType (TreeDecode,_,_) g 
+> mkGSemType (TreeDecode,_,_) g
 >  = (def, map snd syms)
 >  where
 >   mtype s = case monad_sub g of
@@ -412,8 +412,8 @@ Creating a type for storing semantic rules
 >   def  = str "data GSem" . nl
 >       . str " = NoSem"  . nl
 >       . str (" | SemTok (" ++  token_type g ++ ")") . nl
->       . interleave "\n" [ str " | " . str sym . str " " 
->                         | sym <- map fst syms ] 
+>       . interleave "\n" [ str " | " . str sym . str " "
+>                         | sym <- map fst syms ]
 >       . str "instance Show GSem where" . nl
 >       . interleave "\n" [ str "\tshow " . str c . str "{} = " . str (show c)
 >                         | (_,c,_,_) <- map snd syms ]
@@ -423,10 +423,10 @@ Creating a type for storing semantic rules
 >                                              -- find unique types (plus mask)
 >          , let c_name = "Sem_" ++ show i
 >          , let mrty = mtype rty
->          , let ty = foldr (\l r -> l ++ " -> " ++ r) mrty args 
+>          , let ty = foldr (\l r -> l ++ " -> " ++ r) mrty args
 
 >          , let code_info = [ j_code | (that, j_code) <- info, this == that ]
->          , let prod_info = [ ((i,k), code, js) 
+>          , let prod_info = [ ((i,k), code, js)
 >                           | (k,code) <- zip [0..] (nub $ map snd code_info)
 >                           , let js = [ j | (j,code2) <- code_info
 >                                           , code == code2 ]
@@ -435,7 +435,7 @@ Creating a type for storing semantic rules
 >          ]
 
 >   info = [ ((var_mask, args, i_ty), (j,(ts_pats,code)))
->          | i <- user_non_terminals g 
+>          | i <- user_non_terminals g
 >          , let i_ty = typeOf i
 >          , j <- lookupProdsOfName g i  -- all prod numbers
 >          , let (_,ts,(raw_code,dollar_vars),_) = lookupProdNo g j
@@ -455,14 +455,14 @@ Creating a type for storing semantic rules
 >                                       Just t  -> t
 
 > -- NB expects that such labels are Showable
-> mkGSemType (LabelDecode,_,_) g 
+> mkGSemType (LabelDecode,_,_) g
 >  = (def, map snd syms)
 >  where
 >   def = str "data GSem" . nl
 >      . str " = NoSem"  . nl
 >      . str (" | SemTok (" ++  token_type g ++ ")")
->      . interleave "\n" [ str " | "  . str sym . str " " 
->                        | sym <- map fst syms ] 
+>      . interleave "\n" [ str " | "  . str sym . str " "
+>                        | sym <- map fst syms ]
 >      . str "   deriving (Show)" . nl
 
 >   syms = [ (c_name ++ " (" ++ ty ++ ")", (ty, c_name, mask, prod_info))
@@ -470,7 +470,7 @@ Creating a type for storing semantic rules
 >                                              -- find unique types
 >          , let c_name = "Sem_" ++ show i
 >          , let code_info = [ j_code | (that, j_code) <- info, this == that ]
->          , let prod_info = [ ((i,k), code, js) 
+>          , let prod_info = [ ((i,k), code, js)
 >                           | (k,code) <- zip [0..] (nub $ map snd code_info)
 >                           , let js = [ j | (j,code2) <- code_info
 >                                           , code == code2 ]
@@ -501,15 +501,15 @@ Creates the appropriate semantic values.
  - for label-decode, these are the code, but abstracted over the child indices
  - for tree-decode, these are the code abstracted over the children's values
 
-> mkSemObjects :: Options -> MonadInfo -> SemInfo -> ShowS 
+> mkSemObjects :: Options -> MonadInfo -> SemInfo -> ShowS
 > mkSemObjects (LabelDecode,filter_opt,_) ignore_monad_info sem_info
->  = interleave "\n" 
+>  = interleave "\n"
 >  $ [   str (mkSemFn_Name ij)
 >      . str (" ns@(" ++ pat ++ "happy_rest) = ")
 >      . str (" Branch (" ++ c_name ++ " (" ++ code ++ ")) ")
 >      . str (nodes filter_opt)
 >    | (ty, c_name, mask, prod_info) <- sem_info
->    , (ij, (pats,code), ps) <- prod_info 
+>    , (ij, (pats,code), ps) <- prod_info
 >    , let pat | null mask = ""
 >              | otherwise = concatMap (\v -> mk_tok_binder pats (v+1) ++ ":")
 >                                      [0..maximum mask]
@@ -518,22 +518,22 @@ Creates the appropriate semantic values.
 >          nodes UseFiltering = "(" ++ foldr (\l -> mkHappyVar (l+1) . showChar ':') "[])" mask
 >    ]
 >    where
->      mk_tok_binder pats v 
+>      mk_tok_binder pats v
 >       = mk_binder (\s -> "(_,_,HappyTok (" ++ s ++ "))") pats v ""
 
 
 > mkSemObjects (TreeDecode,filter_opt,_) monad_info sem_info
->  = interleave "\n" 
+>  = interleave "\n"
 >  $ [   str (mkSemFn_Name ij)
 >      . str (" ns@(" ++ pat ++ "happy_rest) = ")
 >      . str (" Branch (" ++ c_name ++ " (" ++ sem ++ ")) ")
 >      . str (nodes filter_opt)
 >    | (ty, c_name, mask, prod_info) <- sem_info
->    , (ij, (pats,code), _) <- prod_info 
+>    , (ij, (pats,code), _) <- prod_info
 >    , let indent c = init $ unlines $ map (replicate 2 '\t'++) $ lines c
 >    , let mcode = case monad_info of
 >                    Nothing -> code
->                    Just (_,_,rtn) -> case code of 
+>                    Just (_,_,rtn) -> case code of
 >                                        '%':code -> "\n" ++ indent code
 >                                        other    -> rtn ++ " (" ++ code ++ ")"
 >    , let sem = foldr (\v t -> mk_lambda pats (v + 1) "" ++ t) mcode mask
@@ -542,15 +542,15 @@ Creates the appropriate semantic values.
 >                                      [0..maximum mask]
 >    , let nodes NoFiltering  = "ns"
 >          nodes UseFiltering = "(" ++ foldr (\l -> mkHappyVar (l+1) . showChar ':') "[])" mask
->    ] 
+>    ]
 
 > mk_lambda pats v
 >  = (\s -> "\\" ++ s ++ " -> ") . mk_binder id pats v
 
 > mk_binder wrap pats v
 >  = case lookup v pats of
->      Nothing -> mkHappyVar v 
->      Just p  -> case mapDollarDollar p of 
+>      Nothing -> mkHappyVar v
+>      Just p  -> case mapDollarDollar p of
 >                    Nothing -> wrap . mkHappyVar v . showChar '@' . brack p
 >                    Just fn -> wrap . brack' (fn . mkHappyVar v)
 
@@ -566,20 +566,20 @@ maps production name to the underlying (possibly shared) semantic function
 > mk_semfn_map :: SemInfo -> Array Name String
 > mk_semfn_map sem_info
 >  = array (0,maximum $ map fst prod_map) prod_map
->    where 
->        prod_map = [ (p, mkSemFn_Name ij) 
+>    where
+>        prod_map = [ (p, mkSemFn_Name ij)
 >                   | (_,_,_,pi) <- sem_info, (ij,_,ps) <- pi, p <- ps ]
 
 
 %-----------------------------------------------------------------------------
 Create default decoding functions
 
-Idea is that sem rules are stored as functions in the AbsSyn names, and 
-only unpacked when needed. Using classes here to manage the unpacking. 
+Idea is that sem rules are stored as functions in the AbsSyn names, and
+only unpacked when needed. Using classes here to manage the unpacking.
 
 > mkDecodeUtils :: Options -> MonadInfo -> SemInfo -> ShowS
 > mkDecodeUtils (TreeDecode,filter_opt,_) monad_info seminfo
->  = interleave "\n" 
+>  = interleave "\n"
 >  $ map str (monad_defs monad_info)
 >    ++ map mk_inst ty_cs
 >    where
@@ -593,15 +593,15 @@ only unpacked when needed. Using classes here to manage the unpacking.
 >      mk_inst (ty, cs_vs)
 >       = str ("instance TreeDecode (" ++ ty ++ ") where ") . nl
 >        . interleave "\n"
->         [   char '\t' 
+>         [   char '\t'
 >           . str ("decode_b f (Branch (" ++ c_name ++ " s)")
 >           . str (" (" ++ var_pat ++ ")) = ")
 >            . cross_prod monad_info "s" (nodes filter_opt)
->         | (c_name, vs) <- cs_vs 
+>         | (c_name, vs) <- cs_vs
 >         , let vars = [ "b_" ++ show n | n <- var_range filter_opt vs ]
 >         , let var_pat = foldr (\l r -> l ++ ":" ++ r) "_" vars
 >         , let nodes NoFiltering  = [ vars !! n | n <- vs ]
->               nodes UseFiltering = vars 
+>               nodes UseFiltering = vars
 >         ]
 
 >      var_range _            [] = []
@@ -609,24 +609,24 @@ only unpacked when needed. Using classes here to manage the unpacking.
 >      var_range UseFiltering vs = [0 .. length vs - 1]
 
 >      cross_prod Nothing s_var nodes
->       = cross_prod_ (char '[' . str s_var . char ']') 
+>       = cross_prod_ (char '[' . str s_var . char ']')
 >                     (map str nodes)
 >      cross_prod (Just (_,tn,rtn)) s_var nodes
 >       = str "map happy_join $ "
 >        . cross_prod_ (char '[' . str rtn . char ' ' . str s_var . char ']')
 >                     (map str nodes)
 
->      cross_prod_ = foldl (\s a -> brack' 
->                                 $ str "cross_fn" 
->                                 . char ' ' . s 
->                                 . str " $ decode f " 
+>      cross_prod_ = foldl (\s a -> brack'
+>                                 $ str "cross_fn"
+>                                 . char ' ' . s
+>                                 . str " $ decode f "
 >                                 . a)
 
 
 
 > mkDecodeUtils (LabelDecode,_,_) monad_info seminfo
->  = interleave "\n" 
->  $ map str 
+>  = interleave "\n"
+>  $ map str
 >  $ monad_defs monad_info ++ concatMap (mk_inst) ty_cs
 >    where
 >      ty_cs = [ (ty, [ (c_name, mask)
@@ -647,24 +647,24 @@ This selects the info used for monadic parser generation
 
 > type MonadInfo = Maybe (String,String,String)
 > monad_sub :: Grammar -> MonadInfo
-> monad_sub g 
+> monad_sub g
 >  = case monad g of
 >      (True, _, ty,bd,ret) -> Just (ty,bd,ret)
->      _                    -> Nothing 
+>      _                    -> Nothing
 >    -- TMP: only use monad info if it was user-declared, and ignore ctxt
 >    -- TMP: otherwise default to non-monadic code
 >    -- TMP: (NB not sure of consequences of monads-everywhere yet)
 
 
---- 
-form the various monad-related defs. 
+---
+form the various monad-related defs.
 
 > monad_defs :: MonadInfo -> [String]
-> monad_defs Nothing          
+> monad_defs Nothing
 >  = [ "type Decode_Result a = a"
 >    , "happy_ap = ($)"
 >    , "happy_return = id"]
-> monad_defs (Just (ty,tn,rtn)) 
+> monad_defs (Just (ty,tn,rtn))
 >  = [ "happy_join x = (" ++ tn ++ ") x id"
 >    , "happy_ap f a = (" ++ tn ++ ") f (\\f -> (" ++ tn ++ ") a (\\a -> " ++ rtn ++ "(f a)))"
 >    , "type Decode_Result a = " ++ brack ty " a"
index e225d45..1481dc6 100644 (file)
@@ -32,6 +32,6 @@ filter p s = mkSet [ x | x <- setToList s, p x ]
 fold :: (a -> b -> b) -> b -> Set a -> b
 fold f z = foldr f z . setToList
 
-toAscList :: Set a -> [a] 
+toAscList :: Set a -> [a]
 toAscList = setToList
 #endif
index 4231d6f..e373634 100644 (file)
@@ -18,7 +18,7 @@ import ForeignCall    ( Safety(..), CExportSpec(..), CLabelString,
 import OccName         ( varName, dataName, tcClsName, tvName )
 import DataCon         ( DataCon, dataConName )
 import SrcLoc          ( Located(..), unLoc, getLoc, noLoc, combineSrcSpans,
-                         SrcSpan, combineLocs, srcLocFile, 
+                         SrcSpan, combineLocs, srcLocFile,
                          mkSrcLoc, mkSrcSpan )
 import Module
 import StaticFlags     ( opt_SccProfilingOn, opt_Hpc )
@@ -41,7 +41,7 @@ import Control.Monad    ( mplus )
 
 -- parser produced by Happy Version 1.16
 
-data HappyAbsSyn 
+data HappyAbsSyn
        = HappyTerminal (Located Token)
        | HappyErrorToken Int
        | HappyAbsSyn8 (Located RdrName)
@@ -69,8 +69,8 @@ data HappyAbsSyn
        | HappyAbsSyn39 (LTyClDecl RdrName)
        | HappyAbsSyn43 (Located NewOrData)
        | HappyAbsSyn44 (Located (Maybe Kind))
-       | HappyAbsSyn45 (Located (LHsContext RdrName, 
-                      Located RdrName, 
+       | HappyAbsSyn45 (Located (LHsContext RdrName,
+                      Located RdrName,
                       [LHsTyVarBndr RdrName],
                       [LHsType RdrName]))
        | HappyAbsSyn46 (LDerivDecl RdrName)
@@ -137,12 +137,12 @@ data HappyAbsSyn
        | HappyAbsSyn214 ((HaddockModInfo RdrName, Maybe (HsDoc RdrName)))
        | HappyAbsSyn215 (Maybe (LHsDoc RdrName))
 
-type HappyReduction m = 
-          Int 
+type HappyReduction m =
+          Int
        -> ((Located Token))
        -> HappyState ((Located Token)) (HappyStk HappyAbsSyn -> m HappyAbsSyn)
-       -> [HappyState ((Located Token)) (HappyStk HappyAbsSyn -> m HappyAbsSyn)] 
-       -> HappyStk HappyAbsSyn 
+       -> [HappyState ((Located Token)) (HappyStk HappyAbsSyn -> m HappyAbsSyn)]
+       -> HappyStk HappyAbsSyn
        -> m HappyAbsSyn
 
 action_0,
@@ -16145,28 +16145,28 @@ happyReduction_5 (HappyAbsSyn8  happy_var_1)
         =  HappyAbsSyn8
                 (happy_var_1
        )
-happyReduction_5 _  = notHappyAtAll 
+happyReduction_5 _  = notHappyAtAll
 
 happyReduce_6 = happySpecReduce_1  8 happyReduction_6
 happyReduction_6 (HappyAbsSyn8  happy_var_1)
         =  HappyAbsSyn8
                 (happy_var_1
        )
-happyReduction_6 _  = notHappyAtAll 
+happyReduction_6 _  = notHappyAtAll
 
 happyReduce_7 = happySpecReduce_1  8 happyReduction_7
 happyReduction_7 (HappyAbsSyn8  happy_var_1)
         =  HappyAbsSyn8
                 (happy_var_1
        )
-happyReduction_7 _  = notHappyAtAll 
+happyReduction_7 _  = notHappyAtAll
 
 happyReduce_8 = happySpecReduce_1  8 happyReduction_8
 happyReduction_8 (HappyAbsSyn8  happy_var_1)
         =  HappyAbsSyn8
                 (happy_var_1
        )
-happyReduction_8 _  = notHappyAtAll 
+happyReduction_8 _  = notHappyAtAll
 
 happyReduce_9 = happyMonadReduce 7 9 happyReduction_9
 happyReduction_9 ((HappyAbsSyn13  happy_var_7) `HappyStk`
@@ -16177,8 +16177,8 @@ happyReduction_9 ((HappyAbsSyn13  happy_var_7) `HappyStk`
        _ `HappyStk`
        (HappyAbsSyn10  happy_var_1) `HappyStk`
        happyRest) tk
-        = happyThen (( fileSrcSpan >>= \ loc -> case happy_var_1 of { (opt, info, doc) -> 
-                  return (L loc (HsModule (Just happy_var_3) happy_var_5 (fst happy_var_7) (snd happy_var_7) happy_var_4 
+        = happyThen (( fileSrcSpan >>= \ loc -> case happy_var_1 of { (opt, info, doc) ->
+                  return (L loc (HsModule (Just happy_var_3) happy_var_5 (fst happy_var_7) (snd happy_var_7) happy_var_4
                           opt info doc) )})
        ) (\r -> happyReturn (HappyAbsSyn9 r))
 
@@ -16188,8 +16188,8 @@ happyReduction_10 (_ `HappyStk`
        _ `HappyStk`
        happyRest) tk
         = happyThen (( fileSrcSpan >>= \ loc ->
-                  return (L loc (HsModule Nothing Nothing 
-                          (fst happy_var_2) (snd happy_var_2) Nothing Nothing emptyHaddockModInfo 
+                  return (L loc (HsModule Nothing Nothing
+                          (fst happy_var_2) (snd happy_var_2) Nothing Nothing emptyHaddockModInfo
                           Nothing)))
        ) (\r -> happyReturn (HappyAbsSyn9 r))
 
@@ -16198,14 +16198,14 @@ happyReduction_11 (HappyAbsSyn214  happy_var_1)
         =  HappyAbsSyn10
                 ((Nothing, fst happy_var_1, snd happy_var_1)
        )
-happyReduction_11 _  = notHappyAtAll 
+happyReduction_11 _  = notHappyAtAll
 
 happyReduce_12 = happySpecReduce_1  10 happyReduction_12
 happyReduction_12 (HappyAbsSyn213  happy_var_1)
         =  HappyAbsSyn10
                 ((Just happy_var_1, emptyHaddockModInfo, Nothing)
        )
-happyReduction_12 _  = notHappyAtAll 
+happyReduction_12 _  = notHappyAtAll
 
 happyReduce_13 = happySpecReduce_2  10 happyReduction_13
 happyReduction_13 (HappyAbsSyn214  happy_var_2)
@@ -16213,7 +16213,7 @@ happyReduction_13 (HappyAbsSyn214  happy_var_2)
         =  HappyAbsSyn10
                 ((Just happy_var_1, fst happy_var_2, snd happy_var_2)
        )
-happyReduction_13 _ _  = notHappyAtAll 
+happyReduction_13 _ _  = notHappyAtAll
 
 happyReduce_14 = happySpecReduce_2  10 happyReduction_14
 happyReduction_14 (HappyAbsSyn213  happy_var_2)
@@ -16221,7 +16221,7 @@ happyReduction_14 (HappyAbsSyn213  happy_var_2)
         =  HappyAbsSyn10
                 ((Just happy_var_2, fst happy_var_1, snd happy_var_1)
        )
-happyReduction_14 _ _  = notHappyAtAll 
+happyReduction_14 _ _  = notHappyAtAll
 
 happyReduce_15 = happySpecReduce_0  10 happyReduction_15
 happyReduction_15  =  HappyAbsSyn10
@@ -16240,7 +16240,7 @@ happyReduction_17 _
         =  HappyAbsSyn12
                 (Just (getSTRING happy_var_2)
        )
-happyReduction_17 _ _ _  = notHappyAtAll 
+happyReduction_17 _ _ _  = notHappyAtAll
 
 happyReduce_18 = happySpecReduce_0  12 happyReduction_18
 happyReduction_18  =  HappyAbsSyn12
@@ -16254,7 +16254,7 @@ happyReduction_19 _
         =  HappyAbsSyn13
                 (happy_var_2
        )
-happyReduction_19 _ _ _  = notHappyAtAll 
+happyReduction_19 _ _ _  = notHappyAtAll
 
 happyReduce_20 = happySpecReduce_3  13 happyReduction_20
 happyReduction_20 _
@@ -16263,14 +16263,14 @@ happyReduction_20 _
         =  HappyAbsSyn13
                 (happy_var_2
        )
-happyReduction_20 _ _ _  = notHappyAtAll 
+happyReduction_20 _ _ _  = notHappyAtAll
 
 happyReduce_21 = happySpecReduce_1  14 happyReduction_21
 happyReduction_21 (HappyAbsSyn17  happy_var_1)
         =  HappyAbsSyn13
                 ((reverse happy_var_1,[])
        )
-happyReduction_21 _  = notHappyAtAll 
+happyReduction_21 _  = notHappyAtAll
 
 happyReduce_22 = happySpecReduce_3  14 happyReduction_22
 happyReduction_22 (HappyAbsSyn15  happy_var_3)
@@ -16279,21 +16279,21 @@ happyReduction_22 (HappyAbsSyn15  happy_var_3)
         =  HappyAbsSyn13
                 ((reverse happy_var_1,happy_var_3)
        )
-happyReduction_22 _ _ _  = notHappyAtAll 
+happyReduction_22 _ _ _  = notHappyAtAll
 
 happyReduce_23 = happySpecReduce_1  14 happyReduction_23
 happyReduction_23 (HappyAbsSyn15  happy_var_1)
         =  HappyAbsSyn13
                 (([],happy_var_1)
        )
-happyReduction_23 _  = notHappyAtAll 
+happyReduction_23 _  = notHappyAtAll
 
 happyReduce_24 = happySpecReduce_1  15 happyReduction_24
 happyReduction_24 (HappyAbsSyn37  happy_var_1)
         =  HappyAbsSyn15
                 (cvTopDecls happy_var_1
        )
-happyReduction_24 _  = notHappyAtAll 
+happyReduction_24 _  = notHappyAtAll
 
 happyReduce_25 = happyMonadReduce 7 16 happyReduction_25
 happyReduction_25 ((HappyAbsSyn17  happy_var_7) `HappyStk`
@@ -16304,8 +16304,8 @@ happyReduction_25 ((HappyAbsSyn17  happy_var_7) `HappyStk`
        _ `HappyStk`
        (HappyAbsSyn10  happy_var_1) `HappyStk`
        happyRest) tk
-        = happyThen (( fileSrcSpan >>= \ loc -> case happy_var_1 of { (opt, info, doc) -> 
-                  return (L loc (HsModule (Just happy_var_3) happy_var_5 happy_var_7 [] happy_var_4 
+        = happyThen (( fileSrcSpan >>= \ loc -> case happy_var_1 of { (opt, info, doc) ->
+                  return (L loc (HsModule (Just happy_var_3) happy_var_5 happy_var_7 [] happy_var_4
                    opt info doc))})
        ) (\r -> happyReturn (HappyAbsSyn9 r))
 
@@ -16314,7 +16314,7 @@ happyReduction_26 ((HappyAbsSyn17  happy_var_2) `HappyStk`
        _ `HappyStk`
        happyRest) tk
         = happyThen (( fileSrcSpan >>= \ loc ->
-                  return (L loc (HsModule Nothing Nothing happy_var_2 [] Nothing 
+                  return (L loc (HsModule Nothing Nothing happy_var_2 [] Nothing
                    Nothing emptyHaddockModInfo Nothing)))
        ) (\r -> happyReturn (HappyAbsSyn9 r))
 
@@ -16324,7 +16324,7 @@ happyReduction_27 (HappyAbsSyn17  happy_var_2)
         =  HappyAbsSyn17
                 (happy_var_2
        )
-happyReduction_27 _ _  = notHappyAtAll 
+happyReduction_27 _ _  = notHappyAtAll
 
 happyReduce_28 = happySpecReduce_2  17 happyReduction_28
 happyReduction_28 (HappyAbsSyn17  happy_var_2)
@@ -16332,7 +16332,7 @@ happyReduction_28 (HappyAbsSyn17  happy_var_2)
         =  HappyAbsSyn17
                 (happy_var_2
        )
-happyReduction_28 _ _  = notHappyAtAll 
+happyReduction_28 _ _  = notHappyAtAll
 
 happyReduce_29 = happySpecReduce_3  18 happyReduction_29
 happyReduction_29 _
@@ -16341,7 +16341,7 @@ happyReduction_29 _
         =  HappyAbsSyn18
                 (Just happy_var_2
        )
-happyReduction_29 _ _ _  = notHappyAtAll 
+happyReduction_29 _ _ _  = notHappyAtAll
 
 happyReduce_30 = happySpecReduce_0  18 happyReduction_30
 happyReduction_30  =  HappyAbsSyn18
@@ -16355,14 +16355,14 @@ happyReduction_31 (HappyAbsSyn19  happy_var_3)
         =  HappyAbsSyn19
                 (happy_var_1 ++ happy_var_3
        )
-happyReduction_31 _ _ _  = notHappyAtAll 
+happyReduction_31 _ _ _  = notHappyAtAll
 
 happyReduce_32 = happySpecReduce_1  19 happyReduction_32
 happyReduction_32 (HappyAbsSyn19  happy_var_1)
         =  HappyAbsSyn19
                 (happy_var_1
        )
-happyReduction_32 _  = notHappyAtAll 
+happyReduction_32 _  = notHappyAtAll
 
 happyReduce_33 = happyReduce 5 20 happyReduction_33
 happyReduction_33 ((HappyAbsSyn19  happy_var_5) `HappyStk`
@@ -16382,14 +16382,14 @@ happyReduction_34 (HappyAbsSyn19  happy_var_3)
         =  HappyAbsSyn19
                 (happy_var_1 ++ (happy_var_2 : happy_var_3)
        )
-happyReduction_34 _ _ _  = notHappyAtAll 
+happyReduction_34 _ _ _  = notHappyAtAll
 
 happyReduce_35 = happySpecReduce_1  20 happyReduction_35
 happyReduction_35 (HappyAbsSyn19  happy_var_1)
         =  HappyAbsSyn19
                 (happy_var_1
        )
-happyReduction_35 _  = notHappyAtAll 
+happyReduction_35 _  = notHappyAtAll
 
 happyReduce_36 = happySpecReduce_2  21 happyReduction_36
 happyReduction_36 (HappyAbsSyn19  happy_var_2)
@@ -16397,7 +16397,7 @@ happyReduction_36 (HappyAbsSyn19  happy_var_2)
         =  HappyAbsSyn19
                 (happy_var_1 : happy_var_2
        )
-happyReduction_36 _ _  = notHappyAtAll 
+happyReduction_36 _ _  = notHappyAtAll
 
 happyReduce_37 = happySpecReduce_0  21 happyReduction_37
 happyReduction_37  =  HappyAbsSyn19
@@ -16409,35 +16409,35 @@ happyReduction_38 (HappyAbsSyn212  happy_var_1)
         =  HappyAbsSyn22
                 (sL (getLoc happy_var_1) (case (unLoc happy_var_1) of (n, doc) -> IEGroup n doc)
        )
-happyReduction_38 _  = notHappyAtAll 
+happyReduction_38 _  = notHappyAtAll
 
 happyReduce_39 = happySpecReduce_1  22 happyReduction_39
 happyReduction_39 (HappyAbsSyn211  happy_var_1)
         =  HappyAbsSyn22
                 (sL (getLoc happy_var_1) (IEDocNamed ((fst . unLoc) happy_var_1))
        )
-happyReduction_39 _  = notHappyAtAll 
+happyReduction_39 _  = notHappyAtAll
 
 happyReduce_40 = happySpecReduce_1  22 happyReduction_40
 happyReduction_40 (HappyAbsSyn209  happy_var_1)
         =  HappyAbsSyn22
                 (sL (getLoc happy_var_1) (IEDoc (unLoc happy_var_1))
        )
-happyReduction_40 _  = notHappyAtAll 
+happyReduction_40 _  = notHappyAtAll
 
 happyReduce_41 = happySpecReduce_1  23 happyReduction_41
 happyReduction_41 (HappyAbsSyn8  happy_var_1)
         =  HappyAbsSyn22
                 (sL (getLoc happy_var_1) (IEVar (unLoc happy_var_1))
        )
-happyReduction_41 _  = notHappyAtAll 
+happyReduction_41 _  = notHappyAtAll
 
 happyReduce_42 = happySpecReduce_1  23 happyReduction_42
 happyReduction_42 (HappyAbsSyn8  happy_var_1)
         =  HappyAbsSyn22
                 (sL (getLoc happy_var_1) (IEThingAbs (unLoc happy_var_1))
        )
-happyReduction_42 _  = notHappyAtAll 
+happyReduction_42 _  = notHappyAtAll
 
 happyReduce_43 = happyReduce 4 23 happyReduction_43
 happyReduction_43 ((HappyTerminal happy_var_4) `HappyStk`
@@ -16456,7 +16456,7 @@ happyReduction_44 (HappyTerminal happy_var_3)
         =  HappyAbsSyn22
                 (sL (comb2 happy_var_1 happy_var_3) (IEThingWith (unLoc happy_var_1) [])
        )
-happyReduction_44 _ _ _  = notHappyAtAll 
+happyReduction_44 _ _ _  = notHappyAtAll
 
 happyReduce_45 = happyReduce 4 23 happyReduction_45
 happyReduction_45 ((HappyTerminal happy_var_4) `HappyStk`
@@ -16474,7 +16474,7 @@ happyReduction_46 (HappyAbsSyn207  happy_var_2)
         =  HappyAbsSyn22
                 (sL (comb2 happy_var_1 happy_var_2) (IEModuleContents (unLoc happy_var_2))
        )
-happyReduction_46 _ _  = notHappyAtAll 
+happyReduction_46 _ _  = notHappyAtAll
 
 happyReduce_47 = happySpecReduce_3  24 happyReduction_47
 happyReduction_47 (HappyAbsSyn8  happy_var_3)
@@ -16483,45 +16483,45 @@ happyReduction_47 (HappyAbsSyn8  happy_var_3)
         =  HappyAbsSyn24
                 (unLoc happy_var_3 : happy_var_1
        )
-happyReduction_47 _ _ _  = notHappyAtAll 
+happyReduction_47 _ _ _  = notHappyAtAll
 
 happyReduce_48 = happySpecReduce_1  24 happyReduction_48
 happyReduction_48 (HappyAbsSyn8  happy_var_1)
         =  HappyAbsSyn24
                 ([unLoc happy_var_1]
        )
-happyReduction_48 _  = notHappyAtAll 
+happyReduction_48 _  = notHappyAtAll
 
 happyReduce_49 = happySpecReduce_1  25 happyReduction_49
 happyReduction_49 (HappyAbsSyn8  happy_var_1)
         =  HappyAbsSyn8
                 (happy_var_1
        )
-happyReduction_49 _  = notHappyAtAll 
+happyReduction_49 _  = notHappyAtAll
 
 happyReduce_50 = happySpecReduce_2  25 happyReduction_50
 happyReduction_50 (HappyAbsSyn8  happy_var_2)
        (HappyTerminal happy_var_1)
         =  HappyAbsSyn8
-                (sL (comb2 happy_var_1 happy_var_2) 
-                                            (setRdrNameSpace (unLoc happy_var_2) 
+                (sL (comb2 happy_var_1 happy_var_2)
+                                            (setRdrNameSpace (unLoc happy_var_2)
                                                              tcClsName)
        )
-happyReduction_50 _ _  = notHappyAtAll 
+happyReduction_50 _ _  = notHappyAtAll
 
 happyReduce_51 = happySpecReduce_1  26 happyReduction_51
 happyReduction_51 (HappyAbsSyn8  happy_var_1)
         =  HappyAbsSyn8
                 (happy_var_1
        )
-happyReduction_51 _  = notHappyAtAll 
+happyReduction_51 _  = notHappyAtAll
 
 happyReduce_52 = happySpecReduce_1  26 happyReduction_52
 happyReduction_52 (HappyAbsSyn8  happy_var_1)
         =  HappyAbsSyn8
                 (happy_var_1
        )
-happyReduction_52 _  = notHappyAtAll 
+happyReduction_52 _  = notHappyAtAll
 
 happyReduce_53 = happySpecReduce_3  27 happyReduction_53
 happyReduction_53 (HappyAbsSyn28  happy_var_3)
@@ -16530,7 +16530,7 @@ happyReduction_53 (HappyAbsSyn28  happy_var_3)
         =  HappyAbsSyn17
                 (happy_var_3 : happy_var_1
        )
-happyReduction_53 _ _ _  = notHappyAtAll 
+happyReduction_53 _ _ _  = notHappyAtAll
 
 happyReduce_54 = happySpecReduce_2  27 happyReduction_54
 happyReduction_54 _
@@ -16538,14 +16538,14 @@ happyReduction_54 _
         =  HappyAbsSyn17
                 (happy_var_1
        )
-happyReduction_54 _ _  = notHappyAtAll 
+happyReduction_54 _ _  = notHappyAtAll
 
 happyReduce_55 = happySpecReduce_1  27 happyReduction_55
 happyReduction_55 (HappyAbsSyn28  happy_var_1)
         =  HappyAbsSyn17
                 ([ happy_var_1 ]
        )
-happyReduction_55 _  = notHappyAtAll 
+happyReduction_55 _  = notHappyAtAll
 
 happyReduce_56 = happySpecReduce_0  27 happyReduction_56
 happyReduction_56  =  HappyAbsSyn17
@@ -16593,7 +16593,7 @@ happyReduction_62 (HappyAbsSyn207  happy_var_2)
         =  HappyAbsSyn31
                 (sL (comb2 happy_var_1 happy_var_2) (Just (unLoc happy_var_2))
        )
-happyReduction_62 _ _  = notHappyAtAll 
+happyReduction_62 _ _  = notHappyAtAll
 
 happyReduce_63 = happySpecReduce_0  31 happyReduction_63
 happyReduction_63  =  HappyAbsSyn31
@@ -16605,7 +16605,7 @@ happyReduction_64 (HappyAbsSyn33  happy_var_1)
         =  HappyAbsSyn32
                 (sL (getLoc happy_var_1) (Just (unLoc happy_var_1))
        )
-happyReduction_64 _  = notHappyAtAll 
+happyReduction_64 _  = notHappyAtAll
 
 happyReduce_65 = happySpecReduce_0  32 happyReduction_65
 happyReduction_65  =  HappyAbsSyn32
@@ -16619,7 +16619,7 @@ happyReduction_66 (HappyTerminal happy_var_3)
         =  HappyAbsSyn33
                 (sL (comb2 happy_var_1 happy_var_3) (False, happy_var_2)
        )
-happyReduction_66 _ _ _  = notHappyAtAll 
+happyReduction_66 _ _ _  = notHappyAtAll
 
 happyReduce_67 = happyReduce 4 33 happyReduction_67
 happyReduction_67 ((HappyTerminal happy_var_4) `HappyStk`
@@ -16647,21 +16647,21 @@ happyReduction_70 (HappyTerminal happy_var_1)
         =  HappyAbsSyn35
                 (sL (getLoc happy_var_1) InfixN
        )
-happyReduction_70 _  = notHappyAtAll 
+happyReduction_70 _  = notHappyAtAll
 
 happyReduce_71 = happySpecReduce_1  35 happyReduction_71
 happyReduction_71 (HappyTerminal happy_var_1)
         =  HappyAbsSyn35
                 (sL (getLoc happy_var_1) InfixL
        )
-happyReduction_71 _  = notHappyAtAll 
+happyReduction_71 _  = notHappyAtAll
 
 happyReduce_72 = happySpecReduce_1  35 happyReduction_72
 happyReduction_72 (HappyTerminal happy_var_1)
         =  HappyAbsSyn35
                 (sL (getLoc happy_var_1) InfixR
        )
-happyReduction_72 _  = notHappyAtAll 
+happyReduction_72 _  = notHappyAtAll
 
 happyReduce_73 = happySpecReduce_3  36 happyReduction_73
 happyReduction_73 (HappyAbsSyn8  happy_var_3)
@@ -16670,14 +16670,14 @@ happyReduction_73 (HappyAbsSyn8  happy_var_3)
         =  HappyAbsSyn36
                 (sL (comb2 happy_var_1 happy_var_3) (happy_var_3 : unLoc happy_var_1)
        )
-happyReduction_73 _ _ _  = notHappyAtAll 
+happyReduction_73 _ _ _  = notHappyAtAll
 
 happyReduce_74 = happySpecReduce_1  36 happyReduction_74
 happyReduction_74 (HappyAbsSyn8  happy_var_1)
         =  HappyAbsSyn36
                 (sL (getLoc happy_var_1) [happy_var_1]
        )
-happyReduction_74 _  = notHappyAtAll 
+happyReduction_74 _  = notHappyAtAll
 
 happyReduce_75 = happySpecReduce_3  37 happyReduction_75
 happyReduction_75 (HappyAbsSyn37  happy_var_3)
@@ -16686,7 +16686,7 @@ happyReduction_75 (HappyAbsSyn37  happy_var_3)
         =  HappyAbsSyn37
                 (happy_var_1 `appOL` happy_var_3
        )
-happyReduction_75 _ _ _  = notHappyAtAll 
+happyReduction_75 _ _ _  = notHappyAtAll
 
 happyReduce_76 = happySpecReduce_2  37 happyReduction_76
 happyReduction_76 _
@@ -16694,28 +16694,28 @@ happyReduction_76 _
         =  HappyAbsSyn37
                 (happy_var_1
        )
-happyReduction_76 _ _  = notHappyAtAll 
+happyReduction_76 _ _  = notHappyAtAll
 
 happyReduce_77 = happySpecReduce_1  37 happyReduction_77
 happyReduction_77 (HappyAbsSyn37  happy_var_1)
         =  HappyAbsSyn37
                 (happy_var_1
        )
-happyReduction_77 _  = notHappyAtAll 
+happyReduction_77 _  = notHappyAtAll
 
 happyReduce_78 = happySpecReduce_1  38 happyReduction_78
 happyReduction_78 (HappyAbsSyn39  happy_var_1)
         =  HappyAbsSyn37
                 (unitOL (sL (getLoc happy_var_1) (TyClD (unLoc happy_var_1)))
        )
-happyReduction_78 _  = notHappyAtAll 
+happyReduction_78 _  = notHappyAtAll
 
 happyReduce_79 = happySpecReduce_1  38 happyReduction_79
 happyReduction_79 (HappyAbsSyn39  happy_var_1)
         =  HappyAbsSyn37
                 (unitOL (sL (getLoc happy_var_1) (TyClD (unLoc happy_var_1)))
        )
-happyReduction_79 _  = notHappyAtAll 
+happyReduction_79 _  = notHappyAtAll
 
 happyReduce_80 = happySpecReduce_3  38 happyReduction_80
 happyReduction_80 (HappyAbsSyn47  happy_var_3)
@@ -16723,17 +16723,17 @@ happyReduction_80 (HappyAbsSyn47  happy_var_3)
        (HappyTerminal happy_var_1)
         =  HappyAbsSyn37
                 (let (binds, sigs, ats, _) = cvBindsAndSigs (unLoc happy_var_3)
-             in 
+             in
              unitOL (L (comb3 happy_var_1 happy_var_2 happy_var_3) (InstD (InstDecl happy_var_2 binds sigs ats)))
        )
-happyReduction_80 _ _ _  = notHappyAtAll 
+happyReduction_80 _ _ _  = notHappyAtAll
 
 happyReduce_81 = happySpecReduce_1  38 happyReduction_81
 happyReduction_81 (HappyAbsSyn46  happy_var_1)
         =  HappyAbsSyn37
                 (unitOL (sL (comb2 happy_var_1 happy_var_1) (DerivD (unLoc happy_var_1)))
        )
-happyReduction_81 _  = notHappyAtAll 
+happyReduction_81 _  = notHappyAtAll
 
 happyReduce_82 = happyReduce 4 38 happyReduction_82
 happyReduction_82 ((HappyTerminal happy_var_4) `HappyStk`
@@ -16751,7 +16751,7 @@ happyReduction_83 (HappyAbsSyn60  happy_var_2)
         =  HappyAbsSyn37
                 (unitOL (sL (comb2 happy_var_1 happy_var_2) (unLoc happy_var_2))
        )
-happyReduction_83 _ _  = notHappyAtAll 
+happyReduction_83 _ _  = notHappyAtAll
 
 happyReduce_84 = happySpecReduce_3  38 happyReduction_84
 happyReduction_84 _
@@ -16760,7 +16760,7 @@ happyReduction_84 _
         =  HappyAbsSyn37
                 (happy_var_2
        )
-happyReduction_84 _ _ _  = notHappyAtAll 
+happyReduction_84 _ _ _  = notHappyAtAll
 
 happyReduce_85 = happySpecReduce_3  38 happyReduction_85
 happyReduction_85 _
@@ -16769,14 +16769,14 @@ happyReduction_85 _
         =  HappyAbsSyn37
                 (happy_var_2
        )
-happyReduction_85 _ _ _  = notHappyAtAll 
+happyReduction_85 _ _ _  = notHappyAtAll
 
 happyReduce_86 = happySpecReduce_1  38 happyReduction_86
 happyReduction_86 (HappyAbsSyn47  happy_var_1)
         =  HappyAbsSyn37
                 (unLoc happy_var_1
        )
-happyReduction_86 _  = notHappyAtAll 
+happyReduction_86 _  = notHappyAtAll
 
 happyReduce_87 = happySpecReduce_3  38 happyReduction_87
 happyReduction_87 (HappyTerminal happy_var_3)
@@ -16785,7 +16785,7 @@ happyReduction_87 (HappyTerminal happy_var_3)
         =  HappyAbsSyn37
                 (unitOL (sL (comb2 happy_var_1 happy_var_3) $ SpliceD (SpliceDecl happy_var_2))
        )
-happyReduction_87 _ _ _  = notHappyAtAll 
+happyReduction_87 _ _ _  = notHappyAtAll
 
 happyReduce_88 = happySpecReduce_1  38 happyReduction_88
 happyReduction_88 (HappyTerminal happy_var_1)
@@ -16794,7 +16794,7 @@ happyReduction_88 (HappyTerminal happy_var_1)
                                                        sL (getLoc happy_var_1) $ HsVar (mkUnqual varName (getTH_ID_SPLICE happy_var_1))
                                                  ))
        )
-happyReduction_88 _  = notHappyAtAll 
+happyReduction_88 _  = notHappyAtAll
 
 happyReduce_89 = happyMonadReduce 4 39 happyReduction_89
 happyReduction_89 ((HappyAbsSyn47  happy_var_4) `HappyStk`
@@ -16802,13 +16802,13 @@ happyReduction_89 ((HappyAbsSyn47  happy_var_4) `HappyStk`
        (HappyAbsSyn45  happy_var_2) `HappyStk`
        (HappyTerminal happy_var_1) `HappyStk`
        happyRest) tk
-        = happyThen (( do { let { (binds, sigs, ats, docs)           = 
+        = happyThen (( do { let { (binds, sigs, ats, docs)           =
                                cvBindsAndSigs (unLoc happy_var_4)
                            ; (ctxt, tc, tvs, tparms) = unLoc happy_var_2}
                       ; checkTyVars tparms      -- only type vars allowed
                      ; checkKindSigs ats
-                     ; return $ L (comb4 happy_var_1 happy_var_2 happy_var_3 happy_var_4) 
-                                  (mkClassDecl (ctxt, tc, tvs) 
+                     ; return $ L (comb4 happy_var_1 happy_var_2 happy_var_3 happy_var_4)
+                                  (mkClassDecl (ctxt, tc, tvs)
                                                (unLoc happy_var_3) sigs binds ats docs) })
        ) (\r -> happyReturn (HappyAbsSyn39 r))
 
@@ -16819,7 +16819,7 @@ happyReduction_90 ((HappyAbsSyn75  happy_var_4) `HappyStk`
        (HappyTerminal happy_var_1) `HappyStk`
        happyRest) tk
         = happyThen (( do { (tc, tvs, _) <- checkSynHdr happy_var_2 False
-                     ; return (L (comb2 happy_var_1 happy_var_4) 
+                     ; return (L (comb2 happy_var_1 happy_var_4)
                                  (TySynonym tc tvs Nothing happy_var_4))
                       })
        ) (\r -> happyReturn (HappyAbsSyn39 r))
@@ -16831,7 +16831,7 @@ happyReduction_91 ((HappyAbsSyn44  happy_var_4) `HappyStk`
        (HappyTerminal happy_var_1) `HappyStk`
        happyRest) tk
         = happyThen (( do { (tc, tvs, _) <- checkSynHdr happy_var_3 False
-                     ; return (L (comb3 happy_var_1 happy_var_3 happy_var_4) 
+                     ; return (L (comb3 happy_var_1 happy_var_3 happy_var_4)
                                  (TyFamily TypeFamily tc tvs (unLoc happy_var_4)))
                      })
        ) (\r -> happyReturn (HappyAbsSyn39 r))
@@ -16844,8 +16844,8 @@ happyReduction_92 ((HappyAbsSyn75  happy_var_5) `HappyStk`
        (HappyTerminal happy_var_1) `HappyStk`
        happyRest) tk
         = happyThen (( do { (tc, tvs, typats) <- checkSynHdr happy_var_3 True
-                     ; return (L (comb2 happy_var_1 happy_var_5) 
-                                 (TySynonym tc tvs (Just typats) happy_var_5)) 
+                     ; return (L (comb2 happy_var_1 happy_var_5)
+                                 (TySynonym tc tvs (Just typats) happy_var_5))
                       })
        ) (\r -> happyReturn (HappyAbsSyn39 r))
 
@@ -16859,9 +16859,9 @@ happyReduction_93 ((HappyAbsSyn113  happy_var_4) `HappyStk`
                       ; checkTyVars tparms    -- no type pattern
                      ; return $
                          L (comb4 happy_var_1 happy_var_2 happy_var_3 happy_var_4)
-                                  -- We need the location on tycl_hdr in case 
+                                  -- We need the location on tycl_hdr in case
                                   -- constrs and deriving are both empty
-                           (mkTyData (unLoc happy_var_1) (ctxt, tc, tvs, Nothing) 
+                           (mkTyData (unLoc happy_var_1) (ctxt, tc, tvs, Nothing)
                               Nothing (reverse (unLoc happy_var_3)) (unLoc happy_var_4)) })
        ) (\r -> happyReturn (HappyAbsSyn39 r))
 
@@ -16877,7 +16877,7 @@ happyReduction_94 ((HappyAbsSyn113  happy_var_6) `HappyStk`
                       ; checkTyVars tparms    -- can have type pats
                      ; return $
                          L (comb4 happy_var_1 happy_var_2 happy_var_4 happy_var_5)
-                           (mkTyData (unLoc happy_var_1) (ctxt, tc, tvs, Nothing) 
+                           (mkTyData (unLoc happy_var_1) (ctxt, tc, tvs, Nothing)
                              (unLoc happy_var_3) (reverse (unLoc happy_var_5)) (unLoc happy_var_6)) })
        ) (\r -> happyReturn (HappyAbsSyn39 r))
 
@@ -16890,11 +16890,11 @@ happyReduction_95 ((HappyAbsSyn44  happy_var_4) `HappyStk`
         = happyThen (( do { let {(ctxt, tc, tvs, tparms) = unLoc happy_var_3}
                       ; checkTyVars tparms            -- no type pattern
                      ; unless (null (unLoc ctxt)) $  -- and no context
-                         parseError (getLoc ctxt) 
+                         parseError (getLoc ctxt)
                            "A family declaration cannot have a context"
                      ; return $
                          L (comb3 happy_var_1 happy_var_2 happy_var_4)
-                           (TyFamily (DataFamily (unLoc happy_var_1)) tc tvs 
+                           (TyFamily (DataFamily (unLoc happy_var_1)) tc tvs
                                      (unLoc happy_var_4)) })
        ) (\r -> happyReturn (HappyAbsSyn39 r))
 
@@ -16909,9 +16909,9 @@ happyReduction_96 ((HappyAbsSyn113  happy_var_5) `HappyStk`
                                              -- can have type pats
                      ; return $
                          L (comb4 happy_var_1 happy_var_3 happy_var_4 happy_var_5)
-                                  -- We need the location on tycl_hdr in case 
+                                  -- We need the location on tycl_hdr in case
                                   -- constrs and deriving are both empty
-                           (mkTyData (unLoc happy_var_1) (ctxt, tc, tvs, Just tparms) 
+                           (mkTyData (unLoc happy_var_1) (ctxt, tc, tvs, Just tparms)
                              Nothing (reverse (unLoc happy_var_4)) (unLoc happy_var_5)) })
        ) (\r -> happyReturn (HappyAbsSyn39 r))
 
@@ -16928,7 +16928,7 @@ happyReduction_97 ((HappyAbsSyn113  happy_var_7) `HappyStk`
                                              -- can have type pats
                      ; return $
                          L (comb4 happy_var_1 happy_var_3 happy_var_6 happy_var_7)
-                           (mkTyData (unLoc happy_var_1) (ctxt, tc, tvs, Just tparms) 
+                           (mkTyData (unLoc happy_var_1) (ctxt, tc, tvs, Just tparms)
                               (unLoc happy_var_4) (reverse (unLoc happy_var_6)) (unLoc happy_var_7)) })
        ) (\r -> happyReturn (HappyAbsSyn39 r))
 
@@ -16938,7 +16938,7 @@ happyReduction_98 ((HappyAbsSyn44  happy_var_3) `HappyStk`
        (HappyTerminal happy_var_1) `HappyStk`
        happyRest) tk
         = happyThen (( do { (tc, tvs, _) <- checkSynHdr happy_var_2 False
-                     ; return (L (comb3 happy_var_1 happy_var_2 happy_var_3) 
+                     ; return (L (comb3 happy_var_1 happy_var_2 happy_var_3)
                                  (TyFamily TypeFamily tc tvs (unLoc happy_var_3)))
                      })
        ) (\r -> happyReturn (HappyAbsSyn39 r))
@@ -16950,8 +16950,8 @@ happyReduction_99 ((HappyAbsSyn75  happy_var_4) `HappyStk`
        (HappyTerminal happy_var_1) `HappyStk`
        happyRest) tk
         = happyThen (( do { (tc, tvs, typats) <- checkSynHdr happy_var_2 True
-                     ; return (L (comb2 happy_var_1 happy_var_4) 
-                                 (TySynonym tc tvs (Just typats) happy_var_4)) 
+                     ; return (L (comb2 happy_var_1 happy_var_4)
+                                 (TySynonym tc tvs (Just typats) happy_var_4))
                       })
        ) (\r -> happyReturn (HappyAbsSyn39 r))
 
@@ -16963,12 +16963,12 @@ happyReduction_100 ((HappyAbsSyn44  happy_var_3) `HappyStk`
         = happyThen (( do { let {(ctxt, tc, tvs, tparms) = unLoc happy_var_2}
                       ; checkTyVars tparms            -- no type pattern
                      ; unless (null (unLoc ctxt)) $  -- and no context
-                         parseError (getLoc ctxt) 
+                         parseError (getLoc ctxt)
                            "A family declaration cannot have a context"
                      ; return $
                          L (comb3 happy_var_1 happy_var_2 happy_var_3)
                            (TyFamily (DataFamily (unLoc happy_var_1)) tc tvs
-                                     (unLoc happy_var_3)) 
+                                     (unLoc happy_var_3))
                       })
        ) (\r -> happyReturn (HappyAbsSyn39 r))
 
@@ -16979,8 +16979,8 @@ happyReduction_101 ((HappyAbsSyn75  happy_var_4) `HappyStk`
        (HappyTerminal happy_var_1) `HappyStk`
        happyRest) tk
         = happyThen (( do { (tc, tvs, typats) <- checkSynHdr happy_var_2 True
-                     ; return (L (comb2 happy_var_1 happy_var_4) 
-                                 (TySynonym tc tvs (Just typats) happy_var_4)) 
+                     ; return (L (comb2 happy_var_1 happy_var_4)
+                                 (TySynonym tc tvs (Just typats) happy_var_4))
                       })
        ) (\r -> happyReturn (HappyAbsSyn39 r))
 
@@ -16994,9 +16994,9 @@ happyReduction_102 ((HappyAbsSyn113  happy_var_4) `HappyStk`
                                              -- can have type pats
                      ; return $
                          L (comb4 happy_var_1 happy_var_2 happy_var_3 happy_var_4)
-                                  -- We need the location on tycl_hdr in case 
+                                  -- We need the location on tycl_hdr in case
                                   -- constrs and deriving are both empty
-                           (mkTyData (unLoc happy_var_1) (ctxt, tc, tvs, Just tparms) 
+                           (mkTyData (unLoc happy_var_1) (ctxt, tc, tvs, Just tparms)
                              Nothing (reverse (unLoc happy_var_3)) (unLoc happy_var_4)) })
        ) (\r -> happyReturn (HappyAbsSyn39 r))
 
@@ -17012,7 +17012,7 @@ happyReduction_103 ((HappyAbsSyn113  happy_var_6) `HappyStk`
                                              -- can have type pats
                      ; return $
                          L (comb4 happy_var_1 happy_var_2 happy_var_5 happy_var_6)
-                           (mkTyData (unLoc happy_var_1) (ctxt, tc, tvs, Just tparms) 
+                           (mkTyData (unLoc happy_var_1) (ctxt, tc, tvs, Just tparms)
                             (unLoc happy_var_3) (reverse (unLoc happy_var_5)) (unLoc happy_var_6)) })
        ) (\r -> happyReturn (HappyAbsSyn39 r))
 
@@ -17021,14 +17021,14 @@ happyReduction_104 (HappyTerminal happy_var_1)
         =  HappyAbsSyn43
                 (sL (getLoc happy_var_1) DataType
        )
-happyReduction_104 _  = notHappyAtAll 
+happyReduction_104 _  = notHappyAtAll
 
 happyReduce_105 = happySpecReduce_1  43 happyReduction_105
 happyReduction_105 (HappyTerminal happy_var_1)
         =  HappyAbsSyn43
                 (sL (getLoc happy_var_1) NewType
        )
-happyReduction_105 _  = notHappyAtAll 
+happyReduction_105 _  = notHappyAtAll
 
 happyReduce_106 = happySpecReduce_0  44 happyReduction_106
 happyReduction_106  =  HappyAbsSyn44
@@ -17041,7 +17041,7 @@ happyReduction_107 (HappyAbsSyn100  happy_var_2)
         =  HappyAbsSyn44
                 (sL (comb2 happy_var_1 happy_var_2) (Just (unLoc happy_var_2))
        )
-happyReduction_107 _ _  = notHappyAtAll 
+happyReduction_107 _ _  = notHappyAtAll
 
 happyReduce_108 = happyMonadReduce 3 45 happyReduction_108
 happyReduction_108 ((HappyAbsSyn75  happy_var_3) `HappyStk`
@@ -17070,14 +17070,14 @@ happyReduction_111 (HappyAbsSyn39  happy_var_1)
         =  HappyAbsSyn47
                 (sL (comb2 happy_var_1 happy_var_1) (unitOL (sL (getLoc happy_var_1) (TyClD (unLoc happy_var_1))))
        )
-happyReduction_111 _  = notHappyAtAll 
+happyReduction_111 _  = notHappyAtAll
 
 happyReduce_112 = happySpecReduce_1  47 happyReduction_112
 happyReduction_112 (HappyAbsSyn47  happy_var_1)
         =  HappyAbsSyn47
                 (happy_var_1
        )
-happyReduction_112 _  = notHappyAtAll 
+happyReduction_112 _  = notHappyAtAll
 
 happyReduce_113 = happySpecReduce_3  48 happyReduction_113
 happyReduction_113 (HappyAbsSyn47  happy_var_3)
@@ -17086,7 +17086,7 @@ happyReduction_113 (HappyAbsSyn47  happy_var_3)
         =  HappyAbsSyn47
                 (sL (comb2 happy_var_1 happy_var_3) (unLoc happy_var_1 `appOL` unLoc happy_var_3)
        )
-happyReduction_113 _ _ _  = notHappyAtAll 
+happyReduction_113 _ _ _  = notHappyAtAll
 
 happyReduce_114 = happySpecReduce_2  48 happyReduction_114
 happyReduction_114 (HappyTerminal happy_var_2)
@@ -17094,14 +17094,14 @@ happyReduction_114 (HappyTerminal happy_var_2)
         =  HappyAbsSyn47
                 (sL (comb2 happy_var_1 happy_var_2) (unLoc happy_var_1)
        )
-happyReduction_114 _ _  = notHappyAtAll 
+happyReduction_114 _ _  = notHappyAtAll
 
 happyReduce_115 = happySpecReduce_1  48 happyReduction_115
 happyReduction_115 (HappyAbsSyn47  happy_var_1)
         =  HappyAbsSyn47
                 (happy_var_1
        )
-happyReduction_115 _  = notHappyAtAll 
+happyReduction_115 _  = notHappyAtAll
 
 happyReduce_116 = happySpecReduce_0  48 happyReduction_116
 happyReduction_116  =  HappyAbsSyn47