guniprop.c 42.5 KB
Newer Older
1 2 3 4 5 6
/* guniprop.c - Unicode character properties.
 *
 * Copyright (C) 1999 Tom Tromey
 * Copyright (C) 2000 Red Hat, Inc.
 *
 * 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.1 of the License, or (at your option) any later version.
10 11 12 13
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * 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, see <http://www.gnu.org/licenses/>.
18 19
 */

20
#include "config.h"
21

Behdad Esfahbod's avatar
Behdad Esfahbod committed
22
#include <stdlib.h>
23
#include <stddef.h>
24 25
#include <string.h>
#include <locale.h>
26

Matthias Clasen's avatar
Matthias Clasen committed
27 28 29 30 31
#include "gmem.h"
#include "gstring.h"
#include "gtestutils.h"
#include "gtypes.h"
#include "gunicode.h"
32
#include "gunichartables.h"
33
#include "gmirroringtable.h"
34
#include "gscripttable.h"
35
#include "gunicodeprivate.h"
36 37 38
#ifdef G_OS_WIN32
#include "gwin32.h"
#endif
39

40 41 42
#define ATTR_TABLE(Page) (((Page) <= G_UNICODE_LAST_PAGE_PART1) \
                          ? attr_table_part1[Page] \
                          : attr_table_part2[(Page) - 0xe00])
43

44
#define ATTTABLE(Page, Char) \
45
  ((ATTR_TABLE(Page) == G_UNICODE_MAX_TABLE_INDEX) ? 0 : (attr_data[ATTR_TABLE(Page)][Char]))
46

47 48 49 50
#define TTYPE_PART1(Page, Char) \
  ((type_table_part1[Page] >= G_UNICODE_MAX_TABLE_INDEX) \
   ? (type_table_part1[Page] - G_UNICODE_MAX_TABLE_INDEX) \
   : (type_data[type_table_part1[Page]][Char]))
51

52 53 54 55 56 57 58 59 60 61 62
#define TTYPE_PART2(Page, Char) \
  ((type_table_part2[Page] >= G_UNICODE_MAX_TABLE_INDEX) \
   ? (type_table_part2[Page] - G_UNICODE_MAX_TABLE_INDEX) \
   : (type_data[type_table_part2[Page]][Char]))

#define TYPE(Char) \
  (((Char) <= G_UNICODE_LAST_CHAR_PART1) \
   ? TTYPE_PART1 ((Char) >> 8, (Char) & 0xff) \
   : (((Char) >= 0xe0000 && (Char) <= G_UNICODE_LAST_CHAR) \
      ? TTYPE_PART2 (((Char) - 0xe0000) >> 8, (Char) & 0xff) \
      : G_UNICODE_UNASSIGNED))
63 64


65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88
#define IS(Type, Class)	(((guint)1 << (Type)) & (Class))
#define OR(Type, Rest)	(((guint)1 << (Type)) | (Rest))



#define ISALPHA(Type)	IS ((Type),				\
			    OR (G_UNICODE_LOWERCASE_LETTER,	\
			    OR (G_UNICODE_UPPERCASE_LETTER,	\
			    OR (G_UNICODE_TITLECASE_LETTER,	\
			    OR (G_UNICODE_MODIFIER_LETTER,	\
			    OR (G_UNICODE_OTHER_LETTER,		0))))))

#define ISALDIGIT(Type)	IS ((Type),				\
			    OR (G_UNICODE_DECIMAL_NUMBER,	\
			    OR (G_UNICODE_LETTER_NUMBER,	\
			    OR (G_UNICODE_OTHER_NUMBER,		\
			    OR (G_UNICODE_LOWERCASE_LETTER,	\
			    OR (G_UNICODE_UPPERCASE_LETTER,	\
			    OR (G_UNICODE_TITLECASE_LETTER,	\
			    OR (G_UNICODE_MODIFIER_LETTER,	\
			    OR (G_UNICODE_OTHER_LETTER,		0)))))))))

#define ISMARK(Type)	IS ((Type),				\
			    OR (G_UNICODE_NON_SPACING_MARK,	\
89
			    OR (G_UNICODE_SPACING_MARK,	\
90
			    OR (G_UNICODE_ENCLOSING_MARK,	0))))
91

92 93 94 95 96
#define ISZEROWIDTHTYPE(Type)	IS ((Type),			\
			    OR (G_UNICODE_NON_SPACING_MARK,	\
			    OR (G_UNICODE_ENCLOSING_MARK,	\
			    OR (G_UNICODE_FORMAT,		0))))

Havoc Pennington's avatar
Havoc Pennington committed
97 98 99 100 101 102 103 104
/**
 * g_unichar_isalnum:
 * @c: a Unicode character
 * 
 * Determines whether a character is alphanumeric.
 * Given some UTF-8 text, obtain a character value
 * with g_utf8_get_char().
 * 
105
 * Returns: %TRUE if @c is an alphanumeric character
Havoc Pennington's avatar
Havoc Pennington committed
106
 **/
107 108 109
gboolean
g_unichar_isalnum (gunichar c)
{
110
  return ISALDIGIT (TYPE (c)) ? TRUE : FALSE;
111 112
}

Havoc Pennington's avatar
Havoc Pennington committed
113 114 115 116 117 118 119 120
/**
 * g_unichar_isalpha:
 * @c: a Unicode character
 * 
 * Determines whether a character is alphabetic (i.e. a letter).
 * Given some UTF-8 text, obtain a character value with
 * g_utf8_get_char().
 * 
121
 * Returns: %TRUE if @c is an alphabetic character
Havoc Pennington's avatar
Havoc Pennington committed
122
 **/
123 124 125
gboolean
g_unichar_isalpha (gunichar c)
{
126
  return ISALPHA (TYPE (c)) ? TRUE : FALSE;
127 128
}

Havoc Pennington's avatar
Havoc Pennington committed
129 130 131 132 133 134 135 136 137

/**
 * g_unichar_iscntrl:
 * @c: a Unicode character
 * 
 * Determines whether a character is a control character.
 * Given some UTF-8 text, obtain a character value with
 * g_utf8_get_char().
 * 
138
 * Returns: %TRUE if @c is a control character
Havoc Pennington's avatar
Havoc Pennington committed
139
 **/
140 141 142 143 144 145
gboolean
g_unichar_iscntrl (gunichar c)
{
  return TYPE (c) == G_UNICODE_CONTROL;
}

Havoc Pennington's avatar
Havoc Pennington committed
146 147 148 149 150 151 152 153
/**
 * g_unichar_isdigit:
 * @c: a Unicode character
 * 
 * Determines whether a character is numeric (i.e. a digit).  This
 * covers ASCII 0-9 and also digits in other languages/scripts.  Given
 * some UTF-8 text, obtain a character value with g_utf8_get_char().
 * 
154
 * Returns: %TRUE if @c is a digit
Havoc Pennington's avatar
Havoc Pennington committed
155
 **/
156 157 158 159 160 161
gboolean
g_unichar_isdigit (gunichar c)
{
  return TYPE (c) == G_UNICODE_DECIMAL_NUMBER;
}

Havoc Pennington's avatar
Havoc Pennington committed
162 163 164 165 166 167 168 169 170 171 172

/**
 * g_unichar_isgraph:
 * @c: a Unicode character
 * 
 * Determines whether a character is printable and not a space
 * (returns %FALSE for control characters, format characters, and
 * spaces). g_unichar_isprint() is similar, but returns %TRUE for
 * spaces. Given some UTF-8 text, obtain a character value with
 * g_utf8_get_char().
 * 
173
 * Returns: %TRUE if @c is printable unless it's a space
Havoc Pennington's avatar
Havoc Pennington committed
174
 **/
175 176 177
gboolean
g_unichar_isgraph (gunichar c)
{
178 179 180 181 182 183
  return !IS (TYPE(c),
	      OR (G_UNICODE_CONTROL,
	      OR (G_UNICODE_FORMAT,
	      OR (G_UNICODE_UNASSIGNED,
	      OR (G_UNICODE_SURROGATE,
	      OR (G_UNICODE_SPACE_SEPARATOR,
184
	     0))))));
185 186
}

