gettext-tools/src/msgfmt.c

/* Converts Uniforum style .po files to binary .mo files
   Copyright (C) 1995-1998, 2000-2007, 2009-2010, 2012, 2014-2016, 2018-2020 Free Software
   Foundation, Inc.
   Written by Ulrich Drepper <drepper@gnu.ai.mit.edu>, April 1995.

   This program is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <https://www.gnu.org/licenses/>.  */

#ifdef HAVE_CONFIG_H
# include <config.h>
#endif

#include <ctype.h>
#include <getopt.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <locale.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <assert.h>

#include "noreturn.h"
#include "closeout.h"
#include "str-list.h"
#include "dir-list.h"
#include "error.h"
#include "error-progname.h"
#include "progname.h"
#include "relocatable.h"
#include "basename-lgpl.h"
#include "xerror.h"
#include "xvasprintf.h"
#include "xalloc.h"
#include "msgfmt.h"
#include "write-mo.h"
#include "write-java.h"
#include "write-csharp.h"
#include "write-resources.h"
#include "write-tcl.h"
#include "write-qt.h"
#include "write-desktop.h"
#include "write-xml.h"
#include "propername.h"
#include "message.h"
#include "open-catalog.h"
#include "read-catalog.h"
#include "read-po.h"
#include "read-properties.h"
#include "read-stringtable.h"
#include "read-desktop.h"
#include "po-charset.h"
#include "msgl-check.h"
#include "msgl-iconv.h"
#include "concat-filename.h"
#include "its.h"
#include "locating-rule.h"
#include "search-path.h"
#include "gettext.h"

#define _(str) gettext (str)

#define SIZEOF(a) (sizeof(a) / sizeof(a[0]))

/* Contains exit status for case in which no premature exit occurs.  */
static int exit_status;

/* If true include even fuzzy translations in output file.  */
static bool include_fuzzies = false;

/* If true include even untranslated messages in output file.  */
static bool include_untranslated = false;

/* Specifies name of the output file.  */
static const char *output_file_name;

/* Java mode output file specification.  */
static bool java_mode;
static bool assume_java2;
static const char *java_resource_name;
static const char *java_locale_name;
static const char *java_class_directory;
static bool java_output_source;

/* C# mode output file specification.  */
static bool csharp_mode;
static const char *csharp_resource_name;
static const char *csharp_locale_name;
static const char *csharp_base_directory;

/* C# resources mode output file specification.  */
static bool csharp_resources_mode;

/* Tcl mode output file specification.  */
static bool tcl_mode;
static const char *tcl_locale_name;
static const char *tcl_base_directory;

/* Qt mode output file specification.  */
static bool qt_mode;

/* Desktop Entry mode output file specification.  */
static bool desktop_mode;
static const char *desktop_locale_name;
static const char *desktop_template_name;
static const char *desktop_base_directory;
static hash_table desktop_keywords;
static bool desktop_default_keywords = true;

/* XML mode output file specification.  */
static bool xml_mode;
static const char *xml_locale_name;
static const char *xml_template_name;
static const char *xml_base_directory;
static const char *xml_language;
static its_rule_list_ty *xml_its_rules;

/* We may have more than one input file.  Domains with same names in
   different files have to merged.  So we need a list of tables for
   each output file.  */
struct msg_domain
{
  /* List for mapping message IDs to message strings.  */
  message_list_ty *mlp;
  /* Name of domain these ID/String pairs are part of.  */
  const char *domain_name;
  /* Output file name.  */
  const char *file_name;
  /* Link to the next domain.  */
  struct msg_domain *next;
};
static struct msg_domain *domain_list;
static struct msg_domain *current_domain;

/* Be more verbose.  Use only 'fprintf' and 'multiline_warning' but not
   'error' or 'multiline_error' to emit verbosity messages, because 'error'
   and 'multiline_error' during PO file parsing cause the program to exit
   with EXIT_FAILURE.  See function lex_end().  */
int verbose = 0;

/* If true check strings according to format string rules for the
   language.  */
static bool check_format_strings = false;

/* If true check the header entry is present and complete.  */
static bool check_header = false;

/* Check that domain directives can be satisfied.  */
static bool check_domain = false;

/* Check that msgfmt's behaviour is semantically compatible with
   X/Open msgfmt or XView msgfmt.  */
static bool check_compatibility = false;

/* If true, consider that strings containing an '&' are menu items and
   the '&' designates a keyboard accelerator, and verify that the translations
   also have a keyboard accelerator.  */
static bool check_accelerators = false;
static char accelerator_char = '&';

/* Counters for statistics on translations for the processed files.  */
static int msgs_translated;
static int msgs_untranslated;
static int msgs_fuzzy;

/* If not zero print statistics about translation at the end.  */
static int do_statistics;

/* Long options.  */
static const struct option long_options[] =
{
  { "alignment", required_argument, NULL, 'a' },
  { "check", no_argument, NULL, 'c' },
  { "check-accelerators", optional_argument, NULL, CHAR_MAX + 1 },
  { "check-compatibility", no_argument, NULL, 'C' },
  { "check-domain", no_argument, NULL, CHAR_MAX + 2 },
  { "check-format", no_argument, NULL, CHAR_MAX + 3 },
  { "check-header", no_argument, NULL, CHAR_MAX + 4 },
  { "csharp", no_argument, NULL, CHAR_MAX + 10 },
  { "csharp-resources", no_argument, NULL, CHAR_MAX + 11 },
  { "desktop", no_argument, NULL, CHAR_MAX + 15 },
  { "directory", required_argument, NULL, 'D' },
  { "endianness", required_argument, NULL, CHAR_MAX + 13 },
  { "help", no_argument, NULL, 'h' },
  { "java", no_argument, NULL, 'j' },
  { "java2", no_argument, NULL, CHAR_MAX + 5 },
  { "keyword", required_argument, NULL, 'k' },
  { "language", required_argument, NULL, 'L' },
  { "locale", required_argument, NULL, 'l' },
  { "no-hash", no_argument, NULL, CHAR_MAX + 6 },
  { "output-file", required_argument, NULL, 'o' },
  { "properties-input", no_argument, NULL, 'P' },
  { "qt", no_argument, NULL, CHAR_MAX + 9 },
  { "resource", required_argument, NULL, 'r' },
  { "source", no_argument, NULL, CHAR_MAX + 14 },
  { "statistics", no_argument, &do_statistics, 1 },
  { "strict", no_argument, NULL, 'S' },
  { "stringtable-input", no_argument, NULL, CHAR_MAX + 8 },
  { "tcl", no_argument, NULL, CHAR_MAX + 7 },
  { "template", required_argument, NULL, CHAR_MAX + 16 },
  { "use-fuzzy", no_argument, NULL, 'f' },
  { "use-untranslated", no_argument, NULL, CHAR_MAX + 12 },
  { "verbose", no_argument, NULL, 'v' },
  { "version", no_argument, NULL, 'V' },
  { "xml", no_argument, NULL, 'x' },
  { NULL, 0, NULL, 0 }
};


