[project @ 2000-12-12 12:19:57 by simonmar]

[ghc-hetmet.git] / ghc / lib / std / PrelPack.lhs

diff --git a/ghc/lib/std/PrelPack.lhs b/ghc/lib/std/PrelPack.lhs
index f126c56..5359012 100644 (file)
--- a/ghc/lib/std/PrelPack.lhs
+++ b/ghc/lib/std/PrelPack.lhs
@@ -1,6 +1,9 @@
+% ------------------------------------------------------------------------------
+% $Id: PrelPack.lhs,v 1.15 2000/12/12 12:19:58 simonmar Exp $
 %
-% (c) The GRASP/AQUA Project, Glasgow University, 1997
+% (c) The University of Glasgow, 1997-2000
 %
+
 \section[PrelPack]{Packing/unpacking bytes}
 
 This module provides a small set of low-level functions for packing
@@ -51,7 +54,8 @@ import PrelBase
 import {-# SOURCE #-} PrelErr ( error )
 import PrelList ( length )
 import PrelST
-import PrelArr
+import PrelNum
+import PrelByteArr
 import PrelAddr
 
 \end{code}
@@ -66,11 +70,14 @@ Primitives for converting Addrs pointing to external
 sequence of bytes into a list of @Char@s:
 
 \begin{code}
-unpackCString  :: Addr{- ptr. to NUL terminated string-} -> [Char]
+unpackCString :: Addr -> [Char]
 unpackCString a@(A# addr)
   | a == nullAddr  = []
   | otherwise     = unpackCString# addr
      
+unpackNBytes :: Addr -> Int -> [Char]
+unpackNBytes (A# addr) (I# l) = unpackNBytes# addr l
+
 unpackCStringST  :: Addr{- ptr. to NUL terminated string-} -> ST s [Char]
 unpackCStringST a@(A# addr)
   | a == nullAddr  = return []
@@ -84,37 +91,12 @@ unpackCStringST a@(A# addr)
       where
        ch = indexCharOffAddr# addr nh
 
-unpackCString# :: Addr#  -> [Char]
-unpackCString# addr 
-  = unpack 0#
-  where
-    unpack nh
-      | ch `eqChar#` '\0'# = []
-      | otherwise         = C# ch : unpack (nh +# 1#)
-      where
-       ch = indexCharOffAddr# addr nh
-
-unpackNBytes :: Addr -> Int -> [Char]
-unpackNBytes (A# addr) (I# l) = unpackNBytes# addr l
-
 unpackNBytesST :: Addr -> Int -> ST s [Char]
 unpackNBytesST (A# addr) (I# l) = unpackNBytesAccST# addr l []
 
 unpackNBytesAccST :: Addr -> Int -> [Char] -> ST s [Char]
 unpackNBytesAccST (A# addr) (I# l) rest = unpackNBytesAccST# addr l rest
 
-unpackNBytes#      :: Addr# -> Int#   -> [Char]
-  -- This one is called by the compiler to unpack literal strings with NULs in them; rare.
-  -- It's strict!
-unpackNBytes# _addr 0#   = []
-unpackNBytes#  addr len# = unpack [] (len# -# 1#)
-    where
-     unpack acc i#
-      | i# <# 0#  = acc
-      | otherwise = 
-        case indexCharOffAddr# addr i# of
-           ch -> unpack (C# ch : acc) (i# -# 1#)
-
 unpackNBytesST# :: Addr# -> Int# -> ST s [Char]
 unpackNBytesST# addr# l#   = unpackNBytesAccST# addr# l# []
 
@@ -140,7 +122,7 @@ Converting byte arrays into list of chars:
 
 \begin{code}
 unpackCStringBA :: ByteArray Int -> [Char]
-unpackCStringBA (ByteArray (l@(I# l#),u@(I# u#)) bytes) 
+unpackCStringBA (ByteArray l@(I# l#) u@(I# u#) bytes) 
  | l > u     = []
  | otherwise = unpackCStringBA# bytes (u# -# l# +# 1#)
 
@@ -159,7 +141,7 @@ unpackCStringBA# bytes len
        ch = indexCharArray# bytes nh
 
 unpackNBytesBA :: ByteArray Int -> Int -> [Char]
-unpackNBytesBA (ByteArray (l,u) bytes) i
+unpackNBytesBA (ByteArray l u bytes) i
  = unpackNBytesBA# bytes len#
    where
     len# = case max 0 (min i len) of I# v# -> v#
@@ -189,7 +171,7 @@ Converting a list of chars into a packed @ByteArray@ representation.
 
 \begin{code}
 packCString#        :: [Char]          -> ByteArray#
-packCString# str = case (packString str) of { ByteArray _ bytes -> bytes }
+packCString# str = case (packString str) of { ByteArray _ _ bytes -> bytes }
 
 packString :: [Char] -> ByteArray Int
 packString str = runST (packStringST str)
@@ -230,48 +212,19 @@ write_ps_array    :: MutableByteArray s Int -> Int# -> Char# -> ST s ()
 freeze_ps_array :: MutableByteArray s Int -> Int# -> ST s (ByteArray Int)
 
 new_ps_array size = ST $ \ s ->
-    case (newCharArray# size s)          of { (# s2#, barr# #) ->
-    (# s2#, MutableByteArray bot barr# #) }
+    case (newByteArray# size s)          of { (# s2#, barr# #) ->
+    (# s2#, MutableByteArray bot bot barr# #) }
   where
     bot = error "new_ps_array"
 
-write_ps_array (MutableByteArray _ barr#) n ch = ST $ \ s# ->
+write_ps_array (MutableByteArray _ _ barr#) n ch = ST $ \ s# ->
     case writeCharArray# barr# n ch s# of { s2#   ->
     (# s2#, () #) }
 
 -- same as unsafeFreezeByteArray
-freeze_ps_array (MutableByteArray _ arr#) len# = ST $ \ s# ->
+freeze_ps_array (MutableByteArray _ _ arr#) len# = ST $ \ s# ->
     case unsafeFreezeByteArray# arr# s# of { (# s2#, frozen# #) ->
-    (# s2#, ByteArray (0,I# len#) frozen# #) }
+    (# s2#, ByteArray 0 (I# len#) frozen# #) }
 \end{code}
 
 
-%********************************************************
-%*                                                     *
-\subsection{Misc}
-%*                                                     *
-%********************************************************
-
-The compiler may emit these two
-
-\begin{code}
-unpackAppendCString# :: Addr# -> [Char] -> [Char]
-unpackAppendCString# addr rest
-  = unpack 0#
-  where
-    unpack nh
-      | ch `eqChar#` '\0'# = rest
-      | otherwise         = C# ch : unpack (nh +# 1#)
-      where
-       ch = indexCharOffAddr# addr nh
-
-unpackFoldrCString#  :: Addr# -> (Char  -> a -> a) -> a -> a 
-unpackFoldrCString# addr f z 
-  = unpack 0#
-  where
-    unpack nh
-      | ch `eqChar#` '\0'# = z
-      | otherwise         = C# ch `f` unpack (nh +# 1#)
-      where
-       ch = indexCharOffAddr# addr nh
-\end{code}