1 /* gmarkup.c - Simple XML-like parser
3 * Copyright 2000 Red Hat, Inc.
5 * GLib is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU Lesser General Public License as
7 * published by the Free Software Foundation; either version 2 of the
8 * License, or (at your option) any later version.
10 * GLib is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with GLib; see the file COPYING.LIB. If not,
17 * write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18 * Boston, MA 02111-1307, USA.
31 g_markup_error_quark ()
33 static GQuark error_quark = 0;
36 error_quark = g_quark_from_static_string ("g-markup-error-quark");
44 STATE_AFTER_OPEN_ANGLE,
45 STATE_AFTER_CLOSE_ANGLE,
46 STATE_AFTER_ELISION_SLASH, /* the slash that obviates need for end element */
47 STATE_INSIDE_OPEN_TAG_NAME,
48 STATE_INSIDE_ATTRIBUTE_NAME,
49 STATE_BETWEEN_ATTRIBUTES,
50 STATE_AFTER_ATTRIBUTE_EQUALS_SIGN,
51 STATE_INSIDE_ATTRIBUTE_VALUE,
53 STATE_AFTER_CLOSE_TAG_SLASH,
54 STATE_INSIDE_CLOSE_TAG_NAME,
55 STATE_INSIDE_PASSTHROUGH,
59 struct _GMarkupParseContext
61 const GMarkupParser *parser;
63 GMarkupParseFlags flags;
69 GDestroyNotify dnotify;
71 /* A piece of character data or an element that
72 * hasn't "ended" yet so we haven't yet called
73 * the callback for it.
75 GString *partial_chunk;
77 GMarkupParseState state;
84 const gchar *current_text;
85 gssize current_text_len;
86 const gchar *current_text_end;
88 GString *leftover_char_portion;
90 /* used to save the start of the last interesting thingy */
95 guint document_empty : 1;
100 * g_markup_parse_context_new:
101 * @parser: a #GMarkupParser
102 * @flags: one or more #GMarkupParseFlags
103 * @user_data: user data to pass to #GMarkupParser functions
104 * @user_data_dnotify: user data destroy notifier called when the parse context is freed
106 * Creates a new parse context. A parse context is used to parse
107 * marked-up documents. You can feed any number of documents into
108 * a context, as long as no errors occur; once an error occurs,
109 * the parse context can't continue to parse text (you have to free it
110 * and create a new parse context).
112 * Return value: a new #GMarkupParseContext
114 GMarkupParseContext *
115 g_markup_parse_context_new (const GMarkupParser *parser,
116 GMarkupParseFlags flags,
118 GDestroyNotify user_data_dnotify)
120 GMarkupParseContext *context;
122 g_return_val_if_fail (parser != NULL, NULL);
124 context = g_new (GMarkupParseContext, 1);
126 context->parser = parser;
127 context->flags = flags;
128 context->user_data = user_data;
129 context->dnotify = user_data_dnotify;
131 context->line_number = 1;
132 context->char_number = 1;
134 context->partial_chunk = NULL;
136 context->state = STATE_START;
137 context->tag_stack = NULL;
138 context->attr_names = NULL;
139 context->attr_values = NULL;
140 context->cur_attr = -1;
141 context->alloc_attrs = 0;
143 context->current_text = NULL;
144 context->current_text_len = -1;
145 context->current_text_end = NULL;
146 context->leftover_char_portion = NULL;
148 context->start = NULL;
149 context->iter = NULL;
151 context->document_empty = TRUE;
152 context->parsing = FALSE;
158 * g_markup_parse_context_free:
159 * @context: a #GMarkupParseContext
161 * Frees a #GMarkupParseContext. Can't be called from inside
162 * one of the #GMarkupParser functions.
166 g_markup_parse_context_free (GMarkupParseContext *context)
168 g_return_if_fail (context != NULL);
169 g_return_if_fail (!context->parsing);
171 if (context->dnotify)
172 (* context->dnotify) (context->user_data);
174 g_strfreev (context->attr_names);
175 g_strfreev (context->attr_values);
177 g_slist_foreach (context->tag_stack, (GFunc)g_free, NULL);
178 g_slist_free (context->tag_stack);
180 if (context->partial_chunk)
181 g_string_free (context->partial_chunk, TRUE);
183 if (context->leftover_char_portion)
184 g_string_free (context->leftover_char_portion, TRUE);
190 mark_error (GMarkupParseContext *context,
193 context->state = STATE_ERROR;
195 if (context->parser->error)
196 (*context->parser->error) (context, error, context->user_data);
200 set_error (GMarkupParseContext *context,
210 va_start (args, format);
211 s = g_strdup_vprintf (format, args);
214 tmp_error = g_error_new (G_MARKUP_ERROR,
216 _("Error on line %d char %d: %s"),
217 context->line_number,
218 context->char_number,
223 mark_error (context, tmp_error);
225 g_propagate_error (error, tmp_error);
229 is_name_start_char (gunichar c)
231 if (g_unichar_isalpha (c) ||
240 is_name_char (gunichar c)
242 if (g_unichar_isalnum (c) ||
254 char_str (gunichar c,
258 g_unichar_to_utf8 (c, buf);
263 utf8_str (const gchar *utf8,
266 char_str (g_utf8_get_char (utf8), buf);
271 set_unescape_error (GMarkupParseContext *context,
273 const gchar *remaining_text,
274 const gchar *remaining_text_end,
282 gint remaining_newlines;
285 remaining_newlines = 0;
287 while (p != remaining_text_end)
290 ++remaining_newlines;
294 va_start (args, format);
295 s = g_strdup_vprintf (format, args);
298 tmp_error = g_error_new (G_MARKUP_ERROR,
300 _("Error on line %d: %s"),
301 context->line_number - remaining_newlines,
306 mark_error (context, tmp_error);
308 g_propagate_error (error, tmp_error);
314 USTATE_AFTER_AMPERSAND,
315 USTATE_INSIDE_ENTITY_NAME,
316 USTATE_AFTER_CHARREF_HASH
320 unescape_text (GMarkupParseContext *context,
322 const gchar *text_end,
326 #define MAX_ENT_LEN 5
332 str = g_string_new ("");
334 state = USTATE_INSIDE_TEXT;
337 while (p != text_end && context->state != STATE_ERROR)
339 g_assert (p < text_end);
343 case USTATE_INSIDE_TEXT:
345 while (p != text_end && *p != '&')
346 p = g_utf8_next_char (p);
350 g_string_append_len (str, start, p - start);
355 if (p != text_end && *p == '&')
357 p = g_utf8_next_char (p);
358 state = USTATE_AFTER_AMPERSAND;
363 case USTATE_AFTER_AMPERSAND:
367 p = g_utf8_next_char (p);
370 state = USTATE_AFTER_CHARREF_HASH;
372 else if (!is_name_start_char (g_utf8_get_char (p)))
376 set_unescape_error (context, error,
378 G_MARKUP_ERROR_PARSE,
379 _("Empty entity '&;' seen; valid "
380 "entities are: & " < > '"));
386 set_unescape_error (context, error,
388 G_MARKUP_ERROR_PARSE,
389 _("Character '%s' is not valid at "
390 "the start of an entity name; "
391 "the & character begins an entity; "
392 "if this ampersand isn't supposed "
393 "to be an entity, escape it as "
401 state = USTATE_INSIDE_ENTITY_NAME;
407 case USTATE_INSIDE_ENTITY_NAME:
409 gchar buf[MAX_ENT_LEN+1] = {
410 '\0', '\0', '\0', '\0', '\0', '\0'
414 while (p != text_end)
418 else if (!is_name_char (*p))
422 set_unescape_error (context, error,
424 G_MARKUP_ERROR_PARSE,
425 _("Character '%s' is not valid "
426 "inside an entity name"),
431 p = g_utf8_next_char (p);
434 if (context->state != STATE_ERROR)
449 /* move to after semicolon */
450 p = g_utf8_next_char (p);
452 state = USTATE_INSIDE_TEXT;
454 if (strcmp (buf, "lt") == 0)
455 g_string_append_c (str, '<');
456 else if (strcmp (buf, "gt") == 0)
457 g_string_append_c (str, '>');
458 else if (strcmp (buf, "amp") == 0)
459 g_string_append_c (str, '&');
460 else if (strcmp (buf, "quot") == 0)
461 g_string_append_c (str, '"');
462 else if (strcmp (buf, "apos") == 0)
463 g_string_append_c (str, '\'');
466 set_unescape_error (context, error,
468 G_MARKUP_ERROR_PARSE,
469 _("Entity name '%s' is not known"),
475 set_unescape_error (context, error,
476 /* give line number of the & */
478 G_MARKUP_ERROR_PARSE,
479 _("Entity did not end with a semicolon; "
480 "most likely you used an ampersand "
481 "character without intending to start "
482 "an entity - escape ampersand as &"));
488 case USTATE_AFTER_CHARREF_HASH:
490 gboolean is_hex = FALSE;
494 p = g_utf8_next_char (p);
498 while (p != text_end && *p != ';')
499 p = g_utf8_next_char (p);
503 g_assert (*p == ';');
505 /* digit is between start and p */
509 gchar *digit = g_strndup (start, p - start);
512 gchar *digit_end = digit + (p - start);
516 l = strtoul (digit, &end, 16);
518 l = strtoul (digit, &end, 10);
520 if (end != digit_end || errno != 0)
522 set_unescape_error (context, error,
524 G_MARKUP_ERROR_PARSE,
525 _("Failed to parse '%s', which "
526 "should have been a digit "
527 "inside a character reference "
528 "(ê for example) - perhaps "
529 "the digit is too large"),
534 /* characters XML permits */
538 (l >= 0x20 && l <= 0xD7FF) ||
539 (l >= 0xE000 && l <= 0xFFFD) ||
540 (l >= 0x10000 && l <= 0x10FFFF))
543 g_string_append (str, char_str (l, buf));
547 set_unescape_error (context, error,
549 G_MARKUP_ERROR_PARSE,
550 _("Character reference '%s' does not encode a permitted character"),
557 /* Move to next state */
558 p = g_utf8_next_char (p); /* past semicolon */
560 state = USTATE_INSIDE_TEXT;
564 set_unescape_error (context, error,
566 G_MARKUP_ERROR_PARSE,
567 _("Empty character reference; "
568 "should include a digit such as "
574 set_unescape_error (context, error,
576 G_MARKUP_ERROR_PARSE,
577 _("Character reference did not end with a "
579 "most likely you used an ampersand "
580 "character without intending to start "
581 "an entity - escape ampersand as &"));
587 g_assert_not_reached ();
592 /* If no errors, we should have returned to USTATE_INSIDE_TEXT */
593 g_assert (context->state == STATE_ERROR ||
594 state == USTATE_INSIDE_TEXT);
596 if (context->state == STATE_ERROR)
598 g_string_free (str, TRUE);
604 *unescaped = g_string_free (str, FALSE);
612 advance_char (GMarkupParseContext *context)
615 context->iter = g_utf8_next_char (context->iter);
616 context->char_number += 1;
617 if (*context->iter == '\n')
619 context->line_number += 1;
620 context->char_number = 1;
623 return context->iter != context->current_text_end;
627 skip_spaces (GMarkupParseContext *context)
631 if (!g_unichar_isspace (g_utf8_get_char (context->iter)))
634 while (advance_char (context));
638 advance_to_name_end (GMarkupParseContext *context)
642 if (!is_name_char (g_utf8_get_char (context->iter)))
645 while (advance_char (context));
649 add_to_partial (GMarkupParseContext *context,
650 const gchar *text_start,
651 const gchar *text_end)
653 if (context->partial_chunk == NULL)
654 context->partial_chunk = g_string_new ("");
656 if (text_start != text_end)
657 g_string_append_len (context->partial_chunk, text_start,
658 text_end - text_start);
660 /* Invariant here that partial_chunk exists */
664 truncate_partial (GMarkupParseContext *context)
666 if (context->partial_chunk != NULL)
668 context->partial_chunk = g_string_truncate (context->partial_chunk, 0);
673 current_element (GMarkupParseContext *context)
675 return context->tag_stack->data;
679 current_attribute (GMarkupParseContext *context)
681 g_assert (context->cur_attr >= 0);
682 return context->attr_names[context->cur_attr];
686 find_current_text_end (GMarkupParseContext *context)
688 /* This function must be safe (non-segfaulting) on invalid UTF8 */
689 const gchar *end = context->current_text + context->current_text_len;
693 g_assert (context->current_text_len > 0);
695 p = context->current_text;
696 next = g_utf8_find_next_char (p, end);
701 next = g_utf8_find_next_char (p, end);
704 /* p is now the start of the last character or character portion. */
706 next = g_utf8_next_char (p); /* this only touches *p, nothing beyond */
710 /* whole character */
711 context->current_text_end = end;
716 context->leftover_char_portion = g_string_new_len (p, end - p);
717 context->current_text_len -= (end - p);
718 context->current_text_end = p;
723 add_attribute (GMarkupParseContext *context, char *name)
725 if (context->cur_attr + 2 >= context->alloc_attrs)
727 context->alloc_attrs += 5; /* silly magic number */
728 context->attr_names = g_realloc (context->attr_names, sizeof(char*)*context->alloc_attrs);
729 context->attr_values = g_realloc (context->attr_values, sizeof(char*)*context->alloc_attrs);
732 context->attr_names[context->cur_attr] = name;
733 context->attr_values[context->cur_attr] = NULL;
734 context->attr_names[context->cur_attr+1] = NULL;
738 * g_markup_parse_context_parse:
739 * @context: a #GMarkupParseContext
740 * @text: chunk of text to parse
741 * @text_len: length of @text in bytes
742 * @error: return location for a #GError
744 * Feed some data to the #GMarkupParseContext. The data need not
745 * be valid UTF-8; an error will be signaled if it's invalid.
746 * The data need not be an entire document; you can feed a document
747 * into the parser incrementally, via multiple calls to this function.
748 * Typically, as you receive data from a network connection or file,
749 * you feed each received chunk of data into this function, aborting
750 * the process if an error occurs. Once an error is reported, no further
751 * data may be fed to the #GMarkupParseContext; all errors are fatal.
753 * Return value: %FALSE if an error occurred, %TRUE on success
756 g_markup_parse_context_parse (GMarkupParseContext *context,
761 const gchar *first_invalid;
763 g_return_val_if_fail (context != NULL, FALSE);
764 g_return_val_if_fail (text != NULL, FALSE);
765 g_return_val_if_fail (context->state != STATE_ERROR, FALSE);
766 g_return_val_if_fail (!context->parsing, FALSE);
769 text_len = strlen (text);
774 context->parsing = TRUE;
776 if (context->leftover_char_portion)
778 const gchar *first_char;
780 if ((*text & 0xc0) != 0x80)
783 first_char = g_utf8_find_next_char (text, text + text_len);
787 /* leftover_char_portion was completed. Parse it. */
788 GString *portion = context->leftover_char_portion;
790 g_string_append_len (context->leftover_char_portion,
791 text, first_char - text);
793 /* hacks to allow recursion */
794 context->parsing = FALSE;
795 context->leftover_char_portion = NULL;
797 if (!g_markup_parse_context_parse (context,
798 portion->str, portion->len,
801 g_assert (context->state == STATE_ERROR);
804 g_string_free (portion, TRUE);
805 context->parsing = TRUE;
807 /* Skip the fraction of char that was in this text */
808 text_len -= (first_char - text);
813 /* another little chunk of the leftover char; geez
814 * someone is inefficient.
816 g_string_append_len (context->leftover_char_portion,
819 if (context->leftover_char_portion->len > 7)
821 /* The leftover char portion is too big to be
826 G_MARKUP_ERROR_BAD_UTF8,
827 _("Invalid UTF-8 encoded text"));
834 context->current_text = text;
835 context->current_text_len = text_len;
836 context->iter = context->current_text;
837 context->start = context->iter;
839 /* Nothing left after finishing the leftover char, or nothing
840 * passed in to begin with.
842 if (context->current_text_len == 0)
845 /* find_current_text_end () assumes the string starts at
846 * a character start, so we need to validate at least
847 * that much. It doesn't assume any following bytes
850 if ((*context->current_text & 0xc0) == 0x80) /* not a char start */
854 G_MARKUP_ERROR_BAD_UTF8,
855 _("Invalid UTF-8 encoded text"));
859 /* Initialize context->current_text_end, possibly adjusting
860 * current_text_len, and add any leftover char portion
862 find_current_text_end (context);
864 /* Validate UTF8 (must be done after we find the end, since
865 * we could have a trailing incomplete char)
867 if (!g_utf8_validate (context->current_text,
868 context->current_text_len,
873 p = context->current_text;
874 while (p != context->current_text_end)
881 context->line_number += newlines;
885 G_MARKUP_ERROR_BAD_UTF8,
886 _("Invalid UTF-8 encoded text"));
890 while (context->iter != context->current_text_end)
892 switch (context->state)
895 /* Possible next state: AFTER_OPEN_ANGLE */
897 g_assert (context->tag_stack == NULL);
899 /* whitespace is ignored outside of any elements */
900 skip_spaces (context);
902 if (context->iter != context->current_text_end)
904 if (*context->iter == '<')
906 /* Move after the open angle */
907 advance_char (context);
909 context->state = STATE_AFTER_OPEN_ANGLE;
911 /* this could start a passthrough */
912 context->start = context->iter;
914 /* document is now non-empty */
915 context->document_empty = FALSE;
921 G_MARKUP_ERROR_PARSE,
922 _("Document must begin with an element (e.g. <book>)"));
927 case STATE_AFTER_OPEN_ANGLE:
928 /* Possible next states: INSIDE_OPEN_TAG_NAME,
929 * AFTER_CLOSE_TAG_SLASH, INSIDE_PASSTHROUGH
931 if (*context->iter == '?' ||
932 *context->iter == '!')
934 /* include < in the passthrough */
935 const gchar *openangle = "<";
936 add_to_partial (context, openangle, openangle + 1);
937 context->start = context->iter;
938 context->state = STATE_INSIDE_PASSTHROUGH;
940 else if (*context->iter == '/')
943 advance_char (context);
945 context->state = STATE_AFTER_CLOSE_TAG_SLASH;
947 else if (is_name_start_char (g_utf8_get_char (context->iter)))
949 context->state = STATE_INSIDE_OPEN_TAG_NAME;
951 /* start of tag name */
952 context->start = context->iter;
959 G_MARKUP_ERROR_PARSE,
960 _("'%s' is not a valid character following "
961 "a '<' character; it may not begin an "
963 utf8_str (context->iter, buf));
967 /* The AFTER_CLOSE_ANGLE state is actually sort of
968 * broken, because it doesn't correspond to a range
969 * of characters in the input stream as the others do,
970 * and thus makes things harder to conceptualize
972 case STATE_AFTER_CLOSE_ANGLE:
973 /* Possible next states: INSIDE_TEXT, STATE_START */
974 if (context->tag_stack == NULL)
976 context->start = NULL;
977 context->state = STATE_START;
981 context->start = context->iter;
982 context->state = STATE_INSIDE_TEXT;
986 case STATE_AFTER_ELISION_SLASH:
987 /* Possible next state: AFTER_CLOSE_ANGLE */
990 /* We need to pop the tag stack and call the end_element
991 * function, since this is the close tag
993 GError *tmp_error = NULL;
995 g_assert (context->tag_stack != NULL);
998 if (context->parser->end_element)
999 (* context->parser->end_element) (context,
1000 context->tag_stack->data,
1006 mark_error (context, tmp_error);
1007 g_propagate_error (error, tmp_error);
1011 if (*context->iter == '>')
1013 /* move after the close angle */
1014 advance_char (context);
1015 context->state = STATE_AFTER_CLOSE_ANGLE;
1022 G_MARKUP_ERROR_PARSE,
1023 _("Odd character '%s', expected a '>' character "
1024 "to end the start tag of element '%s'"),
1025 utf8_str (context->iter, buf),
1026 current_element (context));
1030 g_free (context->tag_stack->data);
1031 context->tag_stack = g_slist_delete_link (context->tag_stack,
1032 context->tag_stack);
1036 case STATE_INSIDE_OPEN_TAG_NAME:
1037 /* Possible next states: BETWEEN_ATTRIBUTES */
1039 /* if there's a partial chunk then it's the first part of the
1040 * tag name. If there's a context->start then it's the start
1041 * of the tag name in current_text, the partial chunk goes
1042 * before that start though.
1044 advance_to_name_end (context);
1046 if (context->iter == context->current_text_end)
1048 /* The name hasn't necessarily ended. Merge with
1049 * partial chunk, leave state unchanged.
1051 add_to_partial (context, context->start, context->iter);
1055 /* The name has ended. Combine it with the partial chunk
1056 * if any; push it on the stack; enter next state.
1058 add_to_partial (context, context->start, context->iter);
1059 context->tag_stack =
1060 g_slist_prepend (context->tag_stack,
1061 g_string_free (context->partial_chunk,
1064 context->partial_chunk = NULL;
1066 context->state = STATE_BETWEEN_ATTRIBUTES;
1067 context->start = NULL;
1071 case STATE_INSIDE_ATTRIBUTE_NAME:
1072 /* Possible next states: AFTER_ATTRIBUTE_EQUALS_SIGN */
1074 /* read the full name, if we enter the equals sign state
1075 * then add the attribute to the list (without the value),
1076 * otherwise store a partial chunk to be prepended later.
1078 advance_to_name_end (context);
1080 if (context->iter == context->current_text_end)
1082 /* The name hasn't necessarily ended. Merge with
1083 * partial chunk, leave state unchanged.
1085 add_to_partial (context, context->start, context->iter);
1089 /* The name has ended. Combine it with the partial chunk
1090 * if any; push it on the stack; enter next state.
1092 add_to_partial (context, context->start, context->iter);
1094 add_attribute (context, g_string_free (context->partial_chunk, FALSE));
1096 context->partial_chunk = NULL;
1097 context->start = NULL;
1099 if (*context->iter == '=')
1101 advance_char (context);
1102 context->state = STATE_AFTER_ATTRIBUTE_EQUALS_SIGN;
1109 G_MARKUP_ERROR_PARSE,
1110 _("Odd character '%s', expected a '=' after "
1111 "attribute name '%s' of element '%s'"),
1112 utf8_str (context->iter, buf),
1113 current_attribute (context),
1114 current_element (context));
1120 case STATE_BETWEEN_ATTRIBUTES:
1121 /* Possible next states: AFTER_CLOSE_ANGLE,
1122 * AFTER_ELISION_SLASH, INSIDE_ATTRIBUTE_NAME
1124 skip_spaces (context);
1126 if (context->iter != context->current_text_end)
1128 if (*context->iter == '/')
1130 advance_char (context);
1131 context->state = STATE_AFTER_ELISION_SLASH;
1133 else if (*context->iter == '>')
1136 advance_char (context);
1137 context->state = STATE_AFTER_CLOSE_ANGLE;
1139 else if (is_name_start_char (g_utf8_get_char (context->iter)))
1141 context->state = STATE_INSIDE_ATTRIBUTE_NAME;
1142 /* start of attribute name */
1143 context->start = context->iter;
1150 G_MARKUP_ERROR_PARSE,
1151 _("Odd character '%s', expected a '>' or '/' "
1152 "character to end the start tag of "
1153 "element '%s', or optionally an attribute; "
1154 "perhaps you used an invalid character in "
1155 "an attribute name"),
1156 utf8_str (context->iter, buf),
1157 current_element (context));
1160 /* If we're done with attributes, invoke
1161 * the start_element callback
1163 if (context->state == STATE_AFTER_ELISION_SLASH ||
1164 context->state == STATE_AFTER_CLOSE_ANGLE)
1166 const gchar *start_name;
1167 /* Ugly, but the current code expects an empty array instead of NULL */
1168 const gchar *empty = NULL;
1169 const gchar **attr_names = ∅
1170 const gchar **attr_values = ∅
1173 /* Call user callback for element start */
1174 start_name = current_element (context);
1176 if (context->cur_attr >= 0)
1178 attr_names = (const gchar**)context->attr_names;
1179 attr_values = (const gchar**)context->attr_values;
1183 if (context->parser->start_element)
1184 (* context->parser->start_element) (context,
1186 (const gchar **)attr_names,
1187 (const gchar **)attr_values,
1191 /* Go ahead and free the attributes. */
1192 for (; context->cur_attr >= 0; context->cur_attr--)
1194 int pos = context->cur_attr;
1195 g_free (context->attr_names[pos]);
1196 g_free (context->attr_values[pos]);
1197 context->attr_names[pos] = context->attr_values[pos] = NULL;
1199 context->cur_attr = -1;
1201 if (tmp_error != NULL)
1203 mark_error (context, tmp_error);
1204 g_propagate_error (error, tmp_error);
1210 case STATE_AFTER_ATTRIBUTE_EQUALS_SIGN:
1211 /* Possible next state: INSIDE_ATTRIBUTE_VALUE */
1212 if (*context->iter == '"')
1214 advance_char (context);
1215 context->state = STATE_INSIDE_ATTRIBUTE_VALUE;
1216 context->start = context->iter;
1223 G_MARKUP_ERROR_PARSE,
1224 _("Odd character '%s', expected an open quote mark "
1225 "after the equals sign when giving value for "
1226 "attribute '%s' of element '%s'"),
1227 utf8_str (context->iter, buf),
1228 current_attribute (context),
1229 current_element (context));
1233 case STATE_INSIDE_ATTRIBUTE_VALUE:
1234 /* Possible next states: BETWEEN_ATTRIBUTES */
1237 if (*context->iter == '"')
1240 while (advance_char (context));
1242 if (context->iter == context->current_text_end)
1244 /* The value hasn't necessarily ended. Merge with
1245 * partial chunk, leave state unchanged.
1247 add_to_partial (context, context->start, context->iter);
1251 /* The value has ended at the quote mark. Combine it
1252 * with the partial chunk if any; set it for the current
1255 add_to_partial (context, context->start, context->iter);
1257 g_assert (context->cur_attr >= 0);
1259 if (unescape_text (context,
1260 context->partial_chunk->str,
1261 context->partial_chunk->str +
1262 context->partial_chunk->len,
1263 &context->attr_values[context->cur_attr],
1266 /* success, advance past quote and set state. */
1267 advance_char (context);
1268 context->state = STATE_BETWEEN_ATTRIBUTES;
1269 context->start = NULL;
1272 truncate_partial (context);
1276 case STATE_INSIDE_TEXT:
1277 /* Possible next states: AFTER_OPEN_ANGLE */
1280 if (*context->iter == '<')
1283 while (advance_char (context));
1285 /* The text hasn't necessarily ended. Merge with
1286 * partial chunk, leave state unchanged.
1289 add_to_partial (context, context->start, context->iter);
1291 if (context->iter != context->current_text_end)
1293 gchar *unescaped = NULL;
1295 /* The text has ended at the open angle. Call the text
1299 if (unescape_text (context,
1300 context->partial_chunk->str,
1301 context->partial_chunk->str +
1302 context->partial_chunk->len,
1306 GError *tmp_error = NULL;
1308 if (context->parser->text)
1309 (*context->parser->text) (context,
1317 if (tmp_error == NULL)
1319 /* advance past open angle and set state. */
1320 advance_char (context);
1321 context->state = STATE_AFTER_OPEN_ANGLE;
1322 /* could begin a passthrough */
1323 context->start = context->iter;
1327 mark_error (context, tmp_error);
1328 g_propagate_error (error, tmp_error);
1332 truncate_partial (context);
1336 case STATE_AFTER_CLOSE_TAG_SLASH:
1337 /* Possible next state: INSIDE_CLOSE_TAG_NAME */
1338 if (is_name_start_char (g_utf8_get_char (context->iter)))
1340 context->state = STATE_INSIDE_CLOSE_TAG_NAME;
1342 /* start of tag name */
1343 context->start = context->iter;
1350 G_MARKUP_ERROR_PARSE,
1351 _("'%s' is not a valid character following "
1352 "the characters '</'; '%s' may not begin an "
1354 utf8_str (context->iter, buf),
1355 utf8_str (context->iter, buf));
1359 case STATE_INSIDE_CLOSE_TAG_NAME:
1360 /* Possible next state: AFTER_CLOSE_ANGLE */
1361 advance_to_name_end (context);
1363 if (context->iter == context->current_text_end)
1365 /* The name hasn't necessarily ended. Merge with
1366 * partial chunk, leave state unchanged.
1368 add_to_partial (context, context->start, context->iter);
1372 /* The name has ended. Combine it with the partial chunk
1373 * if any; check that it matches stack top and pop
1374 * stack; invoke proper callback; enter next state.
1378 add_to_partial (context, context->start, context->iter);
1380 close_name = g_string_free (context->partial_chunk, FALSE);
1381 context->partial_chunk = NULL;
1383 if (context->tag_stack == NULL)
1387 G_MARKUP_ERROR_PARSE,
1388 _("Element '%s' was closed, no element "
1389 "is currently open"),
1392 else if (strcmp (close_name, current_element (context)) != 0)
1396 G_MARKUP_ERROR_PARSE,
1397 _("Element '%s' was closed, but the currently "
1398 "open element is '%s'"),
1400 current_element (context));
1402 else if (*context->iter != '>')
1407 G_MARKUP_ERROR_PARSE,
1408 _("'%s' is not a valid character following "
1409 "the close element name '%s'; the allowed "
1410 "character is '>'"),
1411 utf8_str (context->iter, buf),
1417 advance_char (context);
1418 context->state = STATE_AFTER_CLOSE_ANGLE;
1419 context->start = NULL;
1421 /* call the end_element callback */
1423 if (context->parser->end_element)
1424 (* context->parser->end_element) (context,
1430 /* Pop the tag stack */
1431 g_free (context->tag_stack->data);
1432 context->tag_stack = g_slist_delete_link (context->tag_stack,
1433 context->tag_stack);
1437 mark_error (context, tmp_error);
1438 g_propagate_error (error, tmp_error);
1442 g_free (close_name);
1446 case STATE_INSIDE_PASSTHROUGH:
1447 /* Possible next state: AFTER_CLOSE_ANGLE */
1450 if (*context->iter == '>')
1453 while (advance_char (context));
1455 if (context->iter == context->current_text_end)
1457 /* The passthrough hasn't necessarily ended. Merge with
1458 * partial chunk, leave state unchanged.
1460 add_to_partial (context, context->start, context->iter);
1464 /* The passthrough has ended at the close angle. Combine
1465 * it with the partial chunk if any. Call the passthrough
1466 * callback. Note that the open/close angles are
1467 * included in the text of the passthrough.
1469 GError *tmp_error = NULL;
1471 advance_char (context); /* advance past close angle */
1472 add_to_partial (context, context->start, context->iter);
1474 if (context->parser->passthrough)
1475 (*context->parser->passthrough) (context,
1476 context->partial_chunk->str,
1477 context->partial_chunk->len,
1481 truncate_partial (context);
1483 if (tmp_error == NULL)
1485 context->state = STATE_AFTER_CLOSE_ANGLE;
1486 context->start = context->iter; /* could begin text */
1490 mark_error (context, tmp_error);
1491 g_propagate_error (error, tmp_error);
1501 g_assert_not_reached ();
1507 context->parsing = FALSE;
1509 return context->state != STATE_ERROR;
1513 * g_markup_parse_context_end_parse:
1514 * @context: a #GMarkupParseContext
1515 * @error: return location for a #GError
1517 * Signals to the #GMarkupParseContext that all data has been
1518 * fed into the parse context with g_markup_parse_context_parse().
1519 * This function reports an error if the document isn't complete,
1520 * for example if elements are still open.
1522 * Return value: %TRUE on success, %FALSE if an error was set
1525 g_markup_parse_context_end_parse (GMarkupParseContext *context,
1528 g_return_val_if_fail (context != NULL, FALSE);
1529 g_return_val_if_fail (!context->parsing, FALSE);
1530 g_return_val_if_fail (context->state != STATE_ERROR, FALSE);
1532 if (context->partial_chunk != NULL)
1534 g_string_free (context->partial_chunk, TRUE);
1535 context->partial_chunk = NULL;
1538 if (context->document_empty)
1540 set_error (context, error, G_MARKUP_ERROR_EMPTY,
1541 _("Document was empty or contained only whitespace"));
1545 context->parsing = TRUE;
1547 switch (context->state)
1553 case STATE_AFTER_OPEN_ANGLE:
1554 set_error (context, error, G_MARKUP_ERROR_PARSE,
1555 _("Document ended unexpectedly just after an open angle bracket '<'"));
1558 case STATE_AFTER_CLOSE_ANGLE:
1559 if (context->tag_stack != NULL)
1561 /* Error message the same as for INSIDE_TEXT */
1562 set_error (context, error, G_MARKUP_ERROR_PARSE,
1563 _("Document ended unexpectedly with elements still open - "
1564 "'%s' was the last element opened"),
1565 current_element (context));
1569 case STATE_AFTER_ELISION_SLASH:
1570 set_error (context, error, G_MARKUP_ERROR_PARSE,
1571 _("Document ended unexpectedly, expected to see a close angle "
1572 "bracket ending the tag <%s/>"), current_element (context));
1575 case STATE_INSIDE_OPEN_TAG_NAME:
1576 set_error (context, error, G_MARKUP_ERROR_PARSE,
1577 _("Document ended unexpectedly inside an element name"));
1580 case STATE_INSIDE_ATTRIBUTE_NAME:
1581 set_error (context, error, G_MARKUP_ERROR_PARSE,
1582 _("Document ended unexpectedly inside an attribute name"));
1585 case STATE_BETWEEN_ATTRIBUTES:
1586 set_error (context, error, G_MARKUP_ERROR_PARSE,
1587 _("Document ended unexpectedly inside an element-opening "
1591 case STATE_AFTER_ATTRIBUTE_EQUALS_SIGN:
1592 set_error (context, error, G_MARKUP_ERROR_PARSE,
1593 _("Document ended unexpectedly after the equals sign "
1594 "following an attribute name; no attribute value"));
1597 case STATE_INSIDE_ATTRIBUTE_VALUE:
1598 set_error (context, error, G_MARKUP_ERROR_PARSE,
1599 _("Document ended unexpectedly while inside an attribute "
1603 case STATE_INSIDE_TEXT:
1604 g_assert (context->tag_stack != NULL);
1605 set_error (context, error, G_MARKUP_ERROR_PARSE,
1606 _("Document ended unexpectedly with elements still open - "
1607 "'%s' was the last element opened"),
1608 current_element (context));
1611 case STATE_AFTER_CLOSE_TAG_SLASH:
1612 case STATE_INSIDE_CLOSE_TAG_NAME:
1613 set_error (context, error, G_MARKUP_ERROR_PARSE,
1614 _("Document ended unexpectedly inside the close tag for "
1615 "element '%s'"), current_element);
1618 case STATE_INSIDE_PASSTHROUGH:
1619 set_error (context, error, G_MARKUP_ERROR_PARSE,
1620 _("Document ended unexpectedly inside a comment or "
1621 "processing instruction"));
1626 g_assert_not_reached ();
1630 context->parsing = FALSE;
1632 return context->state != STATE_ERROR;
1636 * g_markup_parse_context_get_position:
1637 * @context: a #GMarkupParseContext
1638 * @line_number: return location for a line number, or %NULL
1639 * @char_number: return location for a char-on-line number, or %NULL
1641 * Retrieves the current line number and the number of the character on
1642 * that line. Intended for use in error messages; there are no strict
1643 * semantics for what constitutes the "current" line number other than
1644 * "the best number we could come up with for error messages."
1648 g_markup_parse_context_get_position (GMarkupParseContext *context,
1652 g_return_if_fail (context != NULL);
1655 *line_number = context->line_number;
1658 *char_number = context->char_number;
1662 append_escaped_text (GString *str,
1670 end = text + length;
1675 next = g_utf8_next_char (p);
1680 g_string_append (str, "&");
1684 g_string_append (str, "<");
1688 g_string_append (str, ">");
1692 g_string_append (str, "'");
1696 g_string_append (str, """);
1700 g_string_append_len (str, p, next - p);
1709 * g_markup_escape_text:
1710 * @text: some valid UTF-8 text
1711 * @length: length of @text in bytes
1713 * Escapes text so that the markup parser will parse it verbatim.
1714 * Less than, greater than, ampersand, etc. are replaced with the
1715 * corresponding entities. This function would typically be used
1716 * when writing out a file to be parsed with the markup parser.
1718 * Return value: escaped text
1721 g_markup_escape_text (const gchar *text,
1726 g_return_val_if_fail (text != NULL, NULL);
1729 length = strlen (text);
1731 str = g_string_new ("");
1732 append_escaped_text (str, text, length);
1734 return g_string_free (str, FALSE);