Havoc Pennington's avatar
Havoc Pennington committed
187 188 189 190 191 192 193 194
/**
 * g_unichar_islower:
 * @c: a Unicode character
 * 
 * Determines whether a character is a lowercase letter.
 * Given some UTF-8 text, obtain a character value with
 * g_utf8_get_char().
 * 
195
 * Returns: %TRUE if @c is a lowercase letter
Havoc Pennington's avatar
Havoc Pennington committed
196
 **/
197 198 199 200 201 202
gboolean
g_unichar_islower (gunichar c)
{
  return TYPE (c) == G_UNICODE_LOWERCASE_LETTER;
}

Havoc Pennington's avatar
Havoc Pennington committed
203 204 205 206 207 208 209 210 211 212

/**
 * g_unichar_isprint:
 * @c: a Unicode character
 * 
 * Determines whether a character is printable.
 * Unlike g_unichar_isgraph(), returns %TRUE for spaces.
 * Given some UTF-8 text, obtain a character value with
 * g_utf8_get_char().
 * 
213
 * Returns: %TRUE if @c is printable
Havoc Pennington's avatar
Havoc Pennington committed
214
 **/
215 216 217
gboolean
g_unichar_isprint (gunichar c)
{
218 219 220 221 222
  return !IS (TYPE(c),
	      OR (G_UNICODE_CONTROL,
	      OR (G_UNICODE_FORMAT,
	      OR (G_UNICODE_UNASSIGNED,
	      OR (G_UNICODE_SURROGATE,
223
	     0)))));
224 225
}

Havoc Pennington's avatar
Havoc Pennington committed
226 227 228 229
/**
 * g_unichar_ispunct:
 * @c: a Unicode character
 * 
230
 * Determines whether a character is punctuation or a symbol.
Havoc Pennington's avatar
Havoc Pennington committed
231 232 233
 * Given some UTF-8 text, obtain a character value with
 * g_utf8_get_char().
 * 
234
 * Returns: %TRUE if @c is a punctuation or symbol character
Havoc Pennington's avatar
Havoc Pennington committed
235
 **/
236 237 238
gboolean
g_unichar_ispunct (gunichar c)
{
239 240 241 242 243 244 245 246 247 248 249 250 251
  return IS (TYPE(c),
	     OR (G_UNICODE_CONNECT_PUNCTUATION,
	     OR (G_UNICODE_DASH_PUNCTUATION,
	     OR (G_UNICODE_CLOSE_PUNCTUATION,
	     OR (G_UNICODE_FINAL_PUNCTUATION,
	     OR (G_UNICODE_INITIAL_PUNCTUATION,
	     OR (G_UNICODE_OTHER_PUNCTUATION,
	     OR (G_UNICODE_OPEN_PUNCTUATION,
	     OR (G_UNICODE_CURRENCY_SYMBOL,
	     OR (G_UNICODE_MODIFIER_SYMBOL,
	     OR (G_UNICODE_MATH_SYMBOL,
	     OR (G_UNICODE_OTHER_SYMBOL,
	    0)))))))))))) ? TRUE : FALSE;
252 253
}

Havoc Pennington's avatar
Havoc Pennington committed
254 255 256 257 258 259 260 261 262 263 264 265
/**
 * g_unichar_isspace:
 * @c: a Unicode character
 * 
 * Determines whether a character is a space, tab, or line separator
 * (newline, carriage return, etc.).  Given some UTF-8 text, obtain a
 * character value with g_utf8_get_char().
 *
 * (Note: don't use this to do word breaking; you have to use
 * Pango or equivalent to get word breaking right, the algorithm
 * is fairly complex.)
 *  
266
 * Returns: %TRUE if @c is a space character
Havoc Pennington's avatar
Havoc Pennington committed
267
 **/
268 269 270
gboolean
g_unichar_isspace (gunichar c)
{
271
  switch (c)
Havoc Pennington's avatar
Havoc Pennington committed
272
    {
273 274 275 276 277 278 279 280 281 282
      /* special-case these since Unicode thinks they are not spaces */
    case '\t':
    case '\n':
    case '\r':
    case '\f':
      return TRUE;
      break;
      
    default:
      {
283 284 285 286 287
	return IS (TYPE(c),
	           OR (G_UNICODE_SPACE_SEPARATOR,
	           OR (G_UNICODE_LINE_SEPARATOR,
                   OR (G_UNICODE_PARAGRAPH_SEPARATOR,
		  0)))) ? TRUE : FALSE;
288 289
      }
      break;
Havoc Pennington's avatar
Havoc Pennington committed
290
    }
291 292
}

293 294 295 296 297 298 299 300 301 302 303 304 305 306
/**
 * g_unichar_ismark:
 * @c: a Unicode character
 *
 * Determines whether a character is a mark (non-spacing mark,
 * combining mark, or enclosing mark in Unicode speak).
 * Given some UTF-8 text, obtain a character value
 * with g_utf8_get_char().
 *
 * Note: in most cases where isalpha characters are allowed,
 * ismark characters should be allowed to as they are essential
 * for writing most European languages as well as many non-Latin
 * scripts.
 *
307
 * Returns: %TRUE if @c is a mark character
308 309 310 311 312 313 314 315 316
 *
 * Since: 2.14
 **/
gboolean
g_unichar_ismark (gunichar c)
{
  return ISMARK (TYPE (c));
}

317 318
/**
 * g_unichar_isupper:
319
 * @c: a Unicode character
320 321 322
 * 
 * Determines if a character is uppercase.
 * 
323
 * Returns: %TRUE if @c is an uppercase character
324 325 326 327 328 329 330 331 332
 **/
gboolean
g_unichar_isupper (gunichar c)
{
  return TYPE (c) == G_UNICODE_UPPERCASE_LETTER;
}

/**
 * g_unichar_istitle:
333
 * @c: a Unicode character
334 335 336 337 338 339
 * 
 * Determines if a character is titlecase. Some characters in
 * Unicode which are composites, such as the DZ digraph
 * have three case variants instead of just two. The titlecase
 * form is used at the beginning of a word where only the
 * first letter is capitalized. The titlecase form of the DZ
340
 * digraph is U+01F2 LATIN CAPITAL LETTTER D WITH SMALL LETTER Z.
341
 * 
342
 * Returns: %TRUE if the character is titlecase
343 344 345 346 347
 **/
gboolean
g_unichar_istitle (gunichar c)
{
  unsigned int i;
348
  for (i = 0; i < G_N_ELEMENTS (title_table); ++i)
349
    if (title_table[i][0] == c)
350 351
      return TRUE;
  return FALSE;
352 353 354 355
}

/**
 * g_unichar_isxdigit:
356
 * @c: a Unicode character.
357
 * 
358
 * Determines if a character is a hexidecimal digit.
359
 * 
360
 * Returns: %TRUE if the character is a hexadecimal digit
361 362 363 364 365 366
 **/
gboolean
g_unichar_isxdigit (gunichar c)
{
  return ((c >= 'a' && c <= 'f')
	  || (c >= 'A' && c <= 'F')
367
	  || (TYPE (c) == G_UNICODE_DECIMAL_NUMBER));
368 369 370 371
}

/**
 * g_unichar_isdefined:
372
 * @c: a Unicode character
373 374
 * 
 * Determines if a given character is assigned in the Unicode
Havoc Pennington's avatar
Havoc Pennington committed
375
 * standard.
376
 *
377
 * Returns: %TRUE if the character has an assigned value
378 379 380 381
 **/
gboolean
g_unichar_isdefined (gunichar c)
{
382 383 384 385
  return !IS (TYPE(c),
	      OR (G_UNICODE_UNASSIGNED,
	      OR (G_UNICODE_SURROGATE,
	     0)));
386 387
}

