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

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

 * License as published by the Free Software Foundation; either

 * version 2.1 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, see <http://www.gnu.org/licenses/>.

 */

#include "config.h"

#include <stdlib.h>

#include <stddef.h>

#include <string.h>

#include <locale.h>

#include "gmem.h"

#include "gstring.h"

#include "gtestutils.h"

#include "gtypes.h"

#include "gunicode.h"

#include "gunichartables.h"

#include "gmirroringtable.h"

#include "gscripttable.h"

#include "gunicodeprivate.h"

#ifdef G_OS_WIN32

#include "gwin32.h"

#endif

#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_SPACING_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().

 * 

 * Returns: %TRUE if @c is an alphanumeric character

 **/

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

 * 

 * Returns: %TRUE if @c is an alphabetic character

 **/

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

 * 

 * Returns: %TRUE if @c is a control character

 **/

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

 * 

 * Returns: %TRUE if @c is a digit

 **/

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

 * 

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

 **/

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

 * 

 * Returns: %TRUE if @c is a lowercase letter

 **/

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

 * 

 * Returns: %TRUE if @c is printable

 **/

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

 * 

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

 **/

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

 *  

 * Returns: %TRUE if @c is a space character

 **/

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.

 *

 * Returns: %TRUE if @c is a mark character

 *

 * Since: 2.14

 **/

gboolean

g_unichar_ismark (gunichar c)

{

  return ISMARK (TYPE (c));

}

/**

 * g_unichar_isupper:

 * @c: a Unicode character

 * 

 * Determines if a character is uppercase.

 * 

 * Returns: %TRUE if @c is an uppercase character

 **/

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.

 * 

 * Returns: %TRUE if the character is titlecase

 **/

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.

 * 

 * Returns: %TRUE if the character is a hexadecimal digit

 **/

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.

 *

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

 **/

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.

 *

 * Returns: %TRUE if the character has zero width

 *

 * Since: 2.14

 **/

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;

}

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;

}

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

  int upper = G_N_ELEMENTS (g_unicode_width_table_wide) - 1;

  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;

}

/**

 * g_unichar_iswide:

 * @c: a Unicode character

 * 

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

 * cell.

 * 

 * Returns: %TRUE if the character is wide

 **/

gboolean

g_unichar_iswide (gunichar c)

{

  if (c < g_unicode_width_table_wide[0].start)

    return FALSE;

  else

    return g_unichar_iswide_bsearch (c);

}

/**

 * 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

 * [Unicode Standard Annex #11](http://www.unicode.org/reports/tr11/)

 * 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

 * pass both this test and g_unichar_iszerowidth().

 * 

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

 *

 * Since: 2.12

 */

gboolean

g_unichar_iswide_cjk (gunichar c)

{

  if (g_unichar_iswide (c))

    return TRUE;

  /* bsearch() is declared attribute(nonnull(1)) so we can't validly search

   * for a NULL key */

  if (c == 0)

    return FALSE;

  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],

	       interval_compare))

    return TRUE;

  return FALSE;

}

/**

 * g_unichar_toupper:

 * @c: a Unicode character

 * 

 * Converts a character to uppercase.

 * 

 * Returns: the result of converting @c to uppercase.

 *               If @c is not an lowercase or titlecase character,

 *               or has no upper case equivalent @c is returned unchanged.

 **/

gunichar

g_unichar_toupper (gunichar c)

{

  int t = TYPE (c);

  if (t == G_UNICODE_LOWERCASE_LETTER)

    {

      gunichar val = ATTTABLE (c >> 8, c & 0xff);

      if (val >= 0x1000000)

	{

	  const gchar *p = special_case_table + val - 0x1000000;

          val = g_utf8_get_char (p);

	}

      /* 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;

    }

  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)

	    return title_table[i][1] ? title_table[i][1] : c;

	}

    }

  return c;

}

/**

 * g_unichar_tolower:

 * @c: a Unicode character.

 * 

 * Converts a character to lower case.

 * 

 * Returns: the result of converting @c to lower case.

 *               If @c is not an upperlower or titlecase character,

 *               or has no lowercase equivalent @c is returned unchanged.

 **/

gunichar

g_unichar_tolower (gunichar c)

{

  int t = TYPE (c);

  if (t == G_UNICODE_UPPERCASE_LETTER)

    {

      gunichar val = ATTTABLE (c >> 8, c & 0xff);

      if (val >= 0x1000000)

	{

	  const gchar *p = special_case_table + val - 0x1000000;

	  return g_utf8_get_char (p);

	}

      else

	{

	  /* Not all uppercase letters are guaranteed to have a lowercase

	   * equivalent.  If this is the case, val will be zero. */

	  return val ? val : c;

	}

    }

  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)

	    return title_table[i][2];

	}

    }

  return c;

}

/**

 * g_unichar_totitle:

 * @c: a Unicode character

 * 

 * Converts a character to the titlecase.

 * 

 * Returns: the result of converting @c to titlecase.

 *               If @c is not an uppercase or lowercase character,

 *               @c is returned unchanged.

 **/