/* Forward declaration of local functions.  */
_GL_NORETURN_FUNC static void usage (int status);
static const char *add_mo_suffix (const char *);
static struct msg_domain *new_domain (const char *name, const char *file_name);
static bool is_nonobsolete (const message_ty *mp);
static void read_catalog_file_msgfmt (char *filename,
                                      catalog_input_format_ty input_syntax);
static int msgfmt_desktop_bulk (const char *directory,
                                const char *template_file_name,
                                hash_table *keywords,
                                const char *file_name);
static int msgfmt_xml_bulk (const char *directory,
                            const char *template_file_name,
                            its_rule_list_ty *its_rules,
                            const char *file_name);


int
main (int argc, char *argv[])
{
  int opt;
  bool do_help = false;
  bool do_version = false;
  bool strict_uniforum = false;
  catalog_input_format_ty input_syntax = &input_format_po;
  int arg_i;
  const char *canon_encoding;
  struct msg_domain *domain;

  /* Set default value for global variables.  */
  alignment = DEFAULT_OUTPUT_ALIGNMENT;
  byteswap = 0 ^ ENDIANNESS;

  /* Set program name for messages.  */
  set_program_name (argv[0]);
  error_print_progname = maybe_print_progname;
  error_one_per_line = 1;
  exit_status = EXIT_SUCCESS;

  /* Set locale via LC_ALL.  */
  setlocale (LC_ALL, "");

  /* Set the text message domain.  */
  bindtextdomain (PACKAGE, relocate (LOCALEDIR));
  bindtextdomain ("bison-runtime", relocate (BISON_LOCALEDIR));
  textdomain (PACKAGE);

  /* Ensure that write errors on stdout are detected.  */
  atexit (close_stdout);

  while ((opt = getopt_long (argc, argv, "a:cCd:D:fhjl:L:o:Pr:vVx",
                             long_options, NULL))
         != EOF)
    switch (opt)
      {
      case '\0':                /* Long option.  */
        break;
      case 'a':
        {
          char *endp;
          size_t new_align = strtoul (optarg, &endp, 0);

          if (endp != optarg)
            alignment = new_align;
        }
        break;
      case 'c':
        check_domain = true;
        check_format_strings = true;
        check_header = true;
        break;
      case 'C':
        check_compatibility = true;
        break;
      case 'd':
        java_class_directory = optarg;
        csharp_base_directory = optarg;
        tcl_base_directory = optarg;
        desktop_base_directory = optarg;
        xml_base_directory = optarg;
        break;
      case 'D':
        dir_list_append (optarg);
        break;
      case 'f':
        include_fuzzies = true;
        break;
      case 'h':
        do_help = true;
        break;
      case 'j':
        java_mode = true;
        break;
      case 'k':
        if (optarg == NULL)
          desktop_default_keywords = false;
        else
          {
            if (desktop_keywords.table == NULL)
              {
                hash_init (&desktop_keywords, 100);
                desktop_default_keywords = false;
              }

            desktop_add_keyword (&desktop_keywords, optarg, false);
          }
        break;
      case 'l':
        java_locale_name = optarg;
        csharp_locale_name = optarg;
        tcl_locale_name = optarg;
        desktop_locale_name = optarg;
        xml_locale_name = optarg;
        break;
      case 'L':
        xml_language = optarg;
        break;
      case 'o':
        output_file_name = optarg;
        break;
      case 'P':
        input_syntax = &input_format_properties;
        break;
      case 'r':
        java_resource_name = optarg;
        csharp_resource_name = optarg;
        break;
      case 'S':
        strict_uniforum = true;
        break;
      case 'v':
        verbose++;
        break;
      case 'V':
        do_version = true;
        break;
      case 'x':
        xml_mode = true;
        break;
      case CHAR_MAX + 1: /* --check-accelerators */
        check_accelerators = true;
        if (optarg != NULL)
          {
            if (optarg[0] != '\0' && ispunct ((unsigned char) optarg[0])
                && optarg[1] == '\0')
              accelerator_char = optarg[0];
            else
              error (EXIT_FAILURE, 0,
                     _("the argument to %s should be a single punctuation character"),
                     "--check-accelerators");
          }
        break;
      case CHAR_MAX + 2: /* --check-domain */
        check_domain = true;
        break;
      case CHAR_MAX + 3: /* --check-format */
        check_format_strings = true;
        break;
      case CHAR_MAX + 4: /* --check-header */
        check_header = true;
        break;
      case CHAR_MAX + 5: /* --java2 */
        java_mode = true;
        assume_java2 = true;
        break;
      case CHAR_MAX + 6: /* --no-hash */
        no_hash_table = true;
        break;
      case CHAR_MAX + 7: /* --tcl */
        tcl_mode = true;
        break;
      case CHAR_MAX + 8: /* --stringtable-input */
        input_syntax = &input_format_stringtable;
        break;
      case CHAR_MAX + 9: /* --qt */
        qt_mode = true;
        break;
      case CHAR_MAX + 10: /* --csharp */
        csharp_mode = true;
        break;
      case CHAR_MAX + 11: /* --csharp-resources */
        csharp_resources_mode = true;
        break;
      case CHAR_MAX + 12: /* --use-untranslated (undocumented) */
        include_untranslated = true;
        break;
      case CHAR_MAX + 13: /* --endianness={big|little} */
        {
          int endianness;

          if (strcmp (optarg, "big") == 0)
            endianness = 1;
          else if (strcmp (optarg, "little") == 0)
            endianness = 0;
          else
            error (EXIT_FAILURE, 0, _("invalid endianness: %s"), optarg);

          byteswap = endianness ^ ENDIANNESS;
        }
        break;
      case CHAR_MAX + 14: /* --source */
        java_output_source = true;
        break;
      case CHAR_MAX + 15: /* --desktop */
        desktop_mode = true;
        break;
      case CHAR_MAX + 16: /* --template=TEMPLATE */
        desktop_template_name = optarg;
        xml_template_name = optarg;
        break;
      default:
        usage (EXIT_FAILURE);
        break;
      }

  /* Version information is requested.  */
  if (do_version)
    {
      printf ("%s (GNU %s) %s\n", last_component (program_name),
              PACKAGE, VERSION);
      /* xgettext: no-wrap */
      printf (_("Copyright (C) %s Free Software Foundation, Inc.\n\
License GPLv3+: GNU GPL version 3 or later <%s>\n\
This is free software: you are free to change and redistribute it.\n\
There is NO WARRANTY, to the extent permitted by law.\n\
"),
              "1995-2020", "https://gnu.org/licenses/gpl.html");
      printf (_("Written by %s.\n"), proper_name ("Ulrich Drepper"));
      exit (EXIT_SUCCESS);
    }

  /* Help is requested.  */
  if (do_help)
    usage (EXIT_SUCCESS);

  /* Test whether we have a .po file name as argument.  */
  if (optind >= argc
      && !(desktop_mode && desktop_base_directory)
      && !(xml_mode && xml_base_directory))
    {
      error (EXIT_SUCCESS, 0, _("no input file given"));
      usage (EXIT_FAILURE);
    }
  if (optind < argc
      && ((desktop_mode && desktop_base_directory)
          || (xml_mode && xml_base_directory)))
    {
      error (EXIT_SUCCESS, 0,
             _("no input file should be given if %s and %s are specified"),
             desktop_mode ? "--desktop" : "--xml", "-d");
      usage (EXIT_FAILURE);
    }

  /* Check for contradicting options.  */
  {
    unsigned int modes =
      (java_mode ? 1 : 0)
      | (csharp_mode ? 2 : 0)
      | (csharp_resources_mode ? 4 : 0)
      | (tcl_mode ? 8 : 0)
      | (qt_mode ? 16 : 0)
      | (desktop_mode ? 32 : 0)
      | (xml_mode ? 64 : 0);
    static const char *mode_options[] =
      { "--java", "--csharp", "--csharp-resources", "--tcl", "--qt",
        "--desktop", "--xml" };
    /* More than one bit set?  */
    if (modes & (modes - 1))
      {
        const char *first_option;
        const char *second_option;
        unsigned int i;
        for (i = 0; ; i++)
          if (modes & (1 << i))
            break;
        first_option = mode_options[i];
        for (i = i + 1; ; i++)
          if (modes & (1 << i))
            break;
        second_option = mode_options[i];
        error (EXIT_FAILURE, 0, _("%s and %s are mutually exclusive"),
               first_option, second_option);
      }
  }
  if (java_mode)
    {
      if (output_file_name != NULL)
        {
          error (EXIT_FAILURE, 0, _("%s and %s are mutually exclusive"),
                 "--java", "--output-file");
        }
      if (java_class_directory == NULL)
        {
          error (EXIT_SUCCESS, 0,
                 _("%s requires a \"-d directory\" specification"),
                 "--java");
          usage (EXIT_FAILURE);
        }
    }
  else if (csharp_mode)
    {
      if (output_file_name != NULL)
        {
          error (EXIT_FAILURE, 0, _("%s and %s are mutually exclusive"),
                 "--csharp", "--output-file");
        }
      if (csharp_locale_name == NULL)
        {
          error (EXIT_SUCCESS, 0,
                 _("%s requires a \"-l locale\" specification"),
                 "--csharp");
          usage (EXIT_FAILURE);
        }
      if (csharp_base_directory == NULL)
        {
          error (EXIT_SUCCESS, 0,
                 _("%s requires a \"-d directory\" specification"),
                 "--csharp");
          usage (EXIT_FAILURE);
        }
    }
  else if (tcl_mode)
    {
      if (output_file_name != NULL)
        {
          error (EXIT_FAILURE, 0, _("%s and %s are mutually exclusive"),
                 "--tcl", "--output-file");
        }
      if (tcl_locale_name == NULL)
        {
          error (EXIT_SUCCESS, 0,
                 _("%s requires a \"-l locale\" specification"),
                 "--tcl");
          usage (EXIT_FAILURE);
        }
      if (tcl_base_directory == NULL)
        {
          error (EXIT_SUCCESS, 0,
                 _("%s requires a \"-d directory\" specification"),
                 "--tcl");
          usage (EXIT_FAILURE);
        }
    }
  else if (desktop_mode)
    {
      if (desktop_template_name == NULL)
        {
          error (EXIT_SUCCESS, 0,
                 _("%s requires a \"--template template\" specification"),
                 "--desktop");
          usage (EXIT_FAILURE);
        }
      if (output_file_name == NULL)
        {
          error (EXIT_SUCCESS, 0,
                 _("%s requires a \"-o file\" specification"),
                 "--desktop");
          usage (EXIT_FAILURE);
        }
      if (desktop_base_directory != NULL && desktop_locale_name != NULL)
        error (EXIT_FAILURE, 0,
               _("%s and %s are mutually exclusive in %s"),
               "-d", "-l", "--desktop");
      if (desktop_base_directory == NULL && desktop_locale_name == NULL)
        {
          error (EXIT_SUCCESS, 0,
                 _("%s requires a \"-l locale\" specification"),
                 "--desktop");
          usage (EXIT_FAILURE);
        }
    }
  else if (xml_mode)
    {
      if (xml_template_name == NULL)
        {
          error (EXIT_SUCCESS, 0,
                 _("%s requires a \"--template template\" specification"),
                 "--xml");
          usage (EXIT_FAILURE);
        }
      if (output_file_name == NULL)
        {
          error (EXIT_SUCCESS, 0,
                 _("%s requires a \"-o file\" specification"),
                 "--xml");
          usage (EXIT_FAILURE);
        }
      if (xml_base_directory != NULL && xml_locale_name != NULL)
        error (EXIT_FAILURE, 0,
               _("%s and %s are mutually exclusive in %s"),
               "-d", "-l", "--xml");
      if (xml_base_directory == NULL && xml_locale_name == NULL)
        {
          error (EXIT_SUCCESS, 0,
                 _("%s requires a \"-l locale\" specification"),
                 "--xml");
          usage (EXIT_FAILURE);
        }
    }
  else
    {
      if (java_resource_name != NULL)
        {
          error (EXIT_SUCCESS, 0, _("%s is only valid with %s or %s"),
                 "--resource", "--java", "--csharp");
          usage (EXIT_FAILURE);
        }
      if (java_locale_name != NULL)
        {
          error (EXIT_SUCCESS, 0, _("%s is only valid with %s, %s or %s"),
                 "--locale", "--java", "--csharp", "--tcl");
          usage (EXIT_FAILURE);
        }
      if (java_class_directory != NULL)
        {
          error (EXIT_SUCCESS, 0, _("%s is only valid with %s, %s or %s"),
                 "-d", "--java", "--csharp", "--tcl");
          usage (EXIT_FAILURE);
        }
    }

  if (desktop_mode && desktop_default_keywords)
    {
      if (desktop_keywords.table == NULL)
        hash_init (&desktop_keywords, 100);
      desktop_add_default_keywords (&desktop_keywords);
    }

  /* Bulk processing mode for .desktop files.
     Process all .po files in desktop_base_directory.  */
  if (desktop_mode && desktop_base_directory)
    {
      exit_status = msgfmt_desktop_bulk (desktop_base_directory,
                                         desktop_template_name,
                                         &desktop_keywords,
                                         output_file_name);
      if (desktop_keywords.table != NULL)
        hash_destroy (&desktop_keywords);
      exit (exit_status);
    }

  if (xml_mode)
    {
      char **its_dirs;
      char **dirs;
      locating_rule_list_ty *its_locating_rules;
      const char *its_basename;

      its_dirs = get_search_path ("its");
      its_locating_rules = locating_rule_list_alloc ();
      for (dirs = its_dirs; *dirs != NULL; dirs++)
        locating_rule_list_add_from_directory (its_locating_rules, *dirs);

      its_basename = locating_rule_list_locate (its_locating_rules,
                                                xml_template_name,
                                                xml_language);

      if (its_basename != NULL)
        {
          size_t j;

          xml_its_rules = its_rule_list_alloc ();
          for (j = 0; its_dirs[j] != NULL; j++)
            {
              char *its_filename =
                xconcatenated_filename (its_dirs[j], its_basename, NULL);
              struct stat statbuf;
              bool ok = false;

              if (stat (its_filename, &statbuf) == 0)
                ok = its_rule_list_add_from_file (xml_its_rules, its_filename);
              free (its_filename);
              if (ok)
                break;
            }
          if (its_dirs[j] == NULL)
            {
              its_rule_list_free (xml_its_rules);
              xml_its_rules = NULL;
            }
        }
      locating_rule_list_free (its_locating_rules);

      for (dirs = its_dirs; *dirs != NULL; dirs++)
        free (*dirs);
      free (its_dirs);

      if (xml_its_rules == NULL)
        error (EXIT_FAILURE, 0, _("cannot locate ITS rules for %s"),
               xml_template_name);
    }

  /* Bulk processing mode for XML files.
     Process all .po files in xml_base_directory.  */
  if (xml_mode && xml_base_directory)
    {
      exit_status = msgfmt_xml_bulk (xml_base_directory,
                                     xml_template_name,
                                     xml_its_rules,
                                     output_file_name);
      exit (exit_status);
    }

  /* The -o option determines the name of the domain and therefore
     the output file.  */
  if (output_file_name != NULL)
    current_domain =
      new_domain (output_file_name,
                  strict_uniforum && !csharp_resources_mode && !qt_mode
                  ? add_mo_suffix (output_file_name)
                  : output_file_name);

  /* Process all given .po files.  */
  for (arg_i = optind; arg_i < argc; arg_i++)
    {
      /* Remember that we currently have not specified any domain.  This
         is of course not true when we saw the -o option.  */
      if (output_file_name == NULL)
        current_domain = NULL;

      /* And process the input file.  */
      read_catalog_file_msgfmt (argv[arg_i], input_syntax);
    }

  /* We know a priori that some input_syntax->parse() functions convert
     strings to UTF-8.  */
  canon_encoding = (input_syntax->produces_utf8 ? po_charset_utf8 : NULL);

  /* Remove obsolete messages.  They were only needed for duplicate
     checking.  */
  for (domain = domain_list; domain != NULL; domain = domain->next)
    message_list_remove_if_not (domain->mlp, is_nonobsolete);

  /* Perform all kinds of checks: plural expressions, format strings, ...  */
  {
    int nerrors = 0;

    for (domain = domain_list; domain != NULL; domain = domain->next)
      nerrors +=
        check_message_list (domain->mlp,
                            /* Untranslated and fuzzy messages have already
                               been dealt with during parsing, see below in
                               msgfmt_frob_new_message.  */
                            0, 0,
                            1, check_format_strings, check_header,
                            check_compatibility,
                            check_accelerators, accelerator_char);

    /* Exit with status 1 on any error.  */
    if (nerrors > 0)
      {
        error (0, 0,
               ngettext ("found %d fatal error", "found %d fatal errors",
                         nerrors),
               nerrors);
        exit_status = EXIT_FAILURE;
      }
  }

  /* Now write out all domains.  */
  for (domain = domain_list; domain != NULL; domain = domain->next)
    {
      if (java_mode)
        {
          if (msgdomain_write_java (domain->mlp, canon_encoding,
                                    java_resource_name, java_locale_name,
                                    java_class_directory, assume_java2,
                                    java_output_source))
            exit_status = EXIT_FAILURE;
        }
      else if (csharp_mode)
        {
          if (msgdomain_write_csharp (domain->mlp, canon_encoding,
                                      csharp_resource_name, csharp_locale_name,
                                      csharp_base_directory))
            exit_status = EXIT_FAILURE;
        }
      else if (csharp_resources_mode)
        {
          if (msgdomain_write_csharp_resources (domain->mlp, canon_encoding,
                                                domain->domain_name,
                                                domain->file_name))
            exit_status = EXIT_FAILURE;
        }
      else if (tcl_mode)
        {
          if (msgdomain_write_tcl (domain->mlp, canon_encoding,
                                   tcl_locale_name, tcl_base_directory))
            exit_status = EXIT_FAILURE;
        }
      else if (qt_mode)
        {
          if (msgdomain_write_qt (domain->mlp, canon_encoding,
                                  domain->domain_name, domain->file_name))
            exit_status = EXIT_FAILURE;
        }
      else if (desktop_mode)
        {
          if (msgdomain_write_desktop (domain->mlp, canon_encoding,
                                       desktop_locale_name,
                                       desktop_template_name,
                                       &desktop_keywords,
                                       domain->file_name))
            exit_status = EXIT_FAILURE;

          if (desktop_keywords.table != NULL)
            hash_destroy (&desktop_keywords);
        }
      else if (xml_mode)
        {
          if (msgdomain_write_xml (domain->mlp, canon_encoding,
                                   xml_locale_name,
                                   xml_template_name,
                                   xml_its_rules,
                                   domain->file_name))
            exit_status = EXIT_FAILURE;
        }
      else
        {
          if (msgdomain_write_mo (domain->mlp, domain->domain_name,
                                  domain->file_name))
            exit_status = EXIT_FAILURE;
        }

      /* List is not used anymore.  */
      message_list_free (domain->mlp, 0);
    }

  /* Print statistics if requested.  */
  if (verbose || do_statistics)
    {
      if (do_statistics + verbose >= 2 && optind < argc)
        {
          /* Print the input file name(s) in front of the statistics line.  */
          char *all_input_file_names;

          {
            string_list_ty input_file_names;

            string_list_init (&input_file_names);;
            for (arg_i = optind; arg_i < argc; arg_i++)
              string_list_append (&input_file_names, argv[arg_i]);
            all_input_file_names =
              string_list_join (&input_file_names, ", ", '\0', false);
            string_list_destroy (&input_file_names);
          }

          /* TRANSLATORS: The prefix before a statistics message.  The argument
             is a file name or a comma separated list of file names.  */
          fprintf (stderr, _("%s: "), all_input_file_names);
          free (all_input_file_names);
        }
      fprintf (stderr,
               ngettext ("%d translated message", "%d translated messages",
                         msgs_translated),
               msgs_translated);
      if (msgs_fuzzy > 0)
        fprintf (stderr,
                 ngettext (", %d fuzzy translation", ", %d fuzzy translations",
                           msgs_fuzzy),
                 msgs_fuzzy);
      if (msgs_untranslated > 0)
        fprintf (stderr,
                 ngettext (", %d untranslated message",
                           ", %d untranslated messages",
                           msgs_untranslated),
                 msgs_untranslated);
      fputs (".\n", stderr);
    }

  exit (exit_status);
}


