add install-includes: field
[packages/pretty.git] / GHC / Unicode.hs
index 5b7d47b..0c0cc12 100644 (file)
@@ -1,7 +1,8 @@
 {-# OPTIONS -fno-implicit-prelude #-}
+{-# OPTIONS -#include "WCsubst.h" #-}
 -----------------------------------------------------------------------------
 -- |
--- Module      :  GHC.Unicde
+-- Module      :  GHC.Unicode
 -- Copyright   :  (c) The University of Glasgow, 2003
 -- License     :  see libraries/base/LICENSE
 -- 
 --
 -----------------------------------------------------------------------------
 
+-- #hide
 module GHC.Unicode (
     isAscii, isLatin1, isControl,
     isAsciiUpper, isAsciiLower,
     isPrint, isSpace,  isUpper,
     isLower, isAlpha,  isDigit,
     isOctDigit, isHexDigit, isAlphaNum,
-    toUpper, toLower,
+    toUpper, toLower, toTitle,
+    wgencat,
   ) where
 
 import GHC.Base
@@ -30,7 +33,7 @@ import GHC.Int
 import GHC.Word
 import GHC.Num  (fromInteger)
 
-#include "ghcconfig.h"
+#include "HsBaseConfig.h"
 
 -- | Selects the first 128 characters of the Unicode character set,
 -- corresponding to the ASCII character set.
@@ -42,8 +45,14 @@ isAscii c            =  c <  '\x80'
 isLatin1                :: Char -> Bool
 isLatin1 c              =  c <= '\xff'
 
-isAsciiUpper, isAsciiLower :: Char -> Bool
+-- | Selects ASCII lower-case letters,
+-- i.e. characters satisfying both 'isAscii' and 'isLower'.
+isAsciiLower :: Char -> Bool
 isAsciiLower c          =  c >= 'a' && c <= 'z'
+
+-- | Selects ASCII upper-case letters,
+-- i.e. characters satisfying both 'isAscii' and 'isUpper'.
+isAsciiUpper :: Char -> Bool
 isAsciiUpper c          =  c >= 'A' && c <= 'Z'
 
 -- | Selects control characters, which are the non-printing characters of
@@ -66,26 +75,20 @@ isSpace c           =  c == ' '     ||
                           c == '\r'    ||
                           c == '\f'    ||
                           c == '\v'    ||
-                          c == '\xa0'
+                          c == '\xa0'  ||
+                          iswspace (fromIntegral (ord c)) /= 0
 
--- | Selects alphabetic Unicode characters (letters) that are not lower-case.
--- (In Unicode terms, this includes letters in upper and title cases,
--- as well as modifier letters and other letters.)
+-- | Selects upper-case or title-case alphabetic Unicode characters (letters).
+-- Title case is used by a small number of letter ligatures like the
+-- single-character form of /Lj/.
 isUpper                 :: Char -> Bool
 
 -- | Selects lower-case alphabetic Unicode characters (letters).
 isLower                 :: Char -> Bool
 
--- | Selects alphabetic Unicode characters (letters).
---
--- Note: the Haskell 98 definition of 'isAlpha' is:
---
--- >   isAlpha c = isUpper c || isLower c
---
--- the implementation here diverges from the Haskell 98
--- definition in the sense that Unicode alphabetic characters which
--- are neither upper nor lower case will still be identified as
--- alphabetic by 'isAlpha'.
+-- | Selects alphabetic Unicode characters (lower-case, upper-case and
+-- title-case letters, plus letters of caseless scripts and modifiers letters).
+-- This function is equivalent to 'Data.Char.isLetter'.
 isAlpha                 :: Char -> Bool
 
 -- | Selects alphabetic or numeric digit Unicode characters.
@@ -97,6 +100,7 @@ isAlphaNum              :: Char -> Bool
 
 -- | Selects ASCII digits, i.e. @\'0\'@..@\'9\'@.
 isDigit                 :: Char -> Bool
+isDigit c              =  c >= '0' && c <= '9'
 
 -- | Selects ASCII octal digits, i.e. @\'0\'@..@\'7\'@.
 isOctDigit              :: Char -> Bool
@@ -108,34 +112,30 @@ isHexDigit              :: Char -> Bool
 isHexDigit c           =  isDigit c || c >= 'A' && c <= 'F' ||
                                         c >= 'a' && c <= 'f'
 
--- | Convert a letter to the corresponding upper-case letter, leaving any
--- other character unchanged.  Any Unicode letter which has an upper-case
--- equivalent is transformed.
+-- | Convert a letter to the corresponding upper-case letter, if any.
+-- Any other character is returned unchanged.
 toUpper                 :: Char -> Char
 
--- | Convert a letter to the corresponding lower-case letter, leaving any
--- other character unchanged.  Any Unicode letter which has a lower-case
--- equivalent is transformed.
+-- | Convert a letter to the corresponding lower-case letter, if any.
+-- Any other character is returned unchanged.
 toLower                 :: Char -> Char
 
--- -----------------------------------------------------------------------------
--- Win32 implementation
+-- | Convert a letter to the corresponding title-case or upper-case
+-- letter, if any.  (Title case differs from upper case only for a small
+-- number of ligature letters.)
+-- Any other character is returned unchanged.
+toTitle                 :: Char -> Char
 
-#if (defined(HAVE_WCTYPE_H) && HAVE_ISWSPACE && defined(HTYPE_WINT_T)) || mingw32_TARGET_OS
+-- -----------------------------------------------------------------------------
+-- Implementation with the supplied auto-generated Unicode character properties
+-- table (default)
 
--- Use the wide-char classification functions if available.  Glibc
--- seems to implement these properly, even for chars > 0xffff, as long
--- as you call setlocale() to set the locale to something other than
--- "C".  Therefore, we call setlocale() in hs_init().
+#if 1
 
--- Win32 uses UTF-16, so presumably the system-supplied iswlower() and
--- friends won't work properly with characters > 0xffff.  These
--- characters are represented as surrogate pairs in UTF-16.
+-- Regardless of the O/S and Library, use the functions contained in WCsubst.c
 
-type WInt = HTYPE_WINT_T
 type CInt = HTYPE_INT
 
-isDigit    c = iswdigit (fromIntegral (ord c)) /= 0
 isAlpha    c = iswalpha (fromIntegral (ord c)) /= 0
 isAlphaNum c = iswalnum (fromIntegral (ord c)) /= 0
 --isSpace    c = iswspace (fromIntegral (ord c)) /= 0
@@ -146,39 +146,46 @@ isLower    c = iswlower (fromIntegral (ord c)) /= 0
 
 toLower c = chr (fromIntegral (towlower (fromIntegral (ord c))))
 toUpper c = chr (fromIntegral (towupper (fromIntegral (ord c))))
+toTitle c = chr (fromIntegral (towtitle (fromIntegral (ord c))))
+
+foreign import ccall unsafe "u_iswdigit"
+  iswdigit :: CInt -> CInt
 
-foreign import ccall unsafe "iswdigit"
-  iswdigit :: WInt -> CInt
+foreign import ccall unsafe "u_iswalpha"
+  iswalpha :: CInt -> CInt
 
-foreign import ccall unsafe "iswalpha"
-  iswalpha :: WInt -> CInt
+foreign import ccall unsafe "u_iswalnum"
+  iswalnum :: CInt -> CInt
 
-foreign import ccall unsafe "iswalnum"
-  iswalnum :: WInt -> CInt
+foreign import ccall unsafe "u_iswcntrl"
+  iswcntrl :: CInt -> CInt
 
-foreign import ccall unsafe "iswcntrl"
-  iswcntrl :: WInt -> CInt
+foreign import ccall unsafe "u_iswspace"
+  iswspace :: CInt -> CInt
 
-foreign import ccall unsafe "iswspace"
-  iswspace :: WInt -> CInt
+foreign import ccall unsafe "u_iswprint"
+  iswprint :: CInt -> CInt
 
-foreign import ccall unsafe "iswprint"
-  iswprint :: WInt -> CInt
+foreign import ccall unsafe "u_iswlower"
+  iswlower :: CInt -> CInt
 
-foreign import ccall unsafe "iswlower"
-  iswlower :: WInt -> CInt
+foreign import ccall unsafe "u_iswupper"
+  iswupper :: CInt -> CInt
 
-foreign import ccall unsafe "iswupper"
-  iswupper :: WInt -> CInt
+foreign import ccall unsafe "u_towlower"
+  towlower :: CInt -> CInt
 
-foreign import ccall unsafe "towlower"
-  towlower :: WInt -> WInt
+foreign import ccall unsafe "u_towupper"
+  towupper :: CInt -> CInt
 
-foreign import ccall unsafe "towupper"
-  towupper :: WInt -> WInt
+foreign import ccall unsafe "u_towtitle"
+  towtitle :: CInt -> CInt
+
+foreign import ccall unsafe "u_gencat"
+  wgencat :: CInt -> CInt
 
 -- -----------------------------------------------------------------------------
--- No libunicode, so fall back to the ASCII-only implementation
+-- No libunicode, so fall back to the ASCII-only implementation (never used, indeed)
 
 #else
 
@@ -197,7 +204,6 @@ isLower c           =  c >= 'a' && c <= 'z' ||
                            c >= '\xF8' && c <= '\xFF'
 
 isAlpha c              =  isLower c || isUpper c
-isDigit c              =  c >= '0' && c <= '9'
 isAlphaNum c           =  isAlpha c || isDigit c
 
 -- Case-changing operations