luc14n0/glib
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/glib.git synced 2025-09-06 16:08:43 +02:00
Code Issues Packages Projects Releases Wiki Activity
Files
wip/gmarkupreader
glib/gio/new-compiler.c
Ryan Lortie 404fbcbfc7 new GSettings compiler WIP 
Here is a WIP of the new GSettings compiler based on GMarkupReader.
2014-07-28 11:18:14 +02:00

1238 lines
36 KiB
C
Raw Permalink Blame History

/*
* Copyright © 2010 Codethink Limited
* Copyright © 2013 Canonical 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>
*/
#define _(x)(x)
#include <gio/gio.h>
#include "gvdb/gvdb-builder.h"
#include "strinfo.c"
/* Forward declarations {{{1 */
typedef struct _FileRef FileRef;
typedef struct _Enum Enum;
typedef struct _Schema Schema;
typedef struct _Override Override;
typedef struct _Key Key;
typedef struct _Dir Dir;
static Schema * dir_resolve_schema (Dir *dir,
const gchar *id,
const gchar *detail,
const gchar *purpose,
const gchar *caller,
GError **error);
static Enum * dir_resolve_enum (Dir *dir,
const gchar *id,
gboolean is_flags,
const gchar *for_key,
const gchar *of_schema,
GError **error);
static Enum * schema_resolve_enum (Schema *schema,
const gchar *id,
gboolean is_flags,
const gchar *for_key,
GError **error);
static gboolean dir_add_enum (Dir *dir,
GMarkupReader *reader,
const gchar *id,
Enum *enum_,
GError **error);
static gboolean dir_add_schema (Dir *dir,
GMarkupReader *reader,
const gchar *id,
Schema *schema,
GError **error);
static gboolean schema_add_key (Schema *schema,
GMarkupReader *reader,
const gchar *name,
Key *key,
GError **error);
/* <enum> and <flags> {{{1 */
struct _Enum
{
Dir *dir;
gchar *id;
gboolean is_flags;
GString *strinfo;
};
static void
enum_free (gpointer data)
{
Enum *enum_ = data;
g_string_free (enum_->strinfo, TRUE);
g_free (enum_->id);
g_slice_free (Enum, enum_);
}
static gboolean
enum_parse_value (GMarkupReader *reader,
GCancellable *cancellable,
Enum *enum_,
GError **error)
{
const gchar *nick, *valuestr;
gint64 value;
gchar *end;
if (!g_markup_reader_collect_attributes (reader, error,
G_MARKUP_COLLECT_STRING, "nick", &nick,
G_MARKUP_COLLECT_STRING, "value", &valuestr,
G_MARKUP_COLLECT_INVALID))
return FALSE;
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 FALSE;
}
value = g_ascii_strtoll (valuestr, &end, 0);
if (*end || enum_->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 FALSE;
}
if (strinfo_builder_contains (enum_->strinfo, nick))
{
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
"<value nick='%s'/> already specified", nick);
return FALSE;
}
if (strinfo_builder_contains_value (enum_->strinfo, value))
{
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT, "value='%s' already specified", valuestr);
return FALSE;
}
/* Silently drop the null case if it is mentioned.
* It is properly denoted with an empty array.
*/
if (enum_->is_flags && value == 0)
return TRUE;
if (enum_->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 FALSE;
}
/* 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 (enum_->strinfo, nick, value);
return g_markup_reader_expect_end (reader, NULL, error);
}
static gboolean
enum_parse (GMarkupReader *reader,
GCancellable *cancellable,
Dir *dir,
GError **error)
{
Enum *enum_;
enum_ = g_slice_new0 (Enum);
enum_->is_flags = g_markup_reader_is_start_element (reader, "flags");
enum_->strinfo = g_string_new (NULL);
g_assert (enum_->is_flags || g_markup_reader_is_start_element (reader, "enum"));
if (!g_markup_reader_collect_attributes (reader, error,
G_MARKUP_COLLECT_STRDUP, "id", &enum_->id,
G_MARKUP_COLLECT_INVALID))
goto error;
if (!g_markup_reader_collect_elements (reader, cancellable, enum_, error, "value", enum_parse_value, NULL))
goto error;
if (!dir_add_enum (dir, reader, enum_->id, enum_, error))
goto error;
return TRUE;
error:
enum_free (enum_);
return FALSE;
}
/* <key> {{{1 */
struct _Key
{
Schema *schema;
const gchar *name;
gchar *type_string;
GVariantType *type;
gchar *enum_name;
Enum *enum_;
gchar *flags_name;
Enum *flags;
gchar l10n;
gchar *l10n_context;
gchar *default_text;
GVariant *default_value;
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;
};
static void
key_free (gpointer data)
{
Key *key = data;
g_slice_free (Key, key);
}
static gboolean
key_resolve (Key *key,
GError **error)
{
if (key->enum_name)
{
key->enum_ = schema_resolve_enum (key->schema, key->enum_name, FALSE, key->name, error);
if (key->enum_ == NULL)
return FALSE;
}
if (key->flags_name)
{
key->flags = schema_resolve_enum (key->schema, key->flags_name, TRUE, key->name, error);
if (key->flags == NULL)
return FALSE;
}
return TRUE;
}
static gboolean
key_parse_default (GMarkupReader *reader,
GCancellable *cancellable,
Key *key,
GError **error)
{
if (key->default_value)
{
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT, "<default/> must be specified exactly once");
return FALSE;
}
if (!g_markup_reader_collect_attributes (reader, error,
G_MARKUP_COLLECT_STRDUP | G_MARKUP_COLLECT_OPTIONAL,
"l10n", &key->l10n,
G_MARKUP_COLLECT_STRDUP | G_MARKUP_COLLECT_OPTIONAL,
"context", &key->l10n_context,
G_MARKUP_COLLECT_INVALID))
return FALSE;
key->default_text = g_markup_reader_collect_text (reader, cancellable, error);
return key->default_text != NULL;
}
static gboolean
key_parse_range (GMarkupReader *reader,
GCancellable *cancellable,
Key *key,
GError **error)
{
const gchar *min_str, *max_str;
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;
gint i;
if (!g_markup_reader_collect_attributes (reader, error,
G_MARKUP_COLLECT_STRING | G_MARKUP_COLLECT_OPTIONAL, "min", &min_str,
G_MARKUP_COLLECT_STRING | G_MARKUP_COLLECT_OPTIONAL, "max", &max_str,
G_MARKUP_COLLECT_INVALID))
return FALSE;
if (key->minimum)
{
g_set_error_literal (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
"<range/> already specified for this key");
return FALSE;
}
for (i = 0; i < G_N_ELEMENTS (table); i++)
if (*(char *) key->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)
{
g_set_error (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_INVALID_CONTENT,
"<range> not allowed for keys of type '%s'", key->type_string);
return FALSE;
}
key->minimum = g_variant_parse (key->type, min_str, NULL, NULL, error);
if (key->minimum == NULL)
return FALSE;
key->maximum = g_variant_parse (key->type, max_str, NULL, NULL, error);
if (key->maximum == NULL)
return FALSE;
if (g_variant_compare (key->minimum, key->maximum) > 0)
{
g_set_error (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_INVALID_CONTENT,
"<range> specified minimum is greater than maxmimum");
return FALSE;
}
return g_markup_reader_expect_end (reader, cancellable, error);
}
static gboolean
key_parse_choice (GMarkupReader *reader,
GCancellable *cancellable,
Key *key,
GError **error)
{
const gchar *value;
if (!g_markup_reader_collect_attributes (reader, error,
G_MARKUP_COLLECT_STRING, "value", &value,
G_MARKUP_COLLECT_INVALID))
return FALSE;
if (strinfo_builder_contains (key->strinfo, value))
{
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
"<choice value='%s'/> already given", value);
return FALSE;
}
strinfo_builder_append_item (key->strinfo, value, 0);
key->has_choices = TRUE;
return g_markup_reader_expect_end (reader, cancellable, error);
}
static gboolean
key_parse_choices (GMarkupReader *reader,
GCancellable *cancellable,
Key *key,
GError **error)
{
if (!g_markup_reader_collect_attributes (reader, error, G_MARKUP_COLLECT_INVALID, NULL))
return FALSE;
if (!key->type_string || (!g_str_equal (key->type_string, "s") &&
!g_str_equal (key->type_string, "as") &&
!g_str_equal (key->type_string, "ms")))
{
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
"<choices> only allowed for keys with type 's', 'as' or 'ms'");
return FALSE;
}
key->strinfo = g_string_new (NULL);
if (!g_markup_reader_collect_elements (reader, cancellable, key, error, "choice", key_parse_choice, NULL))
return FALSE;
if (!key->has_choices)
{
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
"<choices> must contain at least one <choice>");
return FALSE;
}
return TRUE;
}
static gboolean
key_parse_aliases (GMarkupReader *reader,
GCancellable *cancellable,
Key *key,
GError **error)
{
return TRUE;
}
static gboolean
ignore_text (GMarkupReader *reader,
GCancellable *cancellable,
gpointer user_data,
GError **error)
{
while (g_markup_reader_advance (reader, cancellable, error) && g_markup_reader_is_text (reader))
;
if (g_markup_reader_is_end_element (reader))
return TRUE;
g_markup_reader_unexpected (reader, error);
return FALSE;
}
static gboolean
key_parse (GMarkupReader *reader,
GCancellable *cancellable,
Schema *schema,
GError **error)
{
Key *key;
g_assert (g_markup_reader_is_start_element (reader, "key"));
key = g_slice_new0 (Key);
key->schema = schema;
if (!g_markup_reader_collect_attributes (reader, error,
G_MARKUP_COLLECT_STRDUP,
"name", &key->name,
G_MARKUP_COLLECT_STRDUP | G_MARKUP_COLLECT_OPTIONAL,
"type", &key->type_string,
G_MARKUP_COLLECT_STRDUP | G_MARKUP_COLLECT_OPTIONAL,
"enum", &key->enum_name,
G_MARKUP_COLLECT_STRDUP | G_MARKUP_COLLECT_OPTIONAL,
"flags", &key->flags_name,
G_MARKUP_COLLECT_INVALID))
goto error;
if ((key->type_string != NULL) + (key->enum_name != NULL) + (key->flags_name != 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 FALSE;
}
if (key->type_string)
{
if (!g_variant_type_string_is_valid (key->type_string))
{
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
_("invalid GVariant type string '%s'"), key->type_string);
return FALSE;
}
key->type = g_variant_type_new (key->type_string);
}
else if (key->enum_name)
key->type = g_variant_type_copy (G_VARIANT_TYPE_STRING);
else /* flags */
key->type = g_variant_type_copy (G_VARIANT_TYPE_STRING_ARRAY);
if (!g_markup_reader_collect_elements (reader, cancellable, key, error,
"summary", ignore_text,
"description", ignore_text,
"default", key_parse_default,
"range", key_parse_range,
"choices", key_parse_choices,
"aliases", key_parse_aliases,
NULL))
goto error;
if (!schema_add_key (schema, reader, key->name, key, error))
goto error;
return TRUE;
error:
return FALSE;
}
/* <schema> {{{1 */
struct _Override
{
Schema *schema;
gchar *name;
gchar *text;
gchar *context;
gchar *l10n;
};
static void
override_free (gpointer data)
{
Override *override = data;
g_free (override->name);
g_free (override->text);
g_free (override->context);
g_free (override->l10n);
g_slice_free (Override, override);
}
struct _Schema
{
Dir *dir;
gchar *id;
gboolean has_translated;
gboolean resolved;
gchar *gettext_domain;
gchar *path;
const gchar *extends_name;
Schema *extends;
const gchar *list_of_name;
Schema *list_of;
GHashTable *children_names;
GHashTable *children;
GHashTable *keys;
GHashTable *overrides;
};
static void
schema_free (gpointer data)
{
Schema *schema = data;
g_slice_free (Schema, schema);
}
static gboolean
schema_resolve (Schema *schema,
GError **error)
{
static GSList *now_resolving; /* we don't unwind this properly in case of error */
GSList me = { schema };
if (schema->resolved)
return TRUE;
if (g_slist_find (now_resolving, schema))
{
GSList *node;
GString *str;
/* We have a reference cycle. */
str = g_string_new ("Reference cycle detected: '%s'");
for (node = now_resolving; node; node = node->next)
{
Schema *s = node->data;
g_string_append_printf (str, "<- '%s'", s->id);
/* Stop once we get back to ourselves. */
if (s == schema)
break;
}
g_set_error_literal (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, str->str);
g_string_free (str, TRUE);
return FALSE;
}
me.next = now_resolving;
now_resolving = &me;
if (schema->extends_name)
{
schema->extends = dir_resolve_schema (schema->dir, schema->extends_name,
"extends", "reference", schema->id,
error);
if (!schema->extends)
return FALSE;
}
if (schema->list_of_name)
{
schema->list_of = dir_resolve_schema (schema->dir, schema->list_of_name,
"list-of", "reference", schema->id,
error);
if (!schema->list_of)
return FALSE;
}
if (schema->children_names)
{
GHashTableIter iter;
gpointer name, id;
schema->children = g_hash_table_new (g_str_hash, g_str_equal);
g_hash_table_iter_init (&iter, schema->children_names);
while (g_hash_table_iter_next (&iter, &name, &id))
{
Schema *child;
child = dir_resolve_schema (schema->dir, id,
name, "child", schema->id,
error);
if (!child)
return FALSE;
g_hash_table_insert (schema->children, name, child);
}
}
if (schema->keys)
{
GHashTableIter iter;
gpointer key;
g_hash_table_iter_init (&iter, schema->keys);
while (g_hash_table_iter_next (&iter, NULL, &key))
if (!key_resolve (key, error))
return FALSE;
}
now_resolving = me.next;
return TRUE;
}
static Enum *
schema_resolve_enum (Schema *schema,
const gchar *id,
gboolean is_flags,
const gchar *for_key,
GError **error)
{
return dir_resolve_enum (schema->dir, id, is_flags, for_key, schema->id, error);
}
static gboolean
schema_add_key (Schema *schema,
GMarkupReader *reader,
const gchar *name,
Key *key,
GError **error)
{
if (g_hash_table_contains (schema->keys, name))
{
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
"<key name='%s'/> already defined in <schema id='%s'/>", name, schema->id);
return FALSE;
}
g_hash_table_insert (schema->keys, g_strdup (name), key);
return TRUE;
}
static gboolean
schema_parse_child (GMarkupReader *reader,
GCancellable *cancellable,
Schema *schema,
GError **error)
{
const gchar *name, *schema_id;
if (!g_markup_reader_collect_attributes (reader, error,
G_MARKUP_COLLECT_STRING, "name", &name,
G_MARKUP_COLLECT_STRING, "schema", &schema_id,
G_MARKUP_COLLECT_INVALID))
return FALSE;
if (g_hash_table_contains (schema->children_names, name))
{
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
"<child name='%s'/> appears twice in <schema id='%s'/>",
name, schema->id);
return FALSE;
}
g_hash_table_insert (schema->children_names, g_strdup (name), g_strdup (schema_id));
if (!g_markup_reader_expect_end (reader, cancellable, error))
return FALSE;
return TRUE;
}
static gboolean
schema_parse_override (GMarkupReader *reader,
GCancellable *cancellable,
Schema *schema,
GError **error)
{
Override *override;
override = g_slice_new0 (Override);
override->schema = schema;
if (!g_markup_reader_collect_attributes (reader, error,
G_MARKUP_COLLECT_STRING, "name", &override->name,
G_MARKUP_COLLECT_STRING, "l10n", &override->l10n,
G_MARKUP_COLLECT_STRING, "context", &override->context,
G_MARKUP_COLLECT_INVALID))
goto error;
if (schema->overrides == NULL)
{
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
"<override name='%s'/> appears within <schema id='%s'/> that is not extending another",
override->name, schema->id);
goto error;
}
if (g_hash_table_contains (schema->overrides, override->name))
{
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
"<override name='%s'/> appears twice in <schema id='%s'/>", override->name, schema->id);
return FALSE;
}
override->text = g_markup_reader_collect_text (reader, cancellable, error);
if (!override->text)
goto error;
g_hash_table_insert (schema->overrides, g_strdup (override->name), override);
return TRUE;
error:
override_free (override);
return FALSE;
}
static gboolean
schema_parse (GMarkupReader *reader,
GCancellable *cancellable,
Dir *dir,
GError **error)
{
Schema *schema;
g_assert (g_markup_reader_is_start_element (reader, "schema"));
schema = g_slice_new0 (Schema);
schema->dir = dir;
schema->keys = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, key_free);
schema->children_names = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
if (!g_markup_reader_collect_attributes (reader, error,
G_MARKUP_COLLECT_STRDUP,
"id", &schema->id,
G_MARKUP_COLLECT_STRDUP | G_MARKUP_COLLECT_OPTIONAL,
"path", &schema->path,
G_MARKUP_COLLECT_STRDUP | G_MARKUP_COLLECT_OPTIONAL,
"gettext-domain", &schema->gettext_domain,
G_MARKUP_COLLECT_STRDUP | G_MARKUP_COLLECT_OPTIONAL,
"extends", &schema->extends_name,
G_MARKUP_COLLECT_STRDUP | G_MARKUP_COLLECT_OPTIONAL,
"list-of", &schema->list_of_name,
G_MARKUP_COLLECT_INVALID))
goto error;
if (schema->extends_name)
schema->overrides = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, override_free);
if (!g_markup_reader_collect_elements (reader, cancellable, schema, error,
"key", key_parse,
"child", schema_parse_child,
"override", schema_parse_override,
NULL))
goto error;
if (!dir_add_schema (dir, reader, schema->id, schema, error))
goto error;
return TRUE;
error:
return FALSE;
}
/* Directory handling {{{1 */
struct _Dir
{
Dir *parent_dir;
const gchar *path;
GHashTable *excludes;
gboolean parsed;
/* temporarily set while parsing <schemalist> */
gchar *gettext_domain;
GHashTable *schemas;
GHashTable *enums;
};
static gboolean
dir_add_enum (Dir *dir,
GMarkupReader *reader,
const gchar *id,
Enum *enum_,
GError **error)
{
if (g_hash_table_contains (dir->enums, id))
{
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
"<enum id='%s'/> or <flags id='%s'/> already defined in directory %s",
id, id, dir->path);
return FALSE;
}
g_hash_table_insert (dir->enums, g_strdup (id), enum_);
return TRUE;
}
static gboolean
dir_add_schema (Dir *dir,
GMarkupReader *reader,
const gchar *id,
Schema *schema,
GError **error)
{
if (g_hash_table_contains (dir->schemas, id))
{
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
"<schema id='%s'/> already defined in directory %s", id, dir->path);
return FALSE;
}
g_hash_table_insert (dir->schemas, g_strdup (id), schema);
return TRUE;
}
static gboolean
dir_parse_schemalist (GMarkupReader *reader,
GCancellable *cancellable,
Dir *dir,
GError **error)
{
gboolean ok;
if (!g_markup_reader_collect_attributes (reader, error,
G_MARKUP_COLLECT_STRDUP | G_MARKUP_COLLECT_OPTIONAL,
"gettext-domain", &dir->gettext_domain,
G_MARKUP_COLLECT_INVALID))
return FALSE;
ok = g_markup_reader_collect_elements (reader, cancellable, dir, error,
"schema", schema_parse, "enum", enum_parse, "flags", enum_parse, NULL);
g_free (dir->gettext_domain);
dir->gettext_domain = NULL;
return ok;
}
static gboolean
dir_parse_one_file (Dir *dir,
const gchar *filename,
GCancellable *cancellable,
GError **error)
{
GFileInputStream *stream;
GMarkupReader *reader;
GFile *file;
gboolean ok;
file = g_file_new_for_path (filename);
stream = g_file_read (file, cancellable, error);
g_object_unref (file);
if (!stream)
return FALSE;
reader = g_markup_reader_new (G_INPUT_STREAM (stream),
G_MARKUP_PREFIX_ERROR_POSITION |
G_MARKUP_TREAT_CDATA_AS_TEXT |
G_MARKUP_IGNORE_QUALIFIED |
G_MARKUP_IGNORE_PASSTHROUGH);
g_object_unref (stream);
ok = g_markup_reader_collect_elements (reader, cancellable, dir, error, "schemalist", dir_parse_schemalist, NULL);
g_object_unref (reader);
if (!ok)
g_prefix_error (error, "%s: ", filename);
return ok;
}
static Dir *compile_dir;
static gboolean
dir_parse (Dir *dir,
GCancellable *cancellable,
GError **error)
{
GError *local_error = NULL;
gboolean ok = TRUE;
const gchar *name;
GDir *dirp;
g_assert (!dir->parsed);
dirp = g_dir_open (dir->path, 0, &local_error);
dir->schemas = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, schema_free);
dir->enums = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, enum_free);
if (!dirp)
{
/* If we get a G_FILE_ERROR_NOENT then ignore it, unless it was
* for the toplevel directory (ie: the one we were asked to
* compile).
*/
if (g_error_matches (local_error, G_FILE_ERROR, G_FILE_ERROR_NOENT) && dir != compile_dir)
{
g_error_free (local_error);
return TRUE;
}
g_propagate_error (error, local_error);
return FALSE;
}
while (ok && (name = g_dir_read_name (dirp)))
{
gchar *fullname;
if (!g_str_has_suffix (name, ".xml"))
continue;
if (dir->excludes && g_hash_table_contains (dir->excludes, name))
continue;
fullname = g_build_filename (dir->path, name, NULL);
ok = dir_parse_one_file (dir, fullname, cancellable, error);
g_free (fullname);
}
g_dir_close (dirp);
dir->parsed = ok;
return ok;
}
static Dir *
dir_new (const gchar *path,
Dir *parent_dir)
{
Dir *dir;
dir = g_slice_new0 (Dir);
dir->path = path;
dir->parent_dir = parent_dir;
return dir;
}
static void
setup_compile_dir (const gchar *directory,
const gchar * const *excluded)
{
const gchar * const * system_dirs;
gint i, n;
/* If we are compiling a system directory we want to include all of
* the directories that come before it.
*
* If we are compiling a non-system directory then we want to include
* all of the system directories before it.
*
* For example, of XDG_DATA_DIRS=/a:/b:/c then:
*
* - for building /a, we want a path of /a, /b, /c
*
* - for building /b, we want a path of /b, /c
*
* - for building /c, we want a path of /c
*
* - for building /x we want a path of /x, /a, /b, /c
*/
system_dirs = g_get_system_data_dirs ();
n = g_strv_length ((gchar **) system_dirs);
/* We're building a linked list -- start at the end */
for (i = n - 1; i >= 0; i--)
{
/* If we see our own directory then stop -- we don't want any more
* system dirs. We will deal with our directory below.
*/
if (g_str_equal (system_dirs[i], directory))
break;
compile_dir = dir_new (system_dirs[i], compile_dir);
}
compile_dir = dir_new (directory, compile_dir);
}
Schema *
dir_resolve_schema (Dir *dir,
const gchar *id,
const gchar *detail,
const gchar *purpose,
const gchar *caller,
GError **error)
{
Schema *schema = NULL;
Dir *d;
g_assert (dir);
for (d = dir; d; d = d->parent_dir)
{
if (!dir->parsed)
if (!dir_parse (dir, NULL, error))
return FALSE;
schema = g_hash_table_lookup (dir->schemas, id);
if (schema)
break;
}
if (!schema)
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
"Unable to locate schema '%s' needed for '%s' %s of %s",
id, detail, purpose, caller);
return NULL;
}
if (!schema_resolve (schema, error))
return NULL;
return schema;
}
Enum *
dir_resolve_enum (Dir *dir,
const gchar *id,
gboolean is_flags,
const gchar *for_key,
const gchar *of_schema,
GError **error)
{
Enum *enum_ = NULL;
Dir *d;
g_assert (dir);
for (d = dir; d; d = d->parent_dir)
{
if (!dir->parsed)
if (!dir_parse (dir, NULL, error))
return FALSE;
enum_ = g_hash_table_lookup (dir->enums, id);
if (enum_)
break;
}
if (!enum_ || enum_->is_flags != is_flags)
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
"Unable to locate <%s id='%s'/> needed for key '%s' of schema '%s'",
is_flags ? "flags" : "enum", id, for_key, of_schema);
return NULL;
}
return enum_;
}
static gboolean
dir_resolve (Dir *dir,
GError **error)
{
GHashTableIter iter;
gpointer schema;
if (!dir_parse (dir, NULL, error))
return FALSE;
g_hash_table_iter_init (&iter, dir->schemas);
while (g_hash_table_iter_next (&iter, NULL, &schema))
if (!schema_resolve (schema, error))
return FALSE;
return TRUE;
}
static GVariant *
key_compile (Key *key,
GError **error)
{
GVariantBuilder builder;
g_variant_builder_init (&builder, G_VARIANT_TYPE_TUPLE);
return g_variant_builder_end (&builder);
}
static GHashTable *
schema_compile (Schema *schema,
GError **error)
{
GHashTable *compiled_schema;
GvdbItem *root_item;
GHashTableIter iter;
gpointer key, name;
gpointer id;
compiled_schema = gvdb_hash_table_new (NULL, NULL);
root_item = gvdb_hash_table_insert (compiled_schema, "");
if (schema->path)
gvdb_hash_table_insert_string (compiled_schema, ".path", schema->path);
if (schema->list_of)
gvdb_hash_table_insert_string (compiled_schema, ".list-of", schema->list_of_name);
if (schema->extends)
gvdb_hash_table_insert_string (compiled_schema, ".extends", schema->extends_name);
/* Only store the gettext domain if a key was actually translated */
if (schema->has_translated)
gvdb_hash_table_insert_string (compiled_schema, ".gettext-domain", schema->gettext_domain);
g_hash_table_iter_init (&iter, schema->keys);
while (g_hash_table_iter_next (&iter, &name, &key))
{
GVariant *compiled_key;
GvdbItem *key_item;
compiled_key = key_compile (key, error);
if (!compiled_key)
goto error;
key_item = gvdb_hash_table_insert (compiled_schema, name);
gvdb_item_set_parent (key_item, root_item);
gvdb_item_set_value (key_item, compiled_key);
}
g_hash_table_iter_init (&iter, schema->children);
while (g_hash_table_iter_next (&iter, &name, &id))
{
GvdbItem *child_item;
child_item = gvdb_hash_table_insert (compiled_schema, name);
gvdb_item_set_parent (child_item, root_item);
gvdb_item_set_value (child_item, g_variant_new_string (id));
}
return compiled_schema;
error:
g_assert_not_reached ();
}
static GHashTable *
dir_compile (Dir *dir,
GError **error)
{
GHashTable *compiled_dir;
GvdbItem *root_item;
GHashTableIter iter;
gpointer schema, id;
compiled_dir = gvdb_hash_table_new (NULL, NULL);
root_item = gvdb_hash_table_insert (compiled_dir, "");
g_hash_table_iter_init (&iter, dir->schemas);
while (g_hash_table_iter_next (&iter, &id, &schema))
{
GHashTable *compiled_schema;
GvdbItem *schema_item;
compiled_schema = schema_compile (schema, error);
if (!compiled_schema)
goto error;
schema_item = gvdb_hash_table_insert (compiled_dir, id);
gvdb_item_set_parent (schema_item, root_item);
gvdb_item_set_hash_table (schema_item, compiled_schema);
}
return compiled_dir;
error:
g_assert_not_reached ();
}
int
main (void)
{
GError *error = NULL;
setup_compile_dir ("/home/desrt/.cache/jhbuild/install/share/glib-2.0/schemas", NULL);
if (!dir_resolve (compile_dir, &error))
g_printerr ("%s\n", error->message);
return error ? 1 : 0;
}
/* Epilogue {{{1 */
/* vim:set foldmethod=marker: */
Reference in New Issue View Git Blame Copy Permalink