← Back to branch summary

~ubuntu-branches/ubuntu/utopic/gettext/utopic

« back to all changes in this revision

Viewing changes to gettext-tools/libgettextpo/gettext-po.c

  • Committer: Colin Watson
  • Date: 2010-08-01 21:36:08 UTC
  • mfrom: (2.1.10 sid)
  • Revision ID: cjwatson@canonical.com-20100801213608-yy7vkm8lpatep3ci
merge from Debian 0.18.1.1-1

Show diffs side-by-side

added added

removed removed

Lines of Context:
gettext-tools/libgettextpo/gettext-po.c
1
1
/* Public API for GNU gettext PO files.
2
 
   Copyright (C) 2003-2007 Free Software Foundation, Inc.
 
2
   Copyright (C) 2003-2009 Free Software Foundation, Inc.
3
3
   Written by Bruno Haible <bruno@clisp.org>, 2003.
4
4
 
5
5
   This program is free software: you can redistribute it and/or modify
106
106
    {
107
107
      fp = fopen (filename, "r");
108
108
      if (fp == NULL)
109
 
        return NULL;
 
109
        return NULL;
110
110
    }
111
111
 
112
112
  /* Establish error handler around read_catalog_stream().  */
122
122
  file->real_filename = filename;
123
123
  file->logical_filename = filename;
124
124
  file->mdlp = read_catalog_stream (fp, file->real_filename,
125
 
                                    file->logical_filename, &input_format_po);
 
125
                                    file->logical_filename, &input_format_po);
126
126
  file->domains = NULL;
127
127
 
128
128
  /* Restore error handler.  */
154
154
    {
155
155
      fp = fopen (filename, "r");
156
156
      if (fp == NULL)
157
 
        return NULL;
 
157
        return NULL;
158
158
    }
159
159
 
160
160
  /* Establish error handler around read_catalog_stream().  */
168
168
  file->real_filename = filename;
169
169
  file->logical_filename = filename;
170
170
  file->mdlp = read_catalog_stream (fp, file->real_filename,
171
 
                                    file->logical_filename, &input_format_po);
 
171
                                    file->logical_filename, &input_format_po);
172
172
  file->domains = NULL;
173
173
 
174
174
  /* Restore error handler.  */
202
202
    {
203
203
      fp = fopen (filename, "r");
204
204
      if (fp == NULL)
205
 
        return NULL;
 
205
        return NULL;
206
206
    }
207
207
 
208
208
  file = XMALLOC (struct po_file);
209
209
  file->real_filename = filename;
210
210
  file->logical_filename = filename;
211
211
  file->mdlp = read_catalog_stream (fp, file->real_filename,
212
 
                                    file->logical_filename, &input_format_po);
 
212
                                    file->logical_filename, &input_format_po);
213
213
  file->domains = NULL;
214
214
 
215
215
  if (fp != stdin)
291
291
      size_t j;
292
292
 
293
293
      for (j = 0; j < n; j++)
294
 
        domains[j] = file->mdlp->item[j]->domain;
 
294
        domains[j] = file->mdlp->item[j]->domain;
295
295
      domains[n] = NULL;
296
296
 
297
297
      file->domains = domains;
317
317
  if (mlp != NULL)
318
318
    for (j = 0; j < mlp->nitems; j++)
319
319
      if (is_header (mlp->item[j]) && !mlp->item[j]->obsolete)
320
 
        {
321
 
          const char *header = mlp->item[j]->msgstr;
 
320
        {
 
321
          const char *header = mlp->item[j]->msgstr;
322
322
 
323
 
          if (header != NULL)
324
 
            return xstrdup (header);
325
 
          else
326
 
            return NULL;
327
 
        }
 
323
          if (header != NULL)
 
324
            return xstrdup (header);
 
325
          else
 
326
            return NULL;
 
327
        }
328
328
  return NULL;
329
329
}
330
330
 
341
341
 
342
342
  for (line = header;;)
