/* guniprop.c - Unicode character properties.

 *

 * Copyright (C) 1999 Tom Tromey

 * Copyright (C) 2000 Red Hat, Inc.

 * Portions copyright (c) 2006-2009 Nokia Corporation.  All rights reserved.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * 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

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

#include "config.h"

#include <stdlib.h>

#include <stddef.h>

#include <string.h>

#include <locale.h>

#include "glib.h"

#include "gunichartables.h"

#include "gmirroringtable.h"

#include "gscripttable.h"

#include "gunicodeprivate.h"

#include "galias.h"

#ifdef __SYMBIAN32__

#include "glib_wsd.h"

#endif /* __SYMBIAN32__ */

#define ATTR_TABLE(Page) (((Page) <= G_UNICODE_LAST_PAGE_PART1) \

                          ? attr_table_part1[Page] \

                          : attr_table_part2[(Page) - 0xe00])

#define ATTTABLE(Page, Char) \

  ((ATTR_TABLE(Page) == G_UNICODE_MAX_TABLE_INDEX) ? 0 : (attr_data[ATTR_TABLE(Page)][Char]))

#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]))

#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))

#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,	\

			    OR (G_UNICODE_COMBINING_MARK,	\

			    OR (G_UNICODE_ENCLOSING_MARK,	0))))

#define ISZEROWIDTHTYPE(Type)	IS ((Type),			\

			    OR (G_UNICODE_NON_SPACING_MARK,	\

			    OR (G_UNICODE_ENCLOSING_MARK,	\

			    OR (G_UNICODE_FORMAT,		0))))

/**

 * 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().

 * 

 * Return value: %TRUE if @c is an alphanumeric character

 **/

EXPORT_C gboolean

g_unichar_isalnum (gunichar c)

{

  return ISALDIGIT (TYPE (c)) ? TRUE : FALSE;

}

/**

 * 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().

 * 

 * Return value: %TRUE if @c is an alphabetic character

 **/

EXPORT_C gboolean

g_unichar_isalpha (gunichar c)

{

  return ISALPHA (TYPE (c)) ? TRUE : FALSE;

}

/**

 * 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().

 * 

 * Return value: %TRUE if @c is a control character

 **/

EXPORT_C gboolean

g_unichar_iscntrl (gunichar c)

{

  return TYPE (c) == G_UNICODE_CONTROL;

}

/**

 * 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().

 * 

 * Return value: %TRUE if @c is a digit

 **/

EXPORT_C gboolean

g_unichar_isdigit (gunichar c)

{

  return TYPE (c) == G_UNICODE_DECIMAL_NUMBER;

}

/**

 * 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().

 * 

 * Return value: %TRUE if @c is printable unless it's a space

 **/

EXPORT_C gboolean

g_unichar_isgraph (gunichar c)

{

  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,

	     0))))));

}

/**

 * 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().

 * 

 * Return value: %TRUE if @c is a lowercase letter

 **/

EXPORT_C gboolean

g_unichar_islower (gunichar c)

{

  return TYPE (c) == G_UNICODE_LOWERCASE_LETTER;

}

/**

 * 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().

 * 

 * Return value: %TRUE if @c is printable

 **/

EXPORT_C gboolean

g_unichar_isprint (gunichar c)

{

  return !IS (TYPE(c),

	      OR (G_UNICODE_CONTROL,

	      OR (G_UNICODE_FORMAT,

	      OR (G_UNICODE_UNASSIGNED,

	      OR (G_UNICODE_SURROGATE,

	     0)))));

}

/**

 * g_unichar_ispunct:

 * @c: a Unicode character

 * 

 * Determines whether a character is punctuation or a symbol.

 * Given some UTF-8 text, obtain a character value with

 * g_utf8_get_char().

 * 

 * Return value: %TRUE if @c is a punctuation or symbol character

 **/

EXPORT_C gboolean

g_unichar_ispunct (gunichar c)

{

  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;

}

/**

 * 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.)

 *  

 * Return value: %TRUE if @c is a space character

 **/

EXPORT_C gboolean

g_unichar_isspace (gunichar c)

{

  switch (c)

    {

      /* special-case these since Unicode thinks they are not spaces */

    case '\t':

    case '\n':

    case '\r':

    case '\f':

      return TRUE;

      break;

    default:

      {

	return IS (TYPE(c),

	           OR (G_UNICODE_SPACE_SEPARATOR,

	           OR (G_UNICODE_LINE_SEPARATOR,

                   OR (G_UNICODE_PARAGRAPH_SEPARATOR,

		  0)))) ? TRUE : FALSE;

      }

      break;

    }

}

