1 /* gmarkup.c - Simple XML-like parser

     2  *

     3  *  Copyright 2000, 2003 Red Hat, Inc.

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

     5  *

     6  * GLib is free software; you can redistribute it and/or modify it

     7  * under the terms of the GNU Lesser General Public License as

     8  * published by the Free Software Foundation; either version 2 of the

     9  * License, or (at your option) any later version.

    10  *

    11  * GLib is distributed in the hope that it will be useful,

    12  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    14  * Lesser General Public License for more details.

    15  *

    16  * You should have received a copy of the GNU Lesser General Public

    17  * License along with GLib; see the file COPYING.LIB.  If not,

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

    19  *   Boston, MA 02111-1307, USA.

    20  */

    21 

    22 #include "config.h"

    23 

    24 #include <stdarg.h>

    25 #include <string.h>

    26 #include <stdio.h>

    27 #include <stdlib.h>

    28 #include <errno.h>

    29 

    30 #include "glib.h"

    31 #include "galias.h"

    32 

    33 #include "glibintl.h"

    34 

    35 #ifdef __SYMBIAN32__

    36 #include <glib_wsd.h>

    37 #endif

    38 

    39 

    40 #if EMULATOR

    41 

    42 PLS(error_quark ,g_markup_error_quark,GQuark)

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

    44 

    45 #endif /* EMULATOR */

    46 

    47 

    48 EXPORT_C GQuark

    49 g_markup_error_quark (void)

    50 {

    51   #if !(EMULATOR)

    52   static GQuark error_quark = 0;

    53   #endif /*EMULATOR */

    54 

    55   if (error_quark == 0)

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

    57 

    58   return error_quark;

    59 }

    60 

    61 #if EMULATOR

    62 #undef error_quark

    63 #endif /* EMULATOR */

    64 

    65 typedef enum

    66 {

    67   STATE_START,

    68   STATE_AFTER_OPEN_ANGLE,

    69   STATE_AFTER_CLOSE_ANGLE,

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

    71   STATE_INSIDE_OPEN_TAG_NAME,

    72   STATE_INSIDE_ATTRIBUTE_NAME,

    73   STATE_AFTER_ATTRIBUTE_NAME,

    74   STATE_BETWEEN_ATTRIBUTES,

    75   STATE_AFTER_ATTRIBUTE_EQUALS_SIGN,

    76   STATE_INSIDE_ATTRIBUTE_VALUE_SQ,

    77   STATE_INSIDE_ATTRIBUTE_VALUE_DQ,

    78   STATE_INSIDE_TEXT,

    79   STATE_AFTER_CLOSE_TAG_SLASH,

    80   STATE_INSIDE_CLOSE_TAG_NAME,

    81   STATE_AFTER_CLOSE_TAG_NAME,

    82   STATE_INSIDE_PASSTHROUGH,

    83   STATE_ERROR

    84 } GMarkupParseState;

    85 

    86 struct _GMarkupParseContext

    87 {

    88   const GMarkupParser *parser;

    89 

    90   GMarkupParseFlags flags;

    91 

    92   gint line_number;

    93   gint char_number;

    94 

    95   gpointer user_data;

    96   GDestroyNotify dnotify;

    97 

    98   /* A piece of character data or an element that

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

   100    * the callback for it.

   101    */

   102   GString *partial_chunk;

   103 

   104   GMarkupParseState state;

   105   GSList *tag_stack;

   106   gchar **attr_names;

   107   gchar **attr_values;

   108   gint cur_attr;

   109   gint alloc_attrs;

   110 

   111   const gchar *current_text;

   112   gssize       current_text_len;      

   113   const gchar *current_text_end;

   114 

   115   GString *leftover_char_portion;

   116 

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

   118   const gchar *start;

   119 

   120   const gchar *iter;

   121 

   122   guint document_empty : 1;

   123   guint parsing : 1;

   124   gint balance;

   125 };

   126 

   127 /**

   128  * g_markup_parse_context_new:

   129  * @parser: a #GMarkupParser

   130  * @flags: one or more #GMarkupParseFlags

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

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

   133  * 

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

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

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

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

   138  * and create a new parse context).

   139  * 

   140  * Return value: a new #GMarkupParseContext

   141  **/

   142 EXPORT_C GMarkupParseContext *

   143 g_markup_parse_context_new (const GMarkupParser *parser,

   144                             GMarkupParseFlags    flags,

   145                             gpointer             user_data,

   146                             GDestroyNotify       user_data_dnotify)

   147 {

   148   GMarkupParseContext *context;

   149 

   150   g_return_val_if_fail (parser != NULL, NULL);

   151   context = g_new (GMarkupParseContext, 1);

   152 

   153   context->parser = parser;

   154   context->flags = flags;

   155   context->user_data = user_data;

   156   context->dnotify = user_data_dnotify;

   157 

   158   context->line_number = 1;

   159   context->char_number = 1;

   160 

   161   context->partial_chunk = NULL;

   162 

   163   context->state = STATE_START;

   164   context->tag_stack = NULL;

   165   context->attr_names = NULL;

   166   context->attr_values = NULL;

   167   context->cur_attr = -1;

   168   context->alloc_attrs = 0;

   169 

   170   context->current_text = NULL;

   171   context->current_text_len = -1;

   172   context->current_text_end = NULL;

   173   context->leftover_char_portion = NULL;

   174 

   175   context->start = NULL;

   176   context->iter = NULL;

   177 

   178   context->document_empty = TRUE;

   179   context->parsing = FALSE;

   180 

   181   context->balance = 0;

   182 

   183   return context;

   184 }

   185 

   186 /**

   187  * g_markup_parse_context_free:

   188  * @context: a #GMarkupParseContext

   189  * 

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

   191  * one of the #GMarkupParser functions.

   192  * 

   193  **/

   194 EXPORT_C void

   195 g_markup_parse_context_free (GMarkupParseContext *context)

   196 {

   197   g_return_if_fail (context != NULL);

   198   g_return_if_fail (!context->parsing);

   199 

   200   if (context->dnotify)

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

   202 

   203   g_strfreev (context->attr_names);

   204   g_strfreev (context->attr_values);

   205 

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

   207   g_slist_free (context->tag_stack);

   208 

   209   if (context->partial_chunk)

   210     g_string_free (context->partial_chunk, TRUE);

   211 

   212   if (context->leftover_char_portion)

   213     g_string_free (context->leftover_char_portion, TRUE);

   214 

   215   g_free (context);

   216 }

   217 

   218 static void

   219 mark_error (GMarkupParseContext *context,

   220             GError              *error)

   221 {

   222   context->state = STATE_ERROR;

   223 

   224   if (context->parser->error)

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

   226 }

   227 

   228 static void set_error (GMarkupParseContext *context,

   229            	       GError             **error,

   230            	       GMarkupError         code,

   231            	       const gchar         *format,

   232            	       ...) G_GNUC_PRINTF (4, 5);

   233 

   234 static void

   235 set_error (GMarkupParseContext *context,

   236            GError             **error,

   237            GMarkupError         code,

   238            const gchar         *format,

   239            ...)

   240 {

   241   GError *tmp_error;

   242   gchar *s;

   243   va_list args;

   244 

   245   va_start (args, format);

   246   s = g_strdup_vprintf (format, args);

   247   va_end (args);

   248 

   249   tmp_error = g_error_new (G_MARKUP_ERROR,

   250                            code,

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

   252                            context->line_number,

   253                            context->char_number,

   254                            s);

   255 

   256   g_free (s);

   257 

   258   mark_error (context, tmp_error);

   259 

   260   g_propagate_error (error, tmp_error);

   261 }

   262 

   263 

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

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

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

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

   268  * the guniprop call.

   269  */

   270 #define IS_COMMON_NAME_END_CHAR(c) \

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

   272 

   273 static gboolean

   274 is_name_start_char (const gchar *p)

   275 {

   276   if (g_ascii_isalpha (*p) ||

   277       (!IS_COMMON_NAME_END_CHAR (*p) &&

   278        (*p == '_' || 

   279 	*p == ':' ||

   280 	g_unichar_isalpha (g_utf8_get_char (p)))))

   281     return TRUE;

   282   else

   283     return FALSE;

   284 }

   285 

   286 static gboolean

   287 is_name_char (const gchar *p)

   288 {

   289   if (g_ascii_isalnum (*p) ||

   290       (!IS_COMMON_NAME_END_CHAR (*p) &&

   291        (*p == '.' || 

   292 	*p == '-' ||

   293 	*p == '_' ||

   294 	*p == ':' ||

   295 	g_unichar_isalpha (g_utf8_get_char (p)))))

   296     return TRUE;

   297   else

   298     return FALSE;

   299 }

   300 

   301 

   302 static gchar*

   303 char_str (gunichar c,

   304           gchar   *buf)

   305 {

   306   memset (buf, 0, 8);

   307   g_unichar_to_utf8 (c, buf);

   308   return buf;

   309 }

   310 

   311 static gchar*

   312 utf8_str (const gchar *utf8,

   313           gchar       *buf)

   314 {

   315   char_str (g_utf8_get_char (utf8), buf);

   316   return buf;

   317 }

   318 

   319 static void

   320 set_unescape_error (GMarkupParseContext *context,

   321                     GError             **error,

   322                     const gchar         *remaining_text,

   323                     const gchar         *remaining_text_end,

   324                     GMarkupError         code,

   325                     const gchar         *format,

   326                     ...)

   327 {

   328   GError *tmp_error;

   329   gchar *s;

   330   va_list args;

   331   gint remaining_newlines;

   332   const gchar *p;

   333 

   334   remaining_newlines = 0;

   335   p = remaining_text;

   336   while (p != remaining_text_end)

   337     {

   338       if (*p == '\n')

   339         ++remaining_newlines;

   340       ++p;

   341     }

   342 

   343   va_start (args, format);

   344   s = g_strdup_vprintf (format, args);

   345   va_end (args);

   346 

   347   tmp_error = g_error_new (G_MARKUP_ERROR,

   348                            code,

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

   350                            context->line_number - remaining_newlines,

   351                            s);

   352 

   353   g_free (s);

   354 

   355   mark_error (context, tmp_error);

   356 

   357   g_propagate_error (error, tmp_error);

   358 }

   359 

   360 typedef enum

   361 {

   362   USTATE_INSIDE_TEXT,

   363   USTATE_AFTER_AMPERSAND,

   364   USTATE_INSIDE_ENTITY_NAME,

   365   USTATE_AFTER_CHARREF_HASH

   366 } UnescapeState;

   367 

   368 typedef struct

   369 {

   370   GMarkupParseContext *context;

   371   GString *str;

   372   UnescapeState state;

   373   const gchar *text;

   374   const gchar *text_end;

   375   const gchar *entity_start;

   376 } UnescapeContext;

   377 

   378 static const gchar*

   379 unescape_text_state_inside_text (UnescapeContext *ucontext,

   380                                  const gchar     *p,

   381                                  GError         **error)

   382 {

   383   const gchar *start;

   384   gboolean normalize_attribute;

   385 

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

   387       ucontext->context->state == STATE_INSIDE_ATTRIBUTE_VALUE_DQ)

   388     normalize_attribute = TRUE;

   389   else

   390     normalize_attribute = FALSE;

   391 

   392   start = p;

   393   

   394   while (p != ucontext->text_end)

   395     {

   396       if (*p == '&')

   397         {

   398           break;

   399         }

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

   401         {

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

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

   404           p = g_utf8_next_char (p);

   405           start = p;

   406         }

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

   408         {

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

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

   411           p = g_utf8_next_char (p);

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

   413             p = g_utf8_next_char (p);

   414           start = p;

   415         }

   416       else

   417         p = g_utf8_next_char (p);

   418     }

   419   

   420   if (p != start)

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

   422   

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

   424     {

   425       p = g_utf8_next_char (p);

   426       ucontext->state = USTATE_AFTER_AMPERSAND;

   427     }

   428 

   429   return p;

   430 }

   431 

   432 static const gchar*

   433 unescape_text_state_after_ampersand (UnescapeContext *ucontext,

   434                                      const gchar     *p,

   435                                      GError         **error)

   436 {

   437   ucontext->entity_start = NULL;

   438   

   439   if (*p == '#')

   440     {

   441       p = g_utf8_next_char (p);

   442 

   443       ucontext->entity_start = p;

   444       ucontext->state = USTATE_AFTER_CHARREF_HASH;

   445     }

   446   else if (!is_name_start_char (p))

   447     {

   448       if (*p == ';')

   449         {

   450           set_unescape_error (ucontext->context, error,

   451                               p, ucontext->text_end,

   452                               G_MARKUP_ERROR_PARSE,

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

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

   455         }

   456       else

   457         {

   458           gchar buf[8];

   459 

   460           set_unescape_error (ucontext->context, error,

   461                               p, ucontext->text_end,

   462                               G_MARKUP_ERROR_PARSE,

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

   464                                 "the start of an entity name; "

   465                                 "the & character begins an entity; "

   466                                 "if this ampersand isn't supposed "

   467                                 "to be an entity, escape it as "

   468                                 "&"),

   469                               utf8_str (p, buf));

   470         }

   471     }

   472   else

   473     {

   474       ucontext->entity_start = p;

   475       ucontext->state = USTATE_INSIDE_ENTITY_NAME;

   476     }

   477 

   478   return p;

   479 }

   480 

   481 static const gchar*

   482 unescape_text_state_inside_entity_name (UnescapeContext *ucontext,

   483                                         const gchar     *p,

   484                                         GError         **error)

   485 {

   486   while (p != ucontext->text_end)

   487     {

   488       if (*p == ';')

   489         break;

   490       else if (!is_name_char (p))

   491         {

   492           gchar ubuf[8];

   493 

   494           set_unescape_error (ucontext->context, error,

   495                               p, ucontext->text_end,

   496                               G_MARKUP_ERROR_PARSE,

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

   498                                 "inside an entity name"),

   499                               utf8_str (p, ubuf));

   500           break;

   501         }

   502 

   503       p = g_utf8_next_char (p);

   504     }

   505 

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

   507     {

   508       if (p != ucontext->text_end)

   509         {

   510 	  gint len = p - ucontext->entity_start;

   511 

   512           /* move to after semicolon */

   513           p = g_utf8_next_char (p);

   514           ucontext->state = USTATE_INSIDE_TEXT;

   515 

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

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

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

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

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

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

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

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

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

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

   526           else

   527             {

   528 	      gchar *name;

   529 

   530 	      name = g_strndup (ucontext->entity_start, len);

   531               set_unescape_error (ucontext->context, error,

   532                                   p, ucontext->text_end,

   533                                   G_MARKUP_ERROR_PARSE,

   534                                   _("Entity name '%s' is not known"),

   535                                   name);

   536 	      g_free (name);

   537             }

   538         }

   539       else

   540         {

   541           set_unescape_error (ucontext->context, error,

   542                               /* give line number of the & */

   543                               ucontext->entity_start, ucontext->text_end,

   544                               G_MARKUP_ERROR_PARSE,

   545                               _("Entity did not end with a semicolon; "

   546                                 "most likely you used an ampersand "

   547                                 "character without intending to start "

   548                                 "an entity - escape ampersand as &"));

   549         }

   550     }

   551 #undef MAX_ENT_LEN

   552 

   553   return p;

   554 }

   555 

   556 static const gchar*

   557 unescape_text_state_after_charref_hash (UnescapeContext *ucontext,

   558                                         const gchar     *p,

   559                                         GError         **error)

   560 {

   561   gboolean is_hex = FALSE;

   562   const char *start;

   563 

   564   start = ucontext->entity_start;

   565 

   566   if (*p == 'x')

   567     {

   568       is_hex = TRUE;

   569       p = g_utf8_next_char (p);

   570       start = p;

   571     }

   572 

   573   while (p != ucontext->text_end && *p != ';')

   574     p = g_utf8_next_char (p);

   575 

   576   if (p != ucontext->text_end)

   577     {

   578       g_assert (*p == ';');

   579 

   580       /* digit is between start and p */

   581 

   582       if (start != p)

   583         {

   584           gulong l;

   585           gchar *end = NULL;

   586                     

   587           errno = 0;

   588           if (is_hex)

   589             l = strtoul (start, &end, 16);

   590           else

   591             l = strtoul (start, &end, 10);

   592 

   593           if (end != p || errno != 0)

   594             {

   595               set_unescape_error (ucontext->context, error,

   596                                   start, ucontext->text_end,

   597                                   G_MARKUP_ERROR_PARSE,

   598                                   _("Failed to parse '%-.*s', which "

   599                                     "should have been a digit "

   600                                     "inside a character reference "

   601                                     "(ê for example) - perhaps "

   602                                     "the digit is too large"),

   603                                   p - start, start);

   604             }

   605           else

   606             {

   607               /* characters XML permits */

   608               if (l == 0x9 ||

   609                   l == 0xA ||

   610                   l == 0xD ||

   611                   (l >= 0x20 && l <= 0xD7FF) ||

   612                   (l >= 0xE000 && l <= 0xFFFD) ||

   613                   (l >= 0x10000 && l <= 0x10FFFF))

   614                 {

   615                   gchar buf[8];

   616                   g_string_append (ucontext->str, char_str (l, buf));

   617                 }

   618               else

   619                 {

   620                   set_unescape_error (ucontext->context, error,

   621                                       start, ucontext->text_end,

   622                                       G_MARKUP_ERROR_PARSE,

   623                                       _("Character reference '%-.*s' does not "

   624 					"encode a permitted character"),

   625                                       p - start, start);

   626                 }

   627             }

   628 

   629           /* Move to next state */

   630           p = g_utf8_next_char (p); /* past semicolon */

   631           ucontext->state = USTATE_INSIDE_TEXT;

   632         }

   633       else

   634         {

   635           set_unescape_error (ucontext->context, error,

   636                               start, ucontext->text_end,

   637                               G_MARKUP_ERROR_PARSE,

   638                               _("Empty character reference; "

   639                                 "should include a digit such as "

   640                                 "dž"));

   641         }

   642     }

   643   else

   644     {

   645       set_unescape_error (ucontext->context, error,

   646                           start, ucontext->text_end,

   647                           G_MARKUP_ERROR_PARSE,

   648                           _("Character reference did not end with a "

   649                             "semicolon; "

   650                             "most likely you used an ampersand "

   651                             "character without intending to start "

   652                             "an entity - escape ampersand as &"));

   653     }

   654 

   655   return p;

   656 }

   657 

   658 static gboolean

   659 unescape_text (GMarkupParseContext *context,

   660                const gchar         *text,

   661                const gchar         *text_end,

   662                GString            **unescaped,

   663                GError             **error)

   664 {

   665   UnescapeContext ucontext;

   666   const gchar *p;

   667 

   668   ucontext.context = context;

   669   ucontext.text = text;

   670   ucontext.text_end = text_end;

   671   ucontext.entity_start = NULL;

   672   

   673   ucontext.str = g_string_sized_new (text_end - text);

   674 

   675   ucontext.state = USTATE_INSIDE_TEXT;

   676   p = text;

   677 

   678   while (p != text_end && context->state != STATE_ERROR)

   679     {

   680       g_assert (p < text_end);

   681       

   682       switch (ucontext.state)

   683         {

   684         case USTATE_INSIDE_TEXT:

   685           {

   686             p = unescape_text_state_inside_text (&ucontext,

   687                                                  p,

   688                                                  error);

   689           }

   690           break;

   691 

   692         case USTATE_AFTER_AMPERSAND:

   693           {

   694             p = unescape_text_state_after_ampersand (&ucontext,

   695                                                      p,

   696                                                      error);

   697           }

   698           break;

   699 

   700 

   701         case USTATE_INSIDE_ENTITY_NAME:

   702           {

   703             p = unescape_text_state_inside_entity_name (&ucontext,

   704                                                         p,

   705                                                         error);

   706           }

   707           break;

   708 

   709         case USTATE_AFTER_CHARREF_HASH:

   710           {

   711             p = unescape_text_state_after_charref_hash (&ucontext,

   712                                                         p,

   713                                                         error);

   714           }

   715           break;

   716 

   717         default:

   718           g_assert_not_reached ();

   719           break;

   720         }

   721     }

   722 

   723   if (context->state != STATE_ERROR) 

   724     {

   725       switch (ucontext.state) 

   726 	{

   727 	case USTATE_INSIDE_TEXT:

   728 	  break;

   729 	case USTATE_AFTER_AMPERSAND:

   730 	case USTATE_INSIDE_ENTITY_NAME:

   731 	  set_unescape_error (context, error,

   732 			      NULL, NULL,

   733 			      G_MARKUP_ERROR_PARSE,

   734 			      _("Unfinished entity reference"));

   735 	  break;

   736 	case USTATE_AFTER_CHARREF_HASH:

   737 	  set_unescape_error (context, error,

   738 			      NULL, NULL,

   739 			      G_MARKUP_ERROR_PARSE,

   740 			      _("Unfinished character reference"));

   741 	  break;

   742 	}

   743     }

   744 

   745   if (context->state == STATE_ERROR)

   746     {

   747       g_string_free (ucontext.str, TRUE);

   748       *unescaped = NULL;

   749       return FALSE;

   750     }

   751   else

   752     {

   753       *unescaped = ucontext.str;

   754       return TRUE;

   755     }

   756 }

   757 

   758 static inline gboolean

   759 advance_char (GMarkupParseContext *context)

   760 {  

   761   context->iter = g_utf8_next_char (context->iter);

   762   context->char_number += 1;

   763 

   764   if (context->iter == context->current_text_end)

   765     {

   766       return FALSE;

   767     }

   768   else if (*context->iter == '\n')

   769     {

   770       context->line_number += 1;

   771       context->char_number = 1;

   772     }

   773   

   774   return TRUE;

   775 }

   776 

   777 static inline gboolean

   778 xml_isspace (char c)

   779 {

   780   return c == ' ' || c == '\t' || c == '\n' || c == '\r';

   781 }

   782 

   783 static void

   784 skip_spaces (GMarkupParseContext *context)

   785 {

   786   do

   787     {

   788       if (!xml_isspace (*context->iter))

   789         return;

   790     }

   791   while (advance_char (context));

   792 }

   793 

   794 static void

   795 advance_to_name_end (GMarkupParseContext *context)

   796 {

   797   do

   798     {

   799       if (!is_name_char (context->iter))

   800         return;

   801     }

   802   while (advance_char (context));

   803 }

   804 

   805 static void

   806 add_to_partial (GMarkupParseContext *context,

   807                 const gchar         *text_start,

   808                 const gchar         *text_end)

   809 {

   810   if (context->partial_chunk == NULL)

   811     context->partial_chunk = g_string_sized_new (text_end - text_start);

   812 

   813   if (text_start != text_end)

   814     g_string_append_len (context->partial_chunk, text_start,

   815                          text_end - text_start);

   816 

   817   /* Invariant here that partial_chunk exists */

   818 }

   819 

   820 static void

   821 truncate_partial (GMarkupParseContext *context)

   822 {

   823   if (context->partial_chunk != NULL)

   824     {

   825       context->partial_chunk = g_string_truncate (context->partial_chunk, 0);

   826     }

   827 }

   828 

   829 static const gchar*

   830 current_element (GMarkupParseContext *context)

   831 {

   832   return context->tag_stack->data;

   833 }

   834 

   835 static const gchar*

   836 current_attribute (GMarkupParseContext *context)

   837 {

   838   g_assert (context->cur_attr >= 0);

   839   return context->attr_names[context->cur_attr];

   840 }

   841 

   842 static void

   843 find_current_text_end (GMarkupParseContext *context)

   844 {

   845   /* This function must be safe (non-segfaulting) on invalid UTF8.

   846    * It assumes the string starts with a character start

   847    */

   848   const gchar *end = context->current_text + context->current_text_len;

   849   const gchar *p;

   850   const gchar *next;

   851 

   852   g_assert (context->current_text_len > 0);

   853 

   854   p = g_utf8_find_prev_char (context->current_text, end);

   855 

   856   g_assert (p != NULL); /* since current_text was a char start */

   857 

   858   /* p is now the start of the last character or character portion. */

   859   g_assert (p != end);

   860   next = g_utf8_next_char (p); /* this only touches *p, nothing beyond */

   861 

   862   if (next == end)

   863     {

   864       /* whole character */

   865       context->current_text_end = end;

   866     }

   867   else

   868     {

   869       /* portion */

   870       context->leftover_char_portion = g_string_new_len (p, end - p);

   871       context->current_text_len -= (end - p);

   872       context->current_text_end = p;

   873     }

   874 }

   875 

   876 

   877 static void

   878 add_attribute (GMarkupParseContext *context, char *name)

   879 {

   880   if (context->cur_attr + 2 >= context->alloc_attrs)

   881     {

   882       context->alloc_attrs += 5; /* silly magic number */

   883       context->attr_names = g_realloc (context->attr_names, sizeof(char*)*context->alloc_attrs);

   884       context->attr_values = g_realloc (context->attr_values, sizeof(char*)*context->alloc_attrs);         

   885     }

   886   context->cur_attr++;

   887   context->attr_names[context->cur_attr] = name;

   888   context->attr_values[context->cur_attr] = NULL;

   889   context->attr_names[context->cur_attr+1] = NULL;

   890   context->attr_values[context->cur_attr+1] = NULL;

   891 }

   892 

   893 /**

   894  * g_markup_parse_context_parse:

   895  * @context: a #GMarkupParseContext

   896  * @text: chunk of text to parse

   897  * @text_len: length of @text in bytes

   898  * @error: return location for a #GError

   899  * 

   900  * Feed some data to the #GMarkupParseContext. The data need not

   901  * be valid UTF-8; an error will be signaled if it's invalid.

   902  * The data need not be an entire document; you can feed a document

   903  * into the parser incrementally, via multiple calls to this function.

   904  * Typically, as you receive data from a network connection or file,

   905  * you feed each received chunk of data into this function, aborting

   906  * the process if an error occurs. Once an error is reported, no further

   907  * data may be fed to the #GMarkupParseContext; all errors are fatal.

   908  * 

   909  * Return value: %FALSE if an error occurred, %TRUE on success

   910  **/

   911 EXPORT_C gboolean

   912 g_markup_parse_context_parse (GMarkupParseContext *context,

   913                               const gchar         *text,

   914                               gssize               text_len,

   915                               GError             **error)

   916 {

   917   const gchar *first_invalid;

   918   

   919   g_return_val_if_fail (context != NULL, FALSE);

   920   g_return_val_if_fail (text != NULL, FALSE);

   921   g_return_val_if_fail (context->state != STATE_ERROR, FALSE);

   922   g_return_val_if_fail (!context->parsing, FALSE);

   923   

   924   if (text_len < 0)

   925     text_len = strlen (text);

   926 

   927   if (text_len == 0)

   928     return TRUE;

   929   

   930   context->parsing = TRUE;

   931   

   932   if (context->leftover_char_portion)

   933     {

   934       const gchar *first_char;

   935 

   936       if ((*text & 0xc0) != 0x80)

   937         first_char = text;

   938       else

   939         first_char = g_utf8_find_next_char (text, text + text_len);

   940 

   941       if (first_char)

   942         {

   943           /* leftover_char_portion was completed. Parse it. */

   944           GString *portion = context->leftover_char_portion;

   945           

   946           g_string_append_len (context->leftover_char_portion,

   947                                text, first_char - text);

   948 

   949           /* hacks to allow recursion */

   950           context->parsing = FALSE;

   951           context->leftover_char_portion = NULL;

   952           

   953           if (!g_markup_parse_context_parse (context,

   954                                              portion->str, portion->len,

   955                                              error))

   956             {

   957               g_assert (context->state == STATE_ERROR);

   958             }

   959           

   960           g_string_free (portion, TRUE);

   961           context->parsing = TRUE;

   962 

   963           /* Skip the fraction of char that was in this text */

   964           text_len -= (first_char - text);

   965           text = first_char;

   966         }

   967       else

   968         {

   969           /* another little chunk of the leftover char; geez

   970            * someone is inefficient.

   971            */

   972           g_string_append_len (context->leftover_char_portion,

   973                                text, text_len);

   974 

   975           if (context->leftover_char_portion->len > 7)

   976             {

   977               /* The leftover char portion is too big to be

   978                * a UTF-8 character

   979                */

   980               set_error (context,

   981                          error,

   982                          G_MARKUP_ERROR_BAD_UTF8,

   983                          _("Invalid UTF-8 encoded text"));

   984             }

   985           

   986           goto finished;

   987         }

   988     }

   989 

   990   context->current_text = text;

   991   context->current_text_len = text_len;

   992   context->iter = context->current_text;

   993   context->start = context->iter;

   994 

   995   /* Nothing left after finishing the leftover char, or nothing

   996    * passed in to begin with.

   997    */

   998   if (context->current_text_len == 0)

   999     goto finished;

  1000 

  1001   /* find_current_text_end () assumes the string starts at

  1002    * a character start, so we need to validate at least

  1003    * that much. It doesn't assume any following bytes

  1004    * are valid.

  1005    */

  1006   if ((*context->current_text & 0xc0) == 0x80) /* not a char start */

  1007     {

  1008       set_error (context,

  1009                  error,

  1010                  G_MARKUP_ERROR_BAD_UTF8,

  1011                  _("Invalid UTF-8 encoded text"));

  1012       goto finished;

  1013     }

  1014 

  1015   /* Initialize context->current_text_end, possibly adjusting

  1016    * current_text_len, and add any leftover char portion

  1017    */

  1018   find_current_text_end (context);

  1019 

  1020   /* Validate UTF8 (must be done after we find the end, since

  1021    * we could have a trailing incomplete char)

  1022    */

  1023   if (!g_utf8_validate (context->current_text,

  1024 			context->current_text_len,

  1025 			&first_invalid))

  1026     {

  1027       gint newlines = 0;

  1028       const gchar *p;

  1029       p = context->current_text;

  1030       while (p != context->current_text_end)

  1031         {

  1032           if (*p == '\n')

  1033             ++newlines;

  1034           ++p;

  1035         }

  1036 

  1037       context->line_number += newlines;

  1038 

  1039       set_error (context,

  1040                  error,

  1041                  G_MARKUP_ERROR_BAD_UTF8,

  1042                  _("Invalid UTF-8 encoded text"));

  1043       goto finished;

  1044     }

  1045 

  1046   while (context->iter != context->current_text_end)

  1047     {

  1048       switch (context->state)

  1049         {

  1050         case STATE_START:

  1051           /* Possible next state: AFTER_OPEN_ANGLE */

  1052 

  1053           g_assert (context->tag_stack == NULL);

  1054 

  1055           /* whitespace is ignored outside of any elements */

  1056           skip_spaces (context);

  1057 

  1058           if (context->iter != context->current_text_end)

  1059             {

  1060               if (*context->iter == '<')

  1061                 {

  1062                   /* Move after the open angle */

  1063                   advance_char (context);

  1064 

  1065                   context->state = STATE_AFTER_OPEN_ANGLE;

  1066 

  1067                   /* this could start a passthrough */

  1068                   context->start = context->iter;

  1069 

  1070                   /* document is now non-empty */

  1071                   context->document_empty = FALSE;

  1072                 }

  1073               else

  1074                 {

  1075                   set_error (context,

  1076                              error,

  1077                              G_MARKUP_ERROR_PARSE,

  1078                              _("Document must begin with an element (e.g. <book>)"));

  1079                 }

  1080             }

  1081           break;

  1082 

  1083         case STATE_AFTER_OPEN_ANGLE:

  1084           /* Possible next states: INSIDE_OPEN_TAG_NAME,

  1085            *  AFTER_CLOSE_TAG_SLASH, INSIDE_PASSTHROUGH

  1086            */

  1087           if (*context->iter == '?' ||

  1088               *context->iter == '!')

  1089             {

  1090               /* include < in the passthrough */

  1091               const gchar *openangle = "<";

  1092               add_to_partial (context, openangle, openangle + 1);

  1093               context->start = context->iter;

  1094 	      context->balance = 1;

  1095               context->state = STATE_INSIDE_PASSTHROUGH;

  1096             }

  1097           else if (*context->iter == '/')

  1098             {

  1099               /* move after it */

  1100               advance_char (context);

  1101 

  1102               context->state = STATE_AFTER_CLOSE_TAG_SLASH;

  1103             }

  1104           else if (is_name_start_char (context->iter))

  1105             {

  1106               context->state = STATE_INSIDE_OPEN_TAG_NAME;

  1107 

  1108               /* start of tag name */

  1109               context->start = context->iter;

  1110             }

  1111           else

  1112             {

  1113               gchar buf[8];

  1114 

  1115               set_error (context,

  1116                          error,

  1117                          G_MARKUP_ERROR_PARSE,

  1118                          _("'%s' is not a valid character following "

  1119                            "a '<' character; it may not begin an "

  1120                            "element name"),

  1121                          utf8_str (context->iter, buf));

  1122             }

  1123           break;

  1124 

  1125           /* The AFTER_CLOSE_ANGLE state is actually sort of

  1126            * broken, because it doesn't correspond to a range

  1127            * of characters in the input stream as the others do,

  1128            * and thus makes things harder to conceptualize

  1129            */

  1130         case STATE_AFTER_CLOSE_ANGLE:

  1131           /* Possible next states: INSIDE_TEXT, STATE_START */

  1132           if (context->tag_stack == NULL)

  1133             {

  1134               context->start = NULL;