343
343
    {
344
 
      if (strncmp (line, field, field_len) == 0
345
 
          && line[field_len] == ':' && line[field_len + 1] == ' ')
346
 
        {
347
 
          const char *value_start;
348
 
          const char *value_end;
349
 
          char *value;
350
 
 
351
 
          value_start = line + field_len + 2;
352
 
          value_end = strchr (value_start, '\n');
353
 
          if (value_end == NULL)
354
 
            value_end = value_start + strlen (value_start);
355
 
 
356
 
          value = XNMALLOC (value_end - value_start + 1, char);
357
 
          memcpy (value, value_start, value_end - value_start);
358
 
          value[value_end - value_start] = '\0';
359
 
 
360
 
          return value;
361
 
        }
 
344
      if (strncmp (line, field, field_len) == 0 && line[field_len] == ':')
 
345
        {
 
346
          const char *value_start;
 
347
          const char *value_end;
 
348
          char *value;
 
349
 
 
350
          value_start = line + field_len + 1;
 
351
          if (*value_start == ' ')
 
352
            value_start++;
 
353
          value_end = strchr (value_start, '\n');
 
354
          if (value_end == NULL)
 
355
            value_end = value_start + strlen (value_start);
 
356
 
 
357
          value = XNMALLOC (value_end - value_start + 1, char);
 
358
          memcpy (value, value_start, value_end - value_start);
 
359
          value[value_end - value_start] = '\0';
 
360
 
 
361
          return value;
 
362
        }
362
363
 
363
364
      line = strchr (line, '\n');
364
365
      if (line != NULL)
365
 
        line++;
 
366
        line++;
366
367
      else
367
 
        break;
 
368
        break;
368
369
    }
369
370
 
370
371
  return NULL;
387
388
 
388
389
    for (line = header;;)
389
390
      {
390
 
        if (strncmp (line, field, field_len) == 0
391
 
            && line[field_len] == ':' && line[field_len + 1] == ' ')
392
 
          {
393
 
            const char *oldvalue_start;
394
 
            const char *oldvalue_end;
395
 
            size_t oldvalue_len;
396
 
            size_t header_part1_len;
397
 
            size_t header_part3_len;
398
 
            size_t result_len;
399
 
            char *result;
400
 
 
401
 
            oldvalue_start = line + field_len + 2;
402
 
            oldvalue_end = strchr (oldvalue_start, '\n');
403
 
            if (oldvalue_end == NULL)
404
 
              oldvalue_end = oldvalue_start + strlen (oldvalue_start);
405
 
            oldvalue_len = oldvalue_end - oldvalue_start;
406
 
 
407
 
            header_part1_len = oldvalue_start - header;
408
 
            header_part3_len = header + header_len - oldvalue_end;
409
 
            result_len = header_part1_len + value_len + header_part3_len;
410
 
                    /* = header_len - oldvalue_len + value_len */
411
 
            result = XNMALLOC (result_len + 1, char);
412
 
            memcpy (result, header, header_part1_len);
413
 
            memcpy (result + header_part1_len, value, value_len);
414
 
            memcpy (result + header_part1_len + value_len, oldvalue_end,
415
 
                    header_part3_len);
416
 
            *(result + result_len) = '\0';
417
 
 
418
 
            return result;
419
 
          }
420
 
 
421
 
        line = strchr (line, '\n');
422
 
        if (line != NULL)
423
 
          line++;
424
 
        else
425
 
          break;
 
391
        if (strncmp (line, field, field_len) == 0 && line[field_len] == ':')
 
392
          {
 
393
            const char *oldvalue_start;
 
394
            const char *oldvalue_end;
 
395
            size_t oldvalue_len;
 
396
            size_t header_part1_len;
 
397
            size_t header_part3_len;
 
398
            size_t result_len;
 
399
            char *result;
 
400
 
 
401
            oldvalue_start = line + field_len + 1;
 
402
            if (*oldvalue_start == ' ')
 
403
              oldvalue_start++;
 
404
            oldvalue_end = strchr (oldvalue_start, '\n');
 
405
            if (oldvalue_end == NULL)
 
406
              oldvalue_end = oldvalue_start + strlen (oldvalue_start);
 
407
            oldvalue_len = oldvalue_end - oldvalue_start;
 
408
 
 
409
            header_part1_len = oldvalue_start - header;
 
410
            header_part3_len = header + header_len - oldvalue_end;
 
411
            result_len = header_part1_len + value_len + header_part3_len;
 
412
                    /* = header_len - oldvalue_len + value_len */
 
413
            result = XNMALLOC (result_len + 1, char);
 
414
            memcpy (result, header, header_part1_len);
 
415
            memcpy (result + header_part1_len, value, value_len);
 
416
            memcpy (result + header_part1_len + value_len, oldvalue_end,
 
417
                    header_part3_len);
 
418
            *(result + result_len) = '\0';
 
419
 
 
420
            return result;
 
421
          }
 
422
 
 
423
        line = strchr (line, '\n');
 
424
        if (line != NULL)
 
425
          line++;
 
426
        else
 
427
          break;
426
428
      }