/**

 * 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.

 *

 * Return value: %TRUE if @c is a mark character

 *

 * Since: 2.14

 **/

EXPORT_C gboolean

g_unichar_ismark (gunichar c)

{

  return ISMARK (TYPE (c));

}

/**

 * g_unichar_isupper:

 * @c: a Unicode character

 * 

 * Determines if a character is uppercase.

 * 

 * Return value: %TRUE if @c is an uppercase character

 **/

EXPORT_C gboolean

g_unichar_isupper (gunichar c)

{

  return TYPE (c) == G_UNICODE_UPPERCASE_LETTER;

}

/**

 * g_unichar_istitle:

 * @c: a Unicode character

 * 

 * 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

 * digraph is U+01F2 LATIN CAPITAL LETTTER D WITH SMALL LETTER Z.

 * 

 * Return value: %TRUE if the character is titlecase

 **/

EXPORT_C gboolean

g_unichar_istitle (gunichar c)

{

  unsigned int i;

  for (i = 0; i < G_N_ELEMENTS (title_table); ++i)

    if (title_table[i][0] == c)

      return TRUE;

  return FALSE;

}

/**

 * g_unichar_isxdigit:

 * @c: a Unicode character.

 * 

 * Determines if a character is a hexidecimal digit.

 * 

 * Return value: %TRUE if the character is a hexadecimal digit

 **/

EXPORT_C gboolean

g_unichar_isxdigit (gunichar c)

{

  return ((c >= 'a' && c <= 'f')

	  || (c >= 'A' && c <= 'F')

	  || (TYPE (c) == G_UNICODE_DECIMAL_NUMBER));

}

/**

 * g_unichar_isdefined:

 * @c: a Unicode character

 * 

 * Determines if a given character is assigned in the Unicode

 * standard.

 *

 * Return value: %TRUE if the character has an assigned value

 **/

EXPORT_C gboolean

g_unichar_isdefined (gunichar c)

{

  return !IS (TYPE(c),

	      OR (G_UNICODE_UNASSIGNED,

	      OR (G_UNICODE_SURROGATE,

	     0)));

}

/**

 * 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.

 *

 * Return value: %TRUE if the character has zero width

 *

 * Since: 2.14

 **/

EXPORT_C gboolean

g_unichar_iszerowidth (gunichar c)

{

  if (G_UNLIKELY (c == 0x00AD))

    return FALSE;

  if (G_UNLIKELY (ISZEROWIDTHTYPE (TYPE (c))))

    return TRUE;

  if (G_UNLIKELY ((c >= 0x1160 && c < 0x1200) ||

		  c == 0x200B))

    return TRUE;

  return FALSE;

}

struct Interval

{

  gunichar start, end;

};

static int

interval_compare (const void *key, const void *elt)

{

  gunichar c = GPOINTER_TO_UINT (key);

  struct Interval *interval = (struct Interval *)elt;

  if (c < interval->start)

    return -1;

  if (c > interval->end)

    return +1;

  return 0;

}

/**

 * g_unichar_iswide:

 * @c: a Unicode character

 * 

 * Determines if a character is typically rendered in a double-width

 * cell.

 * 

 * Return value: %TRUE if the character is wide

 **/

EXPORT_C gboolean

g_unichar_iswide (gunichar c)

{

  /* sorted list of intervals of East_Asian_Width = W and F characters

   * from Unicode 5.1.0.  produced by mungling output of:

   * grep ';[FW]\>' EastAsianWidth.txt */

  static const struct Interval wide[] = {

    {0x1100, 0x1159}, {0x115F, 0x115F}, {0x2329, 0x232A}, {0x2E80, 0x2E99},

    {0x2E9B, 0x2EF3}, {0x2F00, 0x2FD5}, {0x2FF0, 0x2FFB}, {0x3000, 0x303E},

    {0x3041, 0x3096}, {0x3099, 0x30FF}, {0x3105, 0x312D}, {0x3131, 0x318E},

    {0x3190, 0x31B7}, {0x31C0, 0x31E3}, {0x31F0, 0x321E}, {0x3220, 0x3243},

    {0x3250, 0x32FE}, {0x3300, 0x4DB5}, {0x4E00, 0x9FC3}, {0xA000, 0xA48C},

    {0xA490, 0xA4C6}, {0xAC00, 0xD7A3}, {0xF900, 0xFA2D}, {0xFA30, 0xFA6A},

    {0xFA70, 0xFAD9}, {0xFE10, 0xFE19}, {0xFE30, 0xFE52}, {0xFE54, 0xFE66},

    {0xFE68, 0xFE6B}, {0xFF01, 0xFF60}, {0xFFE0, 0xFFE6}, {0x20000, 0x2FFFD},

    {0x30000, 0x3FFFD}

  };

  if (bsearch (GUINT_TO_POINTER (c), wide, G_N_ELEMENTS (wide), sizeof wide[0],

	       interval_compare))

    return TRUE;

  return FALSE;

}

