2 % (c) The AQUA Project, Glasgow University, 1994-1998
4 \section[TysPrim]{Wired-in knowledge about primitive types}
8 alphaTyVars, betaTyVars, alphaTyVar, betaTyVar, gammaTyVar, deltaTyVar,
9 alphaTy, betaTy, gammaTy, deltaTy,
10 openAlphaTy, openAlphaTyVar, openAlphaTyVars,
14 charPrimTyCon, charPrimTy,
15 intPrimTyCon, intPrimTy,
16 wordPrimTyCon, wordPrimTy,
17 addrPrimTyCon, addrPrimTy,
18 floatPrimTyCon, floatPrimTy,
19 doublePrimTyCon, doublePrimTy,
21 statePrimTyCon, mkStatePrimTy,
22 realWorldTyCon, realWorldTy, realWorldStatePrimTy,
24 arrayPrimTyCon, mkArrayPrimTy,
25 byteArrayPrimTyCon, byteArrayPrimTy,
26 mutableArrayPrimTyCon, mkMutableArrayPrimTy,
27 mutableByteArrayPrimTyCon, mkMutableByteArrayPrimTy,
28 mutVarPrimTyCon, mkMutVarPrimTy,
30 mVarPrimTyCon, mkMVarPrimTy,
31 tVarPrimTyCon, mkTVarPrimTy,
32 stablePtrPrimTyCon, mkStablePtrPrimTy,
33 stableNamePrimTyCon, mkStableNamePrimTy,
34 bcoPrimTyCon, bcoPrimTy,
35 weakPrimTyCon, mkWeakPrimTy,
36 foreignObjPrimTyCon, foreignObjPrimTy,
37 threadIdPrimTyCon, threadIdPrimTy,
39 int32PrimTyCon, int32PrimTy,
40 word32PrimTyCon, word32PrimTy,
42 int64PrimTyCon, int64PrimTy,
43 word64PrimTyCon, word64PrimTy
46 #include "HsVersions.h"
48 import Var ( TyVar, mkTyVar )
49 import Name ( Name, BuiltInSyntax(..), mkInternalName, mkWiredInName )
50 import OccName ( mkOccFS, tcName, mkTyVarOcc )
51 import TyCon ( TyCon, ArgVrcs, mkPrimTyCon, mkLiftedPrimTyCon,
53 import Type ( mkTyConApp, mkTyConTy, mkTyVarTys, mkTyVarTy,
54 unliftedTypeKind, liftedTypeKind, openTypeKind,
58 import SrcLoc ( noSrcLoc )
59 import Unique ( mkAlphaTyVarUnique )
61 import FastString ( FastString, mkFastString )
64 import Char ( ord, chr )
67 %************************************************************************
69 \subsection{Primitive type constructors}
71 %************************************************************************
88 , mutableArrayPrimTyCon
89 , mutableByteArrayPrimTyCon
103 mkPrimTc :: FastString -> Unique -> TyCon -> Name
104 mkPrimTc fs uniq tycon
105 = mkWiredInName gHC_PRIM (mkOccFS tcName fs)
107 Nothing -- No parent object
108 (ATyCon tycon) -- Relevant TyCon
109 UserSyntax -- None are built-in syntax
111 charPrimTyConName = mkPrimTc FSLIT("Char#") charPrimTyConKey charPrimTyCon
112 intPrimTyConName = mkPrimTc FSLIT("Int#") intPrimTyConKey intPrimTyCon
113 int32PrimTyConName = mkPrimTc FSLIT("Int32#") int32PrimTyConKey int32PrimTyCon
114 int64PrimTyConName = mkPrimTc FSLIT("Int64#") int64PrimTyConKey int64PrimTyCon
115 wordPrimTyConName = mkPrimTc FSLIT("Word#") wordPrimTyConKey wordPrimTyCon
116 word32PrimTyConName = mkPrimTc FSLIT("Word32#") word32PrimTyConKey word32PrimTyCon
117 word64PrimTyConName = mkPrimTc FSLIT("Word64#") word64PrimTyConKey word64PrimTyCon
118 addrPrimTyConName = mkPrimTc FSLIT("Addr#") addrPrimTyConKey addrPrimTyCon
119 floatPrimTyConName = mkPrimTc FSLIT("Float#") floatPrimTyConKey floatPrimTyCon
120 doublePrimTyConName = mkPrimTc FSLIT("Double#") doublePrimTyConKey doublePrimTyCon
121 statePrimTyConName = mkPrimTc FSLIT("State#") statePrimTyConKey statePrimTyCon
122 realWorldTyConName = mkPrimTc FSLIT("RealWorld") realWorldTyConKey realWorldTyCon
123 arrayPrimTyConName = mkPrimTc FSLIT("Array#") arrayPrimTyConKey arrayPrimTyCon
124 byteArrayPrimTyConName = mkPrimTc FSLIT("ByteArray#") byteArrayPrimTyConKey byteArrayPrimTyCon
125 mutableArrayPrimTyConName = mkPrimTc FSLIT("MutableArray#") mutableArrayPrimTyConKey mutableArrayPrimTyCon
126 mutableByteArrayPrimTyConName = mkPrimTc FSLIT("MutableByteArray#") mutableByteArrayPrimTyConKey mutableByteArrayPrimTyCon
127 mutVarPrimTyConName = mkPrimTc FSLIT("MutVar#") mutVarPrimTyConKey mutVarPrimTyCon
128 mVarPrimTyConName = mkPrimTc FSLIT("MVar#") mVarPrimTyConKey mVarPrimTyCon
129 tVarPrimTyConName = mkPrimTc FSLIT("TVar#") tVarPrimTyConKey tVarPrimTyCon
130 stablePtrPrimTyConName = mkPrimTc FSLIT("StablePtr#") stablePtrPrimTyConKey stablePtrPrimTyCon
131 stableNamePrimTyConName = mkPrimTc FSLIT("StableName#") stableNamePrimTyConKey stableNamePrimTyCon
132 foreignObjPrimTyConName = mkPrimTc FSLIT("ForeignObj#") foreignObjPrimTyConKey foreignObjPrimTyCon
133 bcoPrimTyConName = mkPrimTc FSLIT("BCO#") bcoPrimTyConKey bcoPrimTyCon
134 weakPrimTyConName = mkPrimTc FSLIT("Weak#") weakPrimTyConKey weakPrimTyCon
135 threadIdPrimTyConName = mkPrimTc FSLIT("ThreadId#") threadIdPrimTyConKey threadIdPrimTyCon
138 %************************************************************************
140 \subsection{Support code}
142 %************************************************************************
144 alphaTyVars is a list of type variables for use in templates:
145 ["a", "b", ..., "z", "t1", "t2", ... ]
148 tyVarList :: Kind -> [TyVar]
149 tyVarList kind = [ mkTyVar (mkInternalName (mkAlphaTyVarUnique u)
150 (mkTyVarOcc (mkFastString name))
153 let name | c <= 'z' = [c]
154 | otherwise = 't':show u
155 where c = chr (u-2 + ord 'a')
158 alphaTyVars :: [TyVar]
159 alphaTyVars = tyVarList liftedTypeKind
161 betaTyVars = tail alphaTyVars
163 alphaTyVar, betaTyVar, gammaTyVar :: TyVar
164 (alphaTyVar:betaTyVar:gammaTyVar:deltaTyVar:_) = alphaTyVars
166 alphaTys = mkTyVarTys alphaTyVars
167 (alphaTy:betaTy:gammaTy:deltaTy:_) = alphaTys
169 -- openAlphaTyVar is prepared to be instantiated
170 -- to a lifted or unlifted type variable. It's used for the
171 -- result type for "error", so that we can have (error Int# "Help")
172 openAlphaTyVars :: [TyVar]
173 openAlphaTyVars@(openAlphaTyVar:_) = tyVarList openTypeKind
175 openAlphaTy = mkTyVarTy openAlphaTyVar
177 vrcPos,vrcZero :: (Bool,Bool)
178 vrcPos = (True,False)
179 vrcZero = (False,False)
181 vrcsP,vrcsZ,vrcsZP :: ArgVrcs
184 vrcsZP = [vrcZero,vrcPos]
188 %************************************************************************
190 \subsection[TysPrim-basic]{Basic primitive types (@Char#@, @Int#@, etc.)}
192 %************************************************************************
196 pcPrimTyCon :: Name -> ArgVrcs -> PrimRep -> TyCon
197 pcPrimTyCon name arg_vrcs rep
198 = mkPrimTyCon name kind arity arg_vrcs rep
200 arity = length arg_vrcs
201 kind = mkArrowKinds (replicate arity liftedTypeKind) result_kind
202 result_kind = unliftedTypeKind -- all primitive types are unlifted
204 pcPrimTyCon0 :: Name -> PrimRep -> TyCon
205 pcPrimTyCon0 name rep
206 = mkPrimTyCon name result_kind 0 [] rep
208 result_kind = unliftedTypeKind -- all primitive types are unlifted
210 charPrimTy = mkTyConTy charPrimTyCon
211 charPrimTyCon = pcPrimTyCon0 charPrimTyConName WordRep
213 intPrimTy = mkTyConTy intPrimTyCon
214 intPrimTyCon = pcPrimTyCon0 intPrimTyConName IntRep
216 int32PrimTy = mkTyConTy int32PrimTyCon
217 int32PrimTyCon = pcPrimTyCon0 int32PrimTyConName IntRep
219 int64PrimTy = mkTyConTy int64PrimTyCon
220 int64PrimTyCon = pcPrimTyCon0 int64PrimTyConName Int64Rep
222 wordPrimTy = mkTyConTy wordPrimTyCon
223 wordPrimTyCon = pcPrimTyCon0 wordPrimTyConName WordRep
225 word32PrimTy = mkTyConTy word32PrimTyCon
226 word32PrimTyCon = pcPrimTyCon0 word32PrimTyConName WordRep
228 word64PrimTy = mkTyConTy word64PrimTyCon
229 word64PrimTyCon = pcPrimTyCon0 word64PrimTyConName Word64Rep
231 addrPrimTy = mkTyConTy addrPrimTyCon
232 addrPrimTyCon = pcPrimTyCon0 addrPrimTyConName AddrRep
234 floatPrimTy = mkTyConTy floatPrimTyCon
235 floatPrimTyCon = pcPrimTyCon0 floatPrimTyConName FloatRep
237 doublePrimTy = mkTyConTy doublePrimTyCon
238 doublePrimTyCon = pcPrimTyCon0 doublePrimTyConName DoubleRep
242 %************************************************************************
244 \subsection[TysPrim-state]{The @State#@ type (and @_RealWorld@ types)}
246 %************************************************************************
248 State# is the primitive, unlifted type of states. It has one type parameter,
254 where s is a type variable. The only purpose of the type parameter is to
255 keep different state threads separate. It is represented by nothing at all.
258 mkStatePrimTy ty = mkTyConApp statePrimTyCon [ty]
259 statePrimTyCon = pcPrimTyCon statePrimTyConName vrcsZ VoidRep
262 RealWorld is deeply magical. It is *primitive*, but it is not
263 *unlifted* (hence ptrArg). We never manipulate values of type
264 RealWorld; it's only used in the type system, to parameterise State#.
267 realWorldTyCon = mkLiftedPrimTyCon realWorldTyConName liftedTypeKind 0 [] PtrRep
268 realWorldTy = mkTyConTy realWorldTyCon
269 realWorldStatePrimTy = mkStatePrimTy realWorldTy -- State# RealWorld
272 Note: the ``state-pairing'' types are not truly primitive, so they are
273 defined in \tr{TysWiredIn.lhs}, not here.
276 %************************************************************************
278 \subsection[TysPrim-arrays]{The primitive array types}
280 %************************************************************************
283 arrayPrimTyCon = pcPrimTyCon arrayPrimTyConName vrcsP PtrRep
284 mutableArrayPrimTyCon = pcPrimTyCon mutableArrayPrimTyConName vrcsZP PtrRep
285 mutableByteArrayPrimTyCon = pcPrimTyCon mutableByteArrayPrimTyConName vrcsZ PtrRep
286 byteArrayPrimTyCon = pcPrimTyCon0 byteArrayPrimTyConName PtrRep
288 mkArrayPrimTy elt = mkTyConApp arrayPrimTyCon [elt]
289 byteArrayPrimTy = mkTyConTy byteArrayPrimTyCon
290 mkMutableArrayPrimTy s elt = mkTyConApp mutableArrayPrimTyCon [s, elt]
291 mkMutableByteArrayPrimTy s = mkTyConApp mutableByteArrayPrimTyCon [s]
294 %************************************************************************
296 \subsection[TysPrim-mut-var]{The mutable variable type}
298 %************************************************************************
301 mutVarPrimTyCon = pcPrimTyCon mutVarPrimTyConName vrcsZP PtrRep
303 mkMutVarPrimTy s elt = mkTyConApp mutVarPrimTyCon [s, elt]
306 %************************************************************************
308 \subsection[TysPrim-synch-var]{The synchronizing variable type}
310 %************************************************************************
313 mVarPrimTyCon = pcPrimTyCon mVarPrimTyConName vrcsZP PtrRep
315 mkMVarPrimTy s elt = mkTyConApp mVarPrimTyCon [s, elt]
318 %************************************************************************
320 \subsection[TysPrim-stm-var]{The transactional variable type}
322 %************************************************************************
325 tVarPrimTyCon = pcPrimTyCon tVarPrimTyConName vrcsZP PtrRep
327 mkTVarPrimTy s elt = mkTyConApp tVarPrimTyCon [s, elt]
330 %************************************************************************
332 \subsection[TysPrim-stable-ptrs]{The stable-pointer type}
334 %************************************************************************
337 stablePtrPrimTyCon = pcPrimTyCon stablePtrPrimTyConName vrcsP AddrRep
339 mkStablePtrPrimTy ty = mkTyConApp stablePtrPrimTyCon [ty]
342 %************************************************************************
344 \subsection[TysPrim-stable-names]{The stable-name type}
346 %************************************************************************
349 stableNamePrimTyCon = pcPrimTyCon stableNamePrimTyConName vrcsP PtrRep
351 mkStableNamePrimTy ty = mkTyConApp stableNamePrimTyCon [ty]
354 %************************************************************************
356 \subsection[TysPrim-foreign-objs]{The ``foreign object'' type}
358 %************************************************************************
360 A Foreign Object is just a boxed, unlifted, Addr#. They're needed
361 because finalisers (weak pointers) can't watch Addr#s, they can only
362 watch heap-resident objects.
364 We can't use a lifted Addr# (such as Addr) because race conditions
365 could bite us. For example, if the program deconstructed the Addr
366 before passing its contents to a ccall, and a weak pointer was
367 watching the Addr, the weak pointer might deduce that the Addr was
368 dead before it really was.
371 foreignObjPrimTy = mkTyConTy foreignObjPrimTyCon
372 foreignObjPrimTyCon = pcPrimTyCon0 foreignObjPrimTyConName PtrRep
375 %************************************************************************
377 \subsection[TysPrim-BCOs]{The ``bytecode object'' type}
379 %************************************************************************
382 bcoPrimTy = mkTyConTy bcoPrimTyCon
383 bcoPrimTyCon = pcPrimTyCon0 bcoPrimTyConName PtrRep
386 %************************************************************************
388 \subsection[TysPrim-Weak]{The ``weak pointer'' type}
390 %************************************************************************
393 weakPrimTyCon = pcPrimTyCon weakPrimTyConName vrcsP PtrRep
395 mkWeakPrimTy v = mkTyConApp weakPrimTyCon [v]
398 %************************************************************************
400 \subsection[TysPrim-thread-ids]{The ``thread id'' type}
402 %************************************************************************
404 A thread id is represented by a pointer to the TSO itself, to ensure
405 that they are always unique and we can always find the TSO for a given
406 thread id. However, this has the unfortunate consequence that a
407 ThreadId# for a given thread is treated as a root by the garbage
408 collector and can keep TSOs around for too long.
410 Hence the programmer API for thread manipulation uses a weak pointer
411 to the thread id internally.
414 threadIdPrimTy = mkTyConTy threadIdPrimTyCon
415 threadIdPrimTyCon = pcPrimTyCon0 threadIdPrimTyConName PtrRep