summaryrefslogtreecommitdiffstats
path: root/libgimpconfig/gimpconfig-deserialize.c
diff options
context:
space:
mode:
Diffstat (limited to 'libgimpconfig/gimpconfig-deserialize.c')
-rw-r--r--libgimpconfig/gimpconfig-deserialize.c1019
1 files changed, 1019 insertions, 0 deletions
diff --git a/libgimpconfig/gimpconfig-deserialize.c b/libgimpconfig/gimpconfig-deserialize.c
new file mode 100644
index 0000000..55cbf50
--- /dev/null
+++ b/libgimpconfig/gimpconfig-deserialize.c
@@ -0,0 +1,1019 @@
+/* LIBGIMP - The GIMP Library
+ * Copyright (C) 1995-1997 Spencer Kimball and Peter Mattis
+ *
+ * Object properties deserialization routines
+ * Copyright (C) 2001-2002 Sven Neumann <sven@gimp.org>
+ *
+ * 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 3 of the License, 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
+ * Library 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, see
+ * <https://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include <cairo.h>
+#include <gegl.h>
+#include <gdk-pixbuf/gdk-pixbuf.h>
+
+#include "libgimpbase/gimpbase.h"
+#include "libgimpcolor/gimpcolor.h"
+#include "libgimpmath/gimpmath.h"
+
+#include "gimpconfigtypes.h"
+
+#include "gimpconfigwriter.h"
+#include "gimpconfig-iface.h"
+#include "gimpconfig-deserialize.h"
+#include "gimpconfig-params.h"
+#include "gimpconfig-path.h"
+#include "gimpscanner.h"
+
+#include "libgimp/libgimp-intl.h"
+
+
+/**
+ * SECTION: gimpconfig-deserialize
+ * @title: GimpConfig-deserialize
+ * @short_description: Deserializing code for libgimpconfig.
+ *
+ * Deserializing code for libgimpconfig.
+ **/
+
+
+/*
+ * All functions return G_TOKEN_RIGHT_PAREN on success,
+ * the GTokenType they would have expected but didn't get
+ * or G_TOKEN_NONE if they got the expected token but
+ * couldn't parse it.
+ */
+
+static GTokenType gimp_config_deserialize_value (GValue *value,
+ GimpConfig *config,
+ GParamSpec *prop_spec,
+ GScanner *scanner);
+static GTokenType gimp_config_deserialize_fundamental (GValue *value,
+ GParamSpec *prop_spec,
+ GScanner *scanner);
+static GTokenType gimp_config_deserialize_enum (GValue *value,
+ GParamSpec *prop_spec,
+ GScanner *scanner);
+static GTokenType gimp_config_deserialize_memsize (GValue *value,
+ GParamSpec *prop_spec,
+ GScanner *scanner);
+static GTokenType gimp_config_deserialize_path (GValue *value,
+ GParamSpec *prop_spec,
+ GScanner *scanner);
+static GTokenType gimp_config_deserialize_rgb (GValue *value,
+ GParamSpec *prop_spec,
+ GScanner *scanner);
+static GTokenType gimp_config_deserialize_matrix2 (GValue *value,
+ GParamSpec *prop_spec,
+ GScanner *scanner);
+static GTokenType gimp_config_deserialize_object (GValue *value,
+ GimpConfig *config,
+ GParamSpec *prop_spec,
+ GScanner *scanner,
+ gint nest_level);
+static GTokenType gimp_config_deserialize_value_array (GValue *value,
+ GimpConfig *config,
+ GParamSpec *prop_spec,
+ GScanner *scanner);
+static GTokenType gimp_config_deserialize_unit (GValue *value,
+ GParamSpec *prop_spec,
+ GScanner *scanner);
+static GTokenType gimp_config_deserialize_file_value (GValue *value,
+ GParamSpec *prop_spec,
+ GScanner *scanner);
+static GTokenType gimp_config_deserialize_any (GValue *value,
+ GParamSpec *prop_spec,
+ GScanner *scanner);
+static GTokenType gimp_config_skip_unknown_property (GScanner *scanner);
+
+static inline gboolean scanner_string_utf8_valid (GScanner *scanner,
+ const gchar *token_name);
+
+static inline gboolean
+scanner_string_utf8_valid (GScanner *scanner,
+ const gchar *token_name)
+{
+ if (g_utf8_validate (scanner->value.v_string, -1, NULL))
+ return TRUE;
+
+ g_scanner_error (scanner,
+ _("value for token %s is not a valid UTF-8 string"),
+ token_name);
+
+ return FALSE;
+}
+
+/**
+ * gimp_config_deserialize_properties:
+ * @config: a #GimpConfig.
+ * @scanner: a #GScanner.
+ * @nest_level: the nest level
+ *
+ * This function uses the @scanner to configure the properties of @config.
+ *
+ * Return value: %TRUE on success, %FALSE otherwise.
+ *
+ * Since: 2.4
+ **/
+gboolean
+gimp_config_deserialize_properties (GimpConfig *config,
+ GScanner *scanner,
+ gint nest_level)
+{
+ GObjectClass *klass;
+ GParamSpec **property_specs;
+ guint n_property_specs;
+ guint i;
+ guint scope_id;
+ guint old_scope_id;
+ GTokenType token;
+
+ g_return_val_if_fail (GIMP_IS_CONFIG (config), FALSE);
+
+ klass = G_OBJECT_GET_CLASS (config);
+ property_specs = g_object_class_list_properties (klass, &n_property_specs);
+
+ if (! property_specs)
+ return TRUE;
+
+ scope_id = g_type_qname (G_TYPE_FROM_INSTANCE (config));
+ old_scope_id = g_scanner_set_scope (scanner, scope_id);
+
+ for (i = 0; i < n_property_specs; i++)
+ {
+ GParamSpec *prop_spec = property_specs[i];
+
+ if (prop_spec->flags & GIMP_CONFIG_PARAM_SERIALIZE)
+ {
+ g_scanner_scope_add_symbol (scanner, scope_id,
+ prop_spec->name, prop_spec);
+ }
+ }
+
+ g_free (property_specs);
+
+ g_object_freeze_notify (G_OBJECT (config));
+
+ token = G_TOKEN_LEFT_PAREN;
+
+ while (TRUE)
+ {
+ GTokenType next = g_scanner_peek_next_token (scanner);
+
+ if (next == G_TOKEN_EOF)
+ break;
+
+ if (G_UNLIKELY (next != token &&
+ ! (token == G_TOKEN_SYMBOL &&
+ next == G_TOKEN_IDENTIFIER)))
+ {
+ break;
+ }
+
+ token = g_scanner_get_next_token (scanner);
+
+ switch (token)
+ {
+ case G_TOKEN_LEFT_PAREN:
+ token = G_TOKEN_SYMBOL;
+ break;
+
+ case G_TOKEN_IDENTIFIER:
+ token = gimp_config_skip_unknown_property (scanner);
+ break;
+
+ case G_TOKEN_SYMBOL:
+ token = gimp_config_deserialize_property (config,
+ scanner, nest_level);
+ break;
+
+ case G_TOKEN_RIGHT_PAREN:
+ token = G_TOKEN_LEFT_PAREN;
+ break;
+
+ default: /* do nothing */
+ break;
+ }
+ }
+
+ g_scanner_set_scope (scanner, old_scope_id);
+
+ g_object_thaw_notify (G_OBJECT (config));
+
+ if (token == G_TOKEN_NONE)
+ return FALSE;
+
+ return gimp_config_deserialize_return (scanner, token, nest_level);
+}
+
+/**
+ * gimp_config_deserialize_property:
+ * @config: a #GimpConfig.
+ * @scanner: a #GScanner.
+ * @nest_level: the nest level
+ *
+ * This function deserializes a single property of @config. You
+ * shouldn't need to call this function directly. If possible, use
+ * gimp_config_deserialize_properties() instead.
+ *
+ * Return value: %G_TOKEN_RIGHT_PAREN on success, otherwise the
+ * expected #GTokenType or %G_TOKEN_NONE if the expected token was
+ * found but couldn't be parsed.
+ *
+ * Since: 2.4
+ **/
+GTokenType
+gimp_config_deserialize_property (GimpConfig *config,
+ GScanner *scanner,
+ gint nest_level)
+{
+ GimpConfigInterface *config_iface = NULL;
+ GimpConfigInterface *parent_iface = NULL;
+ GParamSpec *prop_spec;
+ GTokenType token = G_TOKEN_RIGHT_PAREN;
+ GValue value = G_VALUE_INIT;
+ guint old_scope_id;
+
+ old_scope_id = g_scanner_set_scope (scanner, 0);
+
+ prop_spec = G_PARAM_SPEC (scanner->value.v_symbol);
+
+ g_value_init (&value, prop_spec->value_type);
+
+ if (G_TYPE_IS_OBJECT (prop_spec->owner_type))
+ {
+ GTypeClass *owner_class = g_type_class_peek (prop_spec->owner_type);
+
+ config_iface = g_type_interface_peek (owner_class, GIMP_TYPE_CONFIG);
+
+ /* We must call deserialize_property() *only* if the *exact* class
+ * which implements it is param_spec->owner_type's class.
+ *
+ * Therefore, we ask param_spec->owner_type's immediate parent class
+ * for it's GimpConfigInterface and check if we get a different
+ * pointer.
+ *
+ * (if the pointers are the same, param_spec->owner_type's
+ * GimpConfigInterface is inherited from one of it's parent classes
+ * and thus not able to handle param_spec->owner_type's properties).
+ */
+ if (config_iface)
+ {
+ GTypeClass *owner_parent_class;
+
+ owner_parent_class = g_type_class_peek_parent (owner_class);
+
+ parent_iface = g_type_interface_peek (owner_parent_class,
+ GIMP_TYPE_CONFIG);
+ }
+ }
+
+ if (config_iface &&
+ config_iface != parent_iface && /* see comment above */
+ config_iface->deserialize_property &&
+ config_iface->deserialize_property (config,
+ prop_spec->param_id,
+ &value,
+ prop_spec,
+ scanner,
+ &token))
+ {
+ /* nop */
+ }
+ else
+ {
+ if (G_VALUE_HOLDS_OBJECT (&value) &&
+ G_VALUE_TYPE (&value) != G_TYPE_FILE)
+ {
+ token = gimp_config_deserialize_object (&value,
+ config, prop_spec,
+ scanner, nest_level);
+ }
+ else
+ {
+ token = gimp_config_deserialize_value (&value,
+ config, prop_spec, scanner);
+ }
+ }
+
+ if (token == G_TOKEN_RIGHT_PAREN &&
+ g_scanner_peek_next_token (scanner) == token)
+ {
+ if (! (G_VALUE_HOLDS_OBJECT (&value) &&
+ (prop_spec->flags & GIMP_CONFIG_PARAM_AGGREGATE)))
+ g_object_set_property (G_OBJECT (config), prop_spec->name, &value);
+ }
+#ifdef CONFIG_DEBUG
+ else
+ {
+ g_warning ("%s: couldn't deserialize property %s::%s of type %s",
+ G_STRFUNC,
+ g_type_name (G_TYPE_FROM_INSTANCE (config)),
+ prop_spec->name,
+ g_type_name (prop_spec->value_type));
+ }
+#endif
+
+ g_value_unset (&value);
+
+ g_scanner_set_scope (scanner, old_scope_id);
+
+ return token;
+}
+
+static GTokenType
+gimp_config_deserialize_value (GValue *value,
+ GimpConfig *config,
+ GParamSpec *prop_spec,
+ GScanner *scanner)
+{
+ if (G_TYPE_FUNDAMENTAL (prop_spec->value_type) == G_TYPE_ENUM)
+ {
+ return gimp_config_deserialize_enum (value, prop_spec, scanner);
+ }
+ else if (G_TYPE_IS_FUNDAMENTAL (prop_spec->value_type))
+ {
+ return gimp_config_deserialize_fundamental (value, prop_spec, scanner);
+ }
+ else if (prop_spec->value_type == GIMP_TYPE_MEMSIZE)
+ {
+ return gimp_config_deserialize_memsize (value, prop_spec, scanner);
+ }
+ else if (prop_spec->value_type == GIMP_TYPE_CONFIG_PATH)
+ {
+ return gimp_config_deserialize_path (value, prop_spec, scanner);
+ }
+ else if (prop_spec->value_type == GIMP_TYPE_RGB)
+ {
+ return gimp_config_deserialize_rgb (value, prop_spec, scanner);
+ }
+ else if (prop_spec->value_type == GIMP_TYPE_MATRIX2)
+ {
+ return gimp_config_deserialize_matrix2 (value, prop_spec, scanner);
+ }
+ else if (prop_spec->value_type == GIMP_TYPE_VALUE_ARRAY)
+ {
+ return gimp_config_deserialize_value_array (value,
+ config, prop_spec, scanner);
+ }
+ else if (prop_spec->value_type == GIMP_TYPE_UNIT)
+ {
+ return gimp_config_deserialize_unit (value, prop_spec, scanner);
+ }
+ else if (prop_spec->value_type == G_TYPE_FILE)
+ {
+ return gimp_config_deserialize_file_value (value, prop_spec, scanner);
+ }
+
+ /* This fallback will only work for value_types that
+ * can be transformed from a string value.
+ */
+ return gimp_config_deserialize_any (value, prop_spec, scanner);
+}
+
+static GTokenType
+gimp_config_deserialize_fundamental (GValue *value,
+ GParamSpec *prop_spec,
+ GScanner *scanner)
+{
+ GTokenType token;
+ GTokenType next_token;
+ GType value_type;
+ gboolean negate = FALSE;
+
+ value_type = G_TYPE_FUNDAMENTAL (prop_spec->value_type);
+
+ switch (value_type)
+ {
+ case G_TYPE_STRING:
+ token = G_TOKEN_STRING;
+ break;
+
+ case G_TYPE_BOOLEAN:
+ token = G_TOKEN_IDENTIFIER;
+ break;
+
+ case G_TYPE_INT:
+ case G_TYPE_LONG:
+ case G_TYPE_INT64:
+ if (g_scanner_peek_next_token (scanner) == '-')
+ {
+ negate = TRUE;
+ g_scanner_get_next_token (scanner);
+ }
+ /* fallthrough */
+ case G_TYPE_UINT:
+ case G_TYPE_ULONG:
+ case G_TYPE_UINT64:
+ token = G_TOKEN_INT;
+ break;
+
+ case G_TYPE_FLOAT:
+ case G_TYPE_DOUBLE:
+ if (g_scanner_peek_next_token (scanner) == '-')
+ {
+ negate = TRUE;
+ g_scanner_get_next_token (scanner);
+ }
+ token = G_TOKEN_FLOAT;
+ break;
+
+ default:
+ g_assert_not_reached ();
+ break;
+ }
+
+ next_token = g_scanner_peek_next_token (scanner);
+
+ /* we parse integers into floats too, because g_ascii_dtostr()
+ * serialized whole number without decimal point
+ */
+ if (next_token != token &&
+ ! (token == G_TOKEN_FLOAT && next_token == G_TOKEN_INT))
+ {
+ return token;
+ }
+
+ g_scanner_get_next_token (scanner);
+
+ switch (value_type)
+ {
+ case G_TYPE_STRING:
+ if (scanner_string_utf8_valid (scanner, prop_spec->name))
+ g_value_set_string (value, scanner->value.v_string);
+ else
+ return G_TOKEN_NONE;
+ break;
+
+ case G_TYPE_BOOLEAN:
+ if (! g_ascii_strcasecmp (scanner->value.v_identifier, "yes") ||
+ ! g_ascii_strcasecmp (scanner->value.v_identifier, "true"))
+ g_value_set_boolean (value, TRUE);
+ else if (! g_ascii_strcasecmp (scanner->value.v_identifier, "no") ||
+ ! g_ascii_strcasecmp (scanner->value.v_identifier, "false"))
+ g_value_set_boolean (value, FALSE);
+ else
+ {
+ g_scanner_error
+ (scanner,
+ /* please don't translate 'yes' and 'no' */
+ _("expected 'yes' or 'no' for boolean token %s, got '%s'"),
+ prop_spec->name, scanner->value.v_identifier);
+ return G_TOKEN_NONE;
+ }
+ break;
+
+ case G_TYPE_INT:
+ g_value_set_int (value, (negate ?
+ - (gint) scanner->value.v_int64 :
+ (gint) scanner->value.v_int64));
+ break;
+ case G_TYPE_UINT:
+ g_value_set_uint (value, scanner->value.v_int64);
+ break;
+
+ case G_TYPE_LONG:
+ g_value_set_long (value, (negate ?
+ - (glong) scanner->value.v_int64 :
+ (glong) scanner->value.v_int64));
+ break;
+ case G_TYPE_ULONG:
+ g_value_set_ulong (value, scanner->value.v_int64);
+ break;
+
+ case G_TYPE_INT64:
+ g_value_set_int64 (value, (negate ?
+ - (gint64) scanner->value.v_int64 :
+ (gint64) scanner->value.v_int64));
+ break;
+ case G_TYPE_UINT64:
+ g_value_set_uint64 (value, scanner->value.v_int64);
+ break;
+
+ case G_TYPE_FLOAT:
+ if (next_token == G_TOKEN_FLOAT)
+ g_value_set_float (value, negate ?
+ - scanner->value.v_float :
+ scanner->value.v_float);
+ else
+ g_value_set_float (value, negate ?
+ - (gfloat) scanner->value.v_int :
+ (gfloat) scanner->value.v_int);
+ break;
+
+ case G_TYPE_DOUBLE:
+ if (next_token == G_TOKEN_FLOAT)
+ g_value_set_double (value, negate ?
+ - scanner->value.v_float:
+ scanner->value.v_float);
+ else
+ g_value_set_double (value, negate ?
+ - (gdouble) scanner->value.v_int:
+ (gdouble) scanner->value.v_int);
+ break;
+
+ default:
+ g_assert_not_reached ();
+ break;
+ }
+
+ return G_TOKEN_RIGHT_PAREN;
+}
+
+static GTokenType
+gimp_config_deserialize_enum (GValue *value,
+ GParamSpec *prop_spec,
+ GScanner *scanner)
+{
+ GEnumClass *enum_class;
+ GEnumValue *enum_value;
+
+ enum_class = g_type_class_peek (G_VALUE_TYPE (value));
+
+ switch (g_scanner_peek_next_token (scanner))
+ {
+ case G_TOKEN_IDENTIFIER:
+ g_scanner_get_next_token (scanner);
+
+ enum_value = g_enum_get_value_by_nick (enum_class,
+ scanner->value.v_identifier);
+ if (! enum_value)
+ enum_value = g_enum_get_value_by_name (enum_class,
+ scanner->value.v_identifier);
+ if (! enum_value)
+ {
+ /* if the value was not found, check if we have a compat
+ * enum to find the ideitifier
+ */
+ GQuark quark = g_quark_from_static_string ("gimp-compat-enum");
+ GType compat_type = (GType) g_type_get_qdata (G_VALUE_TYPE (value),
+ quark);
+
+ if (compat_type)
+ {
+ GEnumClass *compat_class = g_type_class_ref (compat_type);
+
+ enum_value = g_enum_get_value_by_nick (compat_class,
+ scanner->value.v_identifier);
+ if (! enum_value)
+ enum_value = g_enum_get_value_by_name (compat_class,
+ scanner->value.v_identifier);
+
+ /* finally, if we found a compat value, make sure the
+ * same value exists in the original enum
+ */
+ if (enum_value)
+ enum_value = g_enum_get_value (enum_class, enum_value->value);
+
+ g_type_class_unref (compat_class);
+ }
+ }
+
+ if (! enum_value)
+ {
+ g_scanner_error (scanner,
+ _("invalid value '%s' for token %s"),
+ scanner->value.v_identifier, prop_spec->name);
+ return G_TOKEN_NONE;
+ }
+ break;
+
+ case G_TOKEN_INT:
+ g_scanner_get_next_token (scanner);
+
+ enum_value = g_enum_get_value (enum_class,
+ (gint) scanner->value.v_int64);
+
+ if (! enum_value)
+ {
+ g_scanner_error (scanner,
+ _("invalid value '%ld' for token %s"),
+ (glong) scanner->value.v_int64, prop_spec->name);
+ return G_TOKEN_NONE;
+ }
+ break;
+
+ default:
+ return G_TOKEN_IDENTIFIER;
+ }
+
+ g_value_set_enum (value, enum_value->value);
+
+ return G_TOKEN_RIGHT_PAREN;
+}
+
+static GTokenType
+gimp_config_deserialize_memsize (GValue *value,
+ GParamSpec *prop_spec,
+ GScanner *scanner)
+{
+ gchar *orig_cset_first = scanner->config->cset_identifier_first;
+ gchar *orig_cset_nth = scanner->config->cset_identifier_nth;
+ guint64 memsize;
+
+ scanner->config->cset_identifier_first = G_CSET_DIGITS;
+ scanner->config->cset_identifier_nth = G_CSET_DIGITS "gGmMkKbB";
+
+ if (g_scanner_peek_next_token (scanner) != G_TOKEN_IDENTIFIER)
+ return G_TOKEN_IDENTIFIER;
+
+ g_scanner_get_next_token (scanner);
+
+ scanner->config->cset_identifier_first = orig_cset_first;
+ scanner->config->cset_identifier_nth = orig_cset_nth;
+
+ if (! gimp_memsize_deserialize (scanner->value.v_identifier, &memsize))
+ return G_TOKEN_NONE;
+
+ g_value_set_uint64 (value, memsize);
+
+ return G_TOKEN_RIGHT_PAREN;
+}
+
+static GTokenType
+gimp_config_deserialize_path (GValue *value,
+ GParamSpec *prop_spec,
+ GScanner *scanner)
+{
+ GError *error = NULL;
+
+ if (g_scanner_peek_next_token (scanner) != G_TOKEN_STRING)
+ return G_TOKEN_STRING;
+
+ g_scanner_get_next_token (scanner);
+
+ if (!scanner_string_utf8_valid (scanner, prop_spec->name))
+ return G_TOKEN_NONE;
+
+ if (scanner->value.v_string)
+ {
+ /* Check if the string can be expanded
+ * and converted to the filesystem encoding.
+ */
+ gchar *expand = gimp_config_path_expand (scanner->value.v_string,
+ TRUE, &error);
+
+ if (!expand)
+ {
+ g_scanner_error (scanner,
+ _("while parsing token '%s': %s"),
+ prop_spec->name, error->message);
+ g_error_free (error);
+
+ return G_TOKEN_NONE;
+ }
+
+ g_free (expand);
+
+ g_value_set_static_string (value, scanner->value.v_string);
+ }
+
+ return G_TOKEN_RIGHT_PAREN;
+}
+
+static GTokenType
+gimp_config_deserialize_rgb (GValue *value,
+ GParamSpec *prop_spec,
+ GScanner *scanner)
+{
+ GimpRGB rgb;
+
+ if (! gimp_scanner_parse_color (scanner, &rgb))
+ return G_TOKEN_NONE;
+
+ g_value_set_boxed (value, &rgb);
+
+ return G_TOKEN_RIGHT_PAREN;
+}
+
+static GTokenType
+gimp_config_deserialize_matrix2 (GValue *value,
+ GParamSpec *prop_spec,
+ GScanner *scanner)
+{
+ GimpMatrix2 matrix;
+
+ if (! gimp_scanner_parse_matrix2 (scanner, &matrix))
+ return G_TOKEN_NONE;
+
+ g_value_set_boxed (value, &matrix);
+
+ return G_TOKEN_RIGHT_PAREN;
+}
+
+static GTokenType
+gimp_config_deserialize_object (GValue *value,
+ GimpConfig *config,
+ GParamSpec *prop_spec,
+ GScanner *scanner,
+ gint nest_level)
+{
+ GimpConfigInterface *config_iface;
+ GimpConfig *prop_object;
+
+ g_object_get_property (G_OBJECT (config), prop_spec->name, value);
+
+ prop_object = g_value_get_object (value);
+
+ if (! prop_object)
+ {
+ /* if the object property is not GIMP_CONFIG_PARAM_AGGREGATE, read
+ * the type of the object and create it
+ */
+ if (! (prop_spec->flags & GIMP_CONFIG_PARAM_AGGREGATE))
+ {
+ gchar *type_name;
+ GType type;
+
+ if (! gimp_scanner_parse_string (scanner, &type_name))
+ return G_TOKEN_STRING;
+
+ if (! (type_name && *type_name))
+ {
+ g_scanner_error (scanner, "Type name is empty");
+ g_free (type_name);
+ return G_TOKEN_NONE;
+ }
+
+ type = g_type_from_name (type_name);
+ g_free (type_name);
+
+ if (! g_type_is_a (type, prop_spec->value_type))
+ return G_TOKEN_STRING;
+
+ prop_object = g_object_new (type, NULL);
+
+ g_value_take_object (value, prop_object);
+ }
+ else
+ {
+ return G_TOKEN_RIGHT_PAREN;
+ }
+ }
+
+ config_iface = GIMP_CONFIG_GET_INTERFACE (prop_object);
+
+ if (! config_iface)
+ return gimp_config_deserialize_any (value, prop_spec, scanner);
+
+ if (! config_iface->deserialize (prop_object, scanner, nest_level + 1, NULL))
+ return G_TOKEN_NONE;
+
+ return G_TOKEN_RIGHT_PAREN;
+}
+
+static GTokenType
+gimp_config_deserialize_value_array (GValue *value,
+ GimpConfig *config,
+ GParamSpec *prop_spec,
+ GScanner *scanner)
+{
+ GimpParamSpecValueArray *array_spec;
+ GimpValueArray *array;
+ GValue array_value = G_VALUE_INIT;
+ gint n_values;
+ GTokenType token;
+ gint i;
+
+ array_spec = GIMP_PARAM_SPEC_VALUE_ARRAY (prop_spec);
+
+ if (! gimp_scanner_parse_int (scanner, &n_values))
+ return G_TOKEN_INT;
+
+ array = gimp_value_array_new (n_values);
+
+ for (i = 0; i < n_values; i++)
+ {
+ g_value_init (&array_value, array_spec->element_spec->value_type);
+
+ token = gimp_config_deserialize_value (&array_value,
+ config,
+ array_spec->element_spec,
+ scanner);
+
+ if (token == G_TOKEN_RIGHT_PAREN)
+ gimp_value_array_append (array, &array_value);
+
+ g_value_unset (&array_value);
+
+ if (token != G_TOKEN_RIGHT_PAREN)
+ return token;
+ }
+
+ g_value_take_boxed (value, array);
+
+ return G_TOKEN_RIGHT_PAREN;
+}
+
+/* This function is entirely sick, so is our method of serializing
+ * units, which we write out as (unit foo bar) instead of
+ * (unit "foo bar"). The assumption that caused this shit was that a
+ * unit's "identifier" is really an identifier in the C-ish sense,
+ * when in fact it's just a random user entered string.
+ *
+ * Here, we try to parse at least the default units shipped with gimp,
+ * and we add code to parse (unit "foo bar") in order to be compatible
+ * with future correct unit serializing.
+ */
+static GTokenType
+gimp_config_deserialize_unit (GValue *value,
+ GParamSpec *prop_spec,
+ GScanner *scanner)
+{
+ gchar *old_cset_skip_characters;
+ gchar *old_cset_identifier_first;
+ gchar *old_cset_identifier_nth;
+ GString *buffer;
+ GValue src = G_VALUE_INIT;
+ GTokenType token;
+
+ /* parse the next token *before* reconfiguring the scanner, so it
+ * skips whitespace first
+ */
+ token = g_scanner_peek_next_token (scanner);
+
+ if (token == G_TOKEN_STRING)
+ return gimp_config_deserialize_any (value, prop_spec, scanner);
+
+ old_cset_skip_characters = scanner->config->cset_skip_characters;
+ old_cset_identifier_first = scanner->config->cset_identifier_first;
+ old_cset_identifier_nth = scanner->config->cset_identifier_nth;
+
+ scanner->config->cset_skip_characters = "";
+ scanner->config->cset_identifier_first = ( G_CSET_a_2_z G_CSET_A_2_Z "." );
+ scanner->config->cset_identifier_nth = ( G_CSET_a_2_z G_CSET_A_2_Z
+ G_CSET_DIGITS "-_." );
+
+ buffer = g_string_new ("");
+
+ while (g_scanner_peek_next_token (scanner) != G_TOKEN_RIGHT_PAREN)
+ {
+ token = g_scanner_peek_next_token (scanner);
+
+ if (token == G_TOKEN_IDENTIFIER)
+ {
+ g_scanner_get_next_token (scanner);
+ g_string_append (buffer, scanner->value.v_identifier);
+ }
+ else if (token == G_TOKEN_CHAR)
+ {
+ g_scanner_get_next_token (scanner);
+ g_string_append_c (buffer, scanner->value.v_char);
+ }
+ else if (token == ' ')
+ {
+ g_scanner_get_next_token (scanner);
+ g_string_append_c (buffer, token);
+ }
+ else
+ {
+ token = G_TOKEN_IDENTIFIER;
+ goto cleanup;
+ }
+ }
+
+ g_value_init (&src, G_TYPE_STRING);
+ g_value_set_static_string (&src, buffer->str);
+ g_value_transform (&src, value);
+ g_value_unset (&src);
+
+ token = G_TOKEN_RIGHT_PAREN;
+
+ cleanup:
+
+ g_string_free (buffer, TRUE);
+
+ scanner->config->cset_skip_characters = old_cset_skip_characters;
+ scanner->config->cset_identifier_first = old_cset_identifier_first;
+ scanner->config->cset_identifier_nth = old_cset_identifier_nth;
+
+ return token;
+}
+
+static GTokenType
+gimp_config_deserialize_file_value (GValue *value,
+ GParamSpec *prop_spec,
+ GScanner *scanner)
+{
+ GTokenType token;
+
+ token = g_scanner_peek_next_token (scanner);
+
+ if (token != G_TOKEN_IDENTIFIER &&
+ token != G_TOKEN_STRING)
+ {
+ return G_TOKEN_STRING;
+ }
+
+ g_scanner_get_next_token (scanner);
+
+ if (token == G_TOKEN_IDENTIFIER)
+ {
+ /* this is supposed to parse a literal "NULL" only, but so what... */
+ g_value_set_object (value, NULL);
+ }
+ else
+ {
+ gchar *path = gimp_config_path_expand (scanner->value.v_string, TRUE,
+ NULL);
+
+ if (path)
+ {
+ GFile *file = g_file_new_for_path (path);
+
+ g_value_take_object (value, file);
+ g_free (path);
+ }
+ else
+ {
+ g_value_set_object (value, NULL);
+ }
+ }
+
+ return G_TOKEN_RIGHT_PAREN;
+}
+
+static GTokenType
+gimp_config_deserialize_any (GValue *value,
+ GParamSpec *prop_spec,
+ GScanner *scanner)
+{
+ GValue src = G_VALUE_INIT;
+ GTokenType token;
+
+ if (!g_value_type_transformable (G_TYPE_STRING, prop_spec->value_type))
+ {
+ g_warning ("%s: %s can not be transformed from a string",
+ G_STRFUNC, g_type_name (prop_spec->value_type));
+ return G_TOKEN_NONE;
+ }
+
+ token = g_scanner_peek_next_token (scanner);
+
+ if (token != G_TOKEN_IDENTIFIER &&
+ token != G_TOKEN_STRING)
+ {
+ return G_TOKEN_IDENTIFIER;
+ }
+
+ g_scanner_get_next_token (scanner);
+
+ g_value_init (&src, G_TYPE_STRING);
+
+ if (token == G_TOKEN_IDENTIFIER)
+ g_value_set_static_string (&src, scanner->value.v_identifier);
+ else
+ g_value_set_static_string (&src, scanner->value.v_string);
+
+ g_value_transform (&src, value);
+ g_value_unset (&src);
+
+ return G_TOKEN_RIGHT_PAREN;
+}
+
+static GTokenType
+gimp_config_skip_unknown_property (GScanner *scanner)
+{
+ gint open_paren = 0;
+
+ while (TRUE)
+ {
+ GTokenType token = g_scanner_peek_next_token (scanner);
+
+ switch (token)
+ {
+ case G_TOKEN_LEFT_PAREN:
+ open_paren++;
+ g_scanner_get_next_token (scanner);
+ break;
+
+ case G_TOKEN_RIGHT_PAREN:
+ if (open_paren == 0)
+ return token;
+
+ open_paren--;
+ g_scanner_get_next_token (scanner);
+ break;
+
+ case G_TOKEN_EOF:
+ return token;
+
+ default:
+ g_scanner_get_next_token (scanner);
+ break;
+ }
+ }
+}