427
429
  }
428
430
  {
548
550
 
549
551
      mp->msgctxt = (msgctxt != NULL ? xstrdup (msgctxt) : NULL);
550
552
      if (old_msgctxt != NULL)
551
 
        free (old_msgctxt);
 
553
        free (old_msgctxt);
552
554
    }
553
555
}
554
556
 
577
579
 
578
580
      mp->msgid = xstrdup (msgid);
579
581
      if (old_msgid != NULL)
580
 
        free (old_msgid);
 
582
        free (old_msgid);
581
583
    }
582
584
}
583
585
 
608
610
 
609
611
      mp->msgid_plural = (msgid_plural != NULL ? xstrdup (msgid_plural) : NULL);
610
612
      if (old_msgid_plural != NULL)
611
 
        free (old_msgid_plural);
 
613
        free (old_msgid_plural);
612
614
    }
613
615
}
614
616
 
640
642
      mp->msgstr = xstrdup (msgstr);
641
643
      mp->msgstr_len = strlen (mp->msgstr) + 1;
642
644
      if (old_msgstr != NULL)
643
 
        free (old_msgstr);
 
645
        free (old_msgstr);
644
646
    }
645
647
}
646
648
 
659
661
      const char *p_end = mp->msgstr + mp->msgstr_len;
660
662
 
661
663
      for (p = mp->msgstr; ; p += strlen (p) + 1, index--)
662
 
        {
663
 
          if (p >= p_end)
664
 
            return NULL;
665
 
          if (index == 0)
666
 
            break;
667
 
        }
 
664
        {
 
665
          if (p >= p_end)
 
666
            return NULL;
 
667
          if (index == 0)
 
668
            break;
 
669
        }
668
670
      return p;
669
671
    }
670
672
  else
687
689
      char *copied_msgstr;
688
690
 
689
691
      /* Special care must be taken of the case that msgstr points into the
690
 
         mp->msgstr string list, because mp->msgstr may be relocated before we
691
 
         are done with msgstr.  */
 
692
         mp->msgstr string list, because mp->msgstr may be relocated before we
 
693
         are done with msgstr.  */
692
694
      if (msgstr >= p && msgstr < p_end)
693
 
        msgstr = copied_msgstr = xstrdup (msgstr);
 
695
        msgstr = copied_msgstr = xstrdup (msgstr);
694
696
      else
695
 
        copied_msgstr = NULL;
 
697
        copied_msgstr = NULL;
696
698
 
697
699
      for (; ; p += strlen (p) + 1, index--)
