/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright (c) 1990, 1991, 1994, Sun Microsystems, Inc.
 * All rights reserved.
 */

#ident	"%Z%%M%	%I%	%E% SMI"

#include <nl_types.h>
#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <memory.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <locale.h>
#include <libintl.h>

#ifndef NL_MSGMAX
#define	NL_MSGMAX 32767
#endif

#ifndef NL_SETMAX
#define	NL_SETMAX 255
#endif

#ifndef NL_TEXTMAX
#define	NL_TEXTMAX 2048
#endif

#define	BS		'\b'
#define	CR		'\r'
#define	DOLLAR	'$'
#define	FF		'\f'
#define	NEWLINE	'\n'
#define	NUL		'\000'
#define	REVERSE_SOLIDUS '\\'
#define	SPACE	' '
#define	TAB		'\t'
#define	VTAB	'\v'

#define	FPRINTF			(void) fprintf
#define	FREE(x)			free((char *)(x))
#define	MALLOC(n)		malloc((unsigned)(n))
#define	MEMCPY(dst, src, n) \
		(void) memcpy((char *)(dst), (char *)(src), (int)(n))
#define	MEMSET(s, c, n)	(void) memset((char *)(s), (int)(c), (int)(n));
#define	MSG(n)			gettext(MSG ## n)
#define	READ(fd, p, n)	read((int)(fd), (char *)(p), (unsigned)(n))
#define	REALLOC(x, n)	realloc((char *)(x), (unsigned)(n))

/* double linked list */
struct cat_set {
	struct cat_set	*prev;
	struct cat_set	*next;
	int				set_no;
	struct cat_msg	*first_msg;
};

/* double linked list */
struct cat_msg {
	struct cat_msg	*prev;
	struct cat_msg	*next;
	int				msg_no;
	int				msg_len;
	char			s[1];
};

int		catfd;		/* File descriptor of catalog file */
char	*catfname;	/* Catalog file name */
char	*msgfname;	/* message source file name */
int		ateof;		/* boolean indicating END-OF-FILE */
int		lineno;		/* the line number of message source file */
int		quoting;	/* boolean indicating quotes is used */
int		quote;		/* the current quote */
int		text_len;	/* message text length */
int		text_size;	/* the size of allocated text memory */
char	*text;		/* messsge text */

struct _cat_hdr	hdr;
int				current_set_no;	/* the current set number */
struct cat_set	*first_set;	/* the pointer to the first set */
struct cat_set	*current_set;	/* the pointer to the current set */
struct cat_msg	*current_msg;	/* the pointer to the first message */


/* Error message */
/* 0 */
#define	MSG0	""
/* 1 */
#define	MSG1	"usage: gencat catfile msgfile ...\n"
/* 2 */
#define	MSG2	"gencat: cannot open \"%s\"\n"
/* 3 */
#define	MSG3	"gencat: read error on \"%s\"\n"
/* 4 */
#define	MSG4	"gencat: bad magic number (%#lx)\n"
/* 5 */
#define	MSG5	"gencat: corrupt catalogue file \"%s\"\n"
/* 6 */
#define	MSG6	"gencat: memory limit exceeded\n"
/* 7 */
#define	MSG7	"gencat: seek error on \"%s\"\n"
/* 8 */
#define	MSG8	"gencat: write error on \"%s\"\n"
/* 9 */
#define	MSG9	"gencat: \"%s\", line %d: number too large (%s)\n"
/* 10 */
#define	MSG10	"gencat: \"%s\", line %d: 0 is not a permissible " \
				"message number\n"
/* 11 */
#define	MSG11	"gencat: \"%s\", line %d: warning, message number %d " \
				"exceeds limit (%d)\n"
/* 12 */
#define	MSG12	"gencat: \"%s\", line %d: missing quote (%wc)\n"
/* 13 */
#define	MSG13	"gencat: \"%s\", line %d: character value too large ('\\%o')\n"
/* 14 */
#define	MSG14	"gencat: \"%s\", line %d: extra characters following " \
				"message text\n"
