-- * Operations on handles
- -- ** Determining the size of a file
+ -- ** Determining and changing the size of a file
hFileSize, -- :: Handle -> IO Integer
+#ifdef __GLASGOW_HASKELL__
+ hSetFileSize, -- :: Handle -> Integer -> IO ()
+#endif
-- ** Detecting the end of input
hGetBufNonBlocking, -- :: Handle -> Ptr a -> Int -> IO Int
#endif
+ -- * Temporary files
+
+#ifdef __GLASGOW_HASKELL__
+ openTempFile,
+ openBinaryTempFile,
+#endif
+
module System.IO.Error,
) where
, hGetContents -- :: Handle -> IO [Char]
, hPutChar -- :: Handle -> Char -> IO ()
, hPutStr -- :: Handle -> [Char] -> IO ()
+ , hPutStrLn -- :: Handle -> [Char] -> IO ()
+ , hPrint -- :: Handle -> [Char] -> IO ()
+ , hReady -- :: Handle -> [Char] -> IO ()
, hIsOpen, hIsClosed -- :: Handle -> IO Bool
, hIsReadable, hIsWritable -- :: Handle -> IO Bool
, hIsSeekable -- :: Handle -> IO Bool
, FilePath -- :: String
)
import NHC.IOExtras (fixIO)
-openBinaryFile = openFile
-hSetBinaryMode _ _ = return ()
#endif
import System.IO.Error (
-- -----------------------------------------------------------------------------
-- Standard IO
-#ifndef __HUGS__
+#ifdef __GLASGOW_HASKELL__
-- | Write a character to the standard output device
-- (same as 'hPutChar' 'stdout').
[x] -> return x
[] -> ioError (userError "Prelude.readIO: no parse")
_ -> ioError (userError "Prelude.readIO: ambiguous parse")
-#endif /* __HUGS__ */
+#endif /* __GLASGOW_HASKELL__ */
+#ifndef __NHC__
-- | Computation 'hReady' @hdl@ indicates whether at least one item is
-- available for input from handle @hdl@.
--
hPrint :: Show a => Handle -> a -> IO ()
hPrint hdl = hPutStrLn hdl . show
+#endif /* !__NHC__ */
-- ---------------------------------------------------------------------------
-- fixIO
-- computation a few times before it notices the loop, which is wrong.
#endif
+#if defined(__NHC__)
+-- Assume a unix platform, where text and binary I/O are identical.
+openBinaryFile = openFile
+hSetBinaryMode _ _ = return ()
+#endif
+
-- $locking
-- Implementations should enforce as far as possible, at least locally to the
-- Haskell process, multiple-reader single-writer locking on files.