diff -r 000000000000 -r e4d67989cc36 glib/libglib/src/gmarkup.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/glib/libglib/src/gmarkup.c	Tue Feb 02 02:01:42 2010 +0200
@@ -0,0 +1,2283 @@
+/* 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: &amp; &quot; &lt; &gt; &apos;"));
+        }
+      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 "
+                                "&amp;"),
+                              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;
+
+	      name = g_strndup (ucontext->entity_start, len);
+              set_unescape_error (ucontext->context, error,
+                                  p, ucontext->text_end,
+                                  G_MARKUP_ERROR_PARSE,
+                                  _("Entity name '%s' is not known"),
+                                  name);
+	      g_free (name);
+            }
+        }
+      else
+        {
+          set_unescape_error (ucontext->context, error,
+                              /* give line number of the & */
+                              ucontext->entity_start, ucontext->text_end,
+                              G_MARKUP_ERROR_PARSE,
+                              _("Entity did not end with a semicolon; "
+                                "most likely you used an ampersand "
+                                "character without intending to start "
+                                "an entity - escape ampersand as &amp;"));
+        }
+    }
+#undef MAX_ENT_LEN
+
+  return p;
+}
+
+static const gchar*
+unescape_text_state_after_charref_hash (UnescapeContext *ucontext,
+                                        const gchar     *p,
+                                        GError         **error)
+{
+  gboolean is_hex = FALSE;
+  const char *start;
+
+  start = ucontext->entity_start;
+
+  if (*p == 'x')
+    {
+      is_hex = TRUE;
+      p = g_utf8_next_char (p);
+      start = p;
+    }
+
+  while (p != ucontext->text_end && *p != ';')
+    p = g_utf8_next_char (p);
+
+  if (p != ucontext->text_end)
+    {
+      g_assert (*p == ';');
+
+      /* digit is between start and p */
+
+      if (start != p)
+        {
+          gulong l;
+          gchar *end = NULL;
+                    
+          errno = 0;
+          if (is_hex)
+            l = strtoul (start, &end, 16);
+          else
+            l = strtoul (start, &end, 10);
+
+          if (end != p || errno != 0)
+            {
+              set_unescape_error (ucontext->context, error,
+                                  start, ucontext->text_end,
+                                  G_MARKUP_ERROR_PARSE,
+                                  _("Failed to parse '%-.*s', which "
+                                    "should have been a digit "
+                                    "inside a character reference "
+                                    "(&#234; for example) - perhaps "
+                                    "the digit is too large"),
+                                  p - start, start);
+            }
+          else
+            {
+              /* characters XML permits */
+              if (l == 0x9 ||
+                  l == 0xA ||
+                  l == 0xD ||
+                  (l >= 0x20 && l <= 0xD7FF) ||
+                  (l >= 0xE000 && l <= 0xFFFD) ||
+                  (l >= 0x10000 && l <= 0x10FFFF))
+                {
+                  gchar buf[8];
+                  g_string_append (ucontext->str, char_str (l, buf));
+                }
+              else
+                {
+                  set_unescape_error (ucontext->context, error,
+                                      start, ucontext->text_end,
+                                      G_MARKUP_ERROR_PARSE,
+                                      _("Character reference '%-.*s' does not "
+					"encode a permitted character"),
+                                      p - start, start);
+                }
+            }
+
+          /* Move to next state */
+          p = g_utf8_next_char (p); /* past semicolon */
+          ucontext->state = USTATE_INSIDE_TEXT;
+        }
+      else
+        {
+          set_unescape_error (ucontext->context, error,
+                              start, ucontext->text_end,
+                              G_MARKUP_ERROR_PARSE,
+                              _("Empty character reference; "
+                                "should include a digit such as "
+                                "&#454;"));
+        }
+    }
+  else
+    {
+      set_unescape_error (ucontext->context, error,
+                          start, ucontext->text_end,
+                          G_MARKUP_ERROR_PARSE,
+                          _("Character reference did not end with a "
+                            "semicolon; "
+                            "most likely you used an ampersand "
+                            "character without intending to start "
+                            "an entity - escape ampersand as &amp;"));
+    }
+
+  return p;
+}
+
+static gboolean
+unescape_text (GMarkupParseContext *context,
+               const gchar         *text,
+               const gchar         *text_end,
+               GString            **unescaped,
+               GError             **error)
+{
+  UnescapeContext ucontext;
+  const gchar *p;
+
+  ucontext.context = context;
+  ucontext.text = text;
+  ucontext.text_end = text_end;
+  ucontext.entity_start = NULL;
+  
+  ucontext.str = g_string_sized_new (text_end - text);
+
+  ucontext.state = USTATE_INSIDE_TEXT;
+  p = text;
+
+  while (p != text_end && context->state != STATE_ERROR)
+    {
+      g_assert (p < text_end);
+      
+      switch (ucontext.state)
+        {
+        case USTATE_INSIDE_TEXT:
+          {
+            p = unescape_text_state_inside_text (&ucontext,
+                                                 p,
+                                                 error);
+          }
+          break;
+
+        case USTATE_AFTER_AMPERSAND:
+          {
+            p = unescape_text_state_after_ampersand (&ucontext,
+                                                     p,
+                                                     error);
+          }
+          break;
+
+
+        case USTATE_INSIDE_ENTITY_NAME:
+          {
+            p = unescape_text_state_inside_entity_name (&ucontext,
+                                                        p,
+                                                        error);
+          }
+          break;
+
+        case USTATE_AFTER_CHARREF_HASH:
+          {
+            p = unescape_text_state_after_charref_hash (&ucontext,
+                                                        p,
+                                                        error);
+          }
+          break;
+
+        default:
+          g_assert_not_reached ();
+          break;
+        }
+    }
+
+  if (context->state != STATE_ERROR) 
+    {
+      switch (ucontext.state) 
+	{
+	case USTATE_INSIDE_TEXT:
+	  break;
+	case USTATE_AFTER_AMPERSAND:
+	case USTATE_INSIDE_ENTITY_NAME:
+	  set_unescape_error (context, error,
+			      NULL, NULL,
+			      G_MARKUP_ERROR_PARSE,
+			      _("Unfinished entity reference"));
+	  break;
+	case USTATE_AFTER_CHARREF_HASH:
+	  set_unescape_error (context, error,
+			      NULL, NULL,
+			      G_MARKUP_ERROR_PARSE,
+			      _("Unfinished character reference"));
+	  break;
+	}
+    }
+
+  if (context->state == STATE_ERROR)
+    {
+      g_string_free (ucontext.str, TRUE);
+      *unescaped = NULL;
+      return FALSE;
+    }
+  else
+    {
+      *unescaped = ucontext.str;
+      return TRUE;
+    }
+}
+
+static inline gboolean
+advance_char (GMarkupParseContext *context)
+{  
+  context->iter = g_utf8_next_char (context->iter);
+  context->char_number += 1;
+
+  if (context->iter == context->current_text_end)
+    {
+      return FALSE;
+    }
+  else if (*context->iter == '\n')
+    {
+      context->line_number += 1;
+      context->char_number = 1;
+    }
+  
+  return TRUE;
+}
+
+static inline gboolean
+xml_isspace (char c)
+{
+  return c == ' ' || c == '\t' || c == '\n' || c == '\r';
+}
+
+static void
+skip_spaces (GMarkupParseContext *context)
+{
+  do
+    {
+      if (!xml_isspace (*context->iter))
+        return;
+    }
+  while (advance_char (context));
+}
+
+static void
+advance_to_name_end (GMarkupParseContext *context)
+{
+  do
+    {
+      if (!is_name_char (context->iter))
+        return;
+    }
+  while (advance_char (context));
+}
+
+static void
+add_to_partial (GMarkupParseContext *context,
+                const gchar         *text_start,
+                const gchar         *text_end)
+{
+  if (context->partial_chunk == NULL)
+    context->partial_chunk = g_string_sized_new (text_end - text_start);
+
+  if (text_start != text_end)
+    g_string_append_len (context->partial_chunk, text_start,
+                         text_end - text_start);
+
+  /* Invariant here that partial_chunk exists */
+}
+
+static void
+truncate_partial (GMarkupParseContext *context)
+{
+  if (context->partial_chunk != NULL)
+    {
+      context->partial_chunk = g_string_truncate (context->partial_chunk, 0);
+    }
+}
+
+static const gchar*
+current_element (GMarkupParseContext *context)
+{
+  return context->tag_stack->data;
+}
+
+static const gchar*
+current_attribute (GMarkupParseContext *context)
+{
+  g_assert (context->cur_attr >= 0);
+  return context->attr_names[context->cur_attr];
+}
+
+static void
+find_current_text_end (GMarkupParseContext *context)
+{
+  /* This function must be safe (non-segfaulting) on invalid UTF8.
+   * It assumes the string starts with a character start
+   */
+  const gchar *end = context->current_text + context->current_text_len;
+  const gchar *p;
+  const gchar *next;
+
+  g_assert (context->current_text_len > 0);
+
+  p = g_utf8_find_prev_char (context->current_text, end);
+
+  g_assert (p != NULL); /* since current_text was a char start */
+
+  /* p is now the start of the last character or character portion. */
+  g_assert (p != end);
+  next = g_utf8_next_char (p); /* this only touches *p, nothing beyond */
+
+  if (next == end)
+    {
+      /* whole character */
+      context->current_text_end = end;
+    }
+  else
+    {
+      /* portion */
+      context->leftover_char_portion = g_string_new_len (p, end - p);
+      context->current_text_len -= (end - p);
+      context->current_text_end = p;
+    }
+}
+
+
+static void
+add_attribute (GMarkupParseContext *context, char *name)
+{
+  if (context->cur_attr + 2 >= context->alloc_attrs)
+    {
+      context->alloc_attrs += 5; /* silly magic number */
+      context->attr_names = g_realloc (context->attr_names, sizeof(char*)*context->alloc_attrs);
+      context->attr_values = g_realloc (context->attr_values, sizeof(char*)*context->alloc_attrs);         
+    }
+  context->cur_attr++;
+  context->attr_names[context->cur_attr] = name;
+  context->attr_values[context->cur_attr] = NULL;
+  context->attr_names[context->cur_attr+1] = NULL;
+  context->attr_values[context->cur_attr+1] = NULL;
+}
+
+/**
+ * g_markup_parse_context_parse:
+ * @context: a #GMarkupParseContext
+ * @text: chunk of text to parse
+ * @text_len: length of @text in bytes
+ * @error: return location for a #GError
+ * 
+ * Feed some data to the #GMarkupParseContext. The data need not
+ * be valid UTF-8; an error will be signaled if it's invalid.
+ * The data need not be an entire document; you can feed a document
+ * into the parser incrementally, via multiple calls to this function.
+ * Typically, as you receive data from a network connection or file,
+ * you feed each received chunk of data into this function, aborting
+ * the process if an error occurs. Once an error is reported, no further
+ * data may be fed to the #GMarkupParseContext; all errors are fatal.
+ * 
+ * Return value: %FALSE if an error occurred, %TRUE on success
+ **/
+EXPORT_C gboolean
+g_markup_parse_context_parse (GMarkupParseContext *context,
+                              const gchar         *text,
+                              gssize               text_len,
+                              GError             **error)
+{
+  const gchar *first_invalid;
+  
+  g_return_val_if_fail (context != NULL, FALSE);
+  g_return_val_if_fail (text != NULL, FALSE);
+  g_return_val_if_fail (context->state != STATE_ERROR, FALSE);
+  g_return_val_if_fail (!context->parsing, FALSE);
+  
+  if (text_len < 0)
+    text_len = strlen (text);
+
+  if (text_len == 0)
+    return TRUE;
+  
+  context->parsing = TRUE;
+  
+  if (context->leftover_char_portion)
+    {
+      const gchar *first_char;
+
+      if ((*text & 0xc0) != 0x80)
+        first_char = text;
+      else
+        first_char = g_utf8_find_next_char (text, text + text_len);
+
+      if (first_char)
+        {
+          /* leftover_char_portion was completed. Parse it. */
+          GString *portion = context->leftover_char_portion;
+          
+          g_string_append_len (context->leftover_char_portion,
+                               text, first_char - text);
+
+          /* hacks to allow recursion */
+          context->parsing = FALSE;
+          context->leftover_char_portion = NULL;
+          
+          if (!g_markup_parse_context_parse (context,
+                                             portion->str, portion->len,
+                                             error))
+            {
+              g_assert (context->state == STATE_ERROR);
+            }
+          
+          g_string_free (portion, TRUE);
+          context->parsing = TRUE;
+
+          /* Skip the fraction of char that was in this text */
+          text_len -= (first_char - text);
+          text = first_char;
+        }
+      else
+        {
+          /* another little chunk of the leftover char; geez
+           * someone is inefficient.
+           */
+          g_string_append_len (context->leftover_char_portion,
+                               text, text_len);
+
+          if (context->leftover_char_portion->len > 7)
+            {
+              /* The leftover char portion is too big to be
+               * a UTF-8 character
+               */
+              set_error (context,
+                         error,
+                         G_MARKUP_ERROR_BAD_UTF8,
+                         _("Invalid UTF-8 encoded text"));
+            }
+          
+          goto finished;
+        }
+    }
+
+  context->current_text = text;
+  context->current_text_len = text_len;
+  context->iter = context->current_text;
+  context->start = context->iter;
+
+  /* Nothing left after finishing the leftover char, or nothing
+   * passed in to begin with.
+   */
+  if (context->current_text_len == 0)
+    goto finished;
+
+  /* find_current_text_end () assumes the string starts at
+   * a character start, so we need to validate at least
+   * that much. It doesn't assume any following bytes
+   * are valid.
+   */
+  if ((*context->current_text & 0xc0) == 0x80) /* not a char start */
+    {
+      set_error (context,
+                 error,
+                 G_MARKUP_ERROR_BAD_UTF8,
+                 _("Invalid UTF-8 encoded text"));
+      goto finished;
+    }
+
+  /* Initialize context->current_text_end, possibly adjusting
+   * current_text_len, and add any leftover char portion
+   */
+  find_current_text_end (context);
+
+  /* Validate UTF8 (must be done after we find the end, since
+   * we could have a trailing incomplete char)
+   */
+  if (!g_utf8_validate (context->current_text,
+			context->current_text_len,
+			&first_invalid))
+    {
+      gint newlines = 0;
+      const gchar *p;
+      p = context->current_text;
+      while (p != context->current_text_end)
+        {
+          if (*p == '\n')
+            ++newlines;
+          ++p;
+        }
+
+      context->line_number += newlines;
+
+      set_error (context,
+                 error,
+                 G_MARKUP_ERROR_BAD_UTF8,
+                 _("Invalid UTF-8 encoded text"));
+      goto finished;
+    }
+
+  while (context->iter != context->current_text_end)
+    {
+      switch (context->state)
+        {
+        case STATE_START:
+          /* Possible next state: AFTER_OPEN_ANGLE */
+
+          g_assert (context->tag_stack == NULL);
+
+          /* whitespace is ignored outside of any elements */
+          skip_spaces (context);
+
+          if (context->iter != context->current_text_end)
+            {
+              if (*context->iter == '<')
+                {
+                  /* Move after the open angle */
+                  advance_char (context);
+
+                  context->state = STATE_AFTER_OPEN_ANGLE;
+
+                  /* this could start a passthrough */
+                  context->start = context->iter;
+
+                  /* document is now non-empty */
+                  context->document_empty = FALSE;
+                }
+              else
+                {
+                  set_error (context,
+                             error,
+                             G_MARKUP_ERROR_PARSE,
+                             _("Document must begin with an element (e.g. <book>)"));
+                }
+            }
+          break;
+
+        case STATE_AFTER_OPEN_ANGLE:
+          /* Possible next states: INSIDE_OPEN_TAG_NAME,
+           *  AFTER_CLOSE_TAG_SLASH, INSIDE_PASSTHROUGH
+           */
+          if (*context->iter == '?' ||
+              *context->iter == '!')
+            {
+              /* include < in the passthrough */
+              const gchar *openangle = "<";
+              add_to_partial (context, openangle, openangle + 1);
+              context->start = context->iter;
+	      context->balance = 1;
+              context->state = STATE_INSIDE_PASSTHROUGH;
+            }
+          else if (*context->iter == '/')
+            {
+              /* move after it */
+              advance_char (context);
+
+              context->state = STATE_AFTER_CLOSE_TAG_SLASH;
+            }
+          else if (is_name_start_char (context->iter))
+            {
+              context->state = STATE_INSIDE_OPEN_TAG_NAME;
+
+              /* start of tag name */
+              context->start = context->iter;
+            }
+          else
+            {
+              gchar buf[8];
+
+              set_error (context,
+                         error,
+                         G_MARKUP_ERROR_PARSE,
+                         _("'%s' is not a valid character following "
+                           "a '<' character; it may not begin an "
+                           "element name"),
+                         utf8_str (context->iter, buf));
+            }
+          break;
+
+          /* The AFTER_CLOSE_ANGLE state is actually sort of
+           * broken, because it doesn't correspond to a range
+           * of characters in the input stream as the others do,
+           * and thus makes things harder to conceptualize
+           */
+        case STATE_AFTER_CLOSE_ANGLE:
+          /* Possible next states: INSIDE_TEXT, STATE_START */
+          if (context->tag_stack == NULL)
+            {
+              context->start = NULL;
+              context->state = STATE_START;
+            }
+          else
+            {
+              context->start = context->iter;
+              context->state = STATE_INSIDE_TEXT;
+            }
+          break;
+
+        case STATE_AFTER_ELISION_SLASH:
+          /* Possible next state: AFTER_CLOSE_ANGLE */
+
+          {
+            /* We need to pop the tag stack and call the end_element
+             * function, since this is the close tag
+             */
+            GError *tmp_error = NULL;
+          
+            g_assert (context->tag_stack != NULL);
+
+            tmp_error = NULL;
+            if (context->parser->end_element)
+              (* context->parser->end_element) (context,
+                                                context->tag_stack->data,
+                                                context->user_data,
+                                                &tmp_error);
+          
+            if (tmp_error)
+              {
+                mark_error (context, tmp_error);
+                g_propagate_error (error, tmp_error);
+              }          
+            else
+              {
+                if (*context->iter == '>')
+                  {
+                    /* move after the close angle */
+                    advance_char (context);
+                    context->state = STATE_AFTER_CLOSE_ANGLE;
+                  }
+                else
+                  {
+                    gchar buf[8];
+
+                    set_error (context,
+                               error,
+                               G_MARKUP_ERROR_PARSE,
+                               _("Odd character '%s', expected a '>' character "
+                                 "to end the start tag of element '%s'"),
+                               utf8_str (context->iter, buf),
+                               current_element (context));
+                  }
+              }
+
+            g_free (context->tag_stack->data);
+            context->tag_stack = g_slist_delete_link (context->tag_stack,
+                                                      context->tag_stack);
+          }
+          break;
+
+        case STATE_INSIDE_OPEN_TAG_NAME:
+          /* Possible next states: BETWEEN_ATTRIBUTES */
+
+          /* if there's a partial chunk then it's the first part of the
+           * tag name. If there's a context->start then it's the start
+           * of the tag name in current_text, the partial chunk goes
+           * before that start though.
+           */
+          advance_to_name_end (context);
+
+          if (context->iter == context->current_text_end)
+            {
+              /* The name hasn't necessarily ended. Merge with
+               * partial chunk, leave state unchanged.
+               */
+              add_to_partial (context, context->start, context->iter);
+            }
+          else
+            {
+              /* The name has ended. Combine it with the partial chunk
+               * if any; push it on the stack; enter next state.
+               */
+              add_to_partial (context, context->start, context->iter);
+              context->tag_stack =
+                g_slist_prepend (context->tag_stack,
+                                 g_string_free (context->partial_chunk,
+                                                FALSE));
+
+              context->partial_chunk = NULL;
+
+              context->state = STATE_BETWEEN_ATTRIBUTES;
+              context->start = NULL;
+            }
+          break;
+
+        case STATE_INSIDE_ATTRIBUTE_NAME:
+          /* Possible next states: AFTER_ATTRIBUTE_NAME */
+
+          advance_to_name_end (context);
+	  add_to_partial (context, context->start, context->iter);
+
+          /* read the full name, if we enter the equals sign state
+           * then add the attribute to the list (without the value),
+           * otherwise store a partial chunk to be prepended later.
+           */
+          if (context->iter != context->current_text_end)
+	    context->state = STATE_AFTER_ATTRIBUTE_NAME;
+	  break;
+
+	case STATE_AFTER_ATTRIBUTE_NAME:
+          /* Possible next states: AFTER_ATTRIBUTE_EQUALS_SIGN */
+
+	  skip_spaces (context);
+
+	  if (context->iter != context->current_text_end)
+	    {
+	      /* The name has ended. Combine it with the partial chunk
+	       * if any; push it on the stack; enter next state.
+	       */
+              add_attribute (context, g_string_free (context->partial_chunk, FALSE));
+	      
+              context->partial_chunk = NULL;
+              context->start = NULL;
+	      
+              if (*context->iter == '=')
+                {
+                  advance_char (context);
+                  context->state = STATE_AFTER_ATTRIBUTE_EQUALS_SIGN;
+                }
+              else
+                {
+                  gchar buf[8];
+
+                  set_error (context,
+                             error,
+                             G_MARKUP_ERROR_PARSE,
+                             _("Odd character '%s', expected a '=' after "
+                               "attribute name '%s' of element '%s'"),
+                             utf8_str (context->iter, buf),
+                             current_attribute (context),
+                             current_element (context));
+		  
+                }
+            }
+          break;
+
+        case STATE_BETWEEN_ATTRIBUTES:
+          /* Possible next states: AFTER_CLOSE_ANGLE,
+           * AFTER_ELISION_SLASH, INSIDE_ATTRIBUTE_NAME
+           */
+          skip_spaces (context);
+
+          if (context->iter != context->current_text_end)
+            {
+              if (*context->iter == '/')
+                {
+                  advance_char (context);
+                  context->state = STATE_AFTER_ELISION_SLASH;
+                }
+              else if (*context->iter == '>')
+                {
+
+                  advance_char (context);
+                  context->state = STATE_AFTER_CLOSE_ANGLE;
+                }
+              else if (is_name_start_char (context->iter))
+                {
+                  context->state = STATE_INSIDE_ATTRIBUTE_NAME;
+                  /* start of attribute name */
+                  context->start = context->iter;
+                }
+              else
+                {
+                  gchar buf[8];
+
+                  set_error (context,
+                             error,
+                             G_MARKUP_ERROR_PARSE,
+                             _("Odd character '%s', expected a '>' or '/' "
+                               "character to end the start tag of "
+                               "element '%s', or optionally an attribute; "
+                               "perhaps you used an invalid character in "
+                               "an attribute name"),
+                             utf8_str (context->iter, buf),
+                             current_element (context));
+                }
+
+              /* If we're done with attributes, invoke
+               * the start_element callback
+               */
+              if (context->state == STATE_AFTER_ELISION_SLASH ||
+                  context->state == STATE_AFTER_CLOSE_ANGLE)
+                {
+                  const gchar *start_name;
+		  /* Ugly, but the current code expects an empty array instead of NULL */
+		  const gchar *empty = NULL;
+                  const gchar **attr_names =  &empty;
+                  const gchar **attr_values = &empty;
+                  GError *tmp_error;
+
+                  /* Call user callback for element start */
+                  start_name = current_element (context);
+
+		  if (context->cur_attr >= 0)
+		    {
+		      attr_names = (const gchar**)context->attr_names;
+		      attr_values = (const gchar**)context->attr_values;
+		    }
+
+                  tmp_error = NULL;
+                  if (context->parser->start_element)
+                    (* context->parser->start_element) (context,
+                                                        start_name,
+                                                        (const gchar **)attr_names,
+                                                        (const gchar **)attr_values,
+                                                        context->user_data,
+                                                        &tmp_error);
+
+                  /* Go ahead and free the attributes. */
+		  for (; context->cur_attr >= 0; context->cur_attr--)
+		    {
+		      int pos = context->cur_attr;
+		      g_free (context->attr_names[pos]);
+		      g_free (context->attr_values[pos]);
+		      context->attr_names[pos] = context->attr_values[pos] = NULL;
+		    }
+                  g_assert (context->cur_attr == -1);
+                  g_assert (context->attr_names == NULL ||
+                            context->attr_names[0] == NULL);
+                  g_assert (context->attr_values == NULL ||
+                            context->attr_values[0] == NULL);
+                  
+                  if (tmp_error != NULL)
+                    {
+                      mark_error (context, tmp_error);
+                      g_propagate_error (error, tmp_error);
+                    }
+                }
+            }
+          break;
+
+        case STATE_AFTER_ATTRIBUTE_EQUALS_SIGN:
+          /* Possible next state: INSIDE_ATTRIBUTE_VALUE_[SQ/DQ] */
+
+	  skip_spaces (context);
+
+	  if (context->iter != context->current_text_end)
+	    {
+	      if (*context->iter == '"')
+		{
+		  advance_char (context);
+		  context->state = STATE_INSIDE_ATTRIBUTE_VALUE_DQ;
+		  context->start = context->iter;
+		}
+	      else if (*context->iter == '\'')
+		{
+		  advance_char (context);
+		  context->state = STATE_INSIDE_ATTRIBUTE_VALUE_SQ;
+		  context->start = context->iter;
+		}
+	      else
+		{
+		  gchar buf[8];
+		  
+		  set_error (context,
+			     error,
+			     G_MARKUP_ERROR_PARSE,
+			     _("Odd character '%s', expected an open quote mark "
+			       "after the equals sign when giving value for "
+			       "attribute '%s' of element '%s'"),
+			     utf8_str (context->iter, buf),
+			     current_attribute (context),
+			     current_element (context));
+		}
+	    }
+          break;
+
+        case STATE_INSIDE_ATTRIBUTE_VALUE_SQ:
+        case STATE_INSIDE_ATTRIBUTE_VALUE_DQ:
+          /* Possible next states: BETWEEN_ATTRIBUTES */
+	  {
+	    gchar delim;
+
+	    if (context->state == STATE_INSIDE_ATTRIBUTE_VALUE_SQ) 
+	      {
+		delim = '\'';
+	      }
+	    else 
+	      {
+		delim = '"';
+	      }
+
+	    do
+	      {
+		if (*context->iter == delim)
+		  break;
+	      }
+	    while (advance_char (context));
+	  }
+          if (context->iter == context->current_text_end)
+            {
+              /* The value hasn't necessarily ended. Merge with
+               * partial chunk, leave state unchanged.
+               */
+              add_to_partial (context, context->start, context->iter);
+            }
+          else
+            {
+              /* The value has ended at the quote mark. Combine it
+               * with the partial chunk if any; set it for the current
+               * attribute.
+               */
+              GString *unescaped;
+              
+              add_to_partial (context, context->start, context->iter);
+
+              g_assert (context->cur_attr >= 0);
+              
+              if (unescape_text (context,
+                                 context->partial_chunk->str,
+                                 context->partial_chunk->str +
+                                 context->partial_chunk->len,
+                                 &unescaped,
+                                 error))
+                {
+                  /* success, advance past quote and set state. */
+                  context->attr_values[context->cur_attr] = g_string_free (unescaped, FALSE);
+                  advance_char (context);
+                  context->state = STATE_BETWEEN_ATTRIBUTES;
+                  context->start = NULL;
+                }
+              
+              truncate_partial (context);
+            }
+          break;
+
+        case STATE_INSIDE_TEXT:
+          /* Possible next states: AFTER_OPEN_ANGLE */
+          do
+            {
+              if (*context->iter == '<')
+                break;
+            }
+          while (advance_char (context));
+
+          /* The text hasn't necessarily ended. Merge with
+           * partial chunk, leave state unchanged.
+           */
+
+          add_to_partial (context, context->start, context->iter);
+
+          if (context->iter != context->current_text_end)
+            {
+              GString *unescaped = NULL;
+
+              /* The text has ended at the open angle. Call the text
+               * callback.
+               */
+              
+              if (unescape_text (context,
+                                 context->partial_chunk->str,
+                                 context->partial_chunk->str +
+                                 context->partial_chunk->len,
+                                 &unescaped,
+                                 error))
+                {
+                  GError *tmp_error = NULL;
+
+                  if (context->parser->text)
+                    (*context->parser->text) (context,
+                                              unescaped->str,
+                                              unescaped->len,
+                                              context->user_data,
+                                              &tmp_error);
+                  
+                  g_string_free (unescaped, TRUE);
+
+                  if (tmp_error == NULL)
+                    {
+                      /* advance past open angle and set state. */
+                      advance_char (context);
+                      context->state = STATE_AFTER_OPEN_ANGLE;
+                      /* could begin a passthrough */
+                      context->start = context->iter;
+                    }
+                  else
+                    {
+                      mark_error (context, tmp_error);
+                      g_propagate_error (error, tmp_error);
+                    }
+                }
+
+              truncate_partial (context);
+            }
+          break;
+
+        case STATE_AFTER_CLOSE_TAG_SLASH:
+          /* Possible next state: INSIDE_CLOSE_TAG_NAME */
+          if (is_name_start_char (context->iter))
+            {
+              context->state = STATE_INSIDE_CLOSE_TAG_NAME;
+
+              /* start of tag name */
+              context->start = context->iter;
+            }
+          else
+            {
+              gchar buf[8];
+
+              set_error (context,
+                         error,
+                         G_MARKUP_ERROR_PARSE,
+                         _("'%s' is not a valid character following "
+                           "the characters '</'; '%s' may not begin an "
+                           "element name"),
+                         utf8_str (context->iter, buf),
+                         utf8_str (context->iter, buf));
+            }
+          break;
+
+        case STATE_INSIDE_CLOSE_TAG_NAME:
+          /* Possible next state: AFTER_CLOSE_TAG_NAME */
+          advance_to_name_end (context);
+	  add_to_partial (context, context->start, context->iter);
+
+          if (context->iter != context->current_text_end)
+	    context->state = STATE_AFTER_CLOSE_TAG_NAME;
+	  break;
+
+	case STATE_AFTER_CLOSE_TAG_NAME:
+          /* Possible next state: AFTER_CLOSE_TAG_SLASH */
+
+	  skip_spaces (context);
+	  
+	  if (context->iter != context->current_text_end)
+	    {
+	      gchar *close_name;
+
+	      /* The name has ended. Combine it with the partial chunk
+	       * if any; check that it matches stack top and pop
+	       * stack; invoke proper callback; enter next state.
+	       */
+	      close_name = g_string_free (context->partial_chunk, FALSE);
+	      context->partial_chunk = NULL;
+              
+	      if (*context->iter != '>')
+		{
+		  gchar buf[8];
+
+		  set_error (context,
+			     error,
+			     G_MARKUP_ERROR_PARSE,
+			     _("'%s' is not a valid character following "
+			       "the close element name '%s'; the allowed "
+			       "character is '>'"),
+			     utf8_str (context->iter, buf),
+			     close_name);
+		}
+	      else if (context->tag_stack == NULL)
+		{
+		  set_error (context,
+			     error,
+			     G_MARKUP_ERROR_PARSE,
+			     _("Element '%s' was closed, no element "
+			       "is currently open"),
+			     close_name);
+		}
+	      else if (strcmp (close_name, current_element (context)) != 0)
+		{
+		  set_error (context,
+			     error,
+			     G_MARKUP_ERROR_PARSE,
+			     _("Element '%s' was closed, but the currently "
+			       "open element is '%s'"),
+			     close_name,
+			     current_element (context));
+		}
+	      else
+		{
+		  GError *tmp_error;
+		  advance_char (context);
+		  context->state = STATE_AFTER_CLOSE_ANGLE;
+		  context->start = NULL;
+		  
+		  /* call the end_element callback */
+		  tmp_error = NULL;
+		  if (context->parser->end_element)
+		    (* context->parser->end_element) (context,
+						      close_name,
+						      context->user_data,
+						      &tmp_error);
+		  
+		  
+		  /* Pop the tag stack */
+		  g_free (context->tag_stack->data);
+		  context->tag_stack = g_slist_delete_link (context->tag_stack,
+							    context->tag_stack);
+		  
+		  if (tmp_error)
+                    {
+                      mark_error (context, tmp_error);
+                      g_propagate_error (error, tmp_error);
+                    }
+                }
+	      
+              g_free (close_name);
+            }
+          break;
+	  
+        case STATE_INSIDE_PASSTHROUGH:
+          /* Possible next state: AFTER_CLOSE_ANGLE */
+          do
+            {
+	      if (*context->iter == '<') 
+		context->balance++;
+              if (*context->iter == '>') 
+		{
+		  context->balance--;
+		  add_to_partial (context, context->start, context->iter);
+		  context->start = context->iter;
+		  if ((g_str_has_prefix (context->partial_chunk->str, "<?")
+		       && g_str_has_suffix (context->partial_chunk->str, "?")) ||
+		      (g_str_has_prefix (context->partial_chunk->str, "<!--")
+		       && g_str_has_suffix (context->partial_chunk->str, "--")) ||
+		      (g_str_has_prefix (context->partial_chunk->str, "<![CDATA[") 
+		       && g_str_has_suffix (context->partial_chunk->str, "]]")) ||
+		      (g_str_has_prefix (context->partial_chunk->str, "<!DOCTYPE")
+		       && context->balance == 0)) 
+		    break;
+		}
+            }
+          while (advance_char (context));
+
+          if (context->iter == context->current_text_end)
+            {
+              /* The passthrough hasn't necessarily ended. Merge with
+               * partial chunk, leave state unchanged.
+               */
+              add_to_partial (context, context->start, context->iter);
+            }
+          else
+            {
+              /* The passthrough has ended at the close angle. Combine
+               * it with the partial chunk if any. Call the passthrough
+               * callback. Note that the open/close angles are
+               * included in the text of the passthrough.
+               */
+              GError *tmp_error = NULL;
+
+              advance_char (context); /* advance past close angle */
+              add_to_partial (context, context->start, context->iter);
+
+              if (context->parser->passthrough)
+                (*context->parser->passthrough) (context,
+                                                 context->partial_chunk->str,
+                                                 context->partial_chunk->len,
+                                                 context->user_data,
+                                                 &tmp_error);
+                  
+              truncate_partial (context);
+
+              if (tmp_error == NULL)
+                {
+                  context->state = STATE_AFTER_CLOSE_ANGLE;
+                  context->start = context->iter; /* could begin text */
+                }
+              else
+                {
+                  mark_error (context, tmp_error);
+                  g_propagate_error (error, tmp_error);
+                }
+            }
+          break;
+
+        case STATE_ERROR:
+          goto finished;
+          break;
+
+        default:
+          g_assert_not_reached ();
+          break;
+        }
+    }
+
+ finished:
+  context->parsing = FALSE;
+
+  return context->state != STATE_ERROR;
+}
+
+/**
+ * g_markup_parse_context_end_parse:
+ * @context: a #GMarkupParseContext
+ * @error: return location for a #GError
+ * 
+ * Signals to the #GMarkupParseContext that all data has been
+ * fed into the parse context with g_markup_parse_context_parse().
+ * This function reports an error if the document isn't complete,
+ * for example if elements are still open.
+ * 
+ * Return value: %TRUE on success, %FALSE if an error was set
+ **/
+EXPORT_C gboolean
+g_markup_parse_context_end_parse (GMarkupParseContext *context,
+                                  GError             **error)
+{
+  g_return_val_if_fail (context != NULL, FALSE);
+  g_return_val_if_fail (!context->parsing, FALSE);
+  g_return_val_if_fail (context->state != STATE_ERROR, FALSE);
+
+  if (context->partial_chunk != NULL)
+    {
+      g_string_free (context->partial_chunk, TRUE);
+      context->partial_chunk = NULL;
+    }
+
+  if (context->document_empty)
+    {
+      set_error (context, error, G_MARKUP_ERROR_EMPTY,
+                 _("Document was empty or contained only whitespace"));
+      return FALSE;
+    }
+  
+  context->parsing = TRUE;
+  
+  switch (context->state)
+    {
+    case STATE_START:
+      /* Nothing to do */
+      break;
+
+    case STATE_AFTER_OPEN_ANGLE:
+      set_error (context, error, G_MARKUP_ERROR_PARSE,
+                 _("Document ended unexpectedly just after an open angle bracket '<'"));
+      break;
+
+    case STATE_AFTER_CLOSE_ANGLE:
+      if (context->tag_stack != NULL)
+        {
+          /* Error message the same as for INSIDE_TEXT */
+          set_error (context, error, G_MARKUP_ERROR_PARSE,
+                     _("Document ended unexpectedly with elements still open - "
+                       "'%s' was the last element opened"),
+                     current_element (context));
+        }
+      break;
+      
+    case STATE_AFTER_ELISION_SLASH:
+      set_error (context, error, G_MARKUP_ERROR_PARSE,
+                 _("Document ended unexpectedly, expected to see a close angle "
+                   "bracket ending the tag <%s/>"), current_element (context));
+      break;
+
+    case STATE_INSIDE_OPEN_TAG_NAME:
+      set_error (context, error, G_MARKUP_ERROR_PARSE,
+                 _("Document ended unexpectedly inside an element name"));
+      break;
+
+    case STATE_INSIDE_ATTRIBUTE_NAME:
+      set_error (context, error, G_MARKUP_ERROR_PARSE,
+                 _("Document ended unexpectedly inside an attribute name"));
+      break;
+
+    case STATE_BETWEEN_ATTRIBUTES:
+      set_error (context, error, G_MARKUP_ERROR_PARSE,
+                 _("Document ended unexpectedly inside an element-opening "
+                   "tag."));
+      break;
+
+    case STATE_AFTER_ATTRIBUTE_EQUALS_SIGN:
+      set_error (context, error, G_MARKUP_ERROR_PARSE,
+                 _("Document ended unexpectedly after the equals sign "
+                   "following an attribute name; no attribute value"));
+      break;
+
+    case STATE_INSIDE_ATTRIBUTE_VALUE_SQ:
+    case STATE_INSIDE_ATTRIBUTE_VALUE_DQ:
+      set_error (context, error, G_MARKUP_ERROR_PARSE,
+                 _("Document ended unexpectedly while inside an attribute "
+                   "value"));
+      break;
+
+    case STATE_INSIDE_TEXT:
+      g_assert (context->tag_stack != NULL);
+      set_error (context, error, G_MARKUP_ERROR_PARSE,
+                 _("Document ended unexpectedly with elements still open - "
+                   "'%s' was the last element opened"),
+                 current_element (context));
+      break;
+
+    case STATE_AFTER_CLOSE_TAG_SLASH:
+    case STATE_INSIDE_CLOSE_TAG_NAME:
+      set_error (context, error, G_MARKUP_ERROR_PARSE,
+                 _("Document ended unexpectedly inside the close tag for "
+                   "element '%s'"), current_element (context));
+      break;
+
+    case STATE_INSIDE_PASSTHROUGH:
+      set_error (context, error, G_MARKUP_ERROR_PARSE,
+                 _("Document ended unexpectedly inside a comment or "
+                   "processing instruction"));
+      break;
+
+    case STATE_ERROR:
+    default:
+      g_assert_not_reached ();
+      break;
+    }
+
+  context->parsing = FALSE;
+
+  return context->state != STATE_ERROR;
+}
+
+/**
+ * g_markup_parse_context_get_element:
+ * @context: a #GMarkupParseContext
+ * @returns: the name of the currently open element, or %NULL
+ *
+ * Retrieves the name of the currently open element.
+ *
+ * Since: 2.2
+ **/
+EXPORT_C G_CONST_RETURN gchar *
+g_markup_parse_context_get_element (GMarkupParseContext *context)
+{
+  g_return_val_if_fail (context != NULL, NULL);
+
+  if (context->tag_stack == NULL) 
+    return NULL;
+  else
+    return current_element (context);
+} 
+
+/**
+ * g_markup_parse_context_get_position:
+ * @context: a #GMarkupParseContext
+ * @line_number: return location for a line number, or %NULL
+ * @char_number: return location for a char-on-line number, or %NULL
+ *
+ * Retrieves the current line number and the number of the character on
+ * that line. Intended for use in error messages; there are no strict
+ * semantics for what constitutes the "current" line number other than
+ * "the best number we could come up with for error messages."
+ * 
+ **/
+EXPORT_C void
+g_markup_parse_context_get_position (GMarkupParseContext *context,
+                                     gint                *line_number,
+                                     gint                *char_number)
+{
+  g_return_if_fail (context != NULL);
+
+  if (line_number)
+    *line_number = context->line_number;
+
+  if (char_number)
+    *char_number = context->char_number;
+}
+
+static void
+append_escaped_text (GString     *str,
+                     const gchar *text,
+                     gssize       length)    
+{
+  const gchar *p;
+  const gchar *end;
+
+  p = text;
+  end = text + length;
+
+  while (p != end)
+    {
+      const gchar *next;
+      next = g_utf8_next_char (p);
+
+      switch (*p)
+        {
+        case '&':
+          g_string_append (str, "&amp;");
+          break;
+
+        case '<':
+          g_string_append (str, "&lt;");
+          break;
+
+        case '>':
+          g_string_append (str, "&gt;");
+          break;
+
+        case '\'':
+          g_string_append (str, "&apos;");
+          break;
+
+        case '"':
+          g_string_append (str, "&quot;");
+          break;
+
+        default:
+          g_string_append_len (str, p, next - p);
+          break;
+        }
+
+      p = next;
+    }
+}
+
+/**
+ * g_markup_escape_text:
+ * @text: some valid UTF-8 text
+ * @length: length of @text in bytes, or -1 if the text is nul-terminated
+ * 
+ * Escapes text so that the markup parser will parse it verbatim.
+ * Less than, greater than, ampersand, etc. are replaced with the
+ * corresponding entities. This function would typically be used
+ * when writing out a file to be parsed with the markup parser.
+ * 
+ * Note that this function doesn't protect whitespace and line endings
+ * from being processed according to the XML rules for normalization
+ * of line endings and attribute values.
+ * 
+ * Return value: a newly allocated string with the escaped text
+ **/
+EXPORT_C gchar*
+g_markup_escape_text (const gchar *text,
+                      gssize       length)  
+{
+  GString *str;
+
+  g_return_val_if_fail (text != NULL, NULL);
+
+  if (length < 0)
+    length = strlen (text);
+
+  /* prealloc at least as long as original text */
+  str = g_string_sized_new (length);
+  append_escaped_text (str, text, length);
+
+  return g_string_free (str, FALSE);
+}
+
+/**
+ * find_conversion:
+ * @format: a printf-style format string
+ * @after: location to store a pointer to the character after
+ *   the returned conversion. On a %NULL return, returns the
+ *   pointer to the trailing NUL in the string
+ * 
+ * Find the next conversion in a printf-style format string.
+ * Partially based on code from printf-parser.c,
+ * Copyright (C) 1999-2000, 2002-2003 Free Software Foundation, Inc.
+ * 
+ * Return value: pointer to the next conversion in @format,
+ *  or %NULL, if none.
+ **/
+static const char *
+find_conversion (const char  *format,
+		 const char **after)
+{
+  const char *start = format;
+  const char *cp;
+  
+  while (*start != '\0' && *start != '%')
+    start++;
+
+  if (*start == '\0')
+    {
+      *after = start;
+      return NULL;
+    }
+
+  cp = start + 1;
+
+  if (*cp == '\0')
+    {
+      *after = cp;
+      return NULL;
+    }
+  
+  /* Test for positional argument.  */
+  if (*cp >= '0' && *cp <= '9')
+    {
+      const char *np;
+      
+      for (np = cp; *np >= '0' && *np <= '9'; np++)
+	;
+      if (*np == '$')
+	cp = np + 1;
+    }
+
+  /* Skip the flags.  */
+  for (;;)
+    {
+      if (*cp == '\'' ||
+	  *cp == '-' ||
+	  *cp == '+' ||
+	  *cp == ' ' ||
+	  *cp == '#' ||
+	  *cp == '0')
+	cp++;
+      else
+	break;
+    }
+
+  /* Skip the field width.  */
+  if (*cp == '*')
+    {
+      cp++;
+
+      /* Test for positional argument.  */
+      if (*cp >= '0' && *cp <= '9')
+	{
+	  const char *np;
+
+	  for (np = cp; *np >= '0' && *np <= '9'; np++)
+	    ;
+	  if (*np == '$')
+	    cp = np + 1;
+	}
+    }
+  else
+    {
+      for (; *cp >= '0' && *cp <= '9'; cp++)
+	;
+    }
+
+  /* Skip the precision.  */
+  if (*cp == '.')
+    {
+      cp++;
+      if (*cp == '*')
+	{
+	  /* Test for positional argument.  */
+	  if (*cp >= '0' && *cp <= '9')
+	    {
+	      const char *np;
+
+	      for (np = cp; *np >= '0' && *np <= '9'; np++)
+		;
+	      if (*np == '$')
+		cp = np + 1;
+	    }
+	}
+      else
+	{
+	  for (; *cp >= '0' && *cp <= '9'; cp++)
+	    ;
+	}
+    }
+
+  /* Skip argument type/size specifiers.  */
+  while (*cp == 'h' ||
+	 *cp == 'L' ||
+	 *cp == 'l' ||
+	 *cp == 'j' ||
+	 *cp == 'z' ||
+	 *cp == 'Z' ||
+	 *cp == 't')
+    cp++;
+	  
+  /* Skip the conversion character.  */
+  cp++;
+
+  *after = cp;
+  return start;
+}
+
+/**
+ * g_markup_vprintf_escaped:
+ * @format: printf() style format string
+ * @args: variable argument list, similar to vprintf()
+ * 
+ * Formats the data in @args according to @format, escaping
+ * all string and character arguments in the fashion
+ * of g_markup_escape_text(). See g_markup_printf_escaped().
+ * 
+ * Return value: newly allocated result from formatting
+ *  operation. Free with g_free().
+ *
+ * Since: 2.4
+ **/
+EXPORT_C char *
+g_markup_vprintf_escaped (const char *format,
+			  va_list     args)
+{
+  GString *format1;
+  GString *format2;
+  GString *result = NULL;
+  gchar *output1 = NULL;
+  gchar *output2 = NULL;
+  const char *p, *op1, *op2;
+  va_list args2;
+
+  /* The technique here, is that we make two format strings that
+   * have the identical conversions in the identical order to the
+   * original strings, but differ in the text in-between. We
+   * then use the normal g_strdup_vprintf() to format the arguments
+   * with the two new format strings. By comparing the results,
+   * we can figure out what segments of the output come from
+   * the the original format string, and what from the arguments,
+   * and thus know what portions of the string to escape.
+   *
+   * For instance, for:
+   *
+   *  g_markup_printf_escaped ("%s ate %d apples", "Susan & Fred", 5);
+   *
+   * We form the two format strings "%sX%dX" and %sY%sY". The results
+   * of formatting with those two strings are
+   *
+   * "%sX%dX" => "Susan & FredX5X"
+   * "%sY%dY" => "Susan & FredY5Y"
+   *
+   * To find the span of the first argument, we find the first position
+   * where the two arguments differ, which tells us that the first
+   * argument formatted to "Susan & Fred". We then escape that
+   * to "Susan &amp; Fred" and join up with the intermediate portions
+   * of the format string and the second argument to get
+   * "Susan &amp; Fred ate 5 apples".
+   */
+
+  /* Create the two modified format strings
+   */
+  format1 = g_string_new (NULL);
+  format2 = g_string_new (NULL);
+  p = format;
+  while (TRUE)
+    {
+      const char *after;
+      const char *conv = find_conversion (p, &after);
+      if (!conv)
+	break;
+
+      g_string_append_len (format1, conv, after - conv);
+      g_string_append_c (format1, 'X');
+      g_string_append_len (format2, conv, after - conv);
+      g_string_append_c (format2, 'Y');
+
+      p = after;
+    }
+
+  /* Use them to format the arguments
+   */
+  G_VA_COPY (args2, args);
+  
+  output1 = g_strdup_vprintf (format1->str, args);
+  va_end (args);
+  if (!output1)
+    goto cleanup;
+  
+  output2 = g_strdup_vprintf (format2->str, args2);
+  va_end (args2);
+  if (!output2)
+    goto cleanup;
+
+  result = g_string_new (NULL);
+
+  /* Iterate through the original format string again,
+   * copying the non-conversion portions and the escaped
+   * converted arguments to the output string.
+   */
+  op1 = output1;
+  op2 = output2;
+  p = format;
+  while (TRUE)
+    {
+      const char *after;
+      const char *output_start;
+      const char *conv = find_conversion (p, &after);
+      char *escaped;
+      
+      if (!conv)	/* The end, after points to the trailing \0 */
+	{
+	  g_string_append_len (result, p, after - p);
+	  break;
+	}
+
+      g_string_append_len (result, p, conv - p);
+      output_start = op1;
+      while (*op1 == *op2)
+	{
+	  op1++;
+	  op2++;
+	}
+      
+      escaped = g_markup_escape_text (output_start, op1 - output_start);
+      g_string_append (result, escaped);
+      g_free (escaped);
+      
+      p = after;
+      op1++;
+      op2++;
+    }
+
+ cleanup:
+  g_string_free (format1, TRUE);
+  g_string_free (format2, TRUE);
+  g_free (output1);
+  g_free (output2);
+
+  if (result)
+    return g_string_free (result, FALSE);
+  else
+    return NULL;
+}
+
+/**
+ * g_markup_printf_escaped:
+ * @format: printf() style format string
+ * @Varargs: the arguments to insert in the format string
+ * 
+ * Formats arguments according to @format, escaping
+ * all string and character arguments in the fashion
+ * of g_markup_escape_text(). This is useful when you
+ * want to insert literal strings into XML-style markup
+ * output, without having to worry that the strings
+ * might themselves contain markup.
+ *
+ * <informalexample><programlisting>
+ * const char *store = "Fortnum &amp; Mason";
+ * const char *item = "Tea";
+ * char *output;
+ * &nbsp;
+ * output = g_markup_printf_escaped ("&lt;purchase&gt;"
+ *                                   "&lt;store&gt;&percnt;s&lt;/store&gt;"
+ *                                   "&lt;item&gt;&percnt;s&lt;/item&gt;"
+ *                                   "&lt;/purchase&gt;",
+ *                                   store, item);
+ * </programlisting></informalexample>
+ * 
+ * Return value: newly allocated result from formatting
+ *  operation. Free with g_free().
+ *
+ * Since: 2.4
+ **/
+EXPORT_C char *
+g_markup_printf_escaped (const char *format, ...)
+{
+  char *result;
+  va_list args;
+  
+  va_start (args, format);
+  result = g_markup_vprintf_escaped (format, args);
+  va_end (args);
+
+  return result;
+}
+
+#define __G_MARKUP_C__
+#include "galiasdef.c"