+2008-07-10 Ryan Lortie <desrt@desrt.ca>
+
+ * docs/reference/glib/glib-sections.txt:
+ * glib/glib.symbols:
+ * glib/gmarkup.c:
+ * glib/gmarkup.h: add functions g_markup_parse_context_{push,pop} in
+ order to provide some small hooks on which to build easy-to-use
+ subparsers.
+
+ * glib/tests/Makefile: add new test
+ * glib/tests/markup-subparser.c: new test for subparsers
+
+ Fixes bug #337518.
+
2008-07-05 Matthias Clasen <mclasen@redhat.com>
Bug 528317 – GRegex does not allow recursion limit
g_markup_parse_context_get_element_stack
g_markup_parse_context_new
g_markup_parse_context_parse
+g_markup_parse_context_push
+g_markup_parse_context_pop
<SUBSECTION>
GMarkupCollectType
g_markup_collect_attributes
g_markup_parse_context_get_position
g_markup_parse_context_new
g_markup_parse_context_parse
+g_markup_parse_context_push
+g_markup_parse_context_pop
g_markup_printf_escaped G_GNUC_PRINTF(1,2)
g_markup_vprintf_escaped
g_markup_collect_attributes
/* 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,
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)
{
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)
{
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);
*char_number = context->char_number;
}
+/**
+ * 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,
const gchar *text,
gssize text_len,
GError **error);
+void g_markup_parse_context_push (GMarkupParseContext *context,
+ GMarkupParser *parser,
+ gpointer user_data);
+gpointer g_markup_parse_context_pop (GMarkupParseContext *context);
gboolean g_markup_parse_context_end_parse (GMarkupParseContext *context,
GError **error);
strfuncs_SOURCES = strfuncs.c
strfuncs_LDADD = $(progs_ldadd) -lm
+TEST_PROGS += markup-subparser
+markup_subparser_LDADD = $(progs_ldadd)
+
# some testing of gtester funcitonality
XMLLINT=xmllint
gtester-xmllint-check: # check testreport xml with xmllint if present
--- /dev/null
+/*
+ * Copyright © 2008 Ryan Lortie
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * See the included COPYING file for more information.
+ */
+
+#include <string.h>
+#include <stdio.h>
+#include <glib.h>
+
+/* keep track of GString instances to make sure nothing leaks */
+static int strings_allocated;
+
+/* === the GMarkupParser functions === */
+static void
+subparser_start_element (GMarkupParseContext *context,
+ const gchar *element_name,
+ const gchar **attribute_names,
+ const gchar **attribute_values,
+ gpointer user_data,
+ GError **error)
+{
+ g_string_append_printf (user_data, "{%s}", element_name);
+
+ /* we don't like trouble... */
+ if (strcmp (element_name, "trouble") == 0)
+ g_set_error (error, 0, 0, "we don't like trouble");
+}
+
+static void
+subparser_end_element (GMarkupParseContext *context,
+ const gchar *element_name,
+ gpointer user_data,
+ GError **error)
+{
+ g_string_append_printf (user_data, "{/%s}", element_name);
+}
+
+static void
+subparser_error (GMarkupParseContext *context,
+ GError *error,
+ gpointer user_data)
+{
+ g_string_free (user_data, TRUE);
+ strings_allocated--;
+}
+
+static GMarkupParser subparser_parser =
+{
+ subparser_start_element,
+ subparser_end_element,
+ NULL,
+ NULL,
+ subparser_error
+};
+
+/* convenience functions for a parser that does not
+ * replay the starting tag into the subparser...
+ */
+static void
+subparser_start (GMarkupParseContext *ctx)
+{
+ gpointer user_data;
+
+ user_data = g_string_new (NULL);
+ strings_allocated++;
+ g_markup_parse_context_push (ctx, &subparser_parser, user_data);
+}
+
+static char *
+subparser_end (GMarkupParseContext *ctx,
+ GError **error)
+{
+ GString *string;
+ char *result;
+
+ string = g_markup_parse_context_pop (ctx);
+ result = string->str;
+
+ g_string_free (string, FALSE);
+ strings_allocated--;
+
+ if (result == NULL || result[0] == '\0')
+ {
+ g_free (result);
+ g_set_error (error, 0, 0, "got no data");
+
+ return NULL;
+ }
+
+ return result;
+}
+
+/* convenience functions for a parser that -does-
+ * replay the starting tag into the subparser...
+ */
+static gboolean
+replay_parser_start (GMarkupParseContext *ctx,
+ const char *element_name,
+ const char **attribute_names,
+ const char **attribute_values,
+ GError **error)
+{
+ GError *tmp_error = NULL;
+ gpointer user_data;
+
+ user_data = g_string_new (NULL);
+ strings_allocated++;
+
+ subparser_parser.start_element (ctx, element_name,
+ attribute_names, attribute_values,
+ user_data, &tmp_error);
+
+ if (tmp_error)
+ {
+ g_propagate_error (error, tmp_error);
+ g_string_free (user_data, TRUE);
+ strings_allocated--;
+
+ return FALSE;
+ }
+
+ g_markup_parse_context_push (ctx, &subparser_parser, user_data);
+
+ return TRUE;
+}
+
+static char *
+replay_parser_end (GMarkupParseContext *ctx,
+ GError **error)
+{
+ GError *tmp_error = NULL;
+ GString *string;
+ char *result;
+
+ string = g_markup_parse_context_pop (ctx);
+
+ subparser_parser.end_element (ctx, g_markup_parse_context_get_element (ctx),
+ string, &tmp_error);
+
+ if (tmp_error)
+ {
+ g_propagate_error (error, tmp_error);
+ g_string_free (string, TRUE);
+ strings_allocated--;
+
+ return FALSE;
+ }
+
+ result = string->str;
+
+ g_string_free (string, FALSE);
+ strings_allocated--;
+
+ if (result == NULL || result[0] == '\0')
+ {
+ g_free (result);
+ g_set_error (error, 0, 0, "got no data");
+
+ return NULL;
+ }
+
+ return result;
+}
+
+
+/* === start interface between subparser and calling parser === */
+static void subparser_start (GMarkupParseContext *ctx);
+static char *subparser_end (GMarkupParseContext *ctx,
+ GError **error);
+/* === end interface between subparser and calling parser === */
+
+/* === start interface between replay parser and calling parser === */
+static gboolean replay_parser_start (GMarkupParseContext *ctx,
+ const char *element_name,
+ const char **attribute_names,
+ const char **attribute_values,
+ GError **error);
+static char *replay_parser_end (GMarkupParseContext *ctx,
+ GError **error);
+/* === end interface between replay parser and calling parser === */
+
+
+
+/* now comes our parser for the test.
+ *
+ * we recognise the tags <test> and <sub>.
+ * <test> is ignored.
+ * <sub> invokes the subparser (no replay).
+ *
+ * "unknown tags" are passed to the reply subparser
+ * (so the unknown tag is fed to the subparser...)
+ */
+static void
+start_element (GMarkupParseContext *context,
+ const gchar *element_name,
+ const gchar **attribute_names,
+ const gchar **attribute_values,
+ gpointer user_data,
+ GError **error)
+{
+ g_string_append_printf (user_data, "<%s>", element_name);
+
+ if (strcmp (element_name, "test") == 0)
+ {
+ /* do nothing */
+ }
+ else if (strcmp (element_name, "sub") == 0)
+ {
+ /* invoke subparser */
+ subparser_start (context);
+ }
+ else
+ {
+ /* unknown tag. invoke replay subparser */
+ if (!replay_parser_start (context, element_name,
+ attribute_names, attribute_values,
+ error))
+ return;
+ }
+}
+
+static void
+end_element (GMarkupParseContext *context,
+ const gchar *element_name,
+ gpointer user_data,
+ GError **error)
+{
+ if (strcmp (element_name, "test") == 0)
+ {
+ /* do nothing */
+ }
+ else if (strcmp (element_name, "sub") == 0)
+ {
+ char *result;
+
+ if ((result = subparser_end (context, error)) == NULL)
+ return;
+
+ g_string_append_printf (user_data, "<<%s>>", result);
+ g_free (result);
+ }
+ else
+ {
+ char *result;
+
+ if ((result = replay_parser_end (context, error)) == NULL)
+ return;
+
+ g_string_append_printf (user_data, "[[%s]]", result);
+ g_free (result);
+ }
+
+ g_string_append_printf (user_data, "</%s>", element_name);
+}
+
+static GMarkupParser parser =
+{
+ start_element,
+ end_element
+};
+
+typedef struct
+{
+ const char *markup;
+ const char *result;
+ const char *error_message;
+} TestCase;
+
+void
+test (gconstpointer user_data)
+{
+ const TestCase *tc = user_data;
+ GMarkupParseContext *ctx;
+ GString *string;
+ gboolean result;
+ GError *error;
+
+ error = NULL;
+ string = g_string_new (NULL);
+ ctx = g_markup_parse_context_new (&parser, 0, string, NULL);
+ result = g_markup_parse_context_parse (ctx, tc->markup,
+ strlen (tc->markup), &error);
+ if (result)
+ result = g_markup_parse_context_end_parse (ctx, &error);
+ g_markup_parse_context_free (ctx);
+ g_assert (strings_allocated == 0);
+
+ if (result)
+ {
+ if (tc->error_message)
+ g_error ("expected failure (about '%s') passed!\n"
+ " in: %s\n out: %s",
+ tc->error_message, tc->markup, string->str);
+ }
+ else
+ {
+ if (!tc->error_message)
+ g_error ("unexpected failure: '%s'\n"
+ " in: %s\n out: %s",
+ error->message, tc->markup, string->str);
+
+ if (!strstr (error->message, tc->error_message))
+ g_error ("failed for the wrong reason.\n"
+ " expecting message about '%s'\n"
+ " got message '%s'\n"
+ " in: %s\n out: %s",
+ tc->error_message, error->message, tc->markup, string->str);
+ }
+
+ if (strcmp (string->str, tc->result) != 0)
+ g_error ("got the wrong result.\n"
+ " expected: '%s'\n"
+ " got: '%s'\n"
+ " input: %s",
+ tc->result, string->str, tc->markup);
+
+ if (error)
+ g_error_free (error);
+
+ g_string_free (string, TRUE);
+}
+
+TestCase test_cases[] = /* successful runs */
+{
+ /* in */ /* out */
+ { "<test/>", "<test></test>" },
+ { "<sub><foo/></sub>", "<sub><<{foo}{/foo}>></sub>" },
+ { "<sub><foo/><bar/></sub>", "<sub><<{foo}{/foo}{bar}{/bar}>></sub>" },
+ { "<foo><bar/></foo>", "<foo>[[{foo}{bar}{/bar}{/foo}]]</foo>" },
+ { "<foo><x/><y/></foo>", "<foo>[[{foo}{x}{/x}{y}{/y}{/foo}]]</foo>" },
+ { "<foo/>", "<foo>[[{foo}{/foo}]]</foo>" },
+ { "<sub><foo/></sub><bar/>", "<sub><<{foo}{/foo}>></sub>"
+ "<bar>[[{bar}{/bar}]]</bar>" }
+};
+
+TestCase error_cases[] = /* error cases */
+{
+ /* in */ /* out */ /* error */
+ { "<foo><>", "<foo>", ">"},
+ { "", "", "empty" },
+ { "<trouble/>", "<trouble>", "trouble" },
+ { "<sub><trouble>", "<sub>", "trouble" },
+ { "<foo><trouble>", "<foo>", "trouble" },
+ { "<sub></sub>", "<sub>", "no data" },
+ { "<sub/>", "<sub>", "no data" }
+};
+
+#define add_tests(func, basename, array) \
+ G_STMT_START { \
+ int __add_tests_i; \
+ \
+ for (__add_tests_i = 0; \
+ __add_tests_i < G_N_ELEMENTS (array); \
+ __add_tests_i++) \
+ { \
+ char *testname; \
+ \
+ testname = g_strdup_printf ("%s/%d", basename, __add_tests_i); \
+ g_test_add_data_func (testname, &array[__add_tests_i], func); \
+ g_free (testname); \
+ } \
+ } G_STMT_END
+
+int
+main (int argc, char **argv)
+{
+ g_test_init (&argc, &argv, NULL);
+ add_tests (test, "/glib/markup/subparser/success", test_cases);
+ add_tests (test, "/glib/markup/subparser/failure", error_cases);
+ return g_test_run ();
+}
projects / platform / upstream / glib.git / commitdiff