/* Public API for GNU gettext PO files.
Copyright (C) 2003-2010, 2015 Free Software Foundation, Inc.
Written by Bruno Haible <bruno@clisp.org>, 2003.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
/* Specification. */
#include "gettext-po.h"
#include <limits.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include "message.h"
#include "xalloc.h"
#include "read-catalog.h"
#include "read-po.h"
#include "write-catalog.h"
#include "write-po.h"
#include "error.h"
#include "xerror.h"
#include "po-error.h"
#include "po-xerror.h"
#include "format.h"
#include "xvasprintf.h"
#include "msgl-check.h"
#include "gettext.h"
#define _(str) gettext(str)
struct po_file
{
msgdomain_list_ty *mdlp;
const char *real_filename;
const char *logical_filename;
const char **domains;
};
struct po_message_iterator
{
po_file_t file;
char *domain;
message_list_ty *mlp;
size_t index;
};
/* A po_message_t is actually a 'struct message_ty *'. */
/* A po_filepos_t is actually a 'lex_pos_ty *'. */
/* Version number: (major<<16) + (minor<<8) + subminor */
int libgettextpo_version = LIBGETTEXTPO_VERSION;
/* Create an empty PO file representation in memory. */
po_file_t
po_file_create (void)
{
po_file_t file;
file = XMALLOC (struct po_file);
file->mdlp = msgdomain_list_alloc (false);
file->real_filename = _("<unnamed>");
file->logical_filename = file->real_filename;
file->domains = NULL;
return file;
}
/* Read a PO file into memory.
Return its contents. Upon failure, return NULL and set errno. */
po_file_t
po_file_read (const char *filename, po_xerror_handler_t handler)
{
FILE *fp;
po_file_t file;
if (strcmp (filename, "-") == 0 || strcmp (filename, "/dev/stdin") == 0)
{
filename = _("<stdin>");
fp = stdin;
}
else
{
fp = fopen (filename, "r");
if (fp == NULL)
return NULL;
}
/* Establish error handler around read_catalog_stream(). */
po_xerror =
(void (*) (int, const message_ty *, const char *, size_t, size_t, int, const char *))
handler->xerror;
po_xerror2 =
(void (*) (int, const message_ty *, const char *, size_t, size_t, int, const char *, const message_ty *, const char *, size_t, size_t, int, const char *))
handler->xerror2;
gram_max_allowed_errors = UINT_MAX;
file = XMALLOC (struct po_file);
file->real_filename = filename;
file->logical_filename = filename;
file->mdlp = read_catalog_stream (fp, file->real_filename,
file->logical_filename, &input_format_po);
file->domains = NULL;
/* Restore error handler. */
po_xerror = textmode_xerror;
po_xerror2 = textmode_xerror2;
gram_max_allowed_errors = 20;
if (fp != stdin)
fclose (fp);
return file;
}
#undef po_file_read
#ifdef __cplusplus
extern "C" po_file_t po_file_read_v2 (const char *filename, po_error_handler_t handler);
#endif
po_file_t
po_file_read_v2 (const char *filename, po_error_handler_t handler)
{
FILE *fp;
po_file_t file;
if (strcmp (filename, "-") == 0 || strcmp (filename, "/dev/stdin") == 0)
{
filename = _("<stdin>");
fp = stdin;
}
else
{
fp = fopen (filename, "r");
if (fp == NULL)
return NULL;
}
/* Establish error handler around read_catalog_stream(). */
po_error = handler->error;
po_error_at_line = handler->error_at_line;
po_multiline_warning = handler->multiline_warning;
po_multiline_error = handler->multiline_error;
gram_max_allowed_errors = UINT_MAX;
file = XMALLOC (struct po_file);
file->real_filename = filename;
file->logical_filename = filename;
file->mdlp = read_catalog_stream (fp, file->real_filename,
file->logical_filename, &input_format_po);
file->domains = NULL;
/* Restore error handler. */
po_error = error;
po_error_at_line = error_at_line;
po_multiline_warning = multiline_warning;
po_multiline_error = multiline_error;
gram_max_allowed_errors = 20;
if (fp != stdin)
fclose (fp);
return file;
}
/* Older version for binary backward compatibility. */
#ifdef __cplusplus
extern "C" po_file_t po_file_read (const char *filename);
#endif
po_file_t
po_file_read (const char *filename)
{
FILE *fp;
po_file_t file;
if (strcmp (filename, "-") == 0 || strcmp (filename, "/dev/stdin") == 0)
{
filename = _("<stdin>");
fp = stdin;
}
else
{
fp = fopen (filename, "r");
if (fp == NULL)
return NULL;
}
file = XMALLOC (struct po_file);
file->real_filename = filename;
file->logical_filename = filename;
file->mdlp = read_catalog_stream (fp, file->real_filename,
file->logical_filename, &input_format_po);
file->domains = NULL;
if (fp != stdin)
fclose (fp);
return file;
}
/* Write an in-memory PO file to a file.
Upon failure, return NULL and set errno. */
po_file_t
po_file_write (po_file_t file, const char *filename, po_xerror_handler_t handler)
{
/* Establish error handler around msgdomain_list_print(). */
po_xerror =
(void (*) (int, const message_ty *, const char *, size_t, size_t, int, const char *))
handler->xerror;
po_xerror2 =
(void (*) (int, const message_ty *, const char *, size_t, size_t, int, const char *, const message_ty *, const char *, size_t, size_t, int, const char *))
handler->xerror2;
msgdomain_list_print (file->mdlp, filename, &output_format_po, true, false);
/* Restore error handler. */
po_xerror = textmode_xerror;
po_xerror2 = textmode_xerror2;
return file;
}
#undef po_file_write
/* Older version for binary backward compatibility. */
#ifdef __cplusplus
extern "C" po_file_t po_file_write (po_file_t file, const char *filename, po_error_handler_t handler);
#endif
po_file_t
po_file_write (po_file_t file, const char *filename, po_error_handler_t handler)
{
/* Establish error handler around msgdomain_list_print(). */
po_error = handler->error;
po_error_at_line = handler->error_at_line;
po_multiline_warning = handler->multiline_warning;
po_multiline_error = handler->multiline_error;
msgdomain_list_print (file->mdlp, filename, &output_format_po, true, false);
/* Restore error handler. */
po_error = error;
po_error_at_line = error_at_line;
po_multiline_warning = multiline_warning;
po_multiline_error = multiline_error;
return file;
}
/* Free a PO file from memory. */
void
po_file_free (po_file_t file)
{
msgdomain_list_free (file->mdlp);
if (file->domains != NULL)
free (file->domains);
free (file);
}
/* Return the names of the domains covered by a PO file in memory. */
const char * const *
po_file_domains (po_file_t file)
{
if (file->domains == NULL)
{
size_t n = file->mdlp->nitems;
const char **domains = XNMALLOC (n + 1, const char *);
size_t j;
for (j = 0; j < n; j++)
domains[j] = file->mdlp->item[j]->domain;
domains[n] = NULL;
file->domains = domains;
}
return file->domains;
}
/* Return the header entry of a domain of a PO file in memory.
The domain NULL denotes the default domain.
Return NULL if there is no header entry. */
const char *
po_file_domain_header (po_file_t file, const char *domain)
{
message_list_ty *mlp;
size_t j;
if (domain == NULL)
domain = MESSAGE_DOMAIN_DEFAULT;
mlp = msgdomain_list_sublist (file->mdlp, domain, false);
if (mlp != NULL)
for (j = 0; j < mlp->nitems; j++)
if (is_header (mlp->item[j]) && !mlp->item[j]->obsolete)
{
const char *header = mlp->item[j]->msgstr;
if (header != NULL)
return xstrdup (header);
else
return NULL;
}
return NULL;
}
/* Return the value of a field in a header entry.
The return value is either a freshly allocated string, to be freed by the
caller, or NULL. */
char *
po_header_field (const char *header, const char *field)
{
size_t field_len = strlen (field);
const char *line;
for (line = header;;)
{
if (strncmp (line, field, field_len) == 0 && line[field_len] == ':')
{
const char *value_start;
const char *value_end;
char *value;
value_start = line + field_len + 1;
if (*value_start == ' ')
value_start++;
value_end = strchr (value_start, '\n');
if (value_end == NULL)
value_end = value_start + strlen (value_start);
value = XNMALLOC (value_end - value_start + 1, char);
memcpy (value, value_start, value_end - value_start);
value[value_end - value_start] = '\0';
return value;
}
line = strchr (line, '\n');
if (line != NULL)
line++;
else
break;
}
return NULL;
}
/* Return the header entry with a given field set to a given value. The field
is added if necessary.
The return value is a freshly allocated string. */
char *
po_header_set_field (const char *header, const char *field, const char *value)
{
size_t header_len = strlen (header);
size_t field_len = strlen (field);
size_t value_len = strlen (value);
{
const char *line;
for (line = header;;)
{
if (strncmp (line, field, field_len) == 0 && line[field_len] == ':')
{
const char *oldvalue_start;
const char *oldvalue_end;
size_t header_part1_len;
size_t header_part3_len;
size_t result_len;
char *result;
oldvalue_start = line + field_len + 1;
if (*oldvalue_start == ' ')
oldvalue_start++;
oldvalue_end = strchr (oldvalue_start, '\n');
if (oldvalue_end == NULL)
oldvalue_end = oldvalue_start + strlen (oldvalue_start);
header_part1_len = oldvalue_start - header;
header_part3_len = header + header_len - oldvalue_end;
result_len = header_part1_len + value_len + header_part3_len;
/* = header_len - oldvalue_len + value_len */
result = XNMALLOC (result_len + 1, char);
memcpy (result, header, header_part1_len);
memcpy (result + header_part1_len, value, value_len);
memcpy (result + header_part1_len + value_len, oldvalue_end,
header_part3_len);
*(result + result_len) = '\0';
return result;
}
line = strchr (line, '\n');
if (line != NULL)
line++;
else
break;
}
}
{
size_t newline;
size_t result_len;
char *result;
newline = (header_len > 0 && header[header_len - 1] != '\n' ? 1 : 0);
result_len = header_len + newline + field_len + 2 + value_len + 1;
result = XNMALLOC (result_len + 1, char);
memcpy (result, header, header_len);
if (newline)
*(result + header_len) = '\n';
memcpy (result + header_len + newline, field, field_len);
*(result + header_len + newline + field_len) = ':';
*(result + header_len + newline + field_len + 1) = ' ';
memcpy (result + header_len + newline + field_len + 2, value, value_len);
*(result + header_len + newline + field_len + 2 + value_len) = '\n';
*(result + result_len) = '\0';
return result;
}
}
/* Create an iterator for traversing a domain of a PO file in memory.
The domain NULL denotes the default domain. */
po_message_iterator_t
po_message_iterator (po_file_t file, const char *domain)
{
po_message_iterator_t iterator;
if (domain == NULL)
domain = MESSAGE_DOMAIN_DEFAULT;
iterator = XMALLOC (struct po_message_iterator);
iterator->file = file;
iterator->domain = xstrdup (domain);
iterator->mlp = msgdomain_list_sublist (file->mdlp, domain, false);
iterator->index = 0;
return iterator;
}
/* Free an iterator. */
void
po_message_iterator_free (po_message_iterator_t iterator)
{
free (iterator->domain);
free (iterator);
}
/* Return the next message, and advance the iterator.
Return NULL at the end of the message list. */
po_message_t
po_next_message (po_message_iterator_t iterator)
{
if (iterator->mlp != NULL && iterator->index < iterator->mlp->nitems)
return (po_message_t) iterator->mlp->item[iterator->index++];
else
return NULL;
}
/* Insert a message in a PO file in memory, in the domain and at the position
indicated by the iterator. The iterator thereby advances past the freshly
inserted message. */
void
po_message_insert (po_message_iterator_t iterator, po_message_t message)
{
message_ty *mp = (message_ty *) message;
if (iterator->mlp == NULL)
/* Now we need to allocate a sublist corresponding to the iterator. */
iterator->mlp =
msgdomain_list_sublist (iterator->file->mdlp, iterator->domain, true);
/* Insert the message. */
message_list_insert_at (iterator->mlp, iterator->index, mp);
/* Advance the iterator. */
iterator->index++;
}
/* Return a freshly constructed message.
To finish initializing the message, you must set the msgid and msgstr. */
po_message_t
po_message_create (void)
{
lex_pos_ty pos = { NULL, 0 };
return (po_message_t) message_alloc (NULL, NULL, NULL, xstrdup (""), 1, &pos);
}
/* Return the context of a message, or NULL for a message not restricted to a
context. */
const char *
po_message_msgctxt (po_message_t message)
{
message_ty *mp = (message_ty *) message;
return mp->msgctxt;
}
/* Change the context of a message. NULL means a message not restricted to a
context. */
void
po_message_set_msgctxt (po_message_t message, const char *msgctxt)
{
message_ty *mp = (message_ty *) message;
if (msgctxt != mp->msgctxt)
{
char *old_msgctxt = (char *) mp->msgctxt;
mp->msgctxt = (msgctxt != NULL ? xstrdup (msgctxt) : NULL);
if (old_msgctxt != NULL)
free (old_msgctxt);
}
}
/* Return the msgid (untranslated English string) of a message. */
const char *
po_message_msgid (po_message_t message)
{
message_ty *mp = (message_ty *) message;
return mp->msgid;
}
/* Change the msgid (untranslated English string) of a message. */
void
po_message_set_msgid (po_message_t message, const char *msgid)
{
message_ty *mp = (message_ty *) message;
if (msgid != mp->msgid)
{
char *old_msgid = (char *) mp->msgid;
mp->msgid = xstrdup (msgid);
if (old_msgid != NULL)
free (old_msgid);
}
}
/* Return the msgid_plural (untranslated English plural string) of a message,
or NULL for a message without plural. */
const char *
po_message_msgid_plural (po_message_t message)
{
message_ty *mp = (message_ty *) message;
return mp->msgid_plural;
}
/* Change the msgid_plural (untranslated English plural string) of a message.
NULL means a message without plural. */
void
po_message_set_msgid_plural (po_message_t message, const char *msgid_plural)
{
message_ty *mp = (message_ty *) message;
if (msgid_plural != mp->msgid_plural)
{
char *old_msgid_plural = (char *) mp->msgid_plural;
mp->msgid_plural = (msgid_plural != NULL ? xstrdup (msgid_plural) : NULL);
if (old_msgid_plural != NULL)
free (old_msgid_plural);
}
}
/* Return the msgstr (translation) of a message.
Return the empty string for an untranslated message. */
const char *
po_message_msgstr (po_message_t message)
{
message_ty *mp = (message_ty *) message;
return mp->msgstr;
}
/* Change the msgstr (translation) of a message.
Use an empty string to denote an untranslated message. */
void
po_message_set_msgstr (po_message_t message, const char *msgstr)
{
message_ty *mp = (message_ty *) message;
if (msgstr != mp->msgstr)
{
char *old_msgstr = (char *) mp->msgstr;
mp->msgstr = xstrdup (msgstr);
mp->msgstr_len = strlen (mp->msgstr) + 1;
if (old_msgstr != NULL)
free (old_msgstr);
}
}
/* Return the msgstr[index] for a message with plural handling, or
NULL when the index is out of range or for a message without plural. */
const char *
po_message_msgstr_plural (po_message_t message, int index)
{
message_ty *mp = (message_ty *) message;
if (mp->msgid_plural != NULL && index >= 0)
{
const char *p;
const char *p_end = mp->msgstr + mp->msgstr_len;
for (p = mp->msgstr; ; p += strlen (p) + 1, index--)
{
if (p >= p_end)
return NULL;
if (index == 0)
break;
}
return p;
}
else
return NULL;
}
/* Change the msgstr[index] for a message with plural handling.
Use a NULL value at the end to reduce the number of plural forms. */
void
po_message_set_msgstr_plural (po_message_t message, int index, const char *msgstr)
{
message_ty *mp = (message_ty *) message;
if (mp->msgid_plural != NULL && index >= 0)
{
char *p = (char *) mp->msgstr;
char *p_end = (char *) mp->msgstr + mp->msgstr_len;
char *copied_msgstr;
/* Special care must be taken of the case that msgstr points into the
mp->msgstr string list, because mp->msgstr may be relocated before we
are done with msgstr. */
if (msgstr >= p && msgstr < p_end)
msgstr = copied_msgstr = xstrdup (msgstr);
else
copied_msgstr = NULL;
for (; ; p += strlen (p) + 1, index--)
{
if (p >= p_end)
{
/* Append at the end. */
if (msgstr != NULL)
{
size_t new_msgstr_len = mp->msgstr_len + index + strlen (msgstr) + 1;
mp->msgstr =
(char *) xrealloc ((char *) mp->msgstr, new_msgstr_len);
p = (char *) mp->msgstr + mp->msgstr_len;
for (; index > 0; index--)
*p++ = '\0';
memcpy (p, msgstr, strlen (msgstr) + 1);
mp->msgstr_len = new_msgstr_len;
}
if (copied_msgstr != NULL)
free (copied_msgstr);
return;
}
if (index == 0)
break;
}
if (msgstr == NULL)
{
if (p + strlen (p) + 1 >= p_end)
{
/* Remove the string that starts at p. */
mp->msgstr_len = p - mp->msgstr;
return;
}
/* It is not possible to remove an element of the string list
except the last one. So just replace it with the empty string.
That's the best we can do here. */
msgstr = "";
}
{
/* Replace the string that starts at p. */
size_t i1 = p - mp->msgstr;
size_t i2before = i1 + strlen (p);
size_t i2after = i1 + strlen (msgstr);
size_t new_msgstr_len = mp->msgstr_len - i2before + i2after;
if (i2after > i2before)
mp->msgstr = (char *) xrealloc ((char *) mp->msgstr, new_msgstr_len);
memmove ((char *) mp->msgstr + i2after, mp->msgstr + i2before,
mp->msgstr_len - i2before);
memcpy ((char *) mp->msgstr + i1, msgstr, i2after - i1);
mp->msgstr_len = new_msgstr_len;
}
if (copied_msgstr != NULL)
free (copied_msgstr);
}
}
/* Return the comments for a message. */
const char *
po_message_comments (po_message_t message)
{
/* FIXME: memory leak. */
message_ty *mp = (message_ty *) message;
if (mp->comment == NULL || mp->comment->nitems == 0)
return "";
else
return string_list_join (mp->comment, "\n", '\n', true);
}
/* Change the comments for a message.
comments should be a multiline string, ending in a newline, or empty. */
void
po_message_set_comments (po_message_t message, const char *comments)
{
message_ty *mp = (message_ty *) message;
string_list_ty *slp = string_list_alloc ();
{
char *copy = xstrdup (comments);
char *rest;
rest = copy;
while (*rest != '\0')
{
char *newline = strchr (rest, '\n');
if (newline != NULL)
{
*newline = '\0';
string_list_append (slp, rest);
rest = newline + 1;
}
else
{
string_list_append (slp, rest);
break;
}
}
free (copy);
}
if (mp->comment != NULL)
string_list_free (mp->comment);
mp->comment = slp;
}
/* Return the extracted comments for a message. */
const char *
po_message_extracted_comments (po_message_t message)
{
/* FIXME: memory leak. */
message_ty *mp = (message_ty *) message;
if (mp->comment_dot == NULL || mp->comment_dot->nitems == 0)
return "";
else
return string_list_join (mp->comment_dot, "\n", '\n', true);
}
/* Change the extracted comments for a message.
comments should be a multiline string, ending in a newline, or empty. */
void
po_message_set_extracted_comments (po_message_t message, const char *comments)
{
message_ty *mp = (message_ty *) message;
string_list_ty *slp = string_list_alloc ();
{
char *copy = xstrdup (comments);
char *rest;
rest = copy;
while (*rest != '\0')
{
char *newline = strchr (rest, '\n');
if (newline != NULL)
{
*newline = '\0';
string_list_append (slp, rest);
rest = newline + 1;
}
else
{
string_list_append (slp, rest);
break;
}
}
free (copy);
}
if (mp->comment_dot != NULL)
string_list_free (mp->comment_dot);
mp->comment_dot = slp;
}
/* Return the i-th file position for a message, or NULL if i is out of
range. */
po_filepos_t
po_message_filepos (po_message_t message, int i)
{
message_ty *mp = (message_ty *) message;
if (i >= 0 && (size_t)i < mp->filepos_count)
return (po_filepos_t) &mp->filepos[i];
else
return NULL;
}
/* Remove the i-th file position from a message.
The indices of all following file positions for the message are decremented
by one. */
void
po_message_remove_filepos (po_message_t message, int i)
{
message_ty *mp = (message_ty *) message;
if (i >= 0)
{
size_t j = (size_t)i;
size_t n = mp->filepos_count;
if (j < n)
{
mp->filepos_count = n = n - 1;
free ((char *) mp->filepos[j].file_name);
for (; j < n; j++)
mp->filepos[j] = mp->filepos[j + 1];
}
}
}
/* Add a file position to a message, if it is not already present for the
message.
file is the file name.
start_line is the line number where the string starts, or (size_t)(-1) if no
line number is available. */
void
po_message_add_filepos (po_message_t message, const char *file, size_t start_line)
{
message_ty *mp = (message_ty *) message;
message_comment_filepos (mp, file, start_line);
}
/* Return the previous context of a message, or NULL for none. */
const char *
po_message_prev_msgctxt (po_message_t message)
{
message_ty *mp = (message_ty *) message;
return mp->prev_msgctxt;
}
/* Change the previous context of a message. NULL is allowed. */
void
po_message_set_prev_msgctxt (po_message_t message, const char *prev_msgctxt)
{
message_ty *mp = (message_ty *) message;
if (prev_msgctxt != mp->prev_msgctxt)
{
char *old_prev_msgctxt = (char *) mp->prev_msgctxt;
mp->prev_msgctxt = (prev_msgctxt != NULL ? xstrdup (prev_msgctxt) : NULL);
if (old_prev_msgctxt != NULL)
free (old_prev_msgctxt);
}
}
/* Return the previous msgid (untranslated English string) of a message, or
NULL for none. */
const char *
po_message_prev_msgid (po_message_t message)
{
message_ty *mp = (message_ty *) message;
return mp->prev_msgid;
}
/* Change the previous msgid (untranslated English string) of a message.
NULL is allowed. */
void
po_message_set_prev_msgid (po_message_t message, const char *prev_msgid)
{
message_ty *mp = (message_ty *) message;
if (prev_msgid != mp->prev_msgid)
{
char *old_prev_msgid = (char *) mp->prev_msgid;
mp->prev_msgid = (prev_msgid != NULL ? xstrdup (prev_msgid) : NULL);
if (old_prev_msgid != NULL)
free (old_prev_msgid);
}
}
/* Return the previous msgid_plural (untranslated English plural string) of a
message, or NULL for none. */
const char *
po_message_prev_msgid_plural (po_message_t message)
{
message_ty *mp = (message_ty *) message;
return mp->prev_msgid_plural;
}
/* Change the previous msgid_plural (untranslated English plural string) of a
message. NULL is allowed. */
void
po_message_set_prev_msgid_plural (po_message_t message, const char *prev_msgid_plural)
{
message_ty *mp = (message_ty *) message;
if (prev_msgid_plural != mp->prev_msgid_plural)
{
char *old_prev_msgid_plural = (char *) mp->prev_msgid_plural;
mp->prev_msgid_plural =
(prev_msgid_plural != NULL ? xstrdup (prev_msgid_plural) : NULL);
if (old_prev_msgid_plural != NULL)
free (old_prev_msgid_plural);
}
}
/* Return true if the message is marked obsolete. */
int
po_message_is_obsolete (po_message_t message)
{
message_ty *mp = (message_ty *) message;
return (mp->obsolete ? 1 : 0);
}
/* Change the obsolete mark of a message. */
void
po_message_set_obsolete (po_message_t message, int obsolete)
{
message_ty *mp = (message_ty *) message;
mp->obsolete = obsolete;
}
/* Return true if the message is marked fuzzy. */
int
po_message_is_fuzzy (po_message_t message)
{
message_ty *mp = (message_ty *) message;
return (mp->is_fuzzy ? 1 : 0);
}
/* Change the fuzzy mark of a message. */
void
po_message_set_fuzzy (po_message_t message, int fuzzy)
{
message_ty *mp = (message_ty *) message;
mp->is_fuzzy = fuzzy;
}
/* Return true if the message is marked as being a format string of the given
type (e.g. "c-format"). */
int
po_message_is_format (po_message_t message, const char *format_type)
{
message_ty *mp = (message_ty *) message;
size_t len = strlen (format_type);
size_t i;
if (len >= 7 && memcmp (format_type + len - 7, "-format", 7) == 0)
for (i = 0; i < NFORMATS; i++)
if (strlen (format_language[i]) == len - 7
&& memcmp (format_language[i], format_type, len - 7) == 0)
/* The given format_type corresponds to (enum format_type) i. */
return (possible_format_p (mp->is_format[i]) ? 1 : 0);
return 0;
}
/* Change the format string mark for a given type of a message. */
void
po_message_set_format (po_message_t message, const char *format_type, /*bool*/int value)
{
message_ty *mp = (message_ty *) message;
size_t len = strlen (format_type);
size_t i;
if (len >= 7 && memcmp (format_type + len - 7, "-format", 7) == 0)
for (i = 0; i < NFORMATS; i++)
if (strlen (format_language[i]) == len - 7
&& memcmp (format_language[i], format_type, len - 7) == 0)
/* The given format_type corresponds to (enum format_type) i. */
mp->is_format[i] = (value ? yes : no);
}
/* If a numeric range of a message is set, return true and store the minimum
and maximum value in *MINP and *MAXP. */
int
po_message_is_range (po_message_t message, int *minp, int *maxp)
{
message_ty *mp = (message_ty *) message;
if (has_range_p (mp->range))
{
*minp = mp->range.min;
*maxp = mp->range.max;
return 1;
}
else
return 0;
}
/* Change the numeric range of a message. MIN and MAX must be non-negative,
with MIN < MAX. Use MIN = MAX = -1 to remove the numeric range of a
message. */
void
po_message_set_range (po_message_t message, int min, int max)
{
message_ty *mp = (message_ty *) message;
if (min >= 0 && max >= min)
{
mp->range.min = min;
mp->range.max = max;
}
else if (min < 0 && max < 0)
{
mp->range.min = -1;
mp->range.max = -1;
}
/* Other values of min and max are invalid. */
}
/* Return the file name. */
const char *
po_filepos_file (po_filepos_t filepos)
{
lex_pos_ty *pp = (lex_pos_ty *) filepos;
return pp->file_name;
}
/* Return the line number where the string starts, or (size_t)(-1) if no line
number is available. */
size_t
po_filepos_start_line (po_filepos_t filepos)
{
lex_pos_ty *pp = (lex_pos_ty *) filepos;
return pp->line_number;
}
/* Return a NULL terminated array of the supported format types. */
const char * const *
po_format_list (void)
{
static const char * const * whole_list /* = NULL */;
if (whole_list == NULL)
{
const char **list = XNMALLOC (NFORMATS + 1, const char *);
size_t i;
for (i = 0; i < NFORMATS; i++)
list[i] = xasprintf ("%s-format", format_language[i]);
list[i] = NULL;
whole_list = list;
}
return whole_list;
}
/* Return the pretty name associated with a format type.
For example, for "csharp-format", return "C#".
Return NULL if the argument is not a supported format type. */
const char *
po_format_pretty_name (const char *format_type)
{
size_t len = strlen (format_type);
size_t i;
if (len >= 7 && memcmp (format_type + len - 7, "-format", 7) == 0)
for (i = 0; i < NFORMATS; i++)
if (strlen (format_language[i]) == len - 7
&& memcmp (format_language[i], format_type, len - 7) == 0)
/* The given format_type corresponds to (enum format_type) i. */
return format_language_pretty[i];
return NULL;
}
/* Test whether an entire file PO file is valid, like msgfmt does it.
If it is invalid, pass the reasons to the handler. */
void
po_file_check_all (po_file_t file, po_xerror_handler_t handler)
{
msgdomain_list_ty *mdlp;
size_t k;
/* Establish error handler. */
po_xerror =
(void (*) (int, const message_ty *, const char *, size_t, size_t, int, const char *))
handler->xerror;
po_xerror2 =
(void (*) (int, const message_ty *, const char *, size_t, size_t, int, const char *, const message_ty *, const char *, size_t, size_t, int, const char *))
handler->xerror2;
mdlp = file->mdlp;
for (k = 0; k < mdlp->nitems; k++)
check_message_list (mdlp->item[k]->messages, 1, 1, 1, 1, 1, 0, 0, 0);
/* Restore error handler. */
po_xerror = textmode_xerror;
po_xerror2 = textmode_xerror2;
}
/* Test a single message, to be inserted in a PO file in memory, like msgfmt
does it. If it is invalid, pass the reasons to the handler. The iterator
is not modified by this call; it only specifies the file and the domain. */
void
po_message_check_all (po_message_t message, po_message_iterator_t iterator,
po_xerror_handler_t handler)
{
message_ty *mp = (message_ty *) message;
/* Establish error handler. */
po_xerror =
(void (*) (int, const message_ty *, const char *, size_t, size_t, int, const char *))
handler->xerror;
po_xerror2 =
(void (*) (int, const message_ty *, const char *, size_t, size_t, int, const char *, const message_ty *, const char *, size_t, size_t, int, const char *))
handler->xerror2;
/* For plural checking, combine the message and its header into a small,
two-element message list. */
{
message_ty *header;
/* Find the header. */
{
message_list_ty *mlp;
size_t j;
header = NULL;
mlp =
msgdomain_list_sublist (iterator->file->mdlp, iterator->domain, false);
if (mlp != NULL)
for (j = 0; j < mlp->nitems; j++)
if (is_header (mlp->item[j]) && !mlp->item[j]->obsolete)
{
header = mlp->item[j];
break;
}
}
{
message_ty *items[2];
struct message_list_ty ml;
ml.item = items;
ml.nitems = 0;
ml.nitems_max = 2;
ml.use_hashtable = false;
if (header != NULL)
message_list_append (&ml, header);
if (mp != header)
message_list_append (&ml, mp);
check_message_list (&ml, 1, 1, 1, 1, 1, 0, 0, 0);
}
}
/* Restore error handler. */
po_xerror = textmode_xerror;
po_xerror2 = textmode_xerror2;
}
/* Test whether the message translation is a valid format string if the message
is marked as being a format string. If it is invalid, pass the reasons to
the handler. */
void
po_message_check_format (po_message_t message, po_xerror_handler_t handler)
{
message_ty *mp = (message_ty *) message;
/* Establish error handler. */
po_xerror =
(void (*) (int, const message_ty *, const char *, size_t, size_t, int, const char *))
handler->xerror;
po_xerror2 =
(void (*) (int, const message_ty *, const char *, size_t, size_t, int, const char *, const message_ty *, const char *, size_t, size_t, int, const char *))
handler->xerror2;
if (!mp->obsolete)
check_message (mp, &mp->pos, 0, 1, NULL, 0, 0, 0, 0);
/* Restore error handler. */
po_xerror = textmode_xerror;
po_xerror2 = textmode_xerror2;
}
#undef po_message_check_format
/* Older version for binary backward compatibility. */
/* An error logger based on the po_error function pointer. */
static void
po_error_logger (const char *format, ...)
__attribute__ ((__format__ (__printf__, 1, 2)));
static void
po_error_logger (const char *format, ...)
{
va_list args;
char *error_message;
va_start (args, format);
if (vasprintf (&error_message, format, args) < 0)
error (EXIT_FAILURE, 0, _("memory exhausted"));
va_end (args);
po_error (0, 0, "%s", error_message);
free (error_message);
}
/* Test whether the message translation is a valid format string if the message
is marked as being a format string. If it is invalid, pass the reasons to
the handler. */
#ifdef __cplusplus
extern "C" void po_message_check_format (po_message_t message, po_error_handler_t handler);
#endif
void
po_message_check_format (po_message_t message, po_error_handler_t handler)
{
message_ty *mp = (message_ty *) message;
/* Establish error handler for po_error_logger(). */
po_error = handler->error;
check_msgid_msgstr_format (mp->msgid, mp->msgid_plural,
mp->msgstr, mp->msgstr_len,
mp->is_format, mp->range, NULL, po_error_logger);
/* Restore error handler. */
po_error = error;
}