388 389 390 391 392 393 394 395 396 397 398 399 400 401
/**
 * g_unichar_iszerowidth:
 * @c: a Unicode character
 * 
 * Determines if a given character typically takes zero width when rendered.
 * The return value is %TRUE for all non-spacing and enclosing marks
 * (e.g., combining accents), format characters, zero-width
 * space, but not U+00AD SOFT HYPHEN.
 *
 * A typical use of this function is with one of g_unichar_iswide() or
 * g_unichar_iswide_cjk() to determine the number of cells a string occupies
 * when displayed on a grid display (terminals).  However, note that not all
 * terminals support zero-width rendering of zero-width marks.
 *
402
 * Returns: %TRUE if the character has zero width
403 404 405 406 407 408 409 410 411
 *
 * Since: 2.14
 **/
gboolean
g_unichar_iszerowidth (gunichar c)
{
  if (G_UNLIKELY (c == 0x00AD))
    return FALSE;

412
  if (G_UNLIKELY (ISZEROWIDTHTYPE (TYPE (c))))
413 414 415 416 417 418 419 420 421
    return TRUE;

  if (G_UNLIKELY ((c >= 0x1160 && c < 0x1200) ||
		  c == 0x200B))
    return TRUE;

  return FALSE;
}

Matthias Clasen's avatar
Matthias Clasen committed
422
static int
423 424 425
interval_compare (const void *key, const void *elt)
{
  gunichar c = GPOINTER_TO_UINT (key);
426
  struct Interval *interval = (struct Interval *)elt;
427 428 429 430 431 432 433 434 435

  if (c < interval->start)
    return -1;
  if (c > interval->end)
    return +1;

  return 0;
}

436 437 438 439 440 441
#define G_WIDTH_TABLE_MIDPOINT (G_N_ELEMENTS (g_unicode_width_table_wide) / 2)

static inline gboolean
g_unichar_iswide_bsearch (gunichar ch)
{
  int lower = 0;
442
  int upper = G_N_ELEMENTS (g_unicode_width_table_wide) - 1;
443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461
  static int saved_mid = G_WIDTH_TABLE_MIDPOINT;
  int mid = saved_mid;

  do
    {
      if (ch < g_unicode_width_table_wide[mid].start)
	upper = mid - 1;
      else if (ch > g_unicode_width_table_wide[mid].end)
	lower = mid + 1;
      else
	return TRUE;

      mid = (lower + upper) / 2;
    }
  while (lower <= upper);

  return FALSE;
}

462 463 464 465 466 467 468
/**
 * g_unichar_iswide:
 * @c: a Unicode character
 * 
 * Determines if a character is typically rendered in a double-width
 * cell.
 * 
469
 * Returns: %TRUE if the character is wide
470 471 472 473
 **/
gboolean
g_unichar_iswide (gunichar c)
{
474 475 476 477
  if (c < g_unicode_width_table_wide[0].start)
    return FALSE;
  else
    return g_unichar_iswide_bsearch (c);
478 479 480
}


481 482 483 484 485 486 487
/**
 * g_unichar_iswide_cjk:
 * @c: a Unicode character
 * 
 * Determines if a character is typically rendered in a double-width
 * cell under legacy East Asian locales.  If a character is wide according to
 * g_unichar_iswide(), then it is also reported wide with this function, but
488 489 490
 * the converse is not necessarily true. See the
 * [Unicode Standard Annex #11](http://www.unicode.org/reports/tr11/)
 * for details.
491 492 493
 *
 * If a character passes the g_unichar_iswide() test then it will also pass
 * this test, but not the other way around.  Note that some characters may
494
 * pass both this test and g_unichar_iszerowidth().
495
 * 
496
 * Returns: %TRUE if the character is wide in legacy East Asian locales
Matthias Clasen's avatar
Matthias Clasen committed
497 498 499
 *
 * Since: 2.12
 */
500 501 502 503 504 505
gboolean
g_unichar_iswide_cjk (gunichar c)
{
  if (g_unichar_iswide (c))
    return TRUE;

506 507 508 509 510
  /* bsearch() is declared attribute(nonnull(1)) so we can't validly search
   * for a NULL key */
  if (c == 0)
    return FALSE;

511 512 513 514
  if (bsearch (GUINT_TO_POINTER (c), 
               g_unicode_width_table_ambiguous,
               G_N_ELEMENTS (g_unicode_width_table_ambiguous),
               sizeof g_unicode_width_table_ambiguous[0],
515 516 517 518 519 520 521
	       interval_compare))
    return TRUE;

  return FALSE;
}


522 523
/**
 * g_unichar_toupper:
524
 * @c: a Unicode character
525
 * 
526
 * Converts a character to uppercase.
527
 * 
528
 * Returns: the result of converting @c to uppercase.
529
 *               If @c is not an lowercase or titlecase character,
530
 *               or has no upper case equivalent @c is returned unchanged.
531 532 533 534 535 536
 **/
gunichar
g_unichar_toupper (gunichar c)
{
  int t = TYPE (c);
  if (t == G_UNICODE_LOWERCASE_LETTER)
537 538
    {
      gunichar val = ATTTABLE (c >> 8, c & 0xff);
539
      if (val >= 0x1000000)
540
	{
541
	  const gchar *p = special_case_table + val - 0x1000000;
542
          val = g_utf8_get_char (p);
543
	}
544 545 546 547 548
      /* Some lowercase letters, e.g., U+000AA, FEMININE ORDINAL INDICATOR,
       * do not have an uppercase equivalent, in which case val will be
       * zero. 
       */
      return val ? val : c;
549
    }
550 551 552
  else if (t == G_UNICODE_TITLECASE_LETTER)
    {
      unsigned int i;
553
      for (i = 0; i < G_N_ELEMENTS (title_table); ++i)
554 555
	{
	  if (title_table[i][0] == c)
556
	    return title_table[i][1] ? title_table[i][1] : c;
557 558 559 560 561 562 563
	}
    }
  return c;
}

/**
 * g_unichar_tolower:
564
 * @c: a Unicode character.
565
 * 
566
 * Converts a character to lower case.
567
 * 
568
 * Returns: the result of converting @c to lower case.
569
 *               If @c is not an upperlower or titlecase character,
570
 *               or has no lowercase equivalent @c is returned unchanged.
571 572 573 574 575 576
 **/
gunichar
g_unichar_tolower (gunichar c)
{
  int t = TYPE (c);
  if (t == G_UNICODE_UPPERCASE_LETTER)
577 578
    {
      gunichar val = ATTTABLE (c >> 8, c & 0xff);
579
      if (val >= 0x1000000)
580
	{
581
	  const gchar *p = special_case_table + val - 0x1000000;
582
	  return g_utf8_get_char (p);
583 584
	}
      else
585 586 587 588 589
	{
	  /* Not all uppercase letters are guaranteed to have a lowercase
	   * equivalent.  If this is the case, val will be zero. */
	  return val ? val : c;
	}
590
    }
591 592 593
  else if (t == G_UNICODE_TITLECASE_LETTER)
    {
      unsigned int i;
594
      for (i = 0; i < G_N_ELEMENTS (title_table); ++i)
595 596 597 598 599 600 601 602 603 604
	{
	  if (title_table[i][0] == c)
	    return title_table[i][2];
	}
    }
  return c;
}

/**
 * g_unichar_totitle:
605
 * @c: a Unicode character
606
 * 
607
 * Converts a character to the titlecase.
608
 * 
609
 * Returns: the result of converting @c to titlecase.
610 611 612 613 614 615 616
 *               If @c is not an uppercase or lowercase character,
 *               @c is returned unchanged.
 **/
gunichar
g_unichar_totitle (gunichar c)
{
  unsigned int i;
617
  for (i = 0; i < G_N_ELEMENTS (title_table); ++i)
618 619 620 621 622
    {
      if (title_table[i][0] == c || title_table[i][1] == c
	  || title_table[i][2] == c)
	return title_table[i][0];
    }
623 624 625 626 627
    
  if (TYPE (c) == G_UNICODE_LOWERCASE_LETTER)
    return g_unichar_toupper (c);

  return c;
628 629 630
}

/**
Havoc Pennington's avatar
Havoc Pennington committed
631
 * g_unichar_digit_value:
632
 * @c: a Unicode character
633 634
 *
 * Determines the numeric value of a character as a decimal
635
 * digit.
636
 *
637
 * Returns: If @c is a decimal digit (according to
638
 * g_unichar_isdigit()), its numeric value. Otherwise, -1.
639 640 641 642 643 644 645 646 647 648 649
 **/
