X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;ds=sidebyside;f=GHC%2FUnicode.hs;h=e22fae59e20acfb318ff8110901f97067f31f84c;hb=5031aad924a8b70b5fc4fe4bb1321c007afcab21;hp=b29d44fbc78f63bd891425b87488f18d8c399df9;hpb=62aa5cf8bbbc0c357c6c61caaa62bb94999581df;p=ghc-base.git diff --git a/GHC/Unicode.hs b/GHC/Unicode.hs index b29d44f..e22fae5 100644 --- a/GHC/Unicode.hs +++ b/GHC/Unicode.hs @@ -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 -- @@ -15,13 +16,15 @@ -- ----------------------------------------------------------------------------- +-- #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,6 @@ 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, @@ -43,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 @@ -67,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. @@ -98,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 @@ -109,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 @@ -147,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 -> Int -- ----------------------------------------------------------------------------- --- No libunicode, so fall back to the ASCII-only implementation +-- No libunicode, so fall back to the ASCII-only implementation (never used, indeed) #else @@ -198,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