/* 15 */
#define	MSG15	"gencat: \"%s\", line %d: extra characters following " \
				"$quote directive\n"
/* 16 */
#define	MSG16	"gencat: \"%s\", line %d: no set number specified in " \
				"$set directive\n"
/* 17 */
#define	MSG17	"getcat: \"%s\", line %d: 0 is not a permissible set number\n"
/* 18 */
#define	MSG18	"gencat: \"%s\", line %d: warning, set number %d " \
				"exceeds limit (%d)\n"
/* 19 */
#define	MSG19	"gencat: \"%s\", line %d: unknown directive %s\n"
/* 20 */
#define	MSG20	"gencat: \"%s\", line %d: no set number specified in " \
				"$delset directive\n"
/* 21 */
#define	MSG21	"stdin"
/* 22 */
#define	MSG22	"gencat: \"%s\", line %d: number or $ expected\n"

struct cat_set *
new_set(n)
	int		n;
{
	struct cat_set *p;

	p = (struct cat_set *) MALLOC(sizeof (struct cat_set));
	if (p == NULL) {
		FPRINTF(stderr, MSG(6));
		exit(1);
	}
	p->next = NULL;
	p->prev = NULL;
	p->set_no = n;
	p->first_msg = NULL;
	return (p);
}

void
find_set(no)
	int		no;
{
	struct cat_set	*prev, *next;

	if (current_set && current_set->set_no == no) {
		return;
	}

	current_set_no = no;
	current_msg = NULL;
	/* if no set exists, create a new set */
	if (current_set == NULL) {
		if (first_set == NULL) {
			current_set = first_set = new_set(no);
			return;
		}
		current_set = first_set;
		if (current_set->set_no == no)
			return;
	}

	if (current_set->set_no > no) {
		if (first_set->set_no > no) {
			/* prepend a new set */
			current_set = new_set(no);
			current_set->next = first_set;
			first_set->prev = current_set;
			first_set = current_set;
			return;
		}
		current_set = first_set;
		if (current_set->set_no == no)
			return;
	}

	/* search for the set number 'no' */
	while (current_set->next && current_set->next->set_no < no)
		current_set = current_set->next;

	if (current_set->next && current_set->next->set_no == no) {
		/* set number 'no' found */
		current_set = current_set->next;
		return;
	}

	/* If set number is not found, insert a new set in the middle */
	prev = current_set;
	next = current_set->next;
	current_set = new_set(no);
	current_set->prev = prev;
	current_set->next = next;
	if (prev)
		prev->next = current_set;
	else
		first_set = current_set;
	if (next)
		next->prev = current_set;
}

void
delete_set(no)
	int		no;
{
	struct cat_set	*prev, *next, *setp;
	struct cat_msg	*p, *q;

	for (setp = first_set; setp && setp->set_no < no; setp = setp->next)
		continue;

	if (setp == NULL || setp->set_no != no)	/* set not found */
		return;

	if (setp == current_set) {
		current_set = NULL;
		current_msg = NULL;
	}

	/* free all messages in the set */
	for (p = setp->first_msg; p; p) {
		q = p->next;
		FREE(p);
		p = q;
	}

	/* do the link operation to delete the set */
	prev = setp->prev;
	next = setp->next;
	FREE(setp);
	if (prev)
		prev->next = next;
	else
		first_set = next;
	if (next)
		next->prev = prev;
}

struct cat_msg *
new_msg(no, len, text)
	int		no;
	int		len;
	char	*text;
{
	struct cat_msg	*p;

	p = (struct cat_msg *) MALLOC(sizeof (struct cat_msg) + len);
	if (p == NULL) {
		FPRINTF(stderr, MSG(6));
		exit(1);
	}
	p->next = NULL;
	p->prev = NULL;
	p->msg_no = no;
	p->msg_len = len;
	MEMCPY(p->s, text, len);
	return (p);
}


