-
+%
+% (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
+%
@Uniques@ are used to distinguish entities in the compiler (@Ids@,
@Classes@, etc.) from each other. Thus, @Uniques@ are the basic
\begin{code}
module Unique (
- Unique, Uniquable(..),
- u2i, -- hack: used in UniqFM
+ Unique, Uniquable(..), hasKey,
- pprUnique, pprUnique10, showUnique,
+ pprUnique,
mkUnique, -- Used in UniqSupply
mkUniqueGrimily, -- Used in UniqSupply only!
+ getKey, getKey#, -- Used in Var, UniqFM, Name only!
incrUnique, -- Used for renumbering
- initTyVarUnique, mkTyVarUnique,
- initTidyUniques,
+ deriveUnique, -- Ditto
+ newTagUnique, -- Used in CgCase
+ initTyVarUnique,
+
+ isTupleKey,
-- now all the built-in Uniques (and functions to make them)
-- [the Oh-So-Wonderful Haskell module system wins again...]
mkAlphaTyVarUnique,
mkPrimOpIdUnique,
- mkTupleDataConUnique,
- mkTupleTyConUnique,
-
- getBuiltinUniques, mkBuiltinUnique,
- mkPseudoUnique1, mkPseudoUnique2, mkPseudoUnique3,
-
- absentErrorIdKey, -- alphabetical...
- addrDataConKey,
- addrPrimTyConKey,
- addrTyConKey,
- andandIdKey,
- appendIdKey,
- arrayPrimTyConKey,
- assertIdKey,
- augmentIdKey,
- boolTyConKey,
- boundedClassKey,
- buildDataConKey,
- buildIdKey,
- byteArrayPrimTyConKey,
- cCallableClassKey,
- cReturnableClassKey,
- charDataConKey,
- charPrimTyConKey,
- charTyConKey,
- coerceIdKey,
- composeIdKey,
- consDataConKey,
- doubleDataConKey,
- doublePrimTyConKey,
- doubleTyConKey,
- enumClassKey,
- enumFromClassOpKey,
- enumFromThenClassOpKey,
- enumFromThenToClassOpKey,
- enumFromToClassOpKey,
- eqClassKey,
- eqClassOpKey,
- eqDataConKey,
- errorIdKey,
- evalClassKey,
- falseDataConKey,
- floatDataConKey,
- floatPrimTyConKey,
- floatTyConKey,
- floatingClassKey,
- foldlIdKey,
- foldrIdKey,
- foreignObjDataConKey,
- foreignObjPrimTyConKey,
- foreignObjTyConKey,
- forkIdKey,
- fractionalClassKey,
- fromEnumClassOpKey,
- fromIntClassOpKey,
- fromIntegerClassOpKey,
- fromRationalClassOpKey,
- funTyConKey,
- functorClassKey,
- geClassOpKey,
- gtDataConKey,
- inlineIdKey,
- intDataConKey,
- intPrimTyConKey,
- intTyConKey,
- int8TyConKey,
- int8DataConKey,
- int16TyConKey,
- int16DataConKey,
- int32TyConKey,
- int32DataConKey,
- int64DataConKey,
- int64PrimTyConKey,
- int64TyConKey,
- integerDataConKey,
- integerMinusOneIdKey,
- integerPlusOneIdKey,
- integerPlusTwoIdKey,
- integerTyConKey,
- integerZeroIdKey,
- integralClassKey,
- irrefutPatErrorIdKey,
- ixClassKey,
- lexIdKey,
- liftDataConKey,
- liftTyConKey,
- listTyConKey,
- ltDataConKey,
- mainKey,
- minusClassOpKey,
- monadClassKey,
- monadPlusClassKey,
- monadZeroClassKey,
- mutableArrayPrimTyConKey,
- mutableByteArrayPrimTyConKey,
- nilDataConKey,
- noMethodBindingErrorIdKey,
- nonExhaustiveGuardsErrorIdKey,
- notIdKey,
- numClassKey,
- ordClassKey,
- orderingTyConKey,
- otherwiseIdKey,
- packCStringIdKey,
- parErrorIdKey,
- parIdKey,
- patErrorIdKey,
- ratioDataConKey,
- ratioTyConKey,
- rationalTyConKey,
- readClassKey,
- readParenIdKey,
- realClassKey,
- realFloatClassKey,
- realFracClassKey,
- realWorldPrimIdKey,
- realWorldTyConKey,
- recConErrorIdKey,
- recSelErrIdKey,
- recUpdErrorIdKey,
- return2GMPsDataConKey,
- return2GMPsTyConKey,
- returnIntAndGMPDataConKey,
- returnIntAndGMPTyConKey,
- returnMClassOpKey,
- seqIdKey,
- showClassKey,
- showParenIdKey,
- showSpaceIdKey,
- showStringIdKey,
- stTyConKey,
- stDataConKey,
- ioTyConKey,
- ioDataConKey,
- ioResultTyConKey,
- ioOkDataConKey,
- ioFailDataConKey,
- stablePtrDataConKey,
- stablePtrPrimTyConKey,
- stablePtrTyConKey,
- stateAndAddrPrimDataConKey,
- stateAndAddrPrimTyConKey,
- stateAndArrayPrimDataConKey,
- stateAndArrayPrimTyConKey,
- stateAndByteArrayPrimDataConKey,
- stateAndByteArrayPrimTyConKey,
- stateAndCharPrimDataConKey,
- stateAndCharPrimTyConKey,
- stateAndDoublePrimDataConKey,
- stateAndDoublePrimTyConKey,
- stateAndFloatPrimDataConKey,
- stateAndFloatPrimTyConKey,
- stateAndForeignObjPrimDataConKey,
- stateAndForeignObjPrimTyConKey,
- stateAndIntPrimDataConKey,
- stateAndIntPrimTyConKey,
- stateAndInt64PrimDataConKey,
- stateAndInt64PrimTyConKey,
- stateAndMutableArrayPrimDataConKey,
- stateAndMutableArrayPrimTyConKey,
- stateAndMutableByteArrayPrimDataConKey,
- stateAndMutableByteArrayPrimTyConKey,
- stateAndPtrPrimDataConKey,
- stateAndPtrPrimTyConKey,
- stateAndStablePtrPrimDataConKey,
- stateAndStablePtrPrimTyConKey,
- stateAndSynchVarPrimDataConKey,
- stateAndSynchVarPrimTyConKey,
- stateAndWordPrimDataConKey,
- stateAndWordPrimTyConKey,
- stateAndWord64PrimDataConKey,
- stateAndWord64PrimTyConKey,
- stateDataConKey,
- stRetDataConKey,
- statePrimTyConKey,
- stateTyConKey,
- stRetTyConKey,
- synchVarPrimTyConKey,
- thenMClassOpKey,
- toEnumClassOpKey,
- traceIdKey,
- trueDataConKey,
- unpackCString2IdKey,
- unpackCStringAppendIdKey,
- unpackCStringFoldrIdKey,
- unpackCStringIdKey,
- ureadListIdKey,
- unsafeCoerceIdKey,
- ushowListIdKey,
- voidIdKey,
- voidTyConKey,
- wordDataConKey,
- wordPrimTyConKey,
- wordTyConKey,
- word8TyConKey,
- word8DataConKey,
- word16TyConKey,
- word16DataConKey,
- word32TyConKey,
- word32DataConKey,
- word64DataConKey,
- word64PrimTyConKey,
- word64TyConKey,
- zeroClassOpKey
- , copyableIdKey
- , noFollowIdKey
- , parAtAbsIdKey
- , parAtForNowIdKey
- , parAtIdKey
- , parAtRelIdKey
- , parGlobalIdKey
- , parLocalIdKey
- , unboundKey
- , byteArrayTyConKey
- , mutableByteArrayTyConKey
- , allClassKey
+ mkTupleTyConUnique, mkTupleDataConUnique,
+ mkPreludeMiscIdUnique, mkPreludeDataConUnique,
+ mkPreludeTyConUnique, mkPreludeClassUnique,
+ mkPArrDataConUnique,
+
+ mkBuiltinUnique,
+ mkPseudoUniqueC,
+ mkPseudoUniqueD,
+ mkPseudoUniqueE,
+ mkPseudoUniqueH
) where
#include "HsVersions.h"
-import FastString ( uniqueOfFS )
-import GlaExts
-import ST
-import PrelBase ( Char(..), chr, ord )
-
+import BasicTypes ( Boxity(..) )
+import PackageConfig ( PackageId, packageIdFS )
+import FastString ( FastString, uniqueOfFS )
import Outputable
-import Util
+import FastTypes
+
+import GLAEXTS
+
+import Char ( chr, ord )
\end{code}
%************************************************************************
data Unique = MkUnique Int#
\end{code}
-\begin{code}
-u2i :: Unique -> FAST_INT
-u2i (MkUnique i) = i
-\end{code}
-
Now come the functions which construct uniques from their pieces, and vice versa.
The stuff about unique *supplies* is handled further down this module.
mkUnique :: Char -> Int -> Unique -- Builds a unique from pieces
unpkUnique :: Unique -> (Char, Int) -- The reverse
-mkUniqueGrimily :: Int# -> Unique -- A trap-door for UniqSupply
+mkUniqueGrimily :: Int -> Unique -- A trap-door for UniqSupply
+getKey :: Unique -> Int -- for Var
+getKey# :: Unique -> Int# -- for Var
incrUnique :: Unique -> Unique
+deriveUnique :: Unique -> Int -> Unique
+newTagUnique :: Unique -> Char -> Unique
+
+isTupleKey :: Unique -> Bool
\end{code}
\begin{code}
-mkUniqueGrimily x = MkUnique x
+mkUniqueGrimily (I# x) = MkUnique x
+
+{-# INLINE getKey #-}
+getKey (MkUnique x) = I# x
+{-# INLINE getKey# #-}
+getKey# (MkUnique x) = x
incrUnique (MkUnique i) = MkUnique (i +# 1#)
+-- deriveUnique uses an 'X' tag so that it won't clash with
+-- any of the uniques produced any other way
+deriveUnique (MkUnique i) delta = mkUnique 'X' (I# i + delta)
+
+-- newTagUnique changes the "domain" of a unique to a different char
+newTagUnique u c = mkUnique c i where (_,i) = unpkUnique u
+
-- pop the Char in the top 8 bits of the Unique(Supply)
-- No 64-bit bugs here, as long as we have at least 32 bits. --JSM
i2w_s x = (x::Int#)
mkUnique (C# c) (I# i)
- = MkUnique (w2i (((i2w (ord# c)) `shiftL#` (i2w_s 24#)) `or#` (i2w i)))
+ = MkUnique (w2i (tag `or#` bits))
+ where
+#if __GLASGOW_HASKELL__ >= 503
+ tag = i2w (ord# c) `uncheckedShiftL#` i2w_s 24#
+#else
+ tag = i2w (ord# c) `shiftL#` i2w_s 24#
+#endif
+ bits = i2w i `and#` (i2w 16777215#){-``0x00ffffff''-}
unpkUnique (MkUnique u)
= let
tag = C# (chr# (w2i ((i2w u) `shiftr` (i2w_s 24#))))
- i = I# (w2i ((i2w u) `and#` (i2w 16777215#){-``0x00ffffff''-}))
+ i = I# (w2i ((i2w u) `and#` (i2w 16777215#){-``0x00ffffff''-}))
in
(tag, i)
where
- shiftr x y = shiftRA# x y
+#if __GLASGOW_HASKELL__ >= 503
+ shiftr x y = uncheckedShiftRL# x y
+#else
+ shiftr x y = shiftRL# x y
+#endif
\end{code}
\begin{code}
class Uniquable a where
- uniqueOf :: a -> Unique
+ getUnique :: a -> Unique
+
+hasKey :: Uniquable a => a -> Unique -> Bool
+x `hasKey` k = getUnique x == k
instance Uniquable FastString where
- uniqueOf fs = mkUniqueGrimily (uniqueOfFS fs)
+ getUnique fs = mkUniqueGrimily (I# (uniqueOfFS fs))
+
+instance Uniquable PackageId where
+ getUnique pid = getUnique (packageIdFS pid)
instance Uniquable Int where
- uniqueOf (I# i#) = mkUniqueGrimily i#
+ getUnique i = mkUniqueGrimily i
\end{code}
-----------------
instance Uniquable Unique where
- uniqueOf u = u
+ getUnique u = u
\end{code}
We do sometimes make strings with @Uniques@ in them:
\begin{code}
-pprUnique, pprUnique10 :: Unique -> SDoc
-
+pprUnique :: Unique -> SDoc
pprUnique uniq
= case unpkUnique uniq of
- (tag, u) -> finish_ppr tag u (iToBase62 u)
+ (tag, u) -> finish_ppr tag u (text (iToBase62 u))
+#ifdef UNUSED
+pprUnique10 :: Unique -> SDoc
pprUnique10 uniq -- in base-10, dudes
= case unpkUnique uniq of
(tag, u) -> finish_ppr tag u (int u)
+#endif
finish_ppr 't' u pp_u | u < 26
= -- Special case to make v common tyvars, t1, t2, ...
char (chr (ord 'a' + u))
finish_ppr tag u pp_u = char tag <> pp_u
-showUnique :: Unique -> String
-showUnique uniq = showSDoc (pprUnique uniq)
-
instance Outputable Unique where
ppr u = pprUnique u
-instance Text Unique where
- showsPrec p uniq rest = showUnique uniq
+instance Show Unique where
+ showsPrec p uniq = showsPrecSDoc p (pprUnique uniq)
\end{code}
%************************************************************************
A character-stingy way to read/write numbers (notably Uniques).
The ``62-its'' are \tr{[0-9a-zA-Z]}. We don't handle negative Ints.
Code stolen from Lennart.
+
\begin{code}
-# define BYTE_ARRAY GlaExts.ByteArray
-# define RUN_ST ST.runST
-# define AND_THEN >>=
-# define AND_THEN_ >>
-# define RETURN return
-
-iToBase62 :: Int -> SDoc
-
-iToBase62 n@(I# n#)
- = ASSERT(n >= 0)
- let
- bytes = case chars62 of { BYTE_ARRAY bounds_who_needs_'em bytes -> bytes }
- in
- if n# <# 62# then
- case (indexCharArray# bytes n#) of { c ->
- char (C# c) }
- else
- case (quotRem n 62) of { (q, I# r#) ->
- case (indexCharArray# bytes r#) of { c ->
- (<>) (iToBase62 q) (char (C# c)) }}
-
--- keep this at top level! (bug on 94/10/24 WDP)
-chars62 :: BYTE_ARRAY Int
-chars62
- = RUN_ST (
- newCharArray (0, 61) AND_THEN \ ch_array ->
- fill_in ch_array 0 62 "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
- AND_THEN_
- unsafeFreezeByteArray ch_array
- )
+iToBase62 :: Int -> String
+iToBase62 n@(I# n#)
+ = ASSERT(n >= 0) go n# ""
where
- fill_in ch_array i lim str
- | i == lim
- = RETURN ()
- | otherwise
- = writeCharArray ch_array i (str !! i) AND_THEN_
- fill_in ch_array (i+1) lim str
+ go n# cs | n# <# 62#
+ = case (indexCharOffAddr# chars62# n#) of { c# -> C# c# : cs }
+ | otherwise
+ = case (quotRem (I# n#) 62) of { (I# q#, I# r#) ->
+ case (indexCharOffAddr# chars62# r#) of { c# ->
+ go q# (C# c# : cs) }}
+
+ chars62# = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"#
\end{code}
%************************************************************************
Allocation of unique supply characters:
v,t,u : for renumbering value-, type- and usage- vars.
- other a-z: lower case chars for unique supplies (see Main.lhs)
B: builtin
C-E: pseudo uniques (used in native-code generator)
+ X: uniques derived by deriveUnique
_: unifiable tyvars (above)
- 1-8: prelude things below
+ 0-9: prelude things below
-\begin{code}
-mkAlphaTyVarUnique i = mkUnique '1' i
+ other a-z: lower case chars for unique supplies. Used so far:
-mkPreludeClassUnique i = mkUnique '2' i
-mkPreludeTyConUnique i = mkUnique '3' i
-mkTupleTyConUnique a = mkUnique '4' a
+ d desugarer
+ f AbsC flattener
+ g SimplStg
+ l ndpFlatten
+ n Native codegen
+ r Hsc name cache
+ s simplifier
-mkPreludeDataConUnique i = mkUnique '5' i -- must be alphabetic
-mkTupleDataConUnique a = mkUnique '6' a -- ditto (*may* be used in C labels)
+\begin{code}
+mkAlphaTyVarUnique i = mkUnique '1' i
-mkPrimOpIdUnique op = mkUnique '7' op
-mkPreludeMiscIdUnique i = mkUnique '8' i
+mkPreludeClassUnique i = mkUnique '2' i
--- The "tyvar uniques" print specially nicely: a, b, c, etc.
--- See pprUnique for details
+-- Prelude type constructors occupy *three* slots.
+-- The first is for the tycon itself; the latter two
+-- are for the generic to/from Ids. See TysWiredIn.mk_tc_gen_info.
-initTyVarUnique :: Unique
-initTyVarUnique = mkUnique 't' 0
+mkPreludeTyConUnique i = mkUnique '3' (3*i)
+mkTupleTyConUnique Boxed a = mkUnique '4' (3*a)
+mkTupleTyConUnique Unboxed a = mkUnique '5' (3*a)
-mkTyVarUnique :: Int -> Unique
-mkTyVarUnique n = mkUnique 't' n
+-- Data constructor keys occupy *two* slots. The first is used for the
+-- data constructor itself and its wrapper function (the function that
+-- evaluates arguments as necessary and calls the worker). The second is
+-- used for the worker function (the function that builds the constructor
+-- representation).
-initTidyUniques :: (Unique, Unique) -- Global and local
-initTidyUniques = (mkUnique 'g' 0, mkUnique 'x' 0)
+mkPreludeDataConUnique i = mkUnique '6' (2*i) -- Must be alphabetic
+mkTupleDataConUnique Boxed a = mkUnique '7' (2*a) -- ditto (*may* be used in C labels)
+mkTupleDataConUnique Unboxed a = mkUnique '8' (2*a)
-mkPseudoUnique1, mkPseudoUnique2, mkPseudoUnique3,
- mkBuiltinUnique :: Int -> Unique
+-- This one is used for a tiresome reason
+-- to improve a consistency-checking error check in the renamer
+isTupleKey u = case unpkUnique u of
+ (tag,_) -> tag == '4' || tag == '5' || tag == '7' || tag == '8'
-mkBuiltinUnique i = mkUnique 'B' i
-mkPseudoUnique1 i = mkUnique 'C' i -- used for uniqueOf on Regs
-mkPseudoUnique2 i = mkUnique 'D' i -- ditto
-mkPseudoUnique3 i = mkUnique 'E' i -- ditto
+mkPrimOpIdUnique op = mkUnique '9' op
+mkPreludeMiscIdUnique i = mkUnique '0' i
-getBuiltinUniques :: Int -> [Unique]
-getBuiltinUniques n = map (mkUnique 'B') [1 .. n]
-\end{code}
+-- No numbers left anymore, so I pick something different for the character
+-- tag
+mkPArrDataConUnique a = mkUnique ':' (2*a)
-%************************************************************************
-%* *
-\subsubsection[Uniques-prelude-Classes]{@Uniques@ for wired-in @Classes@}
-%* *
-%************************************************************************
-
-\begin{code}
-boundedClassKey = mkPreludeClassUnique 1
-enumClassKey = mkPreludeClassUnique 2
-eqClassKey = mkPreludeClassUnique 3
-evalClassKey = mkPreludeClassUnique 4
-floatingClassKey = mkPreludeClassUnique 5
-fractionalClassKey = mkPreludeClassUnique 6
-integralClassKey = mkPreludeClassUnique 7
-monadClassKey = mkPreludeClassUnique 8
-monadZeroClassKey = mkPreludeClassUnique 9
-monadPlusClassKey = mkPreludeClassUnique 10
-functorClassKey = mkPreludeClassUnique 11
-numClassKey = mkPreludeClassUnique 12
-ordClassKey = mkPreludeClassUnique 13
-readClassKey = mkPreludeClassUnique 14
-realClassKey = mkPreludeClassUnique 15
-realFloatClassKey = mkPreludeClassUnique 16
-realFracClassKey = mkPreludeClassUnique 17
-showClassKey = mkPreludeClassUnique 18
-
-cCallableClassKey = mkPreludeClassUnique 19
-cReturnableClassKey = mkPreludeClassUnique 20
-
-ixClassKey = mkPreludeClassUnique 21
-allClassKey = mkPreludeClassUnique 22 -- Pseudo class used for universal quantification
-\end{code}
-
-%************************************************************************
-%* *
-\subsubsection[Uniques-prelude-TyCons]{@Uniques@ for wired-in @TyCons@}
-%* *
-%************************************************************************
-
-\begin{code}
-addrPrimTyConKey = mkPreludeTyConUnique 1
-addrTyConKey = mkPreludeTyConUnique 2
-arrayPrimTyConKey = mkPreludeTyConUnique 3
-boolTyConKey = mkPreludeTyConUnique 4
-byteArrayPrimTyConKey = mkPreludeTyConUnique 5
-charPrimTyConKey = mkPreludeTyConUnique 7
-charTyConKey = mkPreludeTyConUnique 8
-doublePrimTyConKey = mkPreludeTyConUnique 9
-doubleTyConKey = mkPreludeTyConUnique 10
-floatPrimTyConKey = mkPreludeTyConUnique 11
-floatTyConKey = mkPreludeTyConUnique 12
-funTyConKey = mkPreludeTyConUnique 13
-intPrimTyConKey = mkPreludeTyConUnique 14
-intTyConKey = mkPreludeTyConUnique 15
-int8TyConKey = mkPreludeTyConUnique 16
-int16TyConKey = mkPreludeTyConUnique 17
-int32TyConKey = mkPreludeTyConUnique 18
-int64PrimTyConKey = mkPreludeTyConUnique 19
-int64TyConKey = mkPreludeTyConUnique 20
-integerTyConKey = mkPreludeTyConUnique 21
-liftTyConKey = mkPreludeTyConUnique 22
-listTyConKey = mkPreludeTyConUnique 23
-foreignObjPrimTyConKey = mkPreludeTyConUnique 24
-foreignObjTyConKey = mkPreludeTyConUnique 25
-mutableArrayPrimTyConKey = mkPreludeTyConUnique 26
-mutableByteArrayPrimTyConKey = mkPreludeTyConUnique 27
-orderingTyConKey = mkPreludeTyConUnique 28
-synchVarPrimTyConKey = mkPreludeTyConUnique 29
-ratioTyConKey = mkPreludeTyConUnique 30
-rationalTyConKey = mkPreludeTyConUnique 31
-realWorldTyConKey = mkPreludeTyConUnique 32
-return2GMPsTyConKey = mkPreludeTyConUnique 33
-returnIntAndGMPTyConKey = mkPreludeTyConUnique 34
-stablePtrPrimTyConKey = mkPreludeTyConUnique 35
-stablePtrTyConKey = mkPreludeTyConUnique 36
-stateAndAddrPrimTyConKey = mkPreludeTyConUnique 37
-stateAndArrayPrimTyConKey = mkPreludeTyConUnique 38
-stateAndByteArrayPrimTyConKey = mkPreludeTyConUnique 39
-stateAndCharPrimTyConKey = mkPreludeTyConUnique 40
-stateAndDoublePrimTyConKey = mkPreludeTyConUnique 41
-stateAndFloatPrimTyConKey = mkPreludeTyConUnique 42
-stateAndIntPrimTyConKey = mkPreludeTyConUnique 43
-stateAndInt64PrimTyConKey = mkPreludeTyConUnique 44
-stateAndForeignObjPrimTyConKey = mkPreludeTyConUnique 45
-stateAndMutableArrayPrimTyConKey = mkPreludeTyConUnique 46
-stateAndMutableByteArrayPrimTyConKey = mkPreludeTyConUnique 47
-stateAndSynchVarPrimTyConKey = mkPreludeTyConUnique 48
-stateAndPtrPrimTyConKey = mkPreludeTyConUnique 49
-stateAndStablePtrPrimTyConKey = mkPreludeTyConUnique 50
-stateAndWordPrimTyConKey = mkPreludeTyConUnique 51
-stateAndWord64PrimTyConKey = mkPreludeTyConUnique 52
-statePrimTyConKey = mkPreludeTyConUnique 53
-stateTyConKey = mkPreludeTyConUnique 54
-mutableByteArrayTyConKey = mkPreludeTyConUnique 55
-stTyConKey = mkPreludeTyConUnique 56
-stRetTyConKey = mkPreludeTyConUnique 57
-ioTyConKey = mkPreludeTyConUnique 58
-ioResultTyConKey = mkPreludeTyConUnique 59
-byteArrayTyConKey = mkPreludeTyConUnique 60
-wordPrimTyConKey = mkPreludeTyConUnique 61
-wordTyConKey = mkPreludeTyConUnique 62
-word8TyConKey = mkPreludeTyConUnique 63
-word16TyConKey = mkPreludeTyConUnique 64
-word32TyConKey = mkPreludeTyConUnique 65
-word64PrimTyConKey = mkPreludeTyConUnique 66
-word64TyConKey = mkPreludeTyConUnique 67
-voidTyConKey = mkPreludeTyConUnique 68
-\end{code}
-
-%************************************************************************
-%* *
-\subsubsection[Uniques-prelude-DataCons]{@Uniques@ for wired-in @DataCons@}
-%* *
-%************************************************************************
-
-\begin{code}
-addrDataConKey = mkPreludeDataConUnique 1
-buildDataConKey = mkPreludeDataConUnique 2
-charDataConKey = mkPreludeDataConUnique 4
-consDataConKey = mkPreludeDataConUnique 5
-doubleDataConKey = mkPreludeDataConUnique 6
-eqDataConKey = mkPreludeDataConUnique 7
-falseDataConKey = mkPreludeDataConUnique 8
-floatDataConKey = mkPreludeDataConUnique 9
-gtDataConKey = mkPreludeDataConUnique 10
-intDataConKey = mkPreludeDataConUnique 11
-int8DataConKey = mkPreludeDataConUnique 12
-int16DataConKey = mkPreludeDataConUnique 13
-int32DataConKey = mkPreludeDataConUnique 14
-int64DataConKey = mkPreludeDataConUnique 15
-integerDataConKey = mkPreludeDataConUnique 16
-liftDataConKey = mkPreludeDataConUnique 17
-ltDataConKey = mkPreludeDataConUnique 18
-foreignObjDataConKey = mkPreludeDataConUnique 19
-nilDataConKey = mkPreludeDataConUnique 20
-ratioDataConKey = mkPreludeDataConUnique 21
-return2GMPsDataConKey = mkPreludeDataConUnique 22
-returnIntAndGMPDataConKey = mkPreludeDataConUnique 23
-stablePtrDataConKey = mkPreludeDataConUnique 24
-stateAndAddrPrimDataConKey = mkPreludeDataConUnique 25
-stateAndArrayPrimDataConKey = mkPreludeDataConUnique 26
-stateAndByteArrayPrimDataConKey = mkPreludeDataConUnique 27
-stateAndCharPrimDataConKey = mkPreludeDataConUnique 28
-stateAndDoublePrimDataConKey = mkPreludeDataConUnique 29
-stateAndFloatPrimDataConKey = mkPreludeDataConUnique 30
-stateAndIntPrimDataConKey = mkPreludeDataConUnique 31
-stateAndInt64PrimDataConKey = mkPreludeDataConUnique 32
-stateAndForeignObjPrimDataConKey = mkPreludeDataConUnique 33
-stateAndMutableArrayPrimDataConKey = mkPreludeDataConUnique 34
-stateAndMutableByteArrayPrimDataConKey = mkPreludeDataConUnique 35
-stateAndSynchVarPrimDataConKey = mkPreludeDataConUnique 36
-stateAndPtrPrimDataConKey = mkPreludeDataConUnique 37
-stateAndStablePtrPrimDataConKey = mkPreludeDataConUnique 38
-stateAndWordPrimDataConKey = mkPreludeDataConUnique 39
-stateAndWord64PrimDataConKey = mkPreludeDataConUnique 40
-stateDataConKey = mkPreludeDataConUnique 41
-trueDataConKey = mkPreludeDataConUnique 42
-wordDataConKey = mkPreludeDataConUnique 43
-word8DataConKey = mkPreludeDataConUnique 44
-word16DataConKey = mkPreludeDataConUnique 45
-word32DataConKey = mkPreludeDataConUnique 46
-word64DataConKey = mkPreludeDataConUnique 47
-stDataConKey = mkPreludeDataConUnique 48
-stRetDataConKey = mkPreludeDataConUnique 49
-ioDataConKey = mkPreludeDataConUnique 50
-ioOkDataConKey = mkPreludeDataConUnique 51
-ioFailDataConKey = mkPreludeDataConUnique 52
-\end{code}
+-- The "tyvar uniques" print specially nicely: a, b, c, etc.
+-- See pprUnique for details
-%************************************************************************
-%* *
-\subsubsection[Uniques-prelude-Ids]{@Uniques@ for wired-in @Ids@ (except @DataCons@)}
-%* *
-%************************************************************************
+initTyVarUnique :: Unique
+initTyVarUnique = mkUnique 't' 0
-\begin{code}
-absentErrorIdKey = mkPreludeMiscIdUnique 1
-andandIdKey = mkPreludeMiscIdUnique 2
-appendIdKey = mkPreludeMiscIdUnique 3
-augmentIdKey = mkPreludeMiscIdUnique 4
-buildIdKey = mkPreludeMiscIdUnique 5
-composeIdKey = mkPreludeMiscIdUnique 6
-errorIdKey = mkPreludeMiscIdUnique 7
-foldlIdKey = mkPreludeMiscIdUnique 8
-foldrIdKey = mkPreludeMiscIdUnique 9
-forkIdKey = mkPreludeMiscIdUnique 10
-recSelErrIdKey = mkPreludeMiscIdUnique 11
-integerMinusOneIdKey = mkPreludeMiscIdUnique 12
-integerPlusOneIdKey = mkPreludeMiscIdUnique 13
-integerPlusTwoIdKey = mkPreludeMiscIdUnique 14
-integerZeroIdKey = mkPreludeMiscIdUnique 15
-irrefutPatErrorIdKey = mkPreludeMiscIdUnique 16
-lexIdKey = mkPreludeMiscIdUnique 17
-noMethodBindingErrorIdKey = mkPreludeMiscIdUnique 20
-nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 21
-notIdKey = mkPreludeMiscIdUnique 22
-packCStringIdKey = mkPreludeMiscIdUnique 23
-parErrorIdKey = mkPreludeMiscIdUnique 24
-parIdKey = mkPreludeMiscIdUnique 25
-patErrorIdKey = mkPreludeMiscIdUnique 26
-readParenIdKey = mkPreludeMiscIdUnique 27
-realWorldPrimIdKey = mkPreludeMiscIdUnique 28
-recConErrorIdKey = mkPreludeMiscIdUnique 29
-recUpdErrorIdKey = mkPreludeMiscIdUnique 30
-seqIdKey = mkPreludeMiscIdUnique 31
-showParenIdKey = mkPreludeMiscIdUnique 32
-showSpaceIdKey = mkPreludeMiscIdUnique 33
-showStringIdKey = mkPreludeMiscIdUnique 34
-traceIdKey = mkPreludeMiscIdUnique 35
-unpackCString2IdKey = mkPreludeMiscIdUnique 36
-unpackCStringAppendIdKey = mkPreludeMiscIdUnique 37
-unpackCStringFoldrIdKey = mkPreludeMiscIdUnique 38
-unpackCStringIdKey = mkPreludeMiscIdUnique 39
-unsafeCoerceIdKey = mkPreludeMiscIdUnique 40
-voidIdKey = mkPreludeMiscIdUnique 41
-ushowListIdKey = mkPreludeMiscIdUnique 42
-ureadListIdKey = mkPreludeMiscIdUnique 43
-
-copyableIdKey = mkPreludeMiscIdUnique 44
-noFollowIdKey = mkPreludeMiscIdUnique 45
-parAtAbsIdKey = mkPreludeMiscIdUnique 46
-parAtForNowIdKey = mkPreludeMiscIdUnique 47
-parAtIdKey = mkPreludeMiscIdUnique 48
-parAtRelIdKey = mkPreludeMiscIdUnique 49
-parGlobalIdKey = mkPreludeMiscIdUnique 50
-parLocalIdKey = mkPreludeMiscIdUnique 51
-\end{code}
+mkPseudoUniqueC, mkPseudoUniqueD, mkPseudoUniqueE, mkPseudoUniqueH,
+ mkBuiltinUnique :: Int -> Unique
-Certain class operations from Prelude classes. They get
-their own uniques so we can look them up easily when we want
-to conjure them up during type checking.
-\begin{code}
-fromIntClassOpKey = mkPreludeMiscIdUnique 52
-fromIntegerClassOpKey = mkPreludeMiscIdUnique 53
-minusClassOpKey = mkPreludeMiscIdUnique 54
-fromRationalClassOpKey = mkPreludeMiscIdUnique 55
-enumFromClassOpKey = mkPreludeMiscIdUnique 56
-enumFromThenClassOpKey = mkPreludeMiscIdUnique 57
-enumFromToClassOpKey = mkPreludeMiscIdUnique 58
-enumFromThenToClassOpKey= mkPreludeMiscIdUnique 59
-eqClassOpKey = mkPreludeMiscIdUnique 50
-geClassOpKey = mkPreludeMiscIdUnique 61
-zeroClassOpKey = mkPreludeMiscIdUnique 62
-thenMClassOpKey = mkPreludeMiscIdUnique 63 -- (>>=)
-unboundKey = mkPreludeMiscIdUnique 64 -- Just a place holder for unbound
- -- variables produced by the renamer
-fromEnumClassOpKey = mkPreludeMiscIdUnique 65
-
-mainKey = mkPreludeMiscIdUnique 66
-returnMClassOpKey = mkPreludeMiscIdUnique 67
-otherwiseIdKey = mkPreludeMiscIdUnique 68
-toEnumClassOpKey = mkPreludeMiscIdUnique 69
+mkBuiltinUnique i = mkUnique 'B' i
+mkPseudoUniqueC i = mkUnique 'C' i -- used for getUnique on Regs
+mkPseudoUniqueD i = mkUnique 'D' i -- used in NCG for getUnique on RealRegs
+mkPseudoUniqueE i = mkUnique 'E' i -- used in NCG spiller to create spill VirtualRegs
+mkPseudoUniqueH i = mkUnique 'H' i -- used in NCG spiller to create spill VirtualRegs
\end{code}
-\begin{code}
-inlineIdKey = mkPreludeMiscIdUnique 70
-coerceIdKey = mkPreludeMiscIdUnique 71
-assertIdKey = mkPreludeMiscIdUnique 72
-\end{code}
projects / ghc-hetmet.git / blobdiff