SYN_IE(Id)
)
import Maybes ( maybeToBool )
-import PprStyle ( PprStyle(..) )
+import Outputable ( Outputable(..), PprStyle(..) )
import PprType ( showTyCon, GenType{-instance Outputable-} )
import TyCon ( TyCon{-instance Eq-} )
import Unique ( showUnique, pprUnique, Unique{-instance Eq-} )
import Pretty
import Util ( assertPanic{-, pprTraceToDo:rm-}, Ord3(..) )
-#if __GLASGOW_HASKELL__ >= 202
-import Outputable ( Outputable(..) )
-#endif
-
\end{code}
things we want to find out:
import SMRep
import Pretty -- ********** NOTE **********
import Util ( panic )
-import PprStyle ( PprStyle )
+import Outputable ( PprStyle )
\end{code}
%************************************************************************
import HeapOffs ( isZeroOff, subOff, pprHeapOffset )
import Literal ( showLiteral, Literal(..) )
import Maybes ( maybeToBool, catMaybes )
-import PprStyle ( PprStyle(..) )
import Pretty
import PrimOp ( primOpNeedsWrapper, pprPrimOp, PrimOp(..) )
import PrimRep ( isFloatingRep, showPrimRep, PrimRep(..) )
import UniqSet ( emptyUniqSet, elementOfUniqSet,
addOneToUniqSet, SYN_IE(UniqSet)
)
-import Outputable ( printDoc )
+import Outputable ( PprStyle(..), printDoc )
import Util ( nOfThem, panic, assertPanic )
infixr 9 `thenTE`
import HeapOffs ( SYN_IE(VirtualHeapOffset),
SYN_IE(VirtualSpAOffset), SYN_IE(VirtualSpBOffset)
)
-import Id ( idPrimRep, toplevelishId, isDataCon,
+import Id ( idPrimRep, toplevelishId,
mkIdEnv, rngIdEnv, SYN_IE(IdEnv),
idSetToList,
GenId{-instance NamedThing-}, SYN_IE(Id)
#ifdef DEBUG
import PprAbsC ( pprAmode )
#endif
-import PprStyle ( PprStyle(..) )
+import Outputable ( PprStyle(..) )
import Pretty ( Doc )
import PrimRep ( PrimRep )
import StgSyn ( SYN_IE(StgArg), SYN_IE(StgLiveVars), GenStgArg(..) )
)
import Literal ( Literal )
import Maybes ( catMaybes )
-import Outputable ( Outputable(..) )
-import PprStyle ( PprStyle(..) )
+import Outputable ( Outputable(..), PprStyle(..) )
import PprType ( GenType{-instance Outputable-} )
import Pretty ( Doc )
import PrimOp ( primOpCanTriggerGC, PrimOp(..),
)
import ListSetOps ( minusList )
import Maybes ( maybeToBool )
-import Outputable ( Outputable(..){-instances-} ) -- ToDo:rm
-import PprStyle ( PprStyle(..) )
+import Outputable ( Outputable(..){-instances-}, PprStyle(..) )
import PprType ( GenType{-instance Outputable-}, TyCon{-ditto-} )
import Pretty ( Doc, hcat, char, ptext, hsep, text )
import PrimRep ( isFollowableRep, PrimRep(..) )
do_one (WwPrim, _) = 'P'
do_one (WwEnum, _) = 'E'
do_one (WwStrict, arg_ty_char) = arg_ty_char
- do_one (WwUnpack _ _, arg_ty_char)
+ do_one (WwUnpack _ _ _, arg_ty_char)
= if arg_ty_char `elem` "CIJFDTS"
then toLower arg_ty_char
else if arg_ty_char == '+' then 't'
)
import IdInfo ( ArityInfo(..) )
import Name ( isLocallyDefined )
-import PprStyle ( PprStyle(..) )
+import Outputable ( PprStyle(..), Outputable(..) )
import Pretty ( Doc )
import PrimOp ( primOpCanTriggerGC, primOpHeapReq, HeapRequirement(..),
getPrimOpResultInfo, PrimOp(..), PrimOpResultInfo(..)
import TyCon ( tyConDataCons, maybeTyConSingleCon )
import Maybes ( assocMaybe, maybeToBool )
import Util ( panic, isIn, pprPanic, assertPanic )
-#if __GLASGOW_HASKELL__ >= 202
-import Outputable ( Outputable(..) )
-#endif
\end{code}
This module provides the support code for @StgToAbstractC@ to deal
SYN_IE(Id)
)
import Maybes ( maybeToBool )
-import PprStyle ( PprStyle(..) )
+import Outputable ( PprStyle(..), Outputable(..) )
import PprType ( GenType{-instance Outputable-} )
import Pretty ( Doc, vcat, hsep, ptext )
import PrimRep ( getPrimRepSize, PrimRep(..) )
import Type ( typePrimRep )
import UniqSet ( elementOfUniqSet )
import Util ( sortLt, panic, pprPanic )
-#if __GLASGOW_HASKELL__ >= 202
-import Outputable ( Outputable(..) )
-#endif
infixr 9 `thenC` -- Right-associative!
infixr 9 `thenFC`
SYN_IE(Id)
)
import Maybes ( catMaybes )
-import PprStyle ( PprStyle(..) )
+import Outputable ( PprStyle(..), Outputable(..) )
import PprType ( TyCon{-instance Outputable-} )
import PrimOp ( primOpCanTriggerGC,
getPrimOpResultInfo, PrimOpResultInfo(..),
import Type ( typePrimRep )
import Pretty ( Doc )
import Util ( zipWithEqual, mapAccumL, isn'tIn,
- pprError, pprTrace, panic, assertPanic
+ pprError, pprTrace, panic, assertPanic, assertPprPanic
)
-#if __GLASGOW_HASKELL__ >= 202
-import Outputable ( Outputable(..) )
-#endif
\end{code}
%************************************************************************
dataReturnConvAlg :: DataCon -> DataReturnConvention
dataReturnConvAlg data_con
- = ASSERT(isDataCon data_con)
+ = ASSERT2(isDataCon data_con, (ppr PprDebug data_con))
case leftover_kinds of
[] -> ReturnInRegs reg_assignment
other -> ReturnInHeap -- Didn't fit in registers
import IdInfo ( ArityInfo(..) )
import Maybes ( maybeToBool )
import Name ( getOccString )
-import PprStyle ( PprStyle(..) )
+import Outputable ( PprStyle(..), Outputable(..) )
import PprType ( getTyDescription, GenType{-instance Outputable-} )
import Pretty --ToDo:rm
import PrelInfo ( maybeCharLikeTyCon, maybeIntLikeTyCon )
import PrimRep ( getPrimRepSize, separateByPtrFollowness, PrimRep )
import SMRep -- all of it
import TyCon ( TyCon{-instance NamedThing-} )
-import Type ( isPrimType, splitForAllTy, splitFunTyExpandingDictsAndPeeking,
+import Type ( isPrimType, splitFunTyExpandingDictsAndPeeking,
mkFunTys, maybeAppSpecDataTyConExpandingDicts,
SYN_IE(Type)
)
import Util ( isIn, mapAccumL, panic, pprPanic, assertPanic )
-#if __GLASGOW_HASKELL__ >= 202
-import Outputable ( Outputable(..) )
-#endif
\end{code}
The ``wrapper'' data type for closure information:
import CLabel ( isAsmTemp, CLabel )
import Maybes ( maybeToBool, expectJust )
import OrdList -- quite a bit of it
-import PprStyle
+import Outputable ( PprStyle(..) )
import Pretty ( ptext, rational )
import PrimRep ( isFloatingRep, PrimRep(..) )
import PrimOp ( PrimOp(..), showPrimOp )
)
import PrimRep ( PrimRep(..), isFloatingRep )
import OrdList ( OrdList )
-import PprStyle ( PprStyle(..) )
+import Outputable ( PprStyle(..) )
import SMRep ( SMRep(..), SMSpecRepKind, SMUpdateKind )
import Stix
import StixMacro ( heapCheck )
import HsTypes ( HsTyVar(..) )
import HsPragmas ( noDataPragmas, noClassPragmas, noInstancePragmas, noGenPragmas )
import RdrHsSyn
+import BasicTypes ( Fixity(..), FixityDirection(..), NewOrData(..) )
import PrefixToHs
+import CmdLineOpts ( opt_PprUserLength )
import ErrUtils ( addErrLoc, ghcExit )
import FiniteMap ( elemFM, FiniteMap )
import Name ( OccName(..), SYN_IE(Module) )
import Lex ( isLexConId )
-import PprStyle ( PprStyle(..) )
+import Outputable ( Outputable(..), PprStyle(..) )
import PrelMods
import Pretty
import SrcLoc ( mkGeneratedSrcLoc, noSrcLoc, SrcLoc )
import Util ( nOfThem, pprError, panic )
-
-#if __GLASGOW_HASKELL__ >= 202
-import Outputable ( Outputable(..) )
-#endif
-
\end{code}
%************************************************************************
let
err = addErrLoc loc "Illegal pattern `application'"
(\sty -> hsep (map (ppr sty) (lpat:lpats)))
- msg = show (err PprForUser)
+ msg = show (err (PprForUser opt_PprUserLength))
in
#if __GLASGOW_HASKELL__ == 201
ioToUgnM (GHCbase.ioToPrimIO (hPutStr stderr msg)) `thenUgn` \ _ ->
mk_class_assertion (MonoTyApp (MonoTyVar name) ty@(MonoTyVar tyname)) = (name, ty)
mk_class_assertion other
- = pprError "ERROR: malformed type context: " (ppr PprForUser other)
+ = pprError "ERROR: malformed type context: " (ppr (PprForUser opt_PprUserLength) other)
-- regrettably, the parser does let some junk past
-- e.g., f :: Num {-nothing-} => a -> ...
\end{code}