[glib] merge GVariant parser



commit bf4dbdbf0e1a3ac4349980942b9e91056ce7e448
Author: Ryan Lortie <desrt desrt ca>
Date:   Sun Mar 21 12:31:46 2010 -0500

    merge GVariant parser

 docs/reference/glib/glib-sections.txt |    7 +
 glib/Makefile.am                      |    1 +
 glib/glib.symbols                     |    7 +
 glib/gvariant-parser.c                | 2185 +++++++++++++++++++++++++++++++++
 glib/gvariant.c                       |   28 +-
 glib/gvariant.h                       |   13 +
 glib/tests/gvariant.c                 |  249 ++++-
 7 files changed, 2473 insertions(+), 17 deletions(-)
---
diff --git a/docs/reference/glib/glib-sections.txt b/docs/reference/glib/glib-sections.txt
index 05b06cd..860e8b8 100644
--- a/docs/reference/glib/glib-sections.txt
+++ b/docs/reference/glib/glib-sections.txt
@@ -2894,7 +2894,14 @@ g_variant_builder_end
 g_variant_builder_open
 g_variant_builder_close
 
+<SUBSECTION>
+G_VARIANT_PARSE_ERROR
+g_variant_parse
+g_variant_new_parsed_va
+g_variant_new_parsed
+
 <SUBSECTION Private>
+g_variant_parser_get_error
 g_variant_type_checked_
 </SECTION>
 
diff --git a/glib/Makefile.am b/glib/Makefile.am
index 0654503..9428f62 100644
--- a/glib/Makefile.am
+++ b/glib/Makefile.am
@@ -179,6 +179,7 @@ libglib_2_0_la_SOURCES = 	\
 	gvariant-core.h		\
 	gvariant-core.c		\
 	gvariant-internal.h	\
+	gvariant-parser.c	\
 	gvariant-serialiser.h	\
 	gvariant-serialiser.c	\
 	gvarianttypeinfo.h	\
diff --git a/glib/glib.symbols b/glib/glib.symbols
index ee9da31..f9a0d8d 100644
--- a/glib/glib.symbols
+++ b/glib/glib.symbols
@@ -1794,6 +1794,13 @@ g_variant_new_from_data
 g_variant_get_normal_form
 g_variant_byteswap
 #endif
+
+#if IN_FILE(__G_VARIANT_PARSER_C__)
+g_variant_new_parsed
+g_variant_new_parsed_va
+g_variant_parse
+g_variant_parser_get_error_quark
+#endif
 #endif
 
 #if IN_HEADER(__G_VARIANT_TYPE_INFO_H__)