void
insert_msg(no, len, text)
	int		no;
	int		len;
	char	*text;
{
	struct cat_msg	*prev, *next;

	if (current_msg == NULL) {
		if (current_set == NULL)
			find_set(current_set_no);
		current_msg = current_set->first_msg;
		if (current_msg == NULL) {
			current_msg = new_msg(no, len, text);
			current_set->first_msg = current_msg;
			return;
		}
	}
	if (current_msg->msg_no >= no) {
		current_msg = current_set->first_msg;
		if (current_msg->msg_no > no) {
			current_msg = new_msg(no, len, text);
			current_msg->next = current_set->first_msg;
			current_set->first_msg->prev = current_msg;
			current_set->first_msg = current_msg;
			return;
		}
		if (current_msg->msg_no == no) {
			current_msg = new_msg(no, len, text);
			current_msg->next = current_set->first_msg->next;
			if (current_set->first_msg->next)
				current_set->first_msg->next->prev =
					current_msg;
			FREE(current_set->first_msg);
			current_set->first_msg = current_msg;
			return;
		}
	}
	while (current_msg->next && current_msg->next->msg_no < no)
		current_msg = current_msg->next;

	/*
	 * if the same msg number is found, then delte the message and
	 * insert the new message. This is same as replacing message.
	 */
	if (current_msg->next && current_msg->next->msg_no == no) {
		current_msg = current_msg->next;
		prev = current_msg->prev;
		next = current_msg->next;
		FREE(current_msg);
	} else {
		prev = current_msg;
		next = current_msg->next;
	}

	current_msg = new_msg(no, len, text);
	current_msg->prev = prev;
	current_msg->next = next;
	if (prev)
		prev->next = current_msg;
	else
		current_set->first_msg = current_msg;
	if (next)
		next->prev = current_msg;
}

void
delete_msg(no)
	int		no;
{
	struct cat_set	*p = current_set;
	struct cat_msg	*prev, *next;

	if (current_msg == NULL) {
		if (current_set == NULL)
			for (p = first_set; p && p->set_no < current_set_no;
							p = p->next)
				continue;
		if (p == NULL || p->set_no != current_set_no)
			return;
		current_set = p;
		current_msg = current_set->first_msg;
		if (current_msg == NULL)
			return;
	}
	if (current_msg->msg_no > no)
		current_msg = current_set->first_msg;

	while (current_msg && current_msg->msg_no != no)
		current_msg = current_msg->next;

	if (current_msg && current_msg->msg_no == no) {
		prev = current_msg->prev;
		next = current_msg->next;
		FREE(current_msg);
		if (prev) {
			current_msg = prev;
			prev->next = next;
		} else {
			current_set->first_msg = next;
			current_msg = next;
		}
		if (next)
			next->prev = prev;
	}
}

int
read_block(fd, p, n, pathname)
	int		fd;
	char	*p;
	int		n;
	char	*pathname;
{
	int		nbytes, bytes_read;

	if (n == 0)
		return (0);

	nbytes = 0;
	while (nbytes < n) {
		bytes_read = READ(fd, p + nbytes, n - nbytes);
		if (bytes_read < 0) {
			if (errno != EINTR) {
				FPRINTF(stderr, MSG(3), pathname);
				perror("");
				exit(1);
			}
		} else if (bytes_read == 0)
			break;
		else
			nbytes += bytes_read;
	}

	return (nbytes);
}

/*
 * Check if catalog file read is valid
 *
 */