/* Display usage information and exit.  */
static void
usage (int status)
{
  if (status != EXIT_SUCCESS)
    fprintf (stderr, _("Try '%s --help' for more information.\n"),
             program_name);
  else
    {
      printf (_("\
Usage: %s [OPTION] filename.po ...\n\
"), program_name);
      printf ("\n");
      printf (_("\
Generate binary message catalog from textual translation description.\n\
"));
      printf ("\n");
      /* xgettext: no-wrap */
      printf (_("\
Mandatory arguments to long options are mandatory for short options too.\n\
Similarly for optional arguments.\n\
"));
      printf ("\n");
      printf (_("\
Input file location:\n"));
      printf (_("\
  filename.po ...             input files\n"));
      printf (_("\
  -D, --directory=DIRECTORY   add DIRECTORY to list for input files search\n"));
      printf (_("\
If input file is -, standard input is read.\n"));
      printf ("\n");
      printf (_("\
Operation mode:\n"));
      printf (_("\
  -j, --java                  Java mode: generate a Java ResourceBundle class\n"));
      printf (_("\
      --java2                 like --java, and assume Java2 (JDK 1.2 or higher)\n"));
      printf (_("\
      --csharp                C# mode: generate a .NET .dll file\n"));
      printf (_("\
      --csharp-resources      C# resources mode: generate a .NET .resources file\n"));
      printf (_("\
      --tcl                   Tcl mode: generate a tcl/msgcat .msg file\n"));
      printf (_("\
      --qt                    Qt mode: generate a Qt .qm file\n"));
      printf (_("\
      --desktop               Desktop Entry mode: generate a .desktop file\n"));
      printf (_("\
      --xml                   XML mode: generate XML file\n"));
      printf ("\n");
      printf (_("\
Output file location:\n"));
      printf (_("\
  -o, --output-file=FILE      write output to specified file\n"));
      printf (_("\
      --strict                enable strict Uniforum mode\n"));
      printf (_("\
If output file is -, output is written to standard output.\n"));
      printf ("\n");
      printf (_("\
Output file location in Java mode:\n"));
      printf (_("\
  -r, --resource=RESOURCE     resource name\n"));
      printf (_("\
  -l, --locale=LOCALE         locale name, either language or language_COUNTRY\n"));
      printf (_("\
      --source                produce a .java file, instead of a .class file\n"));
      printf (_("\
  -d DIRECTORY                base directory of classes directory hierarchy\n"));
      printf (_("\
The class name is determined by appending the locale name to the resource name,\n\
separated with an underscore.  The -d option is mandatory.  The class is\n\
written under the specified directory.\n\
"));
      printf ("\n");
      printf (_("\
Output file location in C# mode:\n"));
      printf (_("\
  -r, --resource=RESOURCE     resource name\n"));
      printf (_("\
  -l, --locale=LOCALE         locale name, either language or language_COUNTRY\n"));
      printf (_("\
  -d DIRECTORY                base directory for locale dependent .dll files\n"));
      printf (_("\
The -l and -d options are mandatory.  The .dll file is written in a\n\
subdirectory of the specified directory whose name depends on the locale.\n"));
      printf ("\n");
      printf (_("\
Output file location in Tcl mode:\n"));
      printf (_("\
  -l, --locale=LOCALE         locale name, either language or language_COUNTRY\n"));
      printf (_("\
  -d DIRECTORY                base directory of .msg message catalogs\n"));
      printf (_("\
The -l and -d options are mandatory.  The .msg file is written in the\n\
specified directory.\n"));
      printf ("\n");
      printf (_("\
Desktop Entry mode options:\n"));
      printf (_("\
  -l, --locale=LOCALE         locale name, either language or language_COUNTRY\n"));
      printf (_("\
  -o, --output-file=FILE      write output to specified file\n"));
      printf (_("\
  --template=TEMPLATE         a .desktop file used as a template\n"));
      printf (_("\
  -d DIRECTORY                base directory of .po files\n"));
      printf (_("\
  -kWORD, --keyword=WORD      look for WORD as an additional keyword\n\
  -k, --keyword               do not to use default keywords\n"));
      printf (_("\
The -l, -o, and --template options are mandatory.  If -D is specified, input\n\
files are read from the directory instead of the command line arguments.\n"));
      printf ("\n");
      printf (_("\
XML mode options:\n"));
      printf (_("\
  -l, --locale=LOCALE         locale name, either language or language_COUNTRY\n"));
      printf (_("\
  -L, --language=NAME         recognise the specified XML language\n"));
      printf (_("\
  -o, --output-file=FILE      write output to specified file\n"));
      printf (_("\
  --template=TEMPLATE         an XML file used as a template\n"));
      printf (_("\
  -d DIRECTORY                base directory of .po files\n"));
      printf (_("\
The -l, -o, and --template options are mandatory.  If -D is specified, input\n\
files are read from the directory instead of the command line arguments.\n"));
      printf ("\n");
      printf (_("\
Input file syntax:\n"));
      printf (_("\
  -P, --properties-input      input files are in Java .properties syntax\n"));
      printf (_("\
      --stringtable-input     input files are in NeXTstep/GNUstep .strings\n\
                              syntax\n"));
      printf ("\n");
      printf (_("\
Input file interpretation:\n"));
      printf (_("\
  -c, --check                 perform all the checks implied by\n\
                                --check-format, --check-header, --check-domain\n"));
      printf (_("\
      --check-format          check language dependent format strings\n"));
      printf (_("\
      --check-header          verify presence and contents of the header entry\n"));
      printf (_("\
      --check-domain          check for conflicts between domain directives\n\
                                and the --output-file option\n"));
      printf (_("\
  -C, --check-compatibility   check that GNU msgfmt behaves like X/Open msgfmt\n"));
      printf (_("\
      --check-accelerators[=CHAR]  check presence of keyboard accelerators for\n\
                                menu items\n"));
      printf (_("\
  -f, --use-fuzzy             use fuzzy entries in output\n"));
      printf ("\n");
      printf (_("\
Output details:\n"));
      printf (_("\
  -a, --alignment=NUMBER      align strings to NUMBER bytes (default: %d)\n"), DEFAULT_OUTPUT_ALIGNMENT);
      printf (_("\
      --endianness=BYTEORDER  write out 32-bit numbers in the given byte order\n\
                                (big or little, default depends on platform)\n"));
      printf (_("\
      --no-hash               binary file will not include the hash table\n"));
      printf ("\n");
      printf (_("\
Informative output:\n"));
      printf (_("\
  -h, --help                  display this help and exit\n"));
      printf (_("\
  -V, --version               output version information and exit\n"));
      printf (_("\
      --statistics            print statistics about translations\n"));
      printf (_("\
  -v, --verbose               increase verbosity level\n"));
      printf ("\n");
      /* TRANSLATORS: The first placeholder is the web address of the Savannah
         project of this package.  The second placeholder is the bug-reporting
         email address for this package.  Please add _another line_ saying
         "Report translation bugs to <...>\n" with the address for translation
         bugs (typically your translation team's web or email address).  */
      printf(_("\
Report bugs in the bug tracker at <%s>\n\
or by email to <%s>.\n"),
             "https://savannah.gnu.org/projects/gettext",
             "bug-gettext@gnu.org");
    }

  exit (status);
}


