gio/glib-compile-schemas.c

   1 /*
   2  * Copyright © 2010 Codethink Limited
   3  *
   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.1 of the License, or (at your option) any later version.
   8  *
   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.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  16  *
  17  * Author: Ryan Lortie <desrt@desrt.ca>
  18  */
  19
  20 /* Prologue {{{1 */
  21 #include "config.h"
  22
  23 #include <gstdio.h>
  24 #include <gi18n.h>
  25
  26 #include <string.h>
  27 #include <stdio.h>
  28 #include <locale.h>
  29
  30 #include "gvdb/gvdb-builder.h"
  31 #include "strinfo.c"
  32
  33 #ifdef G_OS_WIN32
  34 #include "glib/glib-private.h"
  35 #endif
  36
  37 static void
  38 strip_string (GString *string)
  39 {
  40   gint i;
  41
  42   for (i = 0; g_ascii_isspace (string->str[i]); i++);
  43   g_string_erase (string, 0, i);
  44
  45   if (string->len > 0)
  46     {
  47       /* len > 0, so there must be at least one non-whitespace character */
  48       for (i = string->len - 1; g_ascii_isspace (string->str[i]); i--);
  49       g_string_truncate (string, i + 1);
  50     }
  51 }
  52
  53 /* Handling of <enum> {{{1 */
  54 typedef struct
  55 {
  56   GString *strinfo;
  57
  58   gboolean is_flags;
  59 } EnumState;
  60
  61 static void
  62 enum_state_free (gpointer data)
  63 {
  64   EnumState *state = data;
  65
  66   g_string_free (state->strinfo, TRUE);
  67   g_slice_free (EnumState, state);
  68 }
  69
  70 static EnumState *
  71 enum_state_new (gboolean is_flags)
  72 {
  73   EnumState *state;
  74
  75   state = g_slice_new (EnumState);
  76   state->strinfo = g_string_new (NULL);
  77   state->is_flags = is_flags;
  78
  79   return state;
  80 }
  81
  82 static void
  83 enum_state_add_value (EnumState    *state,
  84                       const gchar  *nick,
  85                       const gchar  *valuestr,
  86                       GError      **error)
  87 {
  88   gint64 value;
  89   gchar *end;
  90
  91   if (nick[0] == '\0' || nick[1] == '\0')
  92     {
  93       g_set_error (error, G_MARKUP_ERROR,
  94                    G_MARKUP_ERROR_INVALID_CONTENT,
  95                    "nick must be a minimum of 2 characters");
  96       return;
  97     }
  98
  99   value = g_ascii_strtoll (valuestr, &end, 0);
 100   if (*end || state->is_flags ?
 101                 (value > G_MAXUINT32 || value < 0) :
 102                 (value > G_MAXINT32 || value < G_MININT32))
 103     {
 104       g_set_error (error, G_MARKUP_ERROR,
 105                    G_MARKUP_ERROR_INVALID_CONTENT,
 106                    "invalid numeric value");
 107       return;
 108     }
 109
 110   if (strinfo_builder_contains (state->strinfo, nick))
 111     {
 112       g_set_error (error, G_MARKUP_ERROR,
 113                    G_MARKUP_ERROR_INVALID_CONTENT,
 114                    "<value nick='%s'/> already specified", nick);
 115       return;
 116     }
 117
 118   if (strinfo_builder_contains_value (state->strinfo, value))
 119     {
 120       g_set_error (error, G_MARKUP_ERROR,
 121                    G_MARKUP_ERROR_INVALID_CONTENT,
 122                    "value='%s' already specified", valuestr);
 123       return;
 124     }
 125
 126   /* Silently drop the null case if it is mentioned.
 127    * It is properly denoted with an empty array.
 128    */
 129   if (state->is_flags && value == 0)
 130     return;
 131
 132   if (state->is_flags && (value & (value - 1)))
 133     {
 134       g_set_error (error, G_MARKUP_ERROR,
 135                    G_MARKUP_ERROR_INVALID_CONTENT,
 136                    "flags values must have at most 1 bit set");
 137       return;
 138     }
 139
 140   /* Since we reject exact duplicates of value='' and we only allow one
 141    * bit to be set, it's not possible to have overlaps.
 142    *
 143    * If we loosen the one-bit-set restriction we need an overlap check.
 144    */
 145
 146   strinfo_builder_append_item (state->strinfo, nick, value);
 147 }
 148
 149 static void
 150 enum_state_end (EnumState **state_ptr,
 151                 GError    **error)
 152 {
 153   EnumState *state;
 154
 155   state = *state_ptr;
 156   *state_ptr = NULL;
 157
 158   if (state->strinfo->len == 0)
 159     g_set_error (error,
 160                  G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
 161                  "<%s> must contain at least one <value>",
 162                  state->is_flags ? "flags" : "enum");
 163 }
 164
 165 /* Handling of <key> {{{1 */
 166 typedef struct
 167 {
 168   /* for <child>, @child_schema will be set.
 169    * for <key>, everything else will be set.
 170    */
 171   gchar        *child_schema;
 172
 173
 174   GVariantType *type;
 175   gboolean      have_gettext_domain;
 176
 177   gchar         l10n;
 178   gchar        *l10n_context;
 179   GString      *unparsed_default_value;
 180   GVariant     *default_value;
 181
 182   GString      *strinfo;
 183   gboolean      is_enum;
 184   gboolean      is_flags;
 185
 186   GVariant     *minimum;
 187   GVariant     *maximum;
 188
 189   gboolean      has_choices;
 190   gboolean      has_aliases;
 191   gboolean      is_override;
 192
 193   gboolean      checked;
 194   GVariant     *serialised;
 195
 196   gboolean      summary_seen;
 197   gboolean      description_seen;
 198 } KeyState;
 199
 200 static KeyState *
 201 key_state_new (const gchar *type_string,
 202                const gchar *gettext_domain,
 203                gboolean     is_enum,
 204                gboolean     is_flags,
 205                GString     *strinfo)
 206 {
 207   KeyState *state;
 208
 209   state = g_slice_new0 (KeyState);
 210   state->type = g_variant_type_new (type_string);
 211   state->have_gettext_domain = gettext_domain != NULL;
 212   state->is_enum = is_enum;
 213   state->is_flags = is_flags;
 214   state->summary_seen = FALSE;
 215   state->description_seen = FALSE;
 216
 217   if (strinfo)
 218     state->strinfo = g_string_new_len (strinfo->str, strinfo->len);
 219   else
 220     state->strinfo = g_string_new (NULL);
 221
 222   return state;
 223 }
 224
 225 static KeyState *
 226 key_state_override (KeyState    *state,
 227                     const gchar *gettext_domain)
 228 {
 229   KeyState *copy;
 230
 231   copy = g_slice_new0 (KeyState);
 232   copy->type = g_variant_type_copy (state->type);
 233   copy->have_gettext_domain = gettext_domain != NULL;
 234   copy->strinfo = g_string_new_len (state->strinfo->str,
 235                                     state->strinfo->len);
 236   copy->is_enum = state->is_enum;
 237   copy->is_flags = state->is_flags;
 238   copy->is_override = TRUE;
 239
 240   if (state->minimum)
 241     {
 242       copy->minimum = g_variant_ref (state->minimum);
 243       copy->maximum = g_variant_ref (state->maximum);
 244     }
 245
 246   return copy;
 247 }
 248
 249 static KeyState *
 250 key_state_new_child (const gchar *child_schema)
 251 {
 252   KeyState *state;
 253
 254   state = g_slice_new0 (KeyState);
 255   state->child_schema = g_strdup (child_schema);
 256
 257   return state;
 258 }
 259
 260 static gboolean
 261 is_valid_choices (GVariant *variant,
 262                   GString  *strinfo)
 263 {
 264   switch (g_variant_classify (variant))
 265     {
 266       case G_VARIANT_CLASS_MAYBE:
 267       case G_VARIANT_CLASS_ARRAY:
 268         {
 269           gboolean valid = TRUE;
 270           GVariantIter iter;
 271
 272           g_variant_iter_init (&iter, variant);
 273
 274           while (valid && (variant = g_variant_iter_next_value (&iter)))
 275             {
 276               valid = is_valid_choices (variant, strinfo);
 277               g_variant_unref (variant);
 278             }
 279
 280           return valid;
 281         }
 282
 283       case G_VARIANT_CLASS_STRING:
 284         return strinfo_is_string_valid ((const guint32 *) strinfo->str,
 285                                         strinfo->len / 4,
 286                                         g_variant_get_string (variant, NULL));
 287
 288       default:
 289         g_assert_not_reached ();
 290     }
 291 }
 292
 293
 294 /* Gets called at </default> </choices> or <range/> to check for
 295  * validity of the default value so that any inconsistency is
 296  * reported as soon as it is encountered.
 297  */
 298 static void
 299 key_state_check_range (KeyState  *state,
 300                        GError   **error)
 301 {
 302   if (state->default_value)
 303     {
 304       const gchar *tag;
 305
 306       tag = state->is_override ? "override" : "default";
 307
 308       if (state->minimum)
 309         {
 310           if (g_variant_compare (state->default_value, state->minimum) < 0 ||
 311               g_variant_compare (state->default_value, state->maximum) > 0)
 312             {
 313               g_set_error (error, G_MARKUP_ERROR,
 314                            G_MARKUP_ERROR_INVALID_CONTENT,
 315                            "<%s> is not contained in "
 316                            "the specified range", tag);
 317             }
 318         }
 319
 320       else if (state->strinfo->len)
 321         {
 322           if (!is_valid_choices (state->default_value, state->strinfo))
 323             {
 324               if (state->is_enum)
 325                 g_set_error (error, G_MARKUP_ERROR,
 326                              G_MARKUP_ERROR_INVALID_CONTENT,
 327                              "<%s> is not a valid member of "
 328                              "the specified enumerated type", tag);
 329
 330               else if (state->is_flags)
 331                 g_set_error (error, G_MARKUP_ERROR,
 332                              G_MARKUP_ERROR_INVALID_CONTENT,
 333                              "<%s> contains string not in the "
 334                              "specified flags type", tag);
 335
 336               else
 337                 g_set_error (error, G_MARKUP_ERROR,
 338                              G_MARKUP_ERROR_INVALID_CONTENT,
 339                              "<%s> contains string not in "
 340                              "<choices>", tag);
 341             }
 342         }
 343     }
 344 }
 345
 346 static void
 347 key_state_set_range (KeyState     *state,
 348                      const gchar  *min_str,
 349                      const gchar  *max_str,
 350                      GError      **error)
 351 {
 352   const struct {
 353     const gchar  type;
 354     const gchar *min;
 355     const gchar *max;
 356   } table[] = {
 357     { 'y',                    "0",                  "255" },
 358     { 'n',               "-32768",                "32767" },
 359     { 'q',                    "0",                "65535" },
 360     { 'i',          "-2147483648",           "2147483647" },
 361     { 'u',                    "0",           "4294967295" },
 362     { 'x', "-9223372036854775808",  "9223372036854775807" },
 363     { 't',                    "0", "18446744073709551615" },
 364     { 'd',                 "-inf",                  "inf" },
 365   };
 366   gboolean type_ok = FALSE;
 367   gint i;
 368
 369   if (state->minimum)
 370     {
 371       g_set_error_literal (error, G_MARKUP_ERROR,
 372                            G_MARKUP_ERROR_INVALID_CONTENT,
 373                            "<range/> already specified for this key");
 374       return;
 375     }
 376
 377   for (i = 0; i < G_N_ELEMENTS (table); i++)
 378     if (*(char *) state->type == table[i].type)
 379       {
 380         min_str = min_str ? min_str : table[i].min;
 381         max_str = max_str ? max_str : table[i].max;
 382         type_ok = TRUE;
 383         break;
 384       }
 385
 386   if (!type_ok)
 387     {
 388       gchar *type = g_variant_type_dup_string (state->type);
 389       g_set_error (error, G_MARKUP_ERROR,
 390                   G_MARKUP_ERROR_INVALID_CONTENT,
 391                   "<range> not allowed for keys of type '%s'", type);
 392       g_free (type);
 393       return;
 394     }
 395
 396   state->minimum = g_variant_parse (state->type, min_str, NULL, NULL, error);
 397   if (state->minimum == NULL)
 398     return;
 399
 400   state->maximum = g_variant_parse (state->type, max_str, NULL, NULL, error);
 401   if (state->maximum == NULL)
 402     return;
 403
 404   if (g_variant_compare (state->minimum, state->maximum) > 0)
 405     {
 406       g_set_error (error, G_MARKUP_ERROR,
 407                    G_MARKUP_ERROR_INVALID_CONTENT,
 408                    "<range> specified minimum is greater than maxmimum");
 409       return;
 410     }
 411
 412   key_state_check_range (state, error);
 413 }
 414
 415 static GString *
 416 key_state_start_default (KeyState     *state,
 417                          const gchar  *l10n,
 418                          const gchar  *context,
 419                          GError      **error)
 420 {
 421   if (l10n != NULL)
 422     {
 423       if (strcmp (l10n, "messages") == 0)
 424         state->l10n = 'm';
 425
 426       else if (strcmp (l10n, "time") == 0)
 427         state->l10n = 't';
 428
 429       else
 430         {
 431           g_set_error (error, G_MARKUP_ERROR,
 432                        G_MARKUP_ERROR_INVALID_CONTENT,
 433                        "unsupported l10n category: %s", l10n);
 434           return NULL;
 435         }
 436
 437       if (!state->have_gettext_domain)
 438         {
 439           g_set_error_literal (error, G_MARKUP_ERROR,
 440                                G_MARKUP_ERROR_INVALID_CONTENT,
 441                                "l10n requested, but no "
 442                                "gettext domain given");
 443           return NULL;
 444         }
 445
 446       state->l10n_context = g_strdup (context);
 447     }
 448
 449   else if (context != NULL)
 450     {
 451       g_set_error_literal (error, G_MARKUP_ERROR,
 452                            G_MARKUP_ERROR_INVALID_CONTENT,
 453                            "translation context given for "
 454                            " value without l10n enabled");
 455       return NULL;
 456     }
 457
 458   return g_string_new (NULL);
 459 }
 460
 461 static void
 462 key_state_end_default (KeyState  *state,
 463                        GString  **string,
 464                        GError   **error)
 465 {
 466   state->unparsed_default_value = *string;
 467   *string = NULL;
 468
 469   state->default_value = g_variant_parse (state->type,
 470                                           state->unparsed_default_value->str,
 471                                           NULL, NULL, error);
 472   if (!state->default_value)
 473     {
 474       gchar *type = g_variant_type_dup_string (state->type);
 475       g_prefix_error (error, "failed to parse <default> value of type '%s': ", type);
 476       g_free (type);
 477     }
 478
 479   key_state_check_range (state, error);
 480 }
 481
 482 static void
 483 key_state_start_choices (KeyState  *state,
 484                          GError   **error)
 485 {
 486   const GVariantType *type = state->type;
 487
 488   if (state->is_enum)
 489     {
 490       g_set_error_literal (error, G_MARKUP_ERROR,
 491                            G_MARKUP_ERROR_INVALID_CONTENT,
 492                            "<choices> cannot be specified for keys "
 493                            "tagged as having an enumerated type");
 494       return;
 495     }
 496
 497   if (state->has_choices)
 498     {
 499       g_set_error_literal (error, G_MARKUP_ERROR,
 500                            G_MARKUP_ERROR_INVALID_CONTENT,
 501                            "<choices> already specified for this key");
 502       return;
 503     }
 504
 505   while (g_variant_type_is_maybe (type) || g_variant_type_is_array (type))
 506     type = g_variant_type_element (type);
 507
 508   if (!g_variant_type_equal (type, G_VARIANT_TYPE_STRING))
 509     {
 510       gchar *type_string = g_variant_type_dup_string (state->type);
 511       g_set_error (error, G_MARKUP_ERROR,
 512                    G_MARKUP_ERROR_INVALID_CONTENT,
 513                    "<choices> not allowed for keys of type '%s'",
 514                    type_string);
 515       g_free (type_string);
 516       return;
 517     }
 518 }
 519
 520 static void
 521 key_state_add_choice (KeyState     *state,
 522                       const gchar  *choice,
 523                       GError      **error)
 524 {
 525   if (strinfo_builder_contains (state->strinfo, choice))
 526     {
 527       g_set_error (error, G_MARKUP_ERROR,
 528                    G_MARKUP_ERROR_INVALID_CONTENT,
 529                    "<choice value='%s'/> already given", choice);
 530       return;
 531     }
 532
 533   strinfo_builder_append_item (state->strinfo, choice, 0);
 534   state->has_choices = TRUE;
 535 }
 536
 537 static void
 538 key_state_end_choices (KeyState  *state,
 539                        GError   **error)
 540 {
 541   if (!state->has_choices)
 542     {
 543       g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
 544                    "<choices> must contain at least one <choice>");
 545       return;
 546     }
 547
 548   key_state_check_range (state, error);
 549 }
 550
 551 static void
 552 key_state_start_aliases (KeyState  *state,
 553                          GError   **error)
 554 {
 555   if (state->has_aliases)
 556     g_set_error_literal (error, G_MARKUP_ERROR,
 557                          G_MARKUP_ERROR_INVALID_CONTENT,
 558                          "<aliases> already specified for this key");
 559   else if (!state->is_flags && !state->is_enum && !state->has_choices)
 560     g_set_error_literal (error, G_MARKUP_ERROR,
 561                          G_MARKUP_ERROR_INVALID_CONTENT,
 562                          "<aliases> can only be specified for keys with "
 563                          "enumerated or flags types or after <choices>");
 564 }
 565
 566 static void
 567 key_state_add_alias (KeyState     *state,
 568                      const gchar  *alias,
 569                      const gchar  *target,
 570                      GError      **error)
 571 {
 572   if (strinfo_builder_contains (state->strinfo, alias))
 573     {
 574       if (strinfo_is_string_valid ((guint32 *) state->strinfo->str,
 575                                    state->strinfo->len / 4,
 576                                    alias))
 577         {
 578           if (state->is_enum)
 579             g_set_error (error, G_MARKUP_ERROR,
 580                          G_MARKUP_ERROR_INVALID_CONTENT,
 581                          "<alias value='%s'/> given when '%s' is already "
 582                          "a member of the enumerated type", alias, alias);
 583
 584           else
 585             g_set_error (error, G_MARKUP_ERROR,
 586                          G_MARKUP_ERROR_INVALID_CONTENT,
 587                          "<alias value='%s'/> given when "
 588                          "<choice value='%s'/> was already given",
 589                          alias, alias);
 590         }
 591
 592       else
 593         g_set_error (error, G_MARKUP_ERROR,
 594                      G_MARKUP_ERROR_INVALID_CONTENT,
 595                      "<alias value='%s'/> already specified", alias);
 596
 597       return;
 598     }
 599
 600   if (!strinfo_builder_append_alias (state->strinfo, alias, target))
 601     {
 602       g_set_error (error, G_MARKUP_ERROR,
 603                    G_MARKUP_ERROR_INVALID_CONTENT,
 604                    "alias target '%s' is not in %s", target,
 605                    state->is_enum ? "enumerated type" : "<choices>");
 606       return;
 607     }
 608
 609   state->has_aliases = TRUE;
 610 }
 611
 612 static void
 613 key_state_end_aliases (KeyState  *state,
 614                        GError   **error)
 615 {
 616   if (!state->has_aliases)
 617     {
 618       g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
 619                    "<aliases> must contain at least one <alias>");
 620       return;
 621     }
 622 }
 623
 624 static gboolean
 625 key_state_check (KeyState  *state,
 626                  GError   **error)
 627 {
 628   if (state->checked)
 629     return TRUE;
 630
 631   return state->checked = TRUE;
 632 }
 633
 634 static GVariant *
 635 key_state_serialise (KeyState *state)
 636 {
 637   if (state->serialised == NULL)
 638     {
 639       if (state->child_schema)
 640         {
 641           state->serialised = g_variant_new_string (state->child_schema);
 642         }
 643
 644       else
 645         {
 646           GVariantBuilder builder;
 647
 648           g_assert (key_state_check (state, NULL));
 649
 650           g_variant_builder_init (&builder, G_VARIANT_TYPE_TUPLE);
 651
 652           /* default value */
 653           g_variant_builder_add_value (&builder, state->default_value);
 654
 655           /* translation */
 656           if (state->l10n)
 657             {
 658               /* We are going to store the untranslated default for
 659                * runtime translation according to the current locale.
 660                * We need to strip leading and trailing whitespace from
 661                * the string so that it's exactly the same as the one
 662                * that ended up in the .po file for translation.
 663                *
 664                * We want to do this so that
 665                *
 666                *   <default l10n='messages'>
 667                *     ['a', 'b', 'c']
 668                *   </default>
 669                *
 670                * ends up in the .po file like "['a', 'b', 'c']",
 671                * omitting the extra whitespace at the start and end.
 672                */
 673               strip_string (state->unparsed_default_value);
 674
 675               if (state->l10n_context)
 676                 {
 677                   gint len;
 678
 679                   /* Contextified messages are supported by prepending
 680                    * the context, followed by '\004' to the start of the
 681                    * message string.  We do that here to save GSettings
 682                    * the work later on.
 683                    */
 684                   len = strlen (state->l10n_context);
 685                   state->l10n_context[len] = '\004';
 686                   g_string_prepend_len (state->unparsed_default_value,
 687                                         state->l10n_context, len + 1);
 688                   g_free (state->l10n_context);
 689                   state->l10n_context = NULL;
 690                 }
 691
 692               g_variant_builder_add (&builder, "(y(y&s))", 'l', state->l10n,
 693                                      state->unparsed_default_value->str);
 694               g_string_free (state->unparsed_default_value, TRUE);
 695               state->unparsed_default_value = NULL;
 696             }
 697
 698           /* choice, aliases, enums */
 699           if (state->strinfo->len)
 700             {
 701               GVariant *array;
 702               guint32 *words;
 703               gpointer data;
 704               gsize size;
 705               gint i;
 706
 707               data = state->strinfo->str;
 708               size = state->strinfo->len;
 709
 710               words = data;
 711               for (i = 0; i < size / sizeof (guint32); i++)
 712                 words[i] = GUINT32_TO_LE (words[i]);
 713
 714               array = g_variant_new_from_data (G_VARIANT_TYPE ("au"),
 715                                                data, size, TRUE,
 716                                                g_free, data);
 717
 718               g_string_free (state->strinfo, FALSE);
 719               state->strinfo = NULL;
 720
 721               g_variant_builder_add (&builder, "(y@au)",
 722                                      state->is_flags ? 'f' :
 723                                      state->is_enum ? 'e' : 'c',
 724                                      array);
 725             }
 726
 727           /* range */
 728           if (state->minimum || state->maximum)
 729             g_variant_builder_add (&builder, "(y(**))", 'r',
 730                                    state->minimum, state->maximum);
 731
 732           state->serialised = g_variant_builder_end (&builder);
 733         }
 734
 735       g_variant_ref_sink (state->serialised);
 736     }
 737
 738   return g_variant_ref (state->serialised);
 739 }
 740
 741 static void
 742 key_state_free (gpointer data)
 743 {
 744   KeyState *state = data;
 745
 746   if (state->type)
 747     g_variant_type_free (state->type);
 748
 749   g_free (state->l10n_context);
 750
 751   if (state->unparsed_default_value)
 752     g_string_free (state->unparsed_default_value, TRUE);
 753
 754   if (state->default_value)
 755     g_variant_unref (state->default_value);
 756
 757   if (state->strinfo)
 758     g_string_free (state->strinfo, TRUE);
 759
 760   if (state->minimum)
 761     g_variant_unref (state->minimum);
 762
 763   if (state->maximum)
 764     g_variant_unref (state->maximum);
 765
 766   if (state->serialised)
 767     g_variant_unref (state->serialised);
 768
 769   g_slice_free (KeyState, state);
 770 }
 771
 772 /* Key name validity {{{1 */
 773 static gboolean allow_any_name = FALSE;
 774
 775 static gboolean
 776 is_valid_keyname (const gchar  *key,
 777                   GError      **error)
 778 {
 779   gint i;
 780
 781   if (key[0] == '\0')
 782     {
 783       g_set_error_literal (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
 784                            _("empty names are not permitted"));
 785       return FALSE;
 786     }
 787
 788   if (allow_any_name)
 789     return TRUE;
 790
 791   if (!g_ascii_islower (key[0]))
 792     {
 793       g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
 794                    _("invalid name '%s': names must begin "
 795                      "with a lowercase letter"), key);
 796       return FALSE;
 797     }
 798
 799   for (i = 1; key[i]; i++)
 800     {
 801       if (key[i] != '-' &&
 802           !g_ascii_islower (key[i]) &&
 803           !g_ascii_isdigit (key[i]))
 804         {
 805           g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
 806                        _("invalid name '%s': invalid character '%c'; "
 807                          "only lowercase letters, numbers and hyphen ('-') "
 808                          "are permitted."), key, key[i]);
 809           return FALSE;
 810         }
 811
 812       if (key[i] == '-' && key[i + 1] == '-')
 813         {
 814           g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
 815                        _("invalid name '%s': two successive hyphens ('--') "
 816                          "are not permitted."), key);
 817           return FALSE;
 818         }
 819     }
 820
 821   if (key[i - 1] == '-')
 822     {
 823       g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
 824                    _("invalid name '%s': the last character may not be a "
 825                      "hyphen ('-')."), key);
 826       return FALSE;
 827     }
 828
 829   if (i > 1024)
 830     {
 831       g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
 832                    _("invalid name '%s': maximum length is 1024"), key);
 833       return FALSE;
 834     }
 835
 836   return TRUE;
 837 }
 838
 839 /* Handling of <schema> {{{1 */
 840 typedef struct _SchemaState SchemaState;
 841 struct _SchemaState
 842 {
 843   SchemaState *extends;
 844
 845   gchar       *path;
 846   gchar       *gettext_domain;
 847   gchar       *extends_name;
 848   gchar       *list_of;
 849
 850   GHashTable  *keys;
 851 };
 852
 853 static SchemaState *
 854 schema_state_new (const gchar  *path,
 855                   const gchar  *gettext_domain,
 856                   SchemaState  *extends,
 857                   const gchar  *extends_name,
 858                   const gchar  *list_of)
 859 {
 860   SchemaState *state;
 861
 862   state = g_slice_new (SchemaState);
 863   state->path = g_strdup (path);
 864   state->gettext_domain = g_strdup (gettext_domain);
 865   state->extends = extends;
 866   state->extends_name = g_strdup (extends_name);
 867   state->list_of = g_strdup (list_of);
 868   state->keys = g_hash_table_new_full (g_str_hash, g_str_equal,
 869                                        g_free, key_state_free);
 870
 871   return state;
 872 }
 873
 874 static void
 875 schema_state_free (gpointer data)
 876 {
 877   SchemaState *state = data;
 878
 879   g_free (state->path);
 880   g_free (state->gettext_domain);
 881   g_hash_table_unref (state->keys);
 882   g_slice_free (SchemaState, state);
 883 }
 884
 885 static void
 886 schema_state_add_child (SchemaState  *state,
 887                         const gchar  *name,
 888                         const gchar  *schema,
 889                         GError      **error)
 890 {
 891   gchar *childname;
 892
 893   if (!is_valid_keyname (name, error))
 894     return;
 895
 896   childname = g_strconcat (name, "/", NULL);
 897
 898   if (g_hash_table_lookup (state->keys, childname))
 899     {
 900       g_set_error (error, G_MARKUP_ERROR,
 901                    G_MARKUP_ERROR_INVALID_CONTENT,
 902                    _("<child name='%s'> already specified"), name);
 903       return;
 904     }
 905
 906   g_hash_table_insert (state->keys, childname,
 907                        key_state_new_child (schema));
 908 }
 909
 910 static KeyState *
 911 schema_state_add_key (SchemaState  *state,
 912                       GHashTable   *enum_table,
 913                       GHashTable   *flags_table,
 914                       const gchar  *name,
 915                       const gchar  *type_string,
 916                       const gchar  *enum_type,
 917                       const gchar  *flags_type,
 918                       GError      **error)
 919 {
 920   SchemaState *node;
 921   GString *strinfo;
 922   KeyState *key;
 923
 924   if (state->list_of)
 925     {
 926       g_set_error_literal (error, G_MARKUP_ERROR,
 927                            G_MARKUP_ERROR_INVALID_CONTENT,
 928                            _("cannot add keys to a 'list-of' schema"));
 929       return NULL;
 930     }
 931
 932   if (!is_valid_keyname (name, error))
 933     return NULL;
 934
 935   if (g_hash_table_lookup (state->keys, name))
 936     {
 937       g_set_error (error, G_MARKUP_ERROR,
 938                    G_MARKUP_ERROR_INVALID_CONTENT,
 939                    _("<key name='%s'> already specified"), name);
 940       return NULL;
 941     }
 942
 943   for (node = state; node; node = node->extends)
 944     if (node->extends)
 945       {
 946         KeyState *shadow;
 947
 948         shadow = g_hash_table_lookup (node->extends->keys, name);
 949
 950         /* in case of <key> <override> <key> make sure we report the
 951          * location of the original <key>, not the <override>.
 952          */
 953         if (shadow && !shadow->is_override)
 954           {
 955             g_set_error (error, G_MARKUP_ERROR,
 956                          G_MARKUP_ERROR_INVALID_CONTENT,
 957                          _("<key name='%s'> shadows <key name='%s'> in "
 958                            "<schema id='%s'>; use <override> to modify value"),
 959                          name, name, node->extends_name);
 960             return NULL;
 961           }
 962       }
 963
 964   if ((type_string != NULL) + (enum_type != NULL) + (flags_type != NULL) != 1)
 965     {
 966       g_set_error (error, G_MARKUP_ERROR,
 967                    G_MARKUP_ERROR_MISSING_ATTRIBUTE,
 968                    _("exactly one of 'type', 'enum' or 'flags' must "
 969                      "be specified as an attribute to <key>"));
 970       return NULL;
 971     }
 972
 973   if (type_string == NULL) /* flags or enums was specified */
 974     {
 975       EnumState *enum_state;
 976
 977       if (enum_type)
 978         enum_state = g_hash_table_lookup (enum_table, enum_type);
 979       else
 980         enum_state = g_hash_table_lookup (flags_table, flags_type);
 981
 982
 983       if (enum_state == NULL)
 984         {
 985           g_set_error (error, G_MARKUP_ERROR,
 986                        G_MARKUP_ERROR_INVALID_CONTENT,
 987                        _("<%s id='%s'> not (yet) defined."),
 988                        flags_type ? "flags"    : "enum",
 989                        flags_type ? flags_type : enum_type);
 990           return NULL;
 991         }
 992
 993       type_string = flags_type ? "as" : "s";
 994       strinfo = enum_state->strinfo;
 995     }
 996   else
 997     {
 998       if (!g_variant_type_string_is_valid (type_string))
 999         {
1000           g_set_error (error, G_MARKUP_ERROR,
1001                        G_MARKUP_ERROR_INVALID_CONTENT,
1002                        _("invalid GVariant type string '%s'"), type_string);
1003           return NULL;
1004         }
1005
1006       strinfo = NULL;
1007     }
1008
1009   key = key_state_new (type_string, state->gettext_domain,
1010                        enum_type != NULL, flags_type != NULL, strinfo);
1011   g_hash_table_insert (state->keys, g_strdup (name), key);
1012
1013   return key;
1014 }
1015
1016 static void
1017 schema_state_add_override (SchemaState  *state,
1018                            KeyState    **key_state,
1019                            GString     **string,
1020                            const gchar  *key,
1021                            const gchar  *l10n,
1022                            const gchar  *context,
1023                            GError      **error)
1024 {
1025   SchemaState *parent;
1026   KeyState *original;
1027
1028   if (state->extends == NULL)
1029     {
1030       g_set_error_literal (error, G_MARKUP_ERROR,
1031                            G_MARKUP_ERROR_INVALID_CONTENT,
1032                            _("<override> given but schema isn't "
1033                              "extending anything"));
1034       return;
1035     }
1036
1037   for (parent = state->extends; parent; parent = parent->extends)
1038     if ((original = g_hash_table_lookup (parent->keys, key)))
1039       break;
1040
1041   if (original == NULL)
1042     {
1043       g_set_error (error, G_MARKUP_ERROR,
1044                    G_MARKUP_ERROR_INVALID_CONTENT,
1045                    _("no <key name='%s'> to override"), key);
1046       return;
1047     }
1048
1049   if (g_hash_table_lookup (state->keys, key))
1050     {
1051       g_set_error (error, G_MARKUP_ERROR,
1052                    G_MARKUP_ERROR_INVALID_CONTENT,
1053                    _("<override name='%s'> already specified"), key);
1054       return;
1055     }
1056
1057   *key_state = key_state_override (original, state->gettext_domain);
1058   *string = key_state_start_default (*key_state, l10n, context, error);
1059   g_hash_table_insert (state->keys, g_strdup (key), *key_state);
1060 }
1061
1062 static void
1063 override_state_end (KeyState **key_state,
1064                     GString  **string,
1065                     GError   **error)
1066 {
1067   key_state_end_default (*key_state, string, error);
1068   *key_state = NULL;
1069 }
1070
1071 /* Handling of toplevel state {{{1 */
1072 typedef struct
1073 {
1074   gboolean     strict;                  /* TRUE if --strict was given */
1075
1076   GHashTable  *schema_table;            /* string -> SchemaState */
1077   GHashTable  *flags_table;             /* string -> EnumState */
1078   GHashTable  *enum_table;              /* string -> EnumState */
1079
1080   GSList      *this_file_schemas;       /* strings: <schema>s in this file */
1081   GSList      *this_file_flagss;        /* strings: <flags>s in this file */
1082   GSList      *this_file_enums;         /* strings: <enum>s in this file */
1083
1084   gchar       *schemalist_domain;       /* the <schemalist> gettext domain */
1085
1086   SchemaState *schema_state;            /* non-NULL when inside <schema> */
1087   KeyState    *key_state;               /* non-NULL when inside <key> */
1088   EnumState   *enum_state;              /* non-NULL when inside <enum> */
1089
1090   GString     *string;                  /* non-NULL when accepting text */
1091 } ParseState;
1092
1093 static gboolean
1094 is_subclass (const gchar *class_name,
1095              const gchar *possible_parent,
1096              GHashTable  *schema_table)
1097 {
1098   SchemaState *class;
1099
1100   if (strcmp (class_name, possible_parent) == 0)
1101     return TRUE;
1102
1103   class = g_hash_table_lookup (schema_table, class_name);
1104   g_assert (class != NULL);
1105
1106   return class->extends_name &&
1107          is_subclass (class->extends_name, possible_parent, schema_table);
1108 }
1109
1110 static void
1111 parse_state_start_schema (ParseState  *state,
1112                           const gchar  *id,
1113                           const gchar  *path,
1114                           const gchar  *gettext_domain,
1115                           const gchar  *extends_name,
1116                           const gchar  *list_of,
1117                           GError      **error)
1118 {
1119   SchemaState *extends;
1120   gchar *my_id;
1121
1122   if (g_hash_table_lookup (state->schema_table, id))
1123     {
1124       g_set_error (error, G_MARKUP_ERROR,
1125                    G_MARKUP_ERROR_INVALID_CONTENT,
1126                    _("<schema id='%s'> already specified"), id);
1127       return;
1128     }
1129
1130   if (extends_name)
1131     {
1132       extends = g_hash_table_lookup (state->schema_table, extends_name);
1133
1134       if (extends == NULL)
1135         {
1136           g_set_error (error, G_MARKUP_ERROR,
1137                        G_MARKUP_ERROR_INVALID_CONTENT,
1138                        _("<schema id='%s'> extends not yet existing "
1139                          "schema '%s'"), id, extends_name);
1140           return;
1141         }
1142     }
1143   else
1144     extends = NULL;
1145
1146   if (list_of)
1147     {
1148       SchemaState *tmp;
1149
1150       if (!(tmp = g_hash_table_lookup (state->schema_table, list_of)))
1151         {
1152           g_set_error (error, G_MARKUP_ERROR,
1153                        G_MARKUP_ERROR_INVALID_CONTENT,
1154                        _("<schema id='%s'> is list of not yet existing "
1155                          "schema '%s'"), id, list_of);
1156           return;
1157         }
1158
1159       if (tmp->path)
1160         {
1161           g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
1162                        _("Can not be a list of a schema with a path"));
1163           return;
1164         }
1165     }
1166
1167   if (extends)
1168     {
1169       if (extends->path)
1170         {
1171           g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
1172                        _("Can not extend a schema with a path"));
1173           return;
1174         }
1175
1176       if (list_of)
1177         {
1178           if (extends->list_of == NULL)
1179             {
1180               g_set_error (error, G_MARKUP_ERROR,
1181                            G_MARKUP_ERROR_INVALID_CONTENT,
1182                            _("<schema id='%s'> is a list, extending "
1183                              "<schema id='%s'> which is not a list"),
1184                            id, extends_name);
1185               return;
1186             }
1187
1188           if (!is_subclass (list_of, extends->list_of, state->schema_table))
1189             {
1190               g_set_error (error, G_MARKUP_ERROR,
1191                            G_MARKUP_ERROR_INVALID_CONTENT,
1192                            _("<schema id='%s' list-of='%s'> extends <schema "
1193                              "id='%s' list-of='%s'> but '%s' does not "
1194                              "extend '%s'"), id, list_of, extends_name,
1195                            extends->list_of, list_of, extends->list_of);
1196               return;
1197             }
1198         }
1199       else
1200         /* by default we are a list of the same thing that the schema
1201          * we are extending is a list of (which might be nothing)
1202          */
1203         list_of = extends->list_of;
1204     }
1205
1206   if (path && !(g_str_has_prefix (path, "/") && g_str_has_suffix (path, "/")))
1207     {
1208       g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
1209                    _("a path, if given, must begin and end with a slash"));
1210       return;
1211     }
1212
1213   if (path && list_of && !g_str_has_suffix (path, ":/"))
1214     {
1215       g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
1216                    _("the path of a list must end with ':/'"));
1217       return;
1218     }
1219
1220   if (path && (g_str_has_prefix (path, "/apps/") ||
1221                g_str_has_prefix (path, "/desktop/") ||
1222                g_str_has_prefix (path, "/system/")))
1223     g_printerr ("warning: Schema '%s' has path '%s'.  Paths starting with "
1224                 "'/apps/', '/desktop/' or '/system/' are deprecated.\n", id, path);
1225
1226   state->schema_state = schema_state_new (path, gettext_domain,
1227                                           extends, extends_name, list_of);
1228
1229   my_id = g_strdup (id);
1230   state->this_file_schemas = g_slist_prepend (state->this_file_schemas, my_id);
1231   g_hash_table_insert (state->schema_table, my_id, state->schema_state);
1232 }
1233
1234 static void
1235 parse_state_start_enum (ParseState   *state,
1236                         const gchar  *id,
1237                         gboolean      is_flags,
1238                         GError      **error)
1239 {
1240   GSList **list = is_flags ? &state->this_file_flagss : &state->this_file_enums;
1241   GHashTable *table = is_flags ? state->flags_table : state->enum_table;
1242   gchar *my_id;
1243
1244   if (g_hash_table_lookup (table, id))
1245     {
1246       g_set_error (error, G_MARKUP_ERROR,
1247                    G_MARKUP_ERROR_INVALID_CONTENT,
1248                    _("<%s id='%s'> already specified"),
1249                    is_flags ? "flags" : "enum", id);
1250       return;
1251     }
1252
1253   state->enum_state = enum_state_new (is_flags);
1254
1255   my_id = g_strdup (id);
1256   *list = g_slist_prepend (*list, my_id);
1257   g_hash_table_insert (table, my_id, state->enum_state);
1258 }
1259
1260 /* GMarkup Parser Functions {{{1 */
1261
1262 /* Start element {{{2 */
1263 static void
1264 start_element (GMarkupParseContext  *context,
1265                const gchar          *element_name,
1266                const gchar         **attribute_names,
1267                const gchar         **attribute_values,
1268                gpointer              user_data,
1269                GError              **error)
1270 {
1271   ParseState *state = user_data;
1272   const GSList *element_stack;
1273   const gchar *container;
1274
1275   element_stack = g_markup_parse_context_get_element_stack (context);
1276   container = element_stack->next ? element_stack->next->data : NULL;
1277
1278 #define COLLECT(first, ...) \
1279   g_markup_collect_attributes (element_name,                                 \
1280                                attribute_names, attribute_values, error,     \
1281                                first, __VA_ARGS__, G_MARKUP_COLLECT_INVALID)
1282 #define OPTIONAL   G_MARKUP_COLLECT_OPTIONAL
1283 #define STRDUP     G_MARKUP_COLLECT_STRDUP
1284 #define STRING     G_MARKUP_COLLECT_STRING
1285 #define NO_ATTRS()  COLLECT (G_MARKUP_COLLECT_INVALID, NULL)
1286
1287   /* Toplevel items {{{3 */
1288   if (container == NULL)
1289     {
1290       if (strcmp (element_name, "schemalist") == 0)
1291         {
1292           COLLECT (OPTIONAL | STRDUP,
1293                    "gettext-domain",
1294                    &state->schemalist_domain);
1295           return;
1296         }
1297     }
1298
1299
1300   /* children of <schemalist> {{{3 */
1301   else if (strcmp (container, "schemalist") == 0)
1302     {
1303       if (strcmp (element_name, "schema") == 0)
1304         {
1305           const gchar *id, *path, *gettext_domain, *extends, *list_of;
1306           if (COLLECT (STRING, "id", &id,
1307                        OPTIONAL | STRING, "path", &path,
1308                        OPTIONAL | STRING, "gettext-domain", &gettext_domain,
1309                        OPTIONAL | STRING, "extends", &extends,
1310                        OPTIONAL | STRING, "list-of", &list_of))
1311             parse_state_start_schema (state, id, path,
1312                                       gettext_domain ? gettext_domain
1313                                                      : state->schemalist_domain,
1314                                       extends, list_of, error);
1315           return;
1316         }
1317
1318       else if (strcmp (element_name, "enum") == 0)
1319         {
1320           const gchar *id;
1321           if (COLLECT (STRING, "id", &id))
1322             parse_state_start_enum (state, id, FALSE, error);
1323           return;
1324         }
1325
1326       else if (strcmp (element_name, "flags") == 0)
1327         {
1328           const gchar *id;
1329           if (COLLECT (STRING, "id", &id))
1330             parse_state_start_enum (state, id, TRUE, error);
1331           return;
1332         }
1333     }
1334
1335
1336   /* children of <schema> {{{3 */
1337   else if (strcmp (container, "schema") == 0)
1338     {
1339       if (strcmp (element_name, "key") == 0)
1340         {
1341           const gchar *name, *type_string, *enum_type, *flags_type;
1342
1343           if (COLLECT (STRING,            "name",  &name,
1344                        OPTIONAL | STRING, "type",  &type_string,
1345                        OPTIONAL | STRING, "enum",  &enum_type,
1346                        OPTIONAL | STRING, "flags", &flags_type))
1347
1348             state->key_state = schema_state_add_key (state->schema_state,
1349                                                      state->enum_table,
1350                                                      state->flags_table,
1351                                                      name, type_string,
1352                                                      enum_type, flags_type,
1353                                                      error);
1354           return;
1355         }
1356       else if (strcmp (element_name, "child") == 0)
1357         {
1358           const gchar *name, *schema;
1359
1360           if (COLLECT (STRING, "name", &name, STRING, "schema", &schema))
1361             schema_state_add_child (state->schema_state,
1362                                     name, schema, error);
1363           return;
1364         }
1365       else if (strcmp (element_name, "override") == 0)
1366         {
1367           const gchar *name, *l10n, *context;
1368
1369           if (COLLECT (STRING,            "name",    &name,
1370                        OPTIONAL | STRING, "l10n",    &l10n,
1371                        OPTIONAL | STRING, "context", &context))
1372             schema_state_add_override (state->schema_state,
1373                                        &state->key_state, &state->string,
1374                                        name, l10n, context, error);
1375           return;
1376         }
1377     }
1378
1379   /* children of <key> {{{3 */
1380   else if (strcmp (container, "key") == 0)
1381     {
1382       if (strcmp (element_name, "default") == 0)
1383         {
1384           const gchar *l10n, *context;
1385           if (COLLECT (STRING | OPTIONAL, "l10n",    &l10n,
1386                        STRING | OPTIONAL, "context", &context))
1387             state->string = key_state_start_default (state->key_state,
1388                                                      l10n, context, error);
1389           return;
1390         }
1391
1392       else if (strcmp (element_name, "summary") == 0)
1393         {
1394           if (NO_ATTRS ())
1395             {
1396               if (state->key_state->summary_seen && state->strict)
1397                 g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
1398                              _("Only one <%s> element allowed inside <%s>"),
1399                              element_name, container);
1400               else
1401                 state->string = g_string_new (NULL);
1402
1403               state->key_state->summary_seen = TRUE;
1404             }
1405           return;
1406         }
1407
1408       else if (strcmp (element_name, "description") == 0)
1409         {
1410           if (NO_ATTRS ())
1411             {
1412               if (state->key_state->description_seen && state->strict)
1413                 g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
1414                              _("Only one <%s> element allowed inside <%s>"),
1415                              element_name, container);
1416               else
1417                 state->string = g_string_new (NULL);
1418
1419             state->key_state->description_seen = TRUE;
1420             }
1421           return;
1422         }
1423
1424       else if (strcmp (element_name, "range") == 0)
1425         {
1426           const gchar *min, *max;
1427           if (COLLECT (STRING | OPTIONAL, "min", &min,
1428                        STRING | OPTIONAL, "max", &max))
1429             key_state_set_range (state->key_state, min, max, error);
1430           return;
1431         }
1432
1433       else if (strcmp (element_name, "choices") == 0)
1434         {
1435           if (NO_ATTRS ())
1436             key_state_start_choices (state->key_state, error);
1437           return;
1438         }
1439
1440       else if (strcmp (element_name, "aliases") == 0)
1441         {
1442           if (NO_ATTRS ())
1443             key_state_start_aliases (state->key_state, error);
1444           return;
1445         }
1446     }
1447
1448
1449   /* children of <choices> {{{3 */
1450   else if (strcmp (container, "choices") == 0)
1451     {
1452       if (strcmp (element_name, "choice") == 0)
1453         {
1454           const gchar *value;
1455           if (COLLECT (STRING, "value", &value))
1456             key_state_add_choice (state->key_state, value, error);
1457           return;
1458         }
1459     }
1460
1461
1462   /* children of <aliases> {{{3 */
1463   else if (strcmp (container, "aliases") == 0)
1464     {
1465       if (strcmp (element_name, "alias") == 0)
1466         {
1467           const gchar *value, *target;
1468           if (COLLECT (STRING, "value", &value, STRING, "target", &target))
1469             key_state_add_alias (state->key_state, value, target, error);
1470           return;
1471         }
1472     }
1473
1474
1475   /* children of <enum> {{{3 */
1476   else if (strcmp (container, "enum") == 0 ||
1477            strcmp (container, "flags") == 0)
1478     {
1479       if (strcmp (element_name, "value") == 0)
1480         {
1481           const gchar *nick, *valuestr;
1482           if (COLLECT (STRING, "nick", &nick,
1483                        STRING, "value", &valuestr))
1484             enum_state_add_value (state->enum_state, nick, valuestr, error);
1485           return;
1486         }
1487     }
1488   /* 3}}} */
1489
1490   if (container)
1491     g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_UNKNOWN_ELEMENT,
1492                  _("Element <%s> not allowed inside <%s>"),
1493                  element_name, container);
1494   else
1495     g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_UNKNOWN_ELEMENT,
1496                  _("Element <%s> not allowed at the top level"), element_name);
1497 }
1498 /* 2}}} */
1499 /* End element {{{2 */
1500
1501 static void
1502 key_state_end (KeyState **state_ptr,
1503                GError   **error)
1504 {
1505   KeyState *state;
1506
1507   state = *state_ptr;
1508   *state_ptr = NULL;
1509
1510   if (state->default_value == NULL)
1511     {
1512       g_set_error_literal (error,
1513                            G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
1514                            "element <default> is required in <key>");
1515       return;
1516     }
1517 }
1518
1519 static void
1520 schema_state_end (SchemaState **state_ptr,
1521                   GError      **error)
1522 {
1523   *state_ptr = NULL;
1524 }
1525
1526 static void
1527 end_element (GMarkupParseContext  *context,
1528              const gchar          *element_name,
1529              gpointer              user_data,
1530              GError              **error)
1531 {
1532   ParseState *state = user_data;
1533
1534   if (strcmp (element_name, "schemalist") == 0)
1535     {
1536       g_free (state->schemalist_domain);
1537       state->schemalist_domain = NULL;
1538     }
1539
1540   else if (strcmp (element_name, "enum") == 0 ||
1541            strcmp (element_name, "flags") == 0)
1542     enum_state_end (&state->enum_state, error);
1543
1544   else if (strcmp (element_name, "schema") == 0)
1545     schema_state_end (&state->schema_state, error);
1546
1547   else if (strcmp (element_name, "override") == 0)
1548     override_state_end (&state->key_state, &state->string, error);
1549
1550   else if (strcmp (element_name, "key") == 0)
1551     key_state_end (&state->key_state, error);
1552
1553   else if (strcmp (element_name, "default") == 0)
1554     key_state_end_default (state->key_state, &state->string, error);
1555
1556   else if (strcmp (element_name, "choices") == 0)
1557     key_state_end_choices (state->key_state, error);
1558
1559   else if (strcmp (element_name, "aliases") == 0)
1560     key_state_end_aliases (state->key_state, error);
1561
1562   if (state->string)
1563     {
1564       g_string_free (state->string, TRUE);
1565       state->string = NULL;
1566     }
1567 }
1568 /* Text {{{2 */
1569 static void
1570 text (GMarkupParseContext  *context,
1571       const gchar          *text,
1572       gsize                 text_len,
1573       gpointer              user_data,
1574       GError              **error)
1575 {
1576   ParseState *state = user_data;
1577
1578   if (state->string)
1579     {
1580       /* we are expecting a string, so store the text data.
1581        *
1582        * we store the data verbatim here and deal with whitespace
1583        * later on.  there are two reasons for that:
1584        *
1585        *  1) whitespace is handled differently depending on the tag
1586        *     type.
1587        *
1588        *  2) we could do leading whitespace removal by refusing to
1589        *     insert it into state->string if it's at the start, but for
1590        *     trailing whitespace, we have no idea if there is another
1591        *     text() call coming or not.
1592        */
1593       g_string_append_len (state->string, text, text_len);
1594     }
1595   else
1596     {
1597       /* string is not expected: accept (and ignore) pure whitespace */
1598       gsize i;
1599
1600       for (i = 0; i < text_len; i++)
1601         if (!g_ascii_isspace (text[i]))
1602           {
1603             g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
1604                          _("text may not appear inside <%s>"),
1605                          g_markup_parse_context_get_element (context));
1606             break;
1607           }
1608     }
1609 }
1610
1611 /* Write to GVDB {{{1 */
1612 typedef struct
1613 {
1614   GHashTable *table;
1615   GvdbItem *root;
1616 } GvdbPair;
1617
1618 static void
1619 gvdb_pair_init (GvdbPair *pair)
1620 {
1621   pair->table = gvdb_hash_table_new (NULL, NULL);
1622   pair->root = gvdb_hash_table_insert (pair->table, "");
1623 }
1624
1625 static void
1626 gvdb_pair_clear (GvdbPair *pair)
1627 {
1628   g_hash_table_unref (pair->table);
1629 }
1630
1631 typedef struct
1632 {
1633   GHashTable *schema_table;
1634   GvdbPair root_pair;
1635 } WriteToFileData;
1636
1637 typedef struct
1638 {
1639   GHashTable *schema_table;
1640   GvdbPair pair;
1641   gboolean l10n;
1642 } OutputSchemaData;
1643
1644 static void
1645 output_key (gpointer key,
1646             gpointer value,
1647             gpointer user_data)
1648 {
1649   OutputSchemaData *data;
1650   const gchar *name;
1651   KeyState *state;
1652   GvdbItem *item;
1653   GVariant *serialised = NULL;
1654
1655   name = key;
1656   state = value;
1657   data = user_data;
1658
1659   item = gvdb_hash_table_insert (data->pair.table, name);
1660   gvdb_item_set_parent (item, data->pair.root);
1661   serialised = key_state_serialise (state);
1662   gvdb_item_set_value (item, serialised);
1663   g_variant_unref (serialised);
1664
1665   if (state->l10n)
1666     data->l10n = TRUE;
1667
1668   if (state->child_schema &&
1669       !g_hash_table_lookup (data->schema_table, state->child_schema))
1670     g_printerr ("warning: undefined reference to <schema id='%s'/>\n",
1671                 state->child_schema);
1672 }
1673
1674 static void
1675 output_schema (gpointer key,
1676                gpointer value,
1677                gpointer user_data)
1678 {
1679   WriteToFileData *wtf_data = user_data;
1680   OutputSchemaData data;
1681   GvdbPair *root_pair;
1682   SchemaState *state;
1683   const gchar *id;
1684   GvdbItem *item;
1685
1686   id = key;
1687   state = value;
1688   root_pair = &wtf_data->root_pair;
1689
1690   data.schema_table = wtf_data->schema_table;
1691   gvdb_pair_init (&data.pair);
1692   data.l10n = FALSE;
1693
1694   item = gvdb_hash_table_insert (root_pair->table, id);
1695   gvdb_item_set_parent (item, root_pair->root);
1696   gvdb_item_set_hash_table (item, data.pair.table);
1697
1698   g_hash_table_foreach (state->keys, output_key, &data);
1699
1700   if (state->path)
1701     gvdb_hash_table_insert_string (data.pair.table, ".path", state->path);
1702
1703   if (state->extends_name)
1704     gvdb_hash_table_insert_string (data.pair.table, ".extends",
1705                                    state->extends_name);
1706
1707   if (state->list_of)
1708     gvdb_hash_table_insert_string (data.pair.table, ".list-of",
1709                                    state->list_of);
1710
1711   if (data.l10n)
1712     gvdb_hash_table_insert_string (data.pair.table,
1713                                    ".gettext-domain",
1714                                    state->gettext_domain);
1715
1716   gvdb_pair_clear (&data.pair);
1717 }
1718
1719 static gboolean
1720 write_to_file (GHashTable   *schema_table,
1721                const gchar  *filename,
1722                GError      **error)
1723 {
1724   WriteToFileData data;
1725   gboolean success;
1726
1727   data.schema_table = schema_table;
1728
1729   gvdb_pair_init (&data.root_pair);
1730
1731   g_hash_table_foreach (schema_table, output_schema, &data);
1732
1733   success = gvdb_table_write_contents (data.root_pair.table, filename,
1734                                        G_BYTE_ORDER != G_LITTLE_ENDIAN,
1735                                        error);
1736   g_hash_table_unref (data.root_pair.table);
1737
1738   return success;
1739 }
1740
1741 /* Parser driver {{{1 */
1742 static GHashTable *
1743 parse_gschema_files (gchar    **files,
1744                      gboolean   strict)
1745 {
1746   GMarkupParser parser = { start_element, end_element, text };
1747   ParseState state = { 0, };
1748   const gchar *filename;
1749   GError *error = NULL;
1750
1751   state.strict = strict;
1752
1753   state.enum_table = g_hash_table_new_full (g_str_hash, g_str_equal,
1754                                             g_free, enum_state_free);
1755
1756   state.flags_table = g_hash_table_new_full (g_str_hash, g_str_equal,
1757                                              g_free, enum_state_free);
1758
1759   state.schema_table = g_hash_table_new_full (g_str_hash, g_str_equal,
1760                                               g_free, schema_state_free);
1761
1762   while ((filename = *files++) != NULL)
1763     {
1764       GMarkupParseContext *context;
1765       gchar *contents;
1766       gsize size;
1767       gint line, col;
1768
1769       if (!g_file_get_contents (filename, &contents, &size, &error))
1770         {
1771           fprintf (stderr, "%s\n", error->message);
1772           g_clear_error (&error);
1773           continue;
1774         }
1775
1776       context = g_markup_parse_context_new (&parser,
1777                                             G_MARKUP_TREAT_CDATA_AS_TEXT |
1778                                             G_MARKUP_PREFIX_ERROR_POSITION |
1779                                             G_MARKUP_IGNORE_QUALIFIED,
1780                                             &state, NULL);
1781
1782
1783       if (!g_markup_parse_context_parse (context, contents, size, &error) ||
1784           !g_markup_parse_context_end_parse (context, &error))
1785         {
1786           GSList *item;
1787
1788           /* back out any changes from this file */
1789           for (item = state.this_file_schemas; item; item = item->next)
1790             g_hash_table_remove (state.schema_table, item->data);
1791
1792           for (item = state.this_file_flagss; item; item = item->next)
1793             g_hash_table_remove (state.flags_table, item->data);
1794
1795           for (item = state.this_file_enums; item; item = item->next)
1796             g_hash_table_remove (state.enum_table, item->data);
1797
1798           /* let them know */
1799           g_markup_parse_context_get_position (context, &line, &col);
1800           fprintf (stderr, "%s:%d:%d  %s.  ", filename, line, col, error->message);
1801           g_clear_error (&error);
1802
1803           if (strict)
1804             {
1805               /* Translators: Do not translate "--strict". */
1806               fprintf (stderr, _("--strict was specified; exiting.\n"));
1807               g_hash_table_unref (state.schema_table);
1808               g_hash_table_unref (state.flags_table);
1809               g_hash_table_unref (state.enum_table);
1810
1811               g_free (contents);
1812
1813               return NULL;
1814             }
1815           else
1816             fprintf (stderr, _("This entire file has been ignored.\n"));
1817         }
1818
1819       /* cleanup */
1820       g_free (contents);
1821       g_markup_parse_context_free (context);
1822       g_slist_free (state.this_file_schemas);
1823       g_slist_free (state.this_file_flagss);
1824       g_slist_free (state.this_file_enums);
1825       state.this_file_schemas = NULL;
1826       state.this_file_flagss = NULL;
1827       state.this_file_enums = NULL;
1828     }
1829
1830   g_hash_table_unref (state.flags_table);
1831   g_hash_table_unref (state.enum_table);
1832
1833   return state.schema_table;
1834 }
1835
1836 static gint
1837 compare_strings (gconstpointer a,
1838                  gconstpointer b)
1839 {
1840   gchar *one = *(gchar **) a;
1841   gchar *two = *(gchar **) b;
1842   gint cmp;
1843
1844   cmp = g_str_has_suffix (two, ".enums.xml") -
1845         g_str_has_suffix (one, ".enums.xml");
1846
1847   if (!cmp)
1848     cmp = strcmp (one, two);
1849
1850   return cmp;
1851 }
1852
1853 static gboolean
1854 set_overrides (GHashTable  *schema_table,
1855                gchar      **files,
1856                gboolean     strict)
1857 {
1858   const gchar *filename;
1859   GError *error = NULL;
1860
1861   while ((filename = *files++))
1862     {
1863       GKeyFile *key_file;
1864       gchar **groups;
1865       gint i;
1866
1867       key_file = g_key_file_new ();
1868       if (!g_key_file_load_from_file (key_file, filename, 0, &error))
1869         {
1870           fprintf (stderr, "%s: %s.  ", filename, error->message);
1871           g_key_file_free (key_file);
1872           g_clear_error (&error);
1873
1874           if (!strict)
1875             {
1876               fprintf (stderr, _("Ignoring this file.\n"));
1877               continue;
1878             }
1879
1880           fprintf (stderr, _("--strict was specified; exiting.\n"));
1881           return FALSE;
1882         }
1883
1884       groups = g_key_file_get_groups (key_file, NULL);
1885
1886       for (i = 0; groups[i]; i++)
1887         {
1888           const gchar *group = groups[i];
1889           SchemaState *schema;
1890           gchar **keys;
1891           gint j;
1892
1893           schema = g_hash_table_lookup (schema_table, group);
1894
1895           if (schema == NULL)
1896             /* Having the schema not be installed is expected to be a
1897              * common case.  Don't even emit an error message about
1898              * that.
1899              */
1900             continue;
1901
1902           keys = g_key_file_get_keys (key_file, group, NULL, NULL);
1903           g_assert (keys != NULL);
1904
1905           for (j = 0; keys[j]; j++)
1906             {
1907               const gchar *key = keys[j];
1908               KeyState *state;
1909               GVariant *value;
1910               gchar *string;
1911
1912               state = g_hash_table_lookup (schema->keys, key);
1913
1914               if (state == NULL)
1915                 {
1916                   fprintf (stderr, _("No such key '%s' in schema '%s' as "
1917                                      "specified in override file '%s'"),
1918                            key, group, filename);
1919
1920                   if (!strict)
1921                     {
1922                       fprintf (stderr, _("; ignoring override for this key.\n"));
1923                       continue;
1924                     }
1925
1926                   fprintf (stderr, _(" and --strict was specified; exiting.\n"));
1927                   g_key_file_free (key_file);
1928                   g_strfreev (groups);
1929                   g_strfreev (keys);
1930
1931                   return FALSE;
1932                 }
1933
1934               string = g_key_file_get_value (key_file, group, key, NULL);
1935               g_assert (string != NULL);
1936
1937               value = g_variant_parse (state->type, string,
1938                                        NULL, NULL, &error);
1939
1940               if (value == NULL)
1941                 {
1942                   fprintf (stderr, _("error parsing key '%s' in schema '%s' "
1943                                      "as specified in override file '%s': "
1944                                      "%s."),
1945                            key, group, filename, error->message);
1946
1947                   g_clear_error (&error);
1948                   g_free (string);
1949
1950                   if (!strict)
1951                     {
1952                       fprintf (stderr, _("Ignoring override for this key.\n"));
1953                       continue;
1954                     }
1955
1956                   fprintf (stderr, _("--strict was specified; exiting.\n"));
1957                   g_key_file_free (key_file);
1958                   g_strfreev (groups);
1959                   g_strfreev (keys);
1960
1961                   return FALSE;
1962                 }
1963
1964               if (state->minimum)
1965                 {
1966                   if (g_variant_compare (value, state->minimum) < 0 ||
1967                       g_variant_compare (value, state->maximum) > 0)
1968                     {
1969                       fprintf (stderr,
1970                                _("override for key '%s' in schema '%s' in "
1971                                  "override file '%s' is outside the range "
1972                                  "given in the schema"),
1973                                key, group, filename);
1974
1975                       g_variant_unref (value);
1976                       g_free (string);
1977
1978                       if (!strict)
1979                         {
1980                           fprintf (stderr, _("; ignoring override for this key.\n"));
1981                           continue;
1982                         }
1983
1984                       fprintf (stderr, _(" and --strict was specified; exiting.\n"));
1985                       g_key_file_free (key_file);
1986                       g_strfreev (groups);
1987                       g_strfreev (keys);
1988
1989                       return FALSE;
1990                     }
1991                 }
1992
1993               else if (state->strinfo->len)
1994                 {
1995                   if (!is_valid_choices (value, state->strinfo))
1996                     {
1997                       fprintf (stderr,
1998                                _("override for key '%s' in schema '%s' in "
1999                                  "override file '%s' is not in the list "
2000                                  "of valid choices"),
2001                                key, group, filename);
2002
2003                       g_variant_unref (value);
2004                       g_free (string);
2005
2006                       if (!strict)
2007                         {
2008                           fprintf (stderr, _("; ignoring override for this key.\n"));
2009                           continue;
2010                         }
2011
2012                       fprintf (stderr, _(" and --strict was specified; exiting.\n"));
2013                       g_key_file_free (key_file);
2014                       g_strfreev (groups);
2015                       g_strfreev (keys);
2016
2017                       return FALSE;
2018                     }
2019                 }
2020
2021               g_variant_unref (state->default_value);
2022               state->default_value = value;
2023               g_free (string);
2024             }
2025
2026           g_strfreev (keys);
2027         }
2028
2029       g_strfreev (groups);
2030     }
2031
2032   return TRUE;
2033 }
2034
2035 int
2036 main (int argc, char **argv)
2037 {
2038   GError *error = NULL;
2039   GHashTable *table = NULL;
2040   GDir *dir = NULL;
2041   const gchar *file;
2042   const gchar *srcdir;
2043   gboolean show_version_and_exit = FALSE;
2044   gchar *targetdir = NULL;
2045   gchar *target = NULL;
2046   gboolean dry_run = FALSE;
2047   gboolean strict = FALSE;
2048   gchar **schema_files = NULL;
2049   gchar **override_files = NULL;
2050   GOptionContext *context = NULL;
2051   gint retval;
2052   GOptionEntry entries[] = {
2053     { "version", 0, 0, G_OPTION_ARG_NONE, &show_version_and_exit, N_("Show program version and exit"), NULL },
2054     { "targetdir", 0, 0, G_OPTION_ARG_FILENAME, &targetdir, N_("where to store the gschemas.compiled file"), N_("DIRECTORY") },
2055     { "strict", 0, 0, G_OPTION_ARG_NONE, &strict, N_("Abort on any errors in schemas"), NULL },
2056     { "dry-run", 0, 0, G_OPTION_ARG_NONE, &dry_run, N_("Do not write the gschema.compiled file"), NULL },
2057     { "allow-any-name", 0, 0, G_OPTION_ARG_NONE, &allow_any_name, N_("Do not enforce key name restrictions") },
2058
2059     /* These options are only for use in the gschema-compile tests */
2060     { "schema-file", 0, G_OPTION_FLAG_HIDDEN, G_OPTION_ARG_FILENAME_ARRAY, &schema_files, NULL, NULL },
2061     { NULL }
2062   };
2063
2064 #ifdef G_OS_WIN32
2065   gchar *tmp = NULL;
2066 #endif
2067
2068   setlocale (LC_ALL, "");
2069   textdomain (GETTEXT_PACKAGE);
2070
2071 #ifdef G_OS_WIN32
2072   tmp = _glib_get_locale_dir ();
2073   bindtextdomain (GETTEXT_PACKAGE, tmp);
2074 #else
2075   bindtextdomain (GETTEXT_PACKAGE, GLIB_LOCALE_DIR);
2076 #endif
2077
2078 #ifdef HAVE_BIND_TEXTDOMAIN_CODESET
2079   bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
2080 #endif
2081
2082   context = g_option_context_new (N_("DIRECTORY"));
2083   g_option_context_set_translation_domain (context, GETTEXT_PACKAGE);
2084   g_option_context_set_summary (context,
2085     N_("Compile all GSettings schema files into a schema cache.\n"
2086        "Schema files are required to have the extension .gschema.xml,\n"
2087        "and the cache file is called gschemas.compiled."));
2088   g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE);
2089
2090   if (!g_option_context_parse (context, &argc, &argv, &error))
2091     {
2092       fprintf (stderr, "%s\n", error->message);
2093       retval = 1;
2094       goto done;
2095     }
2096
2097   if (show_version_and_exit)
2098     {
2099       g_print (PACKAGE_VERSION "\n");
2100       retval = 0;
2101       goto done;
2102     }
2103
2104   if (!schema_files && argc != 2)
2105     {
2106       fprintf (stderr, _("You should give exactly one directory name\n"));
2107       retval = 1;
2108       goto done;
2109     }
2110
2111   srcdir = argv[1];
2112
2113   target = g_build_filename (targetdir ? targetdir : srcdir, "gschemas.compiled", NULL);
2114
2115   if (!schema_files)
2116     {
2117       GPtrArray *overrides;
2118       GPtrArray *files;
2119
2120       files = g_ptr_array_new ();
2121       overrides = g_ptr_array_new ();
2122
2123       dir = g_dir_open (srcdir, 0, &error);
2124       if (dir == NULL)
2125         {
2126           fprintf (stderr, "%s\n", error->message);
2127
2128           g_ptr_array_unref (files);
2129           g_ptr_array_unref (overrides);
2130
2131           retval = 1;
2132           goto done;
2133         }
2134
2135       while ((file = g_dir_read_name (dir)) != NULL)
2136         {
2137           if (g_str_has_suffix (file, ".gschema.xml") ||
2138               g_str_has_suffix (file, ".enums.xml"))
2139             g_ptr_array_add (files, g_build_filename (srcdir, file, NULL));
2140
2141           else if (g_str_has_suffix (file, ".gschema.override"))
2142             g_ptr_array_add (overrides,
2143                              g_build_filename (srcdir, file, NULL));
2144         }
2145
2146       if (files->len == 0)
2147         {
2148           fprintf (stdout, _("No schema files found: "));
2149
2150           if (g_unlink (target))
2151             fprintf (stdout, _("doing nothing.\n"));
2152
2153           else
2154             fprintf (stdout, _("removed existing output file.\n"));
2155
2156           g_ptr_array_unref (files);
2157           g_ptr_array_unref (overrides);
2158
2159           retval = 0;
2160           goto done;
2161         }
2162       g_ptr_array_sort (files, compare_strings);
2163       g_ptr_array_add (files, NULL);
2164
2165       g_ptr_array_sort (overrides, compare_strings);
2166       g_ptr_array_add (overrides, NULL);
2167
2168       schema_files = (char **) g_ptr_array_free (files, FALSE);
2169       override_files = (gchar **) g_ptr_array_free (overrides, FALSE);
2170     }
2171
2172   if ((table = parse_gschema_files (schema_files, strict)) == NULL)
2173     {
2174       retval = 1;
2175       goto done;
2176     }
2177
2178   if (override_files != NULL &&
2179       !set_overrides (table, override_files, strict))
2180     {
2181       retval = 1;
2182       goto done;
2183     }
2184
2185   if (!dry_run && !write_to_file (table, target, &error))
2186     {
2187       fprintf (stderr, "%s\n", error->message);
2188       retval = 1;
2189       goto done;
2190     }
2191
2192   /* Success. */
2193   retval = 0;
2194
2195 done:
2196   g_clear_error (&error);
2197   g_clear_pointer (&table, g_hash_table_unref);
2198   g_clear_pointer (&dir, g_dir_close);
2199   g_free (targetdir);
2200   g_free (target);
2201   g_strfreev (schema_files);
2202   g_strfreev (override_files);
2203   g_option_context_free (context);
2204
2205 #ifdef G_OS_WIN32
2206   g_free (tmp);
2207 #endif
2208
2209   return retval;
2210 }
2211
2212 /* Epilogue {{{1 */
2213
2214 /* vim:set foldmethod=marker: */