Add glib-2.20.5 with patches to make GMarkup quicker. Should have quite some good affect on login speed

7 files changed, 1727 insertions, 0 deletions

diff --git a/dev-libs/glib/files/GMarkup-fix-optimization-regression.patch b/dev-libs/glib/files/GMarkup-fix-optimization-regression.patch
new file mode 100644
index 0000000..2f5b7b2
--- /dev/null
+++ b/dev-libs/glib/files/GMarkup-fix-optimization-regression.patch
@@ -0,0 +1,108 @@
+From 059ec81c9e88ee5ec67aafd135714754ea5b9552 Mon Sep 17 00:00:00 2001
+From: Michael Meeks <michael.meeks@novell.com>
+Date: Tue, 9 Jun 2009 11:31:42 +0100
+Subject: [PATCH] move start_element emission out into a new (inlined) function, so
+ the alloca'd memory is released on return, rather than slowly blowing
+ the stack.
+
+---
+ glib/gmarkup.c |   76 +++++++++++++++++++++++++++++++-------------------------
+ 1 files changed, 42 insertions(+), 34 deletions(-)
+
+diff --git a/glib/gmarkup.c b/glib/gmarkup.c
+index 35118ad..bb8165b 100644
+--- a/glib/gmarkup.c
++++ b/glib/gmarkup.c
+@@ -891,6 +891,47 @@ clear_attributes (GMarkupParseContext *context)
+   g_assert (context->attr_values == NULL ||
+ 	    context->attr_values[0] == NULL);
+ }
++
++/* This has to be a separate function to ensure the alloca's
++   are unwound on exit - otherwise we grow & blow the stack
++   with large documents */
++static inline void
++emit_start_element (GMarkupParseContext *context, GError **error)
++{
++  int i;
++  const gchar *start_name;
++  const gchar **attr_names;
++  const gchar **attr_values;
++  GError *tmp_error;
++  
++  attr_names = g_newa (const gchar *, context->cur_attr + 2);
++  attr_values = g_newa (const gchar *, context->cur_attr + 2);
++  for (i = 0; i < context->cur_attr + 1; i++)
++    {
++      attr_names[i] = context->attr_names[i]->str;
++      attr_values[i] = context->attr_values[i]->str;
++    }
++  attr_names[i] = NULL;
++  attr_values[i] = NULL;
++  
++  /* Call user callback for element start */
++  tmp_error = NULL;
++  start_name = current_element (context);
++  
++  if (context->parser->start_element &&
++      name_validate (context, start_name, error))
++    (* context->parser->start_element) (context,
++					start_name,
++					(const gchar **)attr_names,
++					(const gchar **)attr_values,
++					context->user_data,
++					&tmp_error);
++  clear_attributes (context);
++  
++  if (tmp_error != NULL)
++    propagate_error (context, error, tmp_error);
++}
++
+ /**
+  * g_markup_parse_context_parse:
+  * @context: a #GMarkupParseContext
+@@ -1217,40 +1258,7 @@ g_markup_parse_context_parse (GMarkupParseContext *context,
+                */
+               if (context->state == STATE_AFTER_ELISION_SLASH ||
+                   context->state == STATE_AFTER_CLOSE_ANGLE)
+-                {
+-		  int i;
+-		  const gchar *start_name;
+-                  const gchar **attr_names;
+-                  const gchar **attr_values;
+-                  GError *tmp_error;
+-
+-		  attr_names = g_newa (const gchar *, context->cur_attr + 2);
+-		  attr_values = g_newa (const gchar *, context->cur_attr + 2);
+-		  for (i = 0; i < context->cur_attr + 1; i++)
+-		    {
+-		      attr_names[i] = context->attr_names[i]->str;
+-		      attr_values[i] = context->attr_values[i]->str;
+-		    }
+-		  attr_names[i] = NULL;
+-		  attr_values[i] = NULL;
+-
+-                  /* Call user callback for element start */
+-                  tmp_error = NULL;
+-		  start_name = current_element (context);
+-
+-                  if (context->parser->start_element &&
+-		      name_validate (context, start_name, error))
+-                    (* context->parser->start_element) (context,
+-							start_name,
+-                                                        (const gchar **)attr_names,
+-                                                        (const gchar **)attr_values,
+-                                                        context->user_data,
+-                                                        &tmp_error);
+-		  clear_attributes (context);
+-                  
+-                  if (tmp_error != NULL)
+-                    propagate_error (context, error, tmp_error);
+-                }
++		emit_start_element (context, error);
+             }
+           break;
+ 
+-- 
+1.6.1.3
+
diff --git a/dev-libs/glib/files/GMarkup-various-optimizations.patch b/dev-libs/glib/files/GMarkup-various-optimizations.patch
new file mode 100644
index 0000000..06ad016
--- /dev/null
+++ b/dev-libs/glib/files/GMarkup-various-optimizations.patch
@@ -0,0 +1,1527 @@
+From 83699774fa669abfbc5c5c3dc9265308246bd4f6 Mon Sep 17 00:00:00 2001
+From: Michael Meeks <michael.meeks@novell.com>
+Date: Fri, 1 May 2009 15:23:23 +0100
+Subject: [PATCH] Patch originally committed only to the ChangeLog & tests ...
+MIME-Version: 1.0
+Content-Type: text/plain; charset=utf-8
+Content-Transfer-Encoding: 8bit
+
+        Bug 572508 – gmarkup speedup ...
+
+        * glib/gmarkup.c: Various optimizations: do less allocations by
+        keeping a pool of GStrings, do in-place unescaping, avoid redundant
+        utf-8 validation.
+---
+ glib/gmarkup.c | 1129 +++++++++++++++++++++++---------------------------------
+ 1 files changed, 455 insertions(+), 674 deletions(-)
+
+diff --git a/glib/gmarkup.c b/glib/gmarkup.c
+index b1f4f46..35118ad 100644
+--- a/glib/gmarkup.c
++++ b/glib/gmarkup.c
+@@ -82,11 +82,15 @@ struct _GMarkupParseContext
+    * the callback for it.
+    */
+   GString *partial_chunk;
++  GSList *spare_chunks;
+ 
+   GMarkupParseState state;
+   GSList *tag_stack;
+-  gchar **attr_names;
+-  gchar **attr_values;
++  GSList *tag_stack_gstr;
++  GSList *spare_list_nodes;
++
++  GString **attr_names;
++  GString **attr_values;
+   gint cur_attr;
+   gint alloc_attrs;
+ 
+@@ -94,8 +98,6 @@ struct _GMarkupParseContext
+   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;
+ 
+@@ -112,6 +114,39 @@ struct _GMarkupParseContext
+   gpointer held_user_data;
+ };
+ 
++/*
++ * Helpers to reduce our allocation overhead, we have
++ * a well defined allocation lifecycle.
++ */
++static GSList *
++get_list_node (GMarkupParseContext *context, gpointer data)
++{
++  GSList *node;
++  if (context->spare_list_nodes != NULL)
++    {
++      node = context->spare_list_nodes;
++      context->spare_list_nodes = g_slist_remove_link (context->spare_list_nodes, node);
++    }
++  else
++    node = g_slist_alloc();
++  node->data = data;
++  return node;
++}
++
++static void
++free_list_node (GMarkupParseContext *context, GSList *node)
++{
++  node->data = NULL;
++  context->spare_list_nodes = g_slist_concat (node, context->spare_list_nodes);
++}
++
++static inline void
++string_blank (GString *string)
++{
++  string->str[0] = '\0';
++  string->len = 0;
++}
++
+ /**
+  * g_markup_parse_context_new:
+  * @parser: a #GMarkupParser
+@@ -148,9 +183,12 @@ g_markup_parse_context_new (const GMarkupParser *parser,
+   context->char_number = 1;
+ 
+   context->partial_chunk = NULL;
++  context->spare_chunks = NULL;
++  context->spare_list_nodes = NULL;
+ 
+   context->state = STATE_START;
+   context->tag_stack = NULL;
++  context->tag_stack_gstr = NULL;
+   context->attr_names = NULL;
+   context->attr_values = NULL;
+   context->cur_attr = -1;
+@@ -159,7 +197,6 @@ g_markup_parse_context_new (const GMarkupParser *parser,
+   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;
+@@ -179,6 +216,14 @@ g_markup_parse_context_new (const GMarkupParser *parser,
+   return context;
+ }
+ 
++static void
++string_full_free (gpointer ptr, gpointer user_data)
++{
++  g_string_free (ptr, TRUE);
++}
++
++static void clear_attributes (GMarkupParseContext *context);
++
+ /**
+  * g_markup_parse_context_free:
+  * @context: a #GMarkupParseContext
+@@ -198,18 +243,21 @@ g_markup_parse_context_free (GMarkupParseContext *context)
+   if (context->dnotify)
+     (* context->dnotify) (context->user_data);
+ 
+-  g_strfreev (context->attr_names);
+-  g_strfreev (context->attr_values);
++  clear_attributes (context);
++  g_free (context->attr_names);
++  g_free (context->attr_values);
+ 
+-  g_slist_foreach (context->tag_stack, (GFunc)g_free, NULL);
++  g_slist_foreach (context->tag_stack_gstr, string_full_free, NULL);
++  g_slist_free (context->tag_stack_gstr);
+   g_slist_free (context->tag_stack);
+ 
++  g_slist_foreach (context->spare_chunks, string_full_free, NULL);
++  g_slist_free (context->spare_chunks);
++  g_slist_free (context->spare_list_nodes);
++
+   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);
+ }
+ 
+@@ -301,43 +349,101 @@ propagate_error (GMarkupParseContext  *context,
+   g_propagate_error (dest, src);
+ }
+ 
+-/* 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)
++slow_name_validate (GMarkupParseContext *context, const char *name, GError **error)
+ {
+-  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;
++  const char *p = name;
++
++  if (!g_utf8_validate (name, strlen (name), NULL))
++    {
++      set_error (context, error, G_MARKUP_ERROR_BAD_UTF8,
++		 _("Invalid UTF-8 encoded text in name - not valid '%s'"), name);
++      return FALSE;
++    }
++
++  if (!(g_ascii_isalpha (*p) ||
++	(!IS_COMMON_NAME_END_CHAR (*p) &&
++	 (*p == '_' || 
++	  *p == ':' ||
++	  g_unichar_isalpha (g_utf8_get_char (p))))))
++    {
++      set_error (context, error, G_MARKUP_ERROR_PARSE,
++		 _("'%s' is not a valid name "), name);
++      return FALSE;
++    }
++
++  for (p = g_utf8_next_char (name); *p != '\0'; p = g_utf8_next_char (p))
++    {
++      /* is_name_char */
++      if (!(g_ascii_isalnum (*p) ||
++	    (!IS_COMMON_NAME_END_CHAR (*p) &&
++	     (*p == '.' || 
++	      *p == '-' ||
++	      *p == '_' ||
++	      *p == ':' ||
++	      g_unichar_isalpha (g_utf8_get_char (p))))))
++	{
++	  set_error (context, error, G_MARKUP_ERROR_PARSE,
++		     _("'%s' is not a valid name: '%c' "), name, *p);
++	  return FALSE;
++	}
++    }
++  return TRUE;
+ }
+ 
++/* 
++ * Use me for elements, attributes etc.
++ */
+ static gboolean
+-is_name_char (const gchar *p)
++name_validate (GMarkupParseContext *context, const char *name, GError **error)
+ {
+-  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;
++  char mask;
++  const char *p;
++
++  /* name start char */
++  p = name;
++  if (G_UNLIKELY (IS_COMMON_NAME_END_CHAR (*p) ||
++		  !(g_ascii_isalpha (*p) || *p == '_' || *p == ':')))
++    goto slow_validate;
++  
++  for (mask = *p++; *p != '\0'; p++)
++    {
++      mask |= *p;
++
++      /* is_name_char */
++      if (G_UNLIKELY (!(g_ascii_isalnum (*p) ||
++			(!IS_COMMON_NAME_END_CHAR (*p) &&
++			 (*p == '.' || 
++			  *p == '-' ||
++			  *p == '_' ||
++			  *p == ':')))))
++	goto slow_validate;
++    }
++
++  if (mask & 0x80) /* un-common / non-ascii */
++    goto slow_validate;
++
++  return TRUE;
++
++ slow_validate:
++  return slow_name_validate (context, name, error);
+ }
+ 
++static gboolean
++text_validate (GMarkupParseContext *context, const char *p, int len, GError **error)
++{
++  if (!g_utf8_validate (p, len, NULL))
++    {
++      set_error (context, error, G_MARKUP_ERROR_BAD_UTF8,
++		 _("Invalid UTF-8 encoded text in name - not valid '%s'"), p);
++      return FALSE;
++    }
++  else
++    return TRUE;
++}
+ 
+ static gchar*
+ char_str (gunichar c,
+@@ -360,7 +466,6 @@ static void
+ set_unescape_error (GMarkupParseContext *context,
+                     GError             **error,
+                     const gchar         *remaining_text,
+-                    const gchar         *remaining_text_end,
+                     GMarkupError         code,
+                     const gchar         *format,
+                     ...)
+@@ -373,7 +478,7 @@ set_unescape_error (GMarkupParseContext *context,
+ 
+   remaining_newlines = 0;
+   p = remaining_text;
+-  while (p != remaining_text_end)
++  while (*p != '\0')
+     {
+       if (*p == '\n')
+         ++remaining_newlines;
+@@ -397,414 +502,199 @@ set_unescape_error (GMarkupParseContext *context,
+   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)
++/*
++ * re-write the GString in-place, unescaping anything that escaped.
++ * most XML does not contain entities, or escaping.
++ */
++static gboolean
++unescape_gstring_inplace (GMarkupParseContext *context,
++			  GString             *string,
++			  gboolean            *is_ascii,
++			  GError             **error)
+ {
+-  const gchar *start;
++  char mask, *to;
++  int line_num = 1;
++  const char *from;
+   gboolean normalize_attribute;
+ 
+-  if (ucontext->context->state == STATE_INSIDE_ATTRIBUTE_VALUE_SQ ||
+-      ucontext->context->state == STATE_INSIDE_ATTRIBUTE_VALUE_DQ)
++  *is_ascii = FALSE;
++
++  /* are we unescaping an attribute or not ? */
++  if (context->state == STATE_INSIDE_ATTRIBUTE_VALUE_SQ ||
++      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)
++  /*
++   * Meeks' theorum: unescaping can only shrink text.
++   * for &lt; etc. this is obvious, for &#xffff; more
++   * thought is required, but this is patently so.
++   */
++  mask = 0;
++  for (from = to = string->str; *from != '\0'; from++, to++) 
+     {
+-      g_assert (*p == ';');
++      *to = *from;
++
++      mask |= *to;
++      if (*to == '\n')
++	line_num++;
++      if (normalize_attribute && (*to == '\t' || *to == '\n'))
++	*to = ' ';
++      if (*to == '\r')
++	{
++	  *to = normalize_attribute ? ' ' : '\n';
++	  if (from[1] == '\n')
++	    from++;
++	}
++      if (*from == '&')
++	{
++	  from++;
++	  if (*from == '#')
++	    {
++	      gboolean is_hex = FALSE;
++	      gulong l;
++	      gchar *end = NULL;
+ 
+-      /* digit is between start and p */
++	      from++;
+ 
+-      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 (*from == 'x')
++		{
++		  is_hex = TRUE;
++		  from++;
++		}
+ 
+-          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 1.1 permits */
+-              if ((0 < l && l <= 0xD7FF) ||
+-                  (0xE000 <= l && l <= 0xFFFD) ||
+-                  (0x10000 <= l && 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);
+-                }
++	      /* digit is between start and p */
++	      errno = 0;
++	      if (is_hex)
++		l = strtoul (from, &end, 16);
++	      else
++		l = strtoul (from, &end, 10);
++	      
++	      if (end == from || errno != 0)
++		{
++		  set_unescape_error (context, error,
++				      from, 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"),
++				      end - from, from);
++		  return FALSE;
++		}
++	      else if (*end != ';')
++		{
++		  set_unescape_error (context, error,
++				      from, 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 FALSE;
++		}
++	      else
++		{
++		  /* characters XML 1.1 permits */
++		  if ((0 < l && l <= 0xD7FF) ||
++		      (0xE000 <= l && l <= 0xFFFD) ||
++		      (0x10000 <= l && l <= 0x10FFFF))
++		    {
++		      gchar buf[8];
++		      char_str (l, buf);
++		      strcpy (to, buf);
++		      to += strlen (buf) - 1;
++		      from = end;
++		      if (l >= 0x80) /* not ascii */
++			mask |= 0x80;
++		    }
++		  else
++		    {
++		      set_unescape_error (context, error,
++					  from, G_MARKUP_ERROR_PARSE,
++					  _("Character reference '%-.*s' does not "
++					    "encode a permitted character"),
++					  end - from, from);
++		      return FALSE;
++		    }
++		}
+             }
+ 
+-          /* 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;"));
++          else if (strncmp (from, "lt;", 3) == 0)
++	    {
++	      *to = '<';
++	      from += 2;
++	    }
++          else if (strncmp (from, "gt;", 3) == 0)
++	    {
++	      *to = '>';
++	      from += 2;
++	    }
++          else if (strncmp (from, "amp;", 4) == 0)
++	    {
++	      *to = '&';
++	      from += 3;
++	    }
++          else if (strncmp (from, "quot;", 5) == 0)
++	    {
++	      *to = '"';
++	      from += 4;
++	    }
++	  else if (strncmp (from, "apos;", 5) == 0)
++	    {
++	      *to = '\'';
++	      from += 4;
++	    }
++	  else
++	    {
++	      if (*from == ';')
++		set_unescape_error (context, error,
++				    from, G_MARKUP_ERROR_PARSE,
++				    _("Empty entity '&;' seen; valid "
++				      "entities are: &amp; &quot; &lt; &gt; &apos;"));
++	      else
++		{
++		  const char *end = strchr (from, ';');
++		  if (end)
++		    set_unescape_error (context, error,
++					from, G_MARKUP_ERROR_PARSE,
++					_("Entity name '%-.*s' is not known"),
++					end-from, from);
++		  else
++		    set_unescape_error (context, error,
++					from, 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;"));
++		}
++	      return FALSE;
++	    }
++	}
+     }
+ 
+-  return p;
+-}
++  g_assert (to - string->str <= string->len);
++  if (to - string->str != string->len)
++    g_string_truncate (string, to - string->str);
+ 
+-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;
++  *is_ascii = !(mask & 0x80);
+ 
+-        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;
+-    }
++  return TRUE;
+ }
+ 
+ static inline gboolean
+ advance_char (GMarkupParseContext *context)
+ {  
+-  context->iter = g_utf8_next_char (context->iter);
+-  context->char_number += 1;
++  context->iter++;
++  context->char_number++;
+ 
+-  if (context->iter == context->current_text_end)
+-    {
++  if (G_UNLIKELY (context->iter == context->current_text_end))
+       return FALSE;
+-    }
+-  else if (*context->iter == '\n')
++
++  else if (G_UNLIKELY (*context->iter == '\n'))
+     {
+-      context->line_number += 1;
++      context->line_number++;
+       context->char_number = 1;
+     }
+   
+@@ -833,37 +723,62 @@ advance_to_name_end (GMarkupParseContext *context)
+ {
+   do
+     {
+-      if (!is_name_char (context->iter))
++      if (IS_COMMON_NAME_END_CHAR (*(context->iter)))
+         return;
++      if (xml_isspace (*(context->iter)))
++	return;
+     }
+   while (advance_char (context));
+ }
+ 
+ static void
++release_chunk (GMarkupParseContext *context, GString *str)
++{
++  GSList *node;
++  if (!str)
++    return;
++  if (str->allocated_len > 256)
++    { /* large strings are unusual and worth freeing */
++      g_string_free (str, TRUE);
++      return;
++    }
++  string_blank (str);
++  node = get_list_node (context, str);
++  context->spare_chunks = g_slist_concat (node, context->spare_chunks);
++}
++
++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);
++    { /* allocate a new chunk to parse into */
+ 
+-  if (text_start != text_end)
+-    g_string_append_len (context->partial_chunk, text_start,
+-                         text_end - text_start);
++      if (context->spare_chunks != NULL)
++	{
++	  GSList *node = context->spare_chunks;
++	  context->spare_chunks = g_slist_remove_link (context->spare_chunks, node);
++	  context->partial_chunk = node->data;
++	  free_list_node (context, node);
++	}
++      else
++	context->partial_chunk = g_string_sized_new (MAX (28, text_end - text_start));
++    }
+ 
+-  /* Invariant here that partial_chunk exists */
++  if (text_start != text_end)
++    g_string_insert_len (context->partial_chunk, -1,
++			 text_start, text_end - text_start);
+ }
+ 
+-static void
++static inline void
+ truncate_partial (GMarkupParseContext *context)
+ {
+   if (context->partial_chunk != NULL)
+-    {
+-      context->partial_chunk = g_string_truncate (context->partial_chunk, 0);
+-    }
++    string_blank (context->partial_chunk);
+ }
+ 
+-static const gchar*
++static inline const gchar*
+ current_element (GMarkupParseContext *context)
+ {
+   return context->tag_stack->data;
+@@ -891,6 +806,30 @@ pop_subparser_stack (GMarkupParseContext *context)
+ }
+ 
+ static void
++push_partial_as_tag (GMarkupParseContext *context)
++{
++  GString *str = context->partial_chunk;
++  /* sadly, this is exported by gmarkup_get_element_stack as-is */
++  context->tag_stack = g_slist_concat (get_list_node (context, str->str), context->tag_stack);
++  context->tag_stack_gstr = g_slist_concat (get_list_node (context, str), context->tag_stack_gstr);
++  context->partial_chunk = NULL;
++}
++
++static void
++pop_tag (GMarkupParseContext *context)
++{
++  GSList *nodea, *nodeb;
++
++  nodea = context->tag_stack;
++  nodeb = context->tag_stack_gstr;
++  release_chunk (context, nodeb->data);
++  context->tag_stack = g_slist_remove_link (context->tag_stack, nodea);
++  context->tag_stack_gstr = g_slist_remove_link (context->tag_stack_gstr, nodeb);
++  free_list_node (context, nodea);
++  free_list_node (context, nodeb);
++}
++
++static void
+ possibly_finish_subparser (GMarkupParseContext *context)
+ {
+   if (current_element (context) == context->subparser_element)
+@@ -916,60 +855,42 @@ 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;
+-    }
++  return context->attr_names[context->cur_attr]->str;
+ }
+ 
+-
+ static void
+-add_attribute (GMarkupParseContext *context, char *name)
++add_attribute (GMarkupParseContext *context, GString *str)
+ {
+   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->attr_names = g_realloc (context->attr_names, sizeof(GString*)*context->alloc_attrs);
++      context->attr_values = g_realloc (context->attr_values, sizeof(GString*)*context->alloc_attrs);
+     }
+   context->cur_attr++;
+-  context->attr_names[context->cur_attr] = name;
++  context->attr_names[context->cur_attr] = str;
+   context->attr_values[context->cur_attr] = NULL;
+   context->attr_names[context->cur_attr+1] = NULL;
+   context->attr_values[context->cur_attr+1] = NULL;
+ }
+ 
++static void
++clear_attributes (GMarkupParseContext *context)
++{
++  /* Go ahead and free the attributes. */
++  for (; context->cur_attr >= 0; context->cur_attr--)
++    {
++      int pos = context->cur_attr;
++      release_chunk (context, context->attr_names[pos]);
++      release_chunk (context, 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);
++}
+ /**
+  * g_markup_parse_context_parse:
+  * @context: a #GMarkupParseContext
+@@ -994,8 +915,6 @@ g_markup_parse_context_parse (GMarkupParseContext *context,
+                               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);
+@@ -1009,130 +928,16 @@ g_markup_parse_context_parse (GMarkupParseContext *context,
+   
+   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_literal (context,
+-                                 error,
+-                                 G_MARKUP_ERROR_BAD_UTF8,
+-                                 _("Invalid UTF-8 encoded text - overlong sequence"));
+-            }
+-          
+-          goto finished;
+-        }
+-    }
+ 
+   context->current_text = text;
+   context->current_text_len = text_len;
++  context->current_text_end = context->current_text + 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_literal (context,
+-                         error,
+-                         G_MARKUP_ERROR_BAD_UTF8,
+-                         _("Invalid UTF-8 encoded text - not a start char"));
+-      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, *q;
+-      gchar *current_text_dup;
+-
+-      q = p = context->current_text;
+-      while (p != first_invalid)
+-        {
+-          if (*p == '\n')
+-            {
+-              ++newlines;
+-              q = p + 1;
+-              context->char_number = 1;
+-            }
+-          ++p;
+-        }
+-
+-      context->line_number += newlines;
+-      context->char_number += g_utf8_strlen (q, first_invalid - q);
+-
+-      current_text_dup = g_strndup (context->current_text, context->current_text_len);
+-      set_error (context,
+-                 error,
+-                 G_MARKUP_ERROR_BAD_UTF8,
+-                 _("Invalid UTF-8 encoded text - not valid '%s'"),
+-                 current_text_dup);
+-      g_free (current_text_dup);
+-      goto finished;
+-    }
+-
+   while (context->iter != context->current_text_end)
+     {
+       switch (context->state)
+@@ -1191,7 +996,7 @@ g_markup_parse_context_parse (GMarkupParseContext *context,
+ 
+               context->state = STATE_AFTER_CLOSE_TAG_SLASH;
+             }
+-          else if (is_name_start_char (context->iter))
++          else if (!IS_COMMON_NAME_END_CHAR (*(context->iter)))
+             {
+               context->state = STATE_INSIDE_OPEN_TAG_NAME;
+ 
+@@ -1247,7 +1052,7 @@ g_markup_parse_context_parse (GMarkupParseContext *context,
+             tmp_error = NULL;
+             if (context->parser->end_element)
+               (* context->parser->end_element) (context,
+-                                                context->tag_stack->data,
++						current_element (context),
+                                                 context->user_data,
+                                                 &tmp_error);
+ 
+@@ -1279,10 +1084,7 @@ g_markup_parse_context_parse (GMarkupParseContext *context,
+                                current_element (context));
+                   }
+               }
+-
+-            g_free (context->tag_stack->data);
+-            context->tag_stack = g_slist_delete_link (context->tag_stack,
+-                                                      context->tag_stack);
++	    pop_tag (context);
+           }
+           break;
+ 
+@@ -1309,12 +1111,7 @@ g_markup_parse_context_parse (GMarkupParseContext *context,
+                * 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;
++	      push_partial_as_tag (context);
+ 
+               context->state = STATE_BETWEEN_ATTRIBUTES;
+               context->start = NULL;
+@@ -1345,7 +1142,10 @@ g_markup_parse_context_parse (GMarkupParseContext *context,
+ 	      /* 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));
++	      if (!name_validate (context, context->partial_chunk->str, error))
++		break;
++
++	      add_attribute (context, context->partial_chunk);
+ 	      
+               context->partial_chunk = NULL;
+               context->start = NULL;
+@@ -1387,11 +1187,10 @@ g_markup_parse_context_parse (GMarkupParseContext *context,
+                 }
+               else if (*context->iter == '>')
+                 {
+-
+                   advance_char (context);
+                   context->state = STATE_AFTER_CLOSE_ANGLE;
+                 }
+-              else if (is_name_start_char (context->iter))
++              else if (!IS_COMMON_NAME_END_CHAR (*(context->iter)))
+                 {
+                   context->state = STATE_INSIDE_ATTRIBUTE_NAME;
+                   /* start of attribute name */
+@@ -1419,44 +1218,35 @@ g_markup_parse_context_parse (GMarkupParseContext *context,
+               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;
++		  int i;
++		  const gchar *start_name;
++                  const gchar **attr_names;
++                  const gchar **attr_values;
+                   GError *tmp_error;
+ 
+-                  /* Call user callback for element start */
+-                  start_name = current_element (context);
+-
+-		  if (context->cur_attr >= 0)
++		  attr_names = g_newa (const gchar *, context->cur_attr + 2);
++		  attr_values = g_newa (const gchar *, context->cur_attr + 2);
++		  for (i = 0; i < context->cur_attr + 1; i++)
+ 		    {
+-		      attr_names = (const gchar**)context->attr_names;
+-		      attr_values = (const gchar**)context->attr_values;
++		      attr_names[i] = context->attr_names[i]->str;
++		      attr_values[i] = context->attr_values[i]->str;
+ 		    }
++		  attr_names[i] = NULL;
++		  attr_values[i] = NULL;
+ 
++                  /* Call user callback for element start */
+                   tmp_error = NULL;
+-                  if (context->parser->start_element)
++		  start_name = current_element (context);
++
++                  if (context->parser->start_element &&
++		      name_validate (context, start_name, error))
+                     (* context->parser->start_element) (context,
+-                                                        start_name,
++							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);
++		  clear_attributes (context);
+                   
+                   if (tmp_error != NULL)
+                     propagate_error (context, error, tmp_error);
+@@ -1531,25 +1321,22 @@ g_markup_parse_context_parse (GMarkupParseContext *context,
+             }
+           else
+             {
++	      gboolean is_ascii;
+               /* 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))
++              if (unescape_gstring_inplace (context, context->partial_chunk, &is_ascii, error) &&
++		  (is_ascii || text_validate (context, context->partial_chunk->str,
++					      context->partial_chunk->len, error)))
+                 {
+                   /* success, advance past quote and set state. */
+-                  context->attr_values[context->cur_attr] = g_string_free (unescaped, FALSE);
++                  context->attr_values[context->cur_attr] = context->partial_chunk;
++		  context->partial_chunk = NULL;
+                   advance_char (context);
+                   context->state = STATE_BETWEEN_ATTRIBUTES;
+                   context->start = NULL;
+@@ -1576,30 +1363,25 @@ g_markup_parse_context_parse (GMarkupParseContext *context,
+ 
+           if (context->iter != context->current_text_end)
+             {
+-              GString *unescaped = NULL;
++	      gboolean is_ascii;
+ 
+               /* 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))
++              if (unescape_gstring_inplace (context, context->partial_chunk, &is_ascii, error) &&
++		  (is_ascii || text_validate (context, context->partial_chunk->str,
++					      context->partial_chunk->len, error)))
+                 {
+                   GError *tmp_error = NULL;
+ 
+                   if (context->parser->text)
+                     (*context->parser->text) (context,
+-                                              unescaped->str,
+-                                              unescaped->len,
++					      context->partial_chunk->str,
++					      context->partial_chunk->len,
+                                               context->user_data,
+                                               &tmp_error);
+                   
+-                  g_string_free (unescaped, TRUE);
+-
+                   if (tmp_error == NULL)
+                     {
+                       /* advance past open angle and set state. */
+@@ -1618,7 +1400,7 @@ g_markup_parse_context_parse (GMarkupParseContext *context,
+ 
+         case STATE_AFTER_CLOSE_TAG_SLASH:
+           /* Possible next state: INSIDE_CLOSE_TAG_NAME */
+-          if (is_name_start_char (context->iter))
++          if (!IS_COMMON_NAME_END_CHAR (*(context->iter)))
+             {
+               context->state = STATE_INSIDE_CLOSE_TAG_NAME;
+ 
+@@ -1656,13 +1438,9 @@ g_markup_parse_context_parse (GMarkupParseContext *context,
+ 	  
+ 	  if (context->iter != context->current_text_end)
+ 	    {
+-	      gchar *close_name;
++	      GString *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);
++	      close_name = context->partial_chunk;
+ 	      context->partial_chunk = NULL;
+               
+ 	      if (*context->iter != '>')
+@@ -1676,7 +1454,7 @@ g_markup_parse_context_parse (GMarkupParseContext *context,
+ 			       "the close element name '%s'; the allowed "
+ 			       "character is '>'"),
+ 			     utf8_str (context->iter, buf),
+-			     close_name);
++			     close_name->str);
+ 		}
+ 	      else if (context->tag_stack == NULL)
+ 		{
+@@ -1685,16 +1463,16 @@ g_markup_parse_context_parse (GMarkupParseContext *context,
+ 			     G_MARKUP_ERROR_PARSE,
+ 			     _("Element '%s' was closed, no element "
+ 			       "is currently open"),
+-			     close_name);
++			     close_name->str);
+ 		}
+-	      else if (strcmp (close_name, current_element (context)) != 0)
++	      else if (strcmp (close_name->str, 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,
++			     close_name->str,
+ 			     current_element (context));
+ 		}
+ 	      else
+@@ -1710,22 +1488,18 @@ g_markup_parse_context_parse (GMarkupParseContext *context,
+ 		  tmp_error = NULL;
+ 		  if (context->parser->end_element)
+ 		    (* context->parser->end_element) (context,
+-						      close_name,
++						      close_name->str,
+ 						      context->user_data,
+ 						      &tmp_error);
+ 		  
+                   ensure_no_outstanding_subparser (context);
+-		  
+-		  /* Pop the tag stack */
+-		  g_free (context->tag_stack->data);
+-		  context->tag_stack = g_slist_delete_link (context->tag_stack,
+-							    context->tag_stack);
++		  pop_tag (context);
+ 		  
+ 		  if (tmp_error)
+                     propagate_error (context, error, tmp_error);
+                 }
+-	      
+-              g_free (close_name);
++	      context->partial_chunk = close_name;
++	      truncate_partial (context);
+             }
+           break;
+ 	  
+@@ -1784,14 +1558,22 @@ g_markup_parse_context_parse (GMarkupParseContext *context,
+ 	      if (context->flags & G_MARKUP_TREAT_CDATA_AS_TEXT &&
+ 		  strncmp (context->partial_chunk->str, "<![CDATA[", 9) == 0)
+ 		{
+-		  if (context->parser->text)
++		  if (context->parser->text &&
++		      text_validate (context,
++				     context->partial_chunk->str + 9,
++				     context->partial_chunk->len - 12,
++				     error))
+ 		    (*context->parser->text) (context,
+ 					      context->partial_chunk->str + 9,
+ 					      context->partial_chunk->len - 12,
+ 					      context->user_data,
+ 					      &tmp_error);
+ 		}
+-	      else if (context->parser->passthrough)
++	      else if (context->parser->passthrough &&
++		       text_validate (context,
++				      context->partial_chunk->str,
++				      context->partial_chunk->len,
++				      error))
+                 (*context->parser->passthrough) (context,
+                                                  context->partial_chunk->str,
+                                                  context->partial_chunk->len,
+@@ -1999,7 +1781,6 @@ G_CONST_RETURN GSList *
+ g_markup_parse_context_get_element_stack (GMarkupParseContext *context)
+ {
+   g_return_val_if_fail (context != NULL, NULL);
+-
+   return context->tag_stack;
+ }
+ 
+-- 
+1.6.1.3
+
diff --git a/dev-libs/glib/files/fail-36.gmarkup b/dev-libs/glib/files/fail-36.gmarkup
new file mode 100644
index 0000000..4e90be4
--- /dev/null
+++ b/dev-libs/glib/files/fail-36.gmarkup
@@ -0,0 +1 @@
+<foo>�</foo><^$non-carriage-null-fail|>
diff --git a/dev-libs/glib/files/glib-2.10.3-ia64-atomic-ops.patch b/dev-libs/glib/files/glib-2.10.3-ia64-atomic-ops.patch
new file mode 100644
index 0000000..0859e33
--- /dev/null
+++ b/dev-libs/glib/files/glib-2.10.3-ia64-atomic-ops.patch
@@ -0,0 +1,39 @@
+From Debian, this one is needed for gcc < 4.1...
+
+--- glib-2.10.0/glib/gatomic.c	2006-02-24 14:02:51.000000000 +0000
++++ glib-2.10.0/glib/gatomic.c	2006-03-06 18:12:06.000000000 +0000
+@@ -414,14 +414,14 @@
+ g_atomic_int_exchange_and_add (volatile gint *atomic,
+ 			       gint           val)
+ {
+-  return __sync_fetch_and_add (atomic, val);
++  return __sync_fetch_and_add_si (atomic, val);
+ }
+  
+ void
+ g_atomic_int_add (volatile gint *atomic, 
+ 		  gint val)
+ {
+-  __sync_fetch_and_add (atomic, val);
++  __sync_fetch_and_add_si (atomic, val);
+ }
+ 
+ gboolean
+@@ -429,7 +429,7 @@
+ 				   gint           oldval, 
+ 				   gint           newval)
+ {
+-  return __sync_bool_compare_and_swap (atomic, oldval, newval);
++  return __sync_bool_compare_and_swap_si (atomic, oldval, newval);
+ }
+ 
+ gboolean
+@@ -437,7 +437,7 @@
+ 				       gpointer           oldval, 
+ 				       gpointer           newval)
+ {
+-  return __sync_bool_compare_and_swap ((long *)atomic, 
++  return __sync_bool_compare_and_swap_di ((long *)atomic, 
+ 				       (long)oldval, (long)newval);
+ }
+ 
diff --git a/dev-libs/glib/files/glib-2.12.12-fbsd.patch b/dev-libs/glib/files/glib-2.12.12-fbsd.patch
new file mode 100644
index 0000000..bba6329
--- /dev/null
+++ b/dev-libs/glib/files/glib-2.12.12-fbsd.patch
@@ -0,0 +1,21 @@
+diff --exclude-from=/home/dang/.scripts/diffrc -up -ruN glib-2.12.12.orig/gmodule/gmodule-dl.c glib-2.12.12/gmodule/gmodule-dl.c
+--- glib-2.12.12.orig/gmodule/gmodule-dl.c	2007-05-01 19:12:40.000000000 -0400
++++ glib-2.12.12/gmodule/gmodule-dl.c	2007-07-05 20:10:51.000000000 -0400
+@@ -106,6 +106,7 @@ _g_module_open (const gchar *file_name,
+ static gpointer
+ _g_module_self (void)
+ {
++#ifndef __FreeBSD__
+   gpointer handle;
+   
+   /* to query symbols from the program itself, special link options
+@@ -117,6 +118,9 @@ _g_module_self (void)
+     g_module_set_error (fetch_dlerror (TRUE));
+   
+   return handle;
++#else
++  return RTLD_DEFAULT;
++#endif
+ }
+ 
+ static void
diff --git a/dev-libs/glib/files/glib-2.18.1-workaround-gio-test-failure-without-userpriv.patch b/dev-libs/glib/files/glib-2.18.1-workaround-gio-test-failure-without-userpriv.patch
new file mode 100644
index 0000000..cabe56f
--- /dev/null
+++ b/dev-libs/glib/files/glib-2.18.1-workaround-gio-test-failure-without-userpriv.patch
@@ -0,0 +1,20 @@
+Temporary workaround for gio tests failure when ran without FEATURES=userpriv
+until upstream bug #552912 is fixed
+
+--- gio/tests/live-g-file.c.orig	2008-09-25 05:44:12.848556034 +0300
++++ gio/tests/live-g-file.c	2008-09-25 06:12:34.248726237 +0300
+@@ -769,11 +769,14 @@
+ 	      if (posix_compat)
+ 		{
+ 		  /*  target directory is not accessible (no execute flag)  */
++#if 0
++/* Fails when ran as root */
+ 		  do_copy_move (root, item, TEST_DIR_NO_ACCESS,
+ 				TEST_NO_ACCESS);
+ 		  /*  target directory is readonly  */
+ 		  do_copy_move (root, item, TEST_DIR_NO_WRITE,
+ 				TEST_NO_ACCESS);
++#endif
+ 		}
+ 	    }
+ 	}
diff --git a/dev-libs/glib/files/glib-2.6.3-testglib-ssp.patch b/dev-libs/glib/files/glib-2.6.3-testglib-ssp.patch
new file mode 100644
index 0000000..9b104dd
--- /dev/null
+++ b/dev-libs/glib/files/glib-2.6.3-testglib-ssp.patch
@@ -0,0 +1,11 @@
+--- tests/Makefile.in.orig	2005-04-07 01:05:39.000000000 +0000
++++ tests/Makefile.in	2005-04-07 01:09:02.000000000 +0000
+@@ -50,7 +50,7 @@
+ CATOBJEXT = @CATOBJEXT@
+ CC = @CC@
+ CCDEPMODE = @CCDEPMODE@
+-CFLAGS = @CFLAGS@
++CFLAGS = @CFLAGS@ -fno-stack-protector
+ CPP = @CPP@
+ CPPFLAGS = @CPPFLAGS@
+ CROSS_COMPILING_FALSE = @CROSS_COMPILING_FALSE@