/* gutf8.c - Operations on UTF-8 strings.

 *

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

#ifdef HAVE_CODESET

#include <langinfo.h>

#endif

#include <string.h>

#include "glib.h"

#ifdef G_PLATFORM_WIN32

#include <stdio.h>

#define STRICT

#include <windows.h>

#undef STRICT

#endif

#include "libcharset/libcharset.h"

#include "glibintl.h"

#include "galias.h"

#ifdef __SYMBIAN32__

#include "glib_wsd.h"

#endif /* __SYMBIAN32__ */

#if EMULATOR

#define g_thread_functions_for_glib_use (*_g_thread_functions_for_glib_use())

#define g_thread_use_default_impl (*_g_thread_use_default_impl())

#endif /* EMULATOR */

#define UTF8_COMPUTE(Char, Mask, Len)					      \

  if (Char < 128)							      \

    {									      \

      Len = 1;								      \

      Mask = 0x7f;							      \

    }									      \

  else if ((Char & 0xe0) == 0xc0)					      \

    {									      \

      Len = 2;								      \

      Mask = 0x1f;							      \

    }									      \

  else if ((Char & 0xf0) == 0xe0)					      \

    {									      \

      Len = 3;								      \

      Mask = 0x0f;							      \

    }									      \

  else if ((Char & 0xf8) == 0xf0)					      \

    {									      \

      Len = 4;								      \

      Mask = 0x07;							      \

    }									      \

  else if ((Char & 0xfc) == 0xf8)					      \

    {									      \

      Len = 5;								      \

      Mask = 0x03;							      \

    }									      \

  else if ((Char & 0xfe) == 0xfc)					      \

    {									      \

      Len = 6;								      \

      Mask = 0x01;							      \

    }									      \

  else									      \

    Len = -1;

#define UTF8_LENGTH(Char)              \

  ((Char) < 0x80 ? 1 :                 \

   ((Char) < 0x800 ? 2 :               \

    ((Char) < 0x10000 ? 3 :            \

     ((Char) < 0x200000 ? 4 :          \

      ((Char) < 0x4000000 ? 5 : 6)))))

#define UTF8_GET(Result, Chars, Count, Mask, Len)			      \

  (Result) = (Chars)[0] & (Mask);					      \

  for ((Count) = 1; (Count) < (Len); ++(Count))				      \

    {									      \

      if (((Chars)[(Count)] & 0xc0) != 0x80)				      \

	{								      \

	  (Result) = -1;						      \

	  break;							      \

	}								      \

      (Result) <<= 6;							      \

      (Result) |= ((Chars)[(Count)] & 0x3f);				      \

    }

#define UNICODE_VALID(Char)                   \

    ((Char) < 0x110000 &&                     \

     (((Char) & 0xFFFFF800) != 0xD800) &&     \

     ((Char) < 0xFDD0 || (Char) > 0xFDEF) &&  \

     ((Char) & 0xFFFE) != 0xFFFE)

static const gchar utf8_skip_data[256] = {

  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,

  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,

  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,

  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,

  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,

  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,

  2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,

  3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,6,6,1,1

};

const gchar * const g_utf8_skip = utf8_skip_data;

#ifdef __SYMBIAN32__

EXPORT_C const gchar * const * _g_utf8_skip(void)

{

	return &g_utf8_skip;

}

#endif /* __SYMBIAN32__ */

/**

 * g_utf8_find_prev_char:

 * @str: pointer to the beginning of a UTF-8 encoded string

 * @p: pointer to some position within @str

 * 

 * Given a position @p with a UTF-8 encoded string @str, find the start

 * of the previous UTF-8 character starting before @p. Returns %NULL if no

 * UTF-8 characters are present in @str before @p.

 *

 * @p does not have to be at the beginning of a UTF-8 character. No check

 * is made to see if the character found is actually valid other than

 * it starts with an appropriate byte.

 *

 * Return value: a pointer to the found character or %NULL.

 **/

EXPORT_C gchar *

g_utf8_find_prev_char (const char *str,

		       const char *p)

{

  for (--p; p >= str; --p)

    {

      if ((*p & 0xc0) != 0x80)

	return (gchar *)p;

    }

  return NULL;

}

/**

 * g_utf8_find_next_char:

 * @p: a pointer to a position within a UTF-8 encoded string

 * @end: a pointer to the byte following the end of the string,

 * or %NULL to indicate that the string is nul-terminated.

 *

 * Finds the start of the next UTF-8 character in the string after @p.

 *

 * @p does not have to be at the beginning of a UTF-8 character. No check

 * is made to see if the character found is actually valid other than

 * it starts with an appropriate byte.

 * 

 * Return value: a pointer to the found character or %NULL

 **/

