glib/guniprop.c

   1 /* guniprop.c - Unicode character properties.
   2  *
   3  * Copyright (C) 1999 Tom Tromey
   4  * Copyright (C) 2000 Red Hat, Inc.
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the
  18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19  * Boston, MA 02111-1307, USA.
  20  */
  21
  22 #include "config.h"
  23
  24 #include <stdlib.h>
  25 #include <stddef.h>
  26 #include <string.h>
  27 #include <locale.h>
  28
  29 #include "gmem.h"
  30 #include "gstring.h"
  31 #include "gtestutils.h"
  32 #include "gtypes.h"
  33 #include "gunicode.h"
  34 #include "gunichartables.h"
  35 #include "gmirroringtable.h"
  36 #include "gscripttable.h"
  37 #include "gunicodeprivate.h"
  38
  39 #define ATTR_TABLE(Page) (((Page) <= G_UNICODE_LAST_PAGE_PART1) \
  40                           ? attr_table_part1[Page] \
  41                           : attr_table_part2[(Page) - 0xe00])
  42
  43 #define ATTTABLE(Page, Char) \
  44   ((ATTR_TABLE(Page) == G_UNICODE_MAX_TABLE_INDEX) ? 0 : (attr_data[ATTR_TABLE(Page)][Char]))
  45
  46 #define TTYPE_PART1(Page, Char) \
  47   ((type_table_part1[Page] >= G_UNICODE_MAX_TABLE_INDEX) \
  48    ? (type_table_part1[Page] - G_UNICODE_MAX_TABLE_INDEX) \
  49    : (type_data[type_table_part1[Page]][Char]))
  50
  51 #define TTYPE_PART2(Page, Char) \
  52   ((type_table_part2[Page] >= G_UNICODE_MAX_TABLE_INDEX) \
  53    ? (type_table_part2[Page] - G_UNICODE_MAX_TABLE_INDEX) \
  54    : (type_data[type_table_part2[Page]][Char]))
  55
  56 #define TYPE(Char) \
  57   (((Char) <= G_UNICODE_LAST_CHAR_PART1) \
  58    ? TTYPE_PART1 ((Char) >> 8, (Char) & 0xff) \
  59    : (((Char) >= 0xe0000 && (Char) <= G_UNICODE_LAST_CHAR) \
  60       ? TTYPE_PART2 (((Char) - 0xe0000) >> 8, (Char) & 0xff) \
  61       : G_UNICODE_UNASSIGNED))
  62
  63
  64 #define IS(Type, Class) (((guint)1 << (Type)) & (Class))
  65 #define OR(Type, Rest)  (((guint)1 << (Type)) | (Rest))
  66
  67
  68
  69 #define ISALPHA(Type)   IS ((Type),                             \
  70                             OR (G_UNICODE_LOWERCASE_LETTER,     \
  71                             OR (G_UNICODE_UPPERCASE_LETTER,     \
  72                             OR (G_UNICODE_TITLECASE_LETTER,     \
  73                             OR (G_UNICODE_MODIFIER_LETTER,      \
  74                             OR (G_UNICODE_OTHER_LETTER,         0))))))
  75
  76 #define ISALDIGIT(Type) IS ((Type),                             \
  77                             OR (G_UNICODE_DECIMAL_NUMBER,       \
  78                             OR (G_UNICODE_LETTER_NUMBER,        \
  79                             OR (G_UNICODE_OTHER_NUMBER,         \
  80                             OR (G_UNICODE_LOWERCASE_LETTER,     \
  81                             OR (G_UNICODE_UPPERCASE_LETTER,     \
  82                             OR (G_UNICODE_TITLECASE_LETTER,     \
  83                             OR (G_UNICODE_MODIFIER_LETTER,      \
  84                             OR (G_UNICODE_OTHER_LETTER,         0)))))))))
  85
  86 #define ISMARK(Type)    IS ((Type),                             \
  87                             OR (G_UNICODE_NON_SPACING_MARK,     \
  88                             OR (G_UNICODE_COMBINING_MARK,       \
  89                             OR (G_UNICODE_ENCLOSING_MARK,       0))))
  90
  91 #define ISZEROWIDTHTYPE(Type)   IS ((Type),                     \
  92                             OR (G_UNICODE_NON_SPACING_MARK,     \
  93                             OR (G_UNICODE_ENCLOSING_MARK,       \
  94                             OR (G_UNICODE_FORMAT,               0))))
  95
  96 /**
  97  * g_unichar_isalnum:
  98  * @c: a Unicode character
  99  *
 100  * Determines whether a character is alphanumeric.
 101  * Given some UTF-8 text, obtain a character value
 102  * with g_utf8_get_char().
 103  *
 104  * Return value: %TRUE if @c is an alphanumeric character
 105  **/
 106 gboolean
 107 g_unichar_isalnum (gunichar c)
 108 {
 109   return ISALDIGIT (TYPE (c)) ? TRUE : FALSE;
 110 }
 111
 112 /**
 113  * g_unichar_isalpha:
 114  * @c: a Unicode character
 115  *
 116  * Determines whether a character is alphabetic (i.e. a letter).
 117  * Given some UTF-8 text, obtain a character value with
 118  * g_utf8_get_char().
 119  *
 120  * Return value: %TRUE if @c is an alphabetic character
 121  **/
 122 gboolean
 123 g_unichar_isalpha (gunichar c)
 124 {
 125   return ISALPHA (TYPE (c)) ? TRUE : FALSE;
 126 }
 127
 128
 129 /**
 130  * g_unichar_iscntrl:
 131  * @c: a Unicode character
 132  *
 133  * Determines whether a character is a control character.
 134  * Given some UTF-8 text, obtain a character value with
 135  * g_utf8_get_char().
 136  *
 137  * Return value: %TRUE if @c is a control character
 138  **/
 139 gboolean
 140 g_unichar_iscntrl (gunichar c)
 141 {
 142   return TYPE (c) == G_UNICODE_CONTROL;
 143 }
 144
 145 /**
 146  * g_unichar_isdigit:
 147  * @c: a Unicode character
 148  *
 149  * Determines whether a character is numeric (i.e. a digit).  This
 150  * covers ASCII 0-9 and also digits in other languages/scripts.  Given
 151  * some UTF-8 text, obtain a character value with g_utf8_get_char().
 152  *
 153  * Return value: %TRUE if @c is a digit
 154  **/
 155 gboolean
 156 g_unichar_isdigit (gunichar c)
 157 {
 158   return TYPE (c) == G_UNICODE_DECIMAL_NUMBER;
 159 }
 160
 161
 162 /**
 163  * g_unichar_isgraph:
 164  * @c: a Unicode character
 165  *
 166  * Determines whether a character is printable and not a space
 167  * (returns %FALSE for control characters, format characters, and
 168  * spaces). g_unichar_isprint() is similar, but returns %TRUE for
 169  * spaces. Given some UTF-8 text, obtain a character value with
 170  * g_utf8_get_char().
 171  *
 172  * Return value: %TRUE if @c is printable unless it's a space
 173  **/
 174 gboolean
 175 g_unichar_isgraph (gunichar c)
 176 {
 177   return !IS (TYPE(c),
 178               OR (G_UNICODE_CONTROL,
 179               OR (G_UNICODE_FORMAT,
 180               OR (G_UNICODE_UNASSIGNED,
 181               OR (G_UNICODE_SURROGATE,
 182               OR (G_UNICODE_SPACE_SEPARATOR,
 183              0))))));
 184 }
 185
 186 /**
 187  * g_unichar_islower:
 188  * @c: a Unicode character
 189  *
 190  * Determines whether a character is a lowercase letter.
 191  * Given some UTF-8 text, obtain a character value with
 192  * g_utf8_get_char().
 193  *
 194  * Return value: %TRUE if @c is a lowercase letter
 195  **/
 196 gboolean
 197 g_unichar_islower (gunichar c)
 198 {
 199   return TYPE (c) == G_UNICODE_LOWERCASE_LETTER;
 200 }
 201
 202
 203 /**
 204  * g_unichar_isprint:
 205  * @c: a Unicode character
 206  *
 207  * Determines whether a character is printable.
 208  * Unlike g_unichar_isgraph(), returns %TRUE for spaces.
 209  * Given some UTF-8 text, obtain a character value with
 210  * g_utf8_get_char().
 211  *
 212  * Return value: %TRUE if @c is printable
 213  **/
 214 gboolean
 215 g_unichar_isprint (gunichar c)
 216 {
 217   return !IS (TYPE(c),
 218               OR (G_UNICODE_CONTROL,
 219               OR (G_UNICODE_FORMAT,
 220               OR (G_UNICODE_UNASSIGNED,
 221               OR (G_UNICODE_SURROGATE,
 222              0)))));
 223 }
 224
 225 /**
 226  * g_unichar_ispunct:
 227  * @c: a Unicode character
 228  *
 229  * Determines whether a character is punctuation or a symbol.
 230  * Given some UTF-8 text, obtain a character value with
 231  * g_utf8_get_char().
 232  *
 233  * Return value: %TRUE if @c is a punctuation or symbol character
 234  **/
 235 gboolean
 236 g_unichar_ispunct (gunichar c)
 237 {
 238   return IS (TYPE(c),
 239              OR (G_UNICODE_CONNECT_PUNCTUATION,
 240              OR (G_UNICODE_DASH_PUNCTUATION,
 241              OR (G_UNICODE_CLOSE_PUNCTUATION,
 242              OR (G_UNICODE_FINAL_PUNCTUATION,
 243              OR (G_UNICODE_INITIAL_PUNCTUATION,
 244              OR (G_UNICODE_OTHER_PUNCTUATION,
 245              OR (G_UNICODE_OPEN_PUNCTUATION,
 246              OR (G_UNICODE_CURRENCY_SYMBOL,
 247              OR (G_UNICODE_MODIFIER_SYMBOL,
 248              OR (G_UNICODE_MATH_SYMBOL,
 249              OR (G_UNICODE_OTHER_SYMBOL,
 250             0)))))))))))) ? TRUE : FALSE;
 251 }
 252
 253 /**
 254  * g_unichar_isspace:
 255  * @c: a Unicode character
 256  *
 257  * Determines whether a character is a space, tab, or line separator
 258  * (newline, carriage return, etc.).  Given some UTF-8 text, obtain a
 259  * character value with g_utf8_get_char().
 260  *
 261  * (Note: don't use this to do word breaking; you have to use
 262  * Pango or equivalent to get word breaking right, the algorithm
 263  * is fairly complex.)
 264  *
 265  * Return value: %TRUE if @c is a space character
 266  **/
 267 gboolean
 268 g_unichar_isspace (gunichar c)
 269 {
 270   switch (c)
 271     {
 272       /* special-case these since Unicode thinks they are not spaces */
 273     case '\t':
 274     case '\n':
 275     case '\r':
 276     case '\f':
 277       return TRUE;
 278       break;
 279
 280     default:
 281       {
 282         return IS (TYPE(c),
 283                    OR (G_UNICODE_SPACE_SEPARATOR,
 284                    OR (G_UNICODE_LINE_SEPARATOR,
 285                    OR (G_UNICODE_PARAGRAPH_SEPARATOR,
 286                   0)))) ? TRUE : FALSE;
 287       }
 288       break;
 289     }
 290 }
 291
 292 /**
 293  * g_unichar_ismark:
 294  * @c: a Unicode character
 295  *
 296  * Determines whether a character is a mark (non-spacing mark,
 297  * combining mark, or enclosing mark in Unicode speak).
 298  * Given some UTF-8 text, obtain a character value
 299  * with g_utf8_get_char().
 300  *
 301  * Note: in most cases where isalpha characters are allowed,
 302  * ismark characters should be allowed to as they are essential
 303  * for writing most European languages as well as many non-Latin
 304  * scripts.
 305  *
 306  * Return value: %TRUE if @c is a mark character
 307  *
 308  * Since: 2.14
 309  **/
 310 gboolean
 311 g_unichar_ismark (gunichar c)
 312 {
 313   return ISMARK (TYPE (c));
 314 }
 315
 316 /**
 317  * g_unichar_isupper:
 318  * @c: a Unicode character
 319  *
 320  * Determines if a character is uppercase.
 321  *
 322  * Return value: %TRUE if @c is an uppercase character
 323  **/
 324 gboolean
 325 g_unichar_isupper (gunichar c)
 326 {
 327   return TYPE (c) == G_UNICODE_UPPERCASE_LETTER;
 328 }
 329
 330 /**
 331  * g_unichar_istitle:
 332  * @c: a Unicode character
 333  *
 334  * Determines if a character is titlecase. Some characters in
 335  * Unicode which are composites, such as the DZ digraph
 336  * have three case variants instead of just two. The titlecase
 337  * form is used at the beginning of a word where only the
 338  * first letter is capitalized. The titlecase form of the DZ
 339  * digraph is U+01F2 LATIN CAPITAL LETTTER D WITH SMALL LETTER Z.
 340  *
 341  * Return value: %TRUE if the character is titlecase
 342  **/
 343 gboolean
 344 g_unichar_istitle (gunichar c)
 345 {
 346   unsigned int i;
 347   for (i = 0; i < G_N_ELEMENTS (title_table); ++i)
 348     if (title_table[i][0] == c)
 349       return TRUE;
 350   return FALSE;
 351 }
 352
 353 /**
 354  * g_unichar_isxdigit:
 355  * @c: a Unicode character.
 356  *
 357  * Determines if a character is a hexidecimal digit.
 358  *
 359  * Return value: %TRUE if the character is a hexadecimal digit
 360  **/
 361 gboolean
 362 g_unichar_isxdigit (gunichar c)
 363 {
 364   return ((c >= 'a' && c <= 'f')
 365           || (c >= 'A' && c <= 'F')
 366           || (TYPE (c) == G_UNICODE_DECIMAL_NUMBER));
 367 }
 368
 369 /**
 370  * g_unichar_isdefined:
 371  * @c: a Unicode character
 372  *
 373  * Determines if a given character is assigned in the Unicode
 374  * standard.
 375  *
 376  * Return value: %TRUE if the character has an assigned value
 377  **/
 378 gboolean
 379 g_unichar_isdefined (gunichar c)
 380 {
 381   return !IS (TYPE(c),
 382               OR (G_UNICODE_UNASSIGNED,
 383               OR (G_UNICODE_SURROGATE,
 384              0)));
 385 }
 386
 387 /**
 388  * g_unichar_iszerowidth:
 389  * @c: a Unicode character
 390  *
 391  * Determines if a given character typically takes zero width when rendered.
 392  * The return value is %TRUE for all non-spacing and enclosing marks
 393  * (e.g., combining accents), format characters, zero-width
 394  * space, but not U+00AD SOFT HYPHEN.
 395  *
 396  * A typical use of this function is with one of g_unichar_iswide() or
 397  * g_unichar_iswide_cjk() to determine the number of cells a string occupies
 398  * when displayed on a grid display (terminals).  However, note that not all
 399  * terminals support zero-width rendering of zero-width marks.
 400  *
 401  * Return value: %TRUE if the character has zero width
 402  *
 403  * Since: 2.14
 404  **/
 405 gboolean
 406 g_unichar_iszerowidth (gunichar c)
 407 {
 408   if (G_UNLIKELY (c == 0x00AD))
 409     return FALSE;
 410
 411   if (G_UNLIKELY (ISZEROWIDTHTYPE (TYPE (c))))
 412     return TRUE;
 413
 414   if (G_UNLIKELY ((c >= 0x1160 && c < 0x1200) ||
 415                   c == 0x200B))
 416     return TRUE;
 417
 418   return FALSE;
 419 }
 420
 421 struct Interval
 422 {
 423   gunichar start, end;
 424 };
 425
 426 static int
 427 interval_compare (const void *key, const void *elt)
 428 {
 429   gunichar c = GPOINTER_TO_UINT (key);
 430   struct Interval *interval = (struct Interval *)elt;
 431
 432   if (c < interval->start)
 433     return -1;
 434   if (c > interval->end)
 435     return +1;
 436
 437   return 0;
 438 }
 439
 440 /**
 441  * g_unichar_iswide:
 442  * @c: a Unicode character
 443  *
 444  * Determines if a character is typically rendered in a double-width
 445  * cell.
 446  *
 447  * Return value: %TRUE if the character is wide
 448  **/
 449 gboolean
 450 g_unichar_iswide (gunichar c)
 451 {
 452   /* sorted list of intervals of East_Asian_Width = W and F characters
 453    * from Unicode 5.1.0.  produced by mungling output of:
 454    * grep ';[FW]\>' EastAsianWidth.txt */
 455   static const struct Interval wide[] = {
 456     {0x1100, 0x1159}, {0x115F, 0x115F}, {0x2329, 0x232A}, {0x2E80, 0x2E99},
 457     {0x2E9B, 0x2EF3}, {0x2F00, 0x2FD5}, {0x2FF0, 0x2FFB}, {0x3000, 0x303E},
 458     {0x3041, 0x3096}, {0x3099, 0x30FF}, {0x3105, 0x312D}, {0x3131, 0x318E},
 459     {0x3190, 0x31B7}, {0x31C0, 0x31E3}, {0x31F0, 0x321E}, {0x3220, 0x3243},
 460     {0x3250, 0x32FE}, {0x3300, 0x4DB5}, {0x4E00, 0x9FC3}, {0xA000, 0xA48C},
 461     {0xA490, 0xA4C6}, {0xAC00, 0xD7A3}, {0xF900, 0xFA2D}, {0xFA30, 0xFA6A},
 462     {0xFA70, 0xFAD9}, {0xFE10, 0xFE19}, {0xFE30, 0xFE52}, {0xFE54, 0xFE66},
 463     {0xFE68, 0xFE6B}, {0xFF01, 0xFF60}, {0xFFE0, 0xFFE6}, {0x20000, 0x2FFFD},
 464     {0x30000, 0x3FFFD}
 465   };
 466
 467   if (bsearch (GUINT_TO_POINTER (c), wide, G_N_ELEMENTS (wide), sizeof wide[0],
 468                interval_compare))
 469     return TRUE;
 470
 471   return FALSE;
 472 }
 473
 474
 475 /**
 476  * g_unichar_iswide_cjk:
 477  * @c: a Unicode character
 478  *
 479  * Determines if a character is typically rendered in a double-width
 480  * cell under legacy East Asian locales.  If a character is wide according to
 481  * g_unichar_iswide(), then it is also reported wide with this function, but
 482  * the converse is not necessarily true.  See the
 483  * <ulink url="http://www.unicode.org/reports/tr11/">Unicode Standard
 484  * Annex #11</ulink> for details.
 485  *
 486  * If a character passes the g_unichar_iswide() test then it will also pass
 487  * this test, but not the other way around.  Note that some characters may
 488  * pas both this test and g_unichar_iszerowidth().
 489  *
 490  * Return value: %TRUE if the character is wide in legacy East Asian locales
 491  *
 492  * Since: 2.12
 493  */
 494 gboolean
 495 g_unichar_iswide_cjk (gunichar c)
 496 {
 497   /* sorted list of intervals of East_Asian_Width = A and F characters
 498    * from Unicode 5.1.0.  produced by mungling output of:
 499    * grep ';[A]\>' EastAsianWidth.txt */
 500   static const struct Interval ambiguous[] = {
 501     {0x00A1, 0x00A1}, {0x00A4, 0x00A4}, {0x00A7, 0x00A8}, {0x00AA, 0x00AA},
 502     {0x00AD, 0x00AE}, {0x00B0, 0x00B4}, {0x00B6, 0x00BA}, {0x00BC, 0x00BF},
 503     {0x00C6, 0x00C6}, {0x00D0, 0x00D0}, {0x00D7, 0x00D8}, {0x00DE, 0x00E1},
 504     {0x00E6, 0x00E6}, {0x00E8, 0x00EA}, {0x00EC, 0x00ED}, {0x00F0, 0x00F0},
 505     {0x00F2, 0x00F3}, {0x00F7, 0x00FA}, {0x00FC, 0x00FC}, {0x00FE, 0x00FE},
 506     {0x0101, 0x0101}, {0x0111, 0x0111}, {0x0113, 0x0113}, {0x011B, 0x011B},
 507     {0x0126, 0x0127}, {0x012B, 0x012B}, {0x0131, 0x0133}, {0x0138, 0x0138},
 508     {0x013F, 0x0142}, {0x0144, 0x0144}, {0x0148, 0x014B}, {0x014D, 0x014D},
 509     {0x0152, 0x0153}, {0x0166, 0x0167}, {0x016B, 0x016B}, {0x01CE, 0x01CE},
 510     {0x01D0, 0x01D0}, {0x01D2, 0x01D2}, {0x01D4, 0x01D4}, {0x01D6, 0x01D6},
 511     {0x01D8, 0x01D8}, {0x01DA, 0x01DA}, {0x01DC, 0x01DC}, {0x0251, 0x0251},
 512     {0x0261, 0x0261}, {0x02C4, 0x02C4}, {0x02C7, 0x02C7}, {0x02C9, 0x02CB},
 513     {0x02CD, 0x02CD}, {0x02D0, 0x02D0}, {0x02D8, 0x02DB}, {0x02DD, 0x02DD},
 514     {0x02DF, 0x02DF}, {0x0300, 0x036F}, {0x0391, 0x03A1}, {0x03A3, 0x03A9},
 515     {0x03B1, 0x03C1}, {0x03C3, 0x03C9}, {0x0401, 0x0401}, {0x0410, 0x044F},
 516     {0x0451, 0x0451}, {0x2010, 0x2010}, {0x2013, 0x2016}, {0x2018, 0x2019},
 517     {0x201C, 0x201D}, {0x2020, 0x2022}, {0x2024, 0x2027}, {0x2030, 0x2030},
 518     {0x2032, 0x2033}, {0x2035, 0x2035}, {0x203B, 0x203B}, {0x203E, 0x203E},
 519     {0x2074, 0x2074}, {0x207F, 0x207F}, {0x2081, 0x2084}, {0x20AC, 0x20AC},
 520     {0x2103, 0x2103}, {0x2105, 0x2105}, {0x2109, 0x2109}, {0x2113, 0x2113},
 521     {0x2116, 0x2116}, {0x2121, 0x2122}, {0x2126, 0x2126}, {0x212B, 0x212B},
 522     {0x2153, 0x2154}, {0x215B, 0x215E}, {0x2160, 0x216B}, {0x2170, 0x2179},
 523     {0x2190, 0x2199}, {0x21B8, 0x21B9}, {0x21D2, 0x21D2}, {0x21D4, 0x21D4},
 524     {0x21E7, 0x21E7}, {0x2200, 0x2200}, {0x2202, 0x2203}, {0x2207, 0x2208},
 525     {0x220B, 0x220B}, {0x220F, 0x220F}, {0x2211, 0x2211}, {0x2215, 0x2215},
 526     {0x221A, 0x221A}, {0x221D, 0x2220}, {0x2223, 0x2223}, {0x2225, 0x2225},
 527     {0x2227, 0x222C}, {0x222E, 0x222E}, {0x2234, 0x2237}, {0x223C, 0x223D},
 528     {0x2248, 0x2248}, {0x224C, 0x224C}, {0x2252, 0x2252}, {0x2260, 0x2261},
 529     {0x2264, 0x2267}, {0x226A, 0x226B}, {0x226E, 0x226F}, {0x2282, 0x2283},
 530     {0x2286, 0x2287}, {0x2295, 0x2295}, {0x2299, 0x2299}, {0x22A5, 0x22A5},
 531     {0x22BF, 0x22BF}, {0x2312, 0x2312}, {0x2460, 0x24E9}, {0x24EB, 0x254B},
 532     {0x2550, 0x2573}, {0x2580, 0x258F}, {0x2592, 0x2595}, {0x25A0, 0x25A1},
 533     {0x25A3, 0x25A9}, {0x25B2, 0x25B3}, {0x25B6, 0x25B7}, {0x25BC, 0x25BD},
 534     {0x25C0, 0x25C1}, {0x25C6, 0x25C8}, {0x25CB, 0x25CB}, {0x25CE, 0x25D1},
 535     {0x25E2, 0x25E5}, {0x25EF, 0x25EF}, {0x2605, 0x2606}, {0x2609, 0x2609},
 536     {0x260E, 0x260F}, {0x2614, 0x2615}, {0x261C, 0x261C}, {0x261E, 0x261E},
 537     {0x2640, 0x2640}, {0x2642, 0x2642}, {0x2660, 0x2661}, {0x2663, 0x2665},
 538     {0x2667, 0x266A}, {0x266C, 0x266D}, {0x266F, 0x266F}, {0x273D, 0x273D},
 539     {0x2776, 0x277F}, {0xE000, 0xF8FF}, {0xFE00, 0xFE0F}, {0xFFFD, 0xFFFD},
 540     {0xE0100, 0xE01EF}, {0xF0000, 0xFFFFD}, {0x100000, 0x10FFFD}
 541   };
 542
 543   if (g_unichar_iswide (c))
 544     return TRUE;
 545
 546   if (bsearch (GUINT_TO_POINTER (c), ambiguous, G_N_ELEMENTS (ambiguous), sizeof ambiguous[0],
 547                interval_compare))
 548     return TRUE;
 549
 550   return FALSE;
 551 }
 552
 553
 554 /**
 555  * g_unichar_toupper:
 556  * @c: a Unicode character
 557  *
 558  * Converts a character to uppercase.
 559  *
 560  * Return value: the result of converting @c to uppercase.
 561  *               If @c is not an lowercase or titlecase character,
 562  *               or has no upper case equivalent @c is returned unchanged.
 563  **/
 564 gunichar
 565 g_unichar_toupper (gunichar c)
 566 {
 567   int t = TYPE (c);
 568   if (t == G_UNICODE_LOWERCASE_LETTER)
 569     {
 570       gunichar val = ATTTABLE (c >> 8, c & 0xff);
 571       if (val >= 0x1000000)
 572         {
 573           const gchar *p = special_case_table + val - 0x1000000;
 574           val = g_utf8_get_char (p);
 575         }
 576       /* Some lowercase letters, e.g., U+000AA, FEMININE ORDINAL INDICATOR,
 577        * do not have an uppercase equivalent, in which case val will be
 578        * zero.
 579        */
 580       return val ? val : c;
 581     }
 582   else if (t == G_UNICODE_TITLECASE_LETTER)
 583     {
 584       unsigned int i;
 585       for (i = 0; i < G_N_ELEMENTS (title_table); ++i)
 586         {
 587           if (title_table[i][0] == c)
 588             return title_table[i][1];
 589         }
 590     }
 591   return c;
 592 }
 593
 594 /**
 595  * g_unichar_tolower:
 596  * @c: a Unicode character.
 597  *
 598  * Converts a character to lower case.
 599  *
 600  * Return value: the result of converting @c to lower case.
 601  *               If @c is not an upperlower or titlecase character,
 602  *               or has no lowercase equivalent @c is returned unchanged.
 603  **/
 604 gunichar
 605 g_unichar_tolower (gunichar c)
 606 {
 607   int t = TYPE (c);
 608   if (t == G_UNICODE_UPPERCASE_LETTER)
 609     {
 610       gunichar val = ATTTABLE (c >> 8, c & 0xff);
 611       if (val >= 0x1000000)
 612         {
 613           const gchar *p = special_case_table + val - 0x1000000;
 614           return g_utf8_get_char (p);
 615         }
 616       else
 617         {
 618           /* Not all uppercase letters are guaranteed to have a lowercase
 619            * equivalent.  If this is the case, val will be zero. */
 620           return val ? val : c;
 621         }
 622     }
 623   else if (t == G_UNICODE_TITLECASE_LETTER)
 624     {
 625       unsigned int i;
 626       for (i = 0; i < G_N_ELEMENTS (title_table); ++i)
 627         {
 628           if (title_table[i][0] == c)
 629             return title_table[i][2];
 630         }
 631     }
 632   return c;
 633 }
 634
 635 /**
 636  * g_unichar_totitle:
 637  * @c: a Unicode character
 638  *
 639  * Converts a character to the titlecase.
 640  *
 641  * Return value: the result of converting @c to titlecase.
 642  *               If @c is not an uppercase or lowercase character,
 643  *               @c is returned unchanged.
 644  **/
 645 gunichar
 646 g_unichar_totitle (gunichar c)
 647 {
 648   unsigned int i;
 649   for (i = 0; i < G_N_ELEMENTS (title_table); ++i)
 650     {
 651       if (title_table[i][0] == c || title_table[i][1] == c
 652           || title_table[i][2] == c)
 653         return title_table[i][0];
 654     }
 655
 656   if (TYPE (c) == G_UNICODE_LOWERCASE_LETTER)
 657     return g_unichar_toupper (c);
 658
 659   return c;
 660 }
 661
 662 /**
 663  * g_unichar_digit_value:
 664  * @c: a Unicode character
 665  *
 666  * Determines the numeric value of a character as a decimal
 667  * digit.
 668  *
 669  * Return value: If @c is a decimal digit (according to
 670  * g_unichar_isdigit()), its numeric value. Otherwise, -1.
 671  **/
 672 int
 673 g_unichar_digit_value (gunichar c)
 674 {
 675   if (TYPE (c) == G_UNICODE_DECIMAL_NUMBER)
 676     return ATTTABLE (c >> 8, c & 0xff);
 677   return -1;
 678 }
 679
 680 /**
 681  * g_unichar_xdigit_value:
 682  * @c: a Unicode character
 683  *
 684  * Determines the numeric value of a character as a hexidecimal
 685  * digit.
 686  *
 687  * Return value: If @c is a hex digit (according to
 688  * g_unichar_isxdigit()), its numeric value. Otherwise, -1.
 689  **/
 690 int
 691 g_unichar_xdigit_value (gunichar c)
 692 {
 693   if (c >= 'A' && c <= 'F')
 694     return c - 'A' + 10;
 695   if (c >= 'a' && c <= 'f')
 696     return c - 'a' + 10;
 697   if (TYPE (c) == G_UNICODE_DECIMAL_NUMBER)
 698     return ATTTABLE (c >> 8, c & 0xff);
 699   return -1;
 700 }
 701
 702 /**
 703  * g_unichar_type:
 704  * @c: a Unicode character
 705  *
 706  * Classifies a Unicode character by type.
 707  *
 708  * Return value: the type of the character.
 709  **/
 710 GUnicodeType
 711 g_unichar_type (gunichar c)
 712 {
 713   return TYPE (c);
 714 }
 715
 716 /*
 717  * Case mapping functions
 718  */
 719
 720 typedef enum {
 721   LOCALE_NORMAL,
 722   LOCALE_TURKIC,
 723   LOCALE_LITHUANIAN
 724 } LocaleType;
 725
 726 static LocaleType
 727 get_locale_type (void)
 728 {
 729 #ifdef G_OS_WIN32
 730   char *tem = g_win32_getlocale ();
 731   char locale[2];
 732
 733   locale[0] = tem[0];
 734   locale[1] = tem[1];
 735   g_free (tem);
 736 #else
 737   const char *locale = setlocale (LC_CTYPE, NULL);
 738 #endif
 739
 740   switch (locale[0])
 741     {
 742    case 'a':
 743       if (locale[1] == 'z')
 744         return LOCALE_TURKIC;
 745       break;
 746     case 'l':
 747       if (locale[1] == 't')
 748         return LOCALE_LITHUANIAN;
 749       break;
 750     case 't':
 751       if (locale[1] == 'r')
 752         return LOCALE_TURKIC;
 753       break;
 754     }
 755
 756   return LOCALE_NORMAL;
 757 }
 758
 759 static gint
 760 output_marks (const char **p_inout,
 761               char        *out_buffer,
 762               gboolean     remove_dot)
 763 {
 764   const char *p = *p_inout;
 765   gint len = 0;
 766
 767   while (*p)
 768     {
 769       gunichar c = g_utf8_get_char (p);
 770
 771       if (ISMARK (TYPE (c)))
 772         {
 773           if (!remove_dot || c != 0x307 /* COMBINING DOT ABOVE */)
 774             len += g_unichar_to_utf8 (c, out_buffer ? out_buffer + len : NULL);
 775           p = g_utf8_next_char (p);
 776         }
 777       else
 778         break;
 779     }
 780
 781   *p_inout = p;
 782   return len;
 783 }
 784
 785 static gint
 786 output_special_case (gchar *out_buffer,
 787                      int    offset,
 788                      int    type,
 789                      int    which)
 790 {
 791   const gchar *p = special_case_table + offset;
 792   gint len;
 793
 794   if (type != G_UNICODE_TITLECASE_LETTER)
 795     p = g_utf8_next_char (p);
 796
 797   if (which == 1)
 798     p += strlen (p) + 1;
 799
 800   len = strlen (p);
 801   if (out_buffer)
 802     memcpy (out_buffer, p, len);
 803
 804   return len;
 805 }
 806
 807 static gsize
 808 real_toupper (const gchar *str,
 809               gssize       max_len,
 810               gchar       *out_buffer,
 811               LocaleType   locale_type)
 812 {
 813   const gchar *p = str;
 814   const char *last = NULL;
 815   gsize len = 0;
 816   gboolean last_was_i = FALSE;
 817
 818   while ((max_len < 0 || p < str + max_len) && *p)
 819     {
 820       gunichar c = g_utf8_get_char (p);
 821       int t = TYPE (c);
 822       gunichar val;
 823
 824       last = p;
 825       p = g_utf8_next_char (p);
 826
 827       if (locale_type == LOCALE_LITHUANIAN)
 828         {
 829           if (c == 'i')
 830             last_was_i = TRUE;
 831           else
 832             {
 833               if (last_was_i)
 834                 {
 835                   /* Nasty, need to remove any dot above. Though
 836                    * I think only E WITH DOT ABOVE occurs in practice
 837                    * which could simplify this considerably.
 838                    */
 839                   gsize decomp_len, i;
 840                   gunichar *decomp;
 841
 842                   decomp = g_unicode_canonical_decomposition (c, &decomp_len);
 843                   for (i=0; i < decomp_len; i++)
 844                     {
 845                       if (decomp[i] != 0x307 /* COMBINING DOT ABOVE */)
 846                         len += g_unichar_to_utf8 (g_unichar_toupper (decomp[i]), out_buffer ? out_buffer + len : NULL);
 847                     }
 848                   g_free (decomp);
 849
 850                   len += output_marks (&p, out_buffer ? out_buffer + len : NULL, TRUE);
 851
 852                   continue;
 853                 }
 854
 855               if (!ISMARK (t))
 856                 last_was_i = FALSE;
 857             }
 858         }
 859
 860       if (locale_type == LOCALE_TURKIC && c == 'i')
 861         {
 862           /* i => LATIN CAPITAL LETTER I WITH DOT ABOVE */
 863           len += g_unichar_to_utf8 (0x130, out_buffer ? out_buffer + len : NULL);
 864         }
 865       else if (c == 0x0345)     /* COMBINING GREEK YPOGEGRAMMENI */
 866         {
 867           /* Nasty, need to move it after other combining marks .. this would go away if
 868            * we normalized first.
 869            */
 870           len += output_marks (&p, out_buffer ? out_buffer + len : NULL, FALSE);
 871
 872           /* And output as GREEK CAPITAL LETTER IOTA */
 873           len += g_unichar_to_utf8 (0x399, out_buffer ? out_buffer + len : NULL);
 874         }
 875       else if (IS (t,
 876                    OR (G_UNICODE_LOWERCASE_LETTER,
 877                    OR (G_UNICODE_TITLECASE_LETTER,
 878                   0))))
 879         {
 880           val = ATTTABLE (c >> 8, c & 0xff);
 881
 882           if (val >= 0x1000000)
 883             {
 884               len += output_special_case (out_buffer ? out_buffer + len : NULL, val - 0x1000000, t,
 885                                           t == G_UNICODE_LOWERCASE_LETTER ? 0 : 1);
 886             }
 887           else
 888             {
 889               if (t == G_UNICODE_TITLECASE_LETTER)
 890                 {
 891                   unsigned int i;
 892                   for (i = 0; i < G_N_ELEMENTS (title_table); ++i)
 893                     {
 894                       if (title_table[i][0] == c)
 895                         {
 896                           val = title_table[i][1];
 897                           break;
 898                         }
 899                     }
 900                 }
 901
 902               /* Some lowercase letters, e.g., U+000AA, FEMININE ORDINAL INDICATOR,
 903                * do not have an uppercase equivalent, in which case val will be
 904                * zero. */
 905               len += g_unichar_to_utf8 (val ? val : c, out_buffer ? out_buffer + len : NULL);
 906             }
 907         }
 908       else
 909         {
 910           gsize char_len = g_utf8_skip[*(guchar *)last];
 911
 912           if (out_buffer)
 913             memcpy (out_buffer + len, last, char_len);
 914
 915           len += char_len;
 916         }
 917
 918     }
 919
 920   return len;
 921 }
 922
 923 /**
 924  * g_utf8_strup:
 925  * @str: a UTF-8 encoded string
 926  * @len: length of @str, in bytes, or -1 if @str is nul-terminated.
 927  *
 928  * Converts all Unicode characters in the string that have a case
 929  * to uppercase. The exact manner that this is done depends
 930  * on the current locale, and may result in the number of
 931  * characters in the string increasing. (For instance, the
 932  * German ess-zet will be changed to SS.)
 933  *
 934  * Return value: a newly allocated string, with all characters
 935  *    converted to uppercase.
 936  **/
 937 gchar *
 938 g_utf8_strup (const gchar *str,
 939               gssize       len)
 940 {
 941   gsize result_len;
 942   LocaleType locale_type;
 943   gchar *result;
 944
 945   g_return_val_if_fail (str != NULL, NULL);
 946
 947   locale_type = get_locale_type ();
 948
 949   /*
 950    * We use a two pass approach to keep memory management simple
 951    */
 952   result_len = real_toupper (str, len, NULL, locale_type);
 953   result = g_malloc (result_len + 1);
 954   real_toupper (str, len, result, locale_type);
 955   result[result_len] = '\0';
 956
 957   return result;
 958 }
 959
 960 /* traverses the string checking for characters with combining class == 230
 961  * until a base character is found */
 962 static gboolean
 963 has_more_above (const gchar *str)
 964 {
 965   const gchar *p = str;
 966   gint combining_class;
 967
 968   while (*p)
 969     {
 970       combining_class = g_unichar_combining_class (g_utf8_get_char (p));
 971       if (combining_class == 230)
 972         return TRUE;
 973       else if (combining_class == 0)
 974         break;
 975
 976       p = g_utf8_next_char (p);
 977     }
 978
 979   return FALSE;
 980 }
 981
 982 static gsize
 983 real_tolower (const gchar *str,
 984               gssize       max_len,
 985               gchar       *out_buffer,
 986               LocaleType   locale_type)
 987 {
 988   const gchar *p = str;
 989   const char *last = NULL;
 990   gsize len = 0;
 991
 992   while ((max_len < 0 || p < str + max_len) && *p)
 993     {
 994       gunichar c = g_utf8_get_char (p);
 995       int t = TYPE (c);
 996       gunichar val;
 997
 998       last = p;
 999       p = g_utf8_next_char (p);
1000
1001       if (locale_type == LOCALE_TURKIC && c == 'I')
1002         {
1003           if (g_utf8_get_char (p) == 0x0307)
1004             {
1005               /* I + COMBINING DOT ABOVE => i (U+0069) */
1006               len += g_unichar_to_utf8 (0x0069, out_buffer ? out_buffer + len : NULL);
1007               p = g_utf8_next_char (p);
1008             }
1009           else
1010             {
1011               /* I => LATIN SMALL LETTER DOTLESS I */
1012               len += g_unichar_to_utf8 (0x131, out_buffer ? out_buffer + len : NULL);
1013             }
1014         }
1015       /* Introduce an explicit dot above when lowercasing capital I's and J's
1016        * whenever there are more accents above. [SpecialCasing.txt] */
1017       else if (locale_type == LOCALE_LITHUANIAN &&
1018                (c == 0x00cc || c == 0x00cd || c == 0x0128))
1019         {
1020           len += g_unichar_to_utf8 (0x0069, out_buffer ? out_buffer + len : NULL);
1021           len += g_unichar_to_utf8 (0x0307, out_buffer ? out_buffer + len : NULL);
1022
1023           switch (c)
1024             {
1025             case 0x00cc:
1026               len += g_unichar_to_utf8 (0x0300, out_buffer ? out_buffer + len : NULL);
1027               break;
1028             case 0x00cd:
1029               len += g_unichar_to_utf8 (0x0301, out_buffer ? out_buffer + len : NULL);
1030               break;
1031             case 0x0128:
1032               len += g_unichar_to_utf8 (0x0303, out_buffer ? out_buffer + len : NULL);
1033               break;
1034             }
1035         }
1036       else if (locale_type == LOCALE_LITHUANIAN &&
1037                (c == 'I' || c == 'J' || c == 0x012e) &&
1038                has_more_above (p))
1039         {
1040           len += g_unichar_to_utf8 (g_unichar_tolower (c), out_buffer ? out_buffer + len : NULL);
1041           len += g_unichar_to_utf8 (0x0307, out_buffer ? out_buffer + len : NULL);
1042         }
1043       else if (c == 0x03A3)     /* GREEK CAPITAL LETTER SIGMA */
1044         {
1045           if ((max_len < 0 || p < str + max_len) && *p)
1046             {
1047               gunichar next_c = g_utf8_get_char (p);
1048               int next_type = TYPE(next_c);
1049
1050               /* SIGMA mapps differently depending on whether it is
1051                * final or not. The following simplified test would
1052                * fail in the case of combining marks following the
1053                * sigma, but I don't think that occurs in real text.
1054                * The test here matches that in ICU.
1055                */
1056               if (ISALPHA (next_type)) /* Lu,Ll,Lt,Lm,Lo */
1057                 val = 0x3c3;    /* GREEK SMALL SIGMA */
1058               else
1059                 val = 0x3c2;    /* GREEK SMALL FINAL SIGMA */
1060             }
1061           else
1062             val = 0x3c2;        /* GREEK SMALL FINAL SIGMA */
1063
1064           len += g_unichar_to_utf8 (val, out_buffer ? out_buffer + len : NULL);
1065         }
1066       else if (IS (t,
1067                    OR (G_UNICODE_UPPERCASE_LETTER,
1068                    OR (G_UNICODE_TITLECASE_LETTER,
1069                   0))))
1070         {
1071           val = ATTTABLE (c >> 8, c & 0xff);
1072
1073           if (val >= 0x1000000)
1074             {
1075               len += output_special_case (out_buffer ? out_buffer + len : NULL, val - 0x1000000, t, 0);
1076             }
1077           else
1078             {
1079               if (t == G_UNICODE_TITLECASE_LETTER)
1080                 {
1081                   unsigned int i;
1082                   for (i = 0; i < G_N_ELEMENTS (title_table); ++i)
1083                     {
1084                       if (title_table[i][0] == c)
1085                         {
1086                           val = title_table[i][2];
1087                           break;
1088                         }
1089                     }
1090                 }
1091
1092               /* Not all uppercase letters are guaranteed to have a lowercase
1093                * equivalent.  If this is the case, val will be zero. */
1094               len += g_unichar_to_utf8 (val ? val : c, out_buffer ? out_buffer + len : NULL);
1095             }
1096         }
1097       else
1098         {
1099           gsize char_len = g_utf8_skip[*(guchar *)last];
1100
1101           if (out_buffer)
1102             memcpy (out_buffer + len, last, char_len);
1103
1104           len += char_len;
1105         }
1106
1107     }
1108
1109   return len;
1110 }
1111
1112 /**
1113  * g_utf8_strdown:
1114  * @str: a UTF-8 encoded string
1115  * @len: length of @str, in bytes, or -1 if @str is nul-terminated.
1116  *
1117  * Converts all Unicode characters in the string that have a case
1118  * to lowercase. The exact manner that this is done depends
1119  * on the current locale, and may result in the number of
1120  * characters in the string changing.
1121  *
1122  * Return value: a newly allocated string, with all characters
1123  *    converted to lowercase.
1124  **/
1125 gchar *
1126 g_utf8_strdown (const gchar *str,
1127                 gssize       len)
1128 {
1129   gsize result_len;
1130   LocaleType locale_type;
1131   gchar *result;
1132
1133   g_return_val_if_fail (str != NULL, NULL);
1134
1135   locale_type = get_locale_type ();
1136
1137   /*
1138    * We use a two pass approach to keep memory management simple
1139    */
1140   result_len = real_tolower (str, len, NULL, locale_type);
1141   result = g_malloc (result_len + 1);
1142   real_tolower (str, len, result, locale_type);
1143   result[result_len] = '\0';
1144
1145   return result;
1146 }
1147
1148 /**
1149  * g_utf8_casefold:
1150  * @str: a UTF-8 encoded string
1151  * @len: length of @str, in bytes, or -1 if @str is nul-terminated.
1152  *
1153  * Converts a string into a form that is independent of case. The
1154  * result will not correspond to any particular case, but can be
1155  * compared for equality or ordered with the results of calling
1156  * g_utf8_casefold() on other strings.
1157  *
1158  * Note that calling g_utf8_casefold() followed by g_utf8_collate() is
1159  * only an approximation to the correct linguistic case insensitive
1160  * ordering, though it is a fairly good one. Getting this exactly
1161  * right would require a more sophisticated collation function that
1162  * takes case sensitivity into account. GLib does not currently
1163  * provide such a function.
1164  *
1165  * Return value: a newly allocated string, that is a
1166  *   case independent form of @str.
1167  **/
1168 gchar *
1169 g_utf8_casefold (const gchar *str,
1170                  gssize       len)
1171 {
1172   GString *result;
1173   const char *p;
1174
1175   g_return_val_if_fail (str != NULL, NULL);
1176
1177   result = g_string_new (NULL);
1178   p = str;
1179   while ((len < 0 || p < str + len) && *p)
1180     {
1181       gunichar ch = g_utf8_get_char (p);
1182
1183       int start = 0;
1184       int end = G_N_ELEMENTS (casefold_table);
1185
1186       if (ch >= casefold_table[start].ch &&
1187           ch <= casefold_table[end - 1].ch)
1188         {
1189           while (TRUE)
1190             {
1191               int half = (start + end) / 2;
1192               if (ch == casefold_table[half].ch)
1193                 {
1194                   g_string_append (result, casefold_table[half].data);
1195                   goto next;
1196                 }
1197               else if (half == start)
1198                 break;
1199               else if (ch > casefold_table[half].ch)
1200                 start = half;
1201               else
1202                 end = half;
1203             }
1204         }
1205
1206       g_string_append_unichar (result, g_unichar_tolower (ch));
1207
1208     next:
1209       p = g_utf8_next_char (p);
1210     }
1211
1212   return g_string_free (result, FALSE);
1213 }
1214
1215 /**
1216  * g_unichar_get_mirror_char:
1217  * @ch: a Unicode character
1218  * @mirrored_ch: location to store the mirrored character
1219  *
1220  * In Unicode, some characters are <firstterm>mirrored</firstterm>. This
1221  * means that their images are mirrored horizontally in text that is laid
1222  * out from right to left. For instance, "(" would become its mirror image,
1223  * ")", in right-to-left text.
1224  *
1225  * If @ch has the Unicode mirrored property and there is another unicode
1226  * character that typically has a glyph that is the mirror image of @ch's
1227  * glyph and @mirrored_ch is set, it puts that character in the address
1228  * pointed to by @mirrored_ch.  Otherwise the original character is put.
1229  *
1230  * Return value: %TRUE if @ch has a mirrored character, %FALSE otherwise
1231  *
1232  * Since: 2.4
1233  **/
1234 gboolean
1235 g_unichar_get_mirror_char (gunichar ch,
1236                            gunichar *mirrored_ch)
1237 {
1238   gboolean found;
1239   gunichar mirrored;
1240
1241   mirrored = GLIB_GET_MIRRORING(ch);
1242
1243   found = ch != mirrored;
1244   if (mirrored_ch)
1245     *mirrored_ch = mirrored;
1246
1247   return found;
1248
1249 }
1250
1251 #define G_SCRIPT_TABLE_MIDPOINT (G_N_ELEMENTS (g_script_table) / 2)
1252
1253 static inline GUnicodeScript
1254 g_unichar_get_script_bsearch (gunichar ch)
1255 {
1256   int lower = 0;
1257   int upper = G_N_ELEMENTS (g_script_table) - 1;
1258   static int saved_mid = G_SCRIPT_TABLE_MIDPOINT;
1259   int mid = saved_mid;
1260
1261
1262   do
1263     {
1264       if (ch < g_script_table[mid].start)
1265         upper = mid - 1;
1266       else if (ch >= g_script_table[mid].start + g_script_table[mid].chars)
1267         lower = mid + 1;
1268       else
1269         return g_script_table[saved_mid = mid].script;
1270
1271       mid = (lower + upper) / 2;
1272     }
1273   while (lower <= upper);
1274
1275   return G_UNICODE_SCRIPT_UNKNOWN;
1276 }
1277
1278 /**
1279  * g_unichar_get_script:
1280  * @ch: a Unicode character
1281  *
1282  * Looks up the #GUnicodeScript for a particular character (as defined
1283  * by Unicode Standard Annex #24). No check is made for @ch being a
1284  * valid Unicode character; if you pass in invalid character, the
1285  * result is undefined.
1286  *
1287  * This function is equivalent to pango_script_for_unichar() and the
1288  * two are interchangeable.
1289  *
1290  * Return value: the #GUnicodeScript for the character.
1291  *
1292  * Since: 2.14
1293  */
1294 GUnicodeScript
1295 g_unichar_get_script (gunichar ch)
1296 {
1297   if (ch < G_EASY_SCRIPTS_RANGE)
1298     return g_script_easy_table[ch];
1299   else
1300     return g_unichar_get_script_bsearch (ch);
1301 }