diff --git a/glib/gvariant-parser.c b/glib/gvariant-parser.c
new file mode 100644
index 0000000..2e35d05
--- /dev/null
+++ b/glib/gvariant-parser.c
@@ -0,0 +1,2185 @@
+/*
+ * Copyright © 2009, 2010 Codethink Limited
+ *
+ * This library 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 licence, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Author: Ryan Lortie <desrt desrt ca>
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <glib.h>
+
+#include "galias.h"
+
+/*
+ * two-pass algorithm
+ * designed by ryan lortie and william hua
+ * designed in itb-229 and at ghazi's, 2009.
+ */
+
+GQuark
+g_variant_parser_get_error_quark (void)
+{
+  static GQuark the_quark;
+
+  if (the_quark == 0)
+    the_quark = g_quark_from_static_string ("g-variant-parse-error-quark");
+
+  return the_quark;
+}
+
+typedef struct
+{
+  gint start, end;
+} SourceRef;
+
+static void
+parser_set_error_va (GError      **error,
+                     SourceRef    *location,
+                     SourceRef    *other,
+                     const gchar  *format,
+                     va_list       ap)
+{
+  GString *msg = g_string_new (NULL);
+
+  if (location->start == location->end)
+    g_string_append_printf (msg, "%d", location->start);
+  else
+    g_string_append_printf (msg, "%d-%d", location->start, location->end);
+
+  if (other != NULL)
+    {
+      g_assert (other->start != other->end);
+      g_string_append_printf (msg, ",%d-%d", other->start, other->end);
+    }
+  g_string_append_c (msg, ':');
+
+  g_string_append_vprintf (msg, format, ap);
+  g_set_error_literal (error, G_VARIANT_PARSE_ERROR, 0, msg->str);
+  g_string_free (msg, TRUE);
+}
+
+static void
+parser_set_error (GError      **error,
+                  SourceRef    *location,
+                  SourceRef    *other,
+                  const gchar  *format,
+                  ...)
+{
+  va_list ap;
+
+  va_start (ap, format);
+  parser_set_error_va (error, location, other, format, ap);
+  va_end (ap);
+}
+
+typedef struct
+{
+  const gchar *start;
+  const gchar *stream;
+  const gchar *end;
+
+  const gchar *this;
+} TokenStream;
+
+
+static void
+token_stream_set_error (TokenStream  *stream,
+                        GError      **error,
+                        gboolean      this_token,
+                        const gchar  *format,
+                        ...)
+{
+  SourceRef ref;
+  va_list ap;
+
+  ref.start = stream->this - stream->start;
+
+  if (this_token)
+    ref.end = stream->stream - stream->start;
+  else
+    ref.end = ref.start;
+
+  va_start (ap, format);
+  parser_set_error_va (error, &ref, NULL, format, ap);
+  va_end (ap);
+}
+
+static void
+token_stream_prepare (TokenStream *stream)
+{
+  gint brackets = 0;
+  const gchar *end;
+
+  if (stream->this != NULL)
+    return;
+
+  while (stream->stream != stream->end && g_ascii_isspace (*stream->stream))
+    stream->stream++;
+
+  if (stream->stream == stream->end || *stream->stream == '\0')
+    {
+      stream->this = stream->stream;
+      return;
+    }
+
+  switch (stream->stream[0])
+    {
+    case '-': case '+': case '.': case '0': case '1': case '2':
+    case '3': case '4': case '5': case '6': case '7': case '8':
+    case '9':
+      for (end = stream->stream; end != stream->end; end++)
+        if (!g_ascii_isalnum (*end) &&
+            *end != '-' && *end != '+' && *end != '.')
+          break;
+      break;
+
+    case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
+    case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
+    case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
+    case 's': case 't': case 'u': case 'v': case 'w': case 'x':
+    case 'y': case 'z':
+      for (end = stream->stream; end != stream->end; end++)
+        if (!g_ascii_isalnum (*end))
+          break;
+      break;
+
+    case '@': case '%':
+      /* stop at the first space, comma or unmatched bracket.
+       * deals nicely with cases like (%i, %i).
+       */
+      for (end = stream->stream + 1;
+           end != stream->end && *end != ',' && !g_ascii_isspace (*end);
+           end++)
+
+        if (*end == '(' || *end == '{')
+          brackets++;
+
+        else if ((*end == ')' || *end == '}') && !brackets--)
+          break;
+
+      break;
+
+    case '\'': case '"':
+      for (end = stream->stream + 1; end != stream->end; end++)
+        if (*end == stream->stream[0] || *end == '\0' ||
+            (*end == '\\' && (++end == stream->end || *end == '\0')))
+          break;
+
+      if (end != stream->end && *end)
+        end++;
+      break;
+
+    default:
+      end = stream->stream + 1;
+      break;
+    }
+
+  stream->this = stream->stream;
+  stream->stream = end;
+}
+
+static void
+token_stream_next (TokenStream *stream)
+{
+  stream->this = NULL;
+}
+
+static gboolean
+token_stream_peek (TokenStream *stream,
+                   gchar        first_char)
+{
+  token_stream_prepare (stream);
+
+  return stream->this[0] == first_char;
+}
+
+static gboolean
+token_stream_is_keyword (TokenStream *stream)
+{
+  token_stream_prepare (stream);
+
+  return g_ascii_isalpha (stream->this[0]);
+}
+
+static gboolean
+token_stream_is_numeric (TokenStream *stream)
+{
+  token_stream_prepare (stream);
+
+  return (g_ascii_isdigit (stream->this[0]) ||
+          stream->this[0] == '-' ||
+          stream->this[0] == '+' ||
+          stream->this[0] == '.');
+}
+
+static gboolean
+token_stream_consume (TokenStream *stream,
+                      const gchar *token)
+{
+  gint length = strlen (token);
+
+  token_stream_prepare (stream);
+
+  if (stream->stream - stream->this == length &&
+      memcmp (stream->this, token, length) == 0)
+    {
+      token_stream_next (stream);
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+static gboolean
+token_stream_require (TokenStream  *stream,
+                      const gchar  *token,
+                      const gchar  *purpose,
+                      GError      **error)
+{
+
+  if (!token_stream_consume (stream, token))
+    {
+      token_stream_set_error (stream, error, FALSE,
+                              "expected `%s'%s", token, purpose);
+      return FALSE;
+    }
+
+  return TRUE;
+}
+
+static void
+token_stream_assert (TokenStream *stream,
+                     const gchar *token)
+{
+  gboolean correct_token;
+
+  correct_token = token_stream_consume (stream, token);
+  g_assert (correct_token);
+}
+
+static gchar *
+token_stream_get (TokenStream *stream)
+{
+  gchar *result;
+
+  token_stream_prepare (stream);
+
+  result = g_strndup (stream->this, stream->stream - stream->this);
+
+  return result;
+}
+
+static void
+token_stream_start_ref (TokenStream *stream,
+                        SourceRef   *ref)
+{
+  token_stream_prepare (stream);
+  ref->start = stream->this - stream->start;
+}
+
+static void
+token_stream_end_ref (TokenStream *stream,
+                      SourceRef   *ref)
+{
+  ref->end = stream->stream - stream->start;
+}
+
+void
+pattern_copy (gchar       **out,
+              const gchar **in)
+{
+  gint brackets = 0;
+
+  while (**in == 'a' || **in == 'm' || **in == 'M')
+    *(*out)++ = *(*in)++;
+
+  do
+    {
+      if (**in == '(' || **in == '{')
+        brackets++;
+
+      else if (**in == ')' || **in == '}')
+        brackets--;
+
+      *(*out)++ = *(*in)++;
+    }
+  while (brackets);
+}
+
+static gchar *
+pattern_coalesce (const gchar *left,
+                  const gchar *right)
+{
+  gchar *result;
+  gchar *out;
+
+  /* the length of the output is loosely bound by the sum of the input
+   * lengths, not simply the greater of the two lengths.
+   *
+   *   (*(iii)) + ((iii)*) ((iii)(iii))
+   *
+   *      8     +    8    =  12
+   */
+  out = result = g_malloc (strlen (left) + strlen (right));
+
+  while (*left && *right)
+    {
+      if (*left == *right)
+        {
+          *out++ = *left++;
+          right++;
+        }
+
+      else
+        {
+          const gchar **one = &left, **the_other = &right;
+
+         again:
+          if (**one == '*' && **the_other != ')')
+            {
+              pattern_copy (&out, the_other);
+              (*one)++;
+            }
+
+          else if (**one == 'M' && **the_other == 'm')
+            {
+              *out++ = *(*the_other)++;
+            }
+
+          else if (**one == 'M' && **the_other != 'm')
+            {
+              (*one)++;
+            }
+
+          else if (**one == 'N' && strchr ("ynqiuxthd", **the_other))
+            {
+              *out++ = *(*the_other)++;
+              (*one)++;
+            }
+
+          else if (**one == 'S' && strchr ("sog", **the_other))
+            {
+              *out++ = *(*the_other)++;
+              (*one)++;
+            }
+
+          else if (one == &left)
+            {
+              one = &right, the_other = &left;
+              goto again;
+            }
+
+          else
+            break;
+        }
+    }
+
+  if (*left || *right)
+    {
+      g_free (result);
+      result = NULL;
+    }
+  else
+    *out++ = '\0';
+
+  return result;
+}
+
+typedef struct _AST AST;
+typedef gchar *    (*get_pattern_func)    (AST                 *ast,
+                                           GError             **error);
+typedef GVariant * (*get_value_func)      (AST                 *ast,
+                                           const GVariantType  *type,
+                                           GError             **error);
+typedef GVariant * (*get_base_value_func) (AST                 *ast,
+                                           const GVariantType  *type,
+                                           GError             **error);
+typedef void       (*free_func)           (AST                 *ast);
+
+typedef struct
+{
+  gchar *    (* get_pattern)    (AST                 *ast,
+                                 GError             **error);
+  GVariant * (* get_value)      (AST                 *ast,
+                                 const GVariantType  *type,
+                                 GError             **error);
+  GVariant * (* get_base_value) (AST                 *ast,
+                                 const GVariantType  *type,
+                                 GError             **error);
+  void       (* free)           (AST                 *ast);
+} ASTClass;
+
+struct _AST
+{
+  const ASTClass *class;
+  SourceRef source_ref;
+};
+
+static gchar *
+ast_get_pattern (AST     *ast,
+                 GError **error)
+{
+  return ast->class->get_pattern (ast, error);
+}
+
+static GVariant *
+ast_get_value (AST                 *ast,
+               const GVariantType  *type,
+               GError             **error)
+{
+  return ast->class->get_value (ast, type, error);
+}
+
+static void
+ast_free (AST *ast)
+{
+  ast->class->free (ast);
+}
+
+static void
+ast_set_error (AST          *ast,
+               GError      **error,
+               AST          *other_ast,
+               const gchar  *format,
+               ...)
+{
+  va_list ap;
+
+  va_start (ap, format);
+  parser_set_error_va (error, &ast->source_ref,
+                       other_ast ? & other_ast->source_ref : NULL,
+                       format, ap);
+  va_end (ap);
+}
+
+static GVariant *
+ast_type_error (AST                 *ast,
+                const GVariantType  *type,
+                GError             **error)
+{
+  gchar *typestr;
+
+  typestr = g_variant_type_dup_string (type);
+  ast_set_error (ast, error, NULL,
+                 "can not parse as value of type `%s'",
+                 typestr);
+  g_free (typestr);
+
+  return NULL;
+}
+
+static GVariant *
+ast_resolve (AST     *ast,
+             GError **error)
+{
+  GVariant *value;
+  gchar *pattern;
+  gint i, j = 0;
+
+  pattern = ast_get_pattern (ast, error);
+
+  if (pattern == NULL)
+    return NULL;
+
+  /* choose reasonable defaults
+   *
+   *   1) favour non-maybe values where possible
+   *   2) default type for strings is 's'
+   *   3) default type for integers is 'i'
+   */
+  for (i = 0; pattern[i]; i++)
+    switch (pattern[i])
+      {
+      case '*':
+        ast_set_error (ast, error, NULL, "unable to infer type");
+        g_free (pattern);
+        return NULL;
+
+      case 'M':
+        break;
+
+      case 'S':
+        pattern[j++] = 's';
+        break;
+
+      case 'N':
+        pattern[j++] = 'i';
+        break;
+
+      default:
+        pattern[j++] = pattern[i];
+        break;
+      }
+  pattern[j++] = '\0';
+
+  value = ast_get_value (ast, G_VARIANT_TYPE (pattern), error);
+  g_free (pattern);
+
+  return value;
+}
+
+
+static AST *parse (TokenStream  *stream,
+                   va_list      *app,
+                   GError      **error);
+
+static void
+ast_array_append (AST  ***array,
+                  gint   *n_items,
+                  AST    *ast)
+{
+  if ((*n_items & (*n_items - 1)) == 0)
+    *array = g_renew (AST *, *array, *n_items ? 2 ** n_items : 1);
+
+  (*array)[(*n_items)++] = ast;
+}
+
+static void
+ast_array_free (AST  **array,
+                gint   n_items)
+{
+  gint i;
+
+  for (i = 0; i < n_items; i++)
+    ast_free (array[i]);
+  g_free (array);
+}
+
+static gchar *
+ast_array_get_pattern (AST    **array,
+                       gint     n_items,
+                       GError **error)
+{
+  gchar *pattern;
+  gint i;
+
+  pattern = ast_get_pattern (array[0], error);
+
+  if (pattern == NULL)
+    return NULL;
+
+  for (i = 1; i < n_items; i++)
+    {
+      gchar *tmp, *merged;
+
+      tmp = ast_get_pattern (array[i], error);
+
+      if (tmp == NULL)
+        {
+          g_free (pattern);
+          return NULL;
+        }
+
+      merged = pattern_coalesce (pattern, tmp);
+      g_free (pattern);
+      pattern = merged;
+
+      if (merged == NULL)
+        /* set coalescence implies pairwise coalescence (i think).
+         * we should therefore be able to trace the failure to a single
+         * pair of values.
+         */
+        {
+          int j = 0;
+
+          while (TRUE)
+            {
+              gchar *tmp2;
+              gchar *m;
+
+              /* if 'j' reaches 'i' then we failed to find the pair */
+              g_assert (j < i);
+
+              tmp2 = ast_get_pattern (array[j], NULL);
+              g_assert (tmp2 != NULL);
+
+              m = pattern_coalesce (tmp, tmp2);
+              g_free (tmp2);
+              g_free (m);
+
+              if (m == NULL)
+                {
+                  /* we found a conflict between 'i' and 'j'.
+                   *
+                   * report the error.  note: 'j' is first.
+                   */
+                  ast_set_error (array[j], error, array[i],
+                                 "unable to find a common type");
+                  g_free (tmp);
+                  return NULL;
+                }
+
+              j++;
+            }
+        }
+    }
+
+  return pattern;
+}
+
+typedef struct
+{
+  AST ast;
+
+  AST *child;
+} Maybe;
+
+static gchar *
+maybe_get_pattern (AST     *ast,
+                   GError **error)
+{
+  Maybe *maybe = (Maybe *) ast;
+
+  if (maybe->child != NULL)
+    {
+      gchar *child_pattern;
+      gchar *pattern;
+
+      child_pattern = ast_get_pattern (maybe->child, error);
+
+      if (child_pattern == NULL)
+        return NULL;
+
+      pattern = g_strdup_printf ("m%s", child_pattern);
+      g_free (child_pattern);
+
+      return pattern;
+    }
+
+  return g_strdup ("m*");
+}
+
+static GVariant *
+maybe_get_value (AST                 *ast,
+                 const GVariantType  *type,
+                 GError             **error)
+{
+  Maybe *maybe = (Maybe *) ast;
+  GVariant *value;
+
+  if (!g_variant_type_is_maybe (type))
+    return ast_type_error (ast, type, error);
+
+  type = g_variant_type_element (type);
+
+  if (maybe->child)
+    {
+      value = ast_get_value (maybe->child, type, error);
+
+      if (value == NULL)
+        return NULL;
+    }
+  else
+    value = NULL;
+
+  return g_variant_new_maybe (type, value);
+}
+
+static void
+maybe_free (AST *ast)
+{
+  Maybe *maybe = (Maybe *) ast;
+
+  if (maybe->child != NULL)
+    ast_free (maybe->child);
+
+  g_slice_free (Maybe, maybe);
+}
+
+static AST *
+maybe_parse (TokenStream  *stream,
+             va_list      *app,
+             GError      **error)
+{
+  static const ASTClass maybe_class = {
+    maybe_get_pattern,
+    maybe_get_value, NULL,
+    maybe_free
+  };
+  AST *child = NULL;
+  Maybe *maybe;
+
+  if (token_stream_consume (stream, "just"))
+    {
+      child = parse (stream, app, error);
+      if (child == NULL)
+        return NULL;
+    }
+
+  else if (!token_stream_consume (stream, "nothing"))
+    {
+      token_stream_set_error (stream, error, TRUE, "unknown keyword");
+      return NULL;
+    }
+
+  maybe = g_slice_new (Maybe);
+  maybe->ast.class = &maybe_class;
+  maybe->child = child;
+
+  return (AST *) maybe;
+}
+
+static GVariant *
+maybe_wrapper (AST                 *ast,
+               const GVariantType  *type,
+               GError             **error)
+{
+  const GVariantType *t;
+  GVariant *value;
+  int depth;
+
+  for (depth = 0, t = type;
+       g_variant_type_is_maybe (t);
+       depth++, t = g_variant_type_element (t));
+
+  value = ast->class->get_base_value (ast, t, error);
+
+  if (value == NULL)
+    return NULL;
+
+  while (depth--)
+    value = g_variant_new_maybe (NULL, value);
+
+  return value;
+}
+
+typedef struct
+{
+  AST ast;
+
+  AST **children;
+  gint n_children;
+} Array;
+
+static gchar *
+array_get_pattern (AST     *ast,
+                   GError **error)
+{
+  Array *array = (Array *) ast;
+  gchar *pattern;
+  gchar *result;
+
+  if (array->n_children == 0)
+    return g_strdup ("Ma*");
+
+  pattern = ast_array_get_pattern (array->children, array->n_children, error);
+
+  if (pattern == NULL)
+    return NULL;
+
+  result = g_strdup_printf ("Ma%s", pattern);
+  g_free (pattern);
+
+  return result;
+}
+
+static GVariant *
+array_get_value (AST                 *ast,
+                 const GVariantType  *type,
+                 GError             **error)
+{
+  Array *array = (Array *) ast;
+  const GVariantType *childtype;
+  GVariantBuilder builder;
+  gint i;
+
+  if (!g_variant_type_is_array (type))
+    return ast_type_error (ast, type, error);
+
+  g_variant_builder_init (&builder, type);
+  childtype = g_variant_type_element (type);
+
+  for (i = 0; i < array->n_children; i++)
+    {
+      GVariant *child;
+
+      if (!(child = ast_get_value (array->children[i], childtype, error)))
+        {
+          g_variant_builder_clear (&builder);
+          return NULL;
+        }
+
+      g_variant_builder_add_value (&builder, child);
+    }
+
+  return g_variant_builder_end (&builder);
+}
+
+static void
+array_free (AST *ast)
+{
+  Array *array = (Array *) ast;
+
+  ast_array_free (array->children, array->n_children);
+  g_slice_free (Array, array);
+}
+
+static AST *
+array_parse (TokenStream  *stream,
+             va_list      *app,
+             GError      **error)
+{
+  static const ASTClass array_class = {
+    array_get_pattern,
+    maybe_wrapper, array_get_value,
+    array_free
+  };
+  gboolean need_comma = FALSE;
+  Array *array;
+
+  array = g_slice_new (Array);
+  array->ast.class = &array_class;
+  array->children = NULL;
+  array->n_children = 0;
+
+  token_stream_assert (stream, "[");
+  while (!token_stream_consume (stream, "]"))
+    {
+      AST *child;
+
+      if (need_comma &&
+          !token_stream_require (stream, ",",
+                                 " or `]' to follow array element",
+                                 error))
+        goto error;
+
+      child = parse (stream, app, error);
+
+      if (!child)
+        goto error;
+
+      ast_array_append (&array->children, &array->n_children, child);
+      need_comma = TRUE;
+    }
+
+  return (AST *) array;
+
+ error:
+  ast_array_free (array->children, array->n_children);
+  g_slice_free (Array, array);
+
+  return NULL;
+}
+
+typedef struct
+{
+  AST ast;
+
+  AST **children;
+  gint n_children;
+} Tuple;
+
+static gchar *
+tuple_get_pattern (AST     *ast,
+                   GError **error)
+{
+  Tuple *tuple = (Tuple *) ast;
+  gchar *result = NULL;
+  gchar **parts;
+  gint i;
+
+  parts = g_new (gchar *, tuple->n_children + 4);
+  parts[tuple->n_children + 1] = (gchar *) ")";
+  parts[tuple->n_children + 2] = NULL;
+  parts[0] = (gchar *) "M(";
+
+  for (i = 0; i < tuple->n_children; i++)
+    if (!(parts[i + 1] = ast_get_pattern (tuple->children[i], error)))
+      break;
+
+  if (i == tuple->n_children)
+    result = g_strjoinv ("", parts);
+
+  /* parts[0] should not be freed */
+  while (i)
+    g_free (parts[i--]);
+  g_free (parts);
+
+  return result;
+}
+
+static GVariant *
+tuple_get_value (AST                 *ast,
+                 const GVariantType  *type,
+                 GError             **error)
+{
+  Tuple *tuple = (Tuple *) ast;
+  const GVariantType *childtype;
+  GVariantBuilder builder;
+  gint i;
+
+  if (!g_variant_type_is_tuple (type))
+    return ast_type_error (ast, type, error);
+
+  g_variant_builder_init (&builder, type);
+  childtype = g_variant_type_first (type);
+
+  for (i = 0; i < tuple->n_children; i++)
+    {
+      GVariant *child;
+
+      if (!(child = ast_get_value (tuple->children[i], childtype, error)))
+        {
+          g_variant_builder_clear (&builder);
+          return FALSE;
+        }
+
+      g_variant_builder_add_value (&builder, child);
+      childtype = g_variant_type_next (childtype);
+    }
+
+  return g_variant_builder_end (&builder);
+}
+
+static void
+tuple_free (AST *ast)
+{
+  Tuple *tuple = (Tuple *) ast;
+
+  ast_array_free (tuple->children, tuple->n_children);
+  g_slice_free (Tuple, tuple);
+}
+
+static AST *
+tuple_parse (TokenStream  *stream,
+             va_list      *app,
+             GError      **error)
+{
+  static const ASTClass tuple_class = {
+    tuple_get_pattern,
+    maybe_wrapper, tuple_get_value,
+    tuple_free
+  };
+  gboolean need_comma = FALSE;
+  gboolean first = TRUE;
+  Tuple *tuple;
+
+  tuple = g_slice_new (Tuple);
+  tuple->ast.class = &tuple_class;
+  tuple->children = NULL;
+  tuple->n_children = 0;
+
+  token_stream_assert (stream, "(");
+  while (!token_stream_consume (stream, ")"))
+    {
+      AST *child;
+
+      if (need_comma &&
+          !token_stream_require (stream, ",",
+                                 " or `)' to follow tuple element",
+                                 error))
+        goto error;
+
+      child = parse (stream, app, error);
+
+      if (!child)
+        goto error;
+
+      ast_array_append (&tuple->children, &tuple->n_children, child);
+
+      /* the first time, we absolutely require a comma, so grab it here
+       * and leave need_comma = FALSE so that the code above doesn't
+       * require a second comma.
+       *
+       * the second and remaining times, we set need_comma = TRUE.
+       */
+      if (first)
+        {
+          if (!token_stream_require (stream, ",",
+                                     " after first tuple element", error))
+            goto error;
+
+          first = FALSE;
+        }
+      else
+        need_comma = TRUE;
+    }
+
+  return (AST *) tuple;
+
+ error:
+  ast_array_free (tuple->children, tuple->n_children);
+  g_slice_free (Tuple, tuple);
+
+  return NULL;
+}
+
+typedef struct
+{
+  AST ast;
+
+  AST *value;
+} Variant;
+
+static gchar *
+variant_get_pattern (AST     *ast,
+                     GError **error)
+{
+  return g_strdup ("Mv");
+}
+
+static GVariant *
+variant_get_value (AST                 *ast,
+                   const GVariantType  *type,
+                   GError             **error)
+{
+  Variant *variant = (Variant *) ast;
+  GVariant *child;
+
+  g_assert (g_variant_type_equal (type, G_VARIANT_TYPE_VARIANT));
+  child = ast_resolve (variant->value, error);
+
+  if (child == NULL)
+    return NULL;
+
+  return g_variant_new_variant (child);
+}
+
+static void
+variant_free (AST *ast)
+{
+  Variant *variant = (Variant *) ast;
+
+  ast_free (variant->value);
+  g_slice_free (Variant, variant);
+}
+
+static AST *
+variant_parse (TokenStream  *stream,
+               va_list      *app,
+               GError      **error)
+{
+  static const ASTClass variant_class = {
+    variant_get_pattern,
+    maybe_wrapper, variant_get_value,
+    variant_free
+  };
+  Variant *variant;
+  AST *value;
+
+  token_stream_assert (stream, "<");
+  value = parse (stream, app, error);
+
+  if (!value)
+    return NULL;
+
+  if (!token_stream_require (stream, ">", " to follow variant value", error))
+    {
+      ast_free (value);
+      return NULL;
+    }
+
+  variant = g_slice_new (Variant);
+  variant->ast.class = &variant_class;
+  variant->value = value;
+
+  return (AST *) variant;
+}
+
+typedef struct
+{
+  AST ast;
+
+  AST **keys;
+  AST **values;
+  gint n_children;
+} Dictionary;
+
+static gchar *
+dictionary_get_pattern (AST     *ast,
+                        GError **error)
+{
+  Dictionary *dict = (Dictionary *) ast;
+  gchar *value_pattern;
+  gchar *key_pattern;
+  gchar key_char;
+  gchar *result;
+
+  if (dict->n_children == 0)
+    return g_strdup ("Ma{**}");
+
+  key_pattern = ast_array_get_pattern (dict->keys,
+                                       abs (dict->n_children),
+                                       error);
+
+  if (key_pattern == NULL)
+    return NULL;
+
+  /* we can not have maybe keys */
+  if (key_pattern[0] == 'M')
+    key_char = key_pattern[1];
+  else
+    key_char = key_pattern[0];
+
+  g_free (key_pattern);
+
+  /* the basic types,
+   * plus undetermined number type and undetermined string type.
+   */
+  if (!strchr ("bynqiuxthdsogNS", key_char))
+    {
+      ast_set_error (ast, error, NULL,
+                     "dictionary keys must have basic types");
+      return NULL;
+    }
+
+  value_pattern = ast_get_pattern (dict->values[0], error);
+
+  if (value_pattern == NULL)
+    return NULL;
+
+  result = g_strdup_printf ("M%s{%c%s}",
+                            dict->n_children > 0 ? "a" : "",
+                            key_char, value_pattern);
+  g_free (value_pattern);
+
+  return result;
+}
+
+static GVariant *
+dictionary_get_value (AST                 *ast,
+                      const GVariantType  *type,
+                      GError             **error)
+{
+  Dictionary *dict = (Dictionary *) ast;
+
+  if (dict->n_children == -1)
+    {
+      const GVariantType *subtype;
+      GVariantBuilder builder;
+      GVariant *subvalue;
+
+      if (!g_variant_type_is_dict_entry (type))
+        return ast_type_error (ast, type, error);
+
+      g_variant_builder_init (&builder, type);
+
+      subtype = g_variant_type_key (type);
+      if (!(subvalue = ast_get_value (dict->keys[0], subtype, error)))
+        {
+          g_variant_builder_clear (&builder);
+          return FALSE;
+        }
+      g_variant_builder_add_value (&builder, subvalue);
+
+      subtype = g_variant_type_value (type);
+      if (!(subvalue = ast_get_value (dict->values[0], subtype, error)))
+        {
+          g_variant_builder_clear (&builder);
+          return FALSE;
+        }
+      g_variant_builder_add_value (&builder, subvalue);
+
+      return g_variant_builder_end (&builder);
+    }
+  else
+    {
+      const GVariantType *entry, *key, *val;
+      GVariantBuilder builder;
+      gint i;
+
+      if (!g_variant_type_is_subtype_of (type, G_VARIANT_TYPE_DICTIONARY))
+        return ast_type_error (ast, type, error);
+
+      entry = g_variant_type_element (type);
+      key = g_variant_type_key (entry);
+      val = g_variant_type_value (entry);
+
+      g_variant_builder_init (&builder, type);
+
+      for (i = 0; i < dict->n_children; i++)
+        {
+          GVariant *subvalue;
+
+          g_variant_builder_open (&builder, entry);
+
+          if (!(subvalue = ast_get_value (dict->keys[i], key, error)))
+            {
+              g_variant_builder_clear (&builder);
+              return FALSE;
+            }
+          g_variant_builder_add_value (&builder, subvalue);
+
+          if (!(subvalue = ast_get_value (dict->values[i], val, error)))
+            {
+              g_variant_builder_clear (&builder);
+              return FALSE;
+            }
+          g_variant_builder_add_value (&builder, subvalue);
+          g_variant_builder_close (&builder);
+        }
+
+      return g_variant_builder_end (&builder);
+    }
+}
+
+static void
+dictionary_free (AST *ast)
+{
+  Dictionary *dict = (Dictionary *) ast;
+  gint n_children;
+
+  if (dict->n_children > -1)
+    n_children = dict->n_children;
+  else
+    n_children = 1;
+
+  ast_array_free (dict->keys, n_children);
+  ast_array_free (dict->values, n_children);
+  g_slice_free (Dictionary, dict);
+}
+
+static AST *
+dictionary_parse (TokenStream  *stream,
+                  va_list      *app,
+                  GError      **error)
+{
+  static const ASTClass dictionary_class = {
+    dictionary_get_pattern,
+    maybe_wrapper, dictionary_get_value,
+    dictionary_free
+  };
+  gint n_keys, n_values;
+  gboolean only_one;
+  Dictionary *dict;
+  AST *first;
+
+  dict = g_slice_new (Dictionary);
+  dict->ast.class = &dictionary_class;
+  dict->keys = NULL;
+  dict->values = NULL;
+  n_keys = n_values = 0;
+
+  token_stream_assert (stream, "{");
+
+  if (token_stream_consume (stream, "}"))
+    {
+      dict->n_children = 0;
+      return (AST *) dict;
+    }
+
+  if ((first = parse (stream, app, error)) == NULL)
+    goto error;
+
+  ast_array_append (&dict->keys, &n_keys, first);
+
+  only_one = token_stream_consume (stream, ",");
+  if (!only_one &&
+      !token_stream_require (stream, ":",
+                             " or `,' to follow dictionary entry key",
+                             error))
+    goto error;
+
+  if ((first = parse (stream, app, error)) == NULL)
+    goto error;
+
+  ast_array_append (&dict->values, &n_values, first);
+
+  if (only_one)
+    {
+      if (!token_stream_require (stream, "}", " at end of dictionary entry",
+                                 error))
+        goto error;
+
+      g_assert (n_keys == 1 && n_values == 1);
+      dict->n_children = -1;
+
+      return (AST *) dict;
+    }
+
+  while (!token_stream_consume (stream, "}"))
+    {
+      AST *child;
+
+      if (!token_stream_require (stream, ",",
+                                 " or `}' to follow dictionary entry", error))
+        goto error;
+
+      child = parse (stream, app, error);
+
+      if (!child)
+        goto error;
+
+      ast_array_append (&dict->keys, &n_keys, child);
+
+      if (!token_stream_require (stream, ":",
+                                 " to follow dictionary entry key", error))
+        goto error;
+
+      child = parse (stream, app, error);
+
+      if (!child)
+        goto error;
+
+      ast_array_append (&dict->values, &n_values, child);
+    }
+
+  g_assert (n_keys == n_values);
+  dict->n_children = n_keys;
+
+  return (AST *) dict;
+
+ error:
+  ast_array_free (dict->keys, n_keys);
+  ast_array_free (dict->values, n_values);
+  g_slice_free (Dictionary, dict);
+
+  return NULL;
+}
+
+typedef struct
+{
+  AST ast;
+  gchar *string;
+} String;
+
+static gchar *
+string_get_pattern (AST     *ast,
+                    GError **error)
+{
+  return g_strdup ("MS");
+}
+
+static GVariant *
+string_get_value (AST                 *ast,
+                  const GVariantType  *type,
+                  GError             **error)
+{
+  String *string = (String *) ast;
+
+  if (g_variant_type_equal (type, G_VARIANT_TYPE_STRING))
+    return g_variant_new_string (string->string);
+
+  else if (g_variant_type_equal (type, G_VARIANT_TYPE_OBJECT_PATH))
+    {
+      if (!g_variant_is_object_path (string->string))
+        {
+          ast_set_error (ast, error, NULL, "not a valid object path");
+          return NULL;
+        }
+
+      return g_variant_new_object_path (string->string);
+    }
+
+  else if (g_variant_type_equal (type, G_VARIANT_TYPE_SIGNATURE))
+    {
+      if (!g_variant_is_signature (string->string))
+        {
+          ast_set_error (ast, error, NULL, "not a valid signature");
+          return NULL;
+        }
+
+      return g_variant_new_signature (string->string);
+    }
+
+  else
+    return ast_type_error (ast, type, error);
+}
+
+static void
+string_free (AST *ast)
+{
+  String *string = (String *) ast;
+
+  g_free (string->string);
+  g_slice_free (String, string);
+}
+
+static AST *
+string_parse (TokenStream  *stream,
+              va_list      *app,
+              GError      **error)
+{
+  static const ASTClass string_class = {
+    string_get_pattern,
+    maybe_wrapper, string_get_value,
+    string_free
+  };
+  String *string;
+  SourceRef ref;
+  gchar *token;
+  gsize length;
+  gchar quote;
+  gchar *str;
+  gint i, j;
+
+  token_stream_start_ref (stream, &ref);
+  token = token_stream_get (stream);
+  token_stream_end_ref (stream, &ref);
+  length = strlen (token);
+  quote = token[0];
+
+  str = g_malloc (length);
+  g_assert (quote == '"' || quote == '\'');
+  j = 0;
+  i = 1;
+  while (token[i] != quote)
+    switch (token[i])
+      {
+      case '\0':
+        parser_set_error (error, &ref, NULL,
+                          "unterminated string constant");
+        g_free (token);
+        return NULL;
+
+      case '\\':
+        switch (token[++i])
+          {
+          case '\0':
+            parser_set_error (error, &ref, NULL,
+                              "unterminated string constant");
+            g_free (token);
+            return NULL;
+
+          case '0': case '1': case '2': case '3':
+          case '4': case '5': case '6': case '7':
+            {
+              /* up to 3 characters */
+              guchar val = token[i++] - '0';
+
+              if ('0' <= token[i] && token[i] < '8')
+                val = (val << 3) | (token[i++] - '0');
+
+              if ('0' <= token[i] && token[i] < '8')
+                val = (val << 3) | (token[i++] - '0');
+
+              str[j++] = val;
+            }
+            continue;
+
+          case 'b': str[j++] = '\b'; i++; continue;
+          case 'f': str[j++] = '\f'; i++; continue;
+          case 'n': str[j++] = '\n'; i++; continue;
+          case 'r': str[j++] = '\r'; i++; continue;
+          case 't': str[j++] = '\t'; i++; continue;
+          case '\n': i++; continue;
+          }
+
+      default:
+        str[j++] = token[i++];
+      }
+  str[j++] = '\0';
+  g_free (token);
+
+  string = g_slice_new (String);
+  string->ast.class = &string_class;
+  string->string = str;
+
+  token_stream_next (stream);
+
+  return (AST *) string;
+}
+
+typedef struct
+{
+  AST ast;
+
+  gchar *token;
+} Number;
+
+static gchar *
+number_get_pattern (AST     *ast,
+                    GError **error)
+{
+  Number *number = (Number *) ast;
+
+  if (strchr (number->token, '.') ||
+      (!g_str_has_prefix (number->token, "0x") &&
+       strchr (number->token, 'e')))
+    return g_strdup ("Md");
+
+  return g_strdup ("MN");
+}
+
+static GVariant *
+number_overflow (AST                 *ast,
+                 const GVariantType  *type,
+                 GError             **error)
+{
+  ast_set_error (ast, error, NULL, "number out of range for type `%c'",
+                 g_variant_type_peek_string (type)[0]);
+  return NULL;
+}
+
+static GVariant *
+number_get_value (AST                 *ast,
+                  const GVariantType  *type,
+                  GError             **error)
+{
+  Number *number = (Number *) ast;
+  const gchar *token;
+  gboolean negative;
+  gboolean floating;
+  guint64 abs_val;
+  gdouble dbl_val;
+  gchar *end;
+
+  token = number->token;
+
+  if (g_variant_type_equal (type, G_VARIANT_TYPE_DOUBLE))
+    {
+      floating = TRUE;
+
+      errno = 0;
+      dbl_val = g_ascii_strtod (token, &end);
+      if (dbl_val != 0.0 && errno == ERANGE)
+        {
+          ast_set_error (ast, error, NULL, "number too big for any type");
+          return NULL;
+        }
+    }
+  else
+    {
+      floating = FALSE;
+      negative = token[0] == '-';
+      if (token[0] == '-')
+        token++;
+
+      errno = 0;
+      abs_val = g_ascii_strtoull (token, &end, 0);
+      if (abs_val == G_MAXUINT64 && errno == ERANGE)
+        {
+          ast_set_error (ast, error, NULL, "integer too big for any type");
+          return NULL;
+        }
+
+      if (abs_val == 0)
+        negative = FALSE;
+    }
+
+  if (*end != '\0')
+    {
+      SourceRef ref;
+
+      ref = ast->source_ref;
+      ref.start += end - number->token;
+      ref.end = ref.start + 1;
+
+      parser_set_error (error, &ref, NULL,
+                        "invalid character in number");
+      return NULL;
+     }
+
+  if (floating)
+    return g_variant_new_double (dbl_val);
+
+  switch (*g_variant_type_peek_string (type))
+    {
+    case 'y':
+      if (negative || abs_val > G_MAXUINT8)
+        return number_overflow (ast, type, error);
+      return g_variant_new_byte (abs_val);
+
+    case 'n':
+      if (abs_val - negative > G_MAXINT16)
+        return number_overflow (ast, type, error);
+      return g_variant_new_int16 (negative ? -abs_val : abs_val);
+
+    case 'q':
+      if (negative || abs_val > G_MAXUINT16)
+        return number_overflow (ast, type, error);
+      return g_variant_new_uint16 (negative ? -abs_val : abs_val);
+
+    case 'i':
+      if (abs_val - negative > G_MAXINT32)
+        return number_overflow (ast, type, error);
+      return g_variant_new_int32 (negative ? -abs_val : abs_val);
+
+    case 'u':
+      if (negative || abs_val > G_MAXUINT32)
+        return number_overflow (ast, type, error);
+      return g_variant_new_uint32 (negative ? -abs_val : abs_val);
+
+    case 'x':
+      if (abs_val - negative > G_MAXINT64)
+        return number_overflow (ast, type, error);
+      return g_variant_new_int64 (negative ? -abs_val : abs_val);
+
+    case 't':
+      if (negative)
+        return number_overflow (ast, type, error);
+      return g_variant_new_uint64 (negative ? -abs_val : abs_val);
+
+    case 'h':
+      if (abs_val - negative > G_MAXINT32)
+        return number_overflow (ast, type, error);
+      return g_variant_new_handle (negative ? -abs_val : abs_val);
+
+    default:
+      return ast_type_error (ast, type, error);
+    }
+}
+
+static void
+number_free (AST *ast)
+{
+  Number *number = (Number *) ast;
+
+  g_free (number->token);
+  g_slice_free (Number, number);
+}
+
+static AST *
+number_parse (TokenStream  *stream,
+              va_list      *app,
+              GError      **error)
+{
+  static const ASTClass number_class = {
+    number_get_pattern,
+    maybe_wrapper, number_get_value,
+    number_free
+  };
+  Number *number;
+
+  number = g_slice_new (Number);
+  number->ast.class = &number_class;
+  number->token = token_stream_get (stream);
+  token_stream_next (stream);
+
+  return (AST *) number;
+}
+
+typedef struct
+{
+  AST ast;
+  gboolean value;
+} Boolean;
+
+static gchar *
+boolean_get_pattern (AST     *ast,
+                     GError **error)
+{
+  return g_strdup ("Mb");
+}
+
+static GVariant *
+boolean_get_value (AST                 *ast,
+                   const GVariantType  *type,
+                   GError             **error)
+{
+  Boolean *boolean = (Boolean *) ast;
+
+  if (!g_variant_type_equal (type, G_VARIANT_TYPE_BOOLEAN))
+    return ast_type_error (ast, type, error);
+
+  return g_variant_new_boolean (boolean->value);
+}
+
+static void
+boolean_free (AST *ast)
+{
+  Boolean *boolean = (Boolean *) ast;
+
+  g_slice_free (Boolean, boolean);
+}
+
+static AST *
+boolean_new (gboolean value)
+{
+  static const ASTClass boolean_class = {
+    boolean_get_pattern,
+    maybe_wrapper, boolean_get_value,
+    boolean_free
+  };
+  Boolean *boolean;
+
+  boolean = g_slice_new (Boolean);
+  boolean->ast.class = &boolean_class;
+  boolean->value = value;
+
+  return (AST *) boolean;
+}
+
+typedef struct
+{
+  AST ast;
+
+  GVariant *value;
+} Positional;
+
+static gchar *
+positional_get_pattern (AST     *ast,
+                        GError **error)
+{
+  Positional *positional = (Positional *) ast;
+
+  return g_strdup (g_variant_get_type_string (positional->value));
+}
+
+static GVariant *
+positional_get_value (AST                 *ast,
+                      const GVariantType  *type,
+                      GError             **error)
+{
+  Positional *positional = (Positional *) ast;
+  GVariant *value;
+
+  g_assert (positional->value != NULL);
+
+  if G_UNLIKELY (!g_variant_is_of_type (positional->value, type))
+    return ast_type_error (ast, type, error);
+
+  /* NOTE: if _get is called more than once then
+   * things get messed up with respect to floating refs.
+   *
+   * fortunately, this function should only ever get called once.
+   */
+  g_assert (positional->value != NULL);
+  value = positional->value;
+  positional->value = NULL;
+
+  return value;
+}
+
+static void
+positional_free (AST *ast)
+{
+  Positional *positional = (Positional *) ast;
+
+  /* if positional->value is set, just leave it.
+   * memory management doesn't matter in case of programmer error.
+   */
+  g_slice_free (Positional, positional);
+}
+
+static AST *
+positional_parse (TokenStream  *stream,
+                  va_list      *app,
+                  GError      **error)
+{
+  static const ASTClass positional_class = {
+    positional_get_pattern,
+    positional_get_value, NULL,
+    positional_free
+  };
+  Positional *positional;
+  const gchar *endptr;
+  gchar *token;
+
+  token = token_stream_get (stream);
+  g_assert (token[0] == '%');
+
+  positional = g_slice_new (Positional);
+  positional->ast.class = &positional_class;
+  positional->value = g_variant_new_va (token + 1, &endptr, app);
+
+  if (*endptr || positional->value == NULL)
+    {
+      token_stream_set_error (stream, error, TRUE,
+                              "invalid GVariant format string");
+      /* memory management doesn't matter in case of programmer error. */
+      return NULL;
+    }
+
+  token_stream_next (stream);
+  g_free (token);
+
+  return (AST *) positional;
+}
+
+typedef struct
+{
+  AST ast;
+
+  GVariantType *type;
+  AST *child;
+} TypeDecl;
+
+static gchar *
+typedecl_get_pattern (AST     *ast,
+                      GError **error)
+{
+  TypeDecl *decl = (TypeDecl *) ast;
+
+  return g_variant_type_dup_string (decl->type);
+}
+
+static GVariant *
+typedecl_get_value (AST                 *ast,
+                    const GVariantType  *type,
+                    GError             **error)
+{
+  TypeDecl *decl = (TypeDecl *) ast;
+
+  return ast_get_value (decl->child, type, error);
+}
+
+static void
+typedecl_free (AST *ast)
+{
+  TypeDecl *decl = (TypeDecl *) ast;
+
+  ast_free (decl->child);
+  g_variant_type_free (decl->type);
+  g_slice_free (TypeDecl, decl);
+}
+
+static AST *
+typedecl_parse (TokenStream  *stream,
+                va_list      *app,
+                GError      **error)
+{
+  static const ASTClass typedecl_class = {
+    typedecl_get_pattern,
+    typedecl_get_value, NULL,
+    typedecl_free
+  };
+  GVariantType *type;
+  TypeDecl *decl;
+  AST *child;
+
+  if (token_stream_peek (stream, '@'))
+    {
+      gchar *token;
+
+      token = token_stream_get (stream);
+
+      if (!g_variant_type_string_is_valid (token + 1))
+        {
+          token_stream_set_error (stream, error, TRUE,
+                                  "invalid type declaration");
+          g_free (token);
+
+          return NULL;
+        }
+
+      type = g_variant_type_new (token + 1);
+
+      if (!g_variant_type_is_definite (type))
+        {
+          token_stream_set_error (stream, error, TRUE,
+                                  "type declarations must be definite");
+          g_variant_type_free (type);
+          g_free (token);
+
+          return NULL;
+        }
+
+      token_stream_next (stream);
+      g_free (token);
+    }
+  else
+    {
+      if (token_stream_consume (stream, "boolean"))
+        type = g_variant_type_copy (G_VARIANT_TYPE_BOOLEAN);
+
+      else if (token_stream_consume (stream, "byte"))
+        type = g_variant_type_copy (G_VARIANT_TYPE_BYTE);
+
+      else if (token_stream_consume (stream, "int16"))
+        type = g_variant_type_copy (G_VARIANT_TYPE_INT16);
+
+      else if (token_stream_consume (stream, "uint16"))
+        type = g_variant_type_copy (G_VARIANT_TYPE_UINT16);
+
+      else if (token_stream_consume (stream, "int32"))
+        type = g_variant_type_copy (G_VARIANT_TYPE_INT32);
+
+      else if (token_stream_consume (stream, "handle"))
+        type = g_variant_type_copy (G_VARIANT_TYPE_HANDLE);
+
+      else if (token_stream_consume (stream, "uint32"))
+        type = g_variant_type_copy (G_VARIANT_TYPE_UINT32);
+
+      else if (token_stream_consume (stream, "int64"))
+        type = g_variant_type_copy (G_VARIANT_TYPE_INT64);
+
+      else if (token_stream_consume (stream, "uint64"))
+        type = g_variant_type_copy (G_VARIANT_TYPE_UINT64);
+
+      else if (token_stream_consume (stream, "double"))
+        type = g_variant_type_copy (G_VARIANT_TYPE_DOUBLE);
+
+      else if (token_stream_consume (stream, "string"))
+        type = g_variant_type_copy (G_VARIANT_TYPE_STRING);
+
+      else if (token_stream_consume (stream, "objectpath"))
+        type = g_variant_type_copy (G_VARIANT_TYPE_OBJECT_PATH);
+
+      else if (token_stream_consume (stream, "signature"))
+        type = g_variant_type_copy (G_VARIANT_TYPE_SIGNATURE);
+
+      else
+        {
+          token_stream_set_error (stream, error, TRUE, "unknown keyword");
+          return NULL;
+        }
+    }
+
+  if ((child = parse (stream, app, error)) == NULL)
+    {
+      g_variant_type_free (type);
+      return NULL;
+    }
+
+  decl = g_slice_new (TypeDecl);
+  decl->ast.class = &typedecl_class;
+  decl->type = type;
+  decl->child = child;
+
+  return (AST *) decl;
+}
+
+static AST *
+parse (TokenStream  *stream,
+       va_list      *app,
+       GError      **error)
+{
+  SourceRef source_ref;
+  AST *result;
+
+  token_stream_prepare (stream);
+  token_stream_start_ref (stream, &source_ref);
+
+  if (token_stream_peek (stream, '['))
+    result = array_parse (stream, app, error);
+
+  else if (token_stream_peek (stream, '('))
+    result = tuple_parse (stream, app, error);
+
+  else if (token_stream_peek (stream, '<'))
+    result = variant_parse (stream, app, error);
+
+  else if (token_stream_peek (stream, '{'))
+    result = dictionary_parse (stream, app, error);
+
+  else if (app && token_stream_peek (stream, '%'))
+    result = positional_parse (stream, app, error);
+
+  else if (token_stream_consume (stream, "true"))
+    result = boolean_new (TRUE);
+
+  else if (token_stream_consume (stream, "false"))
+    result = boolean_new (FALSE);
+
+  else if (token_stream_peek (stream, 'n') ||
+           token_stream_peek (stream, 'j'))
+    result = maybe_parse (stream, app, error);
+
+  else if (token_stream_peek (stream, '@') ||
+           token_stream_is_keyword (stream))
+    result = typedecl_parse (stream, app, error);
+
+  else if (token_stream_is_numeric (stream))
+    result = number_parse (stream, app, error);
+
+  else if (token_stream_peek (stream, '\'') ||
+           token_stream_peek (stream, '"'))
+    result = string_parse (stream, app, error);
+
+  else
+    {
+      token_stream_set_error (stream, error, FALSE, "expected value");
+      return NULL;
+    }
+
+  if (result != NULL)
+    {
+      token_stream_end_ref (stream, &source_ref);
+      result->source_ref = source_ref;
+    }
+
+  return result;
+}
+
+/**
+ * g_variant_parse:
+ * @type: a #GVariantType, or %NULL
+ * @text: a string containing a GVariant in text form
+ * @limit: a pointer to the end of @text, or %NULL
+ * @endptr: a location to store the end pointer, or %NULL
+ * @error: a pointer to a %NULL #GError pointer, or %NULL
+ * @Returns: a reference to a #GVariant, or %NULL
+ *
+ * Parses a #GVariant from a text representation.
+ *
+ * A single #GVariant is parsed from the content of @text.
+ *
+ * The memory at @limit will never be accessed and the parser behaves as
+ * if the character at @limit is the nul terminator.  This has the
+ * effect of bounding @text.
+ *
+ * If @endptr is non-%NULL then @text is permitted to contain data
+ * following the value that this function parses and @endptr will be
+ * updated to point to the first character past the end of the text
+ * parsed by this function.  If @endptr is %NULL and there is extra data
+ * then an error is returned.
+ *
+ * If @type is non-%NULL then the value will be parsed to have that
+ * type.  This may result in additional parse errors (in the case that
+ * the parsed value doesn't fit the type) but may also result in fewer
+ * errors (in the case that the type would have been ambiguous, such as
+ * with empty arrays).
+ *
+ * In the event that the parsing is successful, the resulting #GVariant
+ * is returned.
+ *
+ * In case of any error, %NULL will be returned.  If @error is non-%NULL
+ * then it will be set to reflect the error that occured.
+ *
+ * Officially, the language understood by the parser is "any string
+ * produced by g_variant_print()".
+ **/
+GVariant *
+g_variant_parse (const GVariantType  *type,
+                 const gchar         *text,
+                 const gchar         *limit,
+                 const gchar        **endptr,
+                 GError             **error)
+{
+  TokenStream stream = {  };
+  GVariant *result = NULL;
+  AST *ast;
+
+  g_return_val_if_fail (text != NULL, NULL);
+  g_return_val_if_fail (text == limit || text != NULL, NULL);
+
+  stream.start = text;
+  stream.stream = text;
+  stream.end = limit;
+
+  if ((ast = parse (&stream, NULL, error)))
+    {
+      if (type == NULL)
+        result = ast_resolve (ast, error);
+      else
+        result = ast_get_value (ast, type, error);
+
+      if (result != NULL)
+        {
+          g_variant_ref_sink (result);
+
+          if (endptr == NULL)
+            {
+              while (stream.stream != limit &&
+                     g_ascii_isspace (*stream.stream))
+                stream.stream++;
+
+              if (stream.stream != limit && *stream.stream != '\0')
+                {
+                  SourceRef ref = { stream.stream - text,
+                                    stream.stream - text };
+
+                  parser_set_error (error, &ref, NULL,
+                                    "expected end of input");
+                  g_variant_unref (result);
+
+                  result = NULL;
+                }
+            }
+          else
+            *endptr = stream.stream;
+        }
+
+      ast_free (ast);
+    }
+
+  return result;
+}
+
+/**
+ * g_variant_new_parsed_va:
+ * @format: a text format #GVariant
+ * @app: a pointer to a #va_list
+ * @returns: a new floating #GVariant instance
+ *
+ * Parses @format and returns the result.
+ *
+ * This is the version of g_variant_new_parsed() intended to be used
+ * from libraries.
+ **/
+GVariant *
+g_variant_new_parsed_va (const gchar *format,
+                         va_list     *app)
+{
+  TokenStream stream = {  };
+  GVariant *result = NULL;
+  GError *error = NULL;
+  AST *ast;
+
+  g_return_val_if_fail (format != NULL, NULL);
+  g_return_val_if_fail (app != NULL, NULL);
+
+  stream.start = format;
+  stream.stream = format;
+  stream.end = NULL;
+
+  if ((ast = parse (&stream, app, &error)))
+    {
+      result = ast_resolve (ast, &error);
+      ast_free (ast);
+    }
+
+  if (result == NULL)
+    g_error ("g_variant_new_parsed: %s", error->message);
+
+  if (*stream.stream)
+    g_error ("g_variant_new_parsed: trailing text after value");
+
+  return result;
+}
+
+/**
+ * g_variant_new_parsed:
+ * @format: a text format #GVariant
+ * @...: arguments as per @format
+ *
+ * Parses @format and returns the result.
+ *
+ * @format must be a text format #GVariant with one extention: at any
+ * point that a value may appear in the text, a '%' character followed
+ * by a GVariant format string (as per g_variant_new()) may appear.  In
+ * that case, the same arguments are collected from the argument list as
+ * g_variant_new() would have collected.
+ *
+ * Consider this simple example:
+ *
+ * <informalexample><programlisting>
+ *  g_variant_new_parsed ("[('one', 1), ('two', %i), (%s, 3)]", 2, "three");
+ * </programlisting></informalexample>
+ *
+ * In the example, the variable argument parameters are collected and
+ * filled in as if they were part of the original string to produce the
+ * result of <code>[('one', 1), ('two', 2), ('three', 3)]</code>.
+ *
+ * This function is intended only to be used with @format as a string
+ * literal.  Any parse error is fatal to the calling process.  If you
+ * want to parse data from untrusted sources, use g_variant_parse().
+ *
+ * You may not use this function to return, unmodified, a single
+ * #GVariant pointer from the argument list.  ie: @format may not solely
+ * be anything along the lines of "%*", "%?", "%r", or anything starting
+ * with "%@".
+ **/
+GVariant *
+g_variant_new_parsed (const gchar *format,
+                      ...)
+{
+  GVariant *result;
+  va_list ap;
+
+  va_start (ap, format);
+  result = g_variant_new_parsed_va (format, &ap);
+  va_end (ap);
+
+  return result;
+}
+
+#define __G_VARIANT_PARSER_C__
+#include "galiasdef.c"
diff --git a/glib/gvariant.c b/glib/gvariant.c
index 154b0ba..e3e7cdc 100644
--- a/glib/gvariant.c
+++ b/glib/gvariant.c
@@ -1454,31 +1454,31 @@ g_variant_print_string (GVariant *value,
           /* Nested maybes:
            *
            * Consider the case of the type "mmi".  In this case we could
-           * write "Just Just 4", but "4" alone is totally unambiguous,
-           * so we try to drop "Just" where possible.
+           * write "just just 4", but "4" alone is totally unambiguous,
+           * so we try to drop "just" where possible.
            *
-           * We have to be careful not to always drop "Just", though,
-           * since "Nothing" needs to be distinguishable from "Just
-           * Nothing".  The case where we need to ensure we keep the
-           * "Just" is actually exactly the case where we have a nested
+           * We have to be careful not to always drop "just", though,
+           * since "nothing" needs to be distinguishable from "just
+           * nothing".  The case where we need to ensure we keep the
+           * "just" is actually exactly the case where we have a nested
            * Nothing.
            *
            * Instead of searching for that nested Nothing, we just print
            * the contained value into a separate string and see if we
-           * end up with "Nothing" at the end of it.  If so, we need to
-           * add "Just" at our level.
+           * end up with "nothing" at the end of it.  If so, we need to
+           * add "just" at our level.
            */
           element = g_variant_get_child_value (value, 0);
           printed_child = g_variant_print (element, FALSE);
           g_variant_unref (element);
 
-          if (g_str_has_suffix (printed_child, "Nothing"))
-            g_string_append (string, "Just ");
+          if (g_str_has_suffix (printed_child, "nothing"))
+            g_string_append (string, "just ");
           g_string_append (string, printed_child);
           g_free (printed_child);
         }
       else
-        g_string_append (string, "Nothing");
+        g_string_append (string, "nothing");
 
       break;
 
@@ -1633,7 +1633,11 @@ g_variant_print_string (GVariant *value,
         const gchar *str = g_variant_get_string (value, NULL);
         gchar *escaped = g_strescape (str, NULL);
 
-        g_string_append_printf (string, "\'%s\'", escaped);
+        /* use double quotes only if a ' is in the string */
+        if (strchr (str, '\''))
+          g_string_append_printf (string, "\"%s\"", escaped);
+        else
+          g_string_append_printf (string, "'%s'", escaped);
 
         g_free (escaped);
       }
diff --git a/glib/gvariant.h b/glib/gvariant.h
index 19c57c6..f51f793 100644
--- a/glib/gvariant.h
+++ b/glib/gvariant.h
@@ -176,6 +176,9 @@ struct _GVariantBuilder {
   gsize x[16];
 };
 
+#define G_VARIANT_PARSE_ERROR (g_variant_parser_get_error_quark ())
+GQuark                          g_variant_parser_get_error_quark        (void);
+
 GVariantBuilder *               g_variant_builder_new                   (const GVariantType   *type);
 void                            g_variant_builder_unref                 (GVariantBuilder      *builder);
 GVariantBuilder *               g_variant_builder_ref                   (GVariantBuilder      *builder);
@@ -206,6 +209,16 @@ void                            g_variant_get_va                        (GVarian
                                                                          va_list              *app);
 
 
+GVariant *                      g_variant_parse                         (const GVariantType   *type,
+                                                                         const gchar          *text,
+                                                                         const gchar          *limit,
+                                                                         const gchar         **endptr,
+                                                                         GError              **error);
+GVariant *                      g_variant_new_parsed                    (const gchar          *format,
+                                                                         ...);
+GVariant *                      g_variant_new_parsed_va                 (const gchar          *format,
+                                                                         va_list              *app);
+
 G_END_DECLS
 
 #endif /* __G_VARIANT_H__ */
diff --git a/glib/tests/gvariant.c b/glib/tests/gvariant.c
index 610fb65..f756d13 100644
--- a/glib/tests/gvariant.c
+++ b/glib/tests/gvariant.c
@@ -2742,7 +2742,7 @@ do_failed_test (const gchar *pattern)
 static void
 test_invalid_varargs (void)
 {
-  if (do_failed_test ("*not a valid GVariant format string*"))
+  if (do_failed_test ("*GVariant format string*"))
     {
       g_variant_new ("z");
       abort ();
@@ -2790,7 +2790,7 @@ test_varargs (void)
                                   g_variant_new_double (37.5))));
     check_and_free (g_variant_new ("(ma{sv}m(a{sv})ma{sv}ii)",
                                    NULL, FALSE, NULL, &array, 7777, 8888),
-                    "(Nothing, Nothing, {'size': <(800, 600)>, "
+                    "(nothing, nothing, {'size': <(800, 600)>, "
                                         "'title': <'Test case'>, "
                                         "'temperature': <37.5>}, "
                      "7777, 8888)");
@@ -2802,7 +2802,7 @@ test_varargs (void)
                                    FALSE, TRUE, 321,
                                    TRUE, FALSE, 321,
                                    TRUE, TRUE, 123),