static const char *
add_mo_suffix (const char *fname)
{
  size_t len;
  char *result;

  len = strlen (fname);
  if (len > 3 && memcmp (fname + len - 3, ".mo", 3) == 0)
    return fname;
  if (len > 4 && memcmp (fname + len - 4, ".gmo", 4) == 0)
    return fname;
  result = XNMALLOC (len + 4, char);
  stpcpy (stpcpy (result, fname), ".mo");
  return result;
}


static struct msg_domain *
new_domain (const char *name, const char *file_name)
{
  struct msg_domain **p_dom = &domain_list;

  while (*p_dom != NULL && strcmp (name, (*p_dom)->domain_name) != 0)
    p_dom = &(*p_dom)->next;

  if (*p_dom == NULL)
    {
      struct msg_domain *domain;

      domain = XMALLOC (struct msg_domain);
      domain->mlp = message_list_alloc (true);
      domain->domain_name = name;
      domain->file_name = file_name;
      domain->next = NULL;
      *p_dom = domain;
    }

  return *p_dom;
}


static bool
is_nonobsolete (const message_ty *mp)
{
  return !mp->obsolete;
}


/* The rest of the file defines a subclass msgfmt_catalog_reader_ty of
   default_catalog_reader_ty.  Its particularities are:
   - The header entry check is performed on-the-fly.
   - Comments are not stored, they are discarded right away.
     (This is achieved by setting handle_comments = false.)
   - The multi-domain handling is adapted to our domain_list.
 */


