X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Fprelude%2FTysWiredIn.lhs;h=3a2a16f91212d7f88f826394aa37e4681e45c6ff;hb=3160f854580e6d8df412c8cd34d93bae27175d67;hp=4df3241c29d99fae1c485ea8365ee5b9a6d1f3f7;hpb=2c8f04b5b883db74f449dfc8c224929fe28b027d;p=ghc-hetmet.git diff --git a/ghc/compiler/prelude/TysWiredIn.lhs b/ghc/compiler/prelude/TysWiredIn.lhs index 4df3241..3a2a16f 100644 --- a/ghc/compiler/prelude/TysWiredIn.lhs +++ b/ghc/compiler/prelude/TysWiredIn.lhs @@ -1,5 +1,5 @@ % -% (c) The GRASP Project, Glasgow University, 1994-1995 +% (c) The GRASP Project, Glasgow University, 1994-1998 % \section[TysWiredIn]{Wired-in knowledge about {\em non-primitive} types} @@ -22,12 +22,13 @@ module TysWiredIn ( consDataCon, doubleDataCon, doubleTy, + isDoubleTy, doubleTyCon, falseDataCon, floatDataCon, floatTy, + isFloatTy, floatTyCon, - getStatePairingConInfo, intDataCon, intTy, @@ -35,84 +36,83 @@ module TysWiredIn ( isIntTy, inIntRange, + int8TyCon, + int16TyCon, + int32TyCon, + + int64TyCon, + integerTy, integerTyCon, integerDataCon, isIntegerTy, - liftDataCon, - liftTyCon, listTyCon, - foreignObjTyCon, - mkLiftTy, mkListTy, + nilDataCon, + + -- tuples mkTupleTy, tupleTyCon, tupleCon, unitTyCon, unitDataCon, pairTyCon, pairDataCon, - nilDataCon, - realWorldStateTy, - return2GMPsTyCon, - returnIntAndGMPTyCon, - - -- ST and STret types - mkStateTy, - mkStateTransformerTy, - mkSTretTy, - stTyCon, - stDataCon, - stRetDataCon, - stRetTyCon, - - -- CCall result types - stateAndAddrPrimTyCon, - stateAndArrayPrimTyCon, - stateAndByteArrayPrimTyCon, - stateAndCharPrimTyCon, - stateAndDoublePrimTyCon, - stateAndFloatPrimTyCon, - stateAndIntPrimTyCon, - stateAndForeignObjPrimTyCon, - stateAndMutableArrayPrimTyCon, - stateAndMutableByteArrayPrimTyCon, - stateAndPtrPrimTyCon, - stateAndStablePtrPrimTyCon, - stateAndSynchVarPrimTyCon, - stateAndWordPrimTyCon, + + -- unboxed tuples + mkUnboxedTupleTy, + unboxedTupleTyCon, unboxedTupleCon, + unboxedPairTyCon, unboxedPairDataCon, + stateDataCon, stateTyCon, + realWorldStateTy, stablePtrTyCon, stringTy, trueDataCon, unitTy, + voidTy, wordDataCon, wordTy, - wordTyCon + wordTyCon, + + word8TyCon, + word16TyCon, + word32TyCon, + word64TyCon, + + isFFIArgumentTy, -- :: Type -> Bool + isFFIResultTy, -- :: Type -> Bool + isFFIExternalTy, -- :: Type -> Bool + isAddrTy, -- :: Type -> Bool + ) where #include "HsVersions.h" -import {-# SOURCE #-} MkId ( mkDataCon, mkTupleCon ) -import {-# SOURCE #-} Id ( Id, StrictnessMark(..) ) +import {-# SOURCE #-} MkId( mkDataConId ) -- friends: import PrelMods import TysPrim -- others: -import Kind ( mkBoxedTypeKind, mkArrowKind ) -import Name ( mkWiredInTyConName, mkWiredInIdName ) -import TyCon ( mkDataTyCon, mkTupleTyCon, mkSynTyCon, - TyCon, Arity - ) -import BasicTypes ( Module, NewOrData(..), RecFlag(..) ) +import Constants ( mAX_TUPLE_SIZE ) +import Name ( Module, varOcc, mkWiredInTyConName, mkWiredInIdName ) +import DataCon ( DataCon, mkDataCon ) +import Var ( TyVar, tyVarKind ) +import TyCon ( TyCon, mkAlgTyCon, mkSynTyCon, mkTupleTyCon ) +import BasicTypes ( Arity, NewOrData(..), + RecFlag(..), StrictnessMark(..) ) import Type ( Type, mkTyConTy, mkTyConApp, mkSigmaTy, mkTyVarTys, - mkFunTy, mkFunTys, splitTyConApp_maybe, splitAlgTyConApp_maybe, - GenType(..), ThetaType, TauType ) -import TyVar ( GenTyVar, TyVar, tyVarKind, alphaTyVars, alphaTyVar, betaTyVar ) -import Lex ( mkTupNameStr ) + mkArrowKinds, boxedTypeKind, unboxedTypeKind, + mkFunTy, mkFunTys, isUnLiftedType, + splitTyConApp_maybe, splitAlgTyConApp_maybe, + ThetaType, TauType ) +import PrimRep ( PrimRep(..) ) import Unique -import Util ( assoc, panic ) +import CmdLineOpts ( opt_GlasgowExts ) +import Util ( assoc ) +import Panic ( panic ) +import Array alpha_tyvar = [alphaTyVar] alpha_ty = [alphaTy] @@ -120,16 +120,16 @@ alpha_beta_tyvars = [alphaTyVar, betaTyVar] pcRecDataTyCon, pcNonRecDataTyCon, pcNonRecNewTyCon :: Unique{-TyConKey-} -> Module -> FAST_STRING - -> [TyVar] -> [Id] -> TyCon + -> [TyVar] -> [DataCon] -> TyCon -pcRecDataTyCon = pc_tycon DataType Recursive -pcNonRecDataTyCon = pc_tycon DataType NonRecursive -pcNonRecNewTyCon = pc_tycon NewType NonRecursive +pcRecDataTyCon = pcTyCon DataType Recursive +pcNonRecDataTyCon = pcTyCon DataType NonRecursive +pcNonRecNewTyCon = pcTyCon NewType NonRecursive -pc_tycon new_or_data is_rec key mod str tyvars cons +pcTyCon new_or_data is_rec key mod str tyvars cons = tycon where - tycon = mkDataTyCon name tycon_kind + tycon = mkAlgTyCon name kind tyvars [] -- No context cons @@ -139,7 +139,7 @@ pc_tycon new_or_data is_rec key mod str tyvars cons is_rec name = mkWiredInTyConName key mod str tycon - tycon_kind = foldr (mkArrowKind . tyVarKind) mkBoxedTypeKind tyvars + kind = mkArrowKinds (map tyVarKind tyvars) boxedTypeKind pcSynTyCon key mod str kind arity tyvars expansion = tycon @@ -148,15 +148,16 @@ pcSynTyCon key mod str kind arity tyvars expansion name = mkWiredInTyConName key mod str tycon pcDataCon :: Unique{-DataConKey-} -> Module -> FAST_STRING - -> [TyVar] -> ThetaType -> [TauType] -> TyCon -> Id + -> [TyVar] -> ThetaType -> [TauType] -> TyCon -> DataCon pcDataCon key mod str tyvars context arg_tys tycon = data_con where data_con = mkDataCon name [ NotMarkedStrict | a <- arg_tys ] [ {- no labelled fields -} ] - tyvars context [] [] arg_tys tycon - name = mkWiredInIdName key mod str data_con + tyvars context [] [] arg_tys tycon id + name = mkWiredInIdName key mod (varOcc str) id + id = mkDataConId data_con \end{code} %************************************************************************ @@ -167,28 +168,38 @@ pcDataCon key mod str tyvars context arg_tys tycon \begin{code} tupleTyCon :: Arity -> TyCon -tupleTyCon arity - = tycon - where - tycon = mkTupleTyCon uniq name arity - uniq = mkTupleTyConUnique arity - name = mkWiredInTyConName uniq mod_name (mkTupNameStr arity) tycon - mod_name | arity == 0 = pREL_BASE - | otherwise = pREL_TUP - -tupleCon :: Arity -> Id -tupleCon arity - = tuple_con +tupleTyCon i | i > mAX_TUPLE_SIZE = fst (mk_tuple i) -- Build one specially + | otherwise = tupleTyConArr!i + +tupleCon :: Arity -> DataCon +tupleCon i | i > mAX_TUPLE_SIZE = snd (mk_tuple i) -- Build one specially + | otherwise = tupleConArr!i + +tupleTyCons :: [TyCon] +tupleTyCons = elems tupleTyConArr + +tupleTyConArr :: Array Int TyCon +tupleTyConArr = array (0,mAX_TUPLE_SIZE) ([0..] `zip` map fst tuples) + +tupleConArr :: Array Int DataCon +tupleConArr = array (0,mAX_TUPLE_SIZE) ([0..] `zip` map snd tuples) + +tuples :: [(TyCon,DataCon)] +tuples = [mk_tuple i | i <- [0..mAX_TUPLE_SIZE]] + +mk_tuple :: Int -> (TyCon,DataCon) +mk_tuple arity = (tycon, tuple_con) where - tuple_con = mkTupleCon arity name ty - uniq = mkTupleDataConUnique arity - name = mkWiredInIdName uniq mod_name (mkTupNameStr arity) tuple_con - mod_name | arity == 0 = pREL_BASE - | otherwise = pREL_TUP - ty = mkSigmaTy tyvars [] (mkFunTys tyvar_tys (mkTyConApp tycon tyvar_tys)) - tyvars = take arity alphaTyVars - tyvar_tys = mkTyVarTys tyvars - tycon = tupleTyCon arity + tycon = mkTupleTyCon tc_name tc_kind arity tyvars tuple_con True + tc_name = mkWiredInTyConName tc_uniq mod_name name_str tycon + tc_kind = mkArrowKinds (map tyVarKind tyvars) boxedTypeKind + + tuple_con = pcDataCon dc_uniq mod_name name_str tyvars [] tyvar_tys tycon + tyvars = take arity alphaTyVars + tyvar_tys = mkTyVarTys tyvars + (mod_name, name_str) = mkTupNameStr arity + tc_uniq = mkTupleTyConUnique arity + dc_uniq = mkTupleDataConUnique arity unitTyCon = tupleTyCon 0 pairTyCon = tupleTyCon 2 @@ -197,6 +208,47 @@ unitDataCon = tupleCon 0 pairDataCon = tupleCon 2 \end{code} +%************************************************************************ +%* * +\subsection[TysWiredIn-ubx-tuples]{Unboxed Tuple Types} +%* * +%************************************************************************ + +\begin{code} +unboxedTupleTyCon :: Arity -> TyCon +unboxedTupleTyCon i | i > mAX_TUPLE_SIZE = fst (mk_unboxed_tuple i) + | otherwise = unboxedTupleTyConArr!i + +unboxedTupleCon :: Arity -> DataCon +unboxedTupleCon i | i > mAX_TUPLE_SIZE = snd (mk_unboxed_tuple i) + | otherwise = unboxedTupleConArr!i + +unboxedTupleTyConArr :: Array Int TyCon +unboxedTupleTyConArr = array (0,mAX_TUPLE_SIZE) ([0..] `zip` map fst ubx_tuples) + +unboxedTupleConArr :: Array Int DataCon +unboxedTupleConArr = array (0,mAX_TUPLE_SIZE) ([0..] `zip` map snd ubx_tuples) + +ubx_tuples :: [(TyCon,DataCon)] +ubx_tuples = [mk_unboxed_tuple i | i <- [0..mAX_TUPLE_SIZE]] + +mk_unboxed_tuple :: Int -> (TyCon,DataCon) +mk_unboxed_tuple arity = (tycon, tuple_con) + where + tycon = mkTupleTyCon tc_name tc_kind arity tyvars tuple_con False + tc_name = mkWiredInTyConName tc_uniq mod_name name_str tycon + tc_kind = mkArrowKinds (map tyVarKind tyvars) unboxedTypeKind + + tuple_con = pcDataCon dc_uniq mod_name name_str tyvars [] tyvar_tys tycon + tyvars = take arity openAlphaTyVars + tyvar_tys = mkTyVarTys tyvars + (mod_name, name_str) = mkUbxTupNameStr arity + tc_uniq = mkUbxTupleTyConUnique arity + dc_uniq = mkUbxTupleDataConUnique arity + +unboxedPairTyCon = unboxedTupleTyCon 2 +unboxedPairDataCon = unboxedTupleCon 2 +\end{code} %************************************************************************ %* * @@ -205,6 +257,22 @@ pairDataCon = tupleCon 2 %************************************************************************ \begin{code} +-- The Void type is represented as a data type with no constructors +-- It's a built in type (i.e. there's no way to define it in Haskell; +-- the nearest would be +-- +-- data Void = -- No constructors! +-- +-- ) It's boxed; there is only one value of this +-- type, namely "void", whose semantics is just bottom. +-- +-- Haskell 98 drops the definition of a Void type, so we just 'simulate' +-- voidTy using (). +voidTy = unitTy +\end{code} + + +\begin{code} charTy = mkTyConTy charTyCon charTyCon = pcNonRecDataTyCon charTyConKey pREL_BASE SLIT("Char") [] [charDataCon] @@ -219,10 +287,10 @@ intTy = mkTyConTy intTyCon intTyCon = pcNonRecDataTyCon intTyConKey pREL_BASE SLIT("Int") [] [intDataCon] intDataCon = pcDataCon intDataConKey pREL_BASE SLIT("I#") [] [] [intPrimTy] intTyCon -isIntTy :: GenType flexi -> Bool +isIntTy :: Type -> Bool isIntTy ty = case (splitAlgTyConApp_maybe ty) of - Just (tycon, [], _) -> uniqueOf tycon == intTyConKey + Just (tycon, [], _) -> getUnique tycon == intTyConKey _ -> False inIntRange :: Integer -> Bool -- Tells if an integer lies in the legal range of Ints @@ -231,13 +299,46 @@ inIntRange i = (min_int <= i) && (i <= max_int) max_int, min_int :: Integer max_int = toInteger maxInt min_int = toInteger minInt + +int8TyCon = pcNonRecDataTyCon int8TyConKey iNT SLIT("Int8") [] [int8DataCon] + where + int8DataCon = pcDataCon int8DataConKey iNT SLIT("I8#") [] [] [intPrimTy] int8TyCon + +int16TyCon = pcNonRecDataTyCon int16TyConKey iNT SLIT("Int16") [] [int16DataCon] + where + int16DataCon = pcDataCon int16DataConKey iNT SLIT("I16#") [] [] [intPrimTy] int16TyCon + +int32TyCon = pcNonRecDataTyCon int32TyConKey iNT SLIT("Int32") [] [int32DataCon] + where + int32DataCon = pcDataCon int32DataConKey iNT SLIT("I32#") [] [] [intPrimTy] int32TyCon + +int64TyCon = pcNonRecDataTyCon int64TyConKey pREL_ADDR SLIT("Int64") [] [int64DataCon] + where + int64DataCon = pcDataCon int64DataConKey pREL_ADDR SLIT("I64#") [] [] [int64PrimTy] int64TyCon \end{code} \begin{code} + wordTy = mkTyConTy wordTyCon -wordTyCon = pcNonRecDataTyCon wordTyConKey pREL_FOREIGN SLIT("Word") [] [wordDataCon] -wordDataCon = pcDataCon wordDataConKey pREL_FOREIGN SLIT("W#") [] [] [wordPrimTy] wordTyCon +wordTyCon = pcNonRecDataTyCon wordTyConKey pREL_ADDR SLIT("Word") [] [wordDataCon] +wordDataCon = pcDataCon wordDataConKey pREL_ADDR SLIT("W#") [] [] [wordPrimTy] wordTyCon + +word8TyCon = pcNonRecDataTyCon word8TyConKey wORD SLIT("Word8") [] [word8DataCon] + where + word8DataCon = pcDataCon word8DataConKey wORD SLIT("W8#") [] [] [wordPrimTy] word8TyCon + +word16TyCon = pcNonRecDataTyCon word16TyConKey wORD SLIT("Word16") [] [word16DataCon] + where + word16DataCon = pcDataCon word16DataConKey wORD SLIT("W16#") [] [] [wordPrimTy] word16TyCon + +word32TyCon = pcNonRecDataTyCon word32TyConKey wORD SLIT("Word32") [] [word32DataCon] + where + word32DataCon = pcDataCon word32DataConKey wORD SLIT("W32#") [] [] [wordPrimTy] word32TyCon + +word64TyCon = pcNonRecDataTyCon word64TyConKey pREL_ADDR SLIT("Word64") [] [word64DataCon] + where + word64DataCon = pcDataCon word64DataConKey pREL_ADDR SLIT("W64#") [] [] [word64PrimTy] word64TyCon \end{code} \begin{code} @@ -245,6 +346,13 @@ addrTy = mkTyConTy addrTyCon addrTyCon = pcNonRecDataTyCon addrTyConKey pREL_ADDR SLIT("Addr") [] [addrDataCon] addrDataCon = pcDataCon addrDataConKey pREL_ADDR SLIT("A#") [] [] [addrPrimTy] addrTyCon + +isAddrTy :: Type -> Bool +isAddrTy ty + = case (splitAlgTyConApp_maybe ty) of + Just (tycon, [], _) -> getUnique tycon == addrTyConKey + _ -> False + \end{code} \begin{code} @@ -252,11 +360,24 @@ floatTy = mkTyConTy floatTyCon floatTyCon = pcNonRecDataTyCon floatTyConKey pREL_BASE SLIT("Float") [] [floatDataCon] floatDataCon = pcDataCon floatDataConKey pREL_BASE SLIT("F#") [] [] [floatPrimTy] floatTyCon + +isFloatTy :: Type -> Bool +isFloatTy ty + = case (splitAlgTyConApp_maybe ty) of + Just (tycon, [], _) -> getUnique tycon == floatTyConKey + _ -> False + \end{code} \begin{code} doubleTy = mkTyConTy doubleTyCon +isDoubleTy :: Type -> Bool +isDoubleTy ty + = case (splitAlgTyConApp_maybe ty) of + Just (tycon, [], _) -> getUnique tycon == doubleTyConKey + _ -> False + doubleTyCon = pcNonRecDataTyCon doubleTyConKey pREL_BASE SLIT("Double") [] [doubleDataCon] doubleDataCon = pcDataCon doubleDataConKey pREL_BASE SLIT("D#") [] [] [doublePrimTy] doubleTyCon \end{code} @@ -283,11 +404,11 @@ stablePtrTyCon \begin{code} foreignObjTyCon - = pcNonRecDataTyCon foreignObjTyConKey pREL_FOREIGN SLIT("ForeignObj") + = pcNonRecDataTyCon foreignObjTyConKey pREL_IO_BASE SLIT("ForeignObj") [] [foreignObjDataCon] where foreignObjDataCon - = pcDataCon foreignObjDataConKey pREL_FOREIGN SLIT("ForeignObj") + = pcDataCon foreignObjDataConKey pREL_IO_BASE SLIT("ForeignObj") [] [] [foreignObjPrimTy] foreignObjTyCon \end{code} @@ -299,236 +420,83 @@ foreignObjTyCon @Integer@ and its pals are not really primitive. @Integer@ itself, first: \begin{code} -integerTy :: GenType t -integerTy = mkTyConTy integerTyCon +integerTy :: Type +integerTy = mkTyConTy integerTyCon integerTyCon = pcNonRecDataTyCon integerTyConKey pREL_BASE SLIT("Integer") [] [integerDataCon] integerDataCon = pcDataCon integerDataConKey pREL_BASE SLIT("J#") [] [] [intPrimTy, intPrimTy, byteArrayPrimTy] integerTyCon -isIntegerTy :: GenType flexi -> Bool +isIntegerTy :: Type -> Bool isIntegerTy ty = case (splitAlgTyConApp_maybe ty) of - Just (tycon, [], _) -> uniqueOf tycon == integerTyConKey + Just (tycon, [], _) -> getUnique tycon == integerTyConKey _ -> False \end{code} -And the other pairing types: -\begin{code} -return2GMPsTyCon = pcNonRecDataTyCon return2GMPsTyConKey - pREL_NUM SLIT("Return2GMPs") [] [return2GMPsDataCon] - -return2GMPsDataCon - = pcDataCon return2GMPsDataConKey pREL_NUM SLIT("Return2GMPs") [] [] - [intPrimTy, intPrimTy, byteArrayPrimTy, - intPrimTy, intPrimTy, byteArrayPrimTy] return2GMPsTyCon - -returnIntAndGMPTyCon = pcNonRecDataTyCon returnIntAndGMPTyConKey - pREL_NUM SLIT("ReturnIntAndGMP") [] [returnIntAndGMPDataCon] - -returnIntAndGMPDataCon - = pcDataCon returnIntAndGMPDataConKey pREL_NUM SLIT("ReturnIntAndGMP") [] [] - [intPrimTy, intPrimTy, intPrimTy, byteArrayPrimTy] returnIntAndGMPTyCon -\end{code} %************************************************************************ %* * -\subsection[TysWiredIn-state-pairing]{``State-pairing'' types} +\subsection[TysWiredIn-ext-type]{External types} %* * %************************************************************************ -These boring types pair a \tr{State#} with another primitive type. -They are not really primitive, so they are given here, not in -\tr{TysPrim.lhs}. - -We fish one of these \tr{StateAnd#} things with -@getStatePairingConInfo@ (given a little way down). +The compiler's foreign function interface supports the passing of a +restricted set of types as arguments and results (the restricting factor +being the ) \begin{code} -stateAndPtrPrimTyCon - = pcNonRecDataTyCon stateAndPtrPrimTyConKey pREL_ST SLIT("StateAndPtr#") - alpha_beta_tyvars [stateAndPtrPrimDataCon] -stateAndPtrPrimDataCon - = pcDataCon stateAndPtrPrimDataConKey pREL_ST SLIT("StateAndPtr#") - alpha_beta_tyvars [] [mkStatePrimTy alphaTy, betaTy] - stateAndPtrPrimTyCon - -stateAndCharPrimTyCon - = pcNonRecDataTyCon stateAndCharPrimTyConKey pREL_ST SLIT("StateAndChar#") - alpha_tyvar [stateAndCharPrimDataCon] -stateAndCharPrimDataCon - = pcDataCon stateAndCharPrimDataConKey pREL_ST SLIT("StateAndChar#") - alpha_tyvar [] [mkStatePrimTy alphaTy, charPrimTy] - stateAndCharPrimTyCon - -stateAndIntPrimTyCon - = pcNonRecDataTyCon stateAndIntPrimTyConKey pREL_ST SLIT("StateAndInt#") - alpha_tyvar [stateAndIntPrimDataCon] -stateAndIntPrimDataCon - = pcDataCon stateAndIntPrimDataConKey pREL_ST SLIT("StateAndInt#") - alpha_tyvar [] [mkStatePrimTy alphaTy, intPrimTy] - stateAndIntPrimTyCon - -stateAndWordPrimTyCon - = pcNonRecDataTyCon stateAndWordPrimTyConKey pREL_ST SLIT("StateAndWord#") - alpha_tyvar [stateAndWordPrimDataCon] -stateAndWordPrimDataCon - = pcDataCon stateAndWordPrimDataConKey pREL_ST SLIT("StateAndWord#") - alpha_tyvar [] [mkStatePrimTy alphaTy, wordPrimTy] - stateAndWordPrimTyCon - -stateAndAddrPrimTyCon - = pcNonRecDataTyCon stateAndAddrPrimTyConKey pREL_ST SLIT("StateAndAddr#") - alpha_tyvar [stateAndAddrPrimDataCon] -stateAndAddrPrimDataCon - = pcDataCon stateAndAddrPrimDataConKey pREL_ST SLIT("StateAndAddr#") - alpha_tyvar [] [mkStatePrimTy alphaTy, addrPrimTy] - stateAndAddrPrimTyCon - -stateAndStablePtrPrimTyCon - = pcNonRecDataTyCon stateAndStablePtrPrimTyConKey pREL_FOREIGN SLIT("StateAndStablePtr#") - alpha_beta_tyvars [stateAndStablePtrPrimDataCon] -stateAndStablePtrPrimDataCon - = pcDataCon stateAndStablePtrPrimDataConKey pREL_FOREIGN SLIT("StateAndStablePtr#") - alpha_beta_tyvars [] - [mkStatePrimTy alphaTy, mkTyConApp stablePtrPrimTyCon [betaTy]] - stateAndStablePtrPrimTyCon - -stateAndForeignObjPrimTyCon - = pcNonRecDataTyCon stateAndForeignObjPrimTyConKey pREL_FOREIGN SLIT("StateAndForeignObj#") - alpha_tyvar [stateAndForeignObjPrimDataCon] -stateAndForeignObjPrimDataCon - = pcDataCon stateAndForeignObjPrimDataConKey pREL_FOREIGN SLIT("StateAndForeignObj#") - alpha_tyvar [] - [mkStatePrimTy alphaTy, mkTyConTy foreignObjPrimTyCon] - stateAndForeignObjPrimTyCon - -stateAndFloatPrimTyCon - = pcNonRecDataTyCon stateAndFloatPrimTyConKey pREL_ST SLIT("StateAndFloat#") - alpha_tyvar [stateAndFloatPrimDataCon] -stateAndFloatPrimDataCon - = pcDataCon stateAndFloatPrimDataConKey pREL_ST SLIT("StateAndFloat#") - alpha_tyvar [] [mkStatePrimTy alphaTy, floatPrimTy] - stateAndFloatPrimTyCon - -stateAndDoublePrimTyCon - = pcNonRecDataTyCon stateAndDoublePrimTyConKey pREL_ST SLIT("StateAndDouble#") - alpha_tyvar [stateAndDoublePrimDataCon] -stateAndDoublePrimDataCon - = pcDataCon stateAndDoublePrimDataConKey pREL_ST SLIT("StateAndDouble#") - alpha_tyvar [] [mkStatePrimTy alphaTy, doublePrimTy] - stateAndDoublePrimTyCon -\end{code} - -\begin{code} -stateAndArrayPrimTyCon - = pcNonRecDataTyCon stateAndArrayPrimTyConKey pREL_ARR SLIT("StateAndArray#") - alpha_beta_tyvars [stateAndArrayPrimDataCon] -stateAndArrayPrimDataCon - = pcDataCon stateAndArrayPrimDataConKey pREL_ARR SLIT("StateAndArray#") - alpha_beta_tyvars [] [mkStatePrimTy alphaTy, mkArrayPrimTy betaTy] - stateAndArrayPrimTyCon - -stateAndMutableArrayPrimTyCon - = pcNonRecDataTyCon stateAndMutableArrayPrimTyConKey pREL_ARR SLIT("StateAndMutableArray#") - alpha_beta_tyvars [stateAndMutableArrayPrimDataCon] -stateAndMutableArrayPrimDataCon - = pcDataCon stateAndMutableArrayPrimDataConKey pREL_ARR SLIT("StateAndMutableArray#") - alpha_beta_tyvars [] [mkStatePrimTy alphaTy, mkMutableArrayPrimTy alphaTy betaTy] - stateAndMutableArrayPrimTyCon - -stateAndByteArrayPrimTyCon - = pcNonRecDataTyCon stateAndByteArrayPrimTyConKey pREL_ARR SLIT("StateAndByteArray#") - alpha_tyvar [stateAndByteArrayPrimDataCon] -stateAndByteArrayPrimDataCon - = pcDataCon stateAndByteArrayPrimDataConKey pREL_ARR SLIT("StateAndByteArray#") - alpha_tyvar [] [mkStatePrimTy alphaTy, byteArrayPrimTy] - stateAndByteArrayPrimTyCon - -stateAndMutableByteArrayPrimTyCon - = pcNonRecDataTyCon stateAndMutableByteArrayPrimTyConKey pREL_ARR SLIT("StateAndMutableByteArray#") - alpha_tyvar [stateAndMutableByteArrayPrimDataCon] -stateAndMutableByteArrayPrimDataCon - = pcDataCon stateAndMutableByteArrayPrimDataConKey pREL_ARR SLIT("StateAndMutableByteArray#") - alpha_tyvar [] [mkStatePrimTy alphaTy, mkTyConApp mutableByteArrayPrimTyCon alpha_ty] - stateAndMutableByteArrayPrimTyCon - -stateAndSynchVarPrimTyCon - = pcNonRecDataTyCon stateAndSynchVarPrimTyConKey pREL_CONC SLIT("StateAndSynchVar#") - alpha_beta_tyvars [stateAndSynchVarPrimDataCon] -stateAndSynchVarPrimDataCon - = pcDataCon stateAndSynchVarPrimDataConKey pREL_CONC SLIT("StateAndSynchVar#") - alpha_beta_tyvars [] [mkStatePrimTy alphaTy, mkSynchVarPrimTy alphaTy betaTy] - stateAndSynchVarPrimTyCon -\end{code} - -The ccall-desugaring mechanism uses this function to figure out how to -rebox the result. It's really a HACK, especially the part about -how many types to drop from \tr{tys_applied}. - -\begin{code} -getStatePairingConInfo - :: Type -- primitive type - -> (Id, -- state pair constructor for prim type - Type) -- type of state pair - -getStatePairingConInfo prim_ty - = case (splitTyConApp_maybe prim_ty) of - Nothing -> panic "getStatePairingConInfo:1" - Just (prim_tycon, tys_applied) -> +isFFIArgumentTy :: Type -> Bool +isFFIArgumentTy ty = + (opt_GlasgowExts && isUnLiftedType ty) || --leave out for now: maybeToBool (maybeBoxedPrimType ty))) || + case (splitAlgTyConApp_maybe ty) of + Just (tycon, _, _) -> (getUnique tycon) `elem` primArgTyConKeys + _ -> False + +-- types that can be passed as arguments to "foreign" functions +primArgTyConKeys + = [ intTyConKey, int8TyConKey, int16TyConKey, int32TyConKey, int64TyConKey + , wordTyConKey, word8TyConKey, word16TyConKey, word32TyConKey, word64TyConKey + , floatTyConKey, doubleTyConKey + , addrTyConKey, charTyConKey, foreignObjTyConKey + , stablePtrTyConKey, byteArrayTyConKey, mutableByteArrayTyConKey + ] + +-- types that can be passed from the outside world into Haskell. +-- excludes (mutable) byteArrays. +isFFIExternalTy :: Type -> Bool +isFFIExternalTy ty = + (opt_GlasgowExts && isUnLiftedType ty) || --leave out for now: maybeToBool (maybeBoxedPrimType ty))) || + case (splitAlgTyConApp_maybe ty) of + Just (tycon, _, _) -> + let + u_tycon = getUnique tycon + in + (u_tycon `elem` primArgTyConKeys) && + not (u_tycon `elem` notLegalExternalTyCons) + _ -> False + + +isFFIResultTy :: Type -> Bool +isFFIResultTy ty = + not (isUnLiftedType ty) && + case (splitAlgTyConApp_maybe ty) of + Just (tycon, _, _) -> let - (pair_con, pair_tycon, num_tys) = assoc "getStatePairingConInfo" tbl prim_tycon - pair_ty = mkTyConApp pair_tycon (realWorldTy : drop num_tys tys_applied) + u_tycon = getUnique tycon in - (pair_con, pair_ty) - where - tbl = [ - (charPrimTyCon, (stateAndCharPrimDataCon, stateAndCharPrimTyCon, 0)), - (intPrimTyCon, (stateAndIntPrimDataCon, stateAndIntPrimTyCon, 0)), - (wordPrimTyCon, (stateAndWordPrimDataCon, stateAndWordPrimTyCon, 0)), - (addrPrimTyCon, (stateAndAddrPrimDataCon, stateAndAddrPrimTyCon, 0)), - (stablePtrPrimTyCon, (stateAndStablePtrPrimDataCon, stateAndStablePtrPrimTyCon, 0)), - (foreignObjPrimTyCon, (stateAndForeignObjPrimDataCon, stateAndForeignObjPrimTyCon, 0)), - (floatPrimTyCon, (stateAndFloatPrimDataCon, stateAndFloatPrimTyCon, 0)), - (doublePrimTyCon, (stateAndDoublePrimDataCon, stateAndDoublePrimTyCon, 0)), - (arrayPrimTyCon, (stateAndArrayPrimDataCon, stateAndArrayPrimTyCon, 0)), - (mutableArrayPrimTyCon, (stateAndMutableArrayPrimDataCon, stateAndMutableArrayPrimTyCon, 1)), - (byteArrayPrimTyCon, (stateAndByteArrayPrimDataCon, stateAndByteArrayPrimTyCon, 0)), - (mutableByteArrayPrimTyCon, (stateAndMutableByteArrayPrimDataCon, stateAndMutableByteArrayPrimTyCon, 1)), - (synchVarPrimTyCon, (stateAndSynchVarPrimDataCon, stateAndSynchVarPrimTyCon, 1)) - -- (PtrPrimTyCon, (stateAndPtrPrimDataCon, stateAndPtrPrimTyCon, 0)), - ] -\end{code} - -%************************************************************************ -%* * -\subsection[TysWiredIn-ST]{The basic @_ST@ state-transformer type} -%* * -%************************************************************************ - -The only reason this is wired in is because we have to represent the -type of runST. - -\begin{code} -mkStateTransformerTy s a = mkTyConApp stTyCon [s, a] - -stTyCon = pcNonRecNewTyCon stTyConKey pREL_ST SLIT("ST") alpha_beta_tyvars [stDataCon] - -stDataCon = pcDataCon stDataConKey pREL_ST SLIT("ST") - alpha_beta_tyvars [] [ty] stTyCon - where - ty = mkFunTy (mkStatePrimTy alphaTy) (mkSTretTy alphaTy betaTy) - -mkSTretTy alpha beta = mkTyConApp stRetTyCon [alpha,beta] - -stRetTyCon - = pcNonRecDataTyCon stRetTyConKey pREL_ST SLIT("STret") - alpha_beta_tyvars [stRetDataCon] -stRetDataCon - = pcDataCon stRetDataConKey pREL_ST SLIT("STret") - alpha_beta_tyvars [] [mkStatePrimTy alphaTy, betaTy] - stRetTyCon + (u_tycon == getUnique unitTyCon) || + ((u_tycon `elem` primArgTyConKeys) && + not (u_tycon `elem` notLegalExternalTyCons)) + _ -> False + +-- it's illegal to return foreign objects and (mutable) +-- bytearrays from a _ccall_ / foreign declaration +-- (or be passed them as arguments in foreign exported functions). +notLegalExternalTyCons = + [ foreignObjTyConKey, byteArrayTyConKey, mutableByteArrayTyConKey ] + \end{code} %************************************************************************ @@ -582,7 +550,8 @@ primitive counterpart. \begin{code} boolTy = mkTyConTy boolTyCon -boolTyCon = pcNonRecDataTyCon boolTyConKey pREL_BASE SLIT("Bool") [] [falseDataCon, trueDataCon] +boolTyCon = pcTyCon EnumType NonRecursive boolTyConKey + pREL_BASE SLIT("Bool") [] [falseDataCon, trueDataCon] falseDataCon = pcDataCon falseDataConKey pREL_BASE SLIT("False") [] [] [] boolTyCon trueDataCon = pcDataCon trueDataConKey pREL_BASE SLIT("True") [] [] [] boolTyCon @@ -604,7 +573,7 @@ data (,) a b = (,,) a b \end{verbatim} \begin{code} -mkListTy :: GenType t -> GenType t +mkListTy :: Type -> Type mkListTy ty = mkTyConApp listTyCon [ty] alphaListTy = mkSigmaTy alpha_tyvar [] (mkTyConApp listTyCon alpha_ty) @@ -667,47 +636,11 @@ done by enumeration\srcloc{lib/prelude/InTup?.hs}. \end{itemize} \begin{code} -mkTupleTy :: Int -> [GenType t] -> GenType t - +mkTupleTy :: Int -> [Type] -> Type mkTupleTy arity tys = mkTyConApp (tupleTyCon arity) tys -unitTy = mkTupleTy 0 [] -\end{code} - -%************************************************************************ -%* * -\subsection[TysWiredIn-_Lift]{@_Lift@ type: to support array indexing} -%* * -%************************************************************************ - -Again, deeply turgid: \tr{data _Lift a = _Lift a}. - -\begin{code} -mkLiftTy ty = mkTyConApp liftTyCon [ty] - -{- -mkLiftTy ty - = mkSigmaTy tvs theta (mkTyConApp liftTyCon [tau]) - where - (tvs, theta, tau) = splitSigmaTy ty - -isLiftTy ty - = case (splitAlgTyConApp_maybeExpandingDicts tau) of - Just (tycon, tys, _) -> tycon == liftTyCon - Nothing -> False - where - (tvs, theta, tau) = splitSigmaTy ty --} - - -alphaLiftTy = mkSigmaTy alpha_tyvar [] (mkTyConApp liftTyCon alpha_ty) +mkUnboxedTupleTy :: Int -> [Type] -> Type +mkUnboxedTupleTy arity tys = mkTyConApp (unboxedTupleTyCon arity) tys -liftTyCon - = pcNonRecDataTyCon liftTyConKey pREL_BASE SLIT("Lift") alpha_tyvar [liftDataCon] - -liftDataCon - = pcDataCon liftDataConKey pREL_BASE SLIT("Lift") - alpha_tyvar [] alpha_ty liftTyCon - where - bottom = panic "liftDataCon:State# _RealWorld" +unitTy = mkTupleTy 0 [] \end{code}