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 / msgcmp.c < prev    next >
C/C++ Source or Header  |  1996-09-28  |  11KB  |  429 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 <stdio.h>
  26.  
  27. #ifdef STDC_HEADERS
  28. # include <stdlib.h>
  29. #endif
  30.  
  31. #ifdef HAVE_LOCALE_H
  32. # include <locale.h>
  33. #endif
  34.  
  35. #include "dir-list.h"
  36. #include "error.h"
  37. #include "message.h"
  38. #include <system.h>
  39. #include <libintl.h>
  40. #include "po.h"
  41. #include "str-list.h"
  42.  
  43. #define _(str) gettext (str)
  44.  
  45.  
  46. /* This structure defines a derived class of the po_ty class.  (See
  47.    po.h for an explanation.)  */
  48. typedef struct compare_class_ty compare_class_ty;
  49. struct compare_class_ty
  50. {
  51.   /* inherited instance variables, etc */
  52.   PO_BASE_TY
  53.  
  54.   /* Name of domain we are currently examining.  */
  55.   char *domain;
  56.  
  57.   /* List of domains already appeared in the current file.  */
  58.   string_list_ty *domain_list;
  59.  
  60.   /* List of messages already appeared in the current file.  */
  61.   message_list_ty *mlp;
  62. };
  63.  
  64. /* String containing name the program is called with.  */
  65. const char *program_name;
  66.  
  67. /* Long options.  */
  68. static const struct option long_options[] =
  69. {
  70.   { "directory", required_argument, NULL, 'D' },
  71.   { "help", no_argument, NULL, 'h' },
  72.   { "version", no_argument, NULL, 'V' },
  73.   { NULL, 0, NULL, 0 }
  74. };
  75.  
  76.  
  77. /* Prototypes for local functions.  */
  78. static void usage PARAMS ((int __status));
  79. static void error_print PARAMS ((void));
  80. static void compare PARAMS ((char *, char *));
  81. static message_list_ty *grammar PARAMS ((char *__filename));
  82. static void compare_constructor PARAMS ((po_ty *__that));
  83. static void compare_destructor PARAMS ((po_ty *__that));
  84. static void compare_directive_domain PARAMS ((po_ty *__that, char *__name));
  85. static void compare_directive_message PARAMS ((po_ty *__that, char *__msgid,
  86.                            lex_pos_ty *msgid_pos,
  87.                            char *__msgstr,
  88.                            lex_pos_ty *__msgstr_pos));
  89. static void compare_parse_debrief PARAMS ((po_ty *__that));
  90.  
  91.  
  92. int
  93. main (argc, argv)
  94.      int argc;
  95.      char *argv[];
  96. {
  97.   int optchar;
  98.   int do_help;
  99.   int do_version;
  100.  
  101.   /* Set program name for messages.  */
  102.   program_name = argv[0];
  103.   error_print_progname = error_print;
  104.  
  105. #ifdef HAVE_SETLOCALE
  106.   /* Set locale via LC_ALL.  */
  107.   setlocale (LC_ALL, "");
  108. #endif
  109.  
  110.   /* Set the text message domain.  */
  111.   bindtextdomain (PACKAGE, LOCALEDIR);
  112.   textdomain (PACKAGE);
  113.  
  114.   do_help = 0;
  115.   do_version = 0;
  116.   while ((optchar = getopt_long (argc, argv, "D:hV", long_options, NULL))
  117.      != EOF)
  118.     switch (optchar)
  119.       {
  120.       case '\0':        /* long option */
  121.     break;
  122.  
  123.       case 'D':
  124.     dir_list_append (optarg);
  125.     break;
  126.  
  127.       case 'h':
  128.     do_help = 1;
  129.     break;
  130.  
  131.       case 'V':
  132.     do_version = 1;
  133.     break;
  134.  
  135.       default:
  136.     usage (EXIT_FAILURE);
  137.     break;
  138.       }
  139.  
  140.   /* Version information is requested.  */
  141.   if (do_version)
  142.     {
  143.       fprintf (stderr, "%s - GNU %s %s\n", program_name, PACKAGE, VERSION);
  144.       exit (EXIT_SUCCESS);
  145.     }
  146.  
  147.   /* Help is requested.  */
  148.   if (do_help)
  149.     usage (EXIT_SUCCESS);
  150.  
  151.   /* Test whether we have an .po file name as argument.  */
  152.   if (optind >= argc)
  153.     {
  154.       error (EXIT_SUCCESS, 0, _("no input files given"));
  155.       usage (EXIT_FAILURE);
  156.     }
  157.   if (optind + 2 != argc)
  158.     {
  159.       error (EXIT_SUCCESS, 0, _("exactly 2 input files required"));
  160.       usage (EXIT_FAILURE);
  161.     }
  162.  
  163.   /* compare the two files */
  164.   compare (argv[optind], argv[optind + 1]);
  165.   exit (EXIT_SUCCESS);
  166. }
  167.  
  168.  
  169. /* Display usage information and exit.  */
  170. static void
  171. usage (status)
  172.      int status;
  173. {
  174.   if (status != EXIT_SUCCESS)
  175.     fprintf (stderr, _("Try `%s --help' for more information\n"),
  176.          program_name);
  177.   else
  178.     /* xgettext: no-wrap */
  179.     printf (_("\
  180. Usage: %s [OPTION] def.po ref.po\n\
  181. Mandatory arguments to long options are mandatory for short options too.\n\
  182.   -D, --directory=DIRECTORY   add DIRECTORY to list for input files search\n\
  183.   -h, --help                  display this help and exit\n\
  184.   -V, --version               output version information and exit\n\
  185. \n\
  186. Compare two Uniforum style .po files to check that both contain the same\n\
  187. set of msgid strings.  The def.po file is an existing PO file with the\n\
  188. old translations.  The ref.po file is the last created PO file\n\
  189. (generally by xgettext).  This is useful for checking that you have\n\
  190. translated each and every message in your program.  Where an exact match\n\
  191. cannot be found, fuzzy matching is used to produce better diagnostics.\n"),
  192.         program_name);
  193.  
  194.   exit (status);
  195. }
  196.  
  197.  
  198. /* The address of this function will be assigned to the hook in the error
  199.    functions.  */
  200. static void
  201. error_print ()
  202. {
  203.   /* We don't want the program name to be printed in messages.  Emacs'
  204.      compile.el does not like this.  */
  205. }
  206.  
  207.  
  208. static void
  209. compare (fn1, fn2)
  210.      char *fn1;
  211.      char *fn2;
  212. {
  213.   message_list_ty *list1;
  214.   message_list_ty *list2;
  215.   int nerrors;
  216.   message_ty *mp1;
  217.   size_t j, k;
  218.  
  219.   /* This is the master file, created by a human.  */
  220.   list1 = grammar (fn1);
  221.  
  222.   /* This is the generated file, created by groping the sources with
  223.      the xgettext program.  */
  224.   list2 = grammar (fn2);
  225.  
  226.   /* Every entry in the xgettext generated file must be matched by a
  227.      (single) entry in the human created file.  */
  228.   nerrors = 0;
  229.   for (j = 0; j < list2->nitems; ++j)
  230.     {
  231.       message_ty *mp2;
  232.  
  233.       mp2 = list2->item[j];
  234.  
  235.       /* See if it is in the other file.  */
  236.       mp1 = message_list_search (list1, mp2->msgid);
  237.       if (mp1)
  238.     {
  239.       mp1->used = 1;
  240.       continue;
  241.     }
  242.  
  243.       /* If the message was not defined at all, try to find a very
  244.      similar message, it could be a typo, or the suggestion may
  245.      help.  */
  246.       ++nerrors;
  247.       mp1 = message_list_search_fuzzy (list1, mp2->msgid);
  248.       if (mp1)
  249.     {
  250.       gram_error_at_line (&mp2->variant[0].pos, _("\
  251. this message is used but not defined..."));
  252.       gram_error_at_line (&mp1->variant[0].pos, _("\
  253. ...but this definition is similar"));
  254.       mp1->used = 1;
  255.     }
  256.       else
  257.     {
  258.       gram_error_at_line (&mp2->variant[0].pos, _("\
  259. this message is used but not defined in %s"), fn1);
  260.     }
  261.     }
  262.  
  263.   /* Look for messages in the human generated file, which are not
  264.      present in the xgettext generated file, indicating messages which
  265.      are not used in the program.  */
  266.   for (k = 0; k < list1->nitems; ++k)
  267.     {
  268.       mp1 = list1->item[k];
  269.       if (mp1->used)
  270.     continue;
  271.       gram_error_at_line (&mp1->variant[0].pos,
  272.                _("warning: this message is not used"));
  273.     }
  274.  
  275.   /* Exit with status 1 on any error.  */
  276.   if (nerrors > 0)
  277.     error (EXIT_FAILURE, 0, "found %d fatal errors", nerrors);
  278. }
  279.  
  280.  
  281. /* Local functions.  */
  282.  
  283. static void
  284. compare_constructor (that)
  285.      po_ty *that;
  286. {
  287.   compare_class_ty *this = (compare_class_ty *) that;
  288.  
  289.   this->mlp = message_list_alloc ();
  290.   this->domain = MESSAGE_DOMAIN_DEFAULT;
  291.   this->domain_list = string_list_alloc ();
  292. }
  293.  
  294.  
  295. static void
  296. compare_destructor (that)
  297.      po_ty *that;
  298. {
  299.   compare_class_ty *this = (compare_class_ty *) that;
  300.  
  301.   string_list_free (this->domain_list);
  302.   /* Do not free this->mlp!  */
  303. }
  304.  
  305.  
  306. static void
  307. compare_directive_domain (that, name)
  308.      po_ty *that;
  309.      char *name;
  310. {
  311.   compare_class_ty *this = (compare_class_ty *)that;
  312.   /* Override current domain name.  Don't free memory.  */
  313.   this->domain = name;
  314. }
  315.  
  316.  
  317. static void
  318. compare_directive_message (that, msgid, msgid_pos, msgstr, msgstr_pos)
  319.      po_ty *that;
  320.      char *msgid;
  321.      lex_pos_ty *msgid_pos;
  322.      char *msgstr;
  323.      lex_pos_ty *msgstr_pos;
  324. {
  325.   compare_class_ty *this = (compare_class_ty *) that;
  326.   message_ty *mp;
  327.   message_variant_ty *mvp;
  328.  
  329.   /* Remember the domain names for later.  */
  330.   string_list_append_unique (this->domain_list, this->domain);
  331.  
  332.   /* See if this message ID has been seen before.  */
  333.   mp = message_list_search (this->mlp, msgid);
  334.   if (mp)
  335.     free (msgid);
  336.   else
  337.     {
  338.       mp = message_alloc (msgid);
  339.       message_list_append (this->mlp, mp);
  340.     }
  341.  
  342.   /* See if this domain has been seen for this message ID.  */
  343.   mvp = message_variant_search (mp, this->domain);
  344.   if (mvp)
  345.     {
  346.       gram_error_at_line (msgid_pos, _("duplicate message definition"));
  347.       gram_error_at_line (&mvp->pos, _("\
  348. this is the location of the first definition"));
  349.       free (msgstr);
  350.     }
  351.   else
  352.     message_variant_append (mp, this->domain, msgstr, msgstr_pos);
  353. }
  354.  
  355.  
  356. static void
  357. compare_parse_debrief (that)
  358.      po_ty *that;
  359. {
  360.   compare_class_ty *this = (compare_class_ty *) that;
  361.   message_list_ty *mlp = this->mlp;
  362.   size_t j;
  363.  
  364.   /* For each domain in the used-domain-list, make sure each message
  365.      defines a msgstr in that domain.  */
  366.   for (j = 0; j < this->domain_list->nitems; ++j)
  367.     {
  368.       const char *domain_name;
  369.       size_t k;
  370.  
  371.       domain_name = this->domain_list->item[j];
  372.       for (k = 0; k < mlp->nitems; ++k)
  373.     {
  374.       const message_ty *mp;
  375.       size_t m;
  376.  
  377.       mp = mlp->item[k];
  378.       for (m = 0; m < mp->variant_count; ++m)
  379.         {
  380.           message_variant_ty *mvp;
  381.  
  382.           mvp = &mp->variant[m];
  383.           if (strcmp (domain_name, mvp->domain) == 0)
  384.         break;
  385.         }
  386.       if (m >= mp->variant_count)
  387.         gram_error_at_line (&mp->variant[0].pos, _("\
  388. this message has no definition in the \"%s\" domain"), domain_name);
  389.     }
  390.     }
  391. }
  392.  
  393.  
  394. /* So that the one parser can be used for multiple programs, and also
  395.    use good data hiding and encapsulation practices, an object
  396.    oriented approach has been taken.  An object instance is allocated,
  397.    and all actions resulting from the parse will be through
  398.    invokations of method functions of that object.  */
  399.  
  400. static po_method_ty compare_methods =
  401. {
  402.   sizeof (compare_class_ty),
  403.   compare_constructor,
  404.   compare_destructor,
  405.   compare_directive_domain,
  406.   compare_directive_message,
  407.   NULL, /* parse_brief */
  408.   compare_parse_debrief,
  409.   NULL, /* comment */
  410.   NULL, /* comment_dot */
  411.   NULL, /* comment_filepos */
  412.   NULL, /* comment_special */
  413. };
  414.  
  415.  
  416. static message_list_ty *
  417. grammar (filename)
  418.      char *filename;
  419. {
  420.   po_ty *pop;
  421.   message_list_ty *mlp;
  422.  
  423.   pop = po_alloc(&compare_methods);
  424.   po_scan(pop, filename);
  425.   mlp = ((compare_class_ty *)pop)->mlp;
  426.   po_free(pop);
  427.   return mlp;
  428. }
  429.