/* This structure defines a derived class of the default_catalog_reader_ty
   class.  (See read-catalog-abstract.h for an explanation.)  */
typedef struct msgfmt_catalog_reader_ty msgfmt_catalog_reader_ty;
struct msgfmt_catalog_reader_ty
{
  /* inherited instance variables, etc */
  DEFAULT_CATALOG_READER_TY

  bool has_header_entry;
};


/* Prepare for first message.  */
static void
msgfmt_constructor (abstract_catalog_reader_ty *that)
{
  msgfmt_catalog_reader_ty *this = (msgfmt_catalog_reader_ty *) that;

  /* Invoke superclass constructor.  */
  default_constructor (that);

  this->has_header_entry = false;
}


/* Some checks after whole file is read.  */
static void
msgfmt_parse_debrief (abstract_catalog_reader_ty *that)
{
  msgfmt_catalog_reader_ty *this = (msgfmt_catalog_reader_ty *) that;

  /* Invoke superclass method.  */
  default_parse_debrief (that);

  /* Test whether header entry was found.  */
  if (check_header)
    {
      if (!this->has_header_entry)
        {
          multiline_error (xasprintf ("%s: ", this->file_name),
                           xasprintf (_("warning: PO file header missing or invalid\n")));
          multiline_error (NULL,
                           xasprintf (_("warning: charset conversion will not work\n")));
        }
    }
}


