/* gmarkup.c - Simple XML-like parser

 *

 *  Copyright 2000, 2003 Red Hat, Inc.

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

 *

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

 *

 * GLib 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 GLib; see the file COPYING.LIB.  If not,

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

 *   Boston, MA 02111-1307, USA.

 */

#include "config.h"

#include <stdarg.h>

#include <string.h>

#include <stdio.h>

#include <stdlib.h>

#include <errno.h>

#include "glib.h"

#include "galias.h"

#include "glibintl.h"

#ifdef __SYMBIAN32__

#include <glib_wsd.h>

#endif

#if EMULATOR

PLS(error_quark ,g_markup_error_quark,GQuark)

#define error_quark  (*FUNCTION_NAME(error_quark ,g_markup_error_quark)())

#endif /* EMULATOR */

EXPORT_C GQuark

g_markup_error_quark (void)

{

  #if !(EMULATOR)

  static GQuark error_quark = 0;

  #endif /*EMULATOR */

  if (error_quark == 0)

    error_quark = g_quark_from_static_string ("g-markup-error-quark");

  return error_quark;

}

#if EMULATOR

#undef error_quark

#endif /* EMULATOR */

typedef enum

{

  STATE_START,

  STATE_AFTER_OPEN_ANGLE,

  STATE_AFTER_CLOSE_ANGLE,

  STATE_AFTER_ELISION_SLASH, /* the slash that obviates need for end element */

  STATE_INSIDE_OPEN_TAG_NAME,

  STATE_INSIDE_ATTRIBUTE_NAME,

  STATE_AFTER_ATTRIBUTE_NAME,

  STATE_BETWEEN_ATTRIBUTES,

  STATE_AFTER_ATTRIBUTE_EQUALS_SIGN,

  STATE_INSIDE_ATTRIBUTE_VALUE_SQ,

  STATE_INSIDE_ATTRIBUTE_VALUE_DQ,

  STATE_INSIDE_TEXT,

  STATE_AFTER_CLOSE_TAG_SLASH,

  STATE_INSIDE_CLOSE_TAG_NAME,

  STATE_AFTER_CLOSE_TAG_NAME,

  STATE_INSIDE_PASSTHROUGH,

  STATE_ERROR

} GMarkupParseState;

struct _GMarkupParseContext

{

  const GMarkupParser *parser;

  GMarkupParseFlags flags;

  gint line_number;

  gint char_number;

  gpointer user_data;

  GDestroyNotify dnotify;

  /* A piece of character data or an element that

   * hasn't "ended" yet so we haven't yet called

   * the callback for it.

   */

  GString *partial_chunk;

  GMarkupParseState state;

  GSList *tag_stack;

  gchar **attr_names;

  gchar **attr_values;

  gint cur_attr;

  gint alloc_attrs;

  const gchar *current_text;

  gssize       current_text_len;      

  const gchar *current_text_end;

  GString *leftover_char_portion;

  /* used to save the start of the last interesting thingy */

  const gchar *start;

  const gchar *iter;

  guint document_empty : 1;

  guint parsing : 1;

  gint balance;

};

/**

 * g_markup_parse_context_new:

 * @parser: a #GMarkupParser

 * @flags: one or more #GMarkupParseFlags

 * @user_data: user data to pass to #GMarkupParser functions

 * @user_data_dnotify: user data destroy notifier called when the parse context is freed

 * 

 * Creates a new parse context. A parse context is used to parse

 * marked-up documents. You can feed any number of documents into

 * a context, as long as no errors occur; once an error occurs,

 * the parse context can't continue to parse text (you have to free it

 * and create a new parse context).

 * 

 * Return value: a new #GMarkupParseContext

 **/

EXPORT_C GMarkupParseContext *

g_markup_parse_context_new (const GMarkupParser *parser,

                            GMarkupParseFlags    flags,

                            gpointer             user_data,

                            GDestroyNotify       user_data_dnotify)

{

  GMarkupParseContext *context;

  g_return_val_if_fail (parser != NULL, NULL);

  context = g_new (GMarkupParseContext, 1);

  context->parser = parser;

  context->flags = flags;

  context->user_data = user_data;

  context->dnotify = user_data_dnotify;

  context->line_number = 1;

  context->char_number = 1;

  context->partial_chunk = NULL;

  context->state = STATE_START;

  context->tag_stack = NULL;

  context->attr_names = NULL;

  context->attr_values = NULL;

  context->cur_attr = -1;

  context->alloc_attrs = 0;

  context->current_text = NULL;

  context->current_text_len = -1;

  context->current_text_end = NULL;

  context->leftover_char_portion = NULL;

  context->start = NULL;

  context->iter = NULL;

  context->document_empty = TRUE;

  context->parsing = FALSE;

  context->balance = 0;

  return context;

}

