/* gmarkup.c - Simple XML-like parser
*
* Copyright 2000, 2003 Red Hat, Inc.
+ * Copyright 2007, 2008 Ryan Lortie <desrt@desrt.ca>
*
* GLib is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
STATE_ERROR
} GMarkupParseState;
+typedef struct
+{
+ const char *prev_element;
+ const GMarkupParser *prev_parser;
+ gpointer prev_user_data;
+} GMarkupRecursionTracker;
+
struct _GMarkupParseContext
{
const GMarkupParser *parser;
guint document_empty : 1;
guint parsing : 1;
+ guint awaiting_pop : 1;
gint balance;
+
+ /* subparser support */
+ GSList *subparser_stack; /* (GMarkupRecursionTracker *) */
+ const char *subparser_element;
+ gpointer held_user_data;
};
/**
context->document_empty = TRUE;
context->parsing = FALSE;
+ context->awaiting_pop = FALSE;
+ context->subparser_stack = NULL;
+ context->subparser_element = NULL;
+
+ /* this is only looked at if awaiting_pop = TRUE. initialise anyway. */
+ context->held_user_data = NULL;
+
context->balance = 0;
return context;
* @context: a #GMarkupParseContext
*
* Frees a #GMarkupParseContext. Can't be called from inside
- * one of the #GMarkupParser functions.
- *
+ * one of the #GMarkupParser functions. Can't be called while
+ * a subparser is pushed.
**/
void
g_markup_parse_context_free (GMarkupParseContext *context)
{
g_return_if_fail (context != NULL);
g_return_if_fail (!context->parsing);
+ g_return_if_fail (!context->subparser_stack);
+ g_return_if_fail (!context->awaiting_pop);
if (context->dnotify)
(* context->dnotify) (context->user_data);
g_free (context);
}
+static void pop_subparser_stack (GMarkupParseContext *context);
+
static void
mark_error (GMarkupParseContext *context,
GError *error)
if (context->parser->error)
(*context->parser->error) (context, error, context->user_data);
+
+ /* report the error all the way up to free all the user-data */
+ while (context->subparser_stack)
+ {
+ pop_subparser_stack (context);
+ context->awaiting_pop = FALSE; /* already been freed */
+
+ if (context->parser->error)
+ (*context->parser->error) (context, error, context->user_data);
+ }
}
static void set_error (GMarkupParseContext *context,
...) G_GNUC_PRINTF (4, 5);
static void
+set_error_literal (GMarkupParseContext *context,
+ GError **error,
+ GMarkupError code,
+ const gchar *message)
+{
+ GError *tmp_error;
+
+ tmp_error = g_error_new_literal (G_MARKUP_ERROR, code, message);
+
+ g_prefix_error (&tmp_error,
+ _("Error on line %d char %d: "),
+ context->line_number,
+ context->char_number);
+
+ mark_error (context, tmp_error);
+
+ g_propagate_error (error, tmp_error);
+}
+
+static void
set_error (GMarkupParseContext *context,
GError **error,
GMarkupError code,
const gchar *format,
...)
{
- GError *tmp_error;
gchar *s;
+ gchar *s_valid;
va_list args;
va_start (args, format);
s = g_strdup_vprintf (format, args);
va_end (args);
- tmp_error = g_error_new_literal (G_MARKUP_ERROR, code, s);
- g_free (s);
+ /* Make sure that the GError message is valid UTF-8 even if it is
+ * complaining about invalid UTF-8 in the markup: */
+ s_valid = _g_utf8_make_valid (s);
+ set_error_literal (context, error, code, s);
- g_prefix_error (&tmp_error,
- _("Error on line %d char %d: "),
- context->line_number,
- context->char_number);
-
- mark_error (context, tmp_error);
-
- g_propagate_error (error, tmp_error);
+ g_free (s);
+ g_free (s_valid);
}
static void
}
else
{
- /* characters XML permits */
- if (l == 0x9 ||
- l == 0xA ||
- l == 0xD ||
- (l >= 0x20 && l <= 0xD7FF) ||
- (l >= 0xE000 && l <= 0xFFFD) ||
- (l >= 0x10000 && l <= 0x10FFFF))
+ /* 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));
return context->tag_stack->data;
}
+static void
+pop_subparser_stack (GMarkupParseContext *context)
+{
+ GMarkupRecursionTracker *tracker;
+
+ g_assert (context->subparser_stack);
+
+ tracker = context->subparser_stack->data;
+
+ context->awaiting_pop = TRUE;
+ context->held_user_data = context->user_data;
+
+ context->user_data = tracker->prev_user_data;
+ context->parser = tracker->prev_parser;
+ context->subparser_element = tracker->prev_element;
+ g_slice_free (GMarkupRecursionTracker, tracker);
+
+ context->subparser_stack = g_slist_delete_link (context->subparser_stack,
+ context->subparser_stack);
+}
+
+static void
+possibly_finish_subparser (GMarkupParseContext *context)
+{
+ if (current_element (context) == context->subparser_element)
+ pop_subparser_stack (context);
+}
+
+static void
+ensure_no_outstanding_subparser (GMarkupParseContext *context)
+{
+ if (context->awaiting_pop)
+ g_critical ("During the first end_element call after invoking a "
+ "subparser you must pop the subparser stack and handle "
+ "the freeing of the subparser user_data. This can be "
+ "done by calling the end function of the subparser. "
+ "Very probably, your program just leaked memory.");
+
+ /* let valgrind watch the pointer disappear... */
+ context->held_user_data = NULL;
+ context->awaiting_pop = FALSE;
+}
+
static const gchar*
current_attribute (GMarkupParseContext *context)
{
/* The leftover char portion is too big to be
* a UTF-8 character
*/
- set_error (context,
- error,
- G_MARKUP_ERROR_BAD_UTF8,
- _("Invalid UTF-8 encoded text - overlong sequence"));
+ set_error_literal (context,
+ error,
+ G_MARKUP_ERROR_BAD_UTF8,
+ _("Invalid UTF-8 encoded text - overlong sequence"));
}
goto finished;
*/
if ((*context->current_text & 0xc0) == 0x80) /* not a char start */
{
- set_error (context,
- error,
- G_MARKUP_ERROR_BAD_UTF8,
- _("Invalid UTF-8 encoded text - not a start char"));
+ set_error_literal (context,
+ error,
+ G_MARKUP_ERROR_BAD_UTF8,
+ _("Invalid UTF-8 encoded text - not a start char"));
goto finished;
}
{
gint newlines = 0;
const gchar *p, *q;
+ gchar *current_text_dup;
+
q = p = context->current_text;
while (p != first_invalid)
{
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'"),
- g_strndup (context->current_text,
- context->current_text_len));
+ current_text_dup);
+ g_free (current_text_dup);
goto finished;
}
}
else
{
- set_error (context,
- error,
- G_MARKUP_ERROR_PARSE,
- _("Document must begin with an element (e.g. <book>)"));
+ set_error_literal (context,
+ error,
+ G_MARKUP_ERROR_PARSE,
+ _("Document must begin with an element (e.g. <book>)"));
}
}
break;
g_assert (context->tag_stack != NULL);
+ possibly_finish_subparser (context);
+
tmp_error = NULL;
if (context->parser->end_element)
(* context->parser->end_element) (context,
context->tag_stack->data,
context->user_data,
&tmp_error);
+
+ ensure_no_outstanding_subparser (context);
if (tmp_error)
{
error,
G_MARKUP_ERROR_PARSE,
_("Odd character '%s', expected a '>' character "
- "to end the start tag of element '%s'"),
+ "to end the empty-element tag '%s'"),
utf8_str (context->iter, buf),
current_element (context));
}
context->state = STATE_AFTER_CLOSE_ANGLE;
context->start = NULL;
+ possibly_finish_subparser (context);
+
/* call the end_element callback */
tmp_error = NULL;
if (context->parser->end_element)
context->user_data,
&tmp_error);
+ ensure_no_outstanding_subparser (context);
/* Pop the tag stack */
g_free (context->tag_stack->data);
if (context->document_empty)
{
- set_error (context, error, G_MARKUP_ERROR_EMPTY,
- _("Document was empty or contained only whitespace"));
+ set_error_literal (context, error, G_MARKUP_ERROR_EMPTY,
+ _("Document was empty or contained only whitespace"));
return FALSE;
}
break;
case STATE_AFTER_OPEN_ANGLE:
- set_error (context, error, G_MARKUP_ERROR_PARSE,
- _("Document ended unexpectedly just after an open angle bracket '<'"));
+ set_error_literal (context, error, G_MARKUP_ERROR_PARSE,
+ _("Document ended unexpectedly just after an open angle bracket '<'"));
break;
case STATE_AFTER_CLOSE_ANGLE:
break;
case STATE_INSIDE_OPEN_TAG_NAME:
- set_error (context, error, G_MARKUP_ERROR_PARSE,
- _("Document ended unexpectedly inside an element name"));
+ set_error_literal (context, error, G_MARKUP_ERROR_PARSE,
+ _("Document ended unexpectedly inside an element name"));
break;
case STATE_INSIDE_ATTRIBUTE_NAME:
case STATE_AFTER_ATTRIBUTE_NAME:
- set_error (context, error, G_MARKUP_ERROR_PARSE,
- _("Document ended unexpectedly inside an attribute name"));
+ set_error_literal (context, error, G_MARKUP_ERROR_PARSE,
+ _("Document ended unexpectedly inside an attribute name"));
break;
case STATE_BETWEEN_ATTRIBUTES:
- set_error (context, error, G_MARKUP_ERROR_PARSE,
- _("Document ended unexpectedly inside an element-opening "
- "tag."));
+ set_error_literal (context, error, G_MARKUP_ERROR_PARSE,
+ _("Document ended unexpectedly inside an element-opening "
+ "tag."));
break;
case STATE_AFTER_ATTRIBUTE_EQUALS_SIGN:
- set_error (context, error, G_MARKUP_ERROR_PARSE,
- _("Document ended unexpectedly after the equals sign "
- "following an attribute name; no attribute value"));
+ set_error_literal (context, error, G_MARKUP_ERROR_PARSE,
+ _("Document ended unexpectedly after the equals sign "
+ "following an attribute name; no attribute value"));
break;
case STATE_INSIDE_ATTRIBUTE_VALUE_SQ:
case STATE_INSIDE_ATTRIBUTE_VALUE_DQ:
- set_error (context, error, G_MARKUP_ERROR_PARSE,
- _("Document ended unexpectedly while inside an attribute "
- "value"));
+ set_error_literal (context, error, G_MARKUP_ERROR_PARSE,
+ _("Document ended unexpectedly while inside an attribute "
+ "value"));
break;
case STATE_INSIDE_TEXT:
break;
case STATE_INSIDE_PASSTHROUGH:
- set_error (context, error, G_MARKUP_ERROR_PARSE,
- _("Document ended unexpectedly inside a comment or "
- "processing instruction"));
+ set_error_literal (context, error, G_MARKUP_ERROR_PARSE,
+ _("Document ended unexpectedly inside a comment or "
+ "processing instruction"));
break;
case STATE_ERROR:
*
* Returns: the element stack, which must not be modified
*
- * Since 2.16
+ * Since: 2.16
**/
G_CONST_RETURN GSList *
g_markup_parse_context_get_element_stack (GMarkupParseContext *context)
*char_number = context->char_number;
}
+/**
+ * g_markup_parse_context_get_user_data:
+ * @context: a #GMarkupParseContext
+ *
+ * Returns the user_data associated with @context. This will either
+ * be the user_data that was provided to g_markup_parse_context_new()
+ * or to the most recent call of g_markup_parse_context_push().
+ *
+ * Returns: the provided user_data. The returned data belongs to
+ * the markup context and will be freed when g_markup_context_free()
+ * is called.
+ *
+ * Since: 2.18
+ **/
+gpointer
+g_markup_parse_context_get_user_data (GMarkupParseContext *context)
+{
+ return context->user_data;
+}
+
+/**
+ * g_markup_parse_context_push:
+ * @context: a #GMarkupParseContext
+ * @parser: a #GMarkupParser
+ * @user_data: user data to pass to #GMarkupParser functions
+ *
+ * Temporarily redirects markup data to a sub-parser.
+ *
+ * This function may only be called from the start_element handler of
+ * a #GMarkupParser. It must be matched with a corresponding call to
+ * g_markup_parse_context_pop() in the matching end_element handler
+ * (except in the case that the parser aborts due to an error).
+ *
+ * All tags, text and other data between the matching tags is
+ * redirected to the subparser given by @parser. @user_data is used
+ * as the user_data for that parser. @user_data is also passed to the
+ * error callback in the event that an error occurs. This includes
+ * errors that occur in subparsers of the subparser.
+ *
+ * The end tag matching the start tag for which this call was made is
+ * handled by the previous parser (which is given its own user_data)
+ * which is why g_markup_parse_context_pop() is provided to allow "one
+ * last access" to the @user_data provided to this function. In the
+ * case of error, the @user_data provided here is passed directly to
+ * the error callback of the subparser and g_markup_parse_context()
+ * should not be called. In either case, if @user_data was allocated
+ * then it ought to be freed from both of these locations.
+ *
+ * This function is not intended to be directly called by users
+ * interested in invoking subparsers. Instead, it is intended to be
+ * used by the subparsers themselves to implement a higher-level
+ * interface.
+ *
+ * As an example, see the following implementation of a simple
+ * parser that counts the number of tags encountered.
+ *
+ * |[
+ * typedef struct
+ * {
+ * gint tag_count;
+ * } CounterData;
+ *
+ * static void
+ * counter_start_element (GMarkupParseContext *context,
+ * const gchar *element_name,
+ * const gchar **attribute_names,
+ * const gchar **attribute_values,
+ * gpointer user_data,
+ * GError **error)
+ * {
+ * CounterData *data = user_data;
+ *
+ * data->tag_count++;
+ * }
+ *
+ * static void
+ * counter_error (GMarkupParseContext *context,
+ * GError *error,
+ * gpointer user_data)
+ * {
+ * CounterData *data = user_data;
+ *
+ * g_slice_free (CounterData, data);
+ * }
+ *
+ * static GMarkupParser counter_subparser =
+ * {
+ * counter_start_element,
+ * NULL,
+ * NULL,
+ * NULL,
+ * counter_error
+ * };
+ * ]|
+ *
+ * In order to allow this parser to be easily used as a subparser, the
+ * following interface is provided:
+ *
+ * |[
+ * void
+ * start_counting (GMarkupParseContext *context)
+ * {
+ * CounterData *data = g_slice_new (CounterData);
+ *
+ * data->tag_count = 0;
+ * g_markup_parse_context_push (context, &counter_subparser, data);
+ * }
+ *
+ * gint
+ * end_counting (GMarkupParseContext *context)
+ * {
+ * CounterData *data = g_markup_parse_context_pop (context);
+ * int result;
+ *
+ * result = data->tag_count;
+ * g_slice_free (CounterData, data);
+ *
+ * return result;
+ * }
+ * ]|
+ *
+ * The subparser would then be used as follows:
+ *
+ * |[
+ * static void start_element (context, element_name, ...)
+ * {
+ * if (strcmp (element_name, "count-these") == 0)
+ * start_counting (context);
+ *
+ * /* else, handle other tags... */
+ * }
+ *
+ * static void end_element (context, element_name, ...)
+ * {
+ * if (strcmp (element_name, "count-these") == 0)
+ * g_print ("Counted %d tags\n", end_counting (context));
+ *
+ * /* else, handle other tags... */
+ * }
+ * ]|
+ *
+ * Since: 2.18
+ **/
+void
+g_markup_parse_context_push (GMarkupParseContext *context,
+ GMarkupParser *parser,
+ gpointer user_data)
+{
+ GMarkupRecursionTracker *tracker;
+
+ tracker = g_slice_new (GMarkupRecursionTracker);
+ tracker->prev_element = context->subparser_element;
+ tracker->prev_parser = context->parser;
+ tracker->prev_user_data = context->user_data;
+
+ context->subparser_element = current_element (context);
+ context->parser = parser;
+ context->user_data = user_data;
+
+ context->subparser_stack = g_slist_prepend (context->subparser_stack,
+ tracker);
+}
+
+/**
+ * g_markup_parse_context_pop:
+ * @context: a #GMarkupParseContext
+ *
+ * Completes the process of a temporary sub-parser redirection.
+ *
+ * This function exists to collect the user_data allocated by a
+ * matching call to g_markup_parse_context_push(). It must be called
+ * in the end_element handler corresponding to the start_element
+ * handler during which g_markup_parse_context_push() was called. You
+ * must not call this function from the error callback -- the
+ * @user_data is provided directly to the callback in that case.
+ *
+ * This function is not intended to be directly called by users
+ * interested in invoking subparsers. Instead, it is intended to be
+ * used by the subparsers themselves to implement a higher-level
+ * interface.
+ *
+ * Returns: the user_data passed to g_markup_parse_context_push().
+ *
+ * Since: 2.18
+ **/
+gpointer
+g_markup_parse_context_pop (GMarkupParseContext *context)
+{
+ gpointer user_data;
+
+ if (!context->awaiting_pop)
+ possibly_finish_subparser (context);
+
+ g_assert (context->awaiting_pop);
+
+ context->awaiting_pop = FALSE;
+
+ /* valgrind friendliness */
+ user_data = context->held_user_data;
+ context->held_user_data = NULL;
+
+ return user_data;
+}
+
static void
append_escaped_text (GString *str,
const gchar *text,
* Note that this function doesn't protect whitespace and line endings
* from being processed according to the XML rules for normalization
* of line endings and attribute values.
+ *
+ * Note also that if given a string containing them, this function
+ * will produce character references in the range of &#x1; ..
+ * &#x1f; for all control sequences except for tabstop, newline
+ * and carriage return. The character references in this range are
+ * not valid XML 1.0, but they are valid XML 1.1 and will be accepted
+ * by the GMarkup parser.
*
* Return value: a newly allocated string with the escaped text
**/
* particular attribute is to be allowed but
* ignored.
*
- * This function deals with issuing errors for
- * missing attributes, unknown attributes and
- * duplicate attributes as well as parse errors
- * for boolean-valued attributes. In all of these
- * cases %FALSE will be returned and @error will
- * be set as appropriate.
+ * This function deals with issuing errors for missing attributes
+ * (of type %G_MARKUP_ERROR_MISSING_ATTRIBUTE), unknown attributes
+ * (of type %G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE) and duplicate
+ * attributes (of type %G_MARKUP_ERROR_INVALID_CONTENT) as well
+ * as parse errors for boolean-valued attributes (again of type
+ * %G_MARKUP_ERROR_INVALID_CONTENT). In all of these cases %FALSE
+ * will be returned and @error will be set as appropriate.
*
* Return value: %TRUE if successful
*
mandatory = FALSE;
for (i = 0; attribute_names[i]; i++)
- if (i >= 40 || !(collected & (1ull << i)))
+ if (i >= 40 || !(collected & (G_GUINT64_CONSTANT(1) << i)))
if (!strcmp (attribute_names[i], attr))
break;
* what error it is, so just continue...
*/
if (i < 40)
- collected |= (1ull << i);
+ collected |= (G_GUINT64_CONSTANT(1) << i);
value = attribute_values[i];
/* ensure we collected all the arguments */
for (i = 0; attribute_names[i]; i++)
- if ((collected & (1 << i)) == 0)
+ if ((collected & (G_GUINT64_CONSTANT(1) << i)) == 0)
{
/* attribute not collected: could be caused by two things.
*