int
cat_ok(cat)
	char	*cat;
{
	int		i, j;
	int		nmsgs;
	int		msg_no;
	struct	_cat_msg_hdr	*msg;
	int		set_no;
	int		first_msg_hdr;
	struct	_cat_set_hdr	*set;

	set = (struct _cat_set_hdr *) cat;
	set_no = 0;
	for (i = 0; i < hdr.__nsets; ++set, ++i) {
		if (set->__set_no < set_no)
			return (0);
		set_no = set->__set_no;
		nmsgs = set->__nmsgs;
		if (nmsgs < 0)
			return (0);
		if (nmsgs == 0)
			continue;
		first_msg_hdr = set->__first_msg_hdr;
		if (first_msg_hdr < 0)
			return (0);
		if (hdr.__msg_hdr_offset + (first_msg_hdr + nmsgs) *
					_CAT_MSG_HDR_SIZE > hdr.__mem)
			return (0);

		msg = (struct _cat_msg_hdr *) (cat + hdr.__msg_hdr_offset) +
						first_msg_hdr;
		msg_no = 0;
		for (j = 0; j < nmsgs; ++msg, ++j) {
			if (msg->__msg_no < msg_no)
				return (0);
			msg_no = msg->__msg_no;
			if (msg->__msg_offset < 0)
				return (0);
			if (hdr.__msg_text_offset + msg->__msg_offset +
						msg->__msg_len > hdr.__mem)
				return (0);
		}
	}

	return (1);
}

/*
 * convert a chunk of catalog file into double linked list format
 */
void
initcat(cat)
	char	*cat;
{
	int		i, j;
	int		nmsgs;
	struct	_cat_set_hdr	*set;
	struct	_cat_msg_hdr	*msg;

	set = (struct _cat_set_hdr *) cat;
	for (i = 0; i < hdr.__nsets; ++set, ++i) {
		nmsgs = set->__nmsgs;
		if (nmsgs == 0)
			continue;
		find_set(set->__set_no);
		msg = (struct _cat_msg_hdr *) (cat + hdr.__msg_hdr_offset)
			+ set->__first_msg_hdr;
		current_msg = current_set->first_msg;
		for (j = 0; j < nmsgs; ++msg, ++j) {
			insert_msg(msg->__msg_no, msg->__msg_len,
			    cat + hdr.__msg_text_offset + msg->__msg_offset);
		}
	}
}

/*
 * read a catalog file in a chunk and convert it to double linked list.
 */
void
readcat(fd, pathname)
	int		fd;
	char	*pathname;
{
	int		i;
	char	*cat;

	i = read_block(fd, (char *) &hdr, _CAT_HDR_SIZE, pathname);
	if (i == 0)
		return;

	if (i >= 4 && hdr.__hdr_magic != _CAT_MAGIC) {
		FPRINTF(stderr, MSG(4), hdr.__hdr_magic);
		exit(1);
	}
	if (i < _CAT_HDR_SIZE || hdr.__nsets < 0) {
		FPRINTF(stderr, MSG(5), pathname);
		exit(1);
	}
	if (hdr.__nsets == 0)
		return;

	if (hdr.__mem < 0 ||
	    hdr.__msg_hdr_offset < 0 ||
	    hdr.__msg_text_offset < 0 ||
	    hdr.__mem < hdr.__nsets * _CAT_SET_HDR_SIZE ||
	    hdr.__mem < hdr.__msg_hdr_offset ||
	    hdr.__mem < hdr.__msg_text_offset) {
		FPRINTF(stderr, MSG(5), pathname);
		exit(1);
	}
	cat = MALLOC(hdr.__mem);
	if (cat == NULL) {
		FPRINTF(stderr, MSG(6));
		exit(1);
	}
	i = read_block(fd, cat, hdr.__mem, pathname);
	if (i < hdr.__mem || !cat_ok(cat)) {
		FPRINTF(stderr, MSG(5), pathname);
		exit(1);
	}
	initcat(cat);

	FREE(cat);
}

/*
 * Extend the memory in 1000 byte chunks whenever runs out of text space.
 */