/**

 * g_markup_parse_context_free:

 * @context: a #GMarkupParseContext

 * 

 * Frees a #GMarkupParseContext. Can't be called from inside

 * one of the #GMarkupParser functions.

 * 

 **/

EXPORT_C void

g_markup_parse_context_free (GMarkupParseContext *context)

{

  g_return_if_fail (context != NULL);

  g_return_if_fail (!context->parsing);

  if (context->dnotify)

    (* context->dnotify) (context->user_data);

  g_strfreev (context->attr_names);

  g_strfreev (context->attr_values);

  g_slist_foreach (context->tag_stack, (GFunc)g_free, NULL);

  g_slist_free (context->tag_stack);

  if (context->partial_chunk)

    g_string_free (context->partial_chunk, TRUE);

  if (context->leftover_char_portion)

    g_string_free (context->leftover_char_portion, TRUE);

  g_free (context);

}

static void

mark_error (GMarkupParseContext *context,

            GError              *error)

{

  context->state = STATE_ERROR;

  if (context->parser->error)

    (*context->parser->error) (context, error, context->user_data);

}

static void set_error (GMarkupParseContext *context,

           	       GError             **error,

           	       GMarkupError         code,

           	       const gchar         *format,

           	       ...) G_GNUC_PRINTF (4, 5);

static void

set_error (GMarkupParseContext *context,

           GError             **error,

           GMarkupError         code,

           const gchar         *format,

           ...)

{

  GError *tmp_error;

  gchar *s;

  va_list args;

  va_start (args, format);

  s = g_strdup_vprintf (format, args);

  va_end (args);

  tmp_error = g_error_new (G_MARKUP_ERROR,

                           code,

                           _("Error on line %d char %d: %s"),

                           context->line_number,

                           context->char_number,

                           s);

  g_free (s);

  mark_error (context, tmp_error);

  g_propagate_error (error, tmp_error);

}

/* To make these faster, we first use the ascii-only tests, then check

 * for the usual non-alnum name-end chars, and only then call the

 * expensive unicode stuff. Nobody uses non-ascii in XML tag/attribute

 * names, so this is a reasonable hack that virtually always avoids

 * the guniprop call.

 */

#define IS_COMMON_NAME_END_CHAR(c) \

  ((c) == '=' || (c) == '/' || (c) == '>' || (c) == ' ')

static gboolean

is_name_start_char (const gchar *p)

{

  if (g_ascii_isalpha (*p) ||

      (!IS_COMMON_NAME_END_CHAR (*p) &&

       (*p == '_' || 

	*p == ':' ||

	g_unichar_isalpha (g_utf8_get_char (p)))))

    return TRUE;

  else

    return FALSE;

}

static gboolean

is_name_char (const gchar *p)

{

  if (g_ascii_isalnum (*p) ||

      (!IS_COMMON_NAME_END_CHAR (*p) &&

       (*p == '.' || 

	*p == '-' ||

	*p == '_' ||

	*p == ':' ||

	g_unichar_isalpha (g_utf8_get_char (p)))))

    return TRUE;

  else

    return FALSE;

}

static gchar*

char_str (gunichar c,

          gchar   *buf)

{

  memset (buf, 0, 8);

  g_unichar_to_utf8 (c, buf);

  return buf;

}

static gchar*

utf8_str (const gchar *utf8,

          gchar       *buf)

{

  char_str (g_utf8_get_char (utf8), buf);

  return buf;

}

static void

set_unescape_error (GMarkupParseContext *context,

                    GError             **error,

                    const gchar         *remaining_text,

                    const gchar         *remaining_text_end,

                    GMarkupError         code,

                    const gchar         *format,

                    ...)

{

  GError *tmp_error;

  gchar *s;

  va_list args;

  gint remaining_newlines;

  const gchar *p;

  remaining_newlines = 0;

  p = remaining_text;

  while (p != remaining_text_end)

    {

      if (*p == '\n')

        ++remaining_newlines;

      ++p;

    }

  va_start (args, format);

  s = g_strdup_vprintf (format, args);

  va_end (args);

  tmp_error = g_error_new (G_MARKUP_ERROR,

                           code,

                           _("Error on line %d: %s"),

                           context->line_number - remaining_newlines,

                           s);

  g_free (s);

  mark_error (context, tmp_error);

  g_propagate_error (error, tmp_error);

}

typedef enum

{

  USTATE_INSIDE_TEXT,

  USTATE_AFTER_AMPERSAND,

  USTATE_INSIDE_ENTITY_NAME,

  USTATE_AFTER_CHARREF_HASH

} UnescapeState;