/**

 * 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

 * the converse is not necessarily true.  See the

 * <ulink url="http://www.unicode.org/reports/tr11/">Unicode Standard

 * Annex #11</ulink> for details.

 *

 * 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

 * pas both this test and g_unichar_iszerowidth().

 * 

 * Return value: %TRUE if the character is wide in legacy East Asian locales

 *

 * Since: 2.12

 */

EXPORT_C gboolean

g_unichar_iswide_cjk (gunichar c)

{

  /* sorted list of intervals of East_Asian_Width = A and F characters

   * from Unicode 5.1.0.  produced by mungling output of:

   * grep ';[A]\>' EastAsianWidth.txt */

  static const struct Interval ambiguous[] = {

    {0x00A1, 0x00A1}, {0x00A4, 0x00A4}, {0x00A7, 0x00A8}, {0x00AA, 0x00AA},

    {0x00AD, 0x00AE}, {0x00B0, 0x00B4}, {0x00B6, 0x00BA}, {0x00BC, 0x00BF},

    {0x00C6, 0x00C6}, {0x00D0, 0x00D0}, {0x00D7, 0x00D8}, {0x00DE, 0x00E1},

    {0x00E6, 0x00E6}, {0x00E8, 0x00EA}, {0x00EC, 0x00ED}, {0x00F0, 0x00F0},

    {0x00F2, 0x00F3}, {0x00F7, 0x00FA}, {0x00FC, 0x00FC}, {0x00FE, 0x00FE},

    {0x0101, 0x0101}, {0x0111, 0x0111}, {0x0113, 0x0113}, {0x011B, 0x011B},

    {0x0126, 0x0127}, {0x012B, 0x012B}, {0x0131, 0x0133}, {0x0138, 0x0138},

    {0x013F, 0x0142}, {0x0144, 0x0144}, {0x0148, 0x014B}, {0x014D, 0x014D},

    {0x0152, 0x0153}, {0x0166, 0x0167}, {0x016B, 0x016B}, {0x01CE, 0x01CE},

    {0x01D0, 0x01D0}, {0x01D2, 0x01D2}, {0x01D4, 0x01D4}, {0x01D6, 0x01D6},

    {0x01D8, 0x01D8}, {0x01DA, 0x01DA}, {0x01DC, 0x01DC}, {0x0251, 0x0251},

    {0x0261, 0x0261}, {0x02C4, 0x02C4}, {0x02C7, 0x02C7}, {0x02C9, 0x02CB},

    {0x02CD, 0x02CD}, {0x02D0, 0x02D0}, {0x02D8, 0x02DB}, {0x02DD, 0x02DD},

    {0x02DF, 0x02DF}, {0x0300, 0x036F}, {0x0391, 0x03A1}, {0x03A3, 0x03A9},

    {0x03B1, 0x03C1}, {0x03C3, 0x03C9}, {0x0401, 0x0401}, {0x0410, 0x044F},

    {0x0451, 0x0451}, {0x2010, 0x2010}, {0x2013, 0x2016}, {0x2018, 0x2019},

    {0x201C, 0x201D}, {0x2020, 0x2022}, {0x2024, 0x2027}, {0x2030, 0x2030},

    {0x2032, 0x2033}, {0x2035, 0x2035}, {0x203B, 0x203B}, {0x203E, 0x203E},

    {0x2074, 0x2074}, {0x207F, 0x207F}, {0x2081, 0x2084}, {0x20AC, 0x20AC},

    {0x2103, 0x2103}, {0x2105, 0x2105}, {0x2109, 0x2109}, {0x2113, 0x2113},

    {0x2116, 0x2116}, {0x2121, 0x2122}, {0x2126, 0x2126}, {0x212B, 0x212B},

    {0x2153, 0x2154}, {0x215B, 0x215E}, {0x2160, 0x216B}, {0x2170, 0x2179},

    {0x2190, 0x2199}, {0x21B8, 0x21B9}, {0x21D2, 0x21D2}, {0x21D4, 0x21D4},

    {0x21E7, 0x21E7}, {0x2200, 0x2200}, {0x2202, 0x2203}, {0x2207, 0x2208},

    {0x220B, 0x220B}, {0x220F, 0x220F}, {0x2211, 0x2211}, {0x2215, 0x2215},

    {0x221A, 0x221A}, {0x221D, 0x2220}, {0x2223, 0x2223}, {0x2225, 0x2225},