void
extend_text()
{
	text_size += 1000;
	if (text)
		text = REALLOC(text, text_size);
	else
		text = MALLOC(text_size);
	if (text == NULL) {
		FPRINTF(stderr, MSG(6));
		exit(1);
	}
}

int
get_number(fp, c)
	FILE	*fp;
	int		c;
{
	int		i, n;
	char	*s, *t;

	i = 0;
	do {
		while (i >= text_size)
			extend_text();
		text[i] = c;
		++i;
		c = getc(fp);
	}
	while (isdigit(c));
	(void) ungetc(c, fp);

	while (i >= text_size)
		extend_text();
	text[i] = NUL;

	for (s = text; *s == '0'; ++s)
		continue;

	n = 0;
	for (t = s; isdigit(*t); ++t) {
		if (n > INT_MAX / 10 ||
			(n == INT_MAX / 10 && *t > '0' + INT_MAX % 10)) {
			FPRINTF(stderr, MSG(9), msgfname, lineno, s);
			exit(1);
		}
		n = 10 * n + (*t - '0');
	}

	return (n);
}

void
get_text(fp)
	FILE	*fp;
{
	int		c;
	int		n;

	text_len = 0;
	c = fgetwc(fp);
	if (quoting && c == quote) {	/* quote is used */
		c = fgetwc(fp);
		while (c != quote) {
			if (c == NEWLINE || c == EOF) {
				FPRINTF(stderr, MSG(12), msgfname, lineno,
								quote);
				exit(1);
			}
			if (c == REVERSE_SOLIDUS) {
				c = fgetwc(fp);
				switch (c) {
				case EOF:
					FPRINTF(stderr, MSG(12), msgfname,
						lineno, quote);
					exit(1);
					break;
				case NEWLINE:
					++lineno;
					c = fgetwc(fp);
					continue;
					/* NOTREACHED */
					break;
				case '0':
				case '1':
				case '2':
				case '3':
				case '4':
				case '5':
				case '6':
				case '7':
					n = (c - '0');
					c = fgetwc(fp);
					if (c >= '0' && c <= '7') {
						n = 8 * n + (c - '0');
						c = fgetwc(fp);
						if (c >= '0' && c <= '7')
							n = 8 * n + (c - '0');
						else
							(void) ungetwc(c, fp);
					} else
						(void) ungetwc(c, fp);
					if (n > UCHAR_MAX) {
						FPRINTF(stderr, MSG(13),
							msgfname, lineno, n);
						exit(1);
					}
					c = n;
					break;

				case 'n':
					c = NEWLINE;
					break;

				case 't':
					c = TAB;
					break;

				case 'v':
					c = VTAB;
					break;

				case 'b':
					c = BS;
					break;

				case 'r':
					c = CR;
					break;

				case 'f':
					c = FF;
					break;
				}
			}
			while ((text_len + (int)MB_CUR_MAX + 1) >= text_size)
				extend_text();
			if ((n = wctomb(&text[text_len], c)) > 0)
				text_len += n;
			c = fgetwc(fp);
		}

		while ((text_len + 1) >= text_size)
			extend_text();
		text[text_len] = '\0';
		++text_len;

		do {
			c = getc(fp);
		} while (c == SPACE || c == TAB);
		if (c == NEWLINE) {
			++lineno;
			return;
		}
		if (c == EOF) {
			ateof = 1;
			return;
		}
		FPRINTF(stderr, MSG(14), msgfname, lineno);
		exit(1);
	}

	while (c != NEWLINE && c != EOF) {	/* quote is not used */
		if (c == REVERSE_SOLIDUS) {
			c = fgetwc(fp);
			switch (c) {
			case EOF:
				return;

			case NEWLINE:
				++lineno;
				c = fgetwc(fp);
				continue;

			case '0':
			case '1':
			case '2':
			case '3':
			case '4':
			case '5':
			case '6':
			case '7':
				n = (c - '0');
				c = fgetwc(fp);
				if (c >= '0' && c <= '7') {
					n = 8 * n + (c - '0');
					c = fgetwc(fp);
					if (c >= '0' && c <= '7')
						n = 8 * n + (c - '0');
					else
						(void) ungetwc(c, fp);
				} else
					(void) ungetwc(c, fp);
				if (n > UCHAR_MAX) {
					FPRINTF(stderr, MSG(13), msgfname,
							lineno, n);
					exit(1);
				}
				c = n;
				break;

			case 'n':
				c = NEWLINE;
				break;

			case 't':
				c = TAB;
				break;

			case 'v':
				c = VTAB;
				break;

			case 'b':
				c = BS;
				break;

			case 'r':
				c = CR;
				break;

			case 'f':
				c = FF;
				break;
			}
		}
		while ((text_len + (int)MB_CUR_MAX + 1) >= text_size)
			extend_text();
		if ((n = wctomb(&text[text_len], c)) > 0)
			text_len += n;
		c = fgetwc(fp);
	}

	while ((text_len + 1) >= text_size)
		extend_text();
	text[text_len] = '\0';
	++text_len;

	if (c == NEWLINE)
		++lineno;
	else
		ateof = 1;
}