698
 
        {
699
 
          if (p >= p_end)
700
 
            {
701
 
              /* Append at the end.  */
702
 
              if (msgstr != NULL)
703
 
                {
704
 
                  size_t new_msgstr_len = mp->msgstr_len + index + strlen (msgstr) + 1;
 
700
        {
 
701
          if (p >= p_end)
 
702
            {
 
703
              /* Append at the end.  */
 
704
              if (msgstr != NULL)
 
705
                {
 
706
                  size_t new_msgstr_len = mp->msgstr_len + index + strlen (msgstr) + 1;
705
707
 
706
 
                  mp->msgstr =
707
 
                    (char *) xrealloc ((char *) mp->msgstr, new_msgstr_len);
708
 
                  p = (char *) mp->msgstr + mp->msgstr_len;
709
 
                  for (; index > 0; index--)
710
 
                    *p++ = '\0';
711
 
                  memcpy (p, msgstr, strlen (msgstr) + 1);
712
 
                  mp->msgstr_len = new_msgstr_len;
713
 
                }
714
 
              if (copied_msgstr != NULL)
715
 
                free (copied_msgstr);
716
 
              return;
717
 
            }
718
 
          if (index == 0)
719
 
            break;
720
 
        }
 
708
                  mp->msgstr =
 
709
                    (char *) xrealloc ((char *) mp->msgstr, new_msgstr_len);
 
710
                  p = (char *) mp->msgstr + mp->msgstr_len;
 
711
                  for (; index > 0; index--)
 
712
                    *p++ = '\0';
 
713
                  memcpy (p, msgstr, strlen (msgstr) + 1);
 
714
                  mp->msgstr_len = new_msgstr_len;
 
715
                }
 
716
              if (copied_msgstr != NULL)
 
717
                free (copied_msgstr);
 
718
              return;
 
719
            }
 
720
          if (index == 0)
 
721
            break;
 
722
        }
721
723
      if (msgstr == NULL)
722
 
        {
723
 
          if (p + strlen (p) + 1 >= p_end)
724
 
            {
725
 
              /* Remove the string that starts at p.  */
726
 
              mp->msgstr_len = p - mp->msgstr;
727
 
              return;
728
 
            }
729
 
          /* It is not possible to remove an element of the string list
730
 
             except the last one.  So just replace it with the empty string.
731
 
             That's the best we can do here.  */
732
 
          msgstr = "";
733
 
        }
 
724
        {
 
725
          if (p + strlen (p) + 1 >= p_end)
 
726
            {
 
727
              /* Remove the string that starts at p.  */
 
728
              mp->msgstr_len = p - mp->msgstr;
 
729
              return;
 
730
            }
 
731
          /* It is not possible to remove an element of the string list
 
732
             except the last one.  So just replace it with the empty string.
 
733
             That's the best we can do here.  */
 
734
          msgstr = "";
 
735
        }
734
736
      {
735
 
        /* Replace the string that starts at p.  */
736
 
        size_t i1 = p - mp->msgstr;
737
 
        size_t i2before = i1 + strlen (p);
738
 
        size_t i2after = i1 + strlen (msgstr);
739
 
        size_t new_msgstr_len = mp->msgstr_len - i2before + i2after;
 
737
        /* Replace the string that starts at p.  */
 
738
        size_t i1 = p - mp->msgstr;
 
739
        size_t i2before = i1 + strlen (p);
 
740
        size_t i2after = i1 + strlen (msgstr);
 
741
        size_t new_msgstr_len = mp->msgstr_len - i2before + i2after;
740
742
 
741
 
        if (i2after > i2before)
742
 
          mp->msgstr = (char *) xrealloc ((char *) mp->msgstr, new_msgstr_len);
743
 
        memmove ((char *) mp->msgstr + i2after, mp->msgstr + i2before,
744
 
                 mp->msgstr_len - i2before);
745
 
        memcpy ((char *) mp->msgstr + i1, msgstr, i2after - i1);
746
 
        mp->msgstr_len = new_msgstr_len;
 
743
        if (i2after > i2before)
 
744
          mp->msgstr = (char *) xrealloc ((char *) mp->msgstr, new_msgstr_len);
 
745
        memmove ((char *) mp->msgstr + i2after, mp->msgstr + i2before,
 
746
                 mp->msgstr_len - i2before);
 
747
        memcpy ((char *) mp->msgstr + i1, msgstr, i2after - i1);
 
748
        mp->msgstr_len = new_msgstr_len;
747
749
      }
