import FastString
import BasicTypes
import Binary
-import Ratio
import Data.Int
+import Data.Ratio
import Data.Word
import Data.Char
\end{code}
import ClosureInfo
import Maybes
-import List
+import Data.List
import Panic
import Unique
import FiniteMap
import ForeignCall
import IdInfo
-import List (sortBy)
+import Data.List
import Maybes
import MkZipCfg
import MkZipCfgCmm hiding (CmmAGraph, CmmBlock, CmmTopZ, CmmZ, CmmGraph)
-import Monad
+import Control.Monad
import Name
import Outputable
import SMRep
import UniqSet
import Unique
-import Monad
+import Control.Monad
-----------------------------------------------------------------------------
-- |Top level driver for the CPS pass
import Constants
import StaticFlags
import Unique
-import Maybe
+import Data.Maybe
import FastString
import Panic
import ErrUtils
import FiniteMap
import HscTypes
-import Maybe
-import Monad
+import Data.Maybe
+import Control.Monad
import Outputable
import StaticFlags
import ZipCfgCmmRep
import Data.Bits
+import qualified Data.List as List
import Data.Word
import FastString
-import List hiding (iterate)
-import Monad
+import Control.Monad
import Outputable
import UniqFM
import Unique
common_block :: (Outputable h, Uniquable h) => State -> (h, CmmBlock) -> (Bool, State)
common_block (bmap, subst) (hash, b) =
case lookupUFM bmap hash of
- Just bs -> case (find (eqBlockBodyWith (eqBid subst) b) bs,
+ Just bs -> case (List.find (eqBlockBodyWith (eqBid subst) b) bs,
lookupBlockEnv subst bid) of
(Just b', Nothing) -> addSubst b'
(Just b', Just b'') | blockId b' /= b'' -> addSubst b'
import ZipCfgCmmRep
import Maybes
-import Monad
+import Control.Monad
import Outputable
import Prelude hiding (unzip, zip)
import Util
import qualified ZipCfg as G
import FastString
-import Monad
+import Control.Monad
import Outputable
import UniqSupply
import BlockId
import Cmm
import CLabel
-import Maybe
import Outputable
import PprCmm
import Constants
import FastString
import Control.Monad
+import Data.Maybe
-- -----------------------------------------------------------------------------
-- Exported entry points:
import CmmExpr
import CmmTx
import DFMonad
-import Monad
+import Control.Monad
import PprCmm()
import PprCmmZ()
import ZipCfg
import CmmTx
import DFMonad
import FiniteMap
-import List (sortBy)
+import Data.List (sortBy)
import Maybes
import MkZipCfg
import MkZipCfgCmm hiding (CmmBlock, CmmGraph, CmmTopZ)
-import Monad
+import Control.Monad
import Outputable
import UniqSet
import UniqSupply
import ZipCfgCmmRep
import ZipDataflow
-import Monad
+import Control.Monad
import Outputable hiding (empty)
import qualified Outputable as PP
import UniqSet
-import Maybe
+import Data.Maybe
import Prelude hiding (zip)
-- The point of this module is to insert spills and reloads to
import Maybes
import MkZipCfg
import MkZipCfgCmm hiding (CmmBlock, CmmGraph)
-import Monad
+import Control.Monad
import Outputable
import SMRep (ByteOff)
import ZipCfg
--import GHC.Exts (State#)
import Panic
import Data.IORef
-import Monad
+import Control.Monad
import StaticFlags (opt_Fuel)
import UniqSupply
import qualified ZipCfg as Z
import CmmZipUtil
-import Maybe
+import Data.Maybe
import FastString
----------------------------------------------------------------
import Outputable hiding (empty)
-import Maybe
+import Data.Maybe
import Prelude hiding (zip, unzip, last)
-------------------------------------------------------------------------
import BasicTypes
import Maybes
-import Monad
+import Control.Monad
import Outputable
import Prelude hiding (zip, unzip, last)
import SMRep (ByteOff)
import FastString
import HscTypes
import Panic
-import Char
import BasicTypes
+import Data.Char
import Data.Word
cgTickBox :: Module -> Int -> Code
import StgSyn
import CostCentre
import Id
-import Monad (foldM, liftM)
+import Control.Monad
import Name
import Module
import ListSetOps
import PrelInfo
import Outputable
import Util ( lengthIs )
-import Char ( ord )
+import Data.Char
---------------------------------------------------------------
import PprCmm ( {- instance Outputable -} )
import Id
import VarEnv
-import Monad
+import Control.Monad
import Name
import StgSyn
import Outputable
import CmmUtils
import FastString
import HscTypes
-import Char
+import Data.Char
import StaticFlags
import BasicTypes
import DynFlags
import FastString
-import IO
import Data.Char
+import System.IO
emitExternalCore :: DynFlags -> CgGuts -> IO ()
emitExternalCore dflags cg_guts
import ExternalCore
import Pretty
-import Char
+import Data.Char
instance Show Module where
showsPrec _ m = shows (pmodule m)
import Module
import Outputable
import DynFlags
-import Monad
+import Control.Monad
import SrcLoc
import ErrUtils
import Name
import TysWiredIn
import Literal
import SrcLoc
-import Ratio
+import Data.Ratio
import Outputable
import Util
import FastString
array >= 0.1 && < 0.3
Build-Depends: filepath >= 1 && < 1.2
- Build-Depends: haskell98, Cabal, hpc
+ Build-Depends: Cabal, hpc
if os(windows)
Build-Depends: Win32
else
import TysWiredIn
import BasicTypes as Hs
import ForeignCall
-import List
+import Data.List
import Unique
import MonadUtils
import ErrUtils
import Module
import Maybes ( firstJust )
-import Directory ( doesFileExist )
-import Monad ( when )
-import IO
+import Control.Exception
+import Control.Monad
+import System.Directory
import System.FilePath
+import System.IO
\end{code}
%************************************************************************
import HsSyn
import Outputable
import SrcLoc
-import Char
import Bag
import Util
import RdrName
+
+import Data.Char
\end{code}
%************************************************************************
import qualified System.Posix.Internals
#else /* Must be Win32 */
import Foreign
-import CString ( CString, peekCString )
+import Foreign.C.String
#endif
import System.Process ( runInteractiveProcess, getProcessExitCode )
import UniqFM
import Unique ( Unique, getUnique )
import UniqSupply
-import List ( groupBy, sortBy )
import DynFlags
#if powerpc_TARGET_ARCH
import StaticFlags ( opt_Static, opt_PIC )
import SrcLoc
import DynFlags
-import Char
+import Data.Char
import Numeric
import System.IO.Unsafe
}
import ParserCoreUtils
import Panic
-import Char
+import Data.Char
import Numeric
isNameChar :: Char -> Bool
import Bag
import ErrUtils
-import Maybe
import Outputable
import StringBuffer
import FastString
import Data.Bits
import Data.Char
import Data.List
+import Data.Maybe
import Data.Map (Map)
import qualified Data.Map as Map
import Data.Ratio
import TyCon ( TyCon, tyConName )
import FastString
import Outputable
-import Char
+import Data.Char
import Unique
#include "../HsVersions.h"
module ParserCoreUtils where
-import IO
+import System.IO
data ParseResult a = OkP a | FailP String
type P a = String -> Int -> ParseResult a
) where
import FastString
-import Char ( isAlphaNum )
import Binary
import Outputable
+
+import Data.Char
\end{code}
import TyCon ( tyConName )
import Util ( isIn )
-import Array ( Array, array, (!) )
+import Data.Array
\end{code}
%************************************************************************
import FastString
import Outputable
-import Char ( ord, chr )
+import Data.Char
\end{code}
%************************************************************************
import TypeRep ( mkArrowKinds, liftedTypeKind, ubxTupleKind )
import Unique ( incrUnique, mkTupleTyConUnique,
mkTupleDataConUnique, mkPArrDataConUnique )
-import Array
+import Data.Array
import FastString
import Outputable
import FastString
import Data.List ( partition )
import Maybes ( orElse )
-import Monad ( foldM, unless )
+import Control.Monad
\end{code}
-- ToDo: Put the annotations into the monad, so that they arrive in the proper
import Util
import Maybes
import ListSetOps ( removeDups )
-import List ( nubBy )
import DynFlags
import FastString
import Control.Monad
+import Data.List
import qualified Data.Set as Set
\end{code}
import RdrName
import LoadIface ( loadInterfaceForName )
import UniqSet
-import List ( nub )
+import Data.List
import Util ( isSingleton )
import ListSetOps ( removeDups )
import Maybes ( expectJust )
import Outputable
import SrcLoc
import FastString
-
-import List ( unzip4 )
\end{code}
import ListSetOps
import Data.List ( partition, (\\), delete )
import qualified Data.Set as Set
-import IO ( openFile, IOMode(..) )
-import Monad ( when, mplus )
+import System.IO
+import Control.Monad
\end{code}
import FastString
import SrcLoc
import DynFlags ( DynFlag(..) )
-import Maybe ( isNothing )
import BasicTypes ( Boxity(..) )
import ListSetOps (findDupsEq)
import Control.Monad
+import Data.Maybe
\end{code}
\begin{code}
import SetLevels ( Level(..), LevelledExpr, LevelledBind,
setLevels, ltMajLvl, ltLvl, isTopLvl )
import UniqSupply ( UniqSupply )
-import List ( partition )
+import Data.List
import Outputable
import FastString
\end{code}
import Util
import UniqSupply ( UniqSupply, mkSplitUniqSupply, splitUniqSupply )
-import IO ( hPutStr, stderr )
import Outputable
import Control.Monad
-import List ( partition, intersperse )
+import Data.List
+import System.IO
import Maybes
\end{code}
import Outputable
import FastString
-import List( nub )
+import Data.List
\end{code}
import BasicTypes ( Activation(..) )
import Maybes ( orElse, catMaybes, isJust, isNothing )
import Util
-import List ( nubBy, partition )
import UniqSupply
import Outputable
import FastString
import UniqFM
import MonadUtils
import Control.Monad ( zipWithM )
+import Data.List
\end{code}
-----------------------------------------------------
import FastString
import Maybes
-import Monad
+import Control.Monad
\end{code}
import ListSetOps
import SrcLoc
import Maybes
-import List
import BasicTypes
import Bag
import FastString
import Control.Monad
+import Data.List
\end{code}
import PrelNames
import DynFlags
import SrcLoc
-import Maybe
+import Data.Maybe
import Outputable
import FastString
\end{code}
import Util
import Outputable
import FastString
-import Monad
+import Control.Monad
\end{code}
tcRnExtCore
) where
-import IO
+import System.IO
#ifdef GHCI
import {-# SOURCE #-} TcSplice ( tcSpliceDecls )
#endif
import SrcLoc
import Outputable
import Unique
-import Maybe
+import Data.Maybe
import BasicTypes
import Panic
import FastString
import Name
import Outputable
import Maybes
-import Monad
import Unify
import Util
import SrcLoc
import BasicTypes
import Bag
+import Control.Monad
import Data.List
\end{code}
import SrcLoc
import Outputable
import Util ( isSingleton )
-import List ( partition )
+import Data.List
\end{code}
import FastTypes
import qualified Pretty
import Pretty ( Doc, Mode(..) )
-import Char ( isAlpha )
import Panic
+import Data.Char
import Data.Word ( Word32 )
import System.IO ( Handle, stderr, stdout, hFlush )
-import Data.Char ( ord )
import System.FilePath
\end{code}