/*
 * This routine handles $ <comment>, $set, $delset, $quote
 */
void
directive(fp)
	FILE	*fp;
{
	int		c;
	int		n;

	c = fgetwc(fp);
	if (c == SPACE || c == TAB) {	/* $ <comment */
		do {
			c = fgetwc(fp);
		} while (c != NEWLINE && c != EOF);
	}
	if (c == NEWLINE) {
		++lineno;
		return;
	}
	if (c == EOF) {
		ateof = 1;
		return;
	}
	text_len = 1;
	while (text_len >= text_size)
		extend_text();
	text[0] = DOLLAR;
	while (isascii(c) && isalpha(c)) {
		while ((text_len + 1) >= text_size)
			extend_text();
		text[text_len] = c;
		++text_len;
		c = fgetwc(fp);
	}

	while ((text_len + 1) >= text_size)
		extend_text();
	text[text_len] = NUL;

	if (strcmp(text, "$set") == 0) {
		while (c == SPACE || c == TAB)
			c = fgetwc(fp);
		if (!isascii(c) || !isdigit(c)) {
			FPRINTF(stderr, MSG(16), msgfname, lineno);
			exit(1);
		}
		n = get_number(fp, c);
		if (n == 0) {
			FPRINTF(stderr, MSG(17), msgfname, lineno);
			exit(1);
		}
		if (n > NL_SETMAX) {
			FPRINTF(stderr, MSG(18), msgfname, lineno,
						n, NL_SETMAX);
		}
		find_set(n);
		do {	/* skip comment */
			c = getc(fp);
		} while (c != NEWLINE && c != EOF);
		if (c == NEWLINE)
			++lineno;
		else
			ateof = 1;
		return;
	} else if (strcmp(text, "$delset") == 0) {
		while (c == SPACE || c == TAB)
			c = fgetwc(fp);
		if (!isascii(c) || !isdigit(c)) {
			FPRINTF(stderr, MSG(20), msgfname, lineno);
			exit(1);
		}
		n = get_number(fp, c);
		if (n == 0) {
			FPRINTF(stderr, MSG(17), msgfname, lineno);
			exit(1);
		}
		if (n > NL_SETMAX) {
			FPRINTF(stderr, MSG(18), msgfname, lineno,
						n, NL_SETMAX);
		}
		delete_set(n);
		do {	/* skip comment */
			c = getc(fp);
		} while (c != NEWLINE && c != EOF);
		if (c == NEWLINE)
			++lineno;
		else
			ateof = 1;
		return;
	} else if (strcmp(text, "$quote") == 0) {
		if (c == NEWLINE) {
			quoting = 0;
			++lineno;
			return;
		}
		if (c == EOF) {
			quoting = 0;
			ateof = 1;
			return;
		}
		if (c == SPACE || c == TAB)
			c = fgetwc(fp);
		if (c == NEWLINE) {
			quoting = 0;
			++lineno;
			return;
		}
		if (c == EOF) {
			quoting = 0;
			ateof = 1;
			return;
		}
		quoting = 1;
		quote = c;
		do {	/* skip comment */
			c = getc(fp);
		} while (c == SPACE || c == TAB);
		if (c == NEWLINE) {
			++lineno;
			return;
		}
		if (c == EOF) {
			ateof = 1;
			return;
		}
		FPRINTF(stderr, MSG(15), msgfname, lineno);
		exit(1);
	} else {
		FPRINTF(stderr, MSG(19), msgfname, lineno, text);
		exit(1);
	}
}