int
g_unichar_digit_value (gunichar c)
{
  if (TYPE (c) == G_UNICODE_DECIMAL_NUMBER)
    return ATTTABLE (c >> 8, c & 0xff);
  return -1;
}

/**
 * g_unichar_xdigit_value:
650
 * @c: a Unicode character
651 652
 *
 * Determines the numeric value of a character as a hexidecimal
653
 * digit.
654
 *
655
 * Returns: If @c is a hex digit (according to
656
 * g_unichar_isxdigit()), its numeric value. Otherwise, -1.
657 658 659 660 661
 **/
int
g_unichar_xdigit_value (gunichar c)
{
  if (c >= 'A' && c <= 'F')
662
    return c - 'A' + 10;
663
  if (c >= 'a' && c <= 'f')
664
    return c - 'a' + 10;
665 666 667 668 669 670 671
  if (TYPE (c) == G_UNICODE_DECIMAL_NUMBER)
    return ATTTABLE (c >> 8, c & 0xff);
  return -1;
}

/**
 * g_unichar_type:
672
 * @c: a Unicode character
673
 * 
674
 * Classifies a Unicode character by type.
675
 * 
676
 * Returns: the type of the character.
677 678 679 680 681 682
 **/
GUnicodeType
g_unichar_type (gunichar c)
{
  return TYPE (c);
}
683 684 685 686 687 688 689 690 691 692 693 694 695 696

/*
 * Case mapping functions
 */

typedef enum {
  LOCALE_NORMAL,
  LOCALE_TURKIC,
  LOCALE_LITHUANIAN
} LocaleType;

static LocaleType
get_locale_type (void)
{
697 698 699 700 701 702 703 704
#ifdef G_OS_WIN32
  char *tem = g_win32_getlocale ();
  char locale[2];

  locale[0] = tem[0];
  locale[1] = tem[1];
  g_free (tem);
#else
705
  const char *locale = setlocale (LC_CTYPE, NULL);
706 707 708

  if (locale == NULL)
    return LOCALE_NORMAL;
709
#endif
710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729

  switch (locale[0])
    {
   case 'a':
      if (locale[1] == 'z')
	return LOCALE_TURKIC;
      break;
    case 'l':
      if (locale[1] == 't')
	return LOCALE_LITHUANIAN;
      break;
    case 't':
      if (locale[1] == 'r')
	return LOCALE_TURKIC;
      break;
    }

  return LOCALE_NORMAL;
}

730
static gint
731 732 733 734 735
output_marks (const char **p_inout,
	      char        *out_buffer,
	      gboolean     remove_dot)
{
  const char *p = *p_inout;
736
  gint len = 0;
737 738 739 740 741
  
  while (*p)
    {
      gunichar c = g_utf8_get_char (p);
      
742
      if (ISMARK (TYPE (c)))
743 744
	{
	  if (!remove_dot || c != 0x307 /* COMBINING DOT ABOVE */)
745
	    len += g_unichar_to_utf8 (c, out_buffer ? out_buffer + len : NULL);
746 747 748 749 750 751 752 753 754 755
	  p = g_utf8_next_char (p);
	}
      else
	break;
    }

  *p_inout = p;
  return len;
}

756
static gint
757
output_special_case (gchar *out_buffer,
758
		     int    offset,
759 760 761
		     int    type,
		     int    which)
{
762
  const gchar *p = special_case_table + offset;
763
  gint len;
764 765

  if (type != G_UNICODE_TITLECASE_LETTER)
766
    p = g_utf8_next_char (p);
767 768

  if (which == 1)
769
    p += strlen (p) + 1;
770

771 772 773
  len = strlen (p);
  if (out_buffer)
    memcpy (out_buffer, p, len);
774 775 776 777 778 779

  return len;
}

static gsize
real_toupper (const gchar *str,
780
	      gssize       max_len,
781 782 783 784 785 786 787 788
	      gchar       *out_buffer,
	      LocaleType   locale_type)
{
  const gchar *p = str;
  const char *last = NULL;
  gsize len = 0;
  gboolean last_was_i = FALSE;

789
  while ((max_len < 0 || p < str + max_len) && *p)
790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810
    {
      gunichar c = g_utf8_get_char (p);
      int t = TYPE (c);
      gunichar val;

      last = p;
      p = g_utf8_next_char (p);

      if (locale_type == LOCALE_LITHUANIAN)
	{
	  if (c == 'i')
	    last_was_i = TRUE;
	  else 
	    {
	      if (last_was_i)
		{
		  /* Nasty, need to remove any dot above. Though
		   * I think only E WITH DOT ABOVE occurs in practice
		   * which could simplify this considerably.
		   */
		  gsize decomp_len, i;
811
		  gunichar decomp[G_UNICHAR_MAX_DECOMPOSITION_LENGTH];
812

813
		  decomp_len = g_unichar_fully_decompose (c, FALSE, decomp, G_N_ELEMENTS (decomp));
814 815 816 817 818 819
		  for (i=0; i < decomp_len; i++)
		    {
		      if (decomp[i] != 0x307 /* COMBINING DOT ABOVE */)
			len += g_unichar_to_utf8 (g_unichar_toupper (decomp[i]), out_buffer ? out_buffer + len : NULL);
		    }
		  
820
		  len += output_marks (&p, out_buffer ? out_buffer + len : NULL, TRUE);
821 822 823 824

		  continue;
		}

825
	      if (!ISMARK (t))
826 827 828
		last_was_i = FALSE;
	    }
	}
829

830 831 832 833 834 835 836 837 838 839
      if (locale_type == LOCALE_TURKIC && c == 'i')
	{
	  /* i => LATIN CAPITAL LETTER I WITH DOT ABOVE */
	  len += g_unichar_to_utf8 (0x130, out_buffer ? out_buffer + len : NULL); 
	}
      else if (c == 0x0345)	/* COMBINING GREEK YPOGEGRAMMENI */
	{
	  /* Nasty, need to move it after other combining marks .. this would go away if
	   * we normalized first.
	   */
840
	  len += output_marks (&p, out_buffer ? out_buffer + len : NULL, FALSE);
841 842 843 844

	  /* And output as GREEK CAPITAL LETTER IOTA */
	  len += g_unichar_to_utf8 (0x399, out_buffer ? out_buffer + len : NULL); 	  
	}
845 846 847 848
      else if (IS (t,
		   OR (G_UNICODE_LOWERCASE_LETTER,
		   OR (G_UNICODE_TITLECASE_LETTER,
		  0))))
849 850 851
	{
	  val = ATTTABLE (c >> 8, c & 0xff);

852
	  if (val >= 0x1000000)
853
	    {
854
	      len += output_special_case (out_buffer ? out_buffer + len : NULL, val - 0x1000000, t,
855 856 857 858 859 860 861 862 863 864
					  t == G_UNICODE_LOWERCASE_LETTER ? 0 : 1);
	    }
	  else
	    {
	      if (t == G_UNICODE_TITLECASE_LETTER)
		{
		  unsigned int i;
		  for (i = 0; i < G_N_ELEMENTS (title_table); ++i)
		    {
		      if (title_table[i][0] == c)
865 866 867 868
			{
			  val = title_table[i][1];
			  break;
			}
869 870 871
		    }
		}

872 873 874 875
	      /* Some lowercase letters, e.g., U+000AA, FEMININE ORDINAL INDICATOR,
	       * do not have an uppercase equivalent, in which case val will be
	       * zero. */
	      len += g_unichar_to_utf8 (val ? val : c, out_buffer ? out_buffer + len : NULL);
876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893
	    }
	}
      else
	{
	  gsize char_len = g_utf8_skip[*(guchar *)last];

	  if (out_buffer)
	    memcpy (out_buffer + len, last, char_len);

	  len += char_len;
	}

    }

  return len;
}

