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 / message.c < prev    next >
C/C++ Source or Header  |  1996-09-28  |  33KB  |  1,389 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 <errno.h>
  25. #include <ctype.h>
  26. #include <stdio.h>
  27.  
  28. #ifdef HAVE_LIMITS_H
  29. # include <limits.h>
  30. #endif
  31.  
  32. #ifdef HAVE_LOCALE_H
  33. # include <locale.h>
  34. #endif
  35.  
  36. #ifdef STDC_HEADERS
  37. # include <stdlib.h>
  38. #endif
  39.  
  40. #include "fstrcmp.h"
  41. #include "message.h"
  42. #include "system.h"
  43. #include "error.h"
  44. #include "libgettext.h"
  45.  
  46.  
  47. /* Our regular abbreviation.  */
  48. #define _(str) gettext (str)
  49.  
  50.  
  51. /* These two variables control the output style of the message_print
  52.    function.  Interface functions for them are to be used.  */
  53. static int indent;
  54. static int uniforum;
  55. static int escape;
  56.  
  57. /* This variable controls the page width when printing messages.
  58.    Defaults to PAGE_WIDTH if not set.  Zero (0) given to message_page_-
  59.    width_set will result in no wrapping being performed.  */
  60. static size_t page_width = PAGE_WIDTH;
  61.  
  62.  
  63. /* Prototypes for local functions.  */
  64. static void wrap PARAMS ((FILE *__fp, const char *__line_prefix,
  65.               const char *__name, const char *__value,
  66.               int do_wrap));
  67. static void print_blank_line PARAMS ((FILE *__fp));
  68. static void message_print PARAMS ((const message_ty *__mp, FILE *__fp,
  69.                    const char *__domain, int blank_line,
  70.                    int __debug));
  71. static void message_print_obsolete PARAMS ((const message_ty *__mp, FILE *__fp,
  72.                         const char *__domain,
  73.                         int blank_line));
  74. static int msgid_cmp PARAMS ((const void *__va, const void *__vb));
  75. static int filepos_cmp PARAMS ((const void *__va, const void *__vb));
  76. static const char *make_c_format_description_string PARAMS ((enum is_c_format,
  77.                                  int debug));
  78. static const char *make_c_width_description_string PARAMS ((enum is_c_format));
  79. static int significant_c_format_p PARAMS ((enum is_c_format __is_c_format));
  80.  
  81.  
  82.  
  83. message_ty *
  84. message_alloc (msgid)
  85.      char *msgid;
  86. {
  87.   message_ty *mp;
  88.  
  89.   mp = xmalloc (sizeof (message_ty));
  90.   mp->msgid = msgid;
  91.   mp->comment = NULL;
  92.   mp->comment_dot = NULL;
  93.   mp->filepos_count = 0;
  94.   mp->filepos = NULL;
  95.   mp->variant_count = 0;
  96.   mp->variant = NULL;
  97.   mp->used = 0;
  98.   mp->obsolete = 0;
  99.   mp->is_fuzzy = 0;
  100.   mp->is_c_format = undecided;
  101.   mp->do_wrap = undecided;
  102.   return mp;
  103. }
  104.  
  105.  
  106. void
  107. message_free (mp)
  108.      message_ty *mp;
  109. {
  110.   size_t j;
  111.  
  112.   if (mp->comment != NULL)
  113.     string_list_free (mp->comment);
  114.   if (mp->comment_dot != NULL)
  115.     string_list_free (mp->comment_dot);
  116.   free ((char *) mp->msgid);
  117.   for (j = 0; j < mp->variant_count; ++j)
  118.     free ((char *) mp->variant[j].msgstr);
  119.   if (mp->variant != NULL)
  120.     free (mp->variant);
  121.   for (j = 0; j < mp->filepos_count; ++j)
  122.     free ((char *) mp->filepos[j].file_name);
  123.   if (mp->filepos != NULL)
  124.     free (mp->filepos);
  125.   free (mp);
  126. }
  127.  
  128.  
  129. message_variant_ty *
  130. message_variant_search (mp, domain)
  131.      message_ty *mp;
  132.      const char *domain;
  133. {
  134.   size_t j;
  135.   message_variant_ty *mvp;
  136.  
  137.   for (j = 0; j < mp->variant_count; ++j)
  138.     {
  139.       mvp = &mp->variant[j];
  140.       if (0 == strcmp (domain, mvp->domain))
  141.     return mvp;
  142.     }
  143.   return 0;
  144. }
  145.  
  146.  
  147. void
  148. message_variant_append (mp, domain, msgstr, pp)
  149.      message_ty *mp;
  150.      const char *domain;
  151.      const char *msgstr;
  152.      const lex_pos_ty *pp;
  153. {
  154.   size_t nbytes;
  155.   message_variant_ty *mvp;
  156.  
  157.   nbytes = (mp->variant_count + 1) * sizeof (mp->variant[0]);
  158.   mp->variant = xrealloc (mp->variant, nbytes);
  159.   mvp = &mp->variant[mp->variant_count++];
  160.   mvp->domain = domain;
  161.   mvp->msgstr = msgstr;
  162.   mvp->pos = *pp;
  163. }
  164.  
  165.  
  166. void
  167. message_comment_append (mp, s)
  168.      message_ty *mp;
  169.      const char *s;
  170. {
  171.   if (mp->comment == NULL)
  172.     mp->comment = string_list_alloc ();
  173.   string_list_append (mp->comment, s);
  174. }
  175.  
  176.  
  177. void
  178. message_comment_dot_append (mp, s)
  179.      message_ty *mp;
  180.      const char *s;
  181. {
  182.   if (mp->comment_dot == NULL)
  183.     mp->comment_dot = string_list_alloc ();
  184.   string_list_append (mp->comment_dot, s);
  185. }
  186.  
  187.  
  188. message_ty *
  189. message_copy (mp)
  190.      message_ty *mp;
  191. {
  192.   message_ty *result;
  193.   size_t j;
  194.  
  195.   result = message_alloc (xstrdup (mp->msgid));
  196.  
  197.   for (j = 0; j < mp->variant_count; ++j)
  198.     {
  199.       message_variant_ty *mvp = &mp->variant[j];
  200.       message_variant_append (result, mvp->domain, mvp->msgstr, &mvp->pos);
  201.     }
  202.   if (mp->comment)
  203.     {
  204.       for (j = 0; j < mp->comment->nitems; ++j)
  205.     message_comment_append (result, mp->comment->item[j]);
  206.     }
  207.   if (mp->comment_dot)
  208.     {
  209.       for (j = 0; j < mp->comment_dot->nitems; ++j)
  210.     message_comment_dot_append (result, mp->comment_dot->item[j]);
  211.     }
  212.   result->is_fuzzy = mp->is_fuzzy;
  213.   result->is_c_format = mp->is_c_format;
  214.   result->do_wrap = mp->do_wrap;
  215.   for (j = 0; j < mp->filepos_count; ++j)
  216.     {
  217.       lex_pos_ty *pp = &mp->filepos[j];
  218.       message_comment_filepos (result, pp->file_name, pp->line_number);
  219.     }
  220.   return result;
  221. }
  222.  
  223.  
  224. message_ty *
  225. message_merge (def, ref)
  226.      message_ty *def;
  227.      message_ty *ref;
  228. {
  229.   message_ty *result;
  230.   const char *pot_date_ptr = NULL;
  231.   size_t pot_date_len = 0;
  232.   size_t j;
  233.  
  234.   /* Take the msgid from the reference.  When fuzzy matches are made,
  235.      the definition will not be unique, but the reference will be -
  236.      usually because it has a typo.  */
  237.   result = message_alloc (xstrdup (ref->msgid));
  238.  
  239.   /* If msgid is the header entry (i.e., "") we find the
  240.      POT-Creation-Date line in the reference.  */
  241.   if (ref->msgid[0] == '\0')
  242.     {
  243.       pot_date_ptr = strstr (ref->variant[0].msgstr, "POT-Creation-Date:");
  244.       if (pot_date_ptr != NULL)
  245.     {
  246.       const char *endp;
  247.  
  248.       pot_date_ptr += sizeof ("POT-Creation-Date:") - 1;
  249.  
  250.       endp = strchr (pot_date_ptr, '\n');
  251.       if (endp == NULL)
  252.         {
  253.           char *extended;
  254.           endp = strchr (pot_date_ptr, '\0');
  255.           pot_date_len = (endp - pot_date_ptr) + 1;
  256.           extended = (char *) alloca (pot_date_len + 1);
  257.           stpcpy (stpcpy (extended, pot_date_ptr), "\n");
  258.           pot_date_ptr = extended;
  259.         }
  260.       else
  261.         pot_date_len = (endp - pot_date_ptr) + 1;
  262.  
  263.       if (pot_date_len == 0)
  264.         pot_date_ptr = NULL;
  265.     }
  266.     }
  267.  
  268.   /* Take the variant list from the definition.  The msgstr of the
  269.      refences will be empty, as they were generated by xgettext.  If
  270.      we currently process the header entry we have to merge the msgstr
  271.      by using the POT-Creation-Date field from the .pot file.  */
  272.   for (j = 0; j < def->variant_count; ++j)
  273.     {
  274.       message_variant_ty *mvp = &def->variant[j];
  275.  
  276.       if (ref->msgid[0] == '\0')
  277.     {
  278.       /* Oh, oh.  The header entry and we have something to fill in.  */
  279.       static const struct
  280.       {
  281.         const char *name;
  282.         size_t len;
  283.       } known_fields[] =
  284.       {
  285.         { "Project-Id-Version:", sizeof ("Project-Id-Version:") - 1 },
  286. #define PROJECT_ID    0
  287.         { "POT-Creation-Date:", sizeof ("POT-Creation-Date:") - 1 },
  288. #define POT_CREATION    1
  289.         { "PO-Revision-Date:", sizeof ("PO-Revision-Date:") - 1 },
  290. #define PO_REVISION    2
  291.         { "Last-Translator:", sizeof ("Last-Translator:") - 1 },
  292. #define LAST_TRANSLATOR    3
  293.         { "Language-Team:", sizeof ("Language-Team:") - 1 },
  294. #define LANGUAGE_TEAM    4
  295.         { "MIME-Version:", sizeof ("MIME-Version:") - 1 },
  296. #define MIME_VERSION    5
  297.         { "Content-Type:", sizeof ("Content-Type:") - 1 },
  298. #define CONTENT_TYPE    6
  299.         { "Content-Transfer-Encoding:",
  300.           sizeof ("Content-Transfer-Encoding:") - 1 }
  301. #define CONTENT_TRANSFER 7
  302.       };
  303. #define UNKNOWN    8
  304.       struct
  305.       {
  306.         const char *string;
  307.         size_t len;
  308.       } header_fields[UNKNOWN + 1];
  309.       const char *cp;
  310.       char *newp;
  311.       size_t len, cnt;
  312.  
  313.       /* Clear all fields.  */
  314.       memset (header_fields, '\0', sizeof (header_fields));
  315.  
  316.       cp = mvp->msgstr;
  317.       while (*cp != '\0')
  318.         {
  319.           const char *endp = strchr (cp, '\n');
  320.           int terminated = endp != NULL;
  321.  
  322.           if (!terminated)
  323.         {
  324.           char *copy;
  325.           endp = strchr (cp, '\0');
  326.  
  327.           len = endp - cp + 1;
  328.  
  329.           copy = (char *) alloca (len + 1);
  330.           stpcpy (stpcpy (copy, cp), "\n");
  331.           cp = copy;
  332.         }
  333.           else
  334.         {
  335.           len = (endp - cp) + 1;
  336.           ++endp;
  337.         }
  338.  
  339.           /* Compare with any of the known fields.  */
  340.           for (cnt = 0;
  341.            cnt < sizeof (known_fields) / sizeof (known_fields[0]);
  342.            ++cnt)
  343.         if (strncasecmp (cp, known_fields[cnt].name,
  344.                  known_fields[cnt].len) == 0)
  345.           break;
  346.  
  347.           if (cnt < sizeof (known_fields) / sizeof (known_fields[0]))
  348.         {
  349.           header_fields[cnt].string = &cp[known_fields[cnt].len];
  350.           header_fields[cnt].len = len - known_fields[cnt].len;
  351.         }
  352.           else
  353.         {
  354.           /* It's an unknown field.  Append content to what is
  355.              already known.  */
  356.           char *extended = (char *) alloca (header_fields[UNKNOWN].len
  357.                             + len + 1);
  358.           memcpy (extended, header_fields[UNKNOWN].string,
  359.               header_fields[UNKNOWN].len);
  360.           memcpy (&extended[header_fields[UNKNOWN].len], cp, len);
  361.           extended[header_fields[UNKNOWN].len + len] = '\0';
  362.           header_fields[UNKNOWN].string = extended;
  363.           header_fields[UNKNOWN].len += len;
  364.         }
  365.  
  366.           cp = endp;
  367.         }
  368.  
  369.       if (pot_date_ptr != NULL)
  370.         {
  371.           header_fields[POT_CREATION].string = pot_date_ptr;
  372.           header_fields[POT_CREATION].len = pot_date_len;
  373.         }
  374.  
  375.       /* Concatenate all the various fields.  */
  376.       len = 0;
  377.       for (cnt = 0; cnt < UNKNOWN; ++cnt)
  378.         if (header_fields[cnt].string != NULL)
  379.           len += known_fields[cnt].len + header_fields[cnt].len;
  380.       len += header_fields[UNKNOWN].len;
  381.  
  382.       cp = newp = (char *) xmalloc (len + 1);
  383.       newp[len] = '\0';
  384.  
  385. #define IF_FILLED(idx)                                  \
  386.       if (header_fields[idx].string)                      \
  387.         newp = stpncpy (stpcpy (newp, known_fields[idx].name),          \
  388.                 header_fields[idx].string, header_fields[idx].len)
  389.  
  390.       IF_FILLED (PROJECT_ID);
  391.       IF_FILLED (POT_CREATION);
  392.       IF_FILLED (PO_REVISION);
  393.       IF_FILLED (LAST_TRANSLATOR);
  394.       IF_FILLED (LANGUAGE_TEAM);
  395.       IF_FILLED (MIME_VERSION);
  396.       IF_FILLED (CONTENT_TYPE);
  397.       IF_FILLED (CONTENT_TRANSFER);
  398.       if (header_fields[UNKNOWN].string != NULL)
  399.         stpcpy (newp, header_fields[UNKNOWN].string);
  400.  
  401.       message_variant_append (result, mvp->domain, cp, &mvp->pos);
  402.     }
  403.       else
  404.     message_variant_append (result, mvp->domain, mvp->msgstr, &mvp->pos);
  405.     }
  406.  
  407.   /* Take the comments from the definition file.  There will be none at
  408.      all in the reference file, as it was generated by xgettext.  */
  409.   if (def->comment)
  410.     for (j = 0; j < def->comment->nitems; ++j)
  411.       message_comment_append (result, def->comment->item[j]);
  412.  
  413.   /* Take the dot comments from the reference file, as they are
  414.      generated by xgettext.  Any in the definition file are old ones
  415.      collected by previous runs of xgettext and msgmerge.  */
  416.   if (ref->comment_dot)
  417.     for (j = 0; j < ref->comment_dot->nitems; ++j)
  418.       message_comment_dot_append (result, ref->comment_dot->item[j]);
  419.  
  420.   /* The flags are mixed in a special way.  Some informations come
  421.      from the reference message (such as format/no-format), others
  422.      come from the definition file (fuzzy or not).  */
  423.   result->is_fuzzy = def->is_fuzzy;
  424.   result->is_c_format = ref->is_c_format;
  425.   result->do_wrap = ref->do_wrap;
  426.  
  427.   /* Take the file position comments from the reference file, as they
  428.      are generated by xgettext.  Any in the definition file are old ones
  429.      collected by previous runs of xgettext and msgmerge.  */
  430.   for (j = 0; j < ref->filepos_count; ++j)
  431.     {
  432.       lex_pos_ty *pp = &ref->filepos[j];
  433.       message_comment_filepos (result, pp->file_name, pp->line_number);
  434.     }
  435.  
  436.   /* All done, return the merged message to the caller.  */
  437.   return result;
  438. }
  439.  
  440.  
  441. void
  442. message_comment_filepos (mp, name, line)
  443.      message_ty *mp;
  444.      const char *name;
  445.      size_t line;
  446. {
  447.   size_t nbytes;
  448.   lex_pos_ty *pp;
  449.   int min, max;
  450.   int j;
  451.  
  452.   /* See if we have this position already.  They are kept in sorted
  453.      order, so use a binary chop.  */
  454.   /* FIXME: use bsearch */
  455.   min = 0;
  456.   max = (int) mp->filepos_count - 1;
  457.   while (min <= max)
  458.     {
  459.       int mid;
  460.       int cmp;
  461.  
  462.       mid = (min + max) / 2;
  463.       pp = &mp->filepos[mid];
  464.       cmp = strcmp (pp->file_name, name);
  465.       if (cmp == 0)
  466.     cmp = (int) pp->line_number - line;
  467.       if (cmp == 0)
  468.     return;
  469.       if (cmp < 0)
  470.     min = mid + 1;
  471.       else
  472.     max = mid - 1;
  473.     }
  474.  
  475.   /* Extend the list so that we can add an position to it.  */
  476.   nbytes = (mp->filepos_count + 1) * sizeof (mp->filepos[0]);
  477.   mp->filepos = xrealloc (mp->filepos, nbytes);
  478.  
  479.   /* Shuffle the rest of the list up one, so that we can insert the
  480.      position at ``min''.  */
  481.   /* FIXME: use memmove */
  482.   for (j = mp->filepos_count; j > min; --j)
  483.     mp->filepos[j] = mp->filepos[j - 1];
  484.   mp->filepos_count++;
  485.  
  486.   /* Insert the postion into the empty slot.  */
  487.   pp = &mp->filepos[min];
  488.   pp->file_name = xstrdup (name);
  489.   pp->line_number = line;
  490. }
  491.  
  492.  
  493. void
  494. message_print_style_indent ()
  495. {
  496.   indent = 1;
  497. }
  498.  
  499.  
  500. void
  501. message_print_style_uniforum ()
  502. {
  503.   uniforum = 1;
  504. }
  505.  
  506.  
  507. void
  508. message_print_style_escape (flag)
  509.      int flag;
  510. {
  511.   escape = (flag != 0);
  512. }
  513.  
  514.  
  515. message_list_ty *
  516. message_list_alloc ()
  517. {
  518.   message_list_ty *mlp;
  519.  
  520.   mlp = xmalloc (sizeof (message_list_ty));
  521.   mlp->nitems = 0;
  522.   mlp->nitems_max = 0;
  523.   mlp->item = 0;
  524.   return mlp;
  525. }
  526.  
  527.  
  528. void
  529. message_list_append (mlp, mp)
  530.      message_list_ty *mlp;
  531.      message_ty *mp;
  532. {
  533.   if (mlp->nitems >= mlp->nitems_max)
  534.     {
  535.       size_t nbytes;
  536.  
  537.       mlp->nitems_max = mlp->nitems_max * 2 + 4;
  538.       nbytes = mlp->nitems_max * sizeof (message_ty *);
  539.       mlp->item = xrealloc (mlp->item, nbytes);
  540.     }
  541.   mlp->item[mlp->nitems++] = mp;
  542. }
  543.  
  544.  
  545. message_ty *
  546. message_list_search (mlp, msgid)
  547.      message_list_ty *mlp;
  548.      const char *msgid;
  549. {
  550.   size_t j;
  551.  
  552.   for (j = 0; j < mlp->nitems; ++j)
  553.     {
  554.       message_ty *mp;
  555.  
  556.       mp = mlp->item[j];
  557.       if (0 == strcmp (msgid, mp->msgid))
  558.     return mp;
  559.     }
  560.   return 0;
  561. }
  562.  
  563.  
  564. message_ty *
  565. message_list_search_fuzzy (mlp, msgid)
  566.      message_list_ty *mlp;
  567.      const char *msgid;
  568. {
  569.   size_t j;
  570.   double best_weight;
  571.   message_ty *best_mp;
  572.  
  573.   best_weight = 0.6;
  574.   best_mp = NULL;
  575.   for (j = 0; j < mlp->nitems; ++j)
  576.     {
  577.       size_t k;
  578.       double weight;
  579.       message_ty *mp;
  580.  
  581.       mp = mlp->item[j];
  582.  
  583.       for (k = 0; k < mp->variant_count; ++k)
  584.     if (mp->variant[k].msgstr != NULL && mp->variant[k].msgstr[0] != '\0')
  585.       break;
  586.       if (k >= mp->variant_count)
  587.     continue;
  588.  
  589.       weight = fstrcmp (msgid, mp->msgid);
  590.       if (weight > best_weight)
  591.     {
  592.       best_weight = weight;
  593.       best_mp = mp;
  594.     }
  595.     }
  596.   return best_mp;
  597. }
  598.  
  599.  
  600. void
  601. message_list_free (mlp)
  602.      message_list_ty *mlp;
  603. {
  604.   size_t j;
  605.  
  606.   for (j = 0; j < mlp->nitems; ++j)
  607.     message_free (mlp->item[j]);
  608.   if (mlp->item)
  609.     free (mlp->item);
  610.   free (mlp);
  611. }
  612.  
  613.  
  614. /* Local functions.  */
  615.  
  616. static void
  617. wrap (fp, line_prefix, name, value, do_wrap)
  618.      FILE *fp;
  619.      const char *line_prefix;
  620.      const char *name;
  621.      const char *value;
  622.      int do_wrap;
  623. {
  624.   const char *s;
  625.   int first_line;
  626.   /* The \a and \v escapes were added by the ANSI C Standard.  Prior
  627.      to the Standard, most compilers did not have them.  Because we
  628.      need the same program on all platforms we don't provide support
  629.      for them here.  */
  630.   static const char escapes[] = "\b\f\n\r\t";
  631.   static const char escape_names[] = "bfnrt";
  632.  
  633.   /* The empty string is a special case.  */
  634.   if (*value == '\0')
  635.     {
  636.       if (line_prefix != NULL)
  637.     fputs (line_prefix, fp);
  638.       fputs (name, fp);
  639.       putc (indent ? '\t' : ' ', fp);
  640.       fputs ("\"\"\n", fp);
  641.       return;
  642.     }
  643.  
  644.   s = value;
  645.   first_line = 1;
  646.   while (*s)
  647.     {
  648.       const char *ep;
  649.       int ocol;
  650.  
  651.       /* The line starts with different things depending on whether it
  652.          is the first line, and if we are using the indented style.  */
  653.       if (first_line)
  654.     {
  655.       ocol = strlen (name) + (line_prefix ? strlen (line_prefix) : 0);
  656.       if (indent && ocol < 8)
  657.         ocol = 8;
  658.       else
  659.         ++ocol;
  660.     }
  661.       else
  662.     ocol = (indent ? 8 : 0);
  663.  
  664.       /* Allow room for the opening quote character. */
  665.       ++ocol;
  666.  
  667.       /* Work out how many characters from the string will fit on a
  668.          line.  Natural breaks occur at embedded newline characters.  */
  669.       for (ep = s; *ep; ++ep)
  670.     {
  671.       const char *esc;
  672.       int cw;
  673.       int c;
  674.  
  675.       c = (unsigned char) *ep;
  676.       /* FIXME This is the wrong locale.  While message_list_print
  677.          set the "C" locale for LC_CTYPE, the need is to use the
  678.          correct locale for the file's contents.  */
  679.       esc = strchr (escapes, c);
  680.       if (esc == NULL && (!escape || isprint (c)))
  681.         cw = 1 + (c == '\\' || c == '"');
  682.       else
  683.         cw = esc != NULL ? 2 : 4;
  684.       /* Allow 1 character for the closing quote.  */
  685.       if (ocol + cw >= (do_wrap == no ? INT_MAX : page_width))
  686.         break;
  687.       ocol += cw;
  688.       if (c == '\n')
  689.         {
  690.           ++ep;
  691.           break;
  692.         }
  693.     }
  694.  
  695.       /* The above loop detects if a line is too long.  If it is too
  696.      long, see if there is a better place to break the line.  */
  697.       if (*ep)
  698.     {
  699.       const char *bp;
  700.  
  701.       for (bp = ep; bp > s; --bp)
  702.         if (bp[-1] == ' ' || bp[-1] == '\n')
  703.           {
  704.         ep = bp;
  705.         break;
  706.           }
  707.     }
  708.  
  709.       /* If this is the first line, and we are not using the indented
  710.          style, and the line would wrap, then use an empty first line
  711.          and restart.  */
  712.       if (first_line && !indent && *ep != '\0')
  713.     {
  714.       fprintf (fp, "%s%s \"\"\n", line_prefix ? line_prefix : "", name);
  715.       s = value;
  716.       first_line = 0;
  717.       continue;
  718.     }
  719.  
  720.       /* Print the beginning of the line.  This will depend on whether
  721.      this is the first line, and if the indented style is being
  722.      used.  */
  723.       if (first_line)
  724.     {
  725.       first_line = 0;
  726.       if (line_prefix != NULL)
  727.         fputs (line_prefix, fp);
  728.       fputs (name, fp);
  729.       putc (indent ? '\t' : ' ', fp);
  730.     }
  731.       else
  732.     {
  733.       if (line_prefix != NULL)
  734.         fputs (line_prefix, fp);
  735.       if (indent)
  736.         putc ('\t', fp);
  737.     }
  738.  
  739.       /* Print the body of the line.  C escapes are used for
  740.      unprintable characters.  */
  741.       putc ('"', fp);
  742.       while (s < ep)
  743.     {
  744.       const char *esc;
  745.       int c;
  746.  
  747.       c = (unsigned char) *s++;
  748.       /* FIXME This is the wrong locale.  While message_list_print
  749.          set the "C" locale for LC_CTYPE, the need is to use the
  750.          correct locale for the file's contents.  */
  751.       esc = strchr (escapes, c);
  752.       if (esc == NULL && (!escape || isprint (c)))
  753.         {
  754.           if (c == '\\' || c == '"')
  755.         putc ('\\', fp);
  756.           putc (c, fp);
  757.         }
  758.       else if (esc != NULL)
  759.         {
  760.           c = escape_names[esc - escapes];
  761.  
  762.           putc ('\\', fp);
  763.           putc (c, fp);
  764.  
  765.           /* We warn about any use of escape sequences beside
  766.          '\n' and '\t'.  */
  767.           if (c != 'n' && c != 't')
  768.         error (0, 0, _("\
  769. internationalized messages should not contain the `\\%c' escape sequence"),
  770.                c);
  771.         }
  772.       else
  773.         fprintf (fp, "\\%3.3o", c);
  774.     }
  775.       fputs ("\"\n", fp);
  776.     }
  777. }
  778.  
  779.  
  780. static void
  781. print_blank_line (fp)
  782.      FILE *fp;
  783. {
  784.   if (uniforum)
  785.     fputs ("#\n", fp);
  786.   else
  787.     putc ('\n', fp);
  788. }
  789.  
  790.  
  791. static void
  792. message_print (mp, fp, domain, blank_line, debug)
  793.      const message_ty *mp;
  794.      FILE *fp;
  795.      const char *domain;
  796.      int blank_line;
  797.      int debug;
  798. {
  799.   message_variant_ty *mvp;
  800.   int first;
  801.   size_t j;
  802.  
  803.   /* Find the relevant message variant.  If there isn't one, remember
  804.      this using a NULL pointer.  */
  805.   mvp = NULL;
  806.   first = 0;
  807.  
  808.   for (j = 0; j < mp->variant_count; ++j)
  809.     {
  810.       if (strcmp (domain, mp->variant[j].domain) == 0)
  811.     {
  812.       mvp = &mp->variant[j];
  813.       first = (j == 0);
  814.       break;
  815.     }
  816.     }
  817.  
  818.   /* Separate messages with a blank line.  Uniforum doesn't like blank
  819.      lines, so use an empty comment (unless there already is one).  */
  820.   if (blank_line && (!uniforum
  821.              || mp->comment == NULL
  822.              || mp->comment->nitems == 0
  823.              || mp->comment->item[0][0] != '\0'))
  824.     print_blank_line (fp);
  825.  
  826.   /* The first variant of a message will have the comments attached to
  827.      it.  We can't attach them to all variants in case we are read in
  828.      again, multiplying the number of comment lines.  Usually there is
  829.      only one variant.  */
  830.   if (first)
  831.     {
  832.       if (mp->comment != NULL)
  833.     for (j = 0; j < mp->comment->nitems; ++j)
  834.       {
  835.         const char *s = mp->comment->item[j];
  836.         do
  837.           {
  838.         const char *e;
  839.         putc ('#', fp);
  840.            /* FIXME This is the wrong locale.  While
  841.           message_list_print set the "C" locale for LC_CTYPE,
  842.           the need to use the correct locale for the file's
  843.           contents.  */
  844.         if (*s != '\0' && !isspace (*s))
  845.           putc (' ', fp);
  846.         e = strchr (s, '\n');
  847.         if (e == NULL)
  848.           {
  849.             fputs (s, fp);
  850.             s = NULL;
  851.           }
  852.         else
  853.           {
  854.             fwrite (s, 1, e - s, fp);
  855.             s = e + 1;
  856.           }
  857.         putc ('\n', fp);
  858.           }
  859.         while (s != NULL);
  860.       }
  861.  
  862.       if (mp->comment_dot != NULL)
  863.     for (j = 0; j < mp->comment_dot->nitems; ++j)
  864.       {
  865.         const char *s = mp->comment_dot->item[j];
  866.         putc ('#', fp);
  867.         putc ('.', fp);
  868.         /* FIXME This is the wrong locale.  While
  869.            message_list_print set the "C" locale for LC_CTYPE, the
  870.            need to use the correct locale for the file's contents.  */
  871.         if (*s && !isspace (*s))
  872.           putc (' ', fp);
  873.         fputs (s, fp);
  874.         putc ('\n', fp);
  875.       }
  876.     }
  877.  
  878.   /* Print the file position comments for every domain.  This will
  879.      help a human who is trying to navigate the sources.  There is no
  880.      problem of getting repeat positions, because duplicates are
  881.      checked for.  */
  882.   if (mp->filepos_count != 0)
  883.     {
  884.       if (uniforum)
  885.     for (j = 0; j < mp->filepos_count; ++j)
  886.       {
  887.         lex_pos_ty *pp = &mp->filepos[j];
  888.         char *cp = pp->file_name;
  889.         while (cp[0] == '.' && cp[1] == '/')
  890.           cp += 2;
  891.         /* There are two Sun formats to choose from: SunOS and
  892.            Solaris.  Use the Solaris form here.  */
  893.         fprintf (fp, "# File: %s, line: %ld\n",
  894.              cp, (long) pp->line_number);
  895.       }
  896.       else
  897.     {
  898.       size_t column;
  899.  
  900.       fputs ("#:", fp);
  901.       column = 2;
  902.       for (j = 0; j < mp->filepos_count; ++j)
  903.         {
  904.           lex_pos_ty *pp;
  905.           char buffer[20];
  906.           char *cp;
  907.           size_t len;
  908.  
  909.           pp = &mp->filepos[j];
  910.           cp = pp->file_name;
  911.           while (cp[0] == '.' && cp[1] == '/')
  912.         cp += 2;
  913.           sprintf (buffer, "%ld", (long) pp->line_number);
  914.           len = strlen (cp) + strlen (buffer) + 2;
  915.           if (column > 2 && column + len >= page_width)
  916.         {
  917.           fputs ("\n#:", fp);
  918.           column = 2;
  919.         }
  920.           fprintf (fp, " %s:%s", cp, buffer);
  921.           column += len;
  922.         }
  923.       putc ('\n', fp);
  924.     }
  925.     }
  926.  
  927.   /* Print flag information in special comment.  */
  928.   if (first && ((mp->is_fuzzy && mvp != NULL && mvp->msgstr[0] != '\0')
  929.         || significant_c_format_p (mp->is_c_format)
  930.         || mp->do_wrap == no))
  931.     {
  932.       int first_flag = 1;
  933.  
  934.       putc ('#', fp);
  935.       putc (',', fp);
  936.  
  937.       /* We don't print the fuzzy flag if the msgstr is empty.  This
  938.      might be introduced by the user but we want to normalize the
  939.      output.  */
  940.       if (mp->is_fuzzy && mvp != NULL && mvp->msgstr[0] != '\0')
  941.     {
  942.       fputs (" fuzzy", fp);
  943.       first_flag = 0;
  944.     }
  945.  
  946.       if (significant_c_format_p (mp->is_c_format))
  947.     {
  948.       if (!first_flag)
  949.         putc (',', fp);
  950.  
  951.       fputs (make_c_format_description_string (mp->is_c_format, debug),
  952.          fp);
  953.       first_flag = 0;
  954.     }
  955.  
  956.       if (mp->do_wrap == no)
  957.     {
  958.       if (!first_flag)
  959.         putc (',', fp);
  960.  
  961.       fputs (make_c_width_description_string (mp->do_wrap), fp);
  962.       first_flag = 0;
  963.     }
  964.  
  965.       putc ('\n', fp);
  966.     }
  967.  
  968.   /* Print each of the message components.  Wrap them nicely so they
  969.      are as readable as possible.  If there is no recorded msgstr for
  970.      this domain, emit an empty string.  */
  971.   wrap (fp, NULL, "msgid", mp->msgid, mp->do_wrap);
  972.   wrap (fp, NULL, "msgstr", mvp ? mvp->msgstr : "", mp->do_wrap);
  973. }
  974.  
  975.  
  976. static void
  977. message_print_obsolete (mp, fp, domain, blank_line)
  978.      const message_ty *mp;
  979.      FILE *fp;
  980.      const char *domain;
  981.      int blank_line;
  982. {
  983.   message_variant_ty *mvp;
  984.   size_t j;
  985.  
  986.   /* Find the relevant message variant.  If there isn't one, remember
  987.      this using a NULL pointer.  */
  988.   mvp = NULL;
  989.  
  990.   for (j = 0; j < mp->variant_count; ++j)
  991.     {
  992.       if (strcmp (domain, mp->variant[j].domain) == 0)
  993.     {
  994.       mvp = &mp->variant[j];
  995.       break;
  996.     }
  997.     }
  998.  
  999.   /* If no msgstr is found or it is the empty string we print nothing.  */
  1000.   if (mvp == NULL || mvp->msgstr[0] == '\0')
  1001.     return;
  1002.  
  1003.   /* Separate messages with a blank line.  Uniforum doesn't like blank
  1004.      lines, so use an empty comment (unless there already is one).  */
  1005.   if (blank_line)
  1006.     print_blank_line (fp);
  1007.  
  1008.   /* Print translator comment if available.  */
  1009.   if (mp->comment)
  1010.     for (j = 0; j < mp->comment->nitems; ++j)
  1011.       {
  1012.     const char *s = mp->comment->item[j];
  1013.     do
  1014.       {
  1015.         const char *e;
  1016.         putc ('#', fp);
  1017.         /* FIXME This is the wrong locale.  While
  1018.            message_list_print set the "C" locale for LC_CTYPE, the
  1019.            need to use the correct locale for the file's contents.  */
  1020.         if (*s != '\0' && !isspace (*s))
  1021.           putc (' ', fp);
  1022.         e = strchr (s, '\n');
  1023.         if (e == NULL)
  1024.           {
  1025.         fputs (s, fp);
  1026.         s = NULL;
  1027.           }
  1028.         else
  1029.           {
  1030.         fwrite (s, 1, e - s, fp);
  1031.         s = e + 1;
  1032.           }
  1033.         putc ('\n', fp);
  1034.       }
  1035.     while (s != NULL);
  1036.       }
  1037.  
  1038.   /* Print flag information in special comment.  */
  1039.   if (mp->is_fuzzy)
  1040.     {
  1041.       int first = 1;
  1042.  
  1043.       putc ('#', fp);
  1044.       putc (',', fp);
  1045.  
  1046.       if (mp->is_fuzzy)
  1047.     {
  1048.       fputs (" fuzzy", fp);
  1049.       first = 0;
  1050.     }
  1051.  
  1052.       putc ('\n', fp);
  1053.     }
  1054.  
  1055.   /* Print each of the message components.  Wrap them nicely so they
  1056.      are as readable as possible.  */
  1057.   wrap (fp, "#~ ", "msgid", mp->msgid, mp->do_wrap);
  1058.   wrap (fp, "#~ ", "msgstr", mvp->msgstr, mp->do_wrap);
  1059. }
  1060.  
  1061.  
  1062. void
  1063. message_list_print (mlp, filename, force, debug)
  1064.      message_list_ty *mlp;
  1065.      const char *filename;
  1066.      int force;
  1067.      int debug;
  1068. {
  1069.   FILE *fp;
  1070.   size_t j, k;
  1071.   string_list_ty *dl;
  1072.   int blank_line;
  1073. #ifdef HAVE_SETLOCALE
  1074.   char *old_locale;
  1075. #endif
  1076.  
  1077.   /* We will not write anything if we have no message or only the
  1078.      header entry.  */
  1079.   if (force == 0
  1080.       && (mlp->nitems == 0
  1081.       || (mlp->nitems == 1 && *mlp->item[0]->msgid == '\0')))
  1082.     return;
  1083.  
  1084.   /* Build the list of domains.  */
  1085.   dl = string_list_alloc ();
  1086.   for (j = 0; j < mlp->nitems; ++j)
  1087.     {
  1088.       message_ty *mp = mlp->item[j];
  1089.       for (k = 0; k < mp->variant_count; ++k)
  1090.     string_list_append_unique (dl, mp->variant[k].domain);
  1091.     }
  1092.  
  1093.   /* Open the output file.  */
  1094.   if (filename != NULL && strcmp (filename, "-") != 0
  1095.       && strcmp (filename, "/dev/stdout") != 0)
  1096.     {
  1097.       fp = fopen (filename, "w");
  1098.       if (fp == NULL)
  1099.     error (EXIT_FAILURE, errno, _("cannot create output file \"%s\""),
  1100.            filename);
  1101.     }
  1102.   else
  1103.     {
  1104.       fp = stdout;
  1105.       /* xgettext:no-c-format */
  1106.       filename = _("standard output");
  1107.     }
  1108.  
  1109. #ifdef HAVE_SETLOCALE
  1110.   /* FIXME This is the wrong locale.  The program is currently set for
  1111.      the user's native language locale, for the error messages.  This
  1112.      code sets it to the "C" locale, but that isn't right either.  The
  1113.      need is to use the correct locale for the file's contents.  */
  1114.   old_locale = setlocale (LC_CTYPE, "C");
  1115.   if (old_locale)
  1116.     old_locale = xstrdup (old_locale);
  1117. #endif
  1118.  
  1119.   /* Write out the messages for each domain.  */
  1120.   blank_line = 0;
  1121.   for (k = 0; k < dl->nitems; ++k)
  1122.     {
  1123.       /* If there is only one domain, and that domain is the default,
  1124.      don't bother emitting the domain name, because it is the
  1125.      default.  */
  1126.       if (dl->nitems != 1 || strcmp (dl->item[0], MESSAGE_DOMAIN_DEFAULT) != 0)
  1127.     {
  1128.       if (blank_line)
  1129.         print_blank_line (fp);
  1130.       fprintf (fp, "domain \"%s\"\n", dl->item[k]);
  1131.       blank_line = 1;
  1132.     }
  1133.  
  1134.       /* Write out each of the messages for this domain.  */
  1135.       for (j = 0; j < mlp->nitems; ++j)
  1136.     if (mlp->item[j]->obsolete == 0)
  1137.       {
  1138.         message_print (mlp->item[j], fp, dl->item[k], blank_line, debug);
  1139.         blank_line = 1;
  1140.       }
  1141.  
  1142.       /* Write out each of the obsolete messages for this domain.  */
  1143.       for (j = 0; j < mlp->nitems; ++j)
  1144.     if (mlp->item[j]->obsolete != 0)
  1145.       {
  1146.         message_print_obsolete (mlp->item[j], fp, dl->item[k], blank_line);
  1147.         blank_line = 1;
  1148.       }
  1149.     }
  1150.   string_list_free (dl);
  1151.  
  1152.   /* Restore the old locale.  Do this before emitting error messages,
  1153.      so that the correct locale is used for the error.  (Ideally,
  1154.      error should ensure this before calling gettext for the format
  1155.      string.)  */
  1156. #ifdef HAVE_SETLOCALE
  1157.   if (old_locale)
  1158.     {
  1159.       setlocale (LC_CTYPE, old_locale);
  1160.       free (old_locale);
  1161.     }
  1162. #endif
  1163.  
  1164.   /* Make sure nothing went wrong.  */
  1165.   if (fflush (fp))
  1166.     error (EXIT_FAILURE, errno, _("error while writing \"%s\" file"),
  1167.        filename);
  1168.   fclose (fp);
  1169. }
  1170.  
  1171.  
  1172. static int
  1173. msgid_cmp (va, vb)
  1174.      const void *va;
  1175.      const void *vb;
  1176. {
  1177.   const message_ty *a = *(const message_ty **) va;
  1178.   const message_ty *b = *(const message_ty **) vb;
  1179. #ifdef HAVE_STRCOLL
  1180.   return strcoll (a->msgid, b->msgid);
  1181. #else
  1182.   return strcmp (a->msgid, b->msgid);
  1183. #endif
  1184. }
  1185.  
  1186.  
  1187. void
  1188. message_list_sort_by_msgid (mlp)
  1189.      message_list_ty *mlp;
  1190. {
  1191.   /* FIXME This is the wrong locale.  The program is currently set for
  1192.      the user's native language locale, for the error messages.  This
  1193.      code sets it to the "C" locale, but that isn't right either.  The
  1194.      need is to use the correct locale for the file's contents.  */
  1195. #ifdef HAVE_SETLOCALE
  1196.   char *tmp = setlocale (LC_COLLATE, "C");
  1197.   if (tmp)
  1198.     tmp = xstrdup (tmp);
  1199. #endif
  1200.   qsort (mlp->item, mlp->nitems, sizeof (mlp->item[0]), msgid_cmp);
  1201. #ifdef HAVE_SETLOCALE
  1202.   if (tmp)
  1203.     {
  1204.       setlocale (LC_COLLATE, tmp);
  1205.       free (tmp);
  1206.     }
  1207. #endif
  1208. }
  1209.  
  1210.  
  1211. static int
  1212. filepos_cmp (va, vb)
  1213.      const void *va;
  1214.      const void *vb;
  1215. {
  1216.   const message_ty *a = *(const message_ty **) va;
  1217.   const message_ty *b = *(const message_ty **) vb;
  1218.   int cmp;
  1219.  
  1220.   /* No filepos is smaller than any other filepos.  */
  1221.   if (a->filepos_count == 0)
  1222.   {
  1223.     if (b->filepos_count != 0)
  1224.       return -1;
  1225.   }
  1226.   if (b->filepos_count == 0)
  1227.     return 1;
  1228.  
  1229.   /* Compare on the file names...  */
  1230.   cmp = strcmp (a->filepos[0].file_name, b->filepos[0].file_name);
  1231.   if (cmp != 0)
  1232.       return cmp;
  1233.  
  1234.   /* If they are equal, compare on the line numbers...  */
  1235.   cmp = a->filepos[0].line_number - b->filepos[0].line_number;
  1236.   if (cmp != 0)
  1237.     return cmp;
  1238.  
  1239.   /* If they are equal, compare on the msgid strings.  */
  1240. #ifdef HAVE_STRCOLL
  1241.   return strcoll (a->msgid, b->msgid);
  1242. #else
  1243.   return strcmp (a->msgid, b->msgid);
  1244. #endif
  1245. }
  1246.  
  1247.  
  1248. void
  1249. message_list_sort_by_filepos (mlp)
  1250.     message_list_ty *mlp;
  1251. {
  1252.   /* FIXME This is the wrong locale.  The program is currently set for
  1253.      the user's native language locale, for the error messages.  This
  1254.      code sets it to the "C" locale, but that isn't right either.  The
  1255.      need is to use the correct locale for the file's contents.  */
  1256. #ifdef HAVE_SETLOCALE
  1257.   char *tmp = setlocale (LC_COLLATE, "C");
  1258.   if (tmp)
  1259.     tmp = xstrdup (tmp);
  1260. #endif
  1261.   qsort (mlp->item, mlp->nitems, sizeof (mlp->item[0]), filepos_cmp);
  1262. #ifdef HAVE_SETLOCALE
  1263.   if (tmp)
  1264.     {
  1265.       setlocale (LC_COLLATE, tmp);
  1266.       free (tmp);
  1267.     }
  1268. #endif
  1269. }
  1270.  
  1271.  
  1272. enum is_c_format
  1273. parse_c_format_description_string (s)
  1274.      const char *s;
  1275. {
  1276.   if (strstr (s, "no-c-format") != NULL)
  1277.     return no;
  1278.   else if (strstr (s, "impossible-c-format") != NULL)
  1279.     return impossible;
  1280.   else if (strstr (s, "possible-c-format") != NULL)
  1281.     return possible;
  1282.   else if (strstr (s, "c-format") != NULL)
  1283.     return yes;
  1284.   return undecided;
  1285. }
  1286.  
  1287.  
  1288. enum is_c_format
  1289. parse_c_width_description_string (s)
  1290.      const char *s;
  1291. {
  1292.   if (strstr (s, "no-wrap") != NULL)
  1293.     return no;
  1294.   else if (strstr (s, "wrap") != NULL)
  1295.     return yes;
  1296.   return undecided;
  1297. }
  1298.  
  1299.  
  1300. static const char *
  1301. make_c_format_description_string (is_c_format, debug)
  1302.      enum is_c_format is_c_format;
  1303.      int debug;
  1304. {
  1305.   const char *result = NULL;
  1306.  
  1307.   switch (is_c_format)
  1308.     {
  1309.     case possible:
  1310.       if (debug)
  1311.     {
  1312.       result = " possible-c-format";
  1313.       break;
  1314.     }
  1315.       /* FALLTHROUGH */
  1316.     case yes:
  1317.       result = " c-format";
  1318.       break;
  1319.     case impossible:
  1320.       result = " impossible-c-format";
  1321.       break;
  1322.     case no:
  1323.       result = " no-c-format";
  1324.       break;
  1325.     case undecided:
  1326.       result = " undecided";
  1327.       break;
  1328.     default:
  1329.       abort ();
  1330.     }
  1331.  
  1332.   return result;
  1333. }
  1334.  
  1335.  
  1336. static const char *
  1337. make_c_width_description_string (do_wrap)
  1338.      enum is_c_format do_wrap;
  1339. {
  1340.   const char *result = NULL;
  1341.  
  1342.   switch (do_wrap)
  1343.     {
  1344.     case yes:
  1345.       result = " wrap";
  1346.       break;
  1347.     case no:
  1348.       result = " no-wrap";
  1349.       break;
  1350.     default:
  1351.       abort ();
  1352.     }
  1353.  
  1354.   return result;
  1355. }
  1356.  
  1357.  
  1358. int
  1359. possible_c_format_p (is_c_format)
  1360.      enum is_c_format is_c_format;
  1361. {
  1362.   return is_c_format == possible || is_c_format == yes;
  1363. }
  1364.  
  1365.  
  1366. static int
  1367. significant_c_format_p (is_c_format)
  1368.      enum is_c_format is_c_format;
  1369. {
  1370.   return is_c_format != undecided && is_c_format != impossible;
  1371. }
  1372.  
  1373.  
  1374. void
  1375. message_page_width_set (n)
  1376.      size_t n;
  1377. {
  1378.   if (n == 0)
  1379.     {
  1380.       page_width = INT_MAX;
  1381.       return;
  1382.     }
  1383.  
  1384.   if (n < 20)
  1385.     n = 20;
  1386.  
  1387.   page_width = n;
  1388. }
  1389.