/*
 * Read message source file and update double linked list message catalog.
 */
void
read_msgfile(fp, pathname)
	FILE	*fp;
	char	*pathname;
{
	int		c;
	int		no;

	ateof = 0;
	msgfname = pathname;
	lineno = 1;
	quoting = 0;
	current_set_no = NL_SETD;
	current_set = NULL;
	current_msg = NULL;

	for (;;) {
		if (ateof)
			return;
		do {
			c = fgetwc(fp);
		} while (c == SPACE || c == TAB);
		if (c == DOLLAR) {
			directive(fp);
			continue;
		}

		if (isascii(c) && isdigit(c)) {
			no = get_number(fp, c);
			if (no == 0) {
				FPRINTF(stderr, MSG(10), msgfname, lineno);
				exit(1);
			}
			if (no > NL_MSGMAX) {
				FPRINTF(stderr, MSG(11), msgfname,
					lineno, no, NL_MSGMAX);
			}
			c = fgetwc(fp);
			if (c == NEWLINE || c == EOF) {
				delete_msg(no);
				if (c == NEWLINE)
					++lineno;
				else
					return;
				continue;
			} else {
				if (c != SPACE && c != TAB)
					(void) ungetwc(c, fp);
				get_text(fp);
				insert_msg(no, text_len, text);
				continue;
			}
		}

		if (c == NEWLINE) {
			++lineno;
			continue;
		}
		if (c == EOF)
			return;

		FPRINTF(stderr, MSG(22), msgfname, lineno);
		exit(1);
	}
}

/*
 * Write double linked list to the file.
 * It first converts a linked list to one chunk of memory and
 * write it to file.
 */