-                    "(123, Nothing, 123, Nothing, Just Nothing, 123)");
+                    "(123, nothing, 123, nothing, just nothing, 123)");
 
     check_and_free (g_variant_new ("(ybnixd)",
                                    'a', 1, 22, 33, (guint64) 44, 5.5),
@@ -3047,7 +3047,7 @@ test_varargs (void)
     gdouble dval;
     gint32 hval;
 
-    /* test all 'Nothing' */
+    /* test all 'nothing' */
     value = g_variant_new ("(mymbmnmqmimumxmtmhmdmv)",
                            FALSE, 'a',
                            FALSE, TRUE,
@@ -3144,7 +3144,7 @@ test_varargs (void)
     g_variant_unref (value);
 
 
-    /* test all 'Just' */
+    /* test all 'just' */
     value = g_variant_new ("(mymbmnmqmimumxmtmhmdmv)",
                            TRUE, 'a',
                            TRUE, TRUE,
@@ -3455,6 +3455,242 @@ test_gv_byteswap ()
   g_free (string);
 }
 
+static void
+test_parser (void)
+{
+  TreeInstance *tree;
+  GVariant *parsed;
+  GVariant *value;
+  gchar *pt, *p;
+  gchar *res;
+
+  tree = tree_instance_new (NULL, 3);
+  value = tree_instance_get_gvariant (tree);
+  tree_instance_free (tree);
+
+  pt = g_variant_print (value, TRUE);
+  p = g_variant_print (value, FALSE);
+
+  parsed = g_variant_parse (NULL, pt, NULL, NULL, NULL);
+  res = g_variant_print (parsed, FALSE);
+  g_assert_cmpstr (p, ==, res);
+  g_variant_unref (parsed);
+  g_free (res);
+
+  parsed = g_variant_parse (g_variant_get_type (value), p,
+                            NULL, NULL, NULL);
+  res = g_variant_print (parsed, TRUE);
+  g_assert_cmpstr (pt, ==, res);
+  g_variant_unref (parsed);
+  g_free (res);
+
+  g_variant_unref (value);
+  g_free (pt);
+  g_free (p);
+}
+
+static void
+test_parses (void)
+{
+  gint i;
+
+  for (i = 0; i < 100; i++)
+    {
+      test_parser ();
+    }
+
+  /* mini test */
+  {
+    gchar str[256];
+    GVariant *val;
+    gchar *p, *p2;
+
+    for (i = 0; i < 256; i++)
+      str[i] = i + 1;
+
+    val = g_variant_new_string (str);
+    p = g_variant_print (val, FALSE);
+    g_variant_unref (val);
+
+    val = g_variant_parse (NULL, p, NULL, NULL, NULL);
+    p2 = g_variant_print (val, FALSE);
+
+    g_assert_cmpstr (str, ==, g_variant_get_string (val, NULL));
+    g_assert_cmpstr (p, ==, p2);
+
+    g_variant_unref (val);
+    g_free (p2);
+    g_free (p);
+  }
+
+  /* another mini test */
+  {
+    const gchar *end;
+    GVariant *value;
+
+    value = g_variant_parse (G_VARIANT_TYPE_INT32, "1 2 3", NULL, &end, NULL);
+    g_assert_cmpint (g_variant_get_int32 (value), ==, 1);
+    /* make sure endptr returning works */
+    g_assert_cmpstr (end, ==, " 2 3");
+    g_variant_unref (value);
+  }
+
+  g_variant_type_info_assert_no_infos ();
+}
+
+static void
+test_parse_failures (void)
+{
+  const gchar *test[] = {
+    "[1, 2,",                   "6:",              "expected value",
+    "",                         "0:",              "expected value",
+    "(1, 2,",                   "6:",              "expected value",
+    "<1",                       "2:",              "expected `>'",
+    "[]",                       "0-2:",            "unable to infer",
+    "(,",                       "1:",              "expected value",
+    "[4,'']",                   "1-2,3-5:",        "common type",
+    "[4, '', 5]",               "1-2,4-6:",        "common type",
+    "['', 4, 5]",               "1-3,5-6:",        "common type",
+    "[4, 5, '']",               "1-2,7-9:",        "common type",
+    "[[4], [], ['']]",          "1-4,10-14:",      "common type",
+    "[[], [4], ['']]",          "5-8,10-14:",      "common type",
+    "just",                     "4:",              "expected value",
+    "nothing",                  "0-7:",            "unable to infer",
+    "just [4, '']",             "6-7,9-11:",       "common type",
+    "[[4,'']]",                 "2-3,4-6:",        "common type",
+    "([4,''],)",                "2-3,4-6:",        "common type",
+    "(4)",                      "2:",              "`,'",
+    "{}",                       "0-2:",            "unable to infer",
+    "{[1,2],[3,4]}",            "0-13:",           "basic types",
+    "{[1,2]:[3,4]}",            "0-13:",           "basic types",
+    "justt",                    "0-5:",            "unknown keyword",
+    "nothng",                   "0-6:",            "unknown keyword",
+    "uint33",                   "0-6:",            "unknown keyword",
+    "@mi just ''",              "9-11:",           "can not parse as",
+    "@ai ['']",                 "5-7:",            "can not parse as",
+    "@(i) ('',)",               "6-8:",            "can not parse as",
+    "[[], 5]",                  "1-3,5-6:",        "common type",
+    "[[5], 5]",                 "1-4,6-7:",        "common type",
+    "5 5",                      "2:",              "expected end of input",
+    "[5, [5, '']]",             "5-6,8-10:",       "common type",
+    "@i just 5",                "3-9:",            "can not parse as",
+    "@i nothing",               "3-10:",           "can not parse as",
+    "@i []",                    "3-5:",            "can not parse as",
+    "@i ()",                    "3-5:",            "can not parse as",
+    "@ai (4,)",                 "4-8:",            "can not parse as",
+    "@(i) []",                  "5-7:",            "can not parse as",
+    "(5 5)",                    "3:",              "expected `,'",
+    "[5 5]",                    "3:",              "expected `,' or `]'",
+    "(5, 5 5)",                 "6:",              "expected `,' or `)'",
+    "[5, 5 5]",                 "6:",              "expected `,' or `]'",
+    "<@i []>",                  "4-6:",            "can not parse as",
+    "<[5 5]>",                  "4:",              "expected `,' or `]'",
+    "{[4,''],5}",               "2-3,4-6:",        "common type",
+    "{5,[4,'']}",               "4-5,6-8:",        "common type",
+    "@i {1,2}",                 "3-8:",            "can not parse as",
+    "{ i '', 5}",               "4-6:",            "can not parse as",
+    "{5, @i ''}",               "7-9:",            "can not parse as",
+    "@ai {}",                   "4-6:",            "can not parse as",
+    "{ i '': 5}",               "4-6:",            "can not parse as",
+    "{5: @i ''}",               "7-9:",            "can not parse as",
+    "{<4,5}",                   "3:",              "expected `>'",
+    "{4,<5}",                   "5:",              "expected `>'",
+    "{4,5,6}",                  "4:",              "expected `}'",
+    "{5 5}",                    "3:",              "expected `:' or `,'",
+    "{4: 5: 6}",                "5:",              "expected `,' or `}'",
+    "{4:5,<6:7}",               "7:",              "expected `>'",
+    "{4:5,6:<7}",               "9:",              "expected `>'",
+    "{4:5,6 7}",                "7:",              "expected `:'",
+    "@o 'foo'",                 "3-8:",            "object path",
+    "@g 'zzz'",                 "3-8:",            "signature",
+    "@i true",                  "3-7:",            "can not parse as",
+    "@z 4",                     "0-2:",            "invalid type",
+    "@a* []",                   "0-3:",            "definite",
+    "@ai [3 3]",                "7:",              "expected `,' or `]'",
+    "18446744073709551616",     "0-20:",           "too big for any type",
+    "-18446744073709551616",    "0-21:",           "too big for any type",
+    "byte 256",                 "5-8:",            "out of range for type",
+    "byte -1",                  "5-7:",            "out of range for type",
+    "int16 32768",              "6-11:",           "out of range for type",
+    "int16 -32769",             "6-12:",           "out of range for type",
+    "uint16 -1",                "7-9:",            "out of range for type",
+    "uint16 65536",             "7-12:",           "out of range for type",
+    "2147483648",               "0-10:",           "out of range for type",
+    "-2147483649",              "0-11:",           "out of range for type",
+    "uint32 -1",                "7-9:",            "out of range for type",
+    "uint32 4294967296",        "7-17:",           "out of range for type",
+    "@x 9223372036854775808",   "3-22:",           "out of range for type",
+    "@x -9223372036854775809",  "3-23:",           "out of range for type",
+    "@t -1",                    "3-5:",            "out of range for type",
+    "@t 18446744073709551616",  "3-23:",           "too big for any type",
+    "handle 2147483648",        "7-17:",           "out of range for type",
+    "handle -2147483649",       "7-18:",           "out of range for type",
+    "1.798e308",                "0-9:",            "too big for any type",
+    "37.5a488",                 "4-5:",            "invalid character",
+    "0x7ffgf",                  "5-6:",            "invalid character",
+    "07758",                    "4-5:",            "invalid character",
+    "123a5",                    "3-4:",            "invalid character",
+    "@ai 123",                  "4-7:",            "can not parse as",
+    "'\"\\'",                   "0-4:",            "unterminated string",
+    "'\"\\'\\",                 "0-5:",            "unterminated string",
+    "boolean 4",                "8-9:",            "can not parse as",
+    "int32 true",               "6-10:",           "can not parse as",
+    "[double 5, int32 5]",      "1-9,11-18:",      "common type",
+    "string 4",                 "7-8:",            "can not parse as"
+  };
+  gint i;
+
+  for (i = 0; i < G_N_ELEMENTS (test); i += 3)
+    {
+      GError *error = NULL;
+      GVariant *value;
+
+      value = g_variant_parse (NULL, test[i], NULL, NULL, &error);
+      g_assert (value == NULL);
+
+      if (!strstr (error->message, test[i+2]))
+        g_error ("test %d: Can't find `%s' in `%s'", i / 3,
+                 test[i+2], error->message);
+
+      if (!g_str_has_prefix (error->message, test[i+1]))
+        g_error ("test %d: Expected location `%s' in `%s'", i / 3,
+                 test[i+1], error->message);
+
+      g_error_free (error);
+    }
+}
+
+static void
+test_parse_positional (void)
+{
+  GVariant *value;
+  check_and_free (g_variant_new_parsed ("[('one', 1), (%s, 2),"
+                                        " ('three', %i)]", "two", 3),
+                  "[('one', 1), ('two', 2), ('three', 3)]");
+  value = g_variant_new_parsed ("[('one', 1), (%s, 2),"
+                                " ('three', %u)]", "two", 3);
+  g_assert (g_variant_is_of_type (value, G_VARIANT_TYPE ("a(su)")));
+  check_and_free (value, "[('one', 1), ('two', 2), ('three', 3)]");
+
+  if (do_failed_test ("*GVariant format string*"))
+    {
+      g_variant_new_parsed ("%z");
+      abort ();
+    }
+
+  if (do_failed_test ("*can not parse as*"))
+    {
+      g_variant_new_parsed ("uint32 %i", 2);
+      abort ();
+    }
+
+  if (do_failed_test ("*expected GVariant of type `i'*"))
+    {
+      g_variant_new_parsed ("% i", g_variant_new_uint32 (2));
+      abort ();
+    }
+}
+
 int
 main (int argc, char **argv)
 {
@@ -3489,6 +3725,9 @@ main (int argc, char **argv)
   g_test_add_func ("/gvariant/builder-memory", test_builder_memory);
   g_test_add_func ("/gvariant/hashing", test_hashing);
   g_test_add_func ("/gvariant/byteswap", test_gv_byteswap);
+  g_test_add_func ("/gvariant/parser", test_parses);
+  g_test_add_func ("/gvariant/parse-failures", test_parse_failures);
+  g_test_add_func ("/gvariant/parse-positional", test_parse_positional);
 
   return g_test_run ();
 }



[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]