/**
894 895 896
 * g_utf8_strup:
 * @str: a UTF-8 encoded string
 * @len: length of @str, in bytes, or -1 if @str is nul-terminated.
897 898 899 900 901 902 903
 * 
 * Converts all Unicode characters in the string that have a case
 * to uppercase. The exact manner that this is done depends
 * on the current locale, and may result in the number of
 * characters in the string increasing. (For instance, the
 * German ess-zet will be changed to SS.)
 * 
904
 * Returns: a newly allocated string, with all characters
905 906 907
 *    converted to uppercase.  
 **/
gchar *
908 909
g_utf8_strup (const gchar *str,
	      gssize       len)
910
{
911
  gsize result_len;
912 913 914 915 916 917 918 919 920 921
  LocaleType locale_type;
  gchar *result;

  g_return_val_if_fail (str != NULL, NULL);

  locale_type = get_locale_type ();
  
  /*
   * We use a two pass approach to keep memory management simple
   */
922 923
  result_len = real_toupper (str, len, NULL, locale_type);
  result = g_malloc (result_len + 1);
924
  real_toupper (str, len, result, locale_type);
925
  result[result_len] = '\0';
926 927 928 929

  return result;
}

930 931 932
/* traverses the string checking for characters with combining class == 230
 * until a base character is found */
static gboolean
933
has_more_above (const gchar *str)
934
{
935
  const gchar *p = str;
936 937 938 939
  gint combining_class;

  while (*p)
    {
940
      combining_class = g_unichar_combining_class (g_utf8_get_char (p));
941 942 943 944 945 946 947 948 949 950 951
      if (combining_class == 230)
        return TRUE;
      else if (combining_class == 0)
        break;

      p = g_utf8_next_char (p);
    }

  return FALSE;
}

952 953
static gsize
real_tolower (const gchar *str,
954
	      gssize       max_len,
955 956 957 958 959 960 961
	      gchar       *out_buffer,
	      LocaleType   locale_type)
{
  const gchar *p = str;
  const char *last = NULL;
  gsize len = 0;

962
  while ((max_len < 0 || p < str + max_len) && *p)
963 964 965 966 967 968 969 970 971 972
    {
      gunichar c = g_utf8_get_char (p);
      int t = TYPE (c);
      gunichar val;

      last = p;
      p = g_utf8_next_char (p);

      if (locale_type == LOCALE_TURKIC && c == 'I')
	{
973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012
          if (g_utf8_get_char (p) == 0x0307)
            {
              /* I + COMBINING DOT ABOVE => i (U+0069) */
              len += g_unichar_to_utf8 (0x0069, out_buffer ? out_buffer + len : NULL); 
              p = g_utf8_next_char (p);
            }
          else
            {
              /* I => LATIN SMALL LETTER DOTLESS I */
              len += g_unichar_to_utf8 (0x131, out_buffer ? out_buffer + len : NULL); 
            }
        }
      /* Introduce an explicit dot above when lowercasing capital I's and J's
       * whenever there are more accents above. [SpecialCasing.txt] */
      else if (locale_type == LOCALE_LITHUANIAN && 
               (c == 0x00cc || c == 0x00cd || c == 0x0128))
        {
          len += g_unichar_to_utf8 (0x0069, out_buffer ? out_buffer + len : NULL); 
          len += g_unichar_to_utf8 (0x0307, out_buffer ? out_buffer + len : NULL); 

          switch (c)
            {
            case 0x00cc: 
              len += g_unichar_to_utf8 (0x0300, out_buffer ? out_buffer + len : NULL); 
              break;
            case 0x00cd: 
              len += g_unichar_to_utf8 (0x0301, out_buffer ? out_buffer + len : NULL); 
              break;
            case 0x0128: 
              len += g_unichar_to_utf8 (0x0303, out_buffer ? out_buffer + len : NULL); 
              break;
            }
        }
      else if (locale_type == LOCALE_LITHUANIAN && 
               (c == 'I' || c == 'J' || c == 0x012e) && 
               has_more_above (p))
        {
          len += g_unichar_to_utf8 (g_unichar_tolower (c), out_buffer ? out_buffer + len : NULL); 
          len += g_unichar_to_utf8 (0x0307, out_buffer ? out_buffer + len : NULL); 
        }
1013 1014
      else if (c == 0x03A3)	/* GREEK CAPITAL LETTER SIGMA */
	{
1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025
	  if ((max_len < 0 || p < str + max_len) && *p)
	    {
	      gunichar next_c = g_utf8_get_char (p);
	      int next_type = TYPE(next_c);

	      /* SIGMA mapps differently depending on whether it is
	       * final or not. The following simplified test would
	       * fail in the case of combining marks following the
	       * sigma, but I don't think that occurs in real text.
	       * The test here matches that in ICU.
	       */
1026
	      if (ISALPHA (next_type)) /* Lu,Ll,Lt,Lm,Lo */
1027 1028 1029 1030
		val = 0x3c3;	/* GREEK SMALL SIGMA */
	      else
		val = 0x3c2;	/* GREEK SMALL FINAL SIGMA */
	    }
1031 1032 1033 1034 1035
	  else
	    val = 0x3c2;	/* GREEK SMALL FINAL SIGMA */

	  len += g_unichar_to_utf8 (val, out_buffer ? out_buffer + len : NULL);
	}
1036 1037 1038 1039
      else if (IS (t,
		   OR (G_UNICODE_UPPERCASE_LETTER,
		   OR (G_UNICODE_TITLECASE_LETTER,
		  0))))
1040 1041 1042
	{
	  val = ATTTABLE (c >> 8, c & 0xff);

1043
	  if (val >= 0x1000000)
1044
	    {
1045
	      len += output_special_case (out_buffer ? out_buffer + len : NULL, val - 0x1000000, t, 0);
1046 1047 1048 1049 1050 1051 1052 1053 1054
	    }
	  else
	    {
	      if (t == G_UNICODE_TITLECASE_LETTER)
		{
		  unsigned int i;
		  for (i = 0; i < G_N_ELEMENTS (title_table); ++i)
		    {
		      if (title_table[i][0] == c)
1055 1056 1057 1058
			{
			  val = title_table[i][2];
			  break;
			}
1059 1060 1061
		    }
		}

1062 1063 1064
	      /* Not all uppercase letters are guaranteed to have a lowercase
	       * equivalent.  If this is the case, val will be zero. */
	      len += g_unichar_to_utf8 (val ? val : c, out_buffer ? out_buffer + len : NULL);
1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082
	    }
	}
      else
	{
	  gsize char_len = g_utf8_skip[*(guchar *)last];

	  if (out_buffer)
	    memcpy (out_buffer + len, last, char_len);

	  len += char_len;
	}

    }

  return len;
}

/**
1083 1084 1085
 * g_utf8_strdown:
 * @str: a UTF-8 encoded string
 * @len: length of @str, in bytes, or -1 if @str is nul-terminated.
1086 1087 1088 1089 1090 1091
 * 
 * Converts all Unicode characters in the string that have a case
 * to lowercase. The exact manner that this is done depends
 * on the current locale, and may result in the number of
 * characters in the string changing.
 * 
1092
 * Returns: a newly allocated string, with all characters
1093 1094 1095
 *    converted to lowercase.  
 **/
gchar *
1096 1097
g_utf8_strdown (const gchar *str,
		gssize       len)
1098
{
1099
  gsize result_len;
1100 1101 1102 1103 1104 1105 1106 1107 1108 1109
  LocaleType locale_type;
  gchar *result;

  g_return_val_if_fail (str != NULL, NULL);

  locale_type = get_locale_type ();
  
  /*
   * We use a two pass approach to keep memory management simple
   */
1110 1111
  result_len = real_tolower (str, len, NULL, locale_type);
  result = g_malloc (result_len + 1);
1112
  real_tolower (str, len, result, locale_type);
1113
  result[result_len] = '\0';
1114 1115 1116 1117 1118 1119 1120

  return result;
}

