2 * Copyright © 2010 Codethink Limited
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the licence, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the
16 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17 * Boston, MA 02111-1307, USA.
19 * Author: Ryan Lortie <desrt@desrt.ca>
34 #include "gvdb/gvdb-builder.h"
37 /* Handling of <enum> {{{1 */
46 enum_state_free (gpointer data)
48 EnumState *state = data;
50 g_string_free (state->strinfo, TRUE);
51 g_slice_free (EnumState, state);
55 enum_state_new (gboolean is_flags)
59 state = g_slice_new (EnumState);
60 state->strinfo = g_string_new (NULL);
61 state->is_flags = is_flags;
67 enum_state_add_value (EnumState *state,
69 const gchar *valuestr,
75 if (nick[0] == '\0' || nick[1] == '\0')
77 g_set_error (error, G_MARKUP_ERROR,
78 G_MARKUP_ERROR_INVALID_CONTENT,
79 "nick must be a minimum of 2 characters");
83 value = g_ascii_strtoll (valuestr, &end, 0);
84 if (*end || state->is_flags ?
85 (value > G_MAXUINT32 || value < 0) :
86 (value > G_MAXINT32 || value < G_MININT32))
88 g_set_error (error, G_MARKUP_ERROR,
89 G_MARKUP_ERROR_INVALID_CONTENT,
90 "invalid numeric value");
94 if (strinfo_builder_contains (state->strinfo, nick))
96 g_set_error (error, G_MARKUP_ERROR,
97 G_MARKUP_ERROR_INVALID_CONTENT,
98 "<value nick='%s'/> already specified", nick);
102 if (strinfo_builder_contains_value (state->strinfo, value))
104 g_set_error (error, G_MARKUP_ERROR,
105 G_MARKUP_ERROR_INVALID_CONTENT,
106 "value='%s' already specified", valuestr);
110 if (state->is_flags && (value & (value - 1)))
112 g_set_error (error, G_MARKUP_ERROR,
113 G_MARKUP_ERROR_INVALID_CONTENT,
114 "flags values must have at most 1 bit set");
118 /* Since we reject exact duplicates of value='' and we only allow one
119 * bit to be set, it's not possible to have overlaps.
121 * If we loosen the one-bit-set restriction we need an overlap check.
125 strinfo_builder_append_item (state->strinfo, nick, value);
129 enum_state_end (EnumState **state_ptr,
137 if (state->strinfo->len == 0)
138 g_set_error_literal (error,
139 G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
140 "<enum> must contain at least one <value>");
143 /* Handling of <key> {{{1 */
146 /* for <child>, @child_schema will be set.
147 * for <key>, everything else will be set.
153 gboolean have_gettext_domain;
157 GString *unparsed_default_value;
158 GVariant *default_value;
167 gboolean has_choices;
168 gboolean has_aliases;
169 gboolean is_override;
172 GVariant *serialised;
176 key_state_new (const gchar *type_string,
177 const gchar *gettext_domain,
184 state = g_slice_new0 (KeyState);
185 state->type = g_variant_type_new (type_string);
186 state->have_gettext_domain = gettext_domain != NULL;
187 state->is_enum = is_enum;
188 state->is_flags = is_flags;
191 state->strinfo = g_string_new_len (strinfo->str, strinfo->len);
193 state->strinfo = g_string_new (NULL);
199 key_state_override (KeyState *state,
200 const gchar *gettext_domain)
204 copy = g_slice_new0 (KeyState);
205 copy->type = g_variant_type_copy (state->type);
206 copy->have_gettext_domain = gettext_domain != NULL;
207 copy->strinfo = g_string_new_len (state->strinfo->str,
208 state->strinfo->len);
209 copy->is_enum = state->is_enum;
210 copy->is_flags = state->is_flags;
211 copy->is_override = TRUE;
215 copy->minimum = g_variant_ref (state->minimum);
216 copy->maximum = g_variant_ref (state->maximum);
223 key_state_new_child (const gchar *child_schema)
227 state = g_slice_new0 (KeyState);
228 state->child_schema = g_strdup (child_schema);
234 is_valid_choices (GVariant *variant,
237 switch (g_variant_classify (variant))
239 case G_VARIANT_CLASS_MAYBE:
240 case G_VARIANT_CLASS_ARRAY:
242 gboolean valid = TRUE;
245 g_variant_iter_init (&iter, variant);
247 while (valid && (variant = g_variant_iter_next_value (&iter)))
249 valid = is_valid_choices (variant, strinfo);
250 g_variant_unref (variant);
256 case G_VARIANT_CLASS_STRING:
257 return strinfo_is_string_valid ((const guint32 *) strinfo->str,
259 g_variant_get_string (variant, NULL));
262 g_assert_not_reached ();
267 /* Gets called at </default> </choices> or <range/> to check for
268 * validity of the default value so that any inconsistency is
269 * reported as soon as it is encountered.
272 key_state_check_range (KeyState *state,
275 if (state->default_value)
279 tag = state->is_override ? "override" : "default";
283 if (g_variant_compare (state->default_value, state->minimum) < 0 ||
284 g_variant_compare (state->default_value, state->maximum) > 0)
286 g_set_error (error, G_MARKUP_ERROR,
287 G_MARKUP_ERROR_INVALID_CONTENT,
288 "<%s> is not contained in "
289 "the specified range", tag);
293 else if (state->strinfo->len)
295 if (!is_valid_choices (state->default_value, state->strinfo))
298 g_set_error (error, G_MARKUP_ERROR,
299 G_MARKUP_ERROR_INVALID_CONTENT,
300 "<%s> is not a valid member of "
301 "the specified enumerated type", tag);
303 else if (state->is_flags)
304 g_set_error (error, G_MARKUP_ERROR,
305 G_MARKUP_ERROR_INVALID_CONTENT,
306 "<%s> contains string not in the "
307 "specified flags type", tag);
310 g_set_error (error, G_MARKUP_ERROR,
311 G_MARKUP_ERROR_INVALID_CONTENT,
312 "<%s> contains string not in "
320 key_state_set_range (KeyState *state,
321 const gchar *min_str,
322 const gchar *max_str,
327 g_set_error_literal (error, G_MARKUP_ERROR,
328 G_MARKUP_ERROR_INVALID_CONTENT,
329 "<range/> already specified for this key");
333 if (strchr ("ynqiuxtd", *(char *) state->type) == NULL)
335 gchar *type = g_variant_type_dup_string (state->type);
336 g_set_error (error, G_MARKUP_ERROR,
337 G_MARKUP_ERROR_INVALID_CONTENT,
338 "<range> not allowed for keys of type '%s'", type);
343 state->minimum = g_variant_parse (state->type, min_str, NULL, NULL, error);
344 if (state->minimum == NULL)
347 state->maximum = g_variant_parse (state->type, max_str, NULL, NULL, error);
348 if (state->maximum == NULL)
351 if (g_variant_compare (state->minimum, state->maximum) > 0)
353 g_set_error (error, G_MARKUP_ERROR,
354 G_MARKUP_ERROR_INVALID_CONTENT,
355 "<range> specified minimum is greater than maxmimum");
359 key_state_check_range (state, error);
363 key_state_start_default (KeyState *state,
365 const gchar *context,
370 if (strcmp (l10n, "messages") == 0)
373 else if (strcmp (l10n, "time") == 0)
378 g_set_error (error, G_MARKUP_ERROR,
379 G_MARKUP_ERROR_INVALID_CONTENT,
380 "unsupported l10n category: %s", l10n);
384 if (!state->have_gettext_domain)
386 g_set_error_literal (error, G_MARKUP_ERROR,
387 G_MARKUP_ERROR_INVALID_CONTENT,
388 "l10n requested, but no "
389 "gettext domain given");
393 state->l10n_context = g_strdup (context);
396 else if (context != NULL)
398 g_set_error_literal (error, G_MARKUP_ERROR,
399 G_MARKUP_ERROR_INVALID_CONTENT,
400 "translation context given for "
401 " value without l10n enabled");
405 return g_string_new (NULL);
409 key_state_end_default (KeyState *state,
413 state->unparsed_default_value = *string;
416 state->default_value = g_variant_parse (state->type,
417 state->unparsed_default_value->str,
419 key_state_check_range (state, error);
423 key_state_start_choices (KeyState *state,
426 const GVariantType *type = state->type;
430 g_set_error_literal (error, G_MARKUP_ERROR,
431 G_MARKUP_ERROR_INVALID_CONTENT,
432 "<choices> can not be specified for keys "
433 "tagged as having an enumerated type");
437 if (state->has_choices)
439 g_set_error_literal (error, G_MARKUP_ERROR,
440 G_MARKUP_ERROR_INVALID_CONTENT,
441 "<choices> already specified for this key");
445 while (g_variant_type_is_maybe (type) || g_variant_type_is_array (type))
446 type = g_variant_type_element (type);
448 if (!g_variant_type_equal (type, G_VARIANT_TYPE_STRING))
450 gchar *type_string = g_variant_type_dup_string (state->type);
451 g_set_error (error, G_MARKUP_ERROR,
452 G_MARKUP_ERROR_INVALID_CONTENT,
453 "<choices> not allowed for keys of type '%s'",
455 g_free (type_string);
461 key_state_add_choice (KeyState *state,
465 if (strinfo_builder_contains (state->strinfo, choice))
467 g_set_error (error, G_MARKUP_ERROR,
468 G_MARKUP_ERROR_INVALID_CONTENT,
469 "<choice value='%s'/> already given", choice);
473 strinfo_builder_append_item (state->strinfo, choice, 0);
474 state->has_choices = TRUE;
478 key_state_end_choices (KeyState *state,
481 if (!state->has_choices)
483 g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
484 "<choices> must contain at least one <choice>");
488 key_state_check_range (state, error);
492 key_state_start_aliases (KeyState *state,
495 if (state->has_aliases)
496 g_set_error_literal (error, G_MARKUP_ERROR,
497 G_MARKUP_ERROR_INVALID_CONTENT,
498 "<aliases> already specified for this key");
500 if (!state->is_flags && !state->is_enum && !state->has_choices)
501 g_set_error_literal (error, G_MARKUP_ERROR,
502 G_MARKUP_ERROR_INVALID_CONTENT,
503 "<aliases> can only be specified for keys with "
504 "enumerated or flags types or after <choices>");
508 key_state_add_alias (KeyState *state,
513 if (strinfo_builder_contains (state->strinfo, alias))
515 if (strinfo_is_string_valid ((guint32 *) state->strinfo->str,
516 state->strinfo->len / 4,
520 g_set_error (error, G_MARKUP_ERROR,
521 G_MARKUP_ERROR_INVALID_CONTENT,
522 "<alias value='%s'/> given when '%s' is already "
523 "a member of the enumerated type", alias, alias);
526 g_set_error (error, G_MARKUP_ERROR,
527 G_MARKUP_ERROR_INVALID_CONTENT,
528 "<alias value='%s'/> given when "
529 "<choice value='%s'/> was already given",
534 g_set_error (error, G_MARKUP_ERROR,
535 G_MARKUP_ERROR_INVALID_CONTENT,
536 "<alias value='%s'/> already specified", alias);
541 if (!strinfo_builder_append_alias (state->strinfo, alias, target))
543 g_set_error (error, G_MARKUP_ERROR,
544 G_MARKUP_ERROR_INVALID_CONTENT,
545 "alias target '%s' is not in %s", target,
546 state->is_enum ? "enumerated type" : "<choices>");
550 state->has_aliases = TRUE;
554 key_state_end_aliases (KeyState *state,
557 if (!state->has_aliases)
559 g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
560 "<aliases> must contain at least one <alias>");
566 key_state_check (KeyState *state,
572 return state->checked = TRUE;
576 key_state_serialise (KeyState *state)
578 if (state->serialised == NULL)
580 if (state->child_schema)
582 state->serialised = g_variant_new_string (state->child_schema);
587 GVariantBuilder builder;
589 g_assert (key_state_check (state, NULL));
591 g_variant_builder_init (&builder, G_VARIANT_TYPE_TUPLE);
594 g_variant_builder_add_value (&builder, state->default_value);
599 if (state->l10n_context)
603 /* Contextified messages are supported by prepending
604 * the context, followed by '\004' to the start of the
605 * message string. We do that here to save GSettings
608 len = strlen (state->l10n_context);
609 state->l10n_context[len] = '\004';
610 g_string_prepend_len (state->unparsed_default_value,
611 state->l10n_context, len + 1);
612 g_free (state->l10n_context);
613 state->l10n_context = NULL;
616 g_variant_builder_add (&builder, "(y(y&s))", 'l', state->l10n,
617 state->unparsed_default_value);
618 g_string_free (state->unparsed_default_value, TRUE);
619 state->unparsed_default_value = NULL;
622 /* choice, aliases, enums */
623 if (state->strinfo->len)
629 data = state->strinfo->str;
630 size = state->strinfo->len;
632 array = g_variant_new_from_data (G_VARIANT_TYPE ("au"),
636 g_string_free (state->strinfo, FALSE);
637 state->strinfo = NULL;
639 g_variant_builder_add (&builder, "(y@au)",
640 state->is_flags ? 'f' :
641 state->is_enum ? 'e' : 'c',
646 if (state->minimum || state->maximum)
647 g_variant_builder_add (&builder, "(y(**))", 'r',
648 state->minimum, state->maximum);
650 state->serialised = g_variant_builder_end (&builder);
653 g_variant_ref_sink (state->serialised);
656 return g_variant_ref (state->serialised);
660 key_state_free (gpointer data)
662 KeyState *state = data;
665 g_variant_type_free (state->type);
667 g_free (state->l10n_context);
669 if (state->unparsed_default_value)
670 g_string_free (state->unparsed_default_value, TRUE);
672 if (state->default_value)
673 g_variant_unref (state->default_value);
676 g_string_free (state->strinfo, TRUE);
679 g_variant_unref (state->minimum);
682 g_variant_unref (state->maximum);
684 if (state->serialised)
685 g_variant_unref (state->serialised);
687 g_slice_free (KeyState, state);
690 /* Key name validity {{{1 */
691 static gboolean allow_any_name = FALSE;
694 is_valid_keyname (const gchar *key,
701 g_set_error_literal (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
702 "empty names are not permitted");
709 if (!g_ascii_islower (key[0]))
711 g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
712 "invalid name '%s': names must begin "
713 "with a lowercase letter", key);
717 for (i = 1; key[i]; i++)
720 !g_ascii_islower (key[i]) &&
721 !g_ascii_isdigit (key[i]))
723 g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
724 "invalid name '%s': invalid character '%c'; "
725 "only lowercase letters, numbers and dash ('-') "
726 "are permitted.", key, key[i]);
730 if (key[i] == '-' && key[i + 1] == '-')
732 g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
733 "invalid name '%s': two successive dashes ('--') are "
734 "not permitted.", key);
739 if (key[i - 1] == '-')
741 g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
742 "invalid name '%s': the last character may not be a "
749 g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
750 "invalid name '%s': maximum length is 32", key);
757 /* Handling of <schema> {{{1 */
758 typedef struct _SchemaState SchemaState;
761 SchemaState *extends;
764 gchar *gettext_domain;
772 schema_state_new (const gchar *path,
773 const gchar *gettext_domain,
774 SchemaState *extends,
775 const gchar *extends_name,
776 const gchar *list_of)
780 state = g_slice_new (SchemaState);
781 state->path = g_strdup (path);
782 state->gettext_domain = g_strdup (gettext_domain);
783 state->extends = extends;
784 state->extends_name = g_strdup (extends_name);
785 state->list_of = g_strdup (list_of);
786 state->keys = g_hash_table_new_full (g_str_hash, g_str_equal,
787 g_free, key_state_free);
793 schema_state_free (gpointer data)
795 SchemaState *state = data;
797 g_free (state->path);
798 g_free (state->gettext_domain);
799 g_hash_table_unref (state->keys);
803 schema_state_add_child (SchemaState *state,
810 if (!is_valid_keyname (name, error))
813 childname = g_strconcat (name, "/", NULL);
815 if (g_hash_table_lookup (state->keys, childname))
817 g_set_error (error, G_MARKUP_ERROR,
818 G_MARKUP_ERROR_INVALID_CONTENT,
819 "<child name='%s'> already specified", name);
823 g_hash_table_insert (state->keys, childname,
824 key_state_new_child (schema));
828 schema_state_add_key (SchemaState *state,
829 GHashTable *enum_table,
830 GHashTable *flags_table,
832 const gchar *type_string,
833 const gchar *enum_type,
834 const gchar *flags_type,
843 g_set_error_literal (error, G_MARKUP_ERROR,
844 G_MARKUP_ERROR_INVALID_CONTENT,
845 "can not add keys to a list-of schema");
849 if (!is_valid_keyname (name, error))
852 if (g_hash_table_lookup (state->keys, name))
854 g_set_error (error, G_MARKUP_ERROR,
855 G_MARKUP_ERROR_INVALID_CONTENT,
856 "<key name='%s'> already specified", name);
860 for (node = state; node; node = node->extends)
865 shadow = g_hash_table_lookup (node->extends->keys, name);
867 /* in case of <key> <override> <key> make sure we report the
868 * location of the original <key>, not the <override>.
870 if (shadow && !shadow->is_override)
872 g_set_error (error, G_MARKUP_ERROR,
873 G_MARKUP_ERROR_INVALID_CONTENT,
874 "<key name='%s'> shadows <key name='%s'> in "
875 "<schema id='%s'>; use <override> to modify value",
876 name, name, node->extends_name);
881 if ((type_string != NULL) + (enum_type != NULL) + (flags_type != NULL) != 1)
883 g_set_error (error, G_MARKUP_ERROR,
884 G_MARKUP_ERROR_MISSING_ATTRIBUTE,
885 "exactly one of 'type', 'enum' or 'flags' must "
886 "be specified as an attribute to <key>");
890 if (type_string == NULL) /* flags or enums was specified */
892 EnumState *enum_state;
895 enum_state = g_hash_table_lookup (enum_table, enum_type);
897 enum_state = g_hash_table_lookup (flags_table, flags_type);
900 if (enum_state == NULL)
902 g_set_error (error, G_MARKUP_ERROR,
903 G_MARKUP_ERROR_INVALID_CONTENT,
904 "<%s id='%s'> not (yet) defined.",
905 flags_type ? "flags" : "enum",
906 flags_type ? flags_type : enum_type);
910 type_string = flags_type ? "as" : "s";
911 strinfo = enum_state->strinfo;
915 if (!g_variant_type_string_is_valid (type_string))
917 g_set_error (error, G_MARKUP_ERROR,
918 G_MARKUP_ERROR_INVALID_CONTENT,
919 "invalid GVariant type string '%s'", type_string);
926 key = key_state_new (type_string, state->gettext_domain,
927 enum_type != NULL, flags_type != NULL, strinfo);
928 g_hash_table_insert (state->keys, g_strdup (name), key);
934 schema_state_add_override (SchemaState *state,
935 KeyState **key_state,
939 const gchar *context,
945 if (state->extends == NULL)
947 g_set_error_literal (error, G_MARKUP_ERROR,
948 G_MARKUP_ERROR_INVALID_CONTENT,
949 "<override> given but schema isn't "
950 "extending anything");
954 for (parent = state->extends; parent; parent = parent->extends)
955 if ((original = g_hash_table_lookup (parent->keys, key)))
958 if (original == NULL)
960 g_set_error (error, G_MARKUP_ERROR,
961 G_MARKUP_ERROR_INVALID_CONTENT,
962 "no <key name='%s'> to override", key);
966 if (g_hash_table_lookup (state->keys, key))
968 g_set_error (error, G_MARKUP_ERROR,
969 G_MARKUP_ERROR_INVALID_CONTENT,
970 "<override name='%s'> already specified", key);
974 *key_state = key_state_override (original, state->gettext_domain);
975 *string = key_state_start_default (*key_state, l10n, context, error);
976 g_hash_table_insert (state->keys, g_strdup (key), *key_state);
980 override_state_end (KeyState **key_state,
984 key_state_end_default (*key_state, string, error);
988 /* Handling of toplevel state {{{1 */
991 GHashTable *schema_table; /* string -> SchemaState */
992 GHashTable *flags_table; /* string -> EnumState */
993 GHashTable *enum_table; /* string -> EnumState */
995 gchar *schemalist_domain; /* the <schemalist> gettext domain */
997 SchemaState *schema_state; /* non-NULL when inside <schema> */
998 KeyState *key_state; /* non-NULL when inside <key> */
999 EnumState *enum_state; /* non-NULL when inside <enum> */
1001 GString *string; /* non-NULL when accepting text */
1005 is_subclass (const gchar *class_name,
1006 const gchar *possible_parent,
1007 GHashTable *schema_table)
1011 if (strcmp (class_name, possible_parent) == 0)
1014 class = g_hash_table_lookup (schema_table, class_name);
1015 g_assert (class != NULL);
1017 return class->extends_name &&
1018 is_subclass (class->extends_name, possible_parent, schema_table);
1022 parse_state_start_schema (ParseState *state,
1025 const gchar *gettext_domain,
1026 const gchar *extends_name,
1027 const gchar *list_of,
1030 SchemaState *extends;
1032 if (g_hash_table_lookup (state->schema_table, id))
1034 g_set_error (error, G_MARKUP_ERROR,
1035 G_MARKUP_ERROR_INVALID_CONTENT,
1036 "<schema id='%s'> already specified", id);
1042 extends = g_hash_table_lookup (state->schema_table, extends_name);
1044 if (extends == NULL)
1046 g_set_error (error, G_MARKUP_ERROR,
1047 G_MARKUP_ERROR_INVALID_CONTENT,
1048 "<schema id='%s'> extends not yet "
1049 "existing schema '%s'", id, extends_name);
1058 if (!g_hash_table_lookup (state->schema_table, list_of))
1060 g_set_error (error, G_MARKUP_ERROR,
1061 G_MARKUP_ERROR_INVALID_CONTENT,
1062 "<schema id='%s'> is list of not yet "
1063 "existing schema '%s'", id, list_of);
1072 if (extends->list_of == NULL)
1074 g_set_error (error, G_MARKUP_ERROR,
1075 G_MARKUP_ERROR_INVALID_CONTENT,
1076 "<schema id='%s'> is a list, extending "
1077 "<schema id='%s'> which is not a list",
1082 if (!is_subclass (list_of, extends->list_of, state->schema_table))
1084 g_set_error (error, G_MARKUP_ERROR,
1085 G_MARKUP_ERROR_INVALID_CONTENT,
1086 "<schema id='%s' list-of='%s'> extends <schema "
1087 "id='%s' list-of='%s'> but '%s' does not extend '%s'",
1088 id, list_of, extends_name, extends->list_of,
1089 list_of, extends->list_of);
1094 /* by default we are a list of the same thing that the schema
1095 * we are extending is a list of (which might be nothing)
1097 list_of = extends->list_of;
1100 if (path && !(g_str_has_prefix (path, "/") && g_str_has_suffix (path, "/")))
1102 g_set_error (error, G_MARKUP_ERROR,
1103 G_MARKUP_ERROR_INVALID_CONTENT,
1104 "a path, if given, must begin and "
1105 "end with a slash");
1109 state->schema_state = schema_state_new (path, gettext_domain,
1110 extends, extends_name, list_of);
1111 g_hash_table_insert (state->schema_table, g_strdup (id),
1112 state->schema_state);
1116 parse_state_start_enum (ParseState *state,
1121 GHashTable *table = is_flags ? state->flags_table : state->enum_table;
1123 if (g_hash_table_lookup (table, id))
1125 g_set_error (error, G_MARKUP_ERROR,
1126 G_MARKUP_ERROR_INVALID_CONTENT,
1127 "<%s id='%s'> already specified",
1128 is_flags ? "flags" : "enum", id);
1132 state->enum_state = enum_state_new (is_flags);
1133 g_hash_table_insert (table, g_strdup (id), state->enum_state);
1136 /* GMarkup Parser Functions {{{1 */
1138 /* Start element {{{2 */
1140 start_element (GMarkupParseContext *context,
1141 const gchar *element_name,
1142 const gchar **attribute_names,
1143 const gchar **attribute_values,
1147 ParseState *state = user_data;
1148 const GSList *element_stack;
1149 const gchar *container;
1151 element_stack = g_markup_parse_context_get_element_stack (context);
1152 container = element_stack->next ? element_stack->next->data : NULL;
1154 #define COLLECT(first, ...) \
1155 g_markup_collect_attributes (element_name, \
1156 attribute_names, attribute_values, error, \
1157 first, __VA_ARGS__, G_MARKUP_COLLECT_INVALID)
1158 #define OPTIONAL G_MARKUP_COLLECT_OPTIONAL
1159 #define STRDUP G_MARKUP_COLLECT_STRDUP
1160 #define STRING G_MARKUP_COLLECT_STRING
1161 #define NO_ATTRS() COLLECT (G_MARKUP_COLLECT_INVALID, NULL)
1163 /* Toplevel items {{{3 */
1164 if (container == NULL)
1166 if (strcmp (element_name, "schemalist") == 0)
1168 COLLECT (OPTIONAL | STRDUP,
1170 &state->schemalist_domain);
1176 /* children of <schemalist> {{{3 */
1177 else if (strcmp (container, "schemalist") == 0)
1179 if (strcmp (element_name, "schema") == 0)
1181 const gchar *id, *path, *gettext_domain, *extends, *list_of;
1182 if (COLLECT (STRING, "id", &id,
1183 OPTIONAL | STRING, "path", &path,
1184 OPTIONAL | STRING, "gettext-domain", &gettext_domain,
1185 OPTIONAL | STRING, "extends", &extends,
1186 OPTIONAL | STRING, "list-of", &list_of))
1187 parse_state_start_schema (state, id, path, gettext_domain,
1188 extends, list_of, error);
1192 else if (strcmp (element_name, "enum") == 0)
1195 if (COLLECT (STRING, "id", &id))
1196 parse_state_start_enum (state, id, FALSE, error);
1200 else if (strcmp (element_name, "flags") == 0)
1203 if (COLLECT (STRING, "id", &id))
1204 parse_state_start_enum (state, id, TRUE, error);
1210 /* children of <schema> {{{3 */
1211 else if (strcmp (container, "schema") == 0)
1213 if (strcmp (element_name, "key") == 0)
1215 const gchar *name, *type_string, *enum_type, *flags_type;
1217 if (COLLECT (STRING, "name", &name,
1218 OPTIONAL | STRING, "type", &type_string,
1219 OPTIONAL | STRING, "enum", &enum_type,
1220 OPTIONAL | STRING, "flags", &flags_type))
1222 state->key_state = schema_state_add_key (state->schema_state,
1226 enum_type, flags_type,
1230 else if (strcmp (element_name, "child") == 0)
1232 const gchar *name, *schema;
1234 if (COLLECT (STRING, "name", &name, STRING, "schema", &schema))
1235 schema_state_add_child (state->schema_state,
1236 name, schema, error);
1239 else if (strcmp (element_name, "override") == 0)
1241 const gchar *name, *l10n, *context;
1243 if (COLLECT (STRING, "name", &name,
1244 OPTIONAL | STRING, "l10n", &l10n,
1245 OPTIONAL | STRING, "context", &context))
1246 schema_state_add_override (state->schema_state,
1247 &state->key_state, &state->string,
1248 name, l10n, context, error);
1253 /* children of <key> {{{3 */
1254 else if (strcmp (container, "key") == 0)
1256 if (strcmp (element_name, "default") == 0)
1258 const gchar *l10n, *context;
1259 if (COLLECT (STRING | OPTIONAL, "l10n", &l10n,
1260 STRING | OPTIONAL, "context", &context))
1261 state->string = key_state_start_default (state->key_state,
1262 l10n, context, error);
1266 else if (strcmp (element_name, "summary") == 0 ||
1267 strcmp (element_name, "description") == 0)
1270 state->string = g_string_new (NULL);
1274 else if (strcmp (element_name, "range") == 0)
1276 const gchar *min, *max;
1277 if (COLLECT (STRING, "min", &min, STRING, "max", &max))
1278 key_state_set_range (state->key_state, min, max, error);
1282 else if (strcmp (element_name, "choices") == 0)
1285 key_state_start_choices (state->key_state, error);
1289 else if (strcmp (element_name, "aliases") == 0)
1292 key_state_start_aliases (state->key_state, error);
1298 /* children of <choices> {{{3 */
1299 else if (strcmp (container, "choices") == 0)
1301 if (strcmp (element_name, "choice") == 0)
1304 if (COLLECT (STRING, "value", &value))
1305 key_state_add_choice (state->key_state, value, error);
1311 /* children of <aliases> {{{3 */
1312 else if (strcmp (container, "aliases") == 0)
1314 if (strcmp (element_name, "alias") == 0)
1316 const gchar *value, *target;
1317 if (COLLECT (STRING, "value", &value, STRING, "target", &target))
1318 key_state_add_alias (state->key_state, value, target, error);
1324 /* children of <enum> {{{3 */
1325 else if (strcmp (container, "enum") == 0 ||
1326 strcmp (container, "flags") == 0)
1328 if (strcmp (element_name, "value") == 0)
1330 const gchar *nick, *valuestr;
1331 if (COLLECT (STRING, "nick", &nick,
1332 STRING, "value", &valuestr))
1333 enum_state_add_value (state->enum_state, nick, valuestr, error);
1340 g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_UNKNOWN_ELEMENT,
1341 "Element <%s> not allowed inside <%s>",
1342 element_name, container);
1344 g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_UNKNOWN_ELEMENT,
1345 "Element <%s> not allowed at toplevel", element_name);
1348 /* End element {{{2 */
1351 key_state_end (KeyState **state_ptr,
1359 if (state->default_value == NULL)
1361 g_set_error_literal (error,
1362 G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
1363 "element <default> is required in <key>");
1369 schema_state_end (SchemaState **state_ptr,
1379 end_element (GMarkupParseContext *context,
1380 const gchar *element_name,
1384 ParseState *state = user_data;
1386 if (strcmp (element_name, "schemalist") == 0)
1388 g_free (state->schemalist_domain);
1389 state->schemalist_domain = NULL;
1392 else if (strcmp (element_name, "enum") == 0 ||
1393 strcmp (element_name, "flags") == 0)
1394 enum_state_end (&state->enum_state, error);
1396 else if (strcmp (element_name, "schema") == 0)
1397 schema_state_end (&state->schema_state, error);
1399 else if (strcmp (element_name, "override") == 0)
1400 override_state_end (&state->key_state, &state->string, error);
1402 else if (strcmp (element_name, "key") == 0)
1403 key_state_end (&state->key_state, error);
1405 else if (strcmp (element_name, "default") == 0)
1406 key_state_end_default (state->key_state, &state->string, error);
1408 else if (strcmp (element_name, "choices") == 0)
1409 key_state_end_choices (state->key_state, error);
1411 else if (strcmp (element_name, "aliases") == 0)
1412 key_state_end_aliases (state->key_state, error);
1416 g_string_free (state->string, TRUE);
1417 state->string = NULL;
1422 text (GMarkupParseContext *context,
1428 ParseState *state = user_data;
1431 for (i = 0; i < text_len; i++)
1432 if (!g_ascii_isspace (text[i]))
1435 g_string_append_len (state->string, text, text_len);
1438 g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
1439 "text may not appear inside <%s>",
1440 g_markup_parse_context_get_element (context));
1446 /* Write to GVDB {{{1 */
1454 gvdb_pair_init (GvdbPair *pair)
1456 pair->table = gvdb_hash_table_new (NULL, NULL);
1457 pair->root = gvdb_hash_table_insert (pair->table, "");
1467 output_key (gpointer key,
1471 OutputSchemaData *data;
1480 item = gvdb_hash_table_insert (data->pair.table, name);
1481 gvdb_item_set_parent (item, data->pair.root);
1482 gvdb_item_set_value (item, key_state_serialise (state));
1489 output_schema (gpointer key,
1493 OutputSchemaData data;
1494 GvdbPair *root_pair;
1501 root_pair = user_data;
1503 gvdb_pair_init (&data.pair);
1506 item = gvdb_hash_table_insert (root_pair->table, id);
1507 gvdb_item_set_parent (item, root_pair->root);
1508 gvdb_item_set_hash_table (item, data.pair.table);
1510 g_hash_table_foreach (state->keys, output_key, &data);
1513 gvdb_hash_table_insert_string (data.pair.table, ".path", state->path);
1515 if (state->extends_name)
1516 gvdb_hash_table_insert_string (data.pair.table, ".extends",
1517 state->extends_name);
1520 gvdb_hash_table_insert_string (data.pair.table, ".list-of",
1521 state->extends_name);
1524 gvdb_hash_table_insert_string (data.pair.table,
1526 state->gettext_domain);
1530 write_to_file (GHashTable *schema_table,
1531 const gchar *filename,
1537 gvdb_pair_init (&pair);
1539 g_hash_table_foreach (schema_table, output_schema, &pair);
1541 success = gvdb_table_write_contents (pair.table, filename,
1542 G_BYTE_ORDER != G_LITTLE_ENDIAN,
1544 g_hash_table_unref (pair.table);
1549 /* Parser driver {{{1 */
1551 parse_gschema_files (gchar **files,
1554 GMarkupParser parser = { start_element, end_element, text };
1555 ParseState state = { 0, };
1556 const gchar *filename;
1558 state.enum_table = g_hash_table_new_full (g_str_hash, g_str_equal,
1559 g_free, enum_state_free);
1561 state.flags_table = g_hash_table_new_full (g_str_hash, g_str_equal,
1562 g_free, enum_state_free);
1564 state.schema_table = g_hash_table_new_full (g_str_hash, g_str_equal,
1565 g_free, schema_state_free);
1567 while ((filename = *files++) != NULL)
1569 GMarkupParseContext *context;
1573 context = g_markup_parse_context_new (&parser,
1574 G_MARKUP_PREFIX_ERROR_POSITION,
1577 if (!g_file_get_contents (filename, &contents, &size, error))
1580 if (!g_markup_parse_context_parse (context, contents, size, error))
1582 g_prefix_error (error, "%s: ", filename);
1586 if (!g_markup_parse_context_end_parse (context, error))
1588 g_prefix_error (error, "%s: ", filename);
1592 g_markup_parse_context_free (context);
1595 g_hash_table_unref (state.enum_table);
1597 return state.schema_table;
1601 compare_strings (gconstpointer a,
1604 gchar *one = *(gchar **) a;
1605 gchar *two = *(gchar **) b;
1608 cmp = g_str_has_suffix (two, ".enums.xml") -
1609 g_str_has_suffix (one, ".enums.xml");
1612 cmp = strcmp (one, two);
1618 main (int argc, char **argv)
1625 gchar *targetdir = NULL;
1627 gboolean uninstall = FALSE;
1628 gboolean dry_run = FALSE;
1629 gchar **schema_files = NULL;
1630 GOptionContext *context;
1631 GOptionEntry entries[] = {
1632 { "targetdir", 0, 0, G_OPTION_ARG_FILENAME, &targetdir, N_("where to store the gschemas.compiled file"), N_("DIRECTORY") },
1633 { "dry-run", 0, 0, G_OPTION_ARG_NONE, &dry_run, N_("Do not write the gschema.compiled file"), NULL },
1634 { "uninstall", 0, 0, G_OPTION_ARG_NONE, &uninstall, N_("This option will be removed soon.") },
1635 { "allow-any-name", 0, 0, G_OPTION_ARG_NONE, &allow_any_name, N_("Do not enforce key name restrictions") },
1637 /* These options are only for use in the gschema-compile tests */
1638 { "schema-file", 0, G_OPTION_FLAG_HIDDEN, G_OPTION_ARG_FILENAME_ARRAY, &schema_files, NULL, NULL },
1642 setlocale (LC_ALL, "");
1644 context = g_option_context_new (N_("DIRECTORY"));
1645 g_option_context_set_translation_domain (context, GETTEXT_PACKAGE);
1646 g_option_context_set_summary (context,
1647 N_("Compile all GSettings schema files into a schema cache.\n"
1648 "Schema files are required to have the extension .gschema.xml,\n"
1649 "and the cache file is called gschemas.compiled."));
1650 g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE);
1653 if (!g_option_context_parse (context, &argc, &argv, &error))
1655 fprintf (stderr, "%s", error->message);
1659 g_option_context_free (context);
1661 if (!schema_files && argc != 2)
1663 fprintf (stderr, _("You should give exactly one directory name\n"));
1669 if (targetdir == NULL)
1672 target = g_build_filename (targetdir, "gschemas.compiled", NULL);
1678 files = g_ptr_array_new ();
1680 dir = g_dir_open (srcdir, 0, &error);
1683 fprintf (stderr, "%s\n", error->message);
1687 while ((file = g_dir_read_name (dir)) != NULL)
1689 if (g_str_has_suffix (file, ".gschema.xml") ||
1690 g_str_has_suffix (file, ".enums.xml"))
1691 g_ptr_array_add (files, g_build_filename (srcdir, file, NULL));
1694 if (files->len == 0)
1696 fprintf (stderr, _("No schema files found: "));
1698 if (g_unlink (target))
1699 fprintf (stderr, _("doing nothing.\n"));
1702 fprintf (stderr, _("removed existing output file.\n"));
1706 g_ptr_array_sort (files, compare_strings);
1707 g_ptr_array_add (files, NULL);
1709 schema_files = (char **) g_ptr_array_free (files, FALSE);
1713 if (!(table = parse_gschema_files (schema_files, &error)) ||
1714 (!dry_run && !write_to_file (table, target, &error)))
1716 fprintf (stderr, "%s\n", error->message);
1727 /* vim:set foldmethod=marker: */