/* Set 'domain' directive when seen in .po file.  */
static void
msgfmt_set_domain (default_catalog_reader_ty *this, char *name)
{
  /* If no output file was given, we change it with each 'domain'
     directive.  */
  if (!java_mode && !csharp_mode && !csharp_resources_mode && !tcl_mode
      && !qt_mode && !desktop_mode && !xml_mode && output_file_name == NULL)
    {
      size_t correct;

      correct = strcspn (name, INVALID_PATH_CHAR);
      if (name[correct] != '\0')
        {
          exit_status = EXIT_FAILURE;
          if (correct == 0)
            {
              error (0, 0,
                     _("domain name \"%s\" not suitable as file name"), name);
              return;
            }
          else
            error (0, 0,
                   _("domain name \"%s\" not suitable as file name: will use prefix"),
                   name);
          name[correct] = '\0';
        }

      /* Set new domain.  */
      current_domain = new_domain (name, add_mo_suffix (name));
      this->domain = current_domain->domain_name;
      this->mlp = current_domain->mlp;
    }
  else
    {
      if (check_domain)
        po_gram_error_at_line (&gram_pos,
                               _("'domain %s' directive ignored"), name);

      /* NAME was allocated in po-gram-gen.y but is not used anywhere.  */
      free (name);
    }
}