typedef struct

{

  GMarkupParseContext *context;

  GString *str;

  UnescapeState state;

  const gchar *text;

  const gchar *text_end;

  const gchar *entity_start;

} UnescapeContext;

static const gchar*

unescape_text_state_inside_text (UnescapeContext *ucontext,

                                 const gchar     *p,

                                 GError         **error)

{

  const gchar *start;

  gboolean normalize_attribute;

  if (ucontext->context->state == STATE_INSIDE_ATTRIBUTE_VALUE_SQ ||

      ucontext->context->state == STATE_INSIDE_ATTRIBUTE_VALUE_DQ)

    normalize_attribute = TRUE;

  else

    normalize_attribute = FALSE;

  start = p;

  while (p != ucontext->text_end)

    {

      if (*p == '&')

        {

          break;

        }

      else if (normalize_attribute && (*p == '\t' || *p == '\n'))

        {

          g_string_append_len (ucontext->str, start, p - start);

          g_string_append_c (ucontext->str, ' ');

          p = g_utf8_next_char (p);

          start = p;

        }

      else if (*p == '\r')

        {

          g_string_append_len (ucontext->str, start, p - start);

          g_string_append_c (ucontext->str, normalize_attribute ? ' ' : '\n');

          p = g_utf8_next_char (p);

          if (p != ucontext->text_end && *p == '\n')

            p = g_utf8_next_char (p);

          start = p;

        }

      else

        p = g_utf8_next_char (p);

    }

  if (p != start)

    g_string_append_len (ucontext->str, start, p - start);

  if (p != ucontext->text_end && *p == '&')

    {

      p = g_utf8_next_char (p);

      ucontext->state = USTATE_AFTER_AMPERSAND;

    }

  return p;

}

static const gchar*

unescape_text_state_after_ampersand (UnescapeContext *ucontext,

                                     const gchar     *p,

                                     GError         **error)

{

  ucontext->entity_start = NULL;

  if (*p == '#')

    {

      p = g_utf8_next_char (p);

      ucontext->entity_start = p;

      ucontext->state = USTATE_AFTER_CHARREF_HASH;

    }

  else if (!is_name_start_char (p))

    {

      if (*p == ';')

        {

          set_unescape_error (ucontext->context, error,

                              p, ucontext->text_end,

                              G_MARKUP_ERROR_PARSE,

                              _("Empty entity '&;' seen; valid "

                                "entities are: & " < > '"));

        }

      else

        {

          gchar buf[8];

          set_unescape_error (ucontext->context, error,

                              p, ucontext->text_end,

                              G_MARKUP_ERROR_PARSE,

                              _("Character '%s' is not valid at "

                                "the start of an entity name; "

                                "the & character begins an entity; "

                                "if this ampersand isn't supposed "

                                "to be an entity, escape it as "

                                "&"),

                              utf8_str (p, buf));

        }

    }

  else

    {

      ucontext->entity_start = p;

      ucontext->state = USTATE_INSIDE_ENTITY_NAME;

    }

  return p;

}

static const gchar*

unescape_text_state_inside_entity_name (UnescapeContext *ucontext,

                                        const gchar     *p,

                                        GError         **error)

{

  while (p != ucontext->text_end)

    {

      if (*p == ';')

        break;

      else if (!is_name_char (p))

        {

          gchar ubuf[8];

          set_unescape_error (ucontext->context, error,

                              p, ucontext->text_end,

                              G_MARKUP_ERROR_PARSE,

                              _("Character '%s' is not valid "

                                "inside an entity name"),

                              utf8_str (p, ubuf));

          break;

        }

      p = g_utf8_next_char (p);

    }

  if (ucontext->context->state != STATE_ERROR)

    {

      if (p != ucontext->text_end)

        {

	  gint len = p - ucontext->entity_start;

          /* move to after semicolon */

          p = g_utf8_next_char (p);

          ucontext->state = USTATE_INSIDE_TEXT;

          if (strncmp (ucontext->entity_start, "lt", len) == 0)

            g_string_append_c (ucontext->str, '<');

          else if (strncmp (ucontext->entity_start, "gt", len) == 0)

            g_string_append_c (ucontext->str, '>');

          else if (strncmp (ucontext->entity_start, "amp", len) == 0)

            g_string_append_c (ucontext->str, '&');

          else if (strncmp (ucontext->entity_start, "quot", len) == 0)

            g_string_append_c (ucontext->str, '"');

          else if (strncmp (ucontext->entity_start, "apos", len) == 0)

            g_string_append_c (ucontext->str, '\'');

          else

            {

	      gchar *name;