X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2FbasicTypes%2FUnique.lhs;h=0634b513065f7e3c6c8b06f396964df83258337c;hb=1b7a99e3e7f64c6f402e8aece32ba0b9a3703bfa;hp=0d4fb494369d5d7cda959042675d727b71ea76eb;hpb=7a3bd641457666e10d0a47be9f22762e03defbf0;p=ghc-hetmet.git diff --git a/ghc/compiler/basicTypes/Unique.lhs b/ghc/compiler/basicTypes/Unique.lhs index 0d4fb49..0634b51 100644 --- a/ghc/compiler/basicTypes/Unique.lhs +++ b/ghc/compiler/basicTypes/Unique.lhs @@ -1,7 +1,6 @@ % -% (c) The GRASP/AQUA Project, Glasgow University, 1992-1996 +% (c) The GRASP/AQUA Project, Glasgow University, 1992-1998 % -\section[Unique]{The @Unique@ data type} @Uniques@ are used to distinguish entities in the compiler (@Ids@, @Classes@, etc.) from each other. Thus, @Uniques@ are the basic @@ -16,21 +15,22 @@ Some of the other hair in this code is to be able to use a Haskell). \begin{code} -#include "HsVersions.h" - --- UniqSupply - module Unique ( - Unique, + Unique, Uniquable(..), hasKey, u2i, -- hack: used in UniqFM - pprUnique, pprUnique10, showUnique, + pprUnique, pprUnique10, mkUnique, -- Used in UniqSupply mkUniqueGrimily, -- Used in UniqSupply only! + getKey, -- Used in Var only! incrUnique, -- Used for renumbering - initRenumberingUniques, + deriveUnique, -- Ditto + initTyVarUnique, + initTidyUniques, + + isTupleKey, -- now all the built-in Uniques (and functions to make them) -- [the Oh-So-Wonderful Haskell module system wins again...] @@ -46,22 +46,25 @@ module Unique ( addrDataConKey, addrPrimTyConKey, addrTyConKey, - andandIdKey, appendIdKey, arrayPrimTyConKey, + assertIdKey, augmentIdKey, + bindIOIdKey, boolTyConKey, boundedClassKey, - buildDataConKey, + boxedConKey, buildIdKey, byteArrayPrimTyConKey, + byteArrayTyConKey, cCallableClassKey, cReturnableClassKey, charDataConKey, charPrimTyConKey, charTyConKey, - composeIdKey, + concatIdKey, consDataConKey, + deRefStablePtrIdKey, doubleDataConKey, doublePrimTyConKey, doubleTyConKey, @@ -72,10 +75,10 @@ module Unique ( enumFromToClassOpKey, eqClassKey, eqClassOpKey, - eqDataConKey, errorIdKey, - evalClassKey, falseDataConKey, + failMClassOpKey, + filterIdKey, floatDataConKey, floatPrimTyConKey, floatTyConKey, @@ -85,7 +88,6 @@ module Unique ( foreignObjDataConKey, foreignObjPrimTyConKey, foreignObjTyConKey, - forkIdKey, fractionalClassKey, fromEnumClassOpKey, fromIntClassOpKey, @@ -94,134 +96,113 @@ module Unique ( funTyConKey, functorClassKey, geClassOpKey, - gtDataConKey, - iOTyConKey, + getTagIdKey, intDataConKey, intPrimTyConKey, intTyConKey, - integerDataConKey, + int8TyConKey, + int16TyConKey, + int32TyConKey, + int64PrimTyConKey, + int64TyConKey, + smallIntegerDataConKey, + largeIntegerDataConKey, integerMinusOneIdKey, integerPlusOneIdKey, integerPlusTwoIdKey, + int2IntegerIdKey, + addr2IntegerIdKey, integerTyConKey, integerZeroIdKey, integralClassKey, irrefutPatErrorIdKey, ixClassKey, - lexIdKey, - liftDataConKey, - liftTyConKey, listTyConKey, - ltDataConKey, + mainKey, + makeStablePtrIdKey, + mapIdKey, + minusClassOpKey, monadClassKey, monadPlusClassKey, - monadZeroClassKey, mutableArrayPrimTyConKey, mutableByteArrayPrimTyConKey, + mutableByteArrayTyConKey, + mutVarPrimTyConKey, nilDataConKey, - noDefaultMethodErrorIdKey, + noMethodBindingErrorIdKey, nonExhaustiveGuardsErrorIdKey, - nonExplicitMethodErrorIdKey, - notIdKey, numClassKey, + anyBoxConKey, ordClassKey, orderingTyConKey, - packCStringIdKey, + otherwiseIdKey, parErrorIdKey, parIdKey, patErrorIdKey, - primIoTyConKey, ratioDataConKey, ratioTyConKey, rationalTyConKey, readClassKey, - readParenIdKey, realClassKey, realFloatClassKey, realFracClassKey, realWorldPrimIdKey, realWorldTyConKey, recConErrorIdKey, + recSelErrIdKey, recUpdErrorIdKey, - return2GMPsDataConKey, - return2GMPsTyConKey, - returnIntAndGMPDataConKey, - returnIntAndGMPTyConKey, - runSTIdKey, - seqIdKey, + returnIOIdKey, + returnMClassOpKey, + runSTRepIdKey, showClassKey, - showParenIdKey, - showSpaceIdKey, - showStringIdKey, - stTyConKey, - stDataConKey, + ioTyConKey, + ioDataConKey, stablePtrDataConKey, stablePtrPrimTyConKey, stablePtrTyConKey, - stateAndAddrPrimDataConKey, - stateAndAddrPrimTyConKey, - stateAndArrayPrimDataConKey, - stateAndArrayPrimTyConKey, - stateAndByteArrayPrimDataConKey, - stateAndByteArrayPrimTyConKey, - stateAndCharPrimDataConKey, - stateAndCharPrimTyConKey, - stateAndDoublePrimDataConKey, - stateAndDoublePrimTyConKey, - stateAndFloatPrimDataConKey, - stateAndFloatPrimTyConKey, - stateAndForeignObjPrimDataConKey, - stateAndForeignObjPrimTyConKey, - stateAndIntPrimDataConKey, - stateAndIntPrimTyConKey, - stateAndMutableArrayPrimDataConKey, - stateAndMutableArrayPrimTyConKey, - stateAndMutableByteArrayPrimDataConKey, - stateAndMutableByteArrayPrimTyConKey, - stateAndPtrPrimDataConKey, - stateAndPtrPrimTyConKey, - stateAndStablePtrPrimDataConKey, - stateAndStablePtrPrimTyConKey, - stateAndSynchVarPrimDataConKey, - stateAndSynchVarPrimTyConKey, - stateAndWordPrimDataConKey, - stateAndWordPrimTyConKey, - stateDataConKey, + stableNameDataConKey, + stableNamePrimTyConKey, + stableNameTyConKey, + statePrimTyConKey, - stateTyConKey, - synchVarPrimTyConKey, + typeConKey, + kindConKey, + boxityConKey, + mVarPrimTyConKey, thenMClassOpKey, + threadIdPrimTyConKey, + toEnumClassOpKey, traceIdKey, trueDataConKey, + unboundKey, + unboxedConKey, unpackCString2IdKey, unpackCStringAppendIdKey, unpackCStringFoldrIdKey, unpackCStringIdKey, - ureadListIdKey, + unsafeCoerceIdKey, ushowListIdKey, - voidIdKey, - voidTyConKey, + weakPrimTyConKey, wordDataConKey, wordPrimTyConKey, wordTyConKey, - zeroClassOpKey - , copyableIdKey - , noFollowIdKey - , parAtAbsIdKey - , parAtForNowIdKey - , parAtIdKey - , parAtRelIdKey - , parGlobalIdKey - , parLocalIdKey - , unboundKey + word8TyConKey, + word16TyConKey, + word32TyConKey, + word64PrimTyConKey, + word64TyConKey, + zipIdKey ) where -import PreludeGlaST +#include "HsVersions.h" -IMP_Ubiq(){-uitous-} +import BasicTypes ( Boxity(..) ) +import FastString ( FastString, uniqueOfFS ) +import GlaExts +import ST +import PrelBase ( Char(..), chr, ord ) -import Pretty -import Util +import Outputable \end{code} %************************************************************************ @@ -234,9 +215,11 @@ The @Chars@ are ``tag letters'' that identify the @UniqueSupply@. Fast comparison is everything on @Uniques@: \begin{code} -u2i :: Unique -> FAST_INT - data Unique = MkUnique Int# +\end{code} + +\begin{code} +u2i :: Unique -> FAST_INT u2i (MkUnique i) = i \end{code} @@ -249,15 +232,27 @@ unpkUnique :: Unique -> (Char, Int) -- The reverse mkUniqueGrimily :: Int# -> Unique -- A trap-door for UniqSupply +getKey :: Unique -> Int# -- for Var + incrUnique :: Unique -> Unique +deriveUnique :: Unique -> Int -> Unique + +isTupleKey :: Unique -> Bool \end{code} \begin{code} mkUniqueGrimily x = MkUnique 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) + -- 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 @@ -267,18 +262,44 @@ i2w x = int2Word# x 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 + tag = i2w (ord# c) `shiftL#` i2w_s 24# + 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 + shiftr x y = shiftRL# x y \end{code} + + +%************************************************************************ +%* * +\subsection[Uniquable-class]{The @Uniquable@ class} +%* * +%************************************************************************ + +\begin{code} +class Uniquable a where + getUnique :: a -> Unique + +hasKey :: Uniquable a => a -> Unique -> Bool +x `hasKey` k = getUnique x == k + +instance Uniquable FastString where + getUnique fs = mkUniqueGrimily (uniqueOfFS fs) + +instance Uniquable Int where + getUnique (I# i#) = mkUniqueGrimily i# +\end{code} + + %************************************************************************ %* * \subsection[Unique-instances]{Instance declarations for @Unique@} @@ -295,7 +316,7 @@ ltUnique (MkUnique u1) (MkUnique u2) = u1 <# u2 leUnique (MkUnique u1) (MkUnique u2) = u1 <=# u2 cmpUnique (MkUnique u1) (MkUnique u2) - = if u1 ==# u2 then EQ_ else if u1 <# u2 then LT_ else GT_ + = if u1 ==# u2 then EQ else if u1 <# u2 then LT else GT instance Eq Unique where a == b = eqUnique a b @@ -306,19 +327,16 @@ instance Ord Unique where a <= b = leUnique a b a > b = not (leUnique a b) a >= b = not (ltUnique a b) - _tagCmp a b = case cmpUnique a b of { LT_ -> _LT; EQ_ -> _EQ; GT__ -> _GT } - -instance Ord3 Unique where - cmp = cmpUnique + compare a b = cmpUnique a b ----------------- 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 -> Pretty +pprUnique, pprUnique10 :: Unique -> SDoc pprUnique uniq = case unpkUnique uniq of @@ -326,30 +344,19 @@ pprUnique uniq pprUnique10 uniq -- in base-10, dudes = case unpkUnique uniq of - (tag, u) -> finish_ppr tag u (ppInt u) - -finish_ppr tag u pp_u - = if tag /= 't' -- this is just to make v common tyvars, t1, t2, ... - -- come out as a, b, ... (shorter, easier to read) - then pp_all - else case u of - 1 -> ppChar 'a' - 2 -> ppChar 'b' - 3 -> ppChar 'c' - 4 -> ppChar 'd' - 5 -> ppChar 'e' - _ -> pp_all - where - pp_all = ppBeside (ppChar tag) pp_u + (tag, u) -> finish_ppr tag u (int u) -showUnique :: Unique -> FAST_STRING -showUnique uniq = _PK_ (ppShow 80 (pprUnique uniq)) +finish_ppr 't' u pp_u | u < 26 + = -- Special case to make v common tyvars, t1, t2, ... + -- come out as a, b, ... (shorter, easier to read) + char (chr (ord 'a' + u)) +finish_ppr tag u pp_u = char tag <> pp_u instance Outputable Unique where - ppr sty u = pprUnique u + ppr u = pprUnique u -instance Text Unique where - showsPrec p uniq rest = _UNPK_ (showUnique uniq) +instance Show Unique where + showsPrec p uniq = showsPrecSDoc p (pprUnique uniq) \end{code} %************************************************************************ @@ -362,34 +369,30 @@ 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} -#if __GLASGOW_HASKELL__ >= 200 -# define BYTE_ARRAY GHCbase.ByteArray -# define RUN_ST GHCbase.runST +# define BYTE_ARRAY GlaExts.ByteArray +# define RUN_ST ST.runST # define AND_THEN >>= # define AND_THEN_ >> # define RETURN return -#else -# define BYTE_ARRAY _ByteArray -# define RUN_ST _runST -# define AND_THEN `thenStrictlyST` -# define AND_THEN_ `seqStrictlyST` -# define RETURN returnStrictlyST -#endif -iToBase62 :: Int -> Pretty +iToBase62 :: Int -> SDoc iToBase62 n@(I# n#) = ASSERT(n >= 0) let +#if __GLASGOW_HASKELL__ < 405 bytes = case chars62 of { BYTE_ARRAY bounds_who_needs_'em bytes -> bytes } +#else + bytes = case chars62 of { BYTE_ARRAY _ _ bytes -> bytes } +#endif in if n# <# 62# then case (indexCharArray# bytes n#) of { c -> - ppChar (C# c) } + char (C# c) } else case (quotRem n 62) of { (q, I# r#) -> case (indexCharArray# bytes r#) of { c -> - ppBeside (iToBase62 q) (ppChar (C# c)) }} + (<>) (iToBase62 q) (char (C# c)) }} -- keep this at top level! (bug on 94/10/24 WDP) chars62 :: BYTE_ARRAY Int @@ -420,31 +423,54 @@ Allocation of unique supply characters: 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 +mkAlphaTyVarUnique i = mkUnique '1' i mkPreludeClassUnique i = mkUnique '2' i mkPreludeTyConUnique i = mkUnique '3' i -mkTupleTyConUnique a = mkUnique '4' a +mkTupleTyConUnique Boxed a = mkUnique '4' a +mkTupleTyConUnique Unboxed a = mkUnique '5' a + +-- 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). + +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) -mkPreludeDataConUnique i = mkUnique '5' i -- must be alphabetic -mkTupleDataConUnique a = mkUnique '6' a -- ditto (*may* be used in C labels) +-- 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' -mkPrimOpIdUnique op = mkUnique '7' op -mkPreludeMiscIdUnique i = mkUnique '8' i +mkPrimOpIdUnique op = mkUnique '9' op +mkPreludeMiscIdUnique i = mkUnique '0' i -initRenumberingUniques = (mkUnique 'v' 1, mkUnique 't' 1, mkUnique 'u' 1) +-- The "tyvar uniques" print specially nicely: a, b, c, etc. +-- See pprUnique for details -mkPseudoUnique1, mkPseudoUnique2, mkPseudoUnique3, - mkBuiltinUnique :: Int -> Unique +initTyVarUnique :: Unique +initTyVarUnique = mkUnique 't' 0 + +initTidyUniques :: (Unique, Unique) -- Global and local +initTidyUniques = (mkUnique 'g' 0, mkUnique 'x' 0) + +mkPseudoUnique1, mkPseudoUnique2, mkPseudoUnique3, + mkBuiltinUnique :: Int -> Unique 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 +mkPseudoUnique1 i = mkUnique 'C' i -- used for getUnique on Regs +mkPseudoUnique2 i = mkUnique 'D' i -- used in NCG for getUnique on RealRegs +mkPseudoUnique3 i = mkUnique 'E' i -- used in NCG spiller to create spill VirtualRegs + + getBuiltinUniques :: Int -> [Unique] getBuiltinUniques n = map (mkUnique 'B') [1 .. n] @@ -460,26 +486,24 @@ getBuiltinUniques n = map (mkUnique 'B') [1 .. n] 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 +monadPlusClassKey = mkPreludeClassUnique 9 +functorClassKey = mkPreludeClassUnique 10 +numClassKey = mkPreludeClassUnique 11 +ordClassKey = mkPreludeClassUnique 12 +readClassKey = mkPreludeClassUnique 13 +realClassKey = mkPreludeClassUnique 14 +realFloatClassKey = mkPreludeClassUnique 15 +realFracClassKey = mkPreludeClassUnique 16 +showClassKey = mkPreludeClassUnique 17 -cCallableClassKey = mkPreludeClassUnique 19 -cReturnableClassKey = mkPreludeClassUnique 20 +cCallableClassKey = mkPreludeClassUnique 18 +cReturnableClassKey = mkPreludeClassUnique 19 -ixClassKey = mkPreludeClassUnique 21 +ixClassKey = mkPreludeClassUnique 20 \end{code} %************************************************************************ @@ -501,48 +525,48 @@ doubleTyConKey = mkPreludeTyConUnique 10 floatPrimTyConKey = mkPreludeTyConUnique 11 floatTyConKey = mkPreludeTyConUnique 12 funTyConKey = mkPreludeTyConUnique 13 -iOTyConKey = mkPreludeTyConUnique 14 -intPrimTyConKey = mkPreludeTyConUnique 15 -intTyConKey = mkPreludeTyConUnique 16 -integerTyConKey = mkPreludeTyConUnique 17 -liftTyConKey = mkPreludeTyConUnique 18 -listTyConKey = mkPreludeTyConUnique 19 -foreignObjPrimTyConKey = mkPreludeTyConUnique 20 -foreignObjTyConKey = mkPreludeTyConUnique 21 -mutableArrayPrimTyConKey = mkPreludeTyConUnique 22 -mutableByteArrayPrimTyConKey = mkPreludeTyConUnique 23 -orderingTyConKey = mkPreludeTyConUnique 24 -synchVarPrimTyConKey = mkPreludeTyConUnique 25 -ratioTyConKey = mkPreludeTyConUnique 26 -rationalTyConKey = mkPreludeTyConUnique 27 -realWorldTyConKey = mkPreludeTyConUnique 28 -return2GMPsTyConKey = mkPreludeTyConUnique 29 -returnIntAndGMPTyConKey = mkPreludeTyConUnique 30 -stablePtrPrimTyConKey = mkPreludeTyConUnique 31 -stablePtrTyConKey = mkPreludeTyConUnique 32 -stateAndAddrPrimTyConKey = mkPreludeTyConUnique 33 -stateAndArrayPrimTyConKey = mkPreludeTyConUnique 34 -stateAndByteArrayPrimTyConKey = mkPreludeTyConUnique 35 -stateAndCharPrimTyConKey = mkPreludeTyConUnique 36 -stateAndDoublePrimTyConKey = mkPreludeTyConUnique 37 -stateAndFloatPrimTyConKey = mkPreludeTyConUnique 38 -stateAndIntPrimTyConKey = mkPreludeTyConUnique 39 -stateAndForeignObjPrimTyConKey = mkPreludeTyConUnique 40 -stateAndMutableArrayPrimTyConKey = mkPreludeTyConUnique 41 -stateAndMutableByteArrayPrimTyConKey = mkPreludeTyConUnique 42 -stateAndSynchVarPrimTyConKey = mkPreludeTyConUnique 43 -stateAndPtrPrimTyConKey = mkPreludeTyConUnique 44 -stateAndStablePtrPrimTyConKey = mkPreludeTyConUnique 45 -stateAndWordPrimTyConKey = mkPreludeTyConUnique 46 -statePrimTyConKey = mkPreludeTyConUnique 47 -stateTyConKey = mkPreludeTyConUnique 48 - -- 49 is spare -stTyConKey = mkPreludeTyConUnique 50 -primIoTyConKey = mkPreludeTyConUnique 51 - -- 52 is spare -wordPrimTyConKey = mkPreludeTyConUnique 53 -wordTyConKey = mkPreludeTyConUnique 54 -voidTyConKey = mkPreludeTyConUnique 55 +intPrimTyConKey = mkPreludeTyConUnique 14 +intTyConKey = mkPreludeTyConUnique 15 +int8TyConKey = mkPreludeTyConUnique 16 +int16TyConKey = mkPreludeTyConUnique 17 +int32TyConKey = mkPreludeTyConUnique 18 +int64PrimTyConKey = mkPreludeTyConUnique 19 +int64TyConKey = mkPreludeTyConUnique 20 +integerTyConKey = mkPreludeTyConUnique 21 +listTyConKey = mkPreludeTyConUnique 22 +foreignObjPrimTyConKey = mkPreludeTyConUnique 23 +foreignObjTyConKey = mkPreludeTyConUnique 24 +weakPrimTyConKey = mkPreludeTyConUnique 25 +mutableArrayPrimTyConKey = mkPreludeTyConUnique 26 +mutableByteArrayPrimTyConKey = mkPreludeTyConUnique 27 +orderingTyConKey = mkPreludeTyConUnique 28 +mVarPrimTyConKey = mkPreludeTyConUnique 29 +ratioTyConKey = mkPreludeTyConUnique 30 +rationalTyConKey = mkPreludeTyConUnique 31 +realWorldTyConKey = mkPreludeTyConUnique 32 +stablePtrPrimTyConKey = mkPreludeTyConUnique 33 +stablePtrTyConKey = mkPreludeTyConUnique 34 +statePrimTyConKey = mkPreludeTyConUnique 35 +stableNamePrimTyConKey = mkPreludeTyConUnique 50 +stableNameTyConKey = mkPreludeTyConUnique 51 +mutableByteArrayTyConKey = mkPreludeTyConUnique 52 +mutVarPrimTyConKey = mkPreludeTyConUnique 53 +ioTyConKey = mkPreludeTyConUnique 55 +byteArrayTyConKey = mkPreludeTyConUnique 56 +wordPrimTyConKey = mkPreludeTyConUnique 57 +wordTyConKey = mkPreludeTyConUnique 58 +word8TyConKey = mkPreludeTyConUnique 59 +word16TyConKey = mkPreludeTyConUnique 60 +word32TyConKey = mkPreludeTyConUnique 61 +word64PrimTyConKey = mkPreludeTyConUnique 62 +word64TyConKey = mkPreludeTyConUnique 63 +boxedConKey = mkPreludeTyConUnique 64 +unboxedConKey = mkPreludeTyConUnique 65 +anyBoxConKey = mkPreludeTyConUnique 66 +kindConKey = mkPreludeTyConUnique 67 +boxityConKey = mkPreludeTyConUnique 68 +typeConKey = mkPreludeTyConUnique 69 +threadIdPrimTyConKey = mkPreludeTyConUnique 70 \end{code} %************************************************************************ @@ -552,43 +576,24 @@ voidTyConKey = mkPreludeTyConUnique 55 %************************************************************************ \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 -integerDataConKey = mkPreludeDataConUnique 12 -liftDataConKey = mkPreludeDataConUnique 13 -ltDataConKey = mkPreludeDataConUnique 14 -foreignObjDataConKey = mkPreludeDataConUnique 15 -nilDataConKey = mkPreludeDataConUnique 18 -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 -stateAndForeignObjPrimDataConKey = mkPreludeDataConUnique 32 -stateAndMutableArrayPrimDataConKey = mkPreludeDataConUnique 33 -stateAndMutableByteArrayPrimDataConKey = mkPreludeDataConUnique 34 -stateAndSynchVarPrimDataConKey = mkPreludeDataConUnique 35 -stateAndPtrPrimDataConKey = mkPreludeDataConUnique 36 -stateAndStablePtrPrimDataConKey = mkPreludeDataConUnique 37 -stateAndWordPrimDataConKey = mkPreludeDataConUnique 38 -stateDataConKey = mkPreludeDataConUnique 39 -trueDataConKey = mkPreludeDataConUnique 40 -wordDataConKey = mkPreludeDataConUnique 41 -stDataConKey = mkPreludeDataConUnique 42 +addrDataConKey = mkPreludeDataConUnique 0 +charDataConKey = mkPreludeDataConUnique 1 +consDataConKey = mkPreludeDataConUnique 2 +doubleDataConKey = mkPreludeDataConUnique 3 +falseDataConKey = mkPreludeDataConUnique 4 +floatDataConKey = mkPreludeDataConUnique 5 +intDataConKey = mkPreludeDataConUnique 6 +smallIntegerDataConKey = mkPreludeDataConUnique 7 +largeIntegerDataConKey = mkPreludeDataConUnique 8 +foreignObjDataConKey = mkPreludeDataConUnique 9 +nilDataConKey = mkPreludeDataConUnique 10 +ratioDataConKey = mkPreludeDataConUnique 11 +stablePtrDataConKey = mkPreludeDataConUnique 12 +stableNameDataConKey = mkPreludeDataConUnique 13 +trueDataConKey = mkPreludeDataConUnique 14 +wordDataConKey = mkPreludeDataConUnique 15 +stDataConKey = mkPreludeDataConUnique 16 +ioDataConKey = mkPreludeDataConUnique 17 \end{code} %************************************************************************ @@ -599,74 +604,75 @@ stDataConKey = mkPreludeDataConUnique 42 \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 -int2IntegerIdKey = mkPreludeMiscIdUnique 11 -integerMinusOneIdKey = mkPreludeMiscIdUnique 12 -integerPlusOneIdKey = mkPreludeMiscIdUnique 13 -integerPlusTwoIdKey = mkPreludeMiscIdUnique 14 -integerZeroIdKey = mkPreludeMiscIdUnique 15 -irrefutPatErrorIdKey = mkPreludeMiscIdUnique 16 -lexIdKey = mkPreludeMiscIdUnique 17 -noDefaultMethodErrorIdKey = mkPreludeMiscIdUnique 20 -nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 21 -nonExplicitMethodErrorIdKey = mkPreludeMiscIdUnique 22 -notIdKey = mkPreludeMiscIdUnique 23 -packCStringIdKey = mkPreludeMiscIdUnique 24 -parErrorIdKey = mkPreludeMiscIdUnique 25 -parIdKey = mkPreludeMiscIdUnique 26 -patErrorIdKey = mkPreludeMiscIdUnique 27 -readParenIdKey = mkPreludeMiscIdUnique 28 -realWorldPrimIdKey = mkPreludeMiscIdUnique 29 -recConErrorIdKey = mkPreludeMiscIdUnique 30 -recUpdErrorIdKey = mkPreludeMiscIdUnique 31 -runSTIdKey = mkPreludeMiscIdUnique 32 -seqIdKey = mkPreludeMiscIdUnique 33 -showParenIdKey = mkPreludeMiscIdUnique 34 -showSpaceIdKey = mkPreludeMiscIdUnique 35 -showStringIdKey = mkPreludeMiscIdUnique 36 -traceIdKey = mkPreludeMiscIdUnique 37 -unpackCString2IdKey = mkPreludeMiscIdUnique 38 -unpackCStringAppendIdKey = mkPreludeMiscIdUnique 39 -unpackCStringFoldrIdKey = mkPreludeMiscIdUnique 40 -unpackCStringIdKey = mkPreludeMiscIdUnique 41 -voidIdKey = mkPreludeMiscIdUnique 42 -ushowListIdKey = mkPreludeMiscIdUnique 43 -ureadListIdKey = mkPreludeMiscIdUnique 44 - -copyableIdKey = mkPreludeMiscIdUnique 45 -noFollowIdKey = mkPreludeMiscIdUnique 46 -parAtAbsIdKey = mkPreludeMiscIdUnique 47 -parAtForNowIdKey = mkPreludeMiscIdUnique 48 -parAtIdKey = mkPreludeMiscIdUnique 49 -parAtRelIdKey = mkPreludeMiscIdUnique 50 -parGlobalIdKey = mkPreludeMiscIdUnique 51 -parLocalIdKey = mkPreludeMiscIdUnique 52 +appendIdKey = mkPreludeMiscIdUnique 2 +augmentIdKey = mkPreludeMiscIdUnique 3 +buildIdKey = mkPreludeMiscIdUnique 4 +errorIdKey = mkPreludeMiscIdUnique 5 +foldlIdKey = mkPreludeMiscIdUnique 6 +foldrIdKey = mkPreludeMiscIdUnique 7 +recSelErrIdKey = mkPreludeMiscIdUnique 8 +integerMinusOneIdKey = mkPreludeMiscIdUnique 9 +integerPlusOneIdKey = mkPreludeMiscIdUnique 10 +integerPlusTwoIdKey = mkPreludeMiscIdUnique 11 +integerZeroIdKey = mkPreludeMiscIdUnique 12 +int2IntegerIdKey = mkPreludeMiscIdUnique 13 +addr2IntegerIdKey = mkPreludeMiscIdUnique 14 +irrefutPatErrorIdKey = mkPreludeMiscIdUnique 15 +lexIdKey = mkPreludeMiscIdUnique 16 +noMethodBindingErrorIdKey = mkPreludeMiscIdUnique 17 +nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 18 +parErrorIdKey = mkPreludeMiscIdUnique 20 +parIdKey = mkPreludeMiscIdUnique 21 +patErrorIdKey = mkPreludeMiscIdUnique 22 +realWorldPrimIdKey = mkPreludeMiscIdUnique 23 +recConErrorIdKey = mkPreludeMiscIdUnique 24 +recUpdErrorIdKey = mkPreludeMiscIdUnique 25 +traceIdKey = mkPreludeMiscIdUnique 26 +unpackCString2IdKey = mkPreludeMiscIdUnique 27 +unpackCStringAppendIdKey = mkPreludeMiscIdUnique 28 +unpackCStringFoldrIdKey = mkPreludeMiscIdUnique 29 +unpackCStringIdKey = mkPreludeMiscIdUnique 30 +ushowListIdKey = mkPreludeMiscIdUnique 31 +unsafeCoerceIdKey = mkPreludeMiscIdUnique 32 +concatIdKey = mkPreludeMiscIdUnique 33 +filterIdKey = mkPreludeMiscIdUnique 34 +zipIdKey = mkPreludeMiscIdUnique 35 +bindIOIdKey = mkPreludeMiscIdUnique 36 +returnIOIdKey = mkPreludeMiscIdUnique 37 +deRefStablePtrIdKey = mkPreludeMiscIdUnique 38 +makeStablePtrIdKey = mkPreludeMiscIdUnique 39 +getTagIdKey = mkPreludeMiscIdUnique 40 \end{code} -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. +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 53 -fromIntegerClassOpKey = mkPreludeMiscIdUnique 54 -fromRationalClassOpKey = mkPreludeMiscIdUnique 55 -enumFromClassOpKey = mkPreludeMiscIdUnique 56 -enumFromThenClassOpKey = mkPreludeMiscIdUnique 57 -enumFromToClassOpKey = mkPreludeMiscIdUnique 58 -enumFromThenToClassOpKey= mkPreludeMiscIdUnique 59 -eqClassOpKey = mkPreludeMiscIdUnique 60 -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 +fromIntClassOpKey = mkPreludeMiscIdUnique 101 +fromIntegerClassOpKey = mkPreludeMiscIdUnique 102 +minusClassOpKey = mkPreludeMiscIdUnique 103 +fromRationalClassOpKey = mkPreludeMiscIdUnique 104 +enumFromClassOpKey = mkPreludeMiscIdUnique 105 +enumFromThenClassOpKey = mkPreludeMiscIdUnique 106 +enumFromToClassOpKey = mkPreludeMiscIdUnique 107 +enumFromThenToClassOpKey = mkPreludeMiscIdUnique 108 +eqClassOpKey = mkPreludeMiscIdUnique 109 +geClassOpKey = mkPreludeMiscIdUnique 110 +failMClassOpKey = mkPreludeMiscIdUnique 112 +thenMClassOpKey = mkPreludeMiscIdUnique 113 -- (>>=) + -- Just a place holder for unbound variables produced by the renamer: +unboundKey = mkPreludeMiscIdUnique 114 +fromEnumClassOpKey = mkPreludeMiscIdUnique 115 + +mainKey = mkPreludeMiscIdUnique 116 +returnMClassOpKey = mkPreludeMiscIdUnique 117 +otherwiseIdKey = mkPreludeMiscIdUnique 118 +toEnumClassOpKey = mkPreludeMiscIdUnique 119 +mapIdKey = mkPreludeMiscIdUnique 120 +\end{code} + +\begin{code} +assertIdKey = mkPreludeMiscIdUnique 121 +runSTRepIdKey = mkPreludeMiscIdUnique 122 \end{code}