static void
msgfmt_add_message (default_catalog_reader_ty *this,
                    char *msgctxt,
                    char *msgid,
                    lex_pos_ty *msgid_pos,
                    char *msgid_plural,
                    char *msgstr, size_t msgstr_len,
                    lex_pos_ty *msgstr_pos,
                    char *prev_msgctxt,
                    char *prev_msgid,
                    char *prev_msgid_plural,
                    bool force_fuzzy, bool obsolete)
{
  /* Check whether already a domain is specified.  If not, use default
     domain.  */
  if (current_domain == NULL)
    {
      current_domain = new_domain (MESSAGE_DOMAIN_DEFAULT,
                                   add_mo_suffix (MESSAGE_DOMAIN_DEFAULT));
      /* Keep current_domain and this->domain synchronized.  */
      this->domain = current_domain->domain_name;
      this->mlp = current_domain->mlp;
    }

  /* Invoke superclass method.  */
  default_add_message (this, msgctxt, msgid, msgid_pos, msgid_plural,
                       msgstr, msgstr_len, msgstr_pos,
                       prev_msgctxt, prev_msgid, prev_msgid_plural,
                       force_fuzzy, obsolete);
}


static void
msgfmt_frob_new_message (default_catalog_reader_ty *that, message_ty *mp,
                         const lex_pos_ty *msgid_pos,
                         const lex_pos_ty *msgstr_pos)
{
  msgfmt_catalog_reader_ty *this = (msgfmt_catalog_reader_ty *) that;

  if (!mp->obsolete)
    {
      /* Don't emit untranslated entries.
         Also don't emit fuzzy entries, unless --use-fuzzy was specified.
         But ignore fuzziness of the header entry.  */
      if ((!include_untranslated && mp->msgstr[0] == '\0')
          || (!include_fuzzies && mp->is_fuzzy && !is_header (mp)))
        {
          if (check_compatibility)
            {
              error_with_progname = false;
              error_at_line (0, 0, mp->pos.file_name, mp->pos.line_number,
                             (mp->msgstr[0] == '\0'
                              ? _("empty 'msgstr' entry ignored")
                              : _("fuzzy 'msgstr' entry ignored")));
              error_with_progname = true;
            }

          /* Increment counter for fuzzy/untranslated messages.  */
          if (mp->msgstr[0] == '\0')
            ++msgs_untranslated;
          else
            ++msgs_fuzzy;

          mp->obsolete = true;
        }
      else
        {
          /* Test for header entry.  */
          if (is_header (mp))
            {
              this->has_header_entry = true;
            }
          else
            /* We don't count the header entry in the statistic so place
               the counter incrementation here.  */
            if (mp->is_fuzzy)
              ++msgs_fuzzy;
            else
              ++msgs_translated;
        }
    }
}


/* Test for '#, fuzzy' comments and warn.  */
static void
msgfmt_comment_special (abstract_catalog_reader_ty *that, const char *s)
{
  msgfmt_catalog_reader_ty *this = (msgfmt_catalog_reader_ty *) that;

  /* Invoke superclass method.  */
  default_comment_special (that, s);

  if (this->is_fuzzy)
    {
      static bool warned = false;

      if (!include_fuzzies && check_compatibility && !warned)
        {
          warned = true;
          error (0, 0,
                 _("%s: warning: source file contains fuzzy translation"),
                 gram_pos.file_name);
        }
    }
}


/* So that the one parser can be used for multiple programs, and also
   use good data hiding and encapsulation practices, an object
   oriented approach has been taken.  An object instance is allocated,
   and all actions resulting from the parse will be through
   invocations of method functions of that object.  */

static default_catalog_reader_class_ty msgfmt_methods =
{
  {
    sizeof (msgfmt_catalog_reader_ty),
    msgfmt_constructor,
    default_destructor,
    default_parse_brief,
    msgfmt_parse_debrief,
    default_directive_domain,
    default_directive_message,
    default_comment,
    default_comment_dot,
    default_comment_filepos,
    msgfmt_comment_special
  },
  msgfmt_set_domain, /* set_domain */
  msgfmt_add_message, /* add_message */
  msgfmt_frob_new_message /* frob_new_message */
};


/* Read .po file FILENAME and store translation pairs.  */
static void
read_catalog_file_msgfmt (char *filename, catalog_input_format_ty input_syntax)
{
  char *real_filename;
  FILE *fp = open_catalog_file (filename, &real_filename, true);
  default_catalog_reader_ty *pop;

  pop = default_catalog_reader_alloc (&msgfmt_methods);
  pop->handle_comments = false;
  pop->allow_domain_directives = true;
  pop->allow_duplicates = false;
  pop->allow_duplicates_if_same_msgstr = false;
  pop->file_name = real_filename;
  pop->mdlp = NULL;
  pop->mlp = NULL;
  if (current_domain != NULL)
    {
      /* Keep current_domain and this->domain synchronized.  */
      pop->domain = current_domain->domain_name;
      pop->mlp = current_domain->mlp;
    }
  po_lex_pass_obsolete_entries (true);
  catalog_reader_parse ((abstract_catalog_reader_ty *) pop, fp, real_filename,
                        filename, input_syntax);
  catalog_reader_free ((abstract_catalog_reader_ty *) pop);

  if (fp != stdin)
    fclose (fp);
}

static void
add_languages (string_list_ty *languages, string_list_ty *desired_languages,
               const char *line, size_t length)
{
  char *start;

  /* Split the line by whitespace and build the languages list.  */
  for (start = (char *) line; start - line < length; )
    {
      char *p;

      /* Skip whitespace before the string.  */
      while (*start == ' ' || *start == '\t')
        start++;

      p = start;
      while (*p != '\0' && *p != ' ' && *p != '\t')
        p++;

      *p = '\0';
      if (desired_languages == NULL
          || string_list_member (desired_languages, start))
        string_list_append_unique (languages, start);
      start = p + 1;
    }
}

/* Compute the languages list by reading the "LINGUAS" envvar or the
   LINGUAS file under DIRECTORY.  */
