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 / xgettext.c < prev   
C/C++ Source or Header  |  1996-09-28  |  33KB  |  1,215 lines
  1. /* xgettext - extracts strings from C source file to Uniforum style .po file
  2.    Copyright (C) 1995, 1996 Free Software Foundation, Inc.
  3.    Written by Ulrich Drepper <drepper@gnu.ai.mit.edu>, April 1995.
  4.  
  5. This program is free software; you can redistribute it and/or modify
  6. it under the terms of the GNU General Public License as published by
  7. the Free Software Foundation; either version 2, or (at your option)
  8. any later version.
  9.  
  10. This program is distributed in the hope that it will be useful,
  11. but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13. GNU General Public License for more details.
  14.  
  15. You should have received a copy of the GNU General Public License
  16. along with this program; if not, write to the Free Software
  17. Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  18.  
  19. #ifdef HAVE_CONFIG_H
  20. # include <config.h>
  21. #endif
  22.  
  23. #include <ctype.h>
  24. #include <errno.h>
  25. #include <getopt.h>
  26. #include <pwd.h>
  27. #include <stdio.h>
  28. #include <time.h>
  29. #include <sys/types.h>
  30.  
  31. #ifdef STDC_HEADERS
  32. # include <stdlib.h>
  33. #endif
  34.  
  35. #ifdef HAVE_LOCALE_H
  36. # include <locale.h>
  37. #endif
  38.  
  39. #ifdef HAVE_UNISTD_H
  40. # include <unistd.h>
  41. #endif
  42.  
  43. #ifndef errno
  44. extern int errno;
  45. #endif
  46.  
  47. #include "dir-list.h"
  48. #include "error.h"
  49. #include "hash.h"
  50. #include "getline.h"
  51. #include "system.h"
  52. #include "po.h"
  53. #include "message.h"
  54. #include "xget-lex.h"
  55. #include "printf-parse.h"
  56.  
  57. #include "gettext.h"
  58. #include "domain.h"
  59. #include <libintl.h>
  60.  
  61. #ifndef _POSIX_VERSION
  62. struct passwd *getpwuid ();
  63. #endif
  64.  
  65.  
  66. /* A convenience macro.  I don't like writing gettext() every time.  */
  67. #define _(str) gettext (str)
  68.  
  69.  
  70. /* If nonzero add all comments immediately preceding one of the keywords. */
  71. static int add_all_comments;
  72.  
  73. /* If nonzero add comments for file name and line number for each msgid.  */
  74. static int line_comment;
  75.  
  76. /* Tag used in comment of prevailing domain.  */
  77. static char *comment_tag;
  78.  
  79. /* Name of default domain file.  If not set defaults to messages.po.  */
  80. static char *default_domain;
  81.  
  82. /* If called with --debug option the output reflects whether format
  83.    string recognision is done automatically or forced by the user.  */
  84. static int do_debug;
  85.  
  86. /* Content of .po files with symbols to be excluded.  */
  87. static message_list_ty *exclude;
  88.  
  89. /* If nonzero extract all strings.  */
  90. static int extract_all;
  91.  
  92. /* Force output of PO file even if empty.  */
  93. static int force_po;
  94.  
  95. /* String used as prefix for msgstr.  */
  96. static char *msgstr_prefix;
  97.  
  98. /* String used as suffix for msgstr.  */
  99. static char *msgstr_suffix;
  100.  
  101. /* Directory in which output files are created.  */
  102. static char *output_dir;
  103.  
  104. /* If nonzero omit header with information about this run.  */
  105. static int omit_header;
  106.  
  107. /* String containing name the program is called with.  */
  108. const char *program_name;
  109.  
  110. /* String length from with on warning are given for possible problem
  111.    while exceeding tools limits.  */
  112. static size_t warn_id_len;
  113.  
  114. /* Long options.  */
  115. static const struct option long_options[] =
  116. {
  117.   { "add-comments", optional_argument, NULL, 'c' },
  118.   { "add-location", no_argument, &line_comment, 1 },
  119.   { "c++", no_argument, NULL, 'C' },
  120.   { "debug", no_argument, &do_debug, 1 },
  121.   { "default-domain", required_argument, NULL, 'd' },
  122.   { "directory", required_argument, NULL, 'D' },
  123.   { "escape", no_argument, NULL, 'E' },
  124.   { "exclude-file", required_argument, NULL, 'x' },
  125.   { "extract-all", no_argument, &extract_all, 1 },
  126.   { "files-from", required_argument, NULL, 'f' },
  127.   { "force-po", no_argument, &force_po, 1 },
  128.   { "help", no_argument, NULL, 'h' },
  129.   { "indent", no_argument, NULL, 'i' },
  130.   { "join-existing", no_argument, NULL, 'j' },
  131.   { "keyword", optional_argument, NULL, 'k' },
  132.   { "msgstr-prefix", optional_argument, NULL, 'm' },
  133.   { "msgstr-suffix", optional_argument, NULL, 'M' },
  134.   { "no-escape", no_argument, NULL, 'e' },
  135.   { "no-location", no_argument, &line_comment, 0 },
  136.   { "omit-header", no_argument, &omit_header, 1 },
  137.   { "output-dir", required_argument, NULL, 'p' },
  138.   { "sort-by-file", no_argument, NULL, 'F' },
  139.   { "sort-output", no_argument, NULL, 's' },
  140.   { "strict", no_argument, NULL, 'S' },
  141.   { "string-limit", required_argument, NULL, 'l' },
  142.   { "trigraphs", no_argument, NULL, 'T' },
  143.   { "version", no_argument, NULL, 'V' },
  144.   { "width", required_argument, NULL, 'w', },
  145.   { NULL, 0, NULL, 0 }
  146. };
  147.  
  148.  
  149. /* Prototypes for local functions.  */
  150. static void usage PARAMS ((int status))
  151. #if defined __GNUC__ && ((__GNUC__ == 2 && __GNUC_MINOR__ > 4) || __GNUC__ > 2)
  152.     __attribute__ ((noreturn))
  153. #endif
  154. ;
  155. static void error_print PARAMS ((void));
  156. static string_list_ty *read_name_from_file PARAMS ((const char *__file_name));
  157. static void exclude_directive_domain PARAMS ((po_ty *__pop, char *__name));
  158. static void exclude_directive_message PARAMS ((po_ty *__pop, char *__msgid,
  159.                            lex_pos_ty *__msgid_pos,
  160.                            char *__msgstr,
  161.                            lex_pos_ty *__msgstr_pos));
  162. static void read_exclusion_file PARAMS ((char *__file_name));
  163. static void remember_a_message PARAMS ((message_list_ty *__mlp,
  164.                     xgettext_token_ty *__tp));
  165. static void scan_c_file PARAMS ((const char *__file_name,
  166.                  message_list_ty *__mlp,  int __is_cpp_file));
  167. static void extract_constructor PARAMS ((po_ty *__that));
  168. static void extract_directive_domain PARAMS ((po_ty *__that, char *__name));
  169. static void extract_directive_message PARAMS ((po_ty *__that, char *__msgid,
  170.                            lex_pos_ty *__msgid_pos,
  171.                            char *__msgstr,
  172.                            lex_pos_ty *__msgstr_pos));
  173. static void extract_parse_brief PARAMS ((po_ty *__that));
  174. static void extract_comment PARAMS ((po_ty *__that, const char *__s));
  175. static void extract_comment_dot PARAMS ((po_ty *__that, const char *__s));
  176. static void extract_comment_filepos PARAMS ((po_ty *__that, const char *__name,
  177.                          int __line));
  178. static void extract_comment_special PARAMS ((po_ty *that, const char *s));
  179. static void read_po_file PARAMS ((const char *__file_name,
  180.                   message_list_ty *__mlp));
  181. static long difftm PARAMS ((const struct tm *__a, const struct tm *__b));
  182. static message_ty *construct_header PARAMS ((void));
  183. static enum is_c_format test_whether_c_format PARAMS ((const char *__s));
  184.  
  185.  
  186. int
  187. main (argc, argv)
  188.      int argc;
  189.      char *argv[];
  190. {
  191.   int cnt;
  192.   int optchar;
  193.   int do_help = 0;
  194.   int do_version = 0;
  195.   message_list_ty *mlp;
  196.   int join_existing = 0;
  197.   int sort_output = 0;
  198.   int sort_by_file = 0;
  199.   char *file_name;
  200.   const char *files_from = NULL;
  201.   string_list_ty *file_list;
  202.   int input_files_are_cplusplus = 0;
  203.  
  204.   /* Set program name for messages.  */
  205.   program_name = argv[0];
  206.   error_print_progname = error_print;
  207.   warn_id_len = WARN_ID_LEN;
  208.  
  209. #ifdef HAVE_SETLOCALE
  210.   /* Set locale via LC_ALL.  */
  211.   setlocale (LC_ALL, "");
  212. #endif
  213.  
  214.   /* Set the text message domain.  */
  215.   bindtextdomain (PACKAGE, LOCALEDIR);
  216.   textdomain (PACKAGE);
  217.  
  218.   /* Set initial value of variables.  */
  219.   line_comment = -1;
  220.   default_domain = MESSAGE_DOMAIN_DEFAULT;
  221.  
  222.   while ((optchar = getopt_long (argc, argv,
  223.                  "ac::Cd:D:eEf:Fhijk::l:m::M::np:sTVw:x:",
  224.                  long_options, NULL)) != EOF)
  225.     switch (optchar)
  226.       {
  227.       case '\0':        /* Long option.  */
  228.     break;
  229.       case 'a':
  230.     extract_all = 1;
  231.     break;
  232.       case 'c':
  233.     if (optarg == NULL)
  234.       {
  235.         add_all_comments = 1;
  236.         comment_tag = NULL;
  237.       }
  238.     else
  239.       {
  240.         add_all_comments = 0;
  241.         comment_tag = optarg;
  242.         /* We ignore leading white space.  */
  243.         while (isspace (*comment_tag))
  244.           ++comment_tag;
  245.       }
  246.     break;
  247.       case 'C':
  248.     input_files_are_cplusplus = 1;
  249.     break;
  250.       case 'd':
  251.     default_domain = optarg;
  252.     break;
  253.       case 'D':
  254.     dir_list_append (optarg);
  255.     break;
  256.       case 'e':
  257.     message_print_style_escape (0);
  258.     break;
  259.       case 'E':
  260.     message_print_style_escape (1);
  261.     break;
  262.       case 'f':
  263.     files_from = optarg;
  264.     break;
  265.       case 'F':
  266.     sort_by_file = 1;
  267.         break;
  268.       case 'h':
  269.     do_help = 1;
  270.     break;
  271.       case 'i':
  272.     message_print_style_indent ();
  273.     break;
  274.       case 'j':
  275.     join_existing = 1;
  276.     break;
  277.       case 'k':
  278.     if (optarg == NULL || *optarg != '\0')
  279.       xgettext_lex_keyword (optarg);
  280.     break;
  281.       case 'l':
  282.     {
  283.       char *endp;
  284.       size_t tmp_val = strtoul (optarg, &endp, 0);
  285.       if (endp[0] == '\0')
  286.         warn_id_len = tmp_val;
  287.     }
  288.     break;
  289.       case 'm':
  290.     /* -m takes an optional argument.  If none is given "" is assumed. */
  291.     msgstr_prefix = optarg == NULL ? "" : optarg;
  292.     break;
  293.       case 'M':
  294.     /* -M takes an optional argument.  If none is given "" is assumed. */
  295.     msgstr_suffix = optarg == NULL ? "" : optarg;
  296.     break;
  297.       case 'n':
  298.     line_comment = 1;
  299.     break;
  300.       case 'p':
  301.     {
  302.       size_t len = strlen (optarg);
  303.  
  304.       if (output_dir != NULL)
  305.         free (output_dir);
  306.  
  307.       if (optarg[len - 1] == '/')
  308.         output_dir = xstrdup (optarg);
  309.       else
  310.         {
  311.           asprintf (&output_dir, "%s/", optarg);
  312.           if (output_dir == NULL)
  313.         /* We are about to construct the absolute path to the
  314.            directory for the output files but asprintf failed.  */
  315.         error (EXIT_FAILURE, errno, _("while preparing output"));
  316.         }
  317.     }
  318.     break;
  319.       case 's':
  320.     sort_output = 1;
  321.     break;
  322.       case 'S':
  323.     message_print_style_uniforum ();
  324.     break;
  325.       case 'T':
  326.     xgettext_lex_trigraphs ();
  327.     break;
  328.       case 'V':
  329.     do_version = 1;
  330.     break;
  331.       case 'w':
  332.     {
  333.       int value;
  334.       char *endp;
  335.       value = strtol (optarg, &endp, 10);
  336.       if (endp != optarg)
  337.         message_page_width_set (value);
  338.     }
  339.     break;
  340.       case 'x':
  341.     read_exclusion_file (optarg);
  342.     break;
  343.       default:
  344.     usage (EXIT_FAILURE);
  345.     /* NOTREACHED */
  346.       }
  347.  
  348.   /* Normalize selected options.  */
  349.   if (omit_header != 0 && line_comment < 0)
  350.     line_comment = 0;
  351.  
  352.   if (!line_comment && sort_by_file)
  353.     error (EXIT_FAILURE, 0, _("%s and %s are mutually exclusive"),
  354.        "--no-location", "--sort-by-file");
  355.  
  356.   if (sort_output && sort_by_file)
  357.     error (EXIT_FAILURE, 0, _("%s and %s are mutually exclusive"),
  358.        "--sort-output", "--sort-by-file");
  359.  
  360.   if (join_existing && strcmp (default_domain, "-") == 0)
  361.     error (EXIT_FAILURE, 0, _("\
  362. --join-existing cannot be used when output is written to stdout"));
  363.  
  364.   /* Version information requested.  */
  365.   if (do_version)
  366.     {
  367.       fprintf (stderr, "%s - GNU %s %s\n", program_name, PACKAGE, VERSION);
  368.       exit (EXIT_SUCCESS);
  369.     }
  370.  
  371.   /* Help is requested.  */
  372.   if (do_help)
  373.     usage (EXIT_SUCCESS);
  374.  
  375.   /* Test whether we have some input files given.  */
  376.   if (files_from == NULL && optind >= argc)
  377.     {
  378.       error (EXIT_SUCCESS, 0, _("no input file given"));
  379.       usage (EXIT_FAILURE);
  380.     }
  381.  
  382.   /* Canonize msgstr prefix/suffix.  */
  383.   if (msgstr_prefix != NULL && msgstr_suffix == NULL)
  384.     msgstr_suffix = "";
  385.   else if (msgstr_prefix == NULL && msgstr_suffix != NULL)
  386.     msgstr_prefix = NULL;
  387.  
  388.   /* Default output directory is the current directory.  */
  389.   if (output_dir == NULL)
  390.     output_dir = "./";
  391.  
  392.   /* Construct the name of the ouput file.  If the default domain has
  393.      the special name "-" we write to stdout.  */
  394.   if (strcmp (default_domain, "-") == 0)
  395.     file_name = "-";
  396.   else
  397.     {
  398.       file_name = (char *) xmalloc (strlen (output_dir)
  399.                     + strlen (default_domain)
  400.                     + sizeof (".po"));
  401.       stpcpy (stpcpy (stpcpy (file_name, output_dir), default_domain), ".po");
  402.     }
  403.  
  404.   /* Determine list of files we have to process.  */
  405.   if (files_from != NULL)
  406.     file_list = read_name_from_file (files_from);
  407.   else
  408.     file_list = string_list_alloc ();
  409.   /* Append names from command line.  */
  410.   for (cnt = optind; cnt < argc; ++cnt)
  411.     string_list_append_unique (file_list, argv[cnt]);
  412.  
  413.   /* Allocate a message list to remember all the messages.  */
  414.   mlp = message_list_alloc ();
  415.  
  416.   /* Generate a header, so that we know how and when this PO file was
  417.      created.  */
  418.   if (!omit_header)
  419.       message_list_append (mlp, construct_header ());
  420.  
  421.   /* Read in the old messages, so that we can add to them.  */
  422.   if (join_existing)
  423.     read_po_file (file_name, mlp);
  424.  
  425.   /* Process all input files.  */
  426.   for (cnt = 0; cnt < file_list->nitems; ++cnt)
  427.     {
  428.       /* Determine input file type, Locate, and open it.  */
  429.       const char *fname = file_list->item[cnt];
  430.       size_t fname_len = strlen (fname);
  431.  
  432. #define HAS_EXTENSION(ext)                              \
  433.       (fname_len >= sizeof (ext)                          \
  434.        && strcmp (&fname[fname_len - sizeof (ext) + 1], ext) == 0)
  435.  
  436.       /* Test for C/C++ file.  */
  437.       if (HAS_EXTENSION (".cc") || HAS_EXTENSION (".C")
  438.       || HAS_EXTENSION (".cxx"))
  439.     scan_c_file (fname, mlp, 1);
  440.       /* Test for PO files.  */
  441.       else if (HAS_EXTENSION (".po") || HAS_EXTENSION (".pot")
  442.            || HAS_EXTENSION (".pox"))
  443.     read_po_file (fname, mlp);
  444.       /* Here will follow more file types: .sh, .pl, .tcl ... */
  445.       else
  446.     {
  447.       if (!HAS_EXTENSION (".c") && !HAS_EXTENSION (".h"))
  448.         {
  449.           const char *extp = &fname[fname_len];
  450.  
  451.           while (extp[-1] != '.' && (extp[0] == '\0' || extp[-1] != '/'))
  452.         --extp;
  453.  
  454.           error (0, 0, _("\
  455. warning: type of file `%s' with extension `%s' is unknown; will try C"),
  456.              fname, extp);
  457.         }
  458.  
  459.       /* The default case: C files.  */
  460.       scan_c_file (fname, mlp, input_files_are_cplusplus);
  461.     }
  462.     }
  463.   string_list_free (file_list);
  464.  
  465.   /* Sorting the list of messages.  */
  466.   if (sort_by_file)
  467.     message_list_sort_by_filepos (mlp);
  468.   else if (sort_output)
  469.     message_list_sort_by_msgid (mlp);
  470.  
  471.   /* Write the PO file.  */
  472.   message_list_print (mlp, file_name, force_po, do_debug);
  473.  
  474.   exit (EXIT_SUCCESS);
  475. }
  476.  
  477.  
  478. /* Display usage information and exit.  */
  479. static void
  480. usage (status)
  481.      int status;
  482. {
  483.   if (status != EXIT_SUCCESS)
  484.     fprintf (stderr, _("Try `%s --help' for more information\n"),
  485.          program_name);
  486.   else
  487.     {
  488.       /* xgettext: no-wrap */
  489.       printf (_("\
  490. Usage: %s [OPTION] INPUTFILE ...\n\
  491. Mandatory arguments to long options are mandatory for short options too.\n\
  492.   -a, --extract-all              extract all strings\n\
  493.   -c, --add-comments[=TAG]       place comment block with TAG (or those\n\
  494.                                  preceding keyword lines) in output file\n\
  495.   -C, --c++                      recognize C++ style comments\n\
  496.       --debug                    more detailed formatstring recognision result\n\
  497.   -d, --default-domain=NAME      use NAME.po for output (instead of messages.po)\n\
  498.   -D, --directory=DIRECTORY      add DIRECTORY to list for input files search\n\
  499.   -e, --no-escape                do not use C escapes in output (default)\n\
  500.   -E, --escape                   use C escapes in output, no extended chars\n\
  501.   -f, --files-from=FILE          get list of input files from FILE\n\
  502.       --force-po                 write PO file even if empty\n\
  503.   -F, --sort-by-file             sort output by file location\n"),
  504.           program_name);
  505.       /* xgettext: no-wrap */
  506.       printf (_("\
  507.   -h, --help                     display this help and exit\n\
  508.   -i, --indent                   write the .po file using indented style\n\
  509.   -j, --join-existing            join messages with existing file\n\
  510.   -k, --keyword[=WORD]           additonal keyword to be looked for (without\n\
  511.                                  WORD means not to use default keywords)\n\
  512.   -l, --string-limit=NUMBER      set string length limit to NUMBER instead %u\n\
  513.   -m, --msgstr-prefix[=STRING]   use STRING or \"\" as prefix for msgstr entries\n\
  514.   -M, --msgstr-suffix[=STRING]   use STRING or \"\" as suffix for msgstr entries\n\
  515.       --no-location              do not write '#: filename:line' lines\n"),
  516.           WARN_ID_LEN);
  517.       /* xgettext: no-wrap */
  518.       fputs (_("\
  519.   -n, --add-location             generate '#: filename:line' lines (default)\n\
  520.       --omit-header              don't write header with `msgid \"\"' entry\n\
  521.   -p, --output-dir=DIR           output files will be placed in directory DIR\n\
  522.   -s, --sort-output              generate sorted output and remove duplicates\n\
  523.       --strict                   write out strict Uniforum conforming .po file\n\
  524.   -T, --trigraphs                understand ANSI C trigraphs for input\n\
  525.   -V, --version                  output version information and exit\n\
  526.   -w, --width=NUMBER             set output page width\n\
  527.   -x, --exclude-file=FILE        entries from FILE are not extracted\n\
  528. \n\
  529. If INPUTFILE is -, standard input is read.\n"),
  530.          stdout);
  531.     }
  532.  
  533.   exit (status);
  534. }
  535.  
  536.  
  537. /* The address of this function will be assigned to the hook in the error
  538.    functions.  */
  539. static void
  540. error_print ()
  541. {
  542.   /* We don't want the program name to be printed in messages.  */
  543. }
  544.  
  545.  
  546. /* Read list of files to process from file.  */
  547. static string_list_ty *
  548. read_name_from_file (file_name)
  549.      const char *file_name;
  550. {
  551.   size_t line_len = 0;
  552.   char *line_buf = NULL;
  553.   FILE *fp;
  554.   string_list_ty *result;
  555.  
  556.   if (strcmp (file_name, "-") == 0)
  557.     fp = stdin;
  558.   else
  559.     {
  560.       fp = fopen (file_name, "r");
  561.       if (fp == NULL)
  562.     error (EXIT_FAILURE, errno,
  563.            _("error while opening \"%s\" for reading"), file_name);
  564.     }
  565.  
  566.   result = string_list_alloc ();
  567.  
  568.   while (!feof (fp))
  569.     {
  570.       /* Read next line from file.  */
  571.       int len = getline (&line_buf, &line_len, fp);
  572.  
  573.       /* In case of an error leave loop.  */
  574.       if (len < 0)
  575.     break;
  576.  
  577.       /* Remove trailing '\n'.  */
  578.       if (len > 0 && line_buf[len - 1] == '\n')
  579.     line_buf[--len] = '\0';
  580.  
  581.       /* Test if we have to ignore the line.  */
  582.       if (*line_buf == '\0' || *line_buf == '#')
  583.     continue;
  584.  
  585.       string_list_append_unique (result, line_buf);
  586.     }
  587.  
  588.   /* Free buffer allocated through getline.  */
  589.   if (line_buf != NULL)
  590.     free (line_buf);
  591.  
  592.   /* Close input stream.  */
  593.   if (fp != stdin)
  594.     fclose (fp);
  595.  
  596.   return result;
  597. }
  598.  
  599.  
  600. static void
  601. exclude_directive_domain (pop, name)
  602.      po_ty *pop;
  603.      char *name;
  604. {
  605.   po_gram_error (_("this file may not contain domain directives"));
  606. }
  607.  
  608.  
  609. static void
  610. exclude_directive_message (pop, msgid, msgid_pos, msgstr, msgstr_pos)
  611.      po_ty *pop;
  612.      char *msgid;
  613.      lex_pos_ty *msgid_pos;
  614.      char *msgstr;
  615.      lex_pos_ty *msgstr_pos;
  616. {
  617.   message_ty *mp;
  618.  
  619.   /* See if this message ID has been seen before.  */
  620.   if (exclude == NULL)
  621.     exclude = message_list_alloc ();
  622.   mp = message_list_search (exclude, msgid);
  623.   if (mp != NULL)
  624.     free (msgid);
  625.   else
  626.     {
  627.       mp = message_alloc (msgid);
  628.       /* Do not free msgid.  */
  629.       message_list_append (exclude, mp);
  630.     }
  631.  
  632.   /* All we care about is the msgid.  Throw the msgstr away.
  633.      Don't even check for duplicate msgids.  */
  634.   free (msgstr);
  635. }
  636.  
  637.  
  638. /* So that the one parer can be used for multiple programs, and also
  639.    use good data hiding and encapsulation practices, an object
  640.    oriented approach has been taken.  An object instance is allocated,
  641.    and all actions resulting from the parse will be through
  642.    invocations of method functions of that object.  */
  643.  
  644. static po_method_ty exclude_methods =
  645. {
  646.   sizeof (po_ty),
  647.   NULL, /* constructor */
  648.   NULL, /* destructor */
  649.   exclude_directive_domain,
  650.   exclude_directive_message,
  651.   NULL, /* parse_brief */
  652.   NULL, /* parse_debrief */
  653.   NULL, /* comment */
  654.   NULL, /* comment_dot */
  655.   NULL, /* comment_filepos */
  656.   NULL, /* comment_special */
  657. };
  658.  
  659.  
  660. static void
  661. read_exclusion_file (file_name)
  662.      char *file_name;
  663. {
  664.   po_ty *pop;
  665.  
  666.   pop = po_alloc (&exclude_methods);
  667.   po_scan (pop, file_name);
  668.   po_free (pop);
  669. }
  670.  
  671.  
  672. static void
  673. remember_a_message (mlp, tp)
  674.      message_list_ty *mlp;
  675.      xgettext_token_ty *tp;
  676. {
  677.   enum is_c_format is_c_format = undecided;
  678.   enum is_c_format do_wrap = undecided;
  679.   char *msgid;
  680.   message_ty *mp;
  681.   char *msgstr;
  682.  
  683.   msgid = tp->string;
  684.  
  685.   /* See whether we shall exclude this message.  */
  686.   if (exclude != NULL && message_list_search (exclude, msgid) != NULL)
  687.     {
  688.       /* Tell the lexer to reset its comment buffer, so that the next
  689.      message gets the correct comments.  */
  690.       xgettext_lex_comment_reset ();
  691.  
  692.       return;
  693.     }
  694.  
  695.   /* See if we have seen this message before.  */
  696.   mp = message_list_search (mlp, msgid);
  697.   if (mp != NULL)
  698.     {
  699.       free (msgid);
  700.       is_c_format = mp->is_c_format;
  701.       do_wrap = mp->do_wrap;
  702.     }
  703.   else
  704.     {
  705.       static lex_pos_ty pos = { __FILE__, __LINE__ };
  706.  
  707.       /* Allocate a new message and append the message to the list.  */
  708.       mp = message_alloc (msgid);
  709.       /* Do not free msgid.  */
  710.       message_list_append (mlp, mp);
  711.  
  712.       /* Construct the msgstr from the prefix and suffix, otherwise use the
  713.      empty string.  */
  714.       if (msgstr_prefix)
  715.     {
  716.       msgstr = (char *) xmalloc (strlen (msgstr_prefix)
  717.                      + strlen (msgid)
  718.                      + strlen(msgstr_suffix) + 1);
  719.       stpcpy (stpcpy (stpcpy (msgstr, msgstr_prefix), msgid),
  720.           msgstr_suffix);
  721.     }
  722.       else
  723.     msgstr = "";
  724.       message_variant_append (mp, MESSAGE_DOMAIN_DEFAULT, msgstr, &pos);
  725.     }
  726.  
  727.   /* Ask the lexer for the comments it has seen.  Only do this for the
  728.      first instance, otherwise there could be problems; especially if
  729.      the same comment appears before each.  */
  730.   if (!mp->comment_dot)
  731.     {
  732.       int j;
  733.  
  734.       for (j = 0; ; ++j)
  735.     {
  736.       const char *s = xgettext_lex_comment (j);
  737.       if (s == NULL)
  738.         break;
  739.  
  740.       /* To reduce the possibility of unwanted matches be do a two
  741.          step match: the line must contains `xgettext:' and one of
  742.          the possible format description strings.  */
  743.       if (strstr (s, "xgettext:") != NULL)
  744.         {
  745.           is_c_format = parse_c_format_description_string (s);
  746.           do_wrap = parse_c_width_description_string (s);
  747.  
  748.           /* If we found a magic string we don't print it.  */
  749.           if (is_c_format != undecided || do_wrap != undecided)
  750.         continue;
  751.         }
  752.       if (add_all_comments
  753.           || (comment_tag != NULL && strncmp (s, comment_tag,
  754.                           strlen (comment_tag)) == 0))
  755.         message_comment_dot_append (mp, s);
  756.     }
  757.     }
  758.  
  759.   /* If not already decided, examine the msgid.  */
  760.   if (is_c_format == undecided)
  761.     is_c_format = test_whether_c_format (mp->msgid);
  762.  
  763.   mp->is_c_format = is_c_format;
  764.   mp->do_wrap = do_wrap == no ? no : yes;    /* By default we wrap.  */
  765.  
  766.   /* Remember where we saw this msgid.  */
  767.   if (line_comment)
  768.     message_comment_filepos (mp, tp->file_name, tp->line_number);
  769.  
  770.   /* Tell the lexer to reset its comment buffer, so that the next
  771.      message gets the correct comments.  */
  772.   xgettext_lex_comment_reset ();
  773. }
  774.  
  775.  
  776. static void
  777. scan_c_file(filename, mlp, is_cpp_file)
  778.      const char *filename;
  779.      message_list_ty *mlp;
  780.      int is_cpp_file;
  781. {
  782.   int state;
  783.  
  784.   /* Inform scanner whether we have C++ files or not.  */
  785.   if (is_cpp_file)
  786.     xgettext_lex_cplusplus ();
  787.  
  788.   /* The file is broken into tokens.  Scan the token stream, looking for
  789.      a keyword, followed by a left paren, followed by a string.  When we
  790.      see this sequence, we have something to remember.  We assume we are
  791.      looking at a valid C or C++ program, and leave the complains about
  792.      the grammar to the compiler.  */
  793.   xgettext_lex_open (filename);
  794.  
  795.   /* Start state is 0.  */
  796.   state = 0;
  797.  
  798.   while (1)
  799.    {
  800.      xgettext_token_ty token;
  801.  
  802.      /* A simple state machine is used to do the recognising:
  803.         State 0 = waiting for something to happen
  804.         State 1 = seen one of our keywords with string in first parameter
  805.         State 2 = was in state 1 and now saw a left paren
  806.     State 3 = seen one of our keywords with string in second parameter
  807.     State 4 = was in state 3 and now saw a left paren
  808.     State 5 = waiting for comma after being in state 4
  809.     State 6 = saw comma after being in state 5  */
  810.      xgettext_lex (&token);
  811.      switch (token.type)
  812.        {
  813.        case xgettext_token_type_keyword1:
  814.      state = 1;
  815.      continue;
  816.  
  817.        case xgettext_token_type_keyword2:
  818.      state = 3;
  819.      continue;
  820.  
  821.        case xgettext_token_type_lp:
  822.      switch (state)
  823.        {
  824.        case 1:
  825.          state = 2;
  826.          break;
  827.        case 3:
  828.          state = 4;
  829.          break;
  830.        default:
  831.          state = 0;
  832.        }
  833.      continue;
  834.  
  835.        case xgettext_token_type_comma:
  836.      state = state == 5 ? 6 : 0;
  837.      continue;
  838.  
  839.        case xgettext_token_type_string_literal:
  840.      if (extract_all || state == 2 || state == 6)
  841.        {
  842.          remember_a_message (mlp, &token);
  843.          state = 0;
  844.        }
  845.      else
  846.        {
  847.          free (token.string);
  848.          state = (state == 4 || state == 5) ? 5 : 0;
  849.        }
  850.      continue;
  851.  
  852.        case xgettext_token_type_symbol:
  853.      state = (state == 4 || state == 5) ? 5 : 0;
  854.      continue;
  855.  
  856.        default:
  857.      state = 0;
  858.      continue;
  859.  
  860.        case xgettext_token_type_eof:
  861.      break;
  862.        }
  863.      break;
  864.    }
  865.  
  866.   /* Close scanner.  */
  867.   xgettext_lex_close ();
  868. }
  869.  
  870.  
  871. typedef struct extract_class_ty extract_class_ty;
  872. struct extract_class_ty
  873. {
  874.   /* Inherited instance variables and methods.  */
  875.   PO_BASE_TY
  876.  
  877.   /* Cumulative list of messages.  */
  878.   message_list_ty *mlp;
  879.  
  880.   /* Cumulative comments for next message.  */
  881.   string_list_ty *comment;
  882.   string_list_ty *comment_dot;
  883.  
  884.   int is_fuzzy;
  885.   int is_c_format;
  886.   int do_wrap;
  887.  
  888.   int filepos_count;
  889.   lex_pos_ty *filepos;
  890. };
  891.  
  892.  
  893. static void
  894. extract_constructor (that)
  895.      po_ty *that;
  896. {
  897.   extract_class_ty *this = (extract_class_ty *) that;
  898.  
  899.   this->mlp = NULL; /* actually set in read_po_file, below */
  900.   this->comment = NULL;
  901.   this->comment_dot = NULL;
  902.   this->is_fuzzy = 0;
  903.   this->is_c_format = undecided;
  904.   this->do_wrap = undecided;
  905.   this->filepos_count = 0;
  906.   this->filepos = NULL;
  907. }
  908.  
  909.  
  910. static void
  911. extract_directive_domain (that, name)
  912.      po_ty *that;
  913.      char *name;
  914. {
  915.   po_gram_error (_("this file may not contain domain directives"));
  916. }
  917.  
  918.  
  919. static void
  920. extract_directive_message (that, msgid, msgid_pos, msgstr, msgstr_pos)
  921.      po_ty *that;
  922.      char *msgid;
  923.      lex_pos_ty *msgid_pos;
  924.      char *msgstr;
  925.      lex_pos_ty *msgstr_pos;
  926. {
  927.   extract_class_ty *this = (extract_class_ty *)that;
  928.   message_ty *mp;
  929.   message_variant_ty *mvp;
  930.   size_t j;
  931.  
  932.   /* If the msgid is the empty string, it is the old header.
  933.      Throw it away, we have constructed a new one.  */
  934.   if (*msgid == '\0')
  935.     {
  936.       free (msgid);
  937.       free (msgstr);
  938.       return;
  939.     }
  940.  
  941.   /* See if this message ID has been seen before.  */
  942.   mp = message_list_search (this->mlp, msgid);
  943.   if (mp)
  944.     free (msgid);
  945.   else
  946.     {
  947.       mp = message_alloc (msgid);
  948.       message_list_append (this->mlp, mp);
  949.     }
  950.  
  951.   /* Add the accumulated comments to the message.  Clear the
  952.      accumulation in preparation for the next message. */
  953.   if (this->comment != NULL)
  954.     {
  955.       for (j = 0; j < this->comment->nitems; ++j)
  956.     message_comment_append (mp, this->comment->item[j]);
  957.       string_list_free (this->comment);
  958.       this->comment = NULL;
  959.     }
  960.   if (this->comment_dot != NULL)
  961.     {
  962.       for (j = 0; j < this->comment_dot->nitems; ++j)
  963.     message_comment_dot_append (mp, this->comment_dot->item[j]);
  964.       string_list_free (this->comment_dot);
  965.       this->comment_dot = NULL;
  966.     }
  967.   mp->is_fuzzy = this->is_fuzzy;
  968.   mp->is_c_format = this->is_c_format;
  969.   mp->do_wrap = this->do_wrap;
  970.   for (j = 0; j < this->filepos_count; ++j)
  971.     {
  972.       lex_pos_ty *pp;
  973.  
  974.       pp = &this->filepos[j];
  975.       message_comment_filepos (mp, pp->file_name, pp->line_number);
  976.       free (pp->file_name);
  977.     }
  978.   if (this->filepos != NULL)
  979.     free (this->filepos);
  980.   this->filepos_count = 0;
  981.   this->filepos = NULL;
  982.   this->is_fuzzy = 0;
  983.   this->is_c_format = undecided;
  984.   this->do_wrap = undecided;
  985.  
  986.   /* See if this domain has been seen for this message ID.  */
  987.   mvp = message_variant_search (mp, MESSAGE_DOMAIN_DEFAULT);
  988.   if (mvp != NULL && strcmp (msgstr, mvp->msgstr) != 0)
  989.     {
  990.       gram_error_at_line (msgid_pos, _("duplicate message definition"));
  991.       gram_error_at_line (&mvp->pos, _("\
  992. ...this is the location of the first definition"));
  993.       free (msgstr);
  994.     }
  995.   else
  996.     message_variant_append (mp, MESSAGE_DOMAIN_DEFAULT, msgstr, msgstr_pos);
  997. }
  998.  
  999.  
  1000. static void
  1001. extract_parse_brief (that)
  1002.      po_ty *that;
  1003. {
  1004.   po_lex_pass_comments (1);
  1005. }
  1006.  
  1007.  
  1008. static void
  1009. extract_comment (that, s)
  1010.      po_ty *that;
  1011.      const char *s;
  1012. {
  1013.   extract_class_ty *this = (extract_class_ty *) that;
  1014.  
  1015.   if (this->comment == NULL)
  1016.     this->comment = string_list_alloc ();
  1017.   string_list_append (this->comment, s);
  1018. }
  1019.  
  1020.  
  1021. static void
  1022. extract_comment_dot (that, s)
  1023.      po_ty *that;
  1024.      const char *s;
  1025. {
  1026.   extract_class_ty *this = (extract_class_ty *) that;
  1027.  
  1028.   if (this->comment_dot == NULL)
  1029.     this->comment_dot = string_list_alloc ();
  1030.   string_list_append (this->comment_dot, s);
  1031. }
  1032.  
  1033.  
  1034. static void
  1035. extract_comment_filepos (that, name, line)
  1036.      po_ty *that;
  1037.      const char *name;
  1038.      int line;
  1039. {
  1040.   extract_class_ty *this = (extract_class_ty *) that;
  1041.   size_t nbytes;
  1042.   lex_pos_ty *pp;
  1043.  
  1044.   /* Write line numbers only if -n option is given.  */
  1045.   if (line_comment != 0)
  1046.     {
  1047.       nbytes = (this->filepos_count + 1) * sizeof (this->filepos[0]);
  1048.       this->filepos = xrealloc (this->filepos, nbytes);
  1049.       pp = &this->filepos[this->filepos_count++];
  1050.       pp->file_name = xstrdup (name);
  1051.       pp->line_number = line;
  1052.     }
  1053. }
  1054.  
  1055.  
  1056. static void
  1057. extract_comment_special (that, s)
  1058.      po_ty *that;
  1059.      const char *s;
  1060. {
  1061.   extract_class_ty *this = (extract_class_ty *) that;
  1062.  
  1063.   if (strstr (s, "fuzzy") != NULL)
  1064.     this->is_fuzzy = 1;
  1065.   this->is_c_format = parse_c_format_description_string (s);
  1066.   this->do_wrap = parse_c_width_description_string (s);
  1067. }
  1068.  
  1069.  
  1070. /* So that the one parser can be used for multiple programs, and also
  1071.    use good data hiding and encapsulation practices, an object
  1072.    oriented approach has been taken.  An object instance is allocated,
  1073.    and all actions resulting from the parse will be through
  1074.    invocations of method functions of that object.  */
  1075.  
  1076. static po_method_ty extract_methods =
  1077. {
  1078.   sizeof (extract_class_ty),
  1079.   extract_constructor,
  1080.   NULL, /* destructor */
  1081.   extract_directive_domain,
  1082.   extract_directive_message,
  1083.   extract_parse_brief,
  1084.   NULL, /* parse_debrief */
  1085.   extract_comment,
  1086.   extract_comment_dot,
  1087.   extract_comment_filepos,
  1088.   extract_comment_special
  1089. };
  1090.  
  1091.  
  1092. /* Read the contents of the specified .po file into a message list.  */
  1093.  
  1094. static void
  1095. read_po_file (file_name, mlp)
  1096.      const char *file_name;
  1097.      message_list_ty *mlp;
  1098. {
  1099.   po_ty *pop = po_alloc (&extract_methods);
  1100.   ((extract_class_ty *) pop)->mlp = mlp;
  1101.   po_scan (pop, file_name);
  1102.   po_free (pop);
  1103. }
  1104.  
  1105.  
  1106. #define TM_YEAR_ORIGIN 1900
  1107.  
  1108. /* Yield A - B, measured in seconds.  */
  1109. static long
  1110. difftm (a, b)
  1111.      const struct tm *a;
  1112.      const struct tm *b;
  1113. {
  1114.   int ay = a->tm_year + (TM_YEAR_ORIGIN - 1);
  1115.   int by = b->tm_year + (TM_YEAR_ORIGIN - 1);
  1116.   /* Some compilers cannot handle this as a single return statement.  */
  1117.   long days = (
  1118.                /* difference in day of year  */
  1119.                a->tm_yday - b->tm_yday
  1120.                /* + intervening leap days  */
  1121.                + ((ay >> 2) - (by >> 2))
  1122.                - (ay / 100 - by / 100)
  1123.                + ((ay / 100 >> 2) - (by / 100 >> 2))
  1124.                /* + difference in years * 365  */
  1125.                + (long) (ay - by) * 365l);
  1126.  
  1127.   return 60l * (60l * (24l * days + (a->tm_hour - b->tm_hour))
  1128.                 + (a->tm_min - b->tm_min))
  1129.          + (a->tm_sec - b->tm_sec);
  1130. }
  1131.  
  1132.  
  1133. static message_ty *
  1134. construct_header ()
  1135. {
  1136.   time_t now;
  1137.   struct tm local_time;
  1138.   message_ty *mp;
  1139.   char *msgstr;
  1140.   static lex_pos_ty pos = { __FILE__, __LINE__, };
  1141.   char tz_sign;
  1142.   long tz_min;
  1143.  
  1144.   mp = message_alloc ("");
  1145.  
  1146.   message_comment_append (mp, "\
  1147. SOME DESCRIPTIVE TITLE.\n\
  1148. Copyright (C) YEAR Free Software Foundation, Inc.\n\
  1149. FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.\n");
  1150.  
  1151.   mp->is_fuzzy = 1;
  1152.  
  1153.   time (&now);
  1154.   local_time = *localtime (&now);
  1155.   tz_sign = '+';
  1156.   tz_min = difftm (&local_time, gmtime (&now)) / 60;
  1157.   if (tz_min < 0)
  1158.     {
  1159.       tz_min = -tz_min;
  1160.       tz_sign = '-';
  1161.     }
  1162.  
  1163.   asprintf (&msgstr, "\
  1164. Project-Id-Version: PACKAGE VERSION\n\
  1165. POT-Creation-Date: %d-%02d-%02d %02d:%02d%c%02d%02d\n\
  1166. PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n\
  1167. Last-Translator: FULL NAME <EMAIL@ADDRESS>\n\
  1168. Language-Team: LANGUAGE <LL@li.org>\n\
  1169. MIME-Version: 1.0\n\
  1170. Content-Type: text/plain; charset=CHARSET\n\
  1171. Content-Transfer-Encoding: ENCODING\n",
  1172.         local_time.tm_year + TM_YEAR_ORIGIN,
  1173.         local_time.tm_mon + 1,
  1174.         local_time.tm_mday,
  1175.         local_time.tm_hour,
  1176.         local_time.tm_min,
  1177.         tz_sign, tz_min / 60, tz_min % 60);
  1178.  
  1179.   if (msgstr == NULL)
  1180.     error (EXIT_FAILURE, errno, _("while preparing output"));
  1181.  
  1182.   message_variant_append (mp, MESSAGE_DOMAIN_DEFAULT, msgstr, &pos);
  1183.  
  1184.   return mp;
  1185. }
  1186.  
  1187.  
  1188. /* We make a pessimistic guess whether the given string is a format
  1189.    string or not.  Pessimistic means here that with the first
  1190.    occurence of an unknown format element we say `impossible'.  */
  1191. static enum is_c_format
  1192. test_whether_c_format (s)
  1193.      const char *s;
  1194. {
  1195.   struct printf_spec spec;
  1196.  
  1197.   if (s == NULL || *(s = find_spec (s)) == '\0')
  1198.     /* We return `possible' here because sometimes strings are used
  1199.        with printf even if they don't contain any format specifier.
  1200.        If the translation in this case would contain a specifier, this
  1201.        would result in an error.  */
  1202.     return impossible;
  1203.  
  1204.   for (s = find_spec (s); *s != '\0'; s = spec.next_fmt)
  1205.     {
  1206.       size_t dummy;
  1207.  
  1208.       (void) parse_one_spec (s, 0, &spec, &dummy);
  1209.       if (strchr ("iduoxXeEfgGcspnm", spec.info.spec) == NULL)
  1210.     return impossible;
  1211.     }
  1212.  
  1213.   return possible;
  1214. }
  1215.