748
750
      if (copied_msgstr != NULL)
749
 
        free (copied_msgstr);
 
751
        free (copied_msgstr);
750
752
    }
751
753
}
752
754
 
762
764
  if (mp->comment == NULL || mp->comment->nitems == 0)
763
765
    return "";
764
766
  else
765
 
    return string_list_join (mp->comment, '\n', '\n', true);
 
767
    return string_list_join (mp->comment, "\n", '\n', true);
766
768
}
767
769
 
768
770
 
782
784
    rest = copy;
783
785
    while (*rest != '\0')
784
786
      {
785
 
        char *newline = strchr (rest, '\n');
 
787
        char *newline = strchr (rest, '\n');
786
788
 
787
 
        if (newline != NULL)
788
 
          {
789
 
            *newline = '\0';
790
 
            string_list_append (slp, rest);
791
 
            rest = newline + 1;
792
 
          }
793
 
        else
794
 
          {
795
 
            string_list_append (slp, rest);
796
 
            break;
797
 
          }
 
789
        if (newline != NULL)
 
790
          {
 
791
            *newline = '\0';
 
792
            string_list_append (slp, rest);
 
793
            rest = newline + 1;
 
794
          }
 
795
        else
 
796
          {
 
797
            string_list_append (slp, rest);
 
798
            break;
 
799
          }
798
800
      }
799
801
    free (copy);
800
802
  }
817
819
  if (mp->comment_dot == NULL || mp->comment_dot->nitems == 0)
818
820
    return "";
819
821
  else
820
 
    return string_list_join (mp->comment_dot, '\n', '\n', true);
 
822
    return string_list_join (mp->comment_dot, "\n", '\n', true);
821
823
}
822
824
 
823
825
 
837
839
    rest = copy;
838
840
    while (*rest != '\0')
839
841
      {
840
 
        char *newline = strchr (rest, '\n');
 
842
        char *newline = strchr (rest, '\n');
841
843
 
842
 
        if (newline != NULL)
843
 
          {
844
 
            *newline = '\0';
845
 
            string_list_append (slp, rest);
846
 
            rest = newline + 1;
847
 
          }
848
 
        else
849
 
          {
850
 
            string_list_append (slp, rest);
851
 
            break;
852
 
          }
 
844
        if (newline != NULL)
 
845
          {
 
846
            *newline = '\0';
 
847
            string_list_append (slp, rest);
 
848
            rest = newline + 1;
 
849
          }
 
850
        else
 
851
          {
 
852
            string_list_append (slp, rest);
 
853
            break;
 
854
          }
853
855
      }
854
856
    free (copy);
855
857
  }
891
893
      size_t n = mp->filepos_count;
892
894
 
893
895
      if (j < n)
894
 
        {
895
 
          mp->filepos_count = n = n - 1;
896
 
          free ((char *) mp->filepos[j].file_name);
897
 
          for (; j < n; j++)
898
 
            mp->filepos[j] = mp->filepos[j + 1];
899
 
        }
 
896
        {
 
897
          mp->filepos_count = n = n - 1;
 
898
          free ((char *) mp->filepos[j].file_name);
 
899
          for (; j < n; j++)
 
900
            mp->filepos[j] = mp->filepos[j + 1];
 
901
        }
900
902
    }
901
903
}
902
904
 
940
942
 
941
943
      mp->prev_msgctxt = (prev_msgctxt != NULL ? xstrdup (prev_msgctxt) : NULL);
942
944
      if (old_prev_msgctxt != NULL)
943
 
        free (old_prev_msgctxt);
 
945
        free (old_prev_msgctxt);
944
946
    }
945
947
}
946
948
 
971
973
 