static void
get_languages (string_list_ty *languages, const char *directory)
{
  char *envval;
  string_list_ty real_desired_languages, *desired_languages = NULL;
  char *linguas_file_name = NULL;
  struct stat statbuf;
  FILE *fp;
  size_t line_len = 0;
  char *line_buf = NULL;

  envval = getenv ("LINGUAS");
  if (envval)
    {
      string_list_init (&real_desired_languages);
      add_languages (&real_desired_languages, NULL, envval, strlen (envval));
      desired_languages = &real_desired_languages;
    }

  linguas_file_name = xconcatenated_filename (directory, "LINGUAS", NULL);
  if (stat (linguas_file_name, &statbuf) < 0)
    {
      error (EXIT_SUCCESS, 0, _("%s does not exist"), linguas_file_name);
      goto out;
    }

  fp = fopen (linguas_file_name, "r");
  if (fp == NULL)
    {
      error (EXIT_SUCCESS, 0, _("%s exists but cannot read"),
             linguas_file_name);
      goto out;
    }

  while (!feof (fp))
    {
      /* Read next line from file.  */
      int len = getline (&line_buf, &line_len, fp);

      /* In case of an error leave loop.  */
      if (len < 0)
        break;

      /* Remove trailing '\n' and trailing whitespace.  */
      if (len > 0 && line_buf[len - 1] == '\n')
        line_buf[--len] = '\0';
      while (len > 0
             && (line_buf[len - 1] == ' '
                 || line_buf[len - 1] == '\t'
                 || line_buf[len - 1] == '\r'))
        line_buf[--len] = '\0';

      /* Test if we have to ignore the line.  */
      if (!(*line_buf == '\0' || *line_buf == '#'))
        /* Include the line among the languages.  */
        add_languages (languages, desired_languages, line_buf, len);
    }

  free (line_buf);
  fclose (fp);

 out:
  if (desired_languages != NULL)
    string_list_destroy (desired_languages);
  free (linguas_file_name);
}

static void
msgfmt_operand_list_init (msgfmt_operand_list_ty *operands)
{
  operands->items = NULL;
  operands->nitems = 0;
  operands->nitems_max = 0;
}

static void
msgfmt_operand_list_destroy (msgfmt_operand_list_ty *operands)
{
  size_t i;

  for (i = 0; i < operands->nitems; i++)
    {
      free (operands->items[i].language);
      message_list_free (operands->items[i].mlp, 0);
    }
  free (operands->items);
}

static void
msgfmt_operand_list_append (msgfmt_operand_list_ty *operands,
                            const char *language,
                            message_list_ty *messages)
{
  msgfmt_operand_ty *operand;

  if (operands->nitems == operands->nitems_max)
    {
      operands->nitems_max = operands->nitems_max * 2 + 1;
      operands->items = xrealloc (operands->items,
                                  sizeof (msgfmt_operand_ty)
                                  * operands->nitems_max);
    }

  operand = &operands->items[operands->nitems++];
  operand->language = xstrdup (language);
  operand->mlp = messages;
}

static int
msgfmt_operand_list_add_from_directory (msgfmt_operand_list_ty *operands,
                                        const char *directory)
{
  string_list_ty languages;
  void *saved_dir_list;
  int retval = 0;
  size_t i;

  string_list_init (&languages);
  get_languages (&languages, directory);

  if (languages.nitems == 0)
    return 0;

  /* Reset the directory search list so only .po files under DIRECTORY
     will be read.  */
  saved_dir_list = dir_list_save_reset ();
  dir_list_append (directory);

  /* Read all .po files.  */
  for (i = 0; i < languages.nitems; i++)
    {
      const char *language = languages.item[i];
      message_list_ty *mlp;
      char *input_file_name;
      int nerrors;

      current_domain = new_domain (MESSAGE_DOMAIN_DEFAULT,
                                   add_mo_suffix (MESSAGE_DOMAIN_DEFAULT));

      input_file_name = xconcatenated_filename ("", language, ".po");
      read_catalog_file_msgfmt (input_file_name, &input_format_po);
      free (input_file_name);

      /* The domain directive is not supported in the bulk execution mode.
         Thus, domain_list should always contain a single domain.  */
      assert (current_domain == domain_list && domain_list->next == NULL);
      mlp = current_domain->mlp;
      free (current_domain);
      current_domain = domain_list = NULL;

      /* Remove obsolete messages.  They were only needed for duplicate
         checking.  */
      message_list_remove_if_not (mlp, is_nonobsolete);

      /* Perform all kinds of checks: plural expressions, format
         strings, ...  */
      nerrors =
        check_message_list (mlp,
                            /* Untranslated and fuzzy messages have already
                               been dealt with during parsing, see below in
                               msgfmt_frob_new_message.  */
                            0, 0,
                            1, check_format_strings, check_header,
                            check_compatibility,
                            check_accelerators, accelerator_char);

      retval += nerrors;
      if (nerrors > 0)
        {
          error (0, 0,
                 ngettext ("found %d fatal error", "found %d fatal errors",
                           nerrors),
                 nerrors);
          continue;
        }

      /* Convert the messages to Unicode.  */
      iconv_message_list (mlp, NULL, po_charset_utf8, NULL);

      msgfmt_operand_list_append (operands, language, mlp);
    }

  string_list_destroy (&languages);
  dir_list_restore (saved_dir_list);

  return retval;
}

/* Helper function to support 'bulk' operation mode of --desktop.
   This reads all .po files in DIRECTORY and merges them into a
   .desktop file FILE_NAME.  Currently it does not support some
   options available in 'iterative' mode, such as --statistics.  */
static int
msgfmt_desktop_bulk (const char *directory,
                     const char *template_file_name,
                     hash_table *keywords,
                     const char *file_name)
{
  msgfmt_operand_list_ty operands;
  int nerrors, status;

  msgfmt_operand_list_init (&operands);

  /* Read all .po files.  */
  nerrors = msgfmt_operand_list_add_from_directory (&operands, directory);
  if (nerrors > 0)
    {
      msgfmt_operand_list_destroy (&operands);
      return 1;
    }

  /* Write the messages into .desktop file.  */
  status = msgdomain_write_desktop_bulk (&operands,
                                         template_file_name,
                                         keywords,
                                         file_name);

  msgfmt_operand_list_destroy (&operands);

  return status;
}

/* Helper function to support 'bulk' operation mode of --xml.
   This reads all .po files in DIRECTORY and merges them into an
   XML file FILE_NAME.  Currently it does not support some
   options available in 'iterative' mode, such as --statistics.  */
static int
msgfmt_xml_bulk (const char *directory,
                 const char *template_file_name,
                 its_rule_list_ty *its_rules,
                 const char *file_name)
{
  msgfmt_operand_list_ty operands;
  int nerrors, status;

  msgfmt_operand_list_init (&operands);

  /* Read all .po files.  */
  nerrors = msgfmt_operand_list_add_from_directory (&operands, directory);
  if (nerrors > 0)
    {
      msgfmt_operand_list_destroy (&operands);
      return 1;
    }

  /* Write the messages into .xml file.  */
  status = msgdomain_write_xml_bulk (&operands,
                                     template_file_name,
                                     its_rules,
                                     file_name);

  msgfmt_operand_list_destroy (&operands);

  return status;
}