EXPORT_C gchar *

g_utf8_find_next_char (const gchar *p,

		       const gchar *end)

{

  if (*p)

    {

      if (end)

	for (++p; p < end && (*p & 0xc0) == 0x80; ++p)

	  ;

      else

	for (++p; (*p & 0xc0) == 0x80; ++p)

	  ;

    }

  return (p == end) ? NULL : (gchar *)p;

}

/**

 * g_utf8_prev_char:

 * @p: a pointer to a position within a UTF-8 encoded string

 *

 * Finds the previous UTF-8 character in the string before @p.

 *

 * @p does not have to be at the beginning of a UTF-8 character. No check

 * is made to see if the character found is actually valid other than

 * it starts with an appropriate byte. If @p might be the first

 * character of the string, you must use g_utf8_find_prev_char() instead.

 * 

 * Return value: a pointer to the found character.

 **/

EXPORT_C gchar *

g_utf8_prev_char (const gchar *p)

{

  while (TRUE)

    {

      p--;

      if ((*p & 0xc0) != 0x80)

	return (gchar *)p;

    }

}

/**

 * g_utf8_strlen:

 * @p: pointer to the start of a UTF-8 encoded string.

 * @max: the maximum number of bytes to examine. If @max

 *       is less than 0, then the string is assumed to be

 *       nul-terminated. If @max is 0, @p will not be examined and 

 *       may be %NULL.

 * 

 * Returns the length of the string in characters.

 *

 * Return value: the length of the string in characters

 **/

EXPORT_C glong

g_utf8_strlen (const gchar *p,

               gssize       max)

{

  glong len = 0;

  const gchar *start = p;

  g_return_val_if_fail (p != NULL || max == 0, 0);

  if (max < 0)

    {

      while (*p)

        {

          p = g_utf8_next_char (p);

          ++len;

        }

    }

  else

    {

      if (max == 0 || !*p)

        return 0;

      p = g_utf8_next_char (p);          

      while (p - start < max && *p)

        {

          ++len;

          p = g_utf8_next_char (p);          

        }

      /* only do the last len increment if we got a complete

       * char (don't count partial chars)

       */

      if (p - start <= max)

        ++len;

    }

  return len;

}

/**

 * g_utf8_get_char:

 * @p: a pointer to Unicode character encoded as UTF-8

 * 

 * Converts a sequence of bytes encoded as UTF-8 to a Unicode character.

 * If @p does not point to a valid UTF-8 encoded character, results are

 * undefined. If you are not sure that the bytes are complete

 * valid Unicode characters, you should use g_utf8_get_char_validated()

 * instead.

 * 

 * Return value: the resulting character

 **/

EXPORT_C gunichar

g_utf8_get_char (const gchar *p)

{

  int i, mask = 0, len;

  gunichar result;

  unsigned char c = (unsigned char) *p;

  UTF8_COMPUTE (c, mask, len);

  if (len == -1)

    return (gunichar)-1;

  UTF8_GET (result, p, i, mask, len);

  return result;

}

/**

 * g_utf8_offset_to_pointer:

 * @str: a UTF-8 encoded string

 * @offset: a character offset within @str

 *

 * Converts from an integer character offset to a pointer to a position

 * within the string.

 *

 * Since 2.10, this function allows to pass a negative @offset to

 * step backwards. It is usually worth stepping backwards from the end

 * instead of forwards if @offset is in the last fourth of the string,

 * since moving forward is about 3 times faster than moving backward.

 *

 * <note><para>

 * This function doesn't abort when reaching the end of @str. Therefore

 * you should be sure that @offset is within string boundaries before

 * calling that function. Call g_utf8_strlen() when unsure.

 *

 * This limitation exists as this function is called frequently during

 * text rendering and therefore has to be as fast as possible.

 * </para></note>

 *

 * Return value: the resulting pointer

 **/

EXPORT_C gchar *

g_utf8_offset_to_pointer  (const gchar *str,

			   glong        offset)

{

  const gchar *s = str;

  if (offset > 0) 

    while (offset--)

      s = g_utf8_next_char (s);

  else

    {

      const char *s1;

      /* This nice technique for fast backwards stepping 

       * through a UTF-8 string was dubbed "stutter stepping" 

       * by its inventor, Larry Ewing.

       */

      while (offset)

	{

	  s1 = s;

	  s += offset;

	  while ((*s & 0xc0) == 0x80)

	    s--;

	  offset += g_utf8_pointer_to_offset (s, s1);

	}

    }

  return (gchar *)s;

}