gunichar

g_unichar_totitle (gunichar c)

{

  unsigned int i;

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

    {

      if (title_table[i][0] == c || title_table[i][1] == c

	  || title_table[i][2] == c)

	return title_table[i][0];

    }

  if (TYPE (c) == G_UNICODE_LOWERCASE_LETTER)

    return g_unichar_toupper (c);

  return c;

}

/**

 * g_unichar_digit_value:

 * @c: a Unicode character

 *

 * Determines the numeric value of a character as a decimal

 * digit.

 *

 * Returns: If @c is a decimal digit (according to

 * g_unichar_isdigit()), its numeric value. Otherwise, -1.

 **/

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:

 * @c: a Unicode character

 *

 * Determines the numeric value of a character as a hexidecimal

 * digit.

 *

 * Returns: If @c is a hex digit (according to

 * g_unichar_isxdigit()), its numeric value. Otherwise, -1.

 **/

int

g_unichar_xdigit_value (gunichar c)

{

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

    return c - 'A' + 10;

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

    return c - 'a' + 10;

  if (TYPE (c) == G_UNICODE_DECIMAL_NUMBER)

    return ATTTABLE (c >> 8, c & 0xff);

  return -1;

}

/**

 * g_unichar_type:

 * @c: a Unicode character

 * 

 * Classifies a Unicode character by type.

 * 

 * Returns: the type of the character.

 **/

GUnicodeType

g_unichar_type (gunichar c)

{

  return TYPE (c);

}

/*

 * Case mapping functions

 */

typedef enum {

  LOCALE_NORMAL,

  LOCALE_TURKIC,

  LOCALE_LITHUANIAN

} LocaleType;

static LocaleType

get_locale_type (void)

{

#ifdef G_OS_WIN32

  char *tem = g_win32_getlocale ();

  char locale[2];

  locale[0] = tem[0];

  locale[1] = tem[1];

  g_free (tem);

#else

  const char *locale = setlocale (LC_CTYPE, NULL);

  if (locale == NULL)

    return LOCALE_NORMAL;

#endif

  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;

}

static gint

output_marks (const char **p_inout,

	      char        *out_buffer,

	      gboolean     remove_dot)

{

  const char *p = *p_inout;

  gint len = 0;

  while (*p)

    {

      gunichar c = g_utf8_get_char (p);

      if (ISMARK (TYPE (c)))

	{

	  if (!remove_dot || c != 0x307 /* COMBINING DOT ABOVE */)

	    len += g_unichar_to_utf8 (c, out_buffer ? out_buffer + len : NULL);

	  p = g_utf8_next_char (p);

	}

      else

	break;

    }

  *p_inout = p;

  return len;

}

static gint

output_special_case (gchar *out_buffer,

		     int    offset,

		     int    type,

		     int    which)

{

  const gchar *p = special_case_table + offset;

  gint len;

  if (type != G_UNICODE_TITLECASE_LETTER)

    p = g_utf8_next_char (p);

  if (which == 1)

    p += strlen (p) + 1;

  len = strlen (p);

  if (out_buffer)

    memcpy (out_buffer, p, len);

  return len;

}

static gsize

real_toupper (const gchar *str,

	      gssize       max_len,

	      gchar       *out_buffer,

	      LocaleType   locale_type)

{

  const gchar *p = str;

  const char *last = NULL;

  gsize len = 0;

  gboolean last_was_i = FALSE;

  while ((max_len < 0 || p < str + max_len) && *p)

    {

      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;

		  gunichar decomp[G_UNICHAR_MAX_DECOMPOSITION_LENGTH];

		  decomp_len = g_unichar_fully_decompose (c, FALSE, decomp, G_N_ELEMENTS (decomp));

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

		    }

		  len += output_marks (&p, out_buffer ? out_buffer + len : NULL, TRUE);

		  continue;

		}

	      if (!ISMARK (t))

		last_was_i = FALSE;

	    }

	}

      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.

	   */

	  len += output_marks (&p, out_buffer ? out_buffer + len : NULL, FALSE);

	  /* And output as GREEK CAPITAL LETTER IOTA */

	  len += g_unichar_to_utf8 (0x399, out_buffer ? out_buffer + len : NULL); 	  

	}

      else if (IS (t,

		   OR (G_UNICODE_LOWERCASE_LETTER,

		   OR (G_UNICODE_TITLECASE_LETTER,

		  0))))

	{

	  val = ATTTABLE (c >> 8, c & 0xff);

	  if (val >= 0x1000000)

	    {

	      len += output_special_case (out_buffer ? out_buffer + len : NULL, val - 0x1000000, t,

					  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)

			{

			  val = title_table[i][1];

			  break;

			}

		    }

		}

	      /* 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);

	    }

	}

      else

	{

	  gsize char_len = g_utf8_skip[*(guchar *)last];