/**
 * g_utf8_casefold:
 * @str: a UTF-8 encoded string
1121
 * @len: length of @str, in bytes, or -1 if @str is nul-terminated.
1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134
 * 
 * Converts a string into a form that is independent of case. The
 * result will not correspond to any particular case, but can be
 * compared for equality or ordered with the results of calling
 * g_utf8_casefold() on other strings.
 * 
 * Note that calling g_utf8_casefold() followed by g_utf8_collate() is
 * only an approximation to the correct linguistic case insensitive
 * ordering, though it is a fairly good one. Getting this exactly
 * right would require a more sophisticated collation function that
 * takes case sensitivity into account. GLib does not currently
 * provide such a function.
 * 
1135
 * Returns: a newly allocated string, that is a
1136 1137 1138
 *   case independent form of @str.
 **/
gchar *
1139 1140
g_utf8_casefold (const gchar *str,
		 gssize       len)
1141
{
Matthias Clasen's avatar
Matthias Clasen committed
1142
  GString *result;
1143 1144
  const char *p;

1145 1146
  g_return_val_if_fail (str != NULL, NULL);

Matthias Clasen's avatar
Matthias Clasen committed
1147
  result = g_string_new (NULL);
1148
  p = str;
1149
  while ((len < 0 || p < str + len) && *p)
1150 1151 1152 1153 1154 1155 1156
    {
      gunichar ch = g_utf8_get_char (p);

      int start = 0;
      int end = G_N_ELEMENTS (casefold_table);

      if (ch >= casefold_table[start].ch &&
1157
          ch <= casefold_table[end - 1].ch)
1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175
	{
	  while (TRUE)
	    {
	      int half = (start + end) / 2;
	      if (ch == casefold_table[half].ch)
		{
		  g_string_append (result, casefold_table[half].data);
		  goto next;
		}
	      else if (half == start)
		break;
	      else if (ch > casefold_table[half].ch)
		start = half;
	      else
		end = half;
	    }
	}

1176
      g_string_append_unichar (result, g_unichar_tolower (ch));
1177 1178 1179 1180 1181 1182 1183
      
    next:
      p = g_utf8_next_char (p);
    }

  return g_string_free (result, FALSE); 
}
1184 1185 1186

/**
 * g_unichar_get_mirror_char:
1187
 * @ch: a Unicode character
1188 1189
 * @mirrored_ch: location to store the mirrored character
 * 
1190 1191 1192 1193
 * In Unicode, some characters are "mirrored". This means that their
 * images are mirrored horizontally in text that is laid out from right
 * to left. For instance, "(" would become its mirror image, ")", in
 * right-to-left text.
1194 1195 1196
 *
 * If @ch has the Unicode mirrored property and there is another unicode
 * character that typically has a glyph that is the mirror image of @ch's
1197 1198
 * glyph and @mirrored_ch is set, it puts that character in the address
 * pointed to by @mirrored_ch.  Otherwise the original character is put.
1199
 *
1200
 * Returns: %TRUE if @ch has a mirrored character, %FALSE otherwise
1201 1202
 *
 * Since: 2.4
1203 1204 1205 1206 1207 1208
 **/
gboolean
g_unichar_get_mirror_char (gunichar ch,
                           gunichar *mirrored_ch)
{
  gboolean found;
1209
  gunichar mirrored;
1210

1211
  mirrored = GLIB_GET_MIRRORING(ch);
1212

1213
  found = ch != mirrored;
1214
  if (mirrored_ch)
1215
    *mirrored_ch = mirrored;
1216 1217 1218 1219

  return found;

}
1220

1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252
#define G_SCRIPT_TABLE_MIDPOINT (G_N_ELEMENTS (g_script_table) / 2)

static inline GUnicodeScript
g_unichar_get_script_bsearch (gunichar ch)
{
  int lower = 0;
  int upper = G_N_ELEMENTS (g_script_table) - 1;
  static int saved_mid = G_SCRIPT_TABLE_MIDPOINT;
  int mid = saved_mid;


  do 
    {
      if (ch < g_script_table[mid].start)
	upper = mid - 1;
      else if (ch >= g_script_table[mid].start + g_script_table[mid].chars)
	lower = mid + 1;
      else
	return g_script_table[saved_mid = mid].script;

      mid = (lower + upper) / 2;
    }
  while (lower <= upper);

  return G_UNICODE_SCRIPT_UNKNOWN;
}

/**
 * g_unichar_get_script:
 * @ch: a Unicode character
 * 
 * Looks up the #GUnicodeScript for a particular character (as defined 
1253
 * by Unicode Standard Annex \#24). No check is made for @ch being a
1254 1255
 * valid Unicode character; if you pass in invalid character, the
 * result is undefined.
1256 1257 1258
 *
 * This function is equivalent to pango_script_for_unichar() and the
 * two are interchangeable.
1259
 * 
1260
 * Returns: the #GUnicodeScript for the character.
1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271
 *
 * Since: 2.14
 */
GUnicodeScript
g_unichar_get_script (gunichar ch)
{
  if (ch < G_EASY_SCRIPTS_RANGE)
    return g_script_easy_table[ch];
  else 
    return g_unichar_get_script_bsearch (ch); 
}
1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387


