home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / gettext-0.10.24-src.tgz / tar.out / fsf / gettext / src / msgmerge.c < prev    next >
C/C++ Source or Header  |  1996-09-28  |  20KB  |  757 lines
  1. /* GNU gettext - internationalization aids
  2.    Copyright (C) 1995, 1996 Free Software Foundation, Inc.
  3.  
  4.    This file was written by Peter Miller <pmiller@agso.gov.au>
  5.  
  6. This program is free software; you can redistribute it and/or modify
  7. it under the terms of the GNU General Public License as published by
  8. the Free Software Foundation; either version 2, or (at your option)
  9. any later version.
  10.  
  11. This program is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with this program; if not, write to the Free Software
  18. Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  19.  
  20. #ifdef HAVE_CONFIG_H
  21. # include <config.h>
  22. #endif
  23.  
  24. #include <getopt.h>
  25. #include <limits.h>
  26. #include <stdio.h>
  27.  
  28. #ifdef STDC_HEADERS
  29. # include <stdlib.h>
  30. # include <string.h>
  31. #else
  32. # include <strings.h>
  33. #endif
  34.  
  35. #ifdef HAVE_LOCALE_H
  36. # include <locale.h>
  37. #endif
  38.  
  39. #include "dir-list.h"
  40. #include "error.h"
  41. #include "message.h"
  42. #include <system.h>
  43. #include <libintl.h>
  44. #include "po.h"
  45.  
  46. #define _(str) gettext (str)
  47.  
  48.  
  49. /* This structure defines a derived class of the po_ty class.  (See
  50.    po.h for an explanation.)  */
  51. typedef struct merge_class_ty merge_class_ty;
  52. struct merge_class_ty
  53. {
  54.   /* inherited instance variables, etc */
  55.   PO_BASE_TY
  56.  
  57.   /* Name of domain we are currently examining.  */
  58.   char *domain;
  59.  
  60.   /* List of domains already appeared in the current file.  */
  61.   string_list_ty *domain_list;
  62.  
  63.   /* List of messages already appeared in the current file.  */
  64.   message_list_ty *mlp;
  65.  
  66.   /* Accumulate comments for next message directive */
  67.   string_list_ty *comment;
  68.   string_list_ty *comment_dot;
  69.  
  70.   /* Flags transported in special comments.  */
  71.   int is_fuzzy;
  72.   enum is_c_format is_c_format;
  73.   enum is_c_format do_wrap;
  74.  
  75.   /* Accumulate filepos comments for the next message directive.  */
  76.   size_t filepos_count;
  77.   lex_pos_ty *filepos;
  78. };
  79.  
  80.  
  81. /* String containing name the program is called with.  */
  82. const char *program_name;
  83.  
  84. /* If non-zero do not print unneeded messages.  */
  85. static int quiet;
  86.  
  87. /* Verbosity level.  */
  88. static int verbosity_level;
  89.  
  90. /* Long options.  */
  91. static const struct option long_options[] =
  92. {
  93.   { "directory", required_argument, NULL, 'D' },
  94.   { "escape", no_argument, NULL, 'E' },
  95.   { "help", no_argument, NULL, 'h' },
  96.   { "indent", no_argument, NULL, 'i' },
  97.   { "no-escape", no_argument, NULL, 'e' },
  98.   { "output-file", required_argument, NULL, 'o' },
  99.   { "quiet", no_argument, NULL, 'q' },
  100.   { "sort-by-file", no_argument, NULL, 'F' },
  101.   { "sort-output", no_argument, NULL, 's' },
  102.   { "silent", no_argument, NULL, 'q' },
  103.   { "strict", no_argument, NULL, 'S' },
  104.   { "verbose", no_argument, NULL, 'v' },
  105.   { "version", no_argument, NULL, 'V' },
  106.   { "width", required_argument, NULL, 'w', },
  107.   { NULL, 0, NULL, 0 }
  108. };
  109.  
  110.  
  111. /* Prototypes for local functions.  */
  112. static void usage PARAMS ((int __status));
  113. static void error_print PARAMS ((void));
  114. static void merge_constructor PARAMS ((po_ty *__that));
  115. static void merge_destructor PARAMS ((po_ty *__that));
  116. static void merge_directive_domain PARAMS ((po_ty *__that, char *__name));
  117. static void merge_directive_message PARAMS ((po_ty *__that, char *__msgid,
  118.                          lex_pos_ty *__msgid_pos,
  119.                          char *__msgstr,
  120.                          lex_pos_ty *__msgstr_pos));
  121. static void merge_parse_brief PARAMS ((po_ty *__that));
  122. static void merge_parse_debrief PARAMS ((po_ty *__that));
  123. static void merge_comment PARAMS ((po_ty *__that, const char *__s));
  124. static void merge_comment_dot PARAMS ((po_ty *__that, const char *__s));
  125. static void merge_comment_special PARAMS ((po_ty *__that, const char *__s));
  126. static void merge_comment_filepos PARAMS ((po_ty *__that, const char *__name,
  127.                        int __line));
  128. static message_list_ty *grammar PARAMS ((const char *__filename));
  129. static message_list_ty *merge PARAMS ((const char *__fn1, const char *__fn2));
  130.  
  131.  
  132. int
  133. main (argc, argv)
  134.      int argc;
  135.      char **argv;
  136. {
  137.   int opt;
  138.   int do_help;
  139.   int do_version;
  140.   char *output_file;
  141.   message_list_ty *result;
  142.   int sort_by_filepos = 0;
  143.   int sort_by_msgid = 0;
  144.  
  145.   /* Set program name for messages.  */
  146.   program_name = argv[0];
  147.   verbosity_level = 0;
  148.   quiet = 0;
  149.   error_print_progname = error_print;
  150.   gram_max_allowed_errors = INT_MAX;
  151.  
  152. #ifdef HAVE_SETLOCALE
  153.   /* Set locale via LC_ALL.  */
  154.   setlocale (LC_ALL, "");
  155. #endif
  156.  
  157.   /* Set the text message domain.  */
  158.   bindtextdomain (PACKAGE, LOCALEDIR);
  159.   textdomain (PACKAGE);
  160.  
  161.   /* Set default values for variables.  */
  162.   do_help = 0;
  163.   do_version = 0;
  164.   output_file = NULL;
  165.  
  166.   while ((opt
  167.       = getopt_long (argc, argv, "D:eEFhio:qsvVw:", long_options, NULL))
  168.      != EOF)
  169.     switch (opt)
  170.       {
  171.       case '\0':        /* Long option.  */
  172.     break;
  173.  
  174.       case 'D':
  175.     dir_list_append (optarg);
  176.     break;
  177.  
  178.       case 'e':
  179.     message_print_style_escape (0);
  180.     break;
  181.  
  182.       case 'E':
  183.     message_print_style_escape (1);
  184.     break;
  185.  
  186.       case 'F':
  187.         sort_by_filepos = 1;
  188.         break;
  189.  
  190.       case 'h':
  191.     do_help = 1;
  192.     break;
  193.  
  194.       case 'i':
  195.     message_print_style_indent ();
  196.     break;
  197.  
  198.       case 'o':
  199.     output_file = optarg;
  200.     break;
  201.  
  202.       case 'q':
  203.     quiet = 1;
  204.     break;
  205.  
  206.       case 's':
  207.         sort_by_msgid = 1;
  208.         break;
  209.  
  210.       case 'S':
  211.     message_print_style_uniforum ();
  212.     break;
  213.  
  214.       case 'v':
  215.     ++verbosity_level;
  216.     break;
  217.  
  218.       case 'V':
  219.     do_version = 1;
  220.     break;
  221.  
  222.       case 'w':
  223.     {
  224.       int value;
  225.       char *endp;
  226.       value = strtol (optarg, &endp, 10);
  227.       if (endp != optarg)
  228.         message_page_width_set (value);
  229.     }
  230.     break;
  231.  
  232.       default:
  233.     usage (EXIT_FAILURE);
  234.     break;
  235.       }
  236.  
  237.   /* Version information is requested.  */
  238.   if (do_version)
  239.     {
  240.       fprintf (stderr, "%s - GNU %s %s\n", program_name, PACKAGE, VERSION);
  241.       exit (EXIT_SUCCESS);
  242.     }
  243.  
  244.   /* Help is requested.  */
  245.   if (do_help)
  246.     usage (EXIT_SUCCESS);
  247.  
  248.   /* Test whether we have an .po file name as argument.  */
  249.   if (optind >= argc)
  250.     {
  251.       error (EXIT_SUCCESS, 0, _("no input files given"));
  252.       usage (EXIT_FAILURE);
  253.     }
  254.   if (optind + 2 != argc)
  255.     {
  256.       error (EXIT_SUCCESS, 0, _("exactly 2 input files required"));
  257.       usage (EXIT_FAILURE);
  258.     }
  259.  
  260.   /* merge the two files */
  261.   result = merge (argv[optind], argv[optind + 1]);
  262.  
  263.   /* Sort the results.  */
  264.   if (sort_by_filepos)
  265.     message_list_sort_by_filepos (result);
  266.   else if (sort_by_msgid)
  267.     message_list_sort_by_msgid (result);
  268.  
  269.   /* Write the merged message list out.  */
  270.   message_list_print (result, output_file, 0, 0);
  271.  
  272.   exit (EXIT_SUCCESS);
  273. }
  274.  
  275.  
  276. /* Display usage information and exit.  */
  277. static void
  278. usage (status)
  279.      int status;
  280. {
  281.   if (status != EXIT_SUCCESS)
  282.     fprintf (stderr, _("Try `%s --help' for more information\n"),
  283.          program_name);
  284.   else
  285.     {
  286.       /* xgettext: no-wrap */
  287.       printf (_("\
  288. Usage: %s [OPTION] def.po ref.po\n\
  289. Mandatory arguments to long options are mandatory for short options too.\n\
  290.   -D, --directory=DIRECTORY   add DIRECTORY to list for input files search\n\
  291.   -e, --no-escape             do not use C escapes in output (default)\n\
  292.   -E, --escape                use C escapes in output, no extended chars\n\
  293.   -h, --help                  display this help and exit\n\
  294.   -i, --indent                indented output style\n\
  295.   -o, --output-file=FILE      result will be written to FILE\n\
  296.       --strict                strict Uniforum output style\n\
  297.   -v, --verbose               increase verbosity level\n\
  298.   -V, --version               output version information and exit\n\
  299.   -w, --width=NUMBER          set output page width\n"),
  300.         program_name);
  301.       /* xgettext: no-wrap */
  302.       fputs (_("\n\
  303. Merges two Uniforum style .po files together.  The def.po file is an\n\
  304. existing PO file with the old translations which will be taken over to\n\
  305. the newly created file as long as they still match; comments will be\n\
  306. preserved, but extract comments and file positions will be discarded.\n\
  307. The ref.po file is the last created PO file (generally by xgettext), any\n\
  308. translations or comments in the file will be discarded, however dot\n\
  309. comments and file positions will be preserved.  Where an exact match\n\
  310. cannot be found, fuzzy matching is used to produce better results.  The\n\
  311. results are written to stdout unless an output file is specified.\n"),
  312.          stdout);
  313.     }
  314.  
  315.   exit (status);
  316. }
  317.  
  318.  
  319. /* The address of this function will be assigned to the hook in the
  320.    error functions.  */
  321. static void
  322. error_print ()
  323. {
  324.   /* We don't want the program name to be printed in messages.  Emacs'
  325.      compile.el does not like this.  */
  326.  
  327.   /* FIXME Why must this program toady to Emacs?  Why can't compile.el
  328.      be enhanced to cope with a leading program name?  --PMiller */
  329. }
  330.  
  331.  
  332. static void
  333. merge_constructor (that)
  334.      po_ty *that;
  335. {
  336.   merge_class_ty *this = (merge_class_ty *) that;
  337.  
  338.   this->mlp = message_list_alloc ();
  339.   this->domain = MESSAGE_DOMAIN_DEFAULT;
  340.   this->domain_list = string_list_alloc ();
  341.   this->comment = NULL;
  342.   this->comment_dot = NULL;
  343.   this->filepos_count = 0;
  344.   this->filepos = NULL;
  345.   this->is_fuzzy = 0;
  346.   this->is_c_format = undecided;
  347.   this->do_wrap = undecided;
  348. }
  349.  
  350.  
  351. static void
  352. merge_destructor (that)
  353.      po_ty *that;
  354. {
  355.   merge_class_ty *this = (merge_class_ty *) that;
  356.   size_t j;
  357.  
  358.   string_list_free (this->domain_list);
  359.   /* Do not free this->mlp.  */
  360.   if (this->comment != NULL)
  361.     string_list_free (this->comment);
  362.   if (this->comment_dot != NULL)
  363.     string_list_free (this->comment_dot);
  364.   for (j = 0; j < this->filepos_count; ++j)
  365.     free (this->filepos[j].file_name);
  366.   if (this->filepos != NULL)
  367.     free (this->filepos);
  368. }
  369.  
  370.  
  371. static void
  372. merge_directive_domain (that, name)
  373.      po_ty *that;
  374.      char *name;
  375. {
  376.   size_t j;
  377.  
  378.   merge_class_ty *this = (merge_class_ty *) that;
  379.   /* Override current domain name.  Don't free memory.  */
  380.   this->domain = name;
  381.  
  382.   /* If there are accumulated comments, throw them away, they are
  383.      probably part of the file header, or about the domain directive,
  384.      and will be unrelated to the next message.  */
  385.   if (this->comment != NULL)
  386.     {
  387.       string_list_free (this->comment);
  388.       this->comment = NULL;
  389.     }
  390.   if (this->comment_dot != NULL)
  391.     {
  392.       string_list_free (this->comment_dot);
  393.       this->comment_dot = NULL;
  394.     }
  395.   for (j = 0; j < this->filepos_count; ++j)
  396.     free (this->filepos[j].file_name);
  397.   if (this->filepos != NULL)
  398.     free (this->filepos);
  399.   this->filepos_count = 0;
  400.   this->filepos = NULL;
  401. }
  402.  
  403.  
  404. static void
  405. merge_directive_message (that, msgid, msgid_pos, msgstr, msgstr_pos)
  406.      po_ty *that;
  407.      char *msgid;
  408.      lex_pos_ty *msgid_pos;
  409.      char *msgstr;
  410.      lex_pos_ty *msgstr_pos;
  411. {
  412.   merge_class_ty *this = (merge_class_ty *) that;
  413.   message_ty *mp;
  414.   message_variant_ty *mvp;
  415.   size_t j;
  416.  
  417.   /* Remember the domain names for later.  */
  418.   string_list_append_unique (this->domain_list, this->domain);
  419.  
  420.   /* See if this message ID has been seen before.  */
  421.   mp = message_list_search (this->mlp, msgid);
  422.   if (mp)
  423.     free (msgid);
  424.   else
  425.     {
  426.       mp = message_alloc (msgid);
  427.       message_list_append (this->mlp, mp);
  428.     }
  429.  
  430.   /* Add the accumulated comments to the message.  Clear the
  431.      accumulation in preparation for the next message.  */
  432.   if (this->comment != NULL)
  433.     {
  434.       for (j = 0; j < this->comment->nitems; ++j)
  435.     message_comment_append (mp, this->comment->item[j]);
  436.       string_list_free (this->comment);
  437.       this->comment = NULL;
  438.     }
  439.   if (this->comment_dot != NULL)
  440.     {
  441.       for (j = 0; j < this->comment_dot->nitems; ++j)
  442.     message_comment_dot_append (mp, this->comment_dot->item[j]);
  443.       string_list_free (this->comment_dot);
  444.       this->comment_dot = NULL;
  445.     }
  446.   for (j = 0; j < this->filepos_count; ++j)
  447.     {
  448.       lex_pos_ty *pp;
  449.  
  450.       pp = &this->filepos[j];
  451.       message_comment_filepos (mp, pp->file_name, pp->line_number);
  452.       free (pp->file_name);
  453.     }
  454.   mp->is_fuzzy = this->is_fuzzy;
  455.   mp->is_c_format = this->is_c_format;
  456.   mp->do_wrap = this->do_wrap;
  457.  
  458.   if (this->filepos != NULL)
  459.     free (this->filepos);
  460.   this->filepos_count = 0;
  461.   this->filepos = NULL;
  462.   this->is_fuzzy = 0;
  463.   this->is_c_format = undecided;
  464.   this->do_wrap = undecided;
  465.  
  466.   /* See if this domain has been seen for this message ID.  */
  467.   mvp = message_variant_search (mp, this->domain);
  468.   if (mvp)
  469.     {
  470.       gram_error_at_line (msgid_pos, _("duplicate message definition"));
  471.       gram_error_at_line (&mvp->pos, _("\
  472. this is the location of the first definition"));
  473.       free (msgstr);
  474.     }
  475.   else
  476.     message_variant_append (mp, this->domain, msgstr, msgstr_pos);
  477. }
  478.  
  479.  
  480. static void
  481. merge_parse_brief (that)
  482.      po_ty *that;
  483. {
  484.   po_lex_pass_comments (1);
  485. }
  486.  
  487.  
  488. static void
  489. merge_parse_debrief (that)
  490.      po_ty *that;
  491. {
  492.   merge_class_ty *this = (merge_class_ty *) that;
  493.   message_list_ty *mlp = this->mlp;
  494.   size_t j;
  495.  
  496.   /* For each domain in the used-domain-list, make sure each message
  497.      defines a msgstr in that domain.  */
  498.   for (j = 0; j < this->domain_list->nitems; ++j)
  499.     {
  500.       const char *domain_name;
  501.       size_t k;
  502.  
  503.       domain_name = this->domain_list->item[j];
  504.       for (k = 0; k < mlp->nitems; ++k)
  505.     {
  506.       const message_ty *mp;
  507.       size_t m;
  508.  
  509.       mp = mlp->item[k];
  510.       for (m = 0; m < mp->variant_count; ++m)
  511.         {
  512.           message_variant_ty *mvp;
  513.  
  514.           mvp = &mp->variant[m];
  515.           if (strcmp (domain_name, mvp->domain) == 0)
  516.         break;
  517.         }
  518.       if (m >= mp->variant_count)
  519.         gram_error_at_line (&mp->variant[0].pos, _("\
  520. this message has no definition in the \"%s\" domain"), domain_name);
  521.     }
  522.     }
  523. }
  524.  
  525.  
  526. static void
  527. merge_comment (that, s)
  528.      po_ty *that;
  529.      const char *s;
  530. {
  531.   merge_class_ty *this = (merge_class_ty *) that;
  532.  
  533.   if (this->comment == NULL)
  534.     this->comment = string_list_alloc ();
  535.   string_list_append (this->comment, s);
  536. }
  537.  
  538.  
  539. static void
  540. merge_comment_dot (that, s)
  541.      po_ty *that;
  542.      const char *s;
  543. {
  544.   merge_class_ty *this = (merge_class_ty *) that;
  545.  
  546.   if (this->comment_dot == NULL)
  547.     this->comment_dot = string_list_alloc ();
  548.   string_list_append (this->comment_dot, s);
  549. }
  550.  
  551.  
  552. static void
  553. merge_comment_special (that, s)
  554.      po_ty *that;
  555.      const char *s;
  556. {
  557.   merge_class_ty *this = (merge_class_ty *) that;
  558.  
  559.   if (strstr (s, "fuzzy") != NULL)
  560.     this->is_fuzzy = 1;
  561.  
  562.   this->is_c_format = parse_c_format_description_string (s);
  563.   this->do_wrap = parse_c_width_description_string (s);
  564. }
  565.  
  566.  
  567. static void
  568. merge_comment_filepos (that, name, line)
  569.      po_ty *that;
  570.      const char *name;
  571.      int line;
  572. {
  573.   merge_class_ty *this = (merge_class_ty *) that;
  574.   size_t nbytes;
  575.   lex_pos_ty *pp;
  576.  
  577.   nbytes = (this->filepos_count + 1) * sizeof (this->filepos[0]);
  578.   this->filepos = xrealloc (this->filepos, nbytes);
  579.   pp = &this->filepos[this->filepos_count++];
  580.   pp->file_name = xstrdup (name);
  581.   pp->line_number = line;
  582. }
  583.  
  584.  
  585. /* So that the one parser can be used for multiple programs, and also
  586.    use good data hiding and encapsulation practices, an object
  587.    oriented approach has been taken.  An object instance is allocated,
  588.    and all actions resulting from the parse will be through
  589.    invokations of method functions of that object.  */
  590.  
  591. static po_method_ty merge_methods =
  592. {
  593.   sizeof (merge_class_ty),
  594.   merge_constructor,
  595.   merge_destructor,
  596.   merge_directive_domain,
  597.   merge_directive_message,
  598.   merge_parse_brief,
  599.   merge_parse_debrief,
  600.   merge_comment,
  601.   merge_comment_dot,
  602.   merge_comment_filepos,
  603.   merge_comment_special
  604. };
  605.  
  606.  
  607. static message_list_ty *
  608. grammar (filename)
  609.      const char *filename;
  610. {
  611.   po_ty *pop;
  612.   message_list_ty *mlp;
  613.  
  614.   pop = po_alloc (&merge_methods);
  615.   po_lex_pass_obsolete_entries (1);
  616.   po_scan (pop, filename);
  617.   mlp = ((merge_class_ty *) pop)->mlp;
  618.   po_free (pop);
  619.   return mlp;
  620. }
  621.  
  622.  
  623. #define DOT_FREQUENCE 10
  624.  
  625. static message_list_ty *
  626. merge (fn1, fn2)
  627.      const char *fn1;            /* definitions */
  628.      const char *fn2;            /* references */
  629. {
  630.   message_list_ty *def;
  631.   message_list_ty *ref;
  632.   message_ty *defmsg;
  633.   size_t j, k;
  634.   size_t merged, fuzzied, missing, obsolete;
  635.   message_list_ty *result;
  636.  
  637.   merged = fuzzied = missing = obsolete = 0;
  638.  
  639.   /* This is the definitions file, created by a human.  */
  640.   def = grammar (fn1);
  641.  
  642.   /* This is the references file, created by groping the sources with
  643.      the xgettext program.  */
  644.   ref = grammar (fn2);
  645.  
  646.   result = message_list_alloc ();
  647.  
  648.   /* Every reference must be matched with its definition. */
  649.   for (j = 0; j < ref->nitems; ++j)
  650.     {
  651.       message_ty *refmsg;
  652.  
  653.       /* Because merging can take a while we print something to signal
  654.      we are not dead.  */
  655.       if (!quiet && verbosity_level <= 1 && j % DOT_FREQUENCE == 0)
  656.     fputc ('.', stderr);
  657.  
  658.       refmsg = ref->item[j];
  659.  
  660.       /* See if it is in the other file.  */
  661.       defmsg = message_list_search (def, refmsg->msgid);
  662.       if (defmsg)
  663.     {
  664.       /* Merge the reference with the definition: take the #. and
  665.          #: comments from the reference, take the # comments from
  666.          the definition, take the msgstr from the definition.  Add
  667.          this merged entry to the output message list.  */
  668.       message_ty *mp = message_merge (defmsg, refmsg);
  669.  
  670.       message_list_append (result, mp);
  671.  
  672.       /* Remember that this message has been used, when we scan
  673.          later to see if anything was omitted.  */
  674.       defmsg->used = 1;
  675.       ++merged;
  676.       continue;
  677.     }
  678.  
  679.       /* If the message was not defined at all, try to find a very
  680.      similar message, it could be a typo, or the suggestion may
  681.      help.  */
  682.       defmsg = message_list_search_fuzzy (def, refmsg->msgid);
  683.       if (defmsg)
  684.     {
  685.       message_ty *mp;
  686.  
  687.       if (verbosity_level > 1)
  688.         {
  689.           gram_error_at_line (&refmsg->variant[0].pos, _("\
  690. this message is used but not defined..."));
  691.           gram_error_at_line (&defmsg->variant[0].pos, _("\
  692. ...but this definition is similar"));
  693.         }
  694.  
  695.       /* Merge the reference with the definition: take the #. and
  696.          #: comments from the reference, take the # comments from
  697.          the definition, take the msgstr from the definition.  Add
  698.          this merged entry to the output message list.  */
  699.       mp = message_merge (defmsg, refmsg);
  700.  
  701.       mp->is_fuzzy = 1;
  702.  
  703.       message_list_append (result, mp);
  704.  
  705.       /* Remember that this message has been used, when we scan
  706.          later to see if anything was omitted.  */
  707.       defmsg->used = 1;
  708.       ++fuzzied;
  709.       if (!quiet && verbosity_level <= 1)
  710.         /* Always print a dot if we handled a fuzzy match.  */
  711.         fputc ('.', stderr);
  712.     }
  713.       else
  714.     {
  715.       message_ty *mp;
  716.  
  717.       if (verbosity_level > 1)
  718.           gram_error_at_line (&refmsg->variant[0].pos, _("\
  719. this message is used but not defined in %s"), fn1);
  720.  
  721.       mp = message_copy (refmsg);
  722.  
  723.       message_list_append (result, mp);
  724.       ++missing;
  725.     }
  726.     }
  727.  
  728.   /* Look for messages in the definition file, which are not present
  729.      in the reference file, indicating messages which defined but not
  730.      used in the program.  */
  731.   for (k = 0; k < def->nitems; ++k)
  732.     {
  733.       defmsg = def->item[k];
  734.       if (defmsg->used)
  735.     continue;
  736.  
  737.       /* Remember the old translation although it is not used anymore.
  738.      But we mark it as obsolete.  */
  739.       defmsg->obsolete = 1;
  740.  
  741.       message_list_append (result, defmsg);
  742.       ++obsolete;
  743.     }
  744.  
  745.   /* Report some statistics.  */
  746.   if (verbosity_level > 0)
  747.     fprintf (stderr, _("%s\
  748. Read %d old + %d reference, \
  749. merged %d, fuzzied %d, missing %d, obsolete %d.\n"),
  750.          !quiet && verbosity_level <= 1 ? "\n" : "",
  751.          def->nitems, ref->nitems, merged, fuzzied, missing, obsolete);
  752.   else if (!quiet)
  753.     fputs (_(" done.\n"), stderr);
  754.  
  755.   return result;
  756. }
  757.