void
writecat(fd, pathname)
	int		fd;
	char	*pathname;
{
	int		i, n;
	int		nsets;
	int		mem;
	int		nmsgs;
	int		text_size;
	int		first_msg_hdr;
	int		msg_offset;
	unsigned	nbytes;
	char	*cat;
	struct	_cat_hdr	*hdrp;
	struct	cat_set		*setp;
	struct	cat_msg		*msgp;
	struct	_cat_set_hdr	*set;
	struct	_cat_msg_hdr	*msg;
	char	*text;

	/* compute number of sets, number of messages, the total text size */
	nsets = 0;
	nmsgs = 0;
	text_size = 0;
	for (setp = first_set; setp; setp = setp->next) {
		++nsets;
		for (msgp = setp->first_msg; msgp; msgp = msgp->next) {
			++nmsgs;
			text_size += msgp->msg_len;
		}
	}

	mem = nsets * _CAT_SET_HDR_SIZE + nmsgs * _CAT_MSG_HDR_SIZE + text_size;
	n = _CAT_HDR_SIZE + mem;
	cat = MALLOC(n);
	if (cat == 0) {
		FPRINTF(stderr, MSG(6));
		exit(1);
	}
	MEMSET(cat, 0, n);

	hdrp = (struct _cat_hdr *) cat;
	hdrp->__hdr_magic = _CAT_MAGIC;
	hdrp->__nsets = nsets;
	hdrp->__mem = mem;
	hdrp->__msg_hdr_offset = nsets * _CAT_SET_HDR_SIZE;
	hdrp->__msg_text_offset = nsets * _CAT_SET_HDR_SIZE +
				nmsgs * _CAT_MSG_HDR_SIZE;

	set = (struct _cat_set_hdr *) (cat + _CAT_HDR_SIZE);
	msg = (struct _cat_msg_hdr *) (set + nsets);
	text = (char *) (msg + nmsgs);

	/* convert linked list to one chunk of memory */
	first_msg_hdr = 0;
	msg_offset = 0;
	for (setp = first_set; setp; ++set, setp = setp->next) {
		set->__set_no = setp->set_no;
		set->__first_msg_hdr = first_msg_hdr;
		nmsgs = 0;
		for (msgp = setp->first_msg; msgp; ++msg, msgp = msgp->next) {
			++nmsgs;
			msg->__msg_no = msgp->msg_no;
			msg->__msg_len = msgp->msg_len;
			msg->__msg_offset = msg_offset;
			if (msgp->msg_len > 0) {
				MEMCPY(text, msgp->s, msgp->msg_len);
				text += msgp->msg_len;
				msg_offset += msgp->msg_len;
			}
		}
		set->__nmsgs = nmsgs;
		first_msg_hdr += nmsgs;
	}

	/* write one chunk of memory to file */
	nbytes = 0;
	while (nbytes < n) {
		i = write(fd, cat + nbytes, n - nbytes);
		if (i < 0) {
			if (errno != EINTR) {
				FPRINTF(stderr, MSG(8), pathname);
				perror("");
				exit(1);
			}
		} else {
			nbytes += n;
		}
	}

	free(cat);
}

int
main(argc, argv)
	int		argc;
	char	*argv[];
{
	int		i;
	int		cat_exists;

	(void) setlocale(LC_ALL, "");
#if !defined(TEXT_DOMAIN)		/* Should be defined by cc -D */
#define	TEXT_DOMAIN	"SYS_TEST"	/* Use this only if it weren't */
#endif
	(void) textdomain(TEXT_DOMAIN);

	if (argc < 3) {
		FPRINTF(stderr, MSG(1));
		exit(1);
	}
	catfname = argv[1];
	cat_exists = 0;
	if ((*catfname == '-') && (*(catfname + 1) == '\0')) {
		catfd = 1;				/* Use stdout */
	} else {
		catfd = open(catfname, O_WRONLY | O_CREAT | O_EXCL, 0666);
		if (catfd < 0) {	/* file exists */
			if (errno != EEXIST ||
			    (catfd = open(catfname, O_RDWR)) < 0) {
				/* cannot open file */
				FPRINTF(stderr, MSG(2), catfname);
				perror("");
				exit(1);
			}
			cat_exists = 1;
			/* read catalog file into memory */
			readcat(catfd, catfname);
			if (lseek(catfd, 0L, 0) < 0) {
				FPRINTF(stderr, MSG(7), catfname);
				perror("");
				exit(1);
			}
		}
	}

	/* process all message source files */
	if ((**(argv + 2) == '-') && (*(*(argv + 2) + 1) == '\0')) {
		if (argc != 3) {
			FPRINTF(stderr, MSG(1));
			exit(1);
		} else {
			read_msgfile(stdin, MSG(21));
		}
	} else {
		for (i = 2; i < argc; ++i) {
			FILE	*fp;
			fp = fopen(*(argv + i), "r");
			if (fp == NULL) {
				FPRINTF(stderr, MSG(2), *(argv + i));
				perror("");
				exit(1);
			}
			read_msgfile(fp, *(argv + i));
			(void) fclose(fp);
		}
	}

	if (cat_exists)
		(void) ftruncate(catfd, 0L);

	/* write catalog to file */
	writecat(catfd, catfname);
	return (0);
}