/* http://unicode.org/iso15924/ */
static const guint32 iso15924_tags[] =
{
#define PACK(a,b,c,d) ((guint32)((((guint8)(a))<<24)|(((guint8)(b))<<16)|(((guint8)(c))<<8)|((guint8)(d))))

    PACK ('Z','y','y','y'), /* G_UNICODE_SCRIPT_COMMON */
    PACK ('Z','i','n','h'), /* G_UNICODE_SCRIPT_INHERITED */
    PACK ('A','r','a','b'), /* G_UNICODE_SCRIPT_ARABIC */
    PACK ('A','r','m','n'), /* G_UNICODE_SCRIPT_ARMENIAN */
    PACK ('B','e','n','g'), /* G_UNICODE_SCRIPT_BENGALI */
    PACK ('B','o','p','o'), /* G_UNICODE_SCRIPT_BOPOMOFO */
    PACK ('C','h','e','r'), /* G_UNICODE_SCRIPT_CHEROKEE */
    PACK ('C','o','p','t'), /* G_UNICODE_SCRIPT_COPTIC */
    PACK ('C','y','r','l'), /* G_UNICODE_SCRIPT_CYRILLIC */
    PACK ('D','s','r','t'), /* G_UNICODE_SCRIPT_DESERET */
    PACK ('D','e','v','a'), /* G_UNICODE_SCRIPT_DEVANAGARI */
    PACK ('E','t','h','i'), /* G_UNICODE_SCRIPT_ETHIOPIC */
    PACK ('G','e','o','r'), /* G_UNICODE_SCRIPT_GEORGIAN */
    PACK ('G','o','t','h'), /* G_UNICODE_SCRIPT_GOTHIC */
    PACK ('G','r','e','k'), /* G_UNICODE_SCRIPT_GREEK */
    PACK ('G','u','j','r'), /* G_UNICODE_SCRIPT_GUJARATI */
    PACK ('G','u','r','u'), /* G_UNICODE_SCRIPT_GURMUKHI */
    PACK ('H','a','n','i'), /* G_UNICODE_SCRIPT_HAN */
    PACK ('H','a','n','g'), /* G_UNICODE_SCRIPT_HANGUL */
    PACK ('H','e','b','r'), /* G_UNICODE_SCRIPT_HEBREW */
    PACK ('H','i','r','a'), /* G_UNICODE_SCRIPT_HIRAGANA */
    PACK ('K','n','d','a'), /* G_UNICODE_SCRIPT_KANNADA */
    PACK ('K','a','n','a'), /* G_UNICODE_SCRIPT_KATAKANA */
    PACK ('K','h','m','r'), /* G_UNICODE_SCRIPT_KHMER */
    PACK ('L','a','o','o'), /* G_UNICODE_SCRIPT_LAO */
    PACK ('L','a','t','n'), /* G_UNICODE_SCRIPT_LATIN */
    PACK ('M','l','y','m'), /* G_UNICODE_SCRIPT_MALAYALAM */
    PACK ('M','o','n','g'), /* G_UNICODE_SCRIPT_MONGOLIAN */
    PACK ('M','y','m','r'), /* G_UNICODE_SCRIPT_MYANMAR */
    PACK ('O','g','a','m'), /* G_UNICODE_SCRIPT_OGHAM */
    PACK ('I','t','a','l'), /* G_UNICODE_SCRIPT_OLD_ITALIC */
    PACK ('O','r','y','a'), /* G_UNICODE_SCRIPT_ORIYA */
    PACK ('R','u','n','r'), /* G_UNICODE_SCRIPT_RUNIC */
    PACK ('S','i','n','h'), /* G_UNICODE_SCRIPT_SINHALA */
    PACK ('S','y','r','c'), /* G_UNICODE_SCRIPT_SYRIAC */
    PACK ('T','a','m','l'), /* G_UNICODE_SCRIPT_TAMIL */
    PACK ('T','e','l','u'), /* G_UNICODE_SCRIPT_TELUGU */
    PACK ('T','h','a','a'), /* G_UNICODE_SCRIPT_THAANA */
    PACK ('T','h','a','i'), /* G_UNICODE_SCRIPT_THAI */
    PACK ('T','i','b','t'), /* G_UNICODE_SCRIPT_TIBETAN */
    PACK ('C','a','n','s'), /* G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL */
    PACK ('Y','i','i','i'), /* G_UNICODE_SCRIPT_YI */
    PACK ('T','g','l','g'), /* G_UNICODE_SCRIPT_TAGALOG */
    PACK ('H','a','n','o'), /* G_UNICODE_SCRIPT_HANUNOO */
    PACK ('B','u','h','d'), /* G_UNICODE_SCRIPT_BUHID */
    PACK ('T','a','g','b'), /* G_UNICODE_SCRIPT_TAGBANWA */

  /* Unicode-4.0 additions */
    PACK ('B','r','a','i'), /* G_UNICODE_SCRIPT_BRAILLE */
    PACK ('C','p','r','t'), /* G_UNICODE_SCRIPT_CYPRIOT */
    PACK ('L','i','m','b'), /* G_UNICODE_SCRIPT_LIMBU */
    PACK ('O','s','m','a'), /* G_UNICODE_SCRIPT_OSMANYA */
    PACK ('S','h','a','w'), /* G_UNICODE_SCRIPT_SHAVIAN */
    PACK ('L','i','n','b'), /* G_UNICODE_SCRIPT_LINEAR_B */
    PACK ('T','a','l','e'), /* G_UNICODE_SCRIPT_TAI_LE */
    PACK ('U','g','a','r'), /* G_UNICODE_SCRIPT_UGARITIC */

  /* Unicode-4.1 additions */
    PACK ('T','a','l','u'), /* G_UNICODE_SCRIPT_NEW_TAI_LUE */
    PACK ('B','u','g','i'), /* G_UNICODE_SCRIPT_BUGINESE */
    PACK ('G','l','a','g'), /* G_UNICODE_SCRIPT_GLAGOLITIC */
    PACK ('T','f','n','g'), /* G_UNICODE_SCRIPT_TIFINAGH */
    PACK ('S','y','l','o'), /* G_UNICODE_SCRIPT_SYLOTI_NAGRI */
    PACK ('X','p','e','o'), /* G_UNICODE_SCRIPT_OLD_PERSIAN */
    PACK ('K','h','a','r'), /* G_UNICODE_SCRIPT_KHAROSHTHI */

  /* Unicode-5.0 additions */
    PACK ('Z','z','z','z'), /* G_UNICODE_SCRIPT_UNKNOWN */
    PACK ('B','a','l','i'), /* G_UNICODE_SCRIPT_BALINESE */
    PACK ('X','s','u','x'), /* G_UNICODE_SCRIPT_CUNEIFORM */
    PACK ('P','h','n','x'), /* G_UNICODE_SCRIPT_PHOENICIAN */
    PACK ('P','h','a','g'), /* G_UNICODE_SCRIPT_PHAGS_PA */
    PACK ('N','k','o','o'), /* G_UNICODE_SCRIPT_NKO */

  /* Unicode-5.1 additions */
    PACK ('K','a','l','i'), /* G_UNICODE_SCRIPT_KAYAH_LI */
    PACK ('L','e','p','c'), /* G_UNICODE_SCRIPT_LEPCHA */
    PACK ('R','j','n','g'), /* G_UNICODE_SCRIPT_REJANG */
    PACK ('S','u','n','d'), /* G_UNICODE_SCRIPT_SUNDANESE */
    PACK ('S','a','u','r'), /* G_UNICODE_SCRIPT_SAURASHTRA */
    PACK ('C','h','a','m'), /* G_UNICODE_SCRIPT_CHAM */
    PACK ('O','l','c','k'), /* G_UNICODE_SCRIPT_OL_CHIKI */
    PACK ('V','a','i','i'), /* G_UNICODE_SCRIPT_VAI */
    PACK ('C','a','r','i'), /* G_UNICODE_SCRIPT_CARIAN */
    PACK ('L','y','c','i'), /* G_UNICODE_SCRIPT_LYCIAN */
    PACK ('L','y','d','i'), /* G_UNICODE_SCRIPT_LYDIAN */

  /* Unicode-5.2 additions */
    PACK ('A','v','s','t'), /* G_UNICODE_SCRIPT_AVESTAN */
    PACK ('B','a','m','u'), /* G_UNICODE_SCRIPT_BAMUM */
    PACK ('E','g','y','p'), /* G_UNICODE_SCRIPT_EGYPTIAN_HIEROGLYPHS */
    PACK ('A','r','m','i'), /* G_UNICODE_SCRIPT_IMPERIAL_ARAMAIC */
    PACK ('P','h','l','i'), /* G_UNICODE_SCRIPT_INSCRIPTIONAL_PAHLAVI */
    PACK ('P','r','t','i'), /* G_UNICODE_SCRIPT_INSCRIPTIONAL_PARTHIAN */
    PACK ('J','a','v','a'), /* G_UNICODE_SCRIPT_JAVANESE */
    PACK ('K','t','h','i'), /* G_UNICODE_SCRIPT_KAITHI */
    PACK ('L','i','s','u'), /* G_UNICODE_SCRIPT_LISU */
    PACK ('M','t','e','i'), /* G_UNICODE_SCRIPT_MEETEI_MAYEK */
    PACK ('S','a','r','b'), /* G_UNICODE_SCRIPT_OLD_SOUTH_ARABIAN */
    PACK ('O','r','k','h'), /* G_UNICODE_SCRIPT_OLD_TURKIC */
    PACK ('S','a','m','r'), /* G_UNICODE_SCRIPT_SAMARITAN */
    PACK ('L','a','n','a'), /* G_UNICODE_SCRIPT_TAI_THAM */
    PACK ('T','a','v','t'), /* G_UNICODE_SCRIPT_TAI_VIET */

  /* Unicode-6.0 additions */
    PACK ('B','a','t','k'), /* G_UNICODE_SCRIPT_BATAK */
    PACK ('B','r','a','h'), /* G_UNICODE_SCRIPT_BRAHMI */
    PACK ('M','a','n','d'), /* G_UNICODE_SCRIPT_MANDAIC */

1388 1389 1390 1391 1392 1393 1394 1395 1396
  /* Unicode-6.1 additions */
    PACK ('C','a','k','m'), /* G_UNICODE_SCRIPT_CHAKMA */
    PACK ('M','e','r','c'), /* G_UNICODE_SCRIPT_MEROITIC_CURSIVE */
    PACK ('M','e','r','o'), /* G_UNICODE_SCRIPT_MEROITIC_HIEROGLYPHS */
    PACK ('P','l','r','d'), /* G_UNICODE_SCRIPT_MIAO */
    PACK ('S','h','r','d'), /* G_UNICODE_SCRIPT_SHARADA */
    PACK ('S','o','r','a'), /* G_UNICODE_SCRIPT_SORA_SOMPENG */
    PACK ('T','a','k','r'), /* G_UNICODE_SCRIPT_TAKRI */

1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421
  /* Unicode 7.0 additions */
    PACK ('B','a','s','s'), /* G_UNICODE_SCRIPT_BASSA_VAH */
    PACK ('A','g','h','b'), /* G_UNICODE_SCRIPT_CAUCASIAN_ALBANIAN */
    PACK ('D','u','p','l'), /* G_UNICODE_SCRIPT_DUPLOYAN */
    PACK ('E','l','b','a'), /* G_UNICODE_SCRIPT_ELBASAN */
    PACK ('G','r','a','n'), /* G_UNICODE_SCRIPT_GRANTHA */
    PACK ('K','h','o','j'), /* G_UNICODE_SCRIPT_KHOJKI*/
    PACK ('S','i','n','d'), /* G_UNICODE_SCRIPT_KHUDAWADI */
    PACK ('L','i','n','a'), /* G_UNICODE_SCRIPT_LINEAR_A */
    PACK ('M','a','h','j'), /* G_UNICODE_SCRIPT_MAHAJANI */
    PACK ('M','a','n','u'), /* G_UNICODE_SCRIPT_MANICHAEAN */
    PACK ('M','e','n','d'), /* G_UNICODE_SCRIPT_MENDE_KIKAKUI */
    PACK ('M','o','d','i'), /* G_UNICODE_SCRIPT_MODI */
    PACK ('M','r','o','o'), /* G_UNICODE_SCRIPT_MRO */
    PACK ('N','b','a','t'), /* G_UNICODE_SCRIPT_NABATAEAN */
    PACK ('N','a','r','b'), /* G_UNICODE_SCRIPT_OLD_NORTH_ARABIAN */
    PACK ('P','e','r','m'), /* G_UNICODE_SCRIPT_OLD_PERMIC */
    PACK ('H','m','n','g'), /* G_UNICODE_SCRIPT_PAHAWH_HMONG */
    PACK ('P','a','l','m'), /* G_UNICODE_SCRIPT_PALMYRENE */
    PACK ('P','a','u','c'), /* G_UNICODE_SCRIPT_PAU_CIN_HAU */
    PACK ('P','h','l','p'), /* G_UNICODE_SCRIPT_PSALTER_PAHLAVI */
    PACK ('S','i','d','d'), /* G_UNICODE_SCRIPT_SIDDHAM */
    PACK ('T','i','r','h'), /* G_UNICODE_SCRIPT_TIRHUTA */
    PACK ('W','a','r','a'), /* G_UNICODE_SCRIPT_WARANG_CITI */

Matthias Clasen's avatar
Matthias Clasen committed
1422 1423 1424 1425 1426 1427 1428
  /* Unicode 8.0 additions */
    PACK ('A','h','o','m'), /* G_UNICODE_SCRIPT_AHOM */
    PACK ('H','l','u','w'), /* G_UNICODE_SCRIPT_ANATOLIAN_HIEROGLYPHS */
    PACK ('H','a','t','r'), /* G_UNICODE_SCRIPT_HATRAN */
    PACK ('M','u','l','t'), /* G_UNICODE_SCRIPT_MULTANI */
    PACK ('H','u','n','g'), /* G_UNICODE_SCRIPT_OLD_HUNGARIAN */
    PACK ('S','g','n','w'), /* G_UNICODE_SCRIPT_SIGNWRITING */
1429 1430

  /* Unicode 9.0 additions */
1431
    PACK ('A','d','l','m'), /* G_UNICODE_SCRIPT_ADLAM */
1432 1433
    PACK ('B','h','k','s'), /* G_UNICODE_SCRIPT_BHAIKSUKI */
    PACK ('M','a','r','c'), /* G_UNICODE_SCRIPT_MARCHEN */
1434 1435
    PACK ('N','e','w','a'), /* G_UNICODE_SCRIPT_NEWA */
    PACK ('O','s','g','e'), /* G_UNICODE_SCRIPT_OSAGE */
1436
    PACK ('T','a','n','g'), /* G_UNICODE_SCRIPT_TANGUT */
1437 1438 1439 1440 1441 1442

  /* Unicode 10.0 additions */
    PACK ('G','o','n','m'), /* G_UNICODE_SCRIPT_MASARAM_GONDI */
    PACK ('N','s','h','u'), /* G_UNICODE_SCRIPT_NUSHU */
    PACK ('S','o','y','o'), /* G_UNICODE_SCRIPT_SOYOMBO */
    PACK ('Z','a','n','b'), /* G_UNICODE_SCRIPT_ZANABAZAR_SQUARE */
1443 1444 1445 1446 1447 1448 1449 1450 1451

  /* Unicode 11.0 additions */
    PACK ('D','o','g','r'), /* G_UNICODE_SCRIPT_DOGRA */
    PACK ('G','o','n','g'), /* G_UNICODE_SCRIPT_GUNJALA_GONDI */
    PACK ('R','o','h','g'), /* G_UNICODE_SCRIPT_HANIFI_ROHINGYA */
    PACK ('M','a','k','a'), /* G_UNICODE_SCRIPT_MAKASAR */
    PACK ('M','e','d','f'), /* G_UNICODE_SCRIPT_MEDEFAIDRIN */
    PACK ('S','o','g','o'), /* G_UNICODE_SCRIPT_OLD_SOGDIAN */
    PACK ('S','o','g','d'), /* G_UNICODE_SCRIPT_SOGDIAN */
1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464
#undef PACK
};

