glib/gio/glib-compile-schemas.c
Daniyar Tleulin 49537e298c glib-compile-schemas: Fix non-ASCII arg parsing on Windows
When the source directory contains non-ASCII symbols,
argument parsing previously failed on MINGW64.

Fixes: #3003
2023-05-23 16:49:21 +06:00

2349 lines
70 KiB
C
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/*
* Copyright © 2010 Codethink Limited
*
* SPDX-License-Identifier: LGPL-2.1-or-later
*
* 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.1 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
* 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, see <http://www.gnu.org/licenses/>.
*
* Author: Ryan Lortie <desrt@desrt.ca>
*/
/* Prologue {{{1 */
#include "config.h"
#include <glib.h>
#include <gstdio.h>
#include <gi18n.h>
#include <string.h>
#include <stdio.h>
#include <locale.h>
#include "gvdb/gvdb-builder.h"
#include "strinfo.c"
#include "glib/glib-private.h"
static void
strip_string (GString *string)
{
gint i;
for (i = 0; g_ascii_isspace (string->str[i]); i++);
g_string_erase (string, 0, i);
if (string->len > 0)
{
/* len > 0, so there must be at least one non-whitespace character */
for (i = string->len - 1; g_ascii_isspace (string->str[i]); i--);
g_string_truncate (string, i + 1);
}
}
/* Handling of <enum> {{{1 */
typedef struct
{
GString *strinfo;
gboolean is_flags;
} EnumState;
static void
enum_state_free (gpointer data)
{
EnumState *state = data;
g_string_free (state->strinfo, TRUE);
g_slice_free (EnumState, state);
}
static EnumState *
enum_state_new (gboolean is_flags)
{
EnumState *state;
state = g_slice_new (EnumState);
state->strinfo = g_string_new (NULL);
state->is_flags = is_flags;
return state;
}
static void
enum_state_add_value (EnumState *state,
const gchar *nick,
const gchar *valuestr,
GError **error)
{
gint64 value;
gchar *end;
if (nick[0] == '\0' || nick[1] == '\0')
{
g_set_error (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_INVALID_CONTENT,
_("nick must be a minimum of 2 characters"));
return;
}
value = g_ascii_strtoll (valuestr, &end, 0);
if (*end || (state->is_flags ?
(value > G_MAXUINT32 || value < 0) :
(value > G_MAXINT32 || value < G_MININT32)))
{
g_set_error (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_INVALID_CONTENT,
_("Invalid numeric value"));
return;
}
if (strinfo_builder_contains (state->strinfo, nick))
{
g_set_error (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_INVALID_CONTENT,
_("<value nick='%s'/> already specified"), nick);
return;
}
if (strinfo_builder_contains_value (state->strinfo, value))
{
g_set_error (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_INVALID_CONTENT,
_("value='%s' already specified"), valuestr);
return;
}
/* Silently drop the null case if it is mentioned.
* It is properly denoted with an empty array.
*/
if (state->is_flags && value == 0)
return;
if (state->is_flags && (value & (value - 1)))
{
g_set_error (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_INVALID_CONTENT,
_("flags values must have at most 1 bit set"));
return;
}
/* Since we reject exact duplicates of value='' and we only allow one
* bit to be set, it's not possible to have overlaps.
*
* If we loosen the one-bit-set restriction we need an overlap check.
*/
strinfo_builder_append_item (state->strinfo, nick, value);
}
static void
enum_state_end (EnumState **state_ptr,
GError **error)
{
EnumState *state;
state = *state_ptr;
*state_ptr = NULL;
if (state->strinfo->len == 0)
g_set_error (error,
G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
_("<%s> must contain at least one <value>"),
state->is_flags ? "flags" : "enum");
}
/* Handling of <key> {{{1 */
typedef struct
{
/* for <child>, @child_schema will be set.
* for <key>, everything else will be set.
*/
gchar *child_schema;
GVariantType *type;
gboolean have_gettext_domain;
gchar l10n;
gchar *l10n_context;
GString *unparsed_default_value;
GVariant *default_value;
GVariantDict *desktop_overrides;
GString *strinfo;
gboolean is_enum;
gboolean is_flags;
GVariant *minimum;
GVariant *maximum;
gboolean has_choices;
gboolean has_aliases;
gboolean is_override;
gboolean checked;
GVariant *serialised;
gboolean summary_seen;
gboolean description_seen;
} KeyState;
static KeyState *
key_state_new (const gchar *type_string,
const gchar *gettext_domain,
gboolean is_enum,
gboolean is_flags,
GString *strinfo)
{
KeyState *state;
state = g_slice_new0 (KeyState);
state->type = g_variant_type_new (type_string);
state->have_gettext_domain = gettext_domain != NULL;
state->is_enum = is_enum;
state->is_flags = is_flags;
state->summary_seen = FALSE;
state->description_seen = FALSE;
if (strinfo)
state->strinfo = g_string_new_len (strinfo->str, strinfo->len);
else
state->strinfo = g_string_new (NULL);
return state;
}
static KeyState *
key_state_override (KeyState *state,
const gchar *gettext_domain)
{
KeyState *copy;
copy = g_slice_new0 (KeyState);
copy->type = g_variant_type_copy (state->type);
copy->have_gettext_domain = gettext_domain != NULL;
copy->strinfo = g_string_new_len (state->strinfo->str,
state->strinfo->len);
copy->is_enum = state->is_enum;
copy->is_flags = state->is_flags;
copy->is_override = TRUE;
if (state->minimum)
{
copy->minimum = g_variant_ref (state->minimum);
copy->maximum = g_variant_ref (state->maximum);
}
return copy;
}
static KeyState *
key_state_new_child (const gchar *child_schema)
{
KeyState *state;
state = g_slice_new0 (KeyState);
state->child_schema = g_strdup (child_schema);
return state;
}
static gboolean
is_valid_choices (GVariant *variant,
GString *strinfo)
{
switch (g_variant_classify (variant))
{
case G_VARIANT_CLASS_MAYBE:
case G_VARIANT_CLASS_ARRAY:
{
gboolean valid = TRUE;
GVariantIter iter;
g_variant_iter_init (&iter, variant);
while (valid && (variant = g_variant_iter_next_value (&iter)))
{
valid = is_valid_choices (variant, strinfo);
g_variant_unref (variant);
}
return valid;
}
case G_VARIANT_CLASS_STRING:
return strinfo_is_string_valid ((const guint32 *) strinfo->str,
strinfo->len / 4,
g_variant_get_string (variant, NULL));
default:
g_assert_not_reached ();
}
}
/* Gets called at </default> </choices> or <range/> to check for
* validity of the default value so that any inconsistency is
* reported as soon as it is encountered.
*/
static void
key_state_check_range (KeyState *state,
GError **error)
{
if (state->default_value)
{
const gchar *tag;
tag = state->is_override ? "override" : "default";
if (state->minimum)
{
if (g_variant_compare (state->default_value, state->minimum) < 0 ||
g_variant_compare (state->default_value, state->maximum) > 0)
{
g_set_error (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_INVALID_CONTENT,
_("<%s> is not contained in "
"the specified range"), tag);
}
}
else if (state->strinfo->len)
{
if (!is_valid_choices (state->default_value, state->strinfo))
{
if (state->is_enum)
g_set_error (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_INVALID_CONTENT,
_("<%s> is not a valid member of "
"the specified enumerated type"), tag);
else if (state->is_flags)
g_set_error (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_INVALID_CONTENT,
_("<%s> contains string not in the "
"specified flags type"), tag);
else
g_set_error (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_INVALID_CONTENT,
_("<%s> contains a string not in "
"<choices>"), tag);
}
}
}
}
static void
key_state_set_range (KeyState *state,
const gchar *min_str,
const gchar *max_str,
GError **error)
{
const struct {
const gchar type;
const gchar *min;
const gchar *max;
} table[] = {
{ 'y', "0", "255" },
{ 'n', "-32768", "32767" },
{ 'q', "0", "65535" },
{ 'i', "-2147483648", "2147483647" },
{ 'u', "0", "4294967295" },
{ 'x', "-9223372036854775808", "9223372036854775807" },
{ 't', "0", "18446744073709551615" },
{ 'd', "-inf", "inf" },
};
gboolean type_ok = FALSE;
gsize i;
if (state->minimum)
{
g_set_error_literal (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_INVALID_CONTENT,
_("<range/> already specified for this key"));
return;
}
for (i = 0; i < G_N_ELEMENTS (table); i++)
if (*(char *) state->type == table[i].type)
{
min_str = min_str ? min_str : table[i].min;
max_str = max_str ? max_str : table[i].max;
type_ok = TRUE;
break;
}
if (!type_ok)
{
gchar *type = g_variant_type_dup_string (state->type);
g_set_error (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_INVALID_CONTENT,
_("<range> not allowed for keys of type “%s”"), type);
g_free (type);
return;
}
state->minimum = g_variant_parse (state->type, min_str, NULL, NULL, error);
if (state->minimum == NULL)
return;
state->maximum = g_variant_parse (state->type, max_str, NULL, NULL, error);
if (state->maximum == NULL)
return;
if (g_variant_compare (state->minimum, state->maximum) > 0)
{
g_set_error (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_INVALID_CONTENT,
_("<range> specified minimum is greater than maximum"));
return;
}
key_state_check_range (state, error);
}
static GString *
key_state_start_default (KeyState *state,
const gchar *l10n,
const gchar *context,
GError **error)
{
if (l10n != NULL)
{
if (strcmp (l10n, "messages") == 0)
state->l10n = 'm';
else if (strcmp (l10n, "time") == 0)
state->l10n = 't';
else
{
g_set_error (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_INVALID_CONTENT,
_("unsupported l10n category: %s"), l10n);
return NULL;
}
if (!state->have_gettext_domain)
{
g_set_error_literal (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_INVALID_CONTENT,
_("l10n requested, but no "
"gettext domain given"));
return NULL;
}
state->l10n_context = g_strdup (context);
}
else if (context != NULL)
{
g_set_error_literal (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_INVALID_CONTENT,
_("translation context given for "
"value without l10n enabled"));
return NULL;
}
return g_string_new (NULL);
}
static void
key_state_end_default (KeyState *state,
GString **string,
GError **error)
{
state->unparsed_default_value = *string;
*string = NULL;
state->default_value = g_variant_parse (state->type,
state->unparsed_default_value->str,
NULL, NULL, error);
if (!state->default_value)
{
gchar *type = g_variant_type_dup_string (state->type);
g_prefix_error (error, _("Failed to parse <default> value of type “%s”: "), type);
g_free (type);
}
key_state_check_range (state, error);
}
static void
key_state_start_choices (KeyState *state,
GError **error)
{
const GVariantType *type = state->type;
if (state->is_enum)
{
g_set_error_literal (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_INVALID_CONTENT,
_("<choices> cannot be specified for keys "
"tagged as having an enumerated type"));
return;
}
if (state->has_choices)
{
g_set_error_literal (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_INVALID_CONTENT,
_("<choices> already specified for this key"));
return;
}
while (g_variant_type_is_maybe (type) || g_variant_type_is_array (type))
type = g_variant_type_element (type);
if (!g_variant_type_equal (type, G_VARIANT_TYPE_STRING))
{
gchar *type_string = g_variant_type_dup_string (state->type);
g_set_error (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_INVALID_CONTENT,
_("<choices> not allowed for keys of type “%s”"),
type_string);
g_free (type_string);
return;
}
}
static void
key_state_add_choice (KeyState *state,
const gchar *choice,
GError **error)
{
if (strinfo_builder_contains (state->strinfo, choice))
{
g_set_error (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_INVALID_CONTENT,
_("<choice value='%s'/> already given"), choice);
return;
}
strinfo_builder_append_item (state->strinfo, choice, 0);
state->has_choices = TRUE;
}
static void
key_state_end_choices (KeyState *state,
GError **error)
{
if (!state->has_choices)
{
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
_("<choices> must contain at least one <choice>"));
return;
}
key_state_check_range (state, error);
}
static void
key_state_start_aliases (KeyState *state,
GError **error)
{
if (state->has_aliases)
g_set_error_literal (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_INVALID_CONTENT,
_("<aliases> already specified for this key"));
else if (!state->is_flags && !state->is_enum && !state->has_choices)
g_set_error_literal (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_INVALID_CONTENT,
_("<aliases> can only be specified for keys with "
"enumerated or flags types or after <choices>"));
}
static void
key_state_add_alias (KeyState *state,
const gchar *alias,
const gchar *target,
GError **error)
{
if (strinfo_builder_contains (state->strinfo, alias))
{
if (strinfo_is_string_valid ((guint32 *) state->strinfo->str,
state->strinfo->len / 4,
alias))
{
if (state->is_enum)
g_set_error (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_INVALID_CONTENT,
_("<alias value='%s'/> given when “%s” is already "
"a member of the enumerated type"), alias, alias);
else
g_set_error (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_INVALID_CONTENT,
_("<alias value='%s'/> given when "
"<choice value='%s'/> was already given"),
alias, alias);
}
else
g_set_error (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_INVALID_CONTENT,
_("<alias value='%s'/> already specified"), alias);
return;
}
if (!strinfo_builder_append_alias (state->strinfo, alias, target))
{
g_set_error (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_INVALID_CONTENT,
state->is_enum ?
_("alias target “%s” is not in enumerated type") :
_("alias target “%s” is not in <choices>"),
target);
return;
}
state->has_aliases = TRUE;
}
static void
key_state_end_aliases (KeyState *state,
GError **error)
{
if (!state->has_aliases)
{
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
_("<aliases> must contain at least one <alias>"));
return;
}
}
static gboolean
key_state_check (KeyState *state,
GError **error)
{
if (state->checked)
return TRUE;
return state->checked = TRUE;
}
static GVariant *
key_state_serialise (KeyState *state)
{
if (state->serialised == NULL)
{
if (state->child_schema)
{
state->serialised = g_variant_new_string (state->child_schema);
}
else
{
GVariantBuilder builder;
gboolean checked G_GNUC_UNUSED /* when compiling with G_DISABLE_ASSERT */;
checked = key_state_check (state, NULL);
g_assert (checked);
g_variant_builder_init (&builder, G_VARIANT_TYPE_TUPLE);
/* default value */
g_variant_builder_add_value (&builder, state->default_value);
/* translation */
if (state->l10n)
{
/* We are going to store the untranslated default for
* runtime translation according to the current locale.
* We need to strip leading and trailing whitespace from
* the string so that it's exactly the same as the one
* that ended up in the .po file for translation.
*
* We want to do this so that
*
* <default l10n='messages'>
* ['a', 'b', 'c']
* </default>
*
* ends up in the .po file like "['a', 'b', 'c']",
* omitting the extra whitespace at the start and end.
*/
strip_string (state->unparsed_default_value);
if (state->l10n_context)
{
gint len;
/* Contextified messages are supported by prepending
* the context, followed by '\004' to the start of the
* message string. We do that here to save GSettings
* the work later on.
*/
len = strlen (state->l10n_context);
state->l10n_context[len] = '\004';
g_string_prepend_len (state->unparsed_default_value,
state->l10n_context, len + 1);
g_free (state->l10n_context);
state->l10n_context = NULL;
}
g_variant_builder_add (&builder, "(y(y&s))", 'l', state->l10n,
state->unparsed_default_value->str);
g_string_free (state->unparsed_default_value, TRUE);
state->unparsed_default_value = NULL;
}
/* choice, aliases, enums */
if (state->strinfo->len)
{
GVariant *array;
guint32 *words;
gpointer data;
gsize size;
gsize i;
size = state->strinfo->len;
data = g_string_free_and_steal (g_steal_pointer (&state->strinfo));
words = data;
for (i = 0; i < size / sizeof (guint32); i++)
words[i] = GUINT32_TO_LE (words[i]);
array = g_variant_new_from_data (G_VARIANT_TYPE ("au"),
data, size, TRUE,
g_free, data);
g_variant_builder_add (&builder, "(y@au)",
state->is_flags ? 'f' :
state->is_enum ? 'e' : 'c',
array);
}
/* range */
if (state->minimum || state->maximum)
g_variant_builder_add (&builder, "(y(**))", 'r',
state->minimum, state->maximum);
/* per-desktop overrides */
if (state->desktop_overrides)
g_variant_builder_add (&builder, "(y@a{sv})", 'd',
g_variant_dict_end (state->desktop_overrides));
state->serialised = g_variant_builder_end (&builder);
}
g_variant_ref_sink (state->serialised);
}
return g_variant_ref (state->serialised);
}
static void
key_state_free (gpointer data)
{
KeyState *state = data;
g_free (state->child_schema);
if (state->type)
g_variant_type_free (state->type);
g_free (state->l10n_context);
if (state->unparsed_default_value)
g_string_free (state->unparsed_default_value, TRUE);
if (state->default_value)
g_variant_unref (state->default_value);
if (state->strinfo)
g_string_free (state->strinfo, TRUE);
if (state->minimum)
g_variant_unref (state->minimum);
if (state->maximum)
g_variant_unref (state->maximum);
if (state->serialised)
g_variant_unref (state->serialised);
if (state->desktop_overrides)
g_variant_dict_unref (state->desktop_overrides);
g_slice_free (KeyState, state);
}
/* Key name validity {{{1 */
static gboolean allow_any_name = FALSE;
static gboolean
is_valid_keyname (const gchar *key,
GError **error)
{
gint i;
if (key[0] == '\0')
{
g_set_error_literal (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
_("Empty names are not permitted"));
return FALSE;
}
if (allow_any_name)
return TRUE;
if (!g_ascii_islower (key[0]))
{
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
_("Invalid name “%s”: names must begin "
"with a lowercase letter"), key);
return FALSE;
}
for (i = 1; key[i]; i++)
{
if (key[i] != '-' &&
!g_ascii_islower (key[i]) &&
!g_ascii_isdigit (key[i]))
{
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
_("Invalid name “%s”: invalid character “%c”; "
"only lowercase letters, numbers and hyphen (“-”) "
"are permitted"), key, key[i]);
return FALSE;
}
if (key[i] == '-' && key[i + 1] == '-')
{
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
_("Invalid name “%s”: two successive hyphens (“--”) "
"are not permitted"), key);
return FALSE;
}
}
if (key[i - 1] == '-')
{
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
_("Invalid name “%s”: the last character may not be a "
"hyphen (“-”)"), key);
return FALSE;
}
if (i > 1024)
{
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
_("Invalid name “%s”: maximum length is 1024"), key);
return FALSE;
}
return TRUE;
}
/* Handling of <schema> {{{1 */
typedef struct _SchemaState SchemaState;
struct _SchemaState
{
SchemaState *extends;
gchar *path;
gchar *gettext_domain;
gchar *extends_name;
gchar *list_of;
GHashTable *keys;
};
static SchemaState *
schema_state_new (const gchar *path,
const gchar *gettext_domain,
SchemaState *extends,
const gchar *extends_name,
const gchar *list_of)
{
SchemaState *state;
state = g_slice_new (SchemaState);
state->path = g_strdup (path);
state->gettext_domain = g_strdup (gettext_domain);
state->extends = extends;
state->extends_name = g_strdup (extends_name);
state->list_of = g_strdup (list_of);
state->keys = g_hash_table_new_full (g_str_hash, g_str_equal,
g_free, key_state_free);
return state;
}
static void
schema_state_free (gpointer data)
{
SchemaState *state = data;
g_free (state->path);
g_free (state->gettext_domain);
g_free (state->extends_name);
g_free (state->list_of);
g_hash_table_unref (state->keys);
g_slice_free (SchemaState, state);
}
static void
schema_state_add_child (SchemaState *state,
const gchar *name,
const gchar *schema,
GError **error)
{
gchar *childname;
if (!is_valid_keyname (name, error))
return;
childname = g_strconcat (name, "/", NULL);
if (g_hash_table_lookup (state->keys, childname))
{
g_set_error (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_INVALID_CONTENT,
_("<child name='%s'> already specified"), name);
return;
}
g_hash_table_insert (state->keys, childname,
key_state_new_child (schema));
}
static KeyState *
schema_state_add_key (SchemaState *state,
GHashTable *enum_table,
GHashTable *flags_table,
const gchar *name,
const gchar *type_string,
const gchar *enum_type,
const gchar *flags_type,
GError **error)
{
SchemaState *node;
GString *strinfo;
KeyState *key;
if (state->list_of)
{
g_set_error_literal (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_INVALID_CONTENT,
_("Cannot add keys to a “list-of” schema"));
return NULL;
}
if (!is_valid_keyname (name, error))
return NULL;
if (g_hash_table_lookup (state->keys, name))
{
g_set_error (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_INVALID_CONTENT,
_("<key name='%s'> already specified"), name);
return NULL;
}
for (node = state; node; node = node->extends)
if (node->extends)
{
KeyState *shadow;
shadow = g_hash_table_lookup (node->extends->keys, name);
/* in case of <key> <override> <key> make sure we report the
* location of the original <key>, not the <override>.
*/
if (shadow && !shadow->is_override)
{
g_set_error (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_INVALID_CONTENT,
_("<key name='%s'> shadows <key name='%s'> in "
"<schema id='%s'>; use <override> to modify value"),
name, name, node->extends_name);
return NULL;
}
}
if ((type_string != NULL) + (enum_type != NULL) + (flags_type != NULL) != 1)
{
g_set_error (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_MISSING_ATTRIBUTE,
_("Exactly one of “type”, “enum” or “flags” must "
"be specified as an attribute to <key>"));
return NULL;
}
if (type_string == NULL) /* flags or enums was specified */
{
EnumState *enum_state;
if (enum_type)
enum_state = g_hash_table_lookup (enum_table, enum_type);
else
enum_state = g_hash_table_lookup (flags_table, flags_type);
if (enum_state == NULL)
{
g_set_error (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_INVALID_CONTENT,
_("<%s id='%s'> not (yet) defined."),
flags_type ? "flags" : "enum",
flags_type ? flags_type : enum_type);
return NULL;
}
type_string = flags_type ? "as" : "s";
strinfo = enum_state->strinfo;
}
else
{
if (!g_variant_type_string_is_valid (type_string))
{
g_set_error (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_INVALID_CONTENT,
_("Invalid GVariant type string “%s”"), type_string);
return NULL;
}
strinfo = NULL;
}
key = key_state_new (type_string, state->gettext_domain,
enum_type != NULL, flags_type != NULL, strinfo);
g_hash_table_insert (state->keys, g_strdup (name), key);
return key;
}
static void
schema_state_add_override (SchemaState *state,
KeyState **key_state,
GString **string,
const gchar *key,
const gchar *l10n,
const gchar *context,
GError **error)
{
SchemaState *parent;
KeyState *original = NULL;
if (state->extends == NULL)
{
g_set_error_literal (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_INVALID_CONTENT,
_("<override> given but schema isnt "
"extending anything"));
return;
}
for (parent = state->extends; parent; parent = parent->extends)
if ((original = g_hash_table_lookup (parent->keys, key)))
break;
if (original == NULL)
{
g_set_error (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_INVALID_CONTENT,
_("No <key name='%s'> to override"), key);
return;
}
if (g_hash_table_lookup (state->keys, key))
{
g_set_error (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_INVALID_CONTENT,
_("<override name='%s'> already specified"), key);
return;
}
*key_state = key_state_override (original, state->gettext_domain);
*string = key_state_start_default (*key_state, l10n, context, error);
g_hash_table_insert (state->keys, g_strdup (key), *key_state);
}
static void
override_state_end (KeyState **key_state,
GString **string,
GError **error)
{
key_state_end_default (*key_state, string, error);
*key_state = NULL;
}
/* Handling of toplevel state {{{1 */
typedef struct
{
gboolean strict; /* TRUE if --strict was given */
GHashTable *schema_table; /* string -> SchemaState */
GHashTable *flags_table; /* string -> EnumState */
GHashTable *enum_table; /* string -> EnumState */
GSList *this_file_schemas; /* strings: <schema>s in this file */
GSList *this_file_flagss; /* strings: <flags>s in this file */
GSList *this_file_enums; /* strings: <enum>s in this file */
gchar *schemalist_domain; /* the <schemalist> gettext domain */
SchemaState *schema_state; /* non-NULL when inside <schema> */
KeyState *key_state; /* non-NULL when inside <key> */
EnumState *enum_state; /* non-NULL when inside <enum> */
GString *string; /* non-NULL when accepting text */
} ParseState;
static gboolean
is_subclass (const gchar *class_name,
const gchar *possible_parent,
GHashTable *schema_table)
{
SchemaState *class;
if (strcmp (class_name, possible_parent) == 0)
return TRUE;
class = g_hash_table_lookup (schema_table, class_name);
g_assert (class != NULL);
return class->extends_name &&
is_subclass (class->extends_name, possible_parent, schema_table);
}
static void
parse_state_start_schema (ParseState *state,
const gchar *id,
const gchar *path,
const gchar *gettext_domain,
const gchar *extends_name,
const gchar *list_of,
GError **error)
{
SchemaState *extends;
gchar *my_id;
if (g_hash_table_lookup (state->schema_table, id))
{
g_set_error (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_INVALID_CONTENT,
_("<schema id='%s'> already specified"), id);
return;
}
if (extends_name)
{
extends = g_hash_table_lookup (state->schema_table, extends_name);
if (extends == NULL)
{
g_set_error (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_INVALID_CONTENT,
_("<schema id='%s'> extends not yet existing "
"schema “%s”"), id, extends_name);
return;
}
}
else
extends = NULL;
if (list_of)
{
SchemaState *tmp;
if (!(tmp = g_hash_table_lookup (state->schema_table, list_of)))
{
g_set_error (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_INVALID_CONTENT,
_("<schema id='%s'> is list of not yet existing "
"schema “%s”"), id, list_of);
return;
}
if (tmp->path)
{
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
_("Cannot be a list of a schema with a path"));
return;
}
}
if (extends)
{
if (extends->path)
{
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
_("Cannot extend a schema with a path"));
return;
}
if (list_of)
{
if (extends->list_of == NULL)
{
g_set_error (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_INVALID_CONTENT,
_("<schema id='%s'> is a list, extending "
"<schema id='%s'> which is not a list"),
id, extends_name);
return;
}
if (!is_subclass (list_of, extends->list_of, state->schema_table))
{
g_set_error (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_INVALID_CONTENT,
_("<schema id='%s' list-of='%s'> extends <schema "
"id='%s' list-of='%s'> but “%s” does not "
"extend “%s”"), id, list_of, extends_name,
extends->list_of, list_of, extends->list_of);
return;
}
}
else
/* by default we are a list of the same thing that the schema
* we are extending is a list of (which might be nothing)
*/
list_of = extends->list_of;
}
if (path && !(g_str_has_prefix (path, "/") && g_str_has_suffix (path, "/")))
{
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
_("A path, if given, must begin and end with a slash"));
return;
}
if (path && list_of && !g_str_has_suffix (path, ":/"))
{
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
_("The path of a list must end with “:/”"));
return;
}
if (path && (g_str_has_prefix (path, "/apps/") ||
g_str_has_prefix (path, "/desktop/") ||
g_str_has_prefix (path, "/system/")))
{
gchar *message = NULL;
message = g_strdup_printf (_("Warning: Schema “%s” has path “%s”. "
"Paths starting with "
"“/apps/”, “/desktop/” or “/system/” are deprecated."),
id, path);
g_printerr ("%s\n", message);
g_free (message);
}
state->schema_state = schema_state_new (path, gettext_domain,
extends, extends_name, list_of);
my_id = g_strdup (id);
state->this_file_schemas = g_slist_prepend (state->this_file_schemas, my_id);
g_hash_table_insert (state->schema_table, my_id, state->schema_state);
}
static void
parse_state_start_enum (ParseState *state,
const gchar *id,
gboolean is_flags,
GError **error)
{
GSList **list = is_flags ? &state->this_file_flagss : &state->this_file_enums;
GHashTable *table = is_flags ? state->flags_table : state->enum_table;
gchar *my_id;
if (g_hash_table_lookup (table, id))
{
g_set_error (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_INVALID_CONTENT,
_("<%s id='%s'> already specified"),
is_flags ? "flags" : "enum", id);
return;
}
state->enum_state = enum_state_new (is_flags);
my_id = g_strdup (id);
*list = g_slist_prepend (*list, my_id);
g_hash_table_insert (table, my_id, state->enum_state);
}
/* GMarkup Parser Functions {{{1 */
/* Start element {{{2 */
static void
start_element (GMarkupParseContext *context,
const gchar *element_name,
const gchar **attribute_names,
const gchar **attribute_values,
gpointer user_data,
GError **error)
{
ParseState *state = user_data;
const GSList *element_stack;
const gchar *container;
element_stack = g_markup_parse_context_get_element_stack (context);
container = element_stack->next ? element_stack->next->data : NULL;
#define COLLECT(first, ...) \
g_markup_collect_attributes (element_name, \
attribute_names, attribute_values, error, \
first, __VA_ARGS__, G_MARKUP_COLLECT_INVALID)
#define OPTIONAL G_MARKUP_COLLECT_OPTIONAL
#define STRDUP G_MARKUP_COLLECT_STRDUP
#define STRING G_MARKUP_COLLECT_STRING
#define NO_ATTRS() COLLECT (G_MARKUP_COLLECT_INVALID, NULL)
/* Toplevel items {{{3 */
if (container == NULL)
{
if (strcmp (element_name, "schemalist") == 0)
{
COLLECT (OPTIONAL | STRDUP,
"gettext-domain",
&state->schemalist_domain);
return;
}
}
/* children of <schemalist> {{{3 */
else if (strcmp (container, "schemalist") == 0)
{
if (strcmp (element_name, "schema") == 0)
{
const gchar *id, *path, *gettext_domain, *extends, *list_of;
if (COLLECT (STRING, "id", &id,
OPTIONAL | STRING, "path", &path,
OPTIONAL | STRING, "gettext-domain", &gettext_domain,
OPTIONAL | STRING, "extends", &extends,
OPTIONAL | STRING, "list-of", &list_of))
parse_state_start_schema (state, id, path,
gettext_domain ? gettext_domain
: state->schemalist_domain,
extends, list_of, error);
return;
}
else if (strcmp (element_name, "enum") == 0)
{
const gchar *id;
if (COLLECT (STRING, "id", &id))
parse_state_start_enum (state, id, FALSE, error);
return;
}
else if (strcmp (element_name, "flags") == 0)
{
const gchar *id;
if (COLLECT (STRING, "id", &id))
parse_state_start_enum (state, id, TRUE, error);
return;
}
}
/* children of <schema> {{{3 */
else if (strcmp (container, "schema") == 0)
{
if (strcmp (element_name, "key") == 0)
{
const gchar *name, *type_string, *enum_type, *flags_type;
if (COLLECT (STRING, "name", &name,
OPTIONAL | STRING, "type", &type_string,
OPTIONAL | STRING, "enum", &enum_type,
OPTIONAL | STRING, "flags", &flags_type))
state->key_state = schema_state_add_key (state->schema_state,
state->enum_table,
state->flags_table,
name, type_string,
enum_type, flags_type,
error);
return;
}
else if (strcmp (element_name, "child") == 0)
{
const gchar *name, *schema;
if (COLLECT (STRING, "name", &name, STRING, "schema", &schema))
schema_state_add_child (state->schema_state,
name, schema, error);
return;
}
else if (strcmp (element_name, "override") == 0)
{
const gchar *name, *l10n, *str_context;
if (COLLECT (STRING, "name", &name,
OPTIONAL | STRING, "l10n", &l10n,
OPTIONAL | STRING, "context", &str_context))
schema_state_add_override (state->schema_state,
&state->key_state, &state->string,
name, l10n, str_context, error);
return;
}
}
/* children of <key> {{{3 */
else if (strcmp (container, "key") == 0)
{
if (strcmp (element_name, "default") == 0)
{
const gchar *l10n, *str_context;
if (COLLECT (STRING | OPTIONAL, "l10n", &l10n,
STRING | OPTIONAL, "context", &str_context))
state->string = key_state_start_default (state->key_state,
l10n, str_context, error);
return;
}
else if (strcmp (element_name, "summary") == 0)
{
if (NO_ATTRS ())
{
if (state->key_state->summary_seen && state->strict)
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
_("Only one <%s> element allowed inside <%s>"),
element_name, container);
else
state->string = g_string_new (NULL);
state->key_state->summary_seen = TRUE;
}
return;
}
else if (strcmp (element_name, "description") == 0)
{
if (NO_ATTRS ())
{
if (state->key_state->description_seen && state->strict)
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
_("Only one <%s> element allowed inside <%s>"),
element_name, container);
else
state->string = g_string_new (NULL);
state->key_state->description_seen = TRUE;
}
return;
}
else if (strcmp (element_name, "range") == 0)
{
const gchar *min, *max;
if (COLLECT (STRING | OPTIONAL, "min", &min,
STRING | OPTIONAL, "max", &max))
key_state_set_range (state->key_state, min, max, error);
return;
}
else if (strcmp (element_name, "choices") == 0)
{
if (NO_ATTRS ())
key_state_start_choices (state->key_state, error);
return;
}
else if (strcmp (element_name, "aliases") == 0)
{
if (NO_ATTRS ())
key_state_start_aliases (state->key_state, error);
return;
}
}
/* children of <choices> {{{3 */
else if (strcmp (container, "choices") == 0)
{
if (strcmp (element_name, "choice") == 0)
{
const gchar *value;
if (COLLECT (STRING, "value", &value))
key_state_add_choice (state->key_state, value, error);
return;
}
}
/* children of <aliases> {{{3 */
else if (strcmp (container, "aliases") == 0)
{
if (strcmp (element_name, "alias") == 0)
{
const gchar *value, *target;
if (COLLECT (STRING, "value", &value, STRING, "target", &target))
key_state_add_alias (state->key_state, value, target, error);
return;
}
}
/* children of <enum> {{{3 */
else if (strcmp (container, "enum") == 0 ||
strcmp (container, "flags") == 0)
{
if (strcmp (element_name, "value") == 0)
{
const gchar *nick, *valuestr;
if (COLLECT (STRING, "nick", &nick,
STRING, "value", &valuestr))
enum_state_add_value (state->enum_state, nick, valuestr, error);
return;
}
}
/* 3}}} */
if (container)
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_UNKNOWN_ELEMENT,
_("Element <%s> not allowed inside <%s>"),
element_name, container);
else
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_UNKNOWN_ELEMENT,
_("Element <%s> not allowed at the top level"), element_name);
}
/* 2}}} */
/* End element {{{2 */
static void
key_state_end (KeyState **state_ptr,
GError **error)
{
KeyState *state;
state = *state_ptr;
*state_ptr = NULL;
if (state->default_value == NULL)
{
g_set_error_literal (error,
G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
_("Element <default> is required in <key>"));
return;
}
}
static void
schema_state_end (SchemaState **state_ptr,
GError **error)
{
*state_ptr = NULL;
}
static void
end_element (GMarkupParseContext *context,
const gchar *element_name,
gpointer user_data,
GError **error)
{
ParseState *state = user_data;
if (strcmp (element_name, "schemalist") == 0)
{
g_free (state->schemalist_domain);
state->schemalist_domain = NULL;
}
else if (strcmp (element_name, "enum") == 0 ||
strcmp (element_name, "flags") == 0)
enum_state_end (&state->enum_state, error);
else if (strcmp (element_name, "schema") == 0)
schema_state_end (&state->schema_state, error);
else if (strcmp (element_name, "override") == 0)
override_state_end (&state->key_state, &state->string, error);
else if (strcmp (element_name, "key") == 0)
key_state_end (&state->key_state, error);
else if (strcmp (element_name, "default") == 0)
key_state_end_default (state->key_state, &state->string, error);
else if (strcmp (element_name, "choices") == 0)
key_state_end_choices (state->key_state, error);
else if (strcmp (element_name, "aliases") == 0)
key_state_end_aliases (state->key_state, error);
if (state->string)
{
g_string_free (state->string, TRUE);
state->string = NULL;
}
}
/* Text {{{2 */
static void
text (GMarkupParseContext *context,
const gchar *text,
gsize text_len,
gpointer user_data,
GError **error)
{
ParseState *state = user_data;
if (state->string)
{
/* we are expecting a string, so store the text data.
*
* we store the data verbatim here and deal with whitespace
* later on. there are two reasons for that:
*
* 1) whitespace is handled differently depending on the tag
* type.
*
* 2) we could do leading whitespace removal by refusing to
* insert it into state->string if it's at the start, but for
* trailing whitespace, we have no idea if there is another
* text() call coming or not.
*/
g_string_append_len (state->string, text, text_len);
}
else
{
/* string is not expected: accept (and ignore) pure whitespace */
gsize i;
for (i = 0; i < text_len; i++)
if (!g_ascii_isspace (text[i]))
{
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
_("Text may not appear inside <%s>"),
g_markup_parse_context_get_element (context));
break;
}
}
}
/* Write to GVDB {{{1 */
typedef struct
{
GHashTable *table;
GvdbItem *root;
} GvdbPair;
static void
gvdb_pair_init (GvdbPair *pair)
{
pair->table = gvdb_hash_table_new (NULL, NULL);
pair->root = gvdb_hash_table_insert (pair->table, "");
}
static void
gvdb_pair_clear (GvdbPair *pair)
{
g_hash_table_unref (pair->table);
}
typedef struct
{
GHashTable *schema_table;
GvdbPair root_pair;
} WriteToFileData;
typedef struct
{
GHashTable *schema_table;
GvdbPair pair;
gboolean l10n;
} OutputSchemaData;
static void
output_key (gpointer key,
gpointer value,
gpointer user_data)
{
OutputSchemaData *data;
const gchar *name;
KeyState *state;
GvdbItem *item;
GVariant *serialised = NULL;
name = key;
state = value;
data = user_data;
item = gvdb_hash_table_insert (data->pair.table, name);
gvdb_item_set_parent (item, data->pair.root);
serialised = key_state_serialise (state);
gvdb_item_set_value (item, serialised);
g_variant_unref (serialised);
if (state->l10n)
data->l10n = TRUE;
if (state->child_schema &&
!g_hash_table_lookup (data->schema_table, state->child_schema))
{
gchar *message = NULL;
message = g_strdup_printf (_("Warning: undefined reference to <schema id='%s'/>"),
state->child_schema);
g_printerr ("%s\n", message);
g_free (message);
}
}
static void
output_schema (gpointer key,
gpointer value,
gpointer user_data)
{
WriteToFileData *wtf_data = user_data;
OutputSchemaData data;
GvdbPair *root_pair;
SchemaState *state;
const gchar *id;
GvdbItem *item;
id = key;
state = value;
root_pair = &wtf_data->root_pair;
data.schema_table = wtf_data->schema_table;
gvdb_pair_init (&data.pair);
data.l10n = FALSE;
item = gvdb_hash_table_insert (root_pair->table, id);
gvdb_item_set_parent (item, root_pair->root);
gvdb_item_set_hash_table (item, data.pair.table);
g_hash_table_foreach (state->keys, output_key, &data);
if (state->path)
gvdb_hash_table_insert_string (data.pair.table, ".path", state->path);
if (state->extends_name)
gvdb_hash_table_insert_string (data.pair.table, ".extends",
state->extends_name);
if (state->list_of)
gvdb_hash_table_insert_string (data.pair.table, ".list-of",
state->list_of);
if (data.l10n)
gvdb_hash_table_insert_string (data.pair.table,
".gettext-domain",
state->gettext_domain);
gvdb_pair_clear (&data.pair);
}
static gboolean
write_to_file (GHashTable *schema_table,
const gchar *filename,
GError **error)
{
WriteToFileData data;
gboolean success;
data.schema_table = schema_table;
gvdb_pair_init (&data.root_pair);
g_hash_table_foreach (schema_table, output_schema, &data);
success = gvdb_table_write_contents (data.root_pair.table, filename,
G_BYTE_ORDER != G_LITTLE_ENDIAN,
error);
g_hash_table_unref (data.root_pair.table);
return success;
}
/* Parser driver {{{1 */
static GHashTable *
parse_gschema_files (gchar **files,
gboolean strict)
{
GMarkupParser parser = { start_element, end_element, text, NULL, NULL };
ParseState state = { 0, };
const gchar *filename;
GError *error = NULL;
state.strict = strict;
state.enum_table = g_hash_table_new_full (g_str_hash, g_str_equal,
g_free, enum_state_free);
state.flags_table = g_hash_table_new_full (g_str_hash, g_str_equal,
g_free, enum_state_free);
state.schema_table = g_hash_table_new_full (g_str_hash, g_str_equal,
g_free, schema_state_free);
while ((filename = *files++) != NULL)
{
GMarkupParseContext *context;
gchar *contents;
gsize size;
gint line, col;
if (!g_file_get_contents (filename, &contents, &size, &error))
{
fprintf (stderr, "%s\n", error->message);
g_clear_error (&error);
continue;
}
context = g_markup_parse_context_new (&parser,
G_MARKUP_TREAT_CDATA_AS_TEXT |
G_MARKUP_PREFIX_ERROR_POSITION |
G_MARKUP_IGNORE_QUALIFIED,
&state, NULL);
if (!g_markup_parse_context_parse (context, contents, size, &error) ||
!g_markup_parse_context_end_parse (context, &error))
{
GSList *item;
/* back out any changes from this file */
for (item = state.this_file_schemas; item; item = item->next)
g_hash_table_remove (state.schema_table, item->data);
for (item = state.this_file_flagss; item; item = item->next)
g_hash_table_remove (state.flags_table, item->data);
for (item = state.this_file_enums; item; item = item->next)
g_hash_table_remove (state.enum_table, item->data);
/* let them know */
g_markup_parse_context_get_position (context, &line, &col);
fprintf (stderr, "%s:%d:%d %s. ", filename, line, col, error->message);
g_clear_error (&error);
if (strict)
{
/* Translators: Do not translate "--strict". */
fprintf (stderr, "%s\n", _("--strict was specified; exiting."));
g_hash_table_unref (state.schema_table);
g_hash_table_unref (state.flags_table);
g_hash_table_unref (state.enum_table);
g_free (contents);
return NULL;
}
else
{
fprintf (stderr, "%s\n", _("This entire file has been ignored."));
}
}
/* cleanup */
g_free (contents);
g_markup_parse_context_free (context);
g_slist_free (state.this_file_schemas);
g_slist_free (state.this_file_flagss);
g_slist_free (state.this_file_enums);
state.this_file_schemas = NULL;
state.this_file_flagss = NULL;
state.this_file_enums = NULL;
}
g_hash_table_unref (state.flags_table);
g_hash_table_unref (state.enum_table);
return state.schema_table;
}
static gint
compare_strings (gconstpointer a,
gconstpointer b)
{
const gchar *one = a;
const gchar *two = b;
gint cmp;
cmp = g_str_has_suffix (two, ".enums.xml") -
g_str_has_suffix (one, ".enums.xml");
if (!cmp)
cmp = strcmp (one, two);
return cmp;
}
static gboolean
set_overrides (GHashTable *schema_table,
gchar **files,
gboolean strict)
{
const gchar *filename;
GError *error = NULL;
while ((filename = *files++))
{
GKeyFile *key_file;
gchar **groups;
gint i;
g_debug ("Processing override file '%s'", filename);
key_file = g_key_file_new ();
if (!g_key_file_load_from_file (key_file, filename, 0, &error))
{
fprintf (stderr, "%s: %s. ", filename, error->message);
g_key_file_free (key_file);
g_clear_error (&error);
if (!strict)
{
fprintf (stderr, "%s\n", _("Ignoring this file."));
continue;
}
fprintf (stderr, "%s\n", _("--strict was specified; exiting."));
return FALSE;
}
groups = g_key_file_get_groups (key_file, NULL);
for (i = 0; groups[i]; i++)
{
const gchar *group = groups[i];
const gchar *schema_name;
const gchar *desktop_id;
SchemaState *schema;
gchar **pieces;
gchar **keys;
gint j;
pieces = g_strsplit (group, ":", 2);
schema_name = pieces[0];
desktop_id = pieces[1];
g_debug ("Processing group '%s' (schema '%s', %s)",
group, schema_name, desktop_id ? desktop_id : "all desktops");
schema = g_hash_table_lookup (schema_table, schema_name);
if (schema == NULL)
{
/* Having the schema not be installed is expected to be a
* common case. Don't even emit an error message about
* that.
*/
g_strfreev (pieces);
continue;
}
keys = g_key_file_get_keys (key_file, group, NULL, NULL);
g_assert (keys != NULL);
for (j = 0; keys[j]; j++)
{
const gchar *key = keys[j];
KeyState *state;
GVariant *value;
gchar *string;
state = g_hash_table_lookup (schema->keys, key);
if (state == NULL)
{
if (!strict)
{
fprintf (stderr, _("No such key “%s” in schema “%s” as "
"specified in override file “%s”; "
"ignoring override for this key."),
key, group, filename);
fprintf (stderr, "\n");
continue;
}
fprintf (stderr, _("No such key “%s” in schema “%s” as "
"specified in override file “%s” and "
"--strict was specified; exiting."),
key, group, filename);
fprintf (stderr, "\n");
g_key_file_free (key_file);
g_strfreev (pieces);
g_strfreev (groups);
g_strfreev (keys);
return FALSE;
}
if (desktop_id != NULL && state->l10n)
{
/* Let's avoid the n*m case of per-desktop localised
* default values, and just forbid it.
*/
if (!strict)
{
fprintf (stderr,
_("Cannot provide per-desktop overrides for "
"localized key “%s” in schema “%s” (override "
"file “%s”); ignoring override for this key."),
key, group, filename);
fprintf (stderr, "\n");
continue;
}
fprintf (stderr,
_("Cannot provide per-desktop overrides for "
"localized key “%s” in schema “%s” (override "
"file “%s”) and --strict was specified; exiting."),
key, group, filename);
fprintf (stderr, "\n");
g_key_file_free (key_file);
g_strfreev (pieces);
g_strfreev (groups);
g_strfreev (keys);
return FALSE;
}
string = g_key_file_get_value (key_file, group, key, NULL);
g_assert (string != NULL);
value = g_variant_parse (state->type, string,
NULL, NULL, &error);
if (value == NULL)
{
if (!strict)
{
fprintf (stderr, _("Error parsing key “%s” in schema “%s” "
"as specified in override file “%s”: "
"%s. Ignoring override for this key."),
key, group, filename, error->message);
fprintf (stderr, "\n");
g_clear_error (&error);
g_free (string);
continue;
}
fprintf (stderr, _("Error parsing key “%s” in schema “%s” "
"as specified in override file “%s”: "
"%s. --strict was specified; exiting."),
key, group, filename, error->message);
fprintf (stderr, "\n");
g_clear_error (&error);
g_free (string);
g_key_file_free (key_file);
g_strfreev (pieces);
g_strfreev (groups);
g_strfreev (keys);
return FALSE;
}
if (state->minimum)
{
if (g_variant_compare (value, state->minimum) < 0 ||
g_variant_compare (value, state->maximum) > 0)
{
g_variant_unref (value);
g_free (string);
if (!strict)
{
fprintf (stderr,
_("Override for key “%s” in schema “%s” in "
"override file “%s” is outside the range "
"given in the schema; ignoring override "
"for this key."),
key, group, filename);
fprintf (stderr, "\n");
continue;
}
fprintf (stderr,
_("Override for key “%s” in schema “%s” in "
"override file “%s” is outside the range "
"given in the schema and --strict was "
"specified; exiting."),
key, group, filename);
fprintf (stderr, "\n");
g_key_file_free (key_file);
g_strfreev (pieces);
g_strfreev (groups);
g_strfreev (keys);
return FALSE;
}
}
else if (state->strinfo->len)
{
if (!is_valid_choices (value, state->strinfo))
{
g_variant_unref (value);
g_free (string);
if (!strict)
{
fprintf (stderr,
_("Override for key “%s” in schema “%s” in "
"override file “%s” is not in the list "
"of valid choices; ignoring override for "
"this key."),
key, group, filename);
fprintf (stderr, "\n");
continue;
}
fprintf (stderr,
_("Override for key “%s” in schema “%s” in "
"override file “%s” is not in the list "
"of valid choices and --strict was specified; "
"exiting."),
key, group, filename);
fprintf (stderr, "\n");
g_key_file_free (key_file);
g_strfreev (pieces);
g_strfreev (groups);
g_strfreev (keys);
return FALSE;
}
}
if (desktop_id != NULL)
{
if (state->desktop_overrides == NULL)
state->desktop_overrides = g_variant_dict_new (NULL);
g_variant_dict_insert_value (state->desktop_overrides, desktop_id, value);
g_variant_unref (value);
}
else
{
g_variant_unref (state->default_value);
state->default_value = value;
}
g_free (string);
}
g_strfreev (pieces);
g_strfreev (keys);
}
g_strfreev (groups);
g_key_file_free (key_file);
}
return TRUE;
}
int
main (int argc, char **argv)
{
GError *error = NULL;
GHashTable *table = NULL;
GDir *dir = NULL;
const gchar *file;
const gchar *srcdir;
gboolean show_version_and_exit = FALSE;
gchar *targetdir = NULL;
gchar *target = NULL;
gboolean dry_run = FALSE;
gboolean strict = FALSE;
gchar **schema_files = NULL;
gchar **override_files = NULL;
GOptionContext *context = NULL;
gint retval;
GOptionEntry entries[] = {
{ "version", 0, 0, G_OPTION_ARG_NONE, &show_version_and_exit, N_("Show program version and exit"), NULL },
{ "targetdir", 0, 0, G_OPTION_ARG_FILENAME, &targetdir, N_("Where to store the gschemas.compiled file"), N_("DIRECTORY") },
{ "strict", 0, 0, G_OPTION_ARG_NONE, &strict, N_("Abort on any errors in schemas"), NULL },
{ "dry-run", 0, 0, G_OPTION_ARG_NONE, &dry_run, N_("Do not write the gschema.compiled file"), NULL },
{ "allow-any-name", 0, 0, G_OPTION_ARG_NONE, &allow_any_name, N_("Do not enforce key name restrictions"), NULL },
/* These options are only for use in the gschema-compile tests */
{ "schema-file", 0, G_OPTION_FLAG_HIDDEN, G_OPTION_ARG_FILENAME_ARRAY, &schema_files, NULL, NULL },
{ "override-file", 0, G_OPTION_FLAG_HIDDEN, G_OPTION_ARG_FILENAME_ARRAY, &override_files, NULL, NULL },
G_OPTION_ENTRY_NULL
};
#ifdef G_OS_WIN32
gchar *tmp = NULL;
gchar **command_line = NULL;
#endif
setlocale (LC_ALL, GLIB_DEFAULT_LOCALE);
textdomain (GETTEXT_PACKAGE);
#ifdef G_OS_WIN32
tmp = _glib_get_locale_dir ();
bindtextdomain (GETTEXT_PACKAGE, tmp);
#else
bindtextdomain (GETTEXT_PACKAGE, GLIB_LOCALE_DIR);
#endif
#ifdef HAVE_BIND_TEXTDOMAIN_CODESET
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
#endif
context = g_option_context_new (N_("DIRECTORY"));
g_option_context_set_translation_domain (context, GETTEXT_PACKAGE);
g_option_context_set_summary (context,
N_("Compile all GSettings schema files into a schema cache.\n"
"Schema files are required to have the extension .gschema.xml,\n"
"and the cache file is called gschemas.compiled."));
g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE);
#ifdef G_OS_WIN32
command_line = g_win32_get_command_line ();
if (!g_option_context_parse_strv (context, &command_line, &error))
{
fprintf (stderr, "%s\n", error->message);
retval = 1;
goto done;
}
argc = g_strv_length (command_line);
#else
if (!g_option_context_parse (context, &argc, &argv, &error))
{
fprintf (stderr, "%s\n", error->message);
retval = 1;
goto done;
}
#endif
if (show_version_and_exit)
{
g_print (PACKAGE_VERSION "\n");
retval = 0;
goto done;
}
if (!schema_files && argc != 2)
{
fprintf (stderr, "%s\n", _("You should give exactly one directory name"));
retval = 1;
goto done;
}
#ifdef G_OS_WIN32
srcdir = command_line[1];
#else
srcdir = argv[1];
#endif
target = g_build_filename (targetdir ? targetdir : srcdir, "gschemas.compiled", NULL);
if (!schema_files)
{
GPtrArray *overrides;
GPtrArray *files;
files = g_ptr_array_new ();
overrides = g_ptr_array_new ();
dir = g_dir_open (srcdir, 0, &error);
if (dir == NULL)
{
fprintf (stderr, "%s\n", error->message);
g_ptr_array_unref (files);
g_ptr_array_unref (overrides);
retval = 1;
goto done;
}
while ((file = g_dir_read_name (dir)) != NULL)
{
if (g_str_has_suffix (file, ".gschema.xml") ||
g_str_has_suffix (file, ".enums.xml"))
g_ptr_array_add (files, g_build_filename (srcdir, file, NULL));
else if (g_str_has_suffix (file, ".gschema.override"))
g_ptr_array_add (overrides,
g_build_filename (srcdir, file, NULL));
}
if (files->len == 0)
{
if (g_unlink (target))
fprintf (stdout, "%s\n", _("No schema files found: doing nothing."));
else
fprintf (stdout, "%s\n", _("No schema files found: removed existing output file."));
g_ptr_array_unref (files);
g_ptr_array_unref (overrides);
retval = 0;
goto done;
}
g_ptr_array_sort_values (files, compare_strings);
g_ptr_array_add (files, NULL);
g_ptr_array_sort_values (overrides, compare_strings);
g_ptr_array_add (overrides, NULL);
schema_files = (char **) g_ptr_array_free (files, FALSE);
override_files = (gchar **) g_ptr_array_free (overrides, FALSE);
}
if ((table = parse_gschema_files (schema_files, strict)) == NULL)
{
retval = 1;
goto done;
}
if (override_files != NULL &&
!set_overrides (table, override_files, strict))
{
retval = 1;
goto done;
}
if (!dry_run && !write_to_file (table, target, &error))
{
fprintf (stderr, "%s\n", error->message);
retval = 1;
goto done;
}
/* Success. */
retval = 0;
done:
g_clear_error (&error);
g_clear_pointer (&table, g_hash_table_unref);
g_clear_pointer (&dir, g_dir_close);
g_free (targetdir);
g_free (target);
g_strfreev (schema_files);
g_strfreev (override_files);
g_option_context_free (context);
#ifdef G_OS_WIN32
g_free (tmp);
g_strfreev (command_line);
#endif
return retval;
}
/* Epilogue {{{1 */
/* vim:set foldmethod=marker: */