gio/glib-compile-resources.c

   1 /*
   2  * Copyright © 2011 Red Hat, Inc
   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: Alexander Larsson <alexl@redhat.com>
  18  */
  19
  20 #include "config.h"
  21
  22 #include <glib.h>
  23 #include <gstdio.h>
  24 #include <gi18n.h>
  25 #include <gioenums.h>
  26
  27 #include <string.h>
  28 #include <stdio.h>
  29 #include <locale.h>
  30 #include <errno.h>
  31 #ifdef G_OS_UNIX
  32 #include <unistd.h>
  33 #endif
  34 #ifdef G_OS_WIN32
  35 #include <io.h>
  36 #endif
  37
  38 #include <gio/gmemoryoutputstream.h>
  39 #include <gio/gzlibcompressor.h>
  40 #include <gio/gconverteroutputstream.h>
  41
  42 #include <glib.h>
  43 #include "gvdb/gvdb-builder.h"
  44
  45 #include "gconstructor_as_data.h"
  46
  47 #ifdef G_OS_WIN32
  48 #include "glib/glib-private.h"
  49 #endif
  50
  51 typedef struct
  52 {
  53   char *filename;
  54   char *content;
  55   gsize content_size;
  56   gsize size;
  57   guint32 flags;
  58 } FileData;
  59
  60 typedef struct
  61 {
  62   GHashTable *table; /* resource path -> FileData */
  63
  64   gboolean collect_data;
  65
  66   /* per gresource */
  67   char *prefix;
  68
  69   /* per file */
  70   char *alias;
  71   gboolean compressed;
  72   char *preproc_options;
  73
  74   GString *string;  /* non-NULL when accepting text */
  75 } ParseState;
  76
  77 static gchar **sourcedirs = NULL;
  78 static gchar *xmllint = NULL;
  79 static gchar *jsonformat = NULL;
  80 static gchar *gdk_pixbuf_pixdata = NULL;
  81
  82 static void
  83 file_data_free (FileData *data)
  84 {
  85   g_free (data->filename);
  86   g_free (data->content);
  87   g_free (data);
  88 }
  89
  90 static void
  91 start_element (GMarkupParseContext  *context,
  92                const gchar          *element_name,
  93                const gchar         **attribute_names,
  94                const gchar         **attribute_values,
  95                gpointer              user_data,
  96                GError              **error)
  97 {
  98   ParseState *state = user_data;
  99   const GSList *element_stack;
 100   const gchar *container;
 101
 102   element_stack = g_markup_parse_context_get_element_stack (context);
 103   container = element_stack->next ? element_stack->next->data : NULL;
 104
 105 #define COLLECT(first, ...) \
 106   g_markup_collect_attributes (element_name,                                 \
 107                                attribute_names, attribute_values, error,     \
 108                                first, __VA_ARGS__, G_MARKUP_COLLECT_INVALID)
 109 #define OPTIONAL   G_MARKUP_COLLECT_OPTIONAL
 110 #define STRDUP     G_MARKUP_COLLECT_STRDUP
 111 #define STRING     G_MARKUP_COLLECT_STRING
 112 #define BOOL       G_MARKUP_COLLECT_BOOLEAN
 113 #define NO_ATTRS()  COLLECT (G_MARKUP_COLLECT_INVALID, NULL)
 114
 115   if (container == NULL)
 116     {
 117       if (strcmp (element_name, "gresources") == 0)
 118         return;
 119     }
 120   else if (strcmp (container, "gresources") == 0)
 121     {
 122       if (strcmp (element_name, "gresource") == 0)
 123         {
 124           COLLECT (OPTIONAL | STRDUP,
 125                    "prefix", &state->prefix);
 126           return;
 127         }
 128     }
 129   else if (strcmp (container, "gresource") == 0)
 130     {
 131       if (strcmp (element_name, "file") == 0)
 132         {
 133           COLLECT (OPTIONAL | STRDUP, "alias", &state->alias,
 134                    OPTIONAL | BOOL, "compressed", &state->compressed,
 135                    OPTIONAL | STRDUP, "preprocess", &state->preproc_options);
 136           state->string = g_string_new ("");
 137           return;
 138         }
 139     }
 140
 141   if (container)
 142     g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_UNKNOWN_ELEMENT,
 143                  _("Element <%s> not allowed inside <%s>"),
 144                  element_name, container);
 145   else
 146     g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_UNKNOWN_ELEMENT,
 147                  _("Element <%s> not allowed at toplevel"), element_name);
 148
 149 }
 150
 151 static GvdbItem *
 152 get_parent (GHashTable *table,
 153             gchar      *key,
 154             gint        length)
 155 {
 156   GvdbItem *grandparent, *parent;
 157
 158   if (length == 1)
 159     return NULL;
 160
 161   while (key[--length - 1] != '/');
 162   key[length] = '\0';
 163
 164   parent = g_hash_table_lookup (table, key);
 165
 166   if (parent == NULL)
 167     {
 168       parent = gvdb_hash_table_insert (table, key);
 169
 170       grandparent = get_parent (table, key, length);
 171
 172       if (grandparent != NULL)
 173         gvdb_item_set_parent (parent, grandparent);
 174     }
 175
 176   return parent;
 177 }
 178
 179 static gchar *
 180 find_file (const gchar *filename)
 181 {
 182   guint i;
 183   gchar *real_file;
 184   gboolean exists;
 185
 186   if (g_path_is_absolute (filename))
 187     return g_strdup (filename);
 188
 189   /* search all the sourcedirs for the correct files in order */
 190   for (i = 0; sourcedirs[i] != NULL; i++)
 191     {
 192         real_file = g_build_path ("/", sourcedirs[i], filename, NULL);
 193         exists = g_file_test (real_file, G_FILE_TEST_EXISTS);
 194         if (exists)
 195           return real_file;
 196         g_free (real_file);
 197     }
 198     return NULL;
 199 }
 200
 201 static void
 202 end_element (GMarkupParseContext  *context,
 203              const gchar          *element_name,
 204              gpointer              user_data,
 205              GError              **error)
 206 {
 207   ParseState *state = user_data;
 208   GError *my_error = NULL;
 209
 210   if (strcmp (element_name, "gresource") == 0)
 211     {
 212       g_free (state->prefix);
 213       state->prefix = NULL;
 214     }
 215
 216   else if (strcmp (element_name, "file") == 0)
 217     {
 218       gchar *file;
 219       gchar *real_file = NULL;
 220       gchar *key;
 221       FileData *data = NULL;
 222       char *tmp_file = NULL;
 223
 224       file = state->string->str;
 225       key = file;
 226       if (state->alias)
 227         key = state->alias;
 228
 229       if (state->prefix)
 230         key = g_build_path ("/", "/", state->prefix, key, NULL);
 231       else
 232         key = g_build_path ("/", "/", key, NULL);
 233
 234       if (g_hash_table_lookup (state->table, key) != NULL)
 235         {
 236           g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
 237                        _("File %s appears multiple times in the resource"),
 238                        key);
 239           return;
 240         }
 241
 242       if (sourcedirs != NULL)
 243         {
 244           real_file = find_file (file);
 245           if (real_file == NULL && state->collect_data)
 246             {
 247                 g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
 248                              _("Failed to locate “%s” in any source directory"), file);
 249                 return;
 250             }
 251         }
 252       else
 253         {
 254           gboolean exists;
 255           exists = g_file_test (file, G_FILE_TEST_EXISTS);
 256           if (!exists && state->collect_data)
 257             {
 258               g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
 259                            _("Failed to locate “%s” in current directory"), file);
 260               return;
 261             }
 262         }
 263
 264       if (real_file == NULL)
 265         real_file = g_strdup (file);
 266
 267       data = g_new0 (FileData, 1);
 268       data->filename = g_strdup (real_file);
 269       if (!state->collect_data)
 270         goto done;
 271
 272       if (state->preproc_options)
 273         {
 274           gchar **options;
 275           guint i;
 276           gboolean xml_stripblanks = FALSE;
 277           gboolean json_stripblanks = FALSE;
 278           gboolean to_pixdata = FALSE;
 279
 280           options = g_strsplit (state->preproc_options, ",", -1);
 281
 282           for (i = 0; options[i]; i++)
 283             {
 284               if (!strcmp (options[i], "xml-stripblanks"))
 285                 xml_stripblanks = TRUE;
 286               else if (!strcmp (options[i], "to-pixdata"))
 287                 to_pixdata = TRUE;
 288               else if (!strcmp (options[i], "json-stripblanks"))
 289                 json_stripblanks = TRUE;
 290               else
 291                 {
 292                   g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
 293                                _("Unknown processing option “%s”"), options[i]);
 294                   g_strfreev (options);
 295                   goto cleanup;
 296                 }
 297             }
 298           g_strfreev (options);
 299
 300           if (xml_stripblanks)
 301             {
 302               /* This is not fatal: pretty-printed XML is still valid XML */
 303               if (xmllint == NULL)
 304                 {
 305                   static gboolean xmllint_warned = FALSE;
 306
 307                   if (!xmllint_warned)
 308                     {
 309                       /* Translators: the first %s is a gresource XML attribute,
 310                        * the second %s is an environment variable, and the third
 311                        * %s is a command line tool
 312                        */
 313                       char *warn = g_strdup_printf (_("%s preprocessing requested, but %s is not set, and %s is not in PATH"),
 314                                                     "xml-stripblanks",
 315                                                     "XMLLINT",
 316                                                     "xmllint");
 317                       g_printerr ("%s\n", warn);
 318                       g_free (warn);
 319
 320                       /* Only warn once */
 321                       xmllint_warned = TRUE;
 322                     }
 323                 }
 324               else
 325                 {
 326                   GSubprocess *proc;
 327                   int fd;
 328
 329                   fd = g_file_open_tmp ("resource-XXXXXXXX", &tmp_file, error);
 330                   if (fd < 0)
 331                     goto cleanup;
 332
 333                   close (fd);
 334
 335                   proc = g_subprocess_new (G_SUBPROCESS_FLAGS_STDOUT_SILENCE, error,
 336                                            xmllint, "--nonet", "--noblanks", "--output", tmp_file, real_file, NULL);
 337                   g_free (real_file);
 338                   real_file = NULL;
 339
 340                   if (!proc)
 341                     goto cleanup;
 342
 343                   if (!g_subprocess_wait_check (proc, NULL, error))
 344                     {
 345                       g_object_unref (proc);
 346                       goto cleanup;
 347                     }
 348
 349                   g_object_unref (proc);
 350
 351                   real_file = g_strdup (tmp_file);
 352                 }
 353             }
 354
 355           if (json_stripblanks)
 356             {
 357               /* As above, this is not fatal: pretty-printed JSON is still
 358                * valid JSON
 359                */
 360               if (jsonformat == NULL)
 361                 {
 362                   static gboolean jsonformat_warned = FALSE;
 363
 364                   if (!jsonformat_warned)
 365                     {
 366                       /* Translators: the first %s is a gresource XML attribute,
 367                        * the second %s is an environment variable, and the third
 368                        * %s is a command line tool
 369                        */
 370                       char *warn = g_strdup_printf (_("%s preprocessing requested, but %s is not set, and %s is not in PATH"),
 371                                                     "json-stripblanks",
 372                                                     "JSON_GLIB_FORMAT",
 373                                                     "json-glib-format");
 374                       g_printerr ("%s\n", warn);
 375                       g_free (warn);
 376
 377                       /* Only warn once */
 378                       jsonformat_warned = TRUE;
 379                     }
 380                 }
 381               else
 382                 {
 383                   GSubprocess *proc;
 384                   int fd;
 385
 386                   fd = g_file_open_tmp ("resource-XXXXXXXX", &tmp_file, error);
 387                   if (fd < 0)
 388                     goto cleanup;
 389
 390                   close (fd);
 391
 392                   proc = g_subprocess_new (G_SUBPROCESS_FLAGS_STDOUT_SILENCE, error,
 393                                            jsonformat, "--output", tmp_file, real_file, NULL);
 394                   g_free (real_file);
 395                   real_file = NULL;
 396
 397                   if (!proc)
 398                     goto cleanup;
 399
 400                   if (!g_subprocess_wait_check (proc, NULL, error))
 401                     {
 402                       g_object_unref (proc);
 403                       goto cleanup;
 404                     }
 405
 406                   g_object_unref (proc);
 407
 408                   real_file = g_strdup (tmp_file);
 409                 }
 410             }
 411
 412           if (to_pixdata)
 413             {
 414               GSubprocess *proc;
 415               int fd;
 416
 417               /* This is a fatal error: if to-pixdata is used it means that
 418                * the code loading the GResource expects a specific data format
 419                */
 420               if (gdk_pixbuf_pixdata == NULL)
 421                 {
 422                   /* Translators: the first %s is a gresource XML attribute,
 423                    * the second %s is an environment variable, and the third
 424                    * %s is a command line tool
 425                    */
 426                   g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
 427                                _("%s preprocessing requested, but %s is not set, and %s is not in PATH"),
 428                                "to-pixdata",
 429                                "GDK_PIXBUF_PIXDATA",
 430                                "gdk-pixbuf-pixdata");
 431                   goto cleanup;
 432                 }
 433
 434               fd = g_file_open_tmp ("resource-XXXXXXXX", &tmp_file, error);
 435               if (fd < 0)
 436                 goto cleanup;
 437
 438               close (fd);
 439
 440               proc = g_subprocess_new (G_SUBPROCESS_FLAGS_STDOUT_SILENCE, error,
 441                                        gdk_pixbuf_pixdata, real_file, tmp_file, NULL);
 442               g_free (real_file);
 443               real_file = NULL;
 444
 445               if (!g_subprocess_wait_check (proc, NULL, error))
 446                 {
 447                   g_object_unref (proc);
 448                   goto cleanup;
 449                 }
 450
 451               g_object_unref (proc);
 452
 453               real_file = g_strdup (tmp_file);
 454             }
 455         }
 456
 457       if (!g_file_get_contents (real_file, &data->content, &data->size, &my_error))
 458         {
 459           g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
 460                        _("Error reading file %s: %s"),
 461                        real_file, my_error->message);
 462           g_clear_error (&my_error);
 463           goto cleanup;
 464         }
 465       /* Include zero termination in content_size for uncompressed files (but not in size) */
 466       data->content_size = data->size + 1;
 467
 468       if (state->compressed)
 469         {
 470           GOutputStream *out = g_memory_output_stream_new (NULL, 0, g_realloc, g_free);
 471           GZlibCompressor *compressor =
 472             g_zlib_compressor_new (G_ZLIB_COMPRESSOR_FORMAT_ZLIB, 9);
 473           GOutputStream *out2 = g_converter_output_stream_new (out, G_CONVERTER (compressor));
 474
 475           if (!g_output_stream_write_all (out2, data->content, data->size,
 476                                           NULL, NULL, NULL) ||
 477               !g_output_stream_close (out2, NULL, NULL))
 478             {
 479               g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
 480                            _("Error compressing file %s"),
 481                            real_file);
 482               goto cleanup;
 483             }
 484
 485           g_free (data->content);
 486           data->content_size = g_memory_output_stream_get_size (G_MEMORY_OUTPUT_STREAM (out));
 487           data->content = g_memory_output_stream_steal_data (G_MEMORY_OUTPUT_STREAM (out));
 488
 489           g_object_unref (compressor);
 490           g_object_unref (out);
 491           g_object_unref (out2);
 492
 493           data->flags |= G_RESOURCE_FLAGS_COMPRESSED;
 494         }
 495
 496 done:
 497       g_hash_table_insert (state->table, key, data);
 498       data = NULL;
 499
 500     cleanup:
 501       /* Cleanup */
 502
 503       g_free (state->alias);
 504       state->alias = NULL;
 505       g_string_free (state->string, TRUE);
 506       state->string = NULL;
 507       g_free (state->preproc_options);
 508       state->preproc_options = NULL;
 509
 510       g_free (real_file);
 511
 512       if (tmp_file)
 513         {
 514           unlink (tmp_file);
 515           g_free (tmp_file);
 516         }
 517
 518       if (data != NULL)
 519         file_data_free (data);
 520     }
 521 }
 522
 523 static void
 524 text (GMarkupParseContext  *context,
 525       const gchar          *text,
 526       gsize                 text_len,
 527       gpointer              user_data,
 528       GError              **error)
 529 {
 530   ParseState *state = user_data;
 531   gsize i;
 532
 533   for (i = 0; i < text_len; i++)
 534     if (!g_ascii_isspace (text[i]))
 535       {
 536         if (state->string)
 537           g_string_append_len (state->string, text, text_len);
 538
 539         else
 540           g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
 541                        _("text may not appear inside <%s>"),
 542                        g_markup_parse_context_get_element (context));
 543
 544         break;
 545       }
 546 }
 547
 548 static GHashTable *
 549 parse_resource_file (const gchar *filename,
 550                      gboolean     collect_data,
 551                      GHashTable  *files)
 552 {
 553   GMarkupParser parser = { start_element, end_element, text };
 554   ParseState state = { 0, };
 555   GMarkupParseContext *context;
 556   GError *error = NULL;
 557   gchar *contents;
 558   GHashTable *table = NULL;
 559   gsize size;
 560
 561   if (!g_file_get_contents (filename, &contents, &size, &error))
 562     {
 563       g_printerr ("%s\n", error->message);
 564       g_clear_error (&error);
 565       return NULL;
 566     }
 567
 568   state.collect_data = collect_data;
 569   state.table = g_hash_table_ref (files);
 570
 571   context = g_markup_parse_context_new (&parser,
 572                                         G_MARKUP_TREAT_CDATA_AS_TEXT |
 573                                         G_MARKUP_PREFIX_ERROR_POSITION,
 574                                         &state, NULL);
 575
 576   if (!g_markup_parse_context_parse (context, contents, size, &error) ||
 577       !g_markup_parse_context_end_parse (context, &error))
 578     {
 579       g_printerr ("%s: %s.\n", filename, error->message);
 580       g_clear_error (&error);
 581     }
 582   else
 583     {
 584       GHashTableIter iter;
 585       const char *key;
 586       char *mykey;
 587       gsize key_len;
 588       FileData *data;
 589       GVariant *v_data;
 590       GVariantBuilder builder;
 591       GvdbItem *item;
 592
 593       table = gvdb_hash_table_new (NULL, NULL);
 594
 595       g_hash_table_iter_init (&iter, state.table);
 596       while (g_hash_table_iter_next (&iter, (gpointer *)&key, (gpointer *)&data))
 597         {
 598           key_len = strlen (key);
 599           mykey = g_strdup (key);
 600
 601           item = gvdb_hash_table_insert (table, key);
 602           gvdb_item_set_parent (item,
 603                                 get_parent (table, mykey, key_len));
 604
 605           g_free (mykey);
 606
 607           g_variant_builder_init (&builder, G_VARIANT_TYPE ("(uuay)"));
 608
 609           g_variant_builder_add (&builder, "u", data->size); /* Size */
 610           g_variant_builder_add (&builder, "u", data->flags); /* Flags */
 611
 612           v_data = g_variant_new_from_data (G_VARIANT_TYPE("ay"),
 613                                             data->content, data->content_size, TRUE,
 614                                             g_free, data->content);
 615           g_variant_builder_add_value (&builder, v_data);
 616           data->content = NULL; /* Take ownership */
 617
 618           gvdb_item_set_value (item,
 619                                g_variant_builder_end (&builder));
 620         }
 621     }
 622
 623   g_hash_table_unref (state.table);
 624   g_markup_parse_context_free (context);
 625   g_free (contents);
 626
 627   return table;
 628 }
 629
 630 static gboolean
 631 write_to_file (GHashTable   *table,
 632                const gchar  *filename,
 633                GError      **error)
 634 {
 635   gboolean success;
 636
 637   success = gvdb_table_write_contents (table, filename,
 638                                        G_BYTE_ORDER != G_LITTLE_ENDIAN,
 639                                        error);
 640
 641   return success;
 642 }
 643
 644 static gboolean
 645 extension_in_set (const char *str,
 646                   ...)
 647 {
 648   va_list list;
 649   const char *ext, *value;
 650   gboolean rv = FALSE;
 651
 652   ext = strrchr (str, '.');
 653   if (ext == NULL)
 654     return FALSE;
 655
 656   ext++;
 657   va_start (list, str);
 658   while ((value = va_arg (list, const char *)) != NULL)
 659     {
 660       if (g_ascii_strcasecmp (ext, value) != 0)
 661         continue;
 662
 663       rv = TRUE;
 664       break;
 665     }
 666
 667   va_end (list);
 668   return rv;
 669 }
 670
 671 /*
 672  * We must escape any characters that `make` finds significant.
 673  * This is largely a duplicate of the logic in gcc's `mkdeps.c:munge()`.
 674  */
 675 static char *
 676 escape_makefile_string (const char *string)
 677 {
 678   GString *str;
 679   const char *p, *q;
 680
 681   str = g_string_sized_new (strlen (string) + 1);
 682   for (p = string; *p != '\0'; ++p)
 683     {
 684       switch (*p)
 685         {
 686         case ' ':
 687         case '\t':
 688           /* GNU make uses a weird quoting scheme for white space.
 689              A space or tab preceded by 2N+1 backslashes represents
 690              N backslashes followed by space; a space or tab
 691              preceded by 2N backslashes represents N backslashes at
 692              the end of a file name; and backslashes in other
 693              contexts should not be doubled.  */
 694           for (q = p - 1; string <= q && *q == '\\';  q--)
 695             g_string_append_c (str, '\\');
 696           g_string_append_c (str, '\\');
 697           break;
 698
 699         case '$':
 700           g_string_append_c (str, '$');
 701           break;
 702
 703         case '#':
 704           g_string_append_c (str, '\\');
 705           break;
 706         }
 707       g_string_append_c (str, *p);
 708     }
 709
 710   return g_string_free (str, FALSE);
 711 }
 712
 713 int
 714 main (int argc, char **argv)
 715 {
 716   GError *error;
 717   GHashTable *table;
 718   GHashTable *files;
 719   gchar *srcfile;
 720   gboolean show_version_and_exit = FALSE;
 721   gchar *target = NULL;
 722   gchar *binary_target = NULL;
 723   gboolean generate_automatic = FALSE;
 724   gboolean generate_source = FALSE;
 725   gboolean generate_header = FALSE;
 726   gboolean manual_register = FALSE;
 727   gboolean internal = FALSE;
 728   gboolean generate_dependencies = FALSE;
 729   gboolean generate_phony_targets = FALSE;
 730   char *dependency_file = NULL;
 731   char *c_name = NULL;
 732   char *c_name_no_underscores;
 733   const char *linkage = "extern";
 734   GOptionContext *context;
 735   GOptionEntry entries[] = {
 736     { "version", 0, 0, G_OPTION_ARG_NONE, &show_version_and_exit, N_("Show program version and exit"), NULL },
 737     { "target", 0, 0, G_OPTION_ARG_FILENAME, &target, N_("Name of the output file"), N_("FILE") },
 738     { "sourcedir", 0, 0, G_OPTION_ARG_FILENAME_ARRAY, &sourcedirs, N_("The directories to load files referenced in FILE from (default: current directory)"), N_("DIRECTORY") },
 739     { "generate", 0, 0, G_OPTION_ARG_NONE, &generate_automatic, N_("Generate output in the format selected for by the target filename extension"), NULL },
 740     { "generate-header", 0, 0, G_OPTION_ARG_NONE, &generate_header, N_("Generate source header"), NULL },
 741     { "generate-source", 0, 0, G_OPTION_ARG_NONE, &generate_source, N_("Generate source code used to link in the resource file into your code"), NULL },
 742     { "generate-dependencies", 0, 0, G_OPTION_ARG_NONE, &generate_dependencies, N_("Generate dependency list"), NULL },
 743     { "dependency-file", 0, 0, G_OPTION_ARG_FILENAME, &dependency_file, N_("Name of the dependency file to generate"), N_("FILE") },
 744     { "generate-phony-targets", 0, 0, G_OPTION_ARG_NONE, &generate_phony_targets, N_("Include phony targets in the generated dependency file"), NULL },
 745     { "manual-register", 0, 0, G_OPTION_ARG_NONE, &manual_register, N_("Don’t automatically create and register resource"), NULL },
 746     { "internal", 0, 0, G_OPTION_ARG_NONE, &internal, N_("Don’t export functions; declare them G_GNUC_INTERNAL"), NULL },
 747     { "c-name", 0, 0, G_OPTION_ARG_STRING, &c_name, N_("C identifier name used for the generated source code"), NULL },
 748     { NULL }
 749   };
 750
 751 #ifdef G_OS_WIN32
 752   gchar *tmp;
 753 #endif
 754
 755   setlocale (LC_ALL, "");
 756   textdomain (GETTEXT_PACKAGE);
 757
 758 #ifdef G_OS_WIN32
 759   tmp = _glib_get_locale_dir ();
 760   bindtextdomain (GETTEXT_PACKAGE, tmp);
 761   g_free (tmp);
 762 #else
 763   bindtextdomain (GETTEXT_PACKAGE, GLIB_LOCALE_DIR);
 764 #endif
 765
 766 #ifdef HAVE_BIND_TEXTDOMAIN_CODESET
 767   bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
 768 #endif
 769
 770   context = g_option_context_new (N_("FILE"));
 771   g_option_context_set_translation_domain (context, GETTEXT_PACKAGE);
 772   g_option_context_set_summary (context,
 773     N_("Compile a resource specification into a resource file.\n"
 774        "Resource specification files have the extension .gresource.xml,\n"
 775        "and the resource file have the extension called .gresource."));
 776   g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE);
 777
 778   error = NULL;
 779   if (!g_option_context_parse (context, &argc, &argv, &error))
 780     {
 781       g_printerr ("%s\n", error->message);
 782       return 1;
 783     }
 784
 785   g_option_context_free (context);
 786
 787   if (show_version_and_exit)
 788     {
 789       g_print (PACKAGE_VERSION "\n");
 790       return 0;
 791     }
 792
 793   if (argc != 2)
 794     {
 795       g_printerr (_("You should give exactly one file name\n"));
 796       g_free (c_name);
 797       return 1;
 798     }
 799
 800   if (internal)
 801     linkage = "G_GNUC_INTERNAL";
 802
 803   srcfile = argv[1];
 804
 805   xmllint = g_strdup (g_getenv ("XMLLINT"));
 806   if (xmllint == NULL)
 807     xmllint = g_find_program_in_path ("xmllint");
 808
 809   jsonformat = g_strdup (g_getenv ("JSON_GLIB_FORMAT"));
 810   if (jsonformat == NULL)
 811     jsonformat = g_find_program_in_path ("json-glib-format");
 812
 813   gdk_pixbuf_pixdata = g_strdup (g_getenv ("GDK_PIXBUF_PIXDATA"));
 814   if (gdk_pixbuf_pixdata == NULL)
 815     gdk_pixbuf_pixdata = g_find_program_in_path ("gdk-pixbuf-pixdata");
 816
 817   if (target == NULL)
 818     {
 819       char *dirname = g_path_get_dirname (srcfile);
 820       char *base = g_path_get_basename (srcfile);
 821       char *target_basename;
 822       if (g_str_has_suffix (base, ".xml"))
 823         base[strlen(base) - strlen (".xml")] = 0;
 824
 825       if (generate_source)
 826         {
 827           if (g_str_has_suffix (base, ".gresource"))
 828             base[strlen(base) - strlen (".gresource")] = 0;
 829           target_basename = g_strconcat (base, ".c", NULL);
 830         }
 831       else if (generate_header)
 832         {
 833           if (g_str_has_suffix (base, ".gresource"))
 834             base[strlen(base) - strlen (".gresource")] = 0;
 835           target_basename = g_strconcat (base, ".h", NULL);
 836         }
 837       else
 838         {
 839           if (g_str_has_suffix (base, ".gresource"))
 840             target_basename = g_strdup (base);
 841           else
 842             target_basename = g_strconcat (base, ".gresource", NULL);
 843         }
 844
 845       target = g_build_filename (dirname, target_basename, NULL);
 846       g_free (target_basename);
 847       g_free (dirname);
 848       g_free (base);
 849     }
 850   else if (generate_automatic)
 851     {
 852       if (extension_in_set (target, "c", "cc", "cpp", "cxx", "c++", NULL))
 853         generate_source = TRUE;
 854       else if (extension_in_set (target, "h", "hh", "hpp", "hxx", "h++", NULL))
 855         generate_header = TRUE;
 856       else if (extension_in_set (target, "gresource", NULL))
 857         { }
 858     }
 859
 860   files = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, (GDestroyNotify)file_data_free);
 861
 862   if ((table = parse_resource_file (srcfile, !generate_dependencies, files)) == NULL)
 863     {
 864       g_free (target);
 865       g_free (c_name);
 866       g_hash_table_unref (files);
 867       return 1;
 868     }
 869
 870   /* This can be used in the same invocation
 871      as other generate commands */
 872   if (dependency_file != NULL)
 873     {
 874       /* Generate a .d file that describes the dependencies for
 875        * build tools, gcc -M -MF style */
 876       GString *dep_string;
 877       GHashTableIter iter;
 878       gpointer key, data;
 879       FileData *file_data;
 880       char *escaped;
 881
 882       g_hash_table_iter_init (&iter, files);
 883
 884       dep_string = g_string_new (NULL);
 885       escaped = escape_makefile_string (srcfile);
 886       g_string_printf (dep_string, "%s:", escaped);
 887       g_free (escaped);
 888
 889       /* First rule: foo.xml: resource1 resource2.. */
 890       while (g_hash_table_iter_next (&iter, &key, &data))
 891         {
 892           file_data = data;
 893           if (!g_str_equal (file_data->filename, srcfile))
 894             {
 895               escaped = escape_makefile_string (file_data->filename);
 896               g_string_append_printf (dep_string, " %s", escaped);
 897               g_free (escaped);
 898             }
 899         }
 900
 901       g_string_append (dep_string, "\n");
 902
 903       /* Optionally include phony targets as it silences `make` but
 904        * isn't supported on `ninja` at the moment. See also: `gcc -MP`
 905        */
 906       if (generate_phony_targets)
 907         {
 908                                         g_string_append (dep_string, "\n");
 909
 910           /* One rule for every resource: resourceN: */
 911           g_hash_table_iter_init (&iter, files);
 912           while (g_hash_table_iter_next (&iter, &key, &data))
 913             {
 914               file_data = data;
 915               if (!g_str_equal (file_data->filename, srcfile))
 916                 {
 917                   escaped = escape_makefile_string (file_data->filename);
 918                   g_string_append_printf (dep_string, "%s:\n\n", escaped);
 919                   g_free (escaped);
 920                 }
 921             }
 922         }
 923
 924       if (g_str_equal (dependency_file, "-"))
 925         {
 926           g_print ("%s\n", dep_string->str);
 927         }
 928       else
 929         {
 930           if (!g_file_set_contents (dependency_file, dep_string->str, dep_string->len, &error))
 931             {
 932               g_printerr ("Error writing dependency file: %s\n", error->message);
 933               g_string_free (dep_string, TRUE);
 934               g_free (dependency_file);
 935               g_error_free (error);
 936               g_hash_table_unref (files);
 937               return 1;
 938             }
 939         }
 940
 941       g_string_free (dep_string, TRUE);
 942       g_free (dependency_file);
 943     }
 944
 945   if (generate_dependencies)
 946     {
 947       GHashTableIter iter;
 948       gpointer key, data;
 949       FileData *file_data;
 950
 951       g_hash_table_iter_init (&iter, files);
 952
 953       /* Generate list of files for direct use as dependencies in a Makefile */
 954       while (g_hash_table_iter_next (&iter, &key, &data))
 955         {
 956           file_data = data;
 957           g_print ("%s\n", file_data->filename);
 958         }
 959     }
 960   else if (generate_source || generate_header)
 961     {
 962       if (generate_source)
 963         {
 964           int fd = g_file_open_tmp (NULL, &binary_target, NULL);
 965           if (fd == -1)
 966             {
 967               g_printerr ("Can't open temp file\n");
 968               g_free (c_name);
 969               g_hash_table_unref (files);
 970               return 1;
 971             }
 972           close (fd);
 973         }
 974
 975       if (c_name == NULL)
 976         {
 977           char *base = g_path_get_basename (srcfile);
 978           GString *s;
 979           char *dot;
 980           int i;
 981
 982           /* Remove extensions */
 983           dot = strchr (base, '.');
 984           if (dot)
 985             *dot = 0;
 986
 987           s = g_string_new ("");
 988
 989           for (i = 0; base[i] != 0; i++)
 990             {
 991               const char *first = G_CSET_A_2_Z G_CSET_a_2_z "_";
 992               const char *rest = G_CSET_A_2_Z G_CSET_a_2_z G_CSET_DIGITS "_";
 993               if (strchr ((i == 0) ? first : rest, base[i]) != NULL)
 994                 g_string_append_c (s, base[i]);
 995               else if (base[i] == '-')
 996                 g_string_append_c (s, '_');
 997
 998             }
 999
1000           c_name = g_string_free (s, FALSE);
1001         }
1002     }
1003   else
1004     binary_target = g_strdup (target);
1005
1006   c_name_no_underscores = c_name;
1007   while (c_name_no_underscores && *c_name_no_underscores == '_')
1008     c_name_no_underscores++;
1009
1010   if (binary_target != NULL &&
1011       !write_to_file (table, binary_target, &error))
1012     {
1013       g_printerr ("%s\n", error->message);
1014       g_free (target);
1015       g_free (c_name);
1016       g_hash_table_unref (files);
1017       return 1;
1018     }
1019
1020   if (generate_header)
1021     {
1022       FILE *file;
1023
1024       file = fopen (target, "w");
1025       if (file == NULL)
1026         {
1027           g_printerr ("can't write to file %s", target);
1028           g_free (c_name);
1029           g_hash_table_unref (files);
1030           return 1;
1031         }
1032
1033       g_fprintf (file,
1034                "#ifndef __RESOURCE_%s_H__\n"
1035                "#define __RESOURCE_%s_H__\n"
1036                "\n"
1037                "#include <gio/gio.h>\n"
1038                "\n"
1039                "%s GResource *%s_get_resource (void);\n",
1040                c_name, c_name, linkage, c_name);
1041
1042       if (manual_register)
1043         g_fprintf (file,
1044                  "\n"
1045                  "%s void %s_register_resource (void);\n"
1046                  "%s void %s_unregister_resource (void);\n"
1047                  "\n",
1048                  linkage, c_name, linkage, c_name);
1049
1050       g_fprintf (file,
1051                "#endif\n");
1052
1053       fclose (file);
1054     }
1055   else if (generate_source)
1056     {
1057       FILE *file;
1058       guint8 *data;
1059       gsize data_size;
1060       gsize i;
1061
1062       if (!g_file_get_contents (binary_target, (char **)&data,
1063                                 &data_size, NULL))
1064         {
1065           g_printerr ("can't read back temporary file");
1066           g_free (c_name);
1067           g_hash_table_unref (files);
1068           return 1;
1069         }
1070       g_unlink (binary_target);
1071
1072       file = fopen (target, "w");
1073       if (file == NULL)
1074         {
1075           g_printerr ("can't write to file %s", target);
1076           g_free (c_name);
1077           g_hash_table_unref (files);
1078           return 1;
1079         }
1080
1081       g_fprintf (file,
1082                "#include <gio/gio.h>\n"
1083                "\n"
1084                "#if defined (__ELF__) && ( __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 6))\n"
1085                "# define SECTION __attribute__ ((section (\".gresource.%s\"), aligned (8)))\n"
1086                "#else\n"
1087                "# define SECTION\n"
1088                "#endif\n"
1089                "\n"
1090                "static const SECTION union { const guint8 data[%"G_GSIZE_FORMAT"]; const double alignment; void * const ptr;}  %s_resource_data = { {\n",
1091                c_name_no_underscores, data_size, c_name);
1092
1093       for (i = 0; i < data_size; i++) {
1094         if (i % 8 == 0)
1095           g_fprintf (file, "  ");
1096         g_fprintf (file, "0x%2.2x", (int)data[i]);
1097         if (i != data_size - 1)
1098           g_fprintf (file, ", ");
1099         if ((i % 8 == 7) || (i == data_size - 1))
1100           g_fprintf (file, "\n");
1101       }
1102
1103       g_fprintf (file, "} };\n");
1104
1105       g_fprintf (file,
1106                "\n"
1107                "static GStaticResource static_resource = { %s_resource_data.data, sizeof (%s_resource_data.data), NULL, NULL, NULL };\n"
1108                "%s GResource *%s_get_resource (void);\n"
1109                "GResource *%s_get_resource (void)\n"
1110                "{\n"
1111                "  return g_static_resource_get_resource (&static_resource);\n"
1112                "}\n",
1113                c_name, c_name, linkage, c_name, c_name);
1114
1115
1116       if (manual_register)
1117         {
1118           g_fprintf (file,
1119                    "\n"
1120                    "%s void %s_unregister_resource (void);\n"
1121                    "void %s_unregister_resource (void)\n"
1122                    "{\n"
1123                    "  g_static_resource_fini (&static_resource);\n"
1124                    "}\n"
1125                    "\n"
1126                    "%s void %s_register_resource (void);\n"
1127                    "void %s_register_resource (void)\n"
1128                    "{\n"
1129                    "  g_static_resource_init (&static_resource);\n"
1130                    "}\n",
1131                    linkage, c_name, c_name, linkage, c_name, c_name);
1132         }
1133       else
1134         {
1135           g_fprintf (file, "%s", gconstructor_code);
1136           g_fprintf (file,
1137                    "\n"
1138                    "#ifdef G_HAS_CONSTRUCTORS\n"
1139                    "\n"
1140                    "#ifdef G_DEFINE_CONSTRUCTOR_NEEDS_PRAGMA\n"
1141                    "#pragma G_DEFINE_CONSTRUCTOR_PRAGMA_ARGS(resource_constructor)\n"
1142                    "#endif\n"
1143                    "G_DEFINE_CONSTRUCTOR(resource_constructor)\n"
1144                    "#ifdef G_DEFINE_DESTRUCTOR_NEEDS_PRAGMA\n"
1145                    "#pragma G_DEFINE_DESTRUCTOR_PRAGMA_ARGS(resource_destructor)\n"
1146                    "#endif\n"
1147                    "G_DEFINE_DESTRUCTOR(resource_destructor)\n"
1148                    "\n"
1149                    "#else\n"
1150                    "#warning \"Constructor not supported on this compiler, linking in resources will not work\"\n"
1151                    "#endif\n"
1152                    "\n"
1153                    "static void resource_constructor (void)\n"
1154                    "{\n"
1155                    "  g_static_resource_init (&static_resource);\n"
1156                    "}\n"
1157                    "\n"
1158                    "static void resource_destructor (void)\n"
1159                    "{\n"
1160                    "  g_static_resource_fini (&static_resource);\n"
1161                    "}\n");
1162         }
1163
1164       fclose (file);
1165
1166       g_free (data);
1167     }
1168
1169   g_free (binary_target);
1170   g_free (target);
1171   g_hash_table_destroy (table);
1172   g_free (xmllint);
1173   g_free (jsonformat);
1174   g_free (c_name);
1175   g_hash_table_unref (files);
1176
1177   return 0;
1178 }