/**
 * g_unicode_script_to_iso15924:
 * @script: a Unicode script
 *
 * Looks up the ISO 15924 code for @script.  ISO 15924 assigns four-letter
 * codes to scripts.  For example, the code for Arabic is 'Arab'.  The
 * four letter codes are encoded as a @guint32 by this function in a
 * big-endian fashion.  That is, the code returned for Arabic is
 * 0x41726162 (0x41 is ASCII code for 'A', 0x72 is ASCII code for 'r', etc).
 *
1465 1466 1467
 * See
 * [Codes for the representation of names of scripts](http://unicode.org/iso15924/codelists.html)
 * for details.
1468
 *
1469
 * Returns: the ISO 15924 code for @script, encoded as an integer,
1470 1471
 *   of zero if @script is %G_UNICODE_SCRIPT_INVALID_CODE or
 *   ISO 15924 code 'Zzzz' (script code for UNKNOWN) if @script is not understood.
1472 1473 1474 1475 1476 1477
 *
 * Since: 2.30
 */
guint32
g_unicode_script_to_iso15924 (GUnicodeScript script)
{
1478
  if (G_UNLIKELY (script == G_UNICODE_SCRIPT_INVALID_CODE))
1479 1480
    return 0;

1481 1482 1483
  if (G_UNLIKELY (script < 0 || script >= (int) G_N_ELEMENTS (iso15924_tags)))
    return 0x5A7A7A7A;

1484 1485
  return iso15924_tags[script];
}
1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496

/**
 * g_unicode_script_from_iso15924:
 * @iso15924: a Unicode script
 *
 * Looks up the Unicode script for @iso15924.  ISO 15924 assigns four-letter
 * codes to scripts.  For example, the code for Arabic is 'Arab'.
 * This function accepts four letter codes encoded as a @guint32 in a
 * big-endian fashion.  That is, the code expected for Arabic is
 * 0x41726162 (0x41 is ASCII code for 'A', 0x72 is ASCII code for 'r', etc).
 *
1497 1498 1499
 * See
 * [Codes for the representation of names of scripts](http://unicode.org/iso15924/codelists.html)
 * for details.
1500
 *
1501
 * Returns: the Unicode script for @iso15924, or
1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520
 *   of %G_UNICODE_SCRIPT_INVALID_CODE if @iso15924 is zero and
 *   %G_UNICODE_SCRIPT_UNKNOWN if @iso15924 is unknown.
 *
 * Since: 2.30
 */
GUnicodeScript
g_unicode_script_from_iso15924 (guint32 iso15924)
{
  unsigned int i;

   if (!iso15924)
     return G_UNICODE_SCRIPT_INVALID_CODE;

  for (i = 0; i < G_N_ELEMENTS (iso15924_tags); i++)
    if (iso15924_tags[i] == iso15924)
      return (GUnicodeScript) i;

  return G_UNICODE_SCRIPT_UNKNOWN;
}