/**

 * g_utf8_pointer_to_offset:

 * @str: a UTF-8 encoded string

 * @pos: a pointer to a position within @str

 * 

 * Converts from a pointer to position within a string to a integer

 * character offset.

 *

 * Since 2.10, this function allows @pos to be before @str, and returns

 * a negative offset in this case.

 * 

 * Return value: the resulting character offset

 **/

EXPORT_C glong    

g_utf8_pointer_to_offset (const gchar *str,

			  const gchar *pos)

{

  const gchar *s = str;

  glong offset = 0;    

  if (pos < str) 

    offset = - g_utf8_pointer_to_offset (pos, str);

  else

    while (s < pos)

      {

	s = g_utf8_next_char (s);

	offset++;

      }

  return offset;

}

/**

 * g_utf8_strncpy:

 * @dest: buffer to fill with characters from @src

 * @src: UTF-8 encoded string

 * @n: character count

 * 

 * Like the standard C strncpy() function, but 

 * copies a given number of characters instead of a given number of 

 * bytes. The @src string must be valid UTF-8 encoded text. 

 * (Use g_utf8_validate() on all text before trying to use UTF-8 

 * utility functions with it.)

 * 

 * Return value: @dest

 **/

EXPORT_C gchar *

g_utf8_strncpy (gchar       *dest,

		const gchar *src,

		gsize        n)

{

  const gchar *s = src;

  while (n && *s)

    {

      s = g_utf8_next_char(s);

      n--;

    }

  strncpy(dest, src, s - src);

  dest[s - src] = 0;

  return dest;

}

#if EMULATOR

PLS_MACRO(aliases,gutf8,GStaticMutex)

#define g__aliases_lock (*FUNCTION_NAME_MACRO(aliases,gutf8)())

PLS(alias_hash,get_alias_hash,GHashTable *)

#define alias_hash (*FUNCTION_NAME(alias_hash,get_alias_hash)())

#else

G_LOCK_DEFINE_STATIC (aliases);

#endif /* EMULATOR */

static GHashTable *

get_alias_hash (void)

{

  #if !(EMULATOR)

  static GHashTable *alias_hash = NULL;

  #endif /* EMULATOR */

  const char *aliases;

  G_LOCK (aliases);

  if (!alias_hash)

    {

      alias_hash = g_hash_table_new (g_str_hash, g_str_equal);

      aliases = _g_locale_get_charset_aliases ();

      while (*aliases != '\0')

	{

	  const char *canonical;

	  const char *alias;

	  const char **alias_array;

	  int count = 0;

	  alias = aliases;

	  aliases += strlen (aliases) + 1;

	  canonical = aliases;

	  aliases += strlen (aliases) + 1;

	  alias_array = g_hash_table_lookup (alias_hash, canonical);

	  if (alias_array)

	    {

	      while (alias_array[count])

		count++;

	    }

	  alias_array = g_renew (const char *, alias_array, count + 2);

	  alias_array[count] = alias;

	  alias_array[count + 1] = NULL;

	  g_hash_table_insert (alias_hash, (char *)canonical, alias_array);

	}

    }

  G_UNLOCK (aliases);

  return alias_hash;

}

#if EMULATOR

#undef alias_hash

#endif /* EMULATOR */

/* As an abuse of the alias table, the following routines gets

 * the charsets that are aliases for the canonical name.

 */

G_GNUC_INTERNAL const char ** 

_g_charset_get_aliases (const char *canonical_name)

{

  GHashTable *alias_hash = get_alias_hash ();

  return g_hash_table_lookup (alias_hash, canonical_name);

}

static gboolean

g_utf8_get_charset_internal (const char  *raw_data,

			     const char **a)

{

  const char *charset = getenv("CHARSET");

  if (charset && *charset)

    {

      *a = charset;

      if (charset && strstr (charset, "UTF-8"))

	return TRUE;

      else

	return FALSE;

    }

  /* The libcharset code tries to be thread-safe without

   * a lock, but has a memory leak and a missing memory

   * barrier, so we lock for it

   */

  G_LOCK (aliases);

  charset = _g_locale_charset_unalias (raw_data);

  G_UNLOCK (aliases);

  if (charset && *charset)

    {

      *a = charset;

      if (charset && strstr (charset, "UTF-8"))

	return TRUE;

      else

	return FALSE;

    }

  /* Assume this for compatibility at present.  */

  *a = "US-ASCII";

  return FALSE;

}

typedef struct _GCharsetCache GCharsetCache;