972
974
      mp->prev_msgid = (prev_msgid != NULL ? xstrdup (prev_msgid) : NULL);
973
975
      if (old_prev_msgid != NULL)
974
 
        free (old_prev_msgid);
 
976
        free (old_prev_msgid);
975
977
    }
976
978
}
977
979
 
1001
1003
      char *old_prev_msgid_plural = (char *) mp->prev_msgid_plural;
1002
1004
 
1003
1005
      mp->prev_msgid_plural =
1004
 
        (prev_msgid_plural != NULL ? xstrdup (prev_msgid_plural) : NULL);
 
1006
        (prev_msgid_plural != NULL ? xstrdup (prev_msgid_plural) : NULL);
1005
1007
      if (old_prev_msgid_plural != NULL)
1006
 
        free (old_prev_msgid_plural);
 
1008
        free (old_prev_msgid_plural);
1007
1009
    }
1008
1010
}
1009
1011
 
1065
1067
  if (len >= 7 && memcmp (format_type + len - 7, "-format", 7) == 0)
1066
1068
    for (i = 0; i < NFORMATS; i++)
1067
1069
      if (strlen (format_language[i]) == len - 7
1068
 
          && memcmp (format_language[i], format_type, len - 7) == 0)
1069
 
        /* The given format_type corresponds to (enum format_type) i.  */
1070
 
        return (possible_format_p (mp->is_format[i]) ? 1 : 0);
 
1070
          && memcmp (format_language[i], format_type, len - 7) == 0)
 
1071
        /* The given format_type corresponds to (enum format_type) i.  */
 
1072
        return (possible_format_p (mp->is_format[i]) ? 1 : 0);
1071
1073
  return 0;
1072
1074
}
1073
1075
 
1084
1086
  if (len >= 7 && memcmp (format_type + len - 7, "-format", 7) == 0)
1085
1087
    for (i = 0; i < NFORMATS; i++)
1086
1088
      if (strlen (format_language[i]) == len - 7
1087
 
          && memcmp (format_language[i], format_type, len - 7) == 0)
1088
 
        /* The given format_type corresponds to (enum format_type) i.  */
1089
 
        mp->is_format[i] = (value ? yes : no);
 
1089
          && memcmp (format_language[i], format_type, len - 7) == 0)
 
1090
        /* The given format_type corresponds to (enum format_type) i.  */
 
1091
        mp->is_format[i] = (value ? yes : no);
 
1092
}
 
1093
 
 
1094
 
 
1095
/* If a numeric range of a message is set, return true and store the minimum
 
1096
   and maximum value in *MINP and *MAXP.  */
 
1097
 
 
1098
int
 
1099
po_message_is_range (po_message_t message, int *minp, int *maxp)
 
1100
{
 
1101
  message_ty *mp = (message_ty *) message;
 
1102
 
 
1103
  if (has_range_p (mp->range))
 
1104
    {
 
1105
      *minp = mp->range.min;
 
1106
      *minp = mp->range.max;
 
1107
      return 1;
 
1108
    }
 
1109
  else
 
1110
    return 0;
 
1111
}
 
1112
 
 
1113
 
 
1114
/* Change the numeric range of a message.  MIN and MAX must be non-negative,
 
1115
   with MIN < MAX.  Use MIN = MAX = -1 to remove the numeric range of a
 
1116
   message.  */
 
1117
 
 
1118
void
 
1119
po_message_set_range (po_message_t message, int min, int max)
 
1120
{
 
1121
  message_ty *mp = (message_ty *) message;
 
1122
 
 
1123
  if (min >= 0 && max >= min)
 
1124
    {
 
1125
      mp->range.min = min;
 
1126
      mp->range.max = max;
 
1127
    }
 
1128
  else if (min < 0 && max < 0)
 
1129
    {
 
1130
      mp->range.min = -1;
 
1131
      mp->range.max = -1;
 
1132
    }
 
1133
  /* Other values of min and max are invalid.  */
1090
1134
}
1091
1135
 
