From 3c44399ab0bdd16bd11db8a6eb21dd9944843665 Mon Sep 17 00:00:00 2001 From: sof Date: Fri, 14 Mar 1997 05:24:02 +0000 Subject: [PATCH] [project @ 1997-03-14 05:24:00 by sof] New interfaces --- ghc/lib/glaExts/ByteArray.lhs | 39 ++++++++++++++++++++++++ ghc/lib/glaExts/GlaExts.lhs | 60 ++++++++++++++++++++++++++++++++++++ ghc/lib/glaExts/MutVar.lhs | 44 +++++++++++++++++++++++++++ ghc/lib/glaExts/MutableArray.lhs | 62 ++++++++++++++++++++++++++++++++++++++ 4 files changed, 205 insertions(+) create mode 100644 ghc/lib/glaExts/ByteArray.lhs create mode 100644 ghc/lib/glaExts/GlaExts.lhs create mode 100644 ghc/lib/glaExts/MutVar.lhs create mode 100644 ghc/lib/glaExts/MutableArray.lhs diff --git a/ghc/lib/glaExts/ByteArray.lhs b/ghc/lib/glaExts/ByteArray.lhs new file mode 100644 index 0000000..2ea73c2 --- /dev/null +++ b/ghc/lib/glaExts/ByteArray.lhs @@ -0,0 +1,39 @@ +% +% (c) The AQUA Project, Glasgow University, 1994-1997 +% +\section[ByteArray]{The @ByteArray@ interface} + +Immutable, read-only chunks of bytes, the @ByteArray@ collects +together the definitions in @ArrBase@ and exports them as one. + +\begin{code} +module ByteArray + ( + ByteArray(..), -- not abstract, for now. + Ix, + + --Indexing of ordinary @Arrays@ is standard Haskell and isn't defined here. + indexCharArray, --:: Ix ix => ByteArray ix -> ix -> Char + indexIntArray, --:: Ix ix => ByteArray ix -> ix -> Int + indexAddrArray, --:: Ix ix => ByteArray ix -> ix -> Addr + indexFloatArray, --:: Ix ix => ByteArray ix -> ix -> Float + indexDoubleArray, --:: Ix ix => ByteArray ix -> ix -> Double + + --Indexing off @Addrs@ is similar, and therefore given here. + indexCharOffAddr, --:: Addr -> Int -> Char + indexIntOffAddr, --:: Addr -> Int -> Int + indexAddrOffAddr, --:: Addr -> Int -> Addr + indexFloatOffAddr, --:: Addr -> Int -> Float + indexDoubleOffAddr, --:: Addr -> Int -> Double + + Addr, + Word + + ) where + +import ArrBase +import Ix +import PrelBase (Addr, Word) + +\end{code} + diff --git a/ghc/lib/glaExts/GlaExts.lhs b/ghc/lib/glaExts/GlaExts.lhs new file mode 100644 index 0000000..1a55b91 --- /dev/null +++ b/ghc/lib/glaExts/GlaExts.lhs @@ -0,0 +1,60 @@ +% +% (c) The AQUA Project, Glasgow University, 1994-1996 +% +\section[GlaExts]{The @GlaExts@ interface} + +The @GlaExts@ packages up various Glasgow extensions and +exports them all through one interface. The Idea being that +a Haskell program using a Glasgow extension doesn't have to +selective import of obscure/likely-to-move (believe me, we +really like to move functions around for the prelude bits!) +GHC interfaces - instead import the GlaExts rag bag and you should be away! + +\begin{code} +module GlaExts + + ( + -- From module STBase, the PrimIO monad + -- (an instance of ST): + PrimIO, + ST, RealWorld, + module Monad, -- ST is an instance + fixPrimIO, unsafePerformPrimIO, unsafeInterleavePrimIO, + returnPrimIO, thenPrimIO, seqPrimIO, + + listPrimIO, mapPrimIO, mapAndUnzipPrimIO, + + -- operations for interfacing IO and ST/PrimIO + -- + stToIO, --:: ST RealWorld a -> IO a + primIOToIO, --:: PrimIO a -> IO a + ioToST, --:: IO a -> ST RealWorld a + ioToPrimIO, --:: IO a -> PrimIO a + thenIO_Prim, -- :: PrimIO a -> (a -> IO b) -> IO b + + -- Everything from module ByteArray: + module ByteArray, + + -- Same for Mutable(Byte)Array interface: + module MutableArray, + + -- the representation of some basic types: + Int(..),Addr(..),Word(..),Float(..),Double(..),Integer(..), + + -- misc bits + trace, + + -- and finally, all the unboxed primops of GHC! + module GHC + + ) where + +import GHC +import STBase +import PrelBase +import ByteArray +import MutableArray +import Monad +import IOBase + +\end{code} diff --git a/ghc/lib/glaExts/MutVar.lhs b/ghc/lib/glaExts/MutVar.lhs new file mode 100644 index 0000000..e3778e9 --- /dev/null +++ b/ghc/lib/glaExts/MutVar.lhs @@ -0,0 +1,44 @@ +% +% (c) The AQUA Project, Glasgow University, 1994-1996 +% +\section[MutVar]{Mutable variables} + +Mutable variables, for the @IO@ monad. + +\begin{code} +module MutVar + + ( + MutVar, -- abstract + + newVar, -- :: a -> IO (MutVar a) + readVar, -- :: MutVar a -> IO a + writeVar, -- :: MutVar a -> a -> IO () + sameVar -- :: MutVar a -> MutVar a -> Bool + + ) where + +import qualified ST +import qualified ArrBase +import IOBase ( IO , stToIO ) +import GHC (RealWorld) + +\end{code} + +\begin{code} + +newtype MutVar a = MutVar (ArrBase.MutableVar RealWorld a) + +newVar :: a -> IO (MutVar a) +newVar v = stToIO (ST.newVar v) >>= \ var -> return (MutVar var) + +readVar :: MutVar a -> IO a +readVar (MutVar var) = stToIO (ST.readVar var) + +writeVar :: MutVar a -> a -> IO () +writeVar (MutVar var) v = stToIO (ST.writeVar var v) + +sameVar :: MutVar a -> MutVar a -> Bool +sameVar (MutVar var1) (MutVar var2) = ST.sameVar var1 var2 + +\end{code} diff --git a/ghc/lib/glaExts/MutableArray.lhs b/ghc/lib/glaExts/MutableArray.lhs new file mode 100644 index 0000000..eead4b6 --- /dev/null +++ b/ghc/lib/glaExts/MutableArray.lhs @@ -0,0 +1,62 @@ +% +% (c) The AQUA Project, Glasgow University, 1997 +% +\section[MutableArray]{The @MutableArray@ interface} + +Mutable (byte)arrays interface, re-exports type types and operations +over them from @ArrBase@. Have to be used in conjunction with +@ST@. + +\begin{code} +module MutableArray + ( + MutableArray(..), -- not abstract + MutableByteArray(..), + + ST, + Ix, + + -- Creators: + newArray, -- :: Ix ix => (ix,ix) -> elt -> ST s (MutableArray s ix elt) + newCharArray, + newAddrArray, + newIntArray, + newFloatArray, + newDoubleArray, -- :: Ix ix => (ix,ix) -> ST s (MutableByteArray s ix) + + boundsOfArray, -- :: Ix ix => MutableArray s ix elt -> (ix, ix) + boundsOfByteArray, -- :: Ix ix => MutableByteArray s ix -> (ix, ix) + + readArray, -- :: Ix ix => MutableArray s ix elt -> ix -> ST s elt + + readCharArray, -- :: Ix ix => MutableByteArray s ix -> ix -> ST s Char + readIntArray, -- :: Ix ix => MutableByteArray s ix -> ix -> ST s Int + readAddrArray, -- :: Ix ix => MutableByteArray s ix -> ix -> ST s Addr + readFloatArray, -- :: Ix ix => MutableByteArray s ix -> ix -> ST s Float + readDoubleArray, -- :: Ix ix => MutableByteArray s ix -> ix -> ST s Double + + writeArray, -- :: Ix ix => MutableArray s ix elt -> ix -> elt -> ST s () + writeCharArray, -- :: Ix ix => MutableByteArray s ix -> ix -> Char -> ST s () + writeIntArray, -- :: Ix ix => MutableByteArray s ix -> ix -> Int -> ST s () + writeAddrArray, -- :: Ix ix => MutableByteArray s ix -> ix -> Addr -> ST s () + writeFloatArray, -- :: Ix ix => MutableByteArray s ix -> ix -> Float -> ST s () + writeDoubleArray, -- :: Ix ix => MutableByteArray s ix -> ix -> Double -> ST s () + + freezeArray, -- :: Ix ix => MutableArray s ix elt -> ST s (Array ix elt) + freezeCharArray, -- :: Ix ix => MutableByteArray s ix -> ST s (ByteArray ix) + freezeIntArray, -- :: Ix ix => MutableByteArray s ix -> ST s (ByteArray ix) + freezeAddrArray, -- :: Ix ix => MutableByteArray s ix -> ST s (ByteArray ix) + freezeFloatArray, -- :: Ix ix => MutableByteArray s ix -> ST s (ByteArray ix) + freezeDoubleArray, -- :: Ix ix => MutableByteArray s ix -> ST s (ByteArray ix) + + unsafeFreezeArray, -- :: Ix ix => MutableArray s ix elt -> ST s (Array ix elt) + unsafeFreezeByteArray, -- :: Ix ix => MutableByteArray s ix -> ST s (ByteArray ix) + thawArray -- :: Ix ix => Array ix elt -> ST s (MutableArray s ix elt) + + ) where + +import ArrBase +import ST +import Ix + +\end{code} -- 1.7.10.4