[project @ 2003-06-01 17:20:02 by ralf]

[ghc-base.git] / Data / PackedString.hs

diff --git a/Data/PackedString.hs b/Data/PackedString.hs
index f276d14..de4f392 100644 (file)
--- a/Data/PackedString.hs
+++ b/Data/PackedString.hs
@@ -23,9 +23,11 @@ module Data.PackedString (
        packString,  -- :: String -> PackedString
        unpackPS,    -- :: PackedString -> String
 
+#ifndef __NHC__
        -- * I\/O with @PackedString@s  
        hPutPS,      -- :: Handle -> PackedString -> IO ()
        hGetPS,      -- :: Handle -> Int -> IO PackedString
+#endif
 
        -- * List-like manipulation functions
        nilPS,       -- :: PackedString
@@ -53,17 +55,20 @@ module Data.PackedString (
        spanPS,      -- :: (Char -> Bool) -> PackedString -> (PackedString, PackedString)
        breakPS,     -- :: (Char -> Bool) -> PackedString -> (PackedString, PackedString)
        linesPS,     -- :: PackedString -> [PackedString]
-
+       unlinesPS,   -- :: [PackedString] -> PackedString
        wordsPS,     -- :: PackedString -> [PackedString]
+       unwordsPS,   -- :: [PackedString] -> PackedString
        splitPS,     -- :: Char -> PackedString -> [PackedString]
        splitWithPS, -- :: (Char -> Bool) -> PackedString -> [PackedString]
 
---     joinPS,      -- :: PackedString -> [PackedString] -> PackedString
+       joinPS,      -- :: PackedString -> [PackedString] -> PackedString
 
     ) where
 
 import Prelude
 
+#ifndef __NHC__
+
 import Data.Array.Unboxed
 import Data.Array.IO
 import Data.Dynamic
@@ -185,8 +190,14 @@ breakPS p ps = spanPS (not . p) ps
 linesPS :: PackedString -> [PackedString]
 linesPS ps = splitPS '\n' ps
 
+unlinesPS :: [PackedString] -> PackedString
+unlinesPS = joinPS (packString "\n")
+
 wordsPS :: PackedString -> [PackedString]
-wordsPS ps = splitWithPS isSpace ps
+wordsPS ps = filter (not.nullPS) (splitWithPS isSpace ps)
+
+unwordsPS :: [PackedString] -> PackedString
+unwordsPS = joinPS (packString " ")
 
 reversePS :: PackedString -> PackedString
 reversePS ps = packString (reverse (unpackPS ps))
@@ -195,7 +206,7 @@ concatPS :: [PackedString] -> PackedString
 concatPS pss = packString (concat (map unpackPS pss))
 
 ------------------------------------------------------------
-{-
+
 joinPS :: PackedString -> [PackedString] -> PackedString
 joinPS filler pss = concatPS (splice pss)
  where
@@ -209,17 +220,8 @@ joinPS filler pss = concatPS (splice pss)
 
   * splitPS x ls = ls'   
       where False = any (map (x `elemPS`) ls')
-            False = any (map (nullPS) ls')
-
-    * all x's have been chopped out.
-    * no empty PackedStrings in returned list. A conseq.
-      of this is:
-           splitPS x nilPS = []
-         
-
-  * joinPS (packString [x]) (_splitPS x ls) = ls
 
--}
+  * joinPS (packString [x]) (splitPS x ls) = ls
 -}
 
 splitPS :: Char -> PackedString -> [PackedString]
@@ -237,14 +239,15 @@ splitWithPS pred (PS ps) =
       let
        break_pt = first_pos_that_satisfies pred ps len n
       in
-      if break_pt == n then -- immediate match, no substring to cut out.
-         splitify (break_pt + 1)
+      if break_pt == n then -- immediate match, empty substring
+         nilPS
+        : splitify (break_pt + 1)
       else 
          substrPS (PS ps) n (break_pt - 1) -- leave out the matching character
          : splitify (break_pt + 1)
 
 first_pos_that_satisfies pred ps len n = 
-   case [ m | m <- [n..len], pred (ps ! m) ] of
+   case [ m | m <- [n..len-1], pred (ps ! m) ] of
        []    -> len
        (m:_) -> m
 
@@ -260,7 +263,7 @@ substrPS (PS ps) begin end = packString [ ps ! i | i <- [begin..end] ]
 -- -----------------------------------------------------------------------------
 -- hPutPS
 
--- | Outputs a 'PackedString' to the specified 'Handle'.  
+-- | Outputs a 'PackedString' to the specified 'Handle'.
 --
 -- NOTE: the representation of the 'PackedString' in the file is assumed to
 -- be in the ISO-8859-1 encoding.  In other words, only the least signficant
@@ -275,8 +278,8 @@ hPutPS h (PS ps) = do
 -- -----------------------------------------------------------------------------
 -- hGetPS
 
--- | Read a 'PackedString' directly from the specified 'Handle'.  This
--- is far more efficient than reading the characters into a 'String'
+-- | Read a 'PackedString' directly from the specified 'Handle'.
+-- This is far more efficient than reading the characters into a 'String'
 -- and then using 'packString'.  
 --
 -- NOTE: as with 'hPutPS', the string representation in the file is 
@@ -287,3 +290,91 @@ hGetPS h i = do
   l <- hGetArray h arr i
   chars <- mapM (\i -> readArray arr i >>= return.chr.fromIntegral) [0..l-1]
   return (packString chars)
+
+#else  /* __NHC__ */
+
+--import Prelude hiding (append, break, concat, cons, drop, dropWhile,
+--                       filter, foldl, foldr, head, length, lines, map,
+--                       nil, null, reverse, span, splitAt, subst, tail,
+--                       take, takeWhile, unlines, unwords, words)
+-- also hiding: Ix(..), Functor(..)
+import qualified NHC.PackedString
+import NHC.PackedString (PackedString,packString,unpackPS)
+import List (intersperse)
+
+
+nilPS       :: PackedString
+consPS      :: Char -> PackedString -> PackedString
+headPS      :: PackedString -> Char
+tailPS      :: PackedString -> PackedString
+nullPS      :: PackedString -> Bool
+appendPS    :: PackedString -> PackedString -> PackedString
+lengthPS    :: PackedString -> Int
+indexPS     :: PackedString -> Int -> Char
+mapPS       :: (Char -> Char) -> PackedString -> PackedString
+filterPS    :: (Char -> Bool) -> PackedString -> PackedString
+reversePS   :: PackedString -> PackedString
+concatPS    :: [PackedString] -> PackedString
+elemPS      :: Char -> PackedString -> Bool
+substrPS    :: PackedString -> Int -> Int -> PackedString
+takePS      :: Int -> PackedString -> PackedString
+dropPS      :: Int -> PackedString -> PackedString
+splitAtPS   :: Int -> PackedString -> (PackedString, PackedString)
+
+foldlPS     :: (a -> Char -> a) -> a -> PackedString -> a
+foldrPS     :: (Char -> a -> a) -> a -> PackedString -> a
+takeWhilePS :: (Char -> Bool) -> PackedString -> PackedString
+dropWhilePS :: (Char -> Bool) -> PackedString -> PackedString
+spanPS      :: (Char -> Bool) -> PackedString -> (PackedString, PackedString)
+breakPS     :: (Char -> Bool) -> PackedString -> (PackedString, PackedString)
+linesPS     :: PackedString -> [PackedString]
+unlinesPS   :: [PackedString] -> PackedString
+
+wordsPS     :: PackedString -> [PackedString]
+unwordsPS   :: [PackedString] -> PackedString
+splitPS     :: Char -> PackedString -> [PackedString]
+splitWithPS :: (Char -> Bool) -> PackedString -> [PackedString]
+joinPS      :: PackedString -> [PackedString] -> PackedString
+
+nilPS       = NHC.PackedString.nil
+consPS      = NHC.PackedString.cons
+headPS      = NHC.PackedString.head
+tailPS      = NHC.PackedString.tail
+nullPS      = NHC.PackedString.null
+appendPS    = NHC.PackedString.append
+lengthPS    = NHC.PackedString.length
+indexPS p i = (unpackPS p) !! i
+mapPS       = NHC.PackedString.map
+filterPS    = NHC.PackedString.filter
+reversePS   = NHC.PackedString.reverse
+concatPS    = NHC.PackedString.concat
+elemPS c p  = c `elem` unpackPS p
+substrPS    = NHC.PackedString.substr
+takePS      = NHC.PackedString.take
+dropPS      = NHC.PackedString.drop
+splitAtPS   = NHC.PackedString.splitAt
+
+foldlPS     = NHC.PackedString.foldl
+foldrPS     = NHC.PackedString.foldr
+takeWhilePS = NHC.PackedString.takeWhile
+dropWhilePS = NHC.PackedString.dropWhile
+spanPS      = NHC.PackedString.span
+breakPS     = NHC.PackedString.break
+linesPS     = NHC.PackedString.lines
+unlinesPS   = NHC.PackedString.unlines
+
+wordsPS     = NHC.PackedString.words
+unwordsPS   = NHC.PackedString.unwords
+splitPS c   = splitWithPS (==c)
+splitWithPS p =
+    map packString . split' p [] . unpackPS
+  where
+    split' :: (Char->Bool) -> String -> String -> [String]
+    split' pred []  []     = []
+    split' pred acc []     = [reverse acc]
+    split' pred acc (x:xs) | pred x    = reverse acc: split' pred [] xs
+                           | otherwise = split' pred (x:acc) xs
+
+joinPS sep  = concatPS . intersperse sep
+
+#endif