1092
1136
 
1124
1168
      const char **list = XNMALLOC (NFORMATS + 1, const char *);
1125
1169
      size_t i;
1126
1170
      for (i = 0; i < NFORMATS; i++)
1127
 
        list[i] = xasprintf ("%s-format", format_language[i]);
 
1171
        list[i] = xasprintf ("%s-format", format_language[i]);
1128
1172
      list[i] = NULL;
1129
1173
      whole_list = list;
1130
1174
    }
1145
1189
  if (len >= 7 && memcmp (format_type + len - 7, "-format", 7) == 0)
1146
1190
    for (i = 0; i < NFORMATS; i++)
1147
1191
      if (strlen (format_language[i]) == len - 7
1148
 
          && memcmp (format_language[i], format_type, len - 7) == 0)
1149
 
        /* The given format_type corresponds to (enum format_type) i.  */
1150
 
        return format_language_pretty[i];
 
1192
          && memcmp (format_language[i], format_type, len - 7) == 0)
 
1193
        /* The given format_type corresponds to (enum format_type) i.  */
 
1194
        return format_language_pretty[i];
1151
1195
  return NULL;
1152
1196
}
1153
1197
 
1185
1229
 
1186
1230
void
1187
1231
po_message_check_all (po_message_t message, po_message_iterator_t iterator,
1188
 
                      po_xerror_handler_t handler)
 
1232
                      po_xerror_handler_t handler)
1189
1233
{
1190
1234
  message_ty *mp = (message_ty *) message;
1191
1235
 
1209
1253
 
1210
1254
      header = NULL;
1211
1255
      mlp =
1212
 
        msgdomain_list_sublist (iterator->file->mdlp, iterator->domain, false);
 
1256
        msgdomain_list_sublist (iterator->file->mdlp, iterator->domain, false);
1213
1257
      if (mlp != NULL)
1214
 
        for (j = 0; j < mlp->nitems; j++)
1215
 
          if (is_header (mlp->item[j]) && !mlp->item[j]->obsolete)
1216
 
            {
1217
 
              header = mlp->item[j];
1218
 
              break;
1219
 
            }
 
1258
        for (j = 0; j < mlp->nitems; j++)
 
1259
          if (is_header (mlp->item[j]) && !mlp->item[j]->obsolete)
 
1260
            {
 
1261
              header = mlp->item[j];
 
1262
              break;
 
1263
            }
1220
1264
    }
1221
1265
 
1222
1266
    {
1228
1272
      ml.use_hashtable = false;
1229
1273
 
1230
1274
      if (header != NULL)
1231
 
        message_list_append (&ml, header);
 
1275
        message_list_append (&ml, header);
1232
1276
      if (mp != header)
1233
 
        message_list_append (&ml, mp);
 
1277
        message_list_append (&ml, mp);
1234
1278
 
1235
1279
      check_message_list (&ml, 1, 1, 1, 0, 0, 0);
1236
1280
    }
1259
1303
    handler->xerror2;
1260
1304
 
1261
1305
  if (!mp->obsolete)
1262
 
    check_message (mp, &mp->pos, 0, 1, NULL, 0, 0, 0, 0, 0);
 
1306
    check_message (mp, &mp->pos, 0, 1, NULL, 0, 0, 0, 0);
1263
1307
 
1264
1308
  /* Restore error handler.  */
1265
1309
  po_xerror  = textmode_xerror;
1302
1346
  po_error = handler->error;
1303
1347
 
1304
1348
  check_msgid_msgstr_format (mp->msgid, mp->msgid_plural,
1305
 
                             mp->msgstr, mp->msgstr_len,
1306
 
                             mp->is_format, NULL, 0, po_error_logger);
 
1349
                             mp->msgstr, mp->msgstr_len,
 
1350
                             mp->is_format, mp->range, NULL, po_error_logger);
1307
1351
 
1308
1352
  /* Restore error handler.  */
1309
1353
  po_error = error;