poe

po.c (40954B)

---

 /* This program is licensed under the terms of GNU GPL v3 or (at your option)
  * any later version. Copyright (C) 2021-2026  Страхиња Радић.
  * See the file LICENSE for exact copyright and license details. */
 
 #include <assert.h>
 #include <libgen.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
 #include <time.h>
 
 #include "draw.h"
 #include "config.h"
 #include "limit.h"
 #include "po.h"
 #include "strtonum.h"
 #include "util.h"
 #include "version.h"
 
 #define INC_COL()                   \
 	do                          \
 	{                           \
 		if (!dstate->error) \
 			(*col)++;   \
 	} while (0)
 
 extern const char* errors[];
 extern const char* flag_strings[];
 
 extern int cp(const char* from, const char* to);
 extern int print_error(const int code, const char* msg, ...);
 extern int redraw_status(struct DrawState* state);
 
 const uint32_t empty_string[] = {0};
 
 int
 add_ref_comment(struct PoEntry* entry, const char* comment)
 {
 	char** ref_comments = NULL;
 	char* new_line	    = NULL;
 	size_t len	    = 0;
 
 	assert((entry != NULL) && (comment != NULL));
 
 	entry->ref_comment_lines++;
 
 	if (!entry->ref_comments)
 		ref_comments = calloc(entry->ref_comment_lines, sizeof(char*));
 	else
 		ref_comments = realloc(entry->ref_comments,
 			entry->ref_comment_lines * sizeof(char*));
 	if (!ref_comments)
 		return 1;
 	entry->ref_comments = ref_comments;
 
 	len	 = strlen(comment) + 1;
 	new_line = calloc(len, 1);
 	if (!new_line)
 		return 1;
 	entry->ref_comments[entry->ref_comment_lines - 1] = new_line;
 	strncpy(new_line, comment, len);
 	return 0;
 }
 
 char*
 format_flags(char* buffer, const size_t max, const struct PoEntry* entry,
 	const int draw_box)
 {
 	snprintf(buffer, max, "%s%c%c%c%c%s", draw_box ? "[ " : "",
 		entry->flags & FL_C_FORMAT ? 'C' : ' ',
 		entry->flags & FL_FUZZY ? 'F' : ' ',
 		entry->msgstr_count > 1 ? 'P' : ' ',
 		entry->flags & FL_NO_C_FORMAT ? 'N' : ' ',
 		draw_box ? " ]" : "");
 	return buffer;
 }
 
 void
 free_po_entry(struct PoEntry* entry)
 {
 	if (!entry)
 		return;
 
 	free(entry->msgid);
 	if (entry->msgstr)
 	{
 		uint32_t** msgstr = entry->msgstr;
 		while (msgstr < entry->msgstr + entry->msgstr_count)
 			free(*msgstr++);
 		free(entry->msgstr);
 	}
 	free(entry->msgstr_size);
 	free(entry->msgstr_len);
 	free(entry->msgid_plural);
 	free(entry->plural_forms);
 
 	if (entry->comments)
 	{
 		uint32_t** comment = entry->comments;
 		while (comment < entry->comments + entry->comment_lines)
 			free(*comment++);
 		free(entry->comments);
 	}
 
 	if (entry->extr_comments)
 	{
 		uint32_t** extr_comment = entry->extr_comments;
 		while (extr_comment
 			< entry->extr_comments + entry->extr_comment_lines)
 			free(*extr_comment++);
 		free(entry->extr_comments);
 	}
 
 	if (entry->ref_comments)
 	{
 		char** comment = entry->ref_comments;
 		while (comment < entry->ref_comments + entry->ref_comment_lines)
 			free(*comment++);
 		free(entry->ref_comments);
 	}
 }
 
 void
 init_po_entry(struct PoEntry* entry)
 {
 	entry->flags		  = FL_NONE;
 	entry->obsolete		  = 0;
 	entry->warning		  = 0;
 	entry->msgid		  = NULL;
 	entry->msgid_size	  = 0;
 	entry->msgid_len	  = 0;
 	entry->msgid_plural	  = NULL;
 	entry->msgid_plural_size  = 0;
 	entry->msgid_plural_len	  = 0;
 	entry->plural_forms	  = NULL;
 	entry->plural_forms_size  = 0;
 	entry->plural_forms_len	  = 0;
 	entry->msgstr		  = NULL;
 	entry->msgstr_count	  = 0;
 	entry->msgstr_size	  = NULL;
 	entry->msgstr_len	  = NULL;
 	entry->comments		  = NULL;
 	entry->comment_lines	  = 0;
 	entry->extr_comments	  = NULL;
 	entry->extr_comment_lines = 0;
 	entry->ref_comments	  = NULL;
 	entry->ref_comment_lines  = 0;
 }
 
 int
 load_file(struct DrawState* dstate, long* lineno, long* col)
 {
 	struct PoEntry* newchunk = NULL;
 	struct PoEntry* entry	 = NULL;
 	struct PoEntry* current	 = NULL;
 	FILE* input		 = NULL;
 	char* input_line	 = NULL;
 	ParseState pstate	 = PS_NONE;
 	int has_plural_msgid	 = 0;
 	ssize_t input_size;
 	ssize_t non_obsolete_sofar = 0;
 	/* lines to tolerate the lack of msgid */
 	int msgid_counter = PO_DETECTION_LINES;
 	int msgstr_index  = -1;
 	int possible_nulbyte;
 
 	assert((dstate != NULL) && (limits != NULL));
 	input_size = limits[L_LINE_MAX];
 	input_line = malloc(input_size);
 	if (!input_line)
 		goto load_file_alloc_error;
 	dstate->msgid_size = 0;
 	newchunk	   = calloc(ALLOC_DELTA, sizeof(struct PoEntry));
 	if (!newchunk)
 		goto load_file_alloc_error;
 
 	dstate->msgid_count = 0;
 	dstate->msgid_size  = ALLOC_DELTA;
 	dstate->entries	    = newchunk;
 	entry		    = dstate->entries;
 	dstate->untranslated_count++;
 
 	if (!(input = fopen(dstate->filename, "rt")))
 		return 1;
 
 	dstate->action = ACT_READING;
 	if (redraw_status(dstate))
 		return 1;
 
 	possible_nulbyte = 0;
 	*lineno		 = 1;
 	while (!feof(input))
 	{
 		char* eol     = NULL;
 		char* nulbyte = NULL;
 
 		if (!fgets(input_line, input_size, input))
 		{
 			if (ferror(input))
 			{
 				fclose(input);
 				return 1;
 			}
 			else
 				continue;
 		}
 
 		if (possible_nulbyte)
 		{
 			/* Definitely not EOF, NUL byte confirmed */
 			dstate->error = ERR_NOTPO_FILE;
 			fclose(input);
 			free(input_line);
 			return 1;
 		}
 		eol = strchr(input_line, '\n');
 		if (eol)
 			*eol = 0;
 		nulbyte = strchr(input_line, 0);
 
 		/* We don't know if the NUL byte not being equal to
 		 * (possibly NULL) eol is the result of EOF or not
 		 */
 		if (nulbyte && (nulbyte != eol))
 			possible_nulbyte = 1;
 
 		if (parse_po_line(input_line, dstate, &entry, &pstate, col,
 			    &msgstr_index))
 		{
 			if (possible_nulbyte && dstate->error == ERR_SYNTAX)
 				dstate->error = ERR_NOTPO_FILE;
 			goto load_file_cleanup;
 		}
 
 		if (entry && entry->msgid_plural)
 			has_plural_msgid = 1;
 
 		switch (dstate->error)
 		{
 		case ERR_NONE:
 			if (pstate & PS_MSGID)
 				msgid_counter = -1;
 			else if (msgid_counter != -1)
 				msgid_counter--;
 			if (msgid_counter == 0)
 			{
 				dstate->error = ERR_NOTPO_FILE;
 				return 1;
 			}
 			break;
 		case ERR_SYNTAX:
 			/* Allow for ERR_NOTPO_FILE to override ERR_SYNTAX */
 			break;
 		default:
 			goto load_file_alloc_error;
 		}
 		if (!dstate->error)
 			(*lineno)++;
 	}
 
 	/* when the .po file is not a standard text file (no LF at end) */
 	if (dstate->msgid_count > 1)
 	{
 		if (entry)
 		{
 			if (entry->msgid)
 				/* regular entry */
 				dstate->msgid_count++;
 			else if (entry->comment_lines > 0)
 				/* obsolete entry */
 				entry->obsolete = 1;
 		}
 		if (has_plural_msgid && !dstate->entries->plural_forms)
 		{
 			dstate->error = ERR_NO_PLURAL_FORMS;
 			goto load_file_cleanup;
 		}
 	}
 
 	/* file has < PO_DETECTION_LINES */
 	if (msgid_counter > 0)
 	{
 		dstate->error = ERR_NOTPO_FILE;
 		goto load_file_cleanup;
 	}
 
 	dstate->first_shown_msgid = dstate->msgid_count > 0 ? 1 : 0;
 	update_statistics(dstate->entries, dstate, entry);
 	dstate->real_msgid_count = dstate->msgid_count + dstate->obsolete_count;
 
 	current			      = dstate->entries;
 	dstate->obsolete_at_end_count = 0;
 	non_obsolete_sofar	      = 0;
 	while (current != dstate->entries + dstate->real_msgid_count)
 	{
 		if (!current->obsolete)
 			non_obsolete_sofar++;
 		else if (non_obsolete_sofar == dstate->msgid_count)
 			dstate->obsolete_at_end_count++;
 		if (!current->obsolete && current->msgid && current->msgstr)
 			update_warning(current->msgid, *current->msgstr,
 				&current->warning);
 		current++;
 	}
 
 load_file_cleanup:
 	if (dstate->error == ERR_CANT_ALLOC)
 		goto load_file_alloc_error;
 	fclose(input);
 	dstate->action = ACT_IDLE;
 	free(input_line);
 	return dstate->error != ERR_NONE;
 
 load_file_alloc_error:
 	return 1;
 }
 
 int
 parse_po_line(const char* line, struct DrawState* dstate,
 	struct PoEntry** current_entry, ParseState* pstate, long* col,
 	int* msgstr_index)
 {
 	char* ptoken	  = NULL;
 	const char* pline = line;
 	char* token	  = NULL;
 	size_t i	  = 0;
 	size_t len;
 
 	assert((line != NULL) && (limits != NULL));
 	*col  = 1;
 	token = malloc(limits[L_LINE_MAX]);
 	if (!token)
 		goto parse_po_line_alloc_error;
 	*token = 0;
 	ptoken = token;
 
 	if (starts_with(line, "msgid_plural "))
 	{
 		len = strlen("msgid_plural ");
 		*pstate &= ~PS_MSGID;
 		*pstate |= PS_MSGID_PLURAL;
 		pline += len;
 		*col += len;
 	}
 	else if (starts_with(line, "msgid "))
 	{
 		len = strlen("msgid ");
 		*pstate |= PS_MSGID;
 		pline += len;
 		*col += len;
 	}
 	else if (starts_with(line, "msgstr["))
 	{
 		len = strlen("msgstr[");
 		*pstate &= ~PS_MSGID;
 		*pstate &= ~PS_MSGID_PLURAL;
 		*pstate |= PS_MSGSTR_ARRAY;
 		(*msgstr_index)++;
 		pline += len;
 		*col += len;
 
 		while (*pline >= '0' && *pline <= '9')
 		{
 			pline++;
 			(*col)++;
 		}
 
 		if (starts_with(pline, "] "))
 		{
 			pline += 2;
 			(*col) += 2;
 		}
 		else
 		{
 			dstate->error = ERR_SYNTAX;
 			goto parse_po_cleanup;
 		}
 	}
 	else if (starts_with(line, "msgstr "))
 	{
 		len = strlen("msgstr ");
 		*pstate &= ~PS_MSGID;
 		*pstate &= ~PS_MSGID_PLURAL;
 		*pstate |= PS_MSGSTR;
 		pline += len;
 		*col += len;
 	}
 	else if (*line == 0)
 	{
 		*pstate &= ~PS_MSGID;
 		*pstate &= ~PS_MSGID_PLURAL;
 		*pstate &= ~PS_MSGSTR;
 		*pstate &= ~PS_MSGSTR_ARRAY;
 	}
 	else if (*line != ' ' && *line != '\t' && *line != '"' && *line != '#')
 	{
 		dstate->error = ERR_SYNTAX;
 		goto parse_po_cleanup;
 	}
 
 	while (*pline && i < strlen(line))
 	{
 		switch (*pline)
 		{
 		case ' ':
 		case '\t':
 			if (*pstate & PS_COMMENT)
 			{
 				*ptoken++ = *pline++;
 				INC_COL();
 			}
 			else if (*pstate & PS_STRING)
 			{
 				*ptoken++ = *pline++;
 				INC_COL();
 			}
 			else
 			{
 				pline++;
 				INC_COL();
 			}
 			break;
 		case '#':
 			if (pline - line + 1 == 1)
 			{
 				*pstate |= PS_COMMENT_TRAN;
 				pline++;
 				INC_COL();
 			}
 			else if (*pstate & (PS_STRING | PS_COMMENT))
 			{
 				*ptoken++ = *pline++;
 				INC_COL();
 			}
 			else
 			{
 				dstate->error = ERR_SYNTAX;
 				goto parse_po_cleanup;
 			}
 			break;
 		case '.':
 			if (pline - line + 1 == 2 && *pstate & PS_COMMENT_TRAN)
 			{
 				*pstate &= ~PS_COMMENT_TRAN;
 				*pstate |= PS_COMMENT_EXTR;
 				pline++;
 				INC_COL();
 				while (*pline == ' ' || *pline == '\t')
 				{
 					pline++;
 					INC_COL();
 				}
 			}
 			else
 			{
 				*ptoken++ = *pline++;
 				INC_COL();
 			}
 			break;
 		case ',':
 			if (pline - line + 1 == 2 && *pstate & PS_COMMENT_TRAN)
 			{
 				*pstate &= ~PS_COMMENT_TRAN;
 				*pstate |= PS_COMMENT_FLAG;
 				pline++;
 				INC_COL();
 				while (*pline == ' ' || *pline == '\t')
 				{
 					pline++;
 					INC_COL();
 				}
 			}
 			else
 			{
 				*ptoken++ = *pline++;
 				INC_COL();
 			}
 			break;
 		case ':':
 			if (pline - line + 1 == 2 && *pstate & PS_COMMENT_TRAN)
 			{
 				*pstate &= ~PS_COMMENT_TRAN;
 				*pstate |= PS_COMMENT_REFN;
 				pline++;
 				INC_COL();
 				while (*pline == ' ' || *pline == '\t')
 				{
 					pline++;
 					INC_COL();
 				}
 			}
 			else
 			{
 				*ptoken++ = *pline++;
 				INC_COL();
 			}
 			break;
 		case '~':
 			if (pline - line + 1 == 2 && (*pstate & PS_COMMENT_TRAN))
 			{
 				*pstate &= ~PS_COMMENT_TRAN;
 				*pstate |= PS_COMMENT_OBSO;
 				pline++;
 				INC_COL();
 				while (*pline == ' ' || *pline == '\t')
 				{
 					pline++;
 					INC_COL();
 				}
 			}
 			else
 			{
 				*ptoken++ = *pline++;
 				INC_COL();
 			}
 			break;
 		case '\\':
 			if ((*pstate & PS_STRING) && *(pline + 1) == '"')
 			{
 				*ptoken++ = *pline++;
 				INC_COL();
 				/* Skip parsing '"' */
 				*ptoken++ = *pline++;
 				INC_COL();
 			}
 			else
 			{
 				*ptoken++ = *pline++;
 				INC_COL();
 			}
 			break;
 		case '"':
 			if (*pstate & PS_COMMENT)
 			{
 				*ptoken++ = *pline++;
 				INC_COL();
 			}
 			else if (*pstate & PS_STRING)
 			{
 				*pstate &= ~PS_STRING;
 				pline++;
 				INC_COL();
 			}
 			else
 			{
 				*pstate |= PS_STRING;
 				pline++;
 				INC_COL();
 			}
 			break;
 		default:
 			if (*pstate & PS_COMMENT)
 			{
 				*ptoken++ = *pline++;
 				INC_COL();
 			}
 			else if (*pstate & PS_STRING)
 			{
 				*ptoken++ = *pline++;
 				INC_COL();
 			}
 			else
 			{
 				dstate->error = ERR_SYNTAX;
 				goto parse_po_cleanup;
 			}
 		}
 	}
 	*ptoken = 0;
 	if (*pstate == PS_NONE)
 	{
 		struct PoEntry* newchunk = NULL;
 
 		if (!(*current_entry)->obsolete)
 			dstate->msgid_count++;
 
 		(*current_entry)++;
 		if (*current_entry == dstate->entries + dstate->msgid_size)
 		{
 			dstate->msgid_size += ALLOC_DELTA;
 			newchunk = realloc(dstate->entries,
 				dstate->msgid_size * sizeof(struct PoEntry));
 			if (!newchunk)
 				goto parse_po_line_alloc_error;
 			dstate->entries = newchunk;
 			*current_entry	= dstate->entries + dstate->msgid_size
 				- ALLOC_DELTA;
 		}
 		init_po_entry(*current_entry);
 		*msgstr_index = -1;
 	}
 
 	if (!*token)
 		goto parse_po_empty_token;
 
 	if (*pstate & PS_MSGID)
 	{
 		if (set_msgid(dstate, *current_entry, token, 1))
 			goto parse_po_line_alloc_error;
 	}
 	else if (*pstate & PS_MSGID_PLURAL)
 	{
 		if (set_msgid_plural(dstate, *current_entry, token, 1))
 			goto parse_po_line_alloc_error;
 		if (*current_entry != dstate->entries)
 			for (int i = 0; i < dstate->nplurals; i++)
 				if (set_msgstr(dstate, *current_entry, NULL, i,
 					    0))
 					goto parse_po_line_alloc_error;
 	}
 	else if (*pstate & PS_MSGSTR)
 	{
 		/* first entry */
 		if (*current_entry == dstate->entries)
 		{
 			if (*pstate & PS_PLURAL_FORMS)
 			{
 				if (set_plural_forms(dstate, *current_entry,
 					    token, 1))
 					goto parse_po_line_alloc_error;
 				if (strstr(token, "\\n"))
 				{
 					*pstate &= ~PS_PLURAL_FORMS;
 					if (set_nplurals(dstate, *current_entry))
 						goto parse_po_cleanup;
 				}
 			}
 			else if (starts_with(token, "Plural-Forms: "))
 			{
 				if (!strstr(token, "\\n"))
 					*pstate |= PS_PLURAL_FORMS;
 				if (set_plural_forms(dstate, *current_entry,
 					    token + strlen("Plural-Forms: "), 0))
 					goto parse_po_line_alloc_error;
 			}
 		}
 
 		if (set_msgstr(dstate, *current_entry, token, 0, 1))
 			goto parse_po_line_alloc_error;
 	}
 	else if (*pstate & PS_MSGSTR_ARRAY)
 	{
 		if (set_msgstr(dstate, *current_entry, token, *msgstr_index, 1))
 			goto parse_po_line_alloc_error;
 	}
 	else if (*pstate & PS_COMMENT_TRAN)
 	{
 		uint32_t* u32_token = NULL;
 		size_t len	    = strlen(token) + 1;
 		u32_token	    = calloc(len, sizeof(uint32_t));
 		if (!u32_token)
 			goto parse_po_line_alloc_error;
 		u8_string_to_unicode(u32_token, token, len);
 		if (u32_add_comment(*current_entry, u32_token))
 			goto parse_po_line_alloc_error;
 		free(u32_token);
 	}
 	else if (*pstate & PS_COMMENT_EXTR)
 	{
 		uint32_t* u32_token = NULL;
 		size_t len	    = strlen(token) + 1;
 		u32_token	    = calloc(len, sizeof(uint32_t));
 		if (!u32_token)
 			goto parse_po_line_alloc_error;
 		u8_string_to_unicode(u32_token, token, len);
 		if (u32_add_extr_comment(*current_entry, u32_token))
 			goto parse_po_line_alloc_error;
 		free(u32_token);
 	}
 	else if (*pstate & PS_COMMENT_FLAG)
 	{
 		ptoken = token;
 		while (*ptoken)
 		{
 			int first = *current_entry == dstate->entries;
 			if (starts_with(ptoken, flag_strings[FL_C_FORMAT]))
 			{
 				(*current_entry)->flags |= FL_C_FORMAT;
 				ptoken += strlen(flag_strings[FL_C_FORMAT]);
 			}
 			else if (starts_with(ptoken,
 					 flag_strings[FL_NO_C_FORMAT]))
 			{
 				(*current_entry)->flags |= FL_NO_C_FORMAT;
 				ptoken += strlen(flag_strings[FL_NO_C_FORMAT]);
 			}
 			else if (starts_with(ptoken, flag_strings[FL_FUZZY])
 				&& !first)
 			{
 				(*current_entry)->flags |= FL_FUZZY;
 				dstate->fuzzy_count++;
 				ptoken += strlen(flag_strings[FL_FUZZY]);
 			}
 			else if (*ptoken == ',' && *(ptoken + 1) == ' ')
 				ptoken += 2;
 			else
 			{
 				/* Let this slip, ignore
 				 * everything instead; see typedef Flags in po.h
 				 * for rationale */
 				while (*ptoken)
 					ptoken++;
 			}
 		}
 	}
 	else if (*pstate & PS_COMMENT_REFN)
 	{
 		if (add_ref_comment(*current_entry, token))
 			goto parse_po_line_alloc_error;
 	}
 	else if (*pstate & PS_COMMENT_OBSO)
 	{
 		uint32_t* u32_token = NULL;
 		size_t len	    = strlen(token) + 1;
 		u32_token	    = calloc(len, sizeof(uint32_t));
 		if (!u32_token)
 			goto parse_po_line_alloc_error;
 		u8_string_to_unicode(u32_token, token, len);
 		if (u32_add_comment(*current_entry, u32_token))
 			goto parse_po_line_alloc_error;
 		else
 			(*current_entry)->obsolete = 1;
 		free(u32_token);
 	}
 	*token = 0;
 	goto parse_po_cleanup;
 
 parse_po_empty_token:
 	if (*pstate & PS_MSGSTR)
 	{
 		if (u32_set_msgstr(dstate, *current_entry, empty_string, 0, 1))
 			goto parse_po_line_alloc_error;
 	}
 	else if (*pstate & PS_MSGSTR_ARRAY)
 	{
 		if (u32_set_msgstr(dstate, *current_entry, empty_string,
 			    *msgstr_index, 1))
 			goto parse_po_line_alloc_error;
 	}
 	else if (*pstate & PS_COMMENT_TRAN)
 	{
 		if (u32_add_comment(*current_entry, empty_string))
 			goto parse_po_line_alloc_error;
 	}
 	else if (*pstate & PS_COMMENT_EXTR)
 	{
 		if (u32_add_extr_comment(*current_entry, empty_string))
 			goto parse_po_line_alloc_error;
 	}
 
 parse_po_cleanup:
 	/* one-line states */
 	*pstate &= ~PS_COMMENT;
 	return !!dstate->error;
 
 parse_po_line_alloc_error:
 	dstate->error = ERR_CANT_ALLOC;
 	return 1;
 }
 
 int
 save_comment(FILE* output, struct DrawState* state,
 	const struct PoEntry* current)
 {
 	char* temp	 = NULL;
 	char* u8_comment = NULL;
 	ssize_t c, len, size;
 
 	assert((output != NULL) && (state != NULL) && (current != NULL));
 	for (c = 0; c < current->comment_lines; c++)
 	{
 		len  = u32_strlen(current->comments[c]);
 		size = len * UTF8REPMAX + 1;
 		temp = realloc(u8_comment, size);
 		if (!temp)
 		{
 			state->error = ERR_CANT_ALLOC;
 			return 1;
 		}
 		u8_comment = temp;
 		unicode_string_to_u8(u8_comment, current->comments[c], len);
 		fprintf(output, "#%s%s\n", current->obsolete ? "~ " : "",
 			u8_comment);
 	}
 	free(u8_comment);
 	return 0;
 }
 
 int
 save_extr_comment(FILE* output, struct DrawState* state,
 	const struct PoEntry* current)
 {
 	char* temp	      = NULL;
 	char* u8_extr_comment = NULL;
 	ssize_t tc, len, size;
 
 	assert((output != NULL) && (state != NULL) && (current != NULL));
 	for (tc = 0; tc < current->extr_comment_lines; tc++)
 	{
 		len  = u32_strlen(current->extr_comments[tc]);
 		size = len * UTF8REPMAX + 1;
 
 		temp = realloc(u8_extr_comment, size);
 		if (!temp)
 		{
 			state->error = ERR_CANT_ALLOC;
 			return 1;
 		}
 		u8_extr_comment = temp;
 		unicode_string_to_u8(u8_extr_comment,
 			current->extr_comments[tc], len);
 		fprintf(output, "#.%s%s\n", u8_extr_comment[0] == 0 ? "" : " ",
 			u8_extr_comment);
 	}
 	free(u8_extr_comment);
 	return 0;
 }
 
 int
 save_file(struct DrawState* state)
 {
 	FILE* output		      = NULL;
 	const struct PoEntry* current = NULL;
 	struct stat st;
 	int result = 0;
 	int saved_errno;
 
 	assert(state != NULL);
 	state->action = ACT_WRITING;
 	if (redraw_status(state))
 		return 1;
 	errno = 0;
 
 	current = state->entries;
 	if (!create_backups)
 		goto save_skip_backup_copy;
 	if (!backup_fail && !state->backup_possible)
 		goto save_skip_backup_copy;
 
 	if ((unlink(state->backup_filename) < 0) && (errno != ENOENT))
 	{
 		state->error = ERR_ERRNO_SET;
 		result	     = 1;
 		goto save_file_cleanup;
 	}
 
 	if (cp(state->rfn_len > 0 ? state->real_filename : state->filename,
 		    state->backup_filename))
 	{
 		if (backup_fail)
 		{
 			state->error = ERR_ERRNO_SET;
 			result	     = 1;
 			goto save_file_cleanup;
 		}
 		else
 			errno = 0; /* ignore errors */
 	}
 
 save_skip_backup_copy:
 	if (!(output = fopen(state->rfn_len > 0 ? state->real_filename
 						: state->filename,
 		      "wt")))
 	{
 		state->error = ERR_ERRNO_SET;
 		result	     = 1;
 		goto save_file_cleanup;
 	}
 
 	if (!create_backups)
 		goto save_skip_backup_symlink;
 
 	if (lstat(state->rfn_len > 0 ? state->real_filename : state->filename,
 		    &st)
 		< 0)
 	{
 		state->error = ERR_ERRNO_SET;
 		result	     = 1;
 		goto save_file_cleanup;
 	}
 
 	if (!backup_fail && !state->backup_possible)
 		goto save_skip_backup_symlink;
 
 	if (state->rfn_len > 0)
 	{
 		if (unlink(state->filename) == -1)
 		{
 			state->error = ERR_ERRNO_SET;
 			result	     = 1;
 			goto save_file_cleanup;
 		}
 		if (symlink(state->orig_real_filename, state->filename) == -1)
 		{
 			state->error = ERR_ERRNO_SET;
 			result	     = 1;
 			goto save_file_cleanup;
 		}
 	}
 	chmod(state->rfn_len > 0 ? state->real_filename : state->filename,
 		st.st_mode);
 
 save_skip_backup_symlink:
 save_loop_entries_start:
 	if (current >= state->entries + state->real_msgid_count)
 		goto save_loop_entries_done;
 
 	if (!current->obsolete && current->comment_lines > 0)
 		if (save_comment(output, state, current))
 			goto save_file_error_cleanup;
 	if (current->extr_comment_lines > 0)
 		if (save_extr_comment(output, state, current))
 			goto save_file_error_cleanup;
 	if (current->ref_comment_lines > 0)
 		if (save_ref_comment(output, current))
 			goto save_file_error_cleanup;
 	if (save_flags(output, current))
 		goto save_file_error_cleanup;
 	if (current->obsolete && current->comment_lines > 0)
 		if (save_comment(output, state, current))
 			goto save_file_error_cleanup;
 
 	if (current->obsolete)
 	{
 		if (current < state->entries + state->real_msgid_count - 1)
 			fprintf(output, "\n");
 		current++;
 		goto save_loop_entries_start;
 	}
 
 	if (save_msgid(output, state, current))
 		goto save_file_error_cleanup;
 	if (current->msgid_plural)
 		if (save_msgid_plural(output, state, current))
 			goto save_file_error_cleanup;
 
 	if (save_msgstrs(output, state, current))
 		goto save_file_error_cleanup;
 
 	if (current < state->entries + state->real_msgid_count - 1)
 		fprintf(output, "\n");
 	current++;
 	goto save_loop_entries_start;
 
 save_file_error_cleanup:
 	result = 1;
 
 save_loop_entries_done:
 save_file_cleanup:
 	saved_errno = errno;
 	if (output)
 		fclose(output);
 	state->action = ACT_IDLE;
 	errno	      = saved_errno;
 	return result;
 }
 
 int
 save_flags(FILE* output, const struct PoEntry* current)
 {
 	Flags flags;
 
 	assert((output != NULL) && (current != NULL));
 	flags = current->flags;
 	if (flags != FL_NONE)
 		fprintf(output, "#, ");
 	while (flags != FL_NONE)
 	{
 		if (flags & FL_C_FORMAT)
 		{
 			flags &= ~FL_C_FORMAT;
 			fprintf(output, "%s", flag_strings[FL_C_FORMAT]);
 		}
 		else if (flags & FL_NO_C_FORMAT)
 		{
 			flags &= ~FL_NO_C_FORMAT;
 			fprintf(output, "%s", flag_strings[FL_NO_C_FORMAT]);
 		}
 		else if (flags & FL_FUZZY)
 		{
 			flags &= ~FL_FUZZY;
 			fprintf(output, "%s", flag_strings[FL_FUZZY]);
 		}
 		else
 			flags = FL_NONE; /* see po.h, typedef Flags */
 
 		if (flags != FL_NONE)
 			fprintf(output, ", ");
 	}
 	if (current->flags != FL_NONE)
 		fprintf(output, "\n");
 	return 0;
 }
 
 int
 save_msgid(FILE* output, struct DrawState* state, const struct PoEntry* current)
 {
 	const uint32_t* old_pumsgid = NULL;
 	const uint32_t* pumsgid	    = NULL;
 	char* u8_msgid		    = NULL;
 	size_t len		    = 0;
 	size_t num_lines;
 	size_t size;
 
 	assert((output != NULL) && (state != NULL) && (current != NULL));
 	if (!current->msgid)
 	{
 		fprintf(output, "msgid \"\"\n");
 		return 0;
 	}
 	num_lines = u32_lines_in_string(current->msgid, 1, wrap_width);
 	if ((num_lines > 1)
 		|| u32_strlen(current->msgid) + strlen("msgid \"") + 1
 			> (size_t)literal_break_threshold)
 	{
 		pumsgid = current->msgid;
 		fprintf(output, "msgid %s", break_literals ? "\"\"\n" : "");
 		while (*pumsgid)
 		{
 			u8_msgid    = NULL;
 			old_pumsgid = pumsgid;
 
 			len = u32_next_line(current->msgid, &pumsgid, 1,
 				wrap_width);
 			if (len == 0)
 				continue;
 
 			size	 = len * UTF8REPMAX + 1;
 			u8_msgid = malloc(size);
 			if (!u8_msgid)
 			{
 				state->error = ERR_CANT_ALLOC;
 				return 1;
 			}
 			memset(u8_msgid, 0, size);
 
 			unicode_string_to_u8(u8_msgid, old_pumsgid, len);
 			fprintf(output, "\"%s\"\n", u8_msgid);
 			free(u8_msgid);
 		}
 	}
 	else
 	{
 		size	 = current->msgid_size * UTF8REPMAX + 1;
 		u8_msgid = malloc(size);
 		if (!u8_msgid)
 		{
 			state->error = ERR_CANT_ALLOC;
 			return 1;
 		}
 
 		memset(u8_msgid, 0, size);
 
 		unicode_string_to_u8(u8_msgid, current->msgid,
 			current->msgid_size);
 		fprintf(output, "msgid \"%s\"\n", u8_msgid);
 		free(u8_msgid);
 	}
 	return 0;
 }
 
 int
 save_msgid_plural(FILE* output, struct DrawState* state,
 	const struct PoEntry* current)
 {
 	const uint32_t* old_pumsgid = NULL;
 	const uint32_t* pumsgid	    = NULL;
 	char* u8_msgid		    = NULL;
 	size_t len		    = 0;
 	size_t msgid_plural_len, num_lines, size;
 
 	assert((output != NULL) && (state != NULL) && (current != NULL));
 	num_lines = u32_lines_in_string(current->msgid_plural, 1, wrap_width);
 	if ((num_lines > 1)
 		|| u32_strlen(current->msgid_plural) + strlen("msgid_plural \"")
 				+ 1
 			> (size_t)literal_break_threshold)
 	{
 		pumsgid = current->msgid_plural;
 		fprintf(output, "msgid_plural %s",
 			break_literals ? "\"\"\n" : "");
 		while (*pumsgid)
 		{
 			u8_msgid    = NULL;
 			old_pumsgid = pumsgid;
 			len = u32_next_line(current->msgid_plural, &pumsgid, 1,
 				wrap_width);
 			if (len == 0)
 				continue;
 
 			size	 = len * UTF8REPMAX + 1;
 			u8_msgid = malloc(size);
 			if (!u8_msgid)
 			{
 				state->error = ERR_CANT_ALLOC;
 				return 1;
 			}
 
 			memset(u8_msgid, 0, size);
 
 			unicode_string_to_u8(u8_msgid, old_pumsgid, len);
 			fprintf(output, "\"%s\"\n", u8_msgid);
 			free(u8_msgid);
 		}
 	}
 	else
 	{
 		size	 = current->msgid_plural_size * UTF8REPMAX + 1;
 		u8_msgid = malloc(size);
 		if (!u8_msgid)
 		{
 			state->error = ERR_CANT_ALLOC;
 			return 1;
 		}
 
 		memset(u8_msgid, 9, size);
 
 		msgid_plural_len = u32_strlen(current->msgid_plural);
 		unicode_string_to_u8(u8_msgid, current->msgid_plural,
 			msgid_plural_len);
 		fprintf(output, "msgid_plural \"%s\"\n", u8_msgid);
 		free(u8_msgid);
 	}
 	return 0;
 }
 
 int
 save_msgstrs(FILE* output, struct DrawState* state,
 	const struct PoEntry* current)
 {
 	struct tm* now_tm	     = NULL;
 	const uint32_t* old_pumsgstr = NULL;
 	const uint32_t* pumsgstr     = NULL;
 	char now[MAXDATEBUF];
 	char* u8_msgstr = NULL;
 	time_t t;
 	ssize_t m, num_lines;
 	size_t len, size, msgstr_len, llen;
 	int i;
 	int seen_generator    = 0;
 	int seen_plural_forms = 0;
 	int first_entry;
 
 	assert((output != NULL) && (state != NULL) && (current != NULL));
 	first_entry = (current == state->entries) && !current->msgid;
 	if (!current->msgstr_count)
 	{
 		if (current->msgid_plural)
 			for (i = 0; i < state->nplurals; i++)
 				fprintf(output, "msgstr[%d] \"\"\n", i);
 		else
 			fprintf(output, "msgstr \"\"\n");
 		return 0;
 	}
 	if (current->msgstr_count == 1)
 	{
 		t      = time(NULL);
 		now_tm = localtime(&t);
 		strftime(now, MAXDATEBUF, "%F %H:%M%z", now_tm);
 	}
 	for (m = 0; m < current->msgstr_count; m++)
 	{
 		assert(current->msgstr);
 		num_lines = u32_lines_in_string(current->msgstr[m], 1,
 			wrap_width);
 
 		llen = (current->msgstr_count == 1 ? strlen("msgstr \"")
 						   : strlen("msgstr[ ] \""))
 			+ u32_strlen(current->msgstr[m]) + 1;
 		if ((num_lines > 1) || llen > (size_t)literal_break_threshold)
 		{
 			pumsgstr = current->msgstr[m];
 			if (current->msgstr_count == 1)
 				fprintf(output, "msgstr %s",
 					break_literals ? "\"\"\n" : "");
 			else
 				fprintf(output, "msgstr[%ld] %s", m,
 					break_literals ? "\"\"\n" : "");
 
 		save_msgstrs_pumsgstr_loop:
 			old_pumsgstr = pumsgstr;
 			len = u32_next_line(current->msgstr[m], &pumsgstr, 1,
 				wrap_width);
 			if (len == 0)
 				goto save_msgstrs_pumsgstr_done;
 			size	  = len * UTF8REPMAX + 1;
 			u8_msgstr = malloc(size);
 			if (!u8_msgstr)
 			{
 				state->error = ERR_CANT_ALLOC;
 				return 1;
 			}
 			memset(u8_msgstr, 0, size);
 
 			unicode_string_to_u8(u8_msgstr, old_pumsgstr, len);
 			if (first_entry
 				&& starts_with(u8_msgstr, "X-Generator: "))
 			{
 				seen_generator = 1;
 				fprintf(output, "\"X-Generator: poe %s\\n\"\n",
 					VERSION);
 			}
 			else if (first_entry && plural_string
 				&& starts_with(u8_msgstr, "Plural-Forms: "))
 			{
 				seen_plural_forms = 1;
 				fprintf(output, "\"%s\"\n", u8_msgstr);
 			}
 			else
 				fprintf(output, "\"%s\"\n", u8_msgstr);
 			free(u8_msgstr);
 			if (*pumsgstr)
 				goto save_msgstrs_pumsgstr_loop;
 
 		save_msgstrs_pumsgstr_done:
 			if (first_entry && !seen_generator)
 				fprintf(output, "\"X-Generator: poe %s\\n\"\n",
 					VERSION);
 			if (first_entry && plural_string && !seen_plural_forms)
 				fprintf(output, "\"Plural-Forms: %s\\n\"\n",
 					plural_string);
 		}
 		else
 		{
 			msgstr_len = u32_strlen(current->msgstr[m]);
 			size	   = (msgstr_len + 1) * UTF8REPMAX;
 			u8_msgstr  = malloc(size);
 			if (!u8_msgstr)
 			{
 				state->error = ERR_CANT_ALLOC;
 				return 1;
 			}
 			unicode_string_to_u8(u8_msgstr, current->msgstr[m],
 				msgstr_len);
 			if (current->msgstr_count == 1)
 				fprintf(output, "msgstr \"%s\"\n", u8_msgstr);
 			else
 				fprintf(output, "msgstr[%ld] \"%s\"\n", m,
 					u8_msgstr);
 			free(u8_msgstr);
 		}
 	}
 	return 0;
 }
 
 int
 save_ref_comment(FILE* output, const struct PoEntry* current)
 {
 	ssize_t rc;
 	assert((output != NULL) && (current != NULL));
 	for (rc = 0; rc < current->ref_comment_lines; rc++)
 		fprintf(output, "#: %s\n", current->ref_comments[rc]);
 	return 0;
 }
 
 int
 set_flags(struct PoEntry* entry, const Flags flags)
 {
 	assert(entry != NULL);
 	entry->flags = flags;
 	return 0;
 }
 
 int
 set_msgid(struct DrawState* state, struct PoEntry* entry, const char* msgid,
 	int append)
 {
 	uint32_t* umsgid = NULL;
 	size_t msgid_len = 0;
 	int result	 = 0;
 
 	assert(entry != NULL);
 	if (msgid)
 		msgid_len = strlen(msgid);
 	umsgid = calloc(msgid_len + 1, sizeof(uint32_t));
 	if (!umsgid)
 		goto set_msgid_alloc_error;
 	if (msgid)
 		(void)u8_string_to_unicode(umsgid, msgid, msgid_len);
 	result = u32_set_msgid(state, entry, umsgid, msgid_len, append);
 	free(umsgid);
 	return result;
 
 set_msgid_alloc_error:
 	state->error = ERR_CANT_ALLOC;
 	return 1;
 }
 
 int
 set_msgid_plural(struct DrawState* state, struct PoEntry* entry,
 	const char* msgid_plural, int append)
 {
 	uint32_t* umsgid_plural = NULL;
 	size_t msgid_plural_len = 0;
 	int result		= 0;
 
 	assert(entry != NULL);
 	if (msgid_plural)
 		msgid_plural_len = strlen(msgid_plural);
 	umsgid_plural = calloc(msgid_plural_len + 1, sizeof(uint32_t));
 	if (!umsgid_plural)
 		goto set_msgid_plural_alloc_error;
 	if (msgid_plural)
 		(void)u8_string_to_unicode(umsgid_plural, msgid_plural,
 			msgid_plural_len);
 	result = u32_set_msgid_plural(state, entry, umsgid_plural,
 		msgid_plural_len, append);
 	free(umsgid_plural);
 	return result;
 
 set_msgid_plural_alloc_error:
 	state->error = ERR_CANT_ALLOC;
 	return 1;
 }
 
 int
 set_msgstr(struct DrawState* state, struct PoEntry* entry, const char* msgstr,
 	int msgstr_index, int append)
 {
 	uint32_t* umsgstr = NULL;
 	size_t msgstr_len = 0;
 	int result	  = 0;
 
 	assert(entry != NULL);
 	if (msgstr)
 		msgstr_len = strlen(msgstr);
 	umsgstr = calloc(msgstr_len + 1, sizeof(uint32_t));
 	if (!umsgstr)
 		goto set_msgstr_alloc_error;
 	if (msgstr)
 		(void)u8_string_to_unicode(umsgstr, msgstr, msgstr_len);
 	result = u32_set_msgstr(state, entry, umsgstr, msgstr_index, append);
 	free(umsgstr);
 	return result;
 
 set_msgstr_alloc_error:
 	state->error = ERR_CANT_ALLOC;
 	return 1;
 }
 
 int
 set_nplurals(struct DrawState* state, struct PoEntry* entry)
 {
 	char token[LINE_DEFAULT];
 	static uint32_t* unplurals = NULL;
 	uint32_t* ppf;
 	uint32_t* temp;
 	char* ptoken = token;
 	int errornum;
 	int read_number	 = 0;
 	int nplurals_len = 0;
 
 	assert(state != NULL);
 	if (!entry || !entry->plural_forms)
 		return 1;
 
 	nplurals_len = strlen("nplurals=");
 	ppf	     = entry->plural_forms;
 	*ptoken	     = 0;
 	while (*ppf)
 	{
 		if (!unplurals)
 		{
 			unplurals = calloc(nplurals_len + 1, sizeof(uint32_t));
 			if (!unplurals)
 				goto set_nplurals_alloc_error;
 			U32_U8_MEMCCPY(unplurals, "nplurals=", nplurals_len,
 				temp);
 		}
 		if (u32_starts_with(ppf, unplurals))
 		{
 			ppf += nplurals_len;
 			read_number = 1;
 		}
 		else if (read_number && *ppf >= ZERO && *ppf <= NINE)
 		{
 			*ptoken++ = *ppf++;
 			*ptoken	  = 0;
 		}
 		else if (read_number && *ppf == SEMICOL)
 		{
 			*ptoken = 0;
 			ptoken	= token;
 			break;
 		}
 		else
 			ppf++;
 	}
 	if (*ptoken)
 	{
 		state->nplurals = strtonumber(ptoken, 0, INT_MAX, &errornum);
 		if (errornum != STN_NONE)
 		{
 			state->error = ERR_BAD_NPLURALS;
 			return 1;
 		}
 	}
 	else
 	{
 		state->error = ERR_BAD_NPLURALS;
 		return 1;
 	}
 
 	return 0;
 
 set_nplurals_alloc_error:
 	state->error = ERR_CANT_ALLOC;
 	return 1;
 }
 
 int
 set_plural_forms(struct DrawState* state, struct PoEntry* entry,
 	const char* plural_forms, int append)
 {
 	uint32_t* uplural_forms = NULL;
 	size_t plural_forms_len = 0;
 	int result		= 0;
 
 	assert(entry != NULL);
 	if (plural_forms)
 		plural_forms_len = strlen(plural_forms);
 	uplural_forms = calloc(plural_forms_len + 1, sizeof(uint32_t));
 	if (!uplural_forms)
 		goto set_plural_forms_alloc_error;
 	if (plural_forms)
 		(void)u8_string_to_unicode(uplural_forms, plural_forms,
 			plural_forms_len);
 	result = u32_set_plural_forms(state, entry, uplural_forms,
 		plural_forms_len, append);
 	free(uplural_forms);
 	return result;
 
 set_plural_forms_alloc_error:
 	state->error = ERR_CANT_ALLOC;
 	return 1;
 }
 
 int
 u32_add_comment(struct PoEntry* entry, const uint32_t* comment)
 {
 	uint32_t** comments = NULL;
 	uint32_t* new_line  = NULL;
 	size_t len	    = 0;
 	size_t size;
 
 	assert((entry != NULL) && (comment != NULL));
 	entry->comment_lines++;
 	if (!entry->comments)
 		comments = calloc(entry->comment_lines, sizeof(uint32_t*));
 	else
 		comments = realloc(entry->comments,
 			entry->comment_lines * sizeof(uint32_t*));
 	if (!comments)
 		return 1;
 	entry->comments = comments;
 
 	len	 = u32_strlen(comment);
 	size	 = len + 1;
 	new_line = calloc(size, sizeof(uint32_t));
 	if (!new_line)
 		return 1;
 	entry->comments[entry->comment_lines - 1] = new_line;
 	u32_strncpy(new_line, comment, size);
 	return 0;
 }
 
 int
 u32_add_extr_comment(struct PoEntry* entry, const uint32_t* extr_comment)
 {
 	uint32_t** extr_comments = NULL;
 	uint32_t* new_line	 = NULL;
 	size_t len		 = 0;
 	size_t size;
 
 	assert((entry != NULL) && (extr_comment != NULL));
 	entry->extr_comment_lines++;
 	if (!entry->extr_comments)
 		extr_comments
 			= calloc(entry->extr_comment_lines, sizeof(uint32_t*));
 	else
 		extr_comments = realloc(entry->extr_comments,
 			entry->extr_comment_lines * sizeof(uint32_t*));
 	if (!extr_comments)
 		return 1;
 	entry->extr_comments = extr_comments;
 
 	len	 = u32_strlen(extr_comment);
 	size	 = len + 1;
 	new_line = calloc(size, sizeof(uint32_t));
 	if (!new_line)
 		return 1;
 	entry->extr_comments[entry->extr_comment_lines - 1] = new_line;
 	u32_strncpy(new_line, extr_comment, size);
 	return 0;
 }
 
 int
 u32_set_msgid(struct DrawState* state, struct PoEntry* entry,
 	const uint32_t* msgid, ssize_t msgid_len, int append)
 {
 	uint32_t* temp = NULL;
 
 	assert((state != NULL) && (entry != NULL));
 	if (!entry->msgid)
 	{
 		entry->msgid_size = MSGDELTA;
 		entry->msgid_len  = 0;
 		entry->msgid	  = calloc(entry->msgid_size, sizeof(uint32_t));
 		if (!entry->msgid)
 			goto u32_set_msgid_alloc_error;
 	}
 	else if (entry->msgid_len + msgid_len >= entry->msgid_size)
 	{
 		entry->msgid_size += MSGDELTA;
 		temp = realloc(entry->msgid,
 			entry->msgid_size * sizeof(uint32_t));
 		if (!temp)
 			goto u32_set_msgid_alloc_error;
 		entry->msgid = temp;
 	}
 	entry->msgid_len += msgid_len;
 	if (append)
 		U32_MEMCCPY(entry->msgid + entry->msgid_len - msgid_len, msgid,
 			entry->msgid_size - msgid_len, temp);
 	else
 		U32_MEMCCPY(entry->msgid, msgid, entry->msgid_size, temp);
 	return 0;
 
 u32_set_msgid_alloc_error:
 	state->error = ERR_CANT_ALLOC;
 	return 1;
 }
 
 int
 u32_set_msgid_plural(struct DrawState* state, struct PoEntry* entry,
 	const uint32_t* msgid_plural, ssize_t msgid_plural_len, int append)
 {
 	uint32_t* temp = NULL;
 
 	assert((state != NULL) && (entry != NULL));
 	if (msgid_plural)
 		msgid_plural_len = u32_strlen(msgid_plural);
 	if (!entry->msgid_plural)
 	{
 		entry->msgid_plural_size = MSGDELTA;
 		entry->msgid_plural_len	 = 0;
 		entry->msgid_plural
 			= calloc(entry->msgid_plural_size, sizeof(uint32_t));
 		if (!entry->msgid_plural)
 			goto u32_set_msgid_plural_alloc_error;
 	}
 	else if (entry->msgid_plural_size + msgid_plural_len
 		>= entry->msgid_plural_size)
 	{
 		entry->msgid_plural_size += MSGDELTA;
 		temp = realloc(entry->msgid_plural,
 			entry->msgid_plural_size * sizeof(uint32_t));
 		if (!temp)
 			goto u32_set_msgid_plural_alloc_error;
 		entry->msgid_plural = temp;
 	}
 	entry->msgid_plural_len += msgid_plural_len;
 	if (append)
 		U32_MEMCCPY(entry->msgid_plural + entry->msgid_plural_len
 				- msgid_plural_len,
 			msgid_plural,
 			entry->msgid_plural_size - msgid_plural_len, temp);
 	else
 		U32_MEMCCPY(entry->msgid_plural, msgid_plural,
 			entry->msgid_plural_size, temp);
 	return 0;
 
 u32_set_msgid_plural_alloc_error:
 	state->error = ERR_CANT_ALLOC;
 	return 1;
 }
 
 int
 u32_set_msgstr(struct DrawState* state, struct PoEntry* entry,
 	const uint32_t* msgstr, int msgstr_index, int append)
 {
 	uint32_t** newmsgstr	= NULL;
 	uint32_t* temp		= NULL;
 	ssize_t* newmsgstr_len	= NULL;
 	ssize_t* newmsgstr_size = NULL;
 	ssize_t msgstr_len	= 0;
 
 	assert((state != NULL) && (entry != NULL));
 	if (msgstr)
 		msgstr_len = u32_strlen(msgstr);
 	if (entry->msgstr_count == 0 || msgstr_index + 1 > entry->msgstr_count)
 	{
 		newmsgstr	    = NULL;
 		newmsgstr_size	    = NULL;
 		newmsgstr_len	    = NULL;
 		entry->msgstr_count = msgstr_index + 1;
 		if (!entry->msgstr)
 		{
 			newmsgstr = calloc(entry->msgstr_count,
 				sizeof(uint32_t*));
 			if (!newmsgstr)
 				goto u32_set_msgstr_alloc_error;
 			newmsgstr_size
 				= calloc(entry->msgstr_count, sizeof(ssize_t));
 			if (!newmsgstr_size)
 				goto u32_set_msgstr_alloc_error;
 			newmsgstr_len
 				= calloc(entry->msgstr_count, sizeof(ssize_t));
 			if (!newmsgstr_len)
 				goto u32_set_msgstr_alloc_error;
 			/* when the .po file is not a standard text file (no LF
 			 * at end) */
 			if (state->untranslated_count > 0)
 				state->untranslated_count--;
 		}
 		else
 		{
 			newmsgstr = realloc(entry->msgstr,
 				entry->msgstr_count * sizeof(uint32_t*));
 			if (!newmsgstr)
 				goto u32_set_msgstr_alloc_error;
 			newmsgstr_size = realloc(entry->msgstr_size,
 				entry->msgstr_count * sizeof(ssize_t));
 			if (!newmsgstr_size)
 				goto u32_set_msgstr_alloc_error;
 			newmsgstr_len = realloc(entry->msgstr_len,
 				entry->msgstr_count * sizeof(ssize_t));
 			if (!newmsgstr_len)
 				goto u32_set_msgstr_alloc_error;
 		}
 		newmsgstr[msgstr_index] = NULL;
 		entry->msgstr		= newmsgstr;
 		entry->msgstr_size	= newmsgstr_size;
 		entry->msgstr_len	= newmsgstr_len;
 	}
 	if (!entry->msgstr[msgstr_index])
 	{
 		entry->msgstr_size[msgstr_index] = MSGDELTA;
 		entry->msgstr_len[msgstr_index]	 = 0;
 		entry->msgstr[msgstr_index]
 			= calloc(entry->msgstr_size[msgstr_index],
 				sizeof(uint32_t));
 		if (!entry->msgstr[msgstr_index])
 			goto u32_set_msgstr_alloc_error;
 	}
 	else if (entry->msgstr_len[msgstr_index] + msgstr_len
 		>= entry->msgstr_size[msgstr_index])
 	{
 		entry->msgstr_size[msgstr_index] += MSGDELTA;
 		entry->msgstr[msgstr_index]
 			= realloc(entry->msgstr[msgstr_index],
 				entry->msgstr_size[msgstr_index]
 					* sizeof(uint32_t));
 		if (!entry->msgstr[msgstr_index])
 			goto u32_set_msgstr_alloc_error;
 	}
 	entry->msgstr_len[msgstr_index] += msgstr_len;
 	if (append)
 		U32_MEMCCPY(entry->msgstr[msgstr_index]
 				+ entry->msgstr_len[msgstr_index] - msgstr_len,
 			msgstr, entry->msgstr_size[msgstr_index] - msgstr_len,
 			temp);
 	else
 		U32_MEMCCPY(entry->msgstr[msgstr_index], msgstr,
 			entry->msgstr_size[msgstr_index], temp);
 	return 0;
 
 u32_set_msgstr_alloc_error:
 	state->error = ERR_CANT_ALLOC;
 	return 1;
 }
 
 int
 u32_set_plural_forms(struct DrawState* state, struct PoEntry* entry,
 	const uint32_t* plural_forms, const ssize_t plural_forms_len,
 	int append)
 {
 	uint32_t* temp = NULL;
 
 	assert((state != NULL) && (entry != NULL));
 	if (plural_forms_len >= MSGDELTA)
 		return 1;
 	if (!entry->plural_forms)
 	{
 		entry->plural_forms_size = MSGDELTA;
 		entry->plural_forms_len	 = 0;
 		entry->plural_forms	 = calloc(MAXMSGLINE, sizeof(uint32_t));
 		if (!entry->plural_forms)
 			goto u32_set_plural_forms_alloc_error;
 	}
 	else if (entry->plural_forms_len + plural_forms_len
 		>= entry->plural_forms_size)
 	{
 		entry->plural_forms_size += MSGDELTA;
 		temp = realloc(entry->plural_forms,
 			entry->plural_forms_size * sizeof(uint32_t));
 		if (!temp)
 			goto u32_set_plural_forms_alloc_error;
 		entry->plural_forms = temp;
 	}
 	entry->plural_forms_len += plural_forms_len;
 	if (append)
 		U32_MEMCCPY(entry->plural_forms + entry->plural_forms_size
 				- plural_forms_len,
 			plural_forms,
 			entry->plural_forms_size - plural_forms_len, temp);
 	else
 		U32_MEMCCPY(entry->plural_forms, plural_forms,
 			entry->plural_forms_size, temp);
 	return 0;
 
 u32_set_plural_forms_alloc_error:
 	state->error = ERR_CANT_ALLOC;
 	return 1;
 }
 
 void
 update_statistics(const struct PoEntry* entries, struct DrawState* state,
 	struct PoEntry* entry)
 {
 	const struct PoEntry* current = NULL;
 	int advance		      = 1;
 
 	state->fuzzy_count	  = 0;
 	state->obsolete_count	  = 0;
 	state->untranslated_count = 0;
 
 	current = entries;
 	while (current && advance)
 	{
 		if (current->obsolete)
 			state->obsolete_count++;
 		else
 		{
 			if (current->msgid
 				&& (!current->msgstr || !*current->msgstr
 					|| !**current->msgstr))
 				state->untranslated_count++;
 			if (current->flags & FL_FUZZY)
 				state->fuzzy_count++;
 		}
 		if (current == entry)
 			advance = 0;
 		else
 			current++;
 	}
 }
 
 void
 update_warning(const uint32_t* msgid, const uint32_t* msgstr, int* warning)
 {
 	if (!msgid || !msgstr || !warning)
 		return;
 	if (u32_count_strings(msgid, bslash_en)
 			!= u32_count_strings(msgstr, bslash_en)
 		|| (warn_count_dots
 			&& u32_count_chars(msgid, DOT)
 				!= u32_count_chars(msgstr, DOT)))
 		*warning = 1;
 	else
 		*warning = 0;
 }