xref: /onnv-gate/usr/src/cmd/sgs/tools/common/sgsmsg.c (revision 5892:b863dde33f1b)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (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 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * sgsmsg generates several message files from an input template file.  Messages
 * are constructed for use with gettext(3i) - the default - or catgets(3c).  The
 * files generate are:
 *
 * msg.h	a header file containing definitions for each message.  The -h
 *		option triggers the creation of these definitions and specifies
 *		the name to use.
 *
 * msg.c	a data array of message strings.  The msg.h definitions are
 *		offsets into this array.  The -d option triggers the creation of
 *		these definitions and specifies the name to use.
 *
 * messages	a message file suitable for catgets(3c) or gettext(3i) use.  The
 *		-m option triggers this output and specifies the filename to be
 *		used.
 *
 * The template file is processed based on the first character of each line:
 *
 * # or $	entries are copied (as is) to the message file (messages).
 *
 * @ token(s)	entries are translated.  Two translations are possible dependent
 *		on whether one or more tokens are supplied:
 *
 *		A single token is interpreted as one of two reserved message
 *		output indicators, or a message identifier.  The reserved output
 *		indicator _START_ enables output to the message file - Note that
 *		the occurance of any other @ token will also enable message
 *		output.  The reserved output indicator _END_ disables output to
 *		the message file.  The use of these two indicators provides for
 *		only those message strings that require translation to be output
 *		to the message file.
 *
 *		Besides the reserved output indicators, a single token is taken
 *		to be a message identifier which will be subsituted for a
 *		`setid' for catgets(3c) output, or a `domain' name for
 *		gettext(3i) output.  This value is determine by substituting the
 *		token for the associated definition found in the message
 *		identifier file (specified with the -i option).
 *
 *		Multiple tokens are taken to be a message definition followed by
 *		the associated message string.  The message string is copied to
 *		the data array being built in msg.c.  The index into this array
 *		becomes the `message' identifier created in the msg.h file.
 */
#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include	<fcntl.h>
#include	<stdlib.h>
#include	<stdio.h>
#include	<unistd.h>
#include	<limits.h>
#include	<string.h>
#include	<ctype.h>
#include	<errno.h>
#include	<sys/param.h>

#include	<sgs.h>
#include	<_string_table.h>

/*
 * Define any error message strings.
 */
static const char
	* Errmsg_malt =	"sgsmsg: file %s: line %d: malformed input "
			"at line\n",
	* Errmsg_nmem =	"sgsmsg: memory allocation failed: %s\n",
	* Errmsg_opne =	"sgsmsg: file %s: open failed: %s\n",
	* Errmsg_wrte =	"sgsmsg: file %s: write failed: %s\n",
	* Errmsg_read =	"sgsmsg: file %s: read failed %s\n",
	* Errmsg_stnw =	"sgsmsg: st_new(): failed: %s\n",
	* Errmsg_stin =	"sgsmsg: Str_tbl insert failed: %s\n",
	* Errmsg_mnfn =	"sgsmsg: message not found in Str_tbl: %s\n",
	* Errmsg_use  =	"usage: sgsmsg [-clv] [-d mesgdata] [-h mesgdefs] "
			"[-m messages] [-n name] [-i mesgident] file ...\n";

/*
 * Define all output filenames and associated descriptors.
 */
static FILE	*fddefs, *fddata, *fdmsgs, *fdmids, *fddesc;
static char	*fldefs, *fldata, *flmsgs, *flmids, *fldesc;
static FILE	*fdlint;
static char	fllint[MAXPATHLEN];

static uint_t		vflag;	/* verbose flag */
static Str_tbl		*stp;	/* string table */

/*
 * Define any default strings.
 */
static const char
	*nmlint =	"/tmp/sgsmsg.lint",
	*interface =	"sgs_msg",
	*start =	"_START_",
	*end =		"_END_";

/*
 * Define any default flags and data items.
 */
static int	cflag = 0, lflag = 0, prtmsgs = 0, line, ptr = 1, msgid = 0;
static char	*mesgid = 0, *setid = 0, *domain = 0;

typedef struct msg_string {
	char			*ms_defn;
	char			*ms_message;
	struct msg_string	*ms_next;
} msg_string;

static msg_string	*msg_head;
static msg_string	*msg_tail;

/*
 * message_append() is responsible for both inserting strings into
 * the master Str_tbl as well as maintaining a list of the
 * DEFINITIONS associated with each string.
 *
 * The list of strings is traversed at the end once the full
 * Str_tbl has been constructed - and string offsets can be
 * assigned.
 */
static void
message_append(const char *defn, const char *message)
{
	msg_string	*msg;
	if ((msg = calloc(sizeof (msg_string), 1)) == 0) {
		(void) fprintf(stderr, Errmsg_nmem, strerror(errno));
		exit(1);
	}

	/*
	 * Initialize the string table.
	 */
	if ((stp == 0) && ((stp = st_new(FLG_STNEW_COMPRESS)) == NULL)) {
		(void) fprintf(stderr, Errmsg_stnw, strerror(errno));
		exit(1);
	}


	if ((msg->ms_defn = strdup(defn)) == 0) {
		(void) fprintf(stderr, Errmsg_nmem, strerror(errno));
		exit(1);
	}
	if ((msg->ms_message = strdup(message)) == 0) {
		(void) fprintf(stderr, Errmsg_nmem, strerror(errno));
		exit(1);
	}

	if (st_insert(stp, msg->ms_message) == -1) {
		(void) fprintf(stderr, Errmsg_stin,
		    message);
		exit(1);
	}

	if (msg_head == 0) {
		msg_head = msg_tail = msg;
		return;
	}
	msg_tail->ms_next = msg;
	msg_tail = msg;
}

/*
 * Initialize a setid value.  Given a setid definition determine its numeric
 * value from the specified message identifier file (specified with the -i
 * option).  Return a pointer to the numeric string.
 */
static int
getmesgid(char *id)
{
	char	*buffer, *token, *_mesgid = 0, *_setid = 0, *_domain = 0;

	/*
	 * If we're being asked to interpret a message id but the user didn't
	 * provide the required message identifier file (-i option) we're in
	 * trouble.
	 */
	if (flmids == 0) {
		(void) fprintf(stderr, "sgsmsg: file %s: line %d: mesgid %s: "
		    "unable to process mesgid\n\t"
		    "no message identifier file specified "
		    "(see -i option)\n", fldesc, line, id);
		return (1);
	}

	if ((buffer = malloc(LINE_MAX)) == 0) {
		(void) fprintf(stderr, Errmsg_nmem, strerror(errno));
		return (1);
	}

	/*
	 * Read the message identifier file and locate the required mesgid.
	 */
	rewind(fdmids);
	while (fgets(buffer, LINE_MAX, fdmids) != NULL) {
		if ((token = strstr(buffer, id)) == NULL)
			continue;

		/*
		 * Establish individual strings for the mesgid, setid and domain
		 * values.
		 */
		_mesgid = token;
		while (!(isspace(*token)))
			token++;
		*token++ = 0;

		while (isspace(*token))
			token++;
		_setid = token;
		while (!(isspace(*token)))
			token++;
		*token++ = 0;

		while (isspace(*token))
			token++;
		_domain = token;
		while (!(isspace(*token)))
			token++;
		*token = 0;
		break;
	}

	/*
	 * Did we find a match?
	 */
	if ((_mesgid == 0) || (_setid == 0) || (_domain == 0)) {
		(void) fprintf(stderr, "sgsmsg: file %s: line %d: mesgid %s: "
		    "unable to process mesgid\n\t"
		    "identifier does not exist in file %s\n",
		    fldesc, line, id, flmids);
		return (1);
	}

	/*
	 * Have we been here before?
	 */
	if (mesgid) {
		if (cflag == 1) {
			/*
			 * If we're being asked to process more than one mesgid
			 * warn the user that only one mesgid can be used for
			 * the catgets(3c) call.
			 */
			(void) fprintf(stderr, "sgsmsg: file %s: line %d: "
			    "setid %s: warning: multiple mesgids "
			    "encountered\n\t"
			    "last setting used in messaging code\n",
			    fldesc, line, id);
		}
	}

	mesgid = _mesgid;
	setid = _setid;
	domain = _domain;

	/*
	 * Generate the message file output (insure output flag is enabled).
	 */
	if (prtmsgs != -1)
		prtmsgs = 1;
	if (fdmsgs && (prtmsgs == 1)) {
		if (cflag == 1) {
			if (fprintf(fdmsgs, "$quote \"\n$set %s\n",
			    setid) < 0) {
				(void) fprintf(stderr, Errmsg_wrte, flmsgs,
				    strerror(errno));
				return (1);
			}
		} else {
			if (fprintf(fdmsgs, "domain\t\"%s\"\n", domain) < 0) {
				(void) fprintf(stderr, Errmsg_wrte, flmsgs,
				    strerror(errno));
				return (1);
			}
		}
	}

	/*
	 * For catgets(3c) output generate a setid definition in the message
	 * definition file.
	 */
	if (fddefs && (cflag == 1) &&
	    (fprintf(fddefs, "#define\t%s\t%s\n\n", mesgid, setid) < 0)) {
		(void) fprintf(stderr, Errmsg_wrte, fldefs, strerror(errno));
		return (1);
	}

	return (0);
}

/*
 * Dump contents of String Table to standard out
 */
static void
dump_stringtab(Str_tbl *stp)
{
	uint_t	cnt;

	if ((stp->st_flags & FLG_STTAB_COMPRESS) == 0) {
		(void) printf("string table full size: %ld: uncompressed\n",
		    stp->st_fullstrsize);
		return;
	}

	(void) printf("string table full size: %ld compressed down to: %ld\n\n",
	    stp->st_fullstrsize, stp->st_strsize);
	(void) printf("string table compression information [%d buckets]:\n",
	    stp->st_hbckcnt);

	for (cnt = 0; cnt < stp->st_hbckcnt; cnt++) {
		Str_hash	*sthash = stp->st_hashbcks[cnt];

		if (sthash == 0)
			continue;

		(void) printf(" bucket: [%d]\n", cnt);

		while (sthash) {
			size_t	stroff = sthash->hi_mstr->sm_strlen -
			    sthash->hi_strlen;

			if (stroff == 0) {
				(void) printf("  [%ld]: '%s'  <master>\n",
				    sthash->hi_refcnt, sthash->hi_mstr->sm_str);
			} else {
				(void) printf("  [%ld]: '%s'  <suffix of: "
				    "'%s'>\n", sthash->hi_refcnt,
				    &sthash->hi_mstr->sm_str[stroff],
				    sthash->hi_mstr->sm_str);
			}
			sthash = sthash->hi_next;
		}
	}
}

/*
 * Initialize the message definition header file stream.
 */
static int
init_defs(void)
{
	static char	guard[FILENAME_MAX + 6];
	char		*optr;
	const char	*iptr, *_ptr;

	/*
	 * Establish a header guard name using the files basename.
	 */
	for (iptr = 0, _ptr = fldefs; _ptr && (*_ptr != '\0'); _ptr++) {
		if (*_ptr == '/')
			iptr = _ptr + 1;
	}
	if (iptr == 0)
		iptr = fldefs;

	optr = guard;
	for (*optr++ = '_'; iptr && (*iptr != '\0'); iptr++, optr++) {
		if (*iptr == '.') {
			*optr++ = '_';
			*optr++ = 'D';
			*optr++ = 'O';
			*optr++ = 'T';
			*optr = '_';
		} else
			*optr = toupper(*iptr);
	}

	if (fprintf(fddefs, "#ifndef\t%s\n#define\t%s\n\n", guard, guard) < 0) {
		(void) fprintf(stderr, Errmsg_wrte, fldefs, strerror(errno));
		return (1);
	}

	if (fprintf(fddefs, "#ifndef\t__lint\n\n") < 0) {
		(void) fprintf(stderr, Errmsg_wrte, fldefs, strerror(errno));
		return (1);
	}

	/*
	 * add "typedef int	Msg;"
	 */
	if (fprintf(fddefs, "typedef int\tMsg;\n\n") < 0) {
		(void) fprintf(stderr, Errmsg_wrte, fldefs, strerror(errno));
		return (1);
	}

	/*
	 * If the associated data array is global define a prototype.
	 * Define a macro to access the array elements.
	 */
	if (lflag == 0) {
		if (fprintf(fddefs, "extern\tconst char\t__%s[];\n\n",
		    interface) < 0) {
			(void) fprintf(stderr, Errmsg_wrte, fldefs,
			    strerror(errno));
			return (1);
		}
	}
	if (fprintf(fddefs, "#define\tMSG_ORIG(x)\t&__%s[x]\n\n",
	    interface) < 0) {
		(void) fprintf(stderr, Errmsg_wrte, fldefs, strerror(errno));
		return (1);
	}

	/*
	 * Generate a prototype to access the associated data array.
	 */
	if (fprintf(fddefs, "extern\tconst char *\t_%s(Msg);\n\n",
	    interface) < 0) {
		(void) fprintf(stderr, Errmsg_wrte, fldefs, strerror(errno));
		return (1);
	}
	if (fprintf(fddefs, "#define\tMSG_INTL(x)\t_%s(x)\n\n",
	    interface) < 0) {
		(void) fprintf(stderr, Errmsg_wrte, fldefs, strerror(errno));
		return (1);
	}

	return (0);
}


/*
 * Finish the message definition header file.
 */
static int
fini_defs(void)
{
	if (fprintf(fddefs, "\n#else\t/* __lint */\n\n") < 0) {
		(void) fprintf(stderr, Errmsg_wrte, fldefs, strerror(errno));
		return (1);
	}

	/*
	 * When __lint is defined, Msg is a char *.  This allows lint to
	 * check our format strings against it's arguments.
	 */
	if (fprintf(fddefs, "\ntypedef char *\tMsg;\n\n") < 0) {
		(void) fprintf(stderr, Errmsg_wrte, fldefs, strerror(errno));
		return (1);
	}

	if (fprintf(fddefs, "extern\tconst char *\t_%s(Msg);\n\n",
	    interface) < 0) {
		(void) fprintf(stderr, Errmsg_wrte, fldefs, strerror(errno));
		return (1);
	}

	if (lflag == 0) {
		if (fprintf(fddefs, "extern\tconst char\t__%s[];\n\n",
		    interface) < 0) {
			(void) fprintf(stderr, Errmsg_wrte, fldefs,
			    strerror(errno));
			return (1);
		}
	}

	if (fprintf(fddefs,
	    "#define MSG_ORIG(x)\tx\n#define MSG_INTL(x)\tx\n") < 0) {
		(void) fprintf(stderr, Errmsg_wrte, fldefs, strerror(errno));
		return (1);
	}

	/*
	 * Copy the temporary lint defs file into the new header.
	 */
	if (fdlint) {
		long	size;
		char	*buf;

		size = ftell(fdlint);
		(void) rewind(fdlint);

		if ((buf = malloc(size)) == 0) {
			(void) fprintf(stderr, Errmsg_nmem, strerror(errno));
			return (1);
		}
		if (fread(buf, size, 1, fdlint) == 0) {
			(void) fprintf(stderr, Errmsg_read, fllint,
			    strerror(errno));
			return (1);
		}
		if (fwrite(buf, size, 1, fddefs) == 0) {
			(void) fprintf(stderr, Errmsg_wrte, fldefs,
			    strerror(errno));
			return (1);
		}
		(void) free(buf);
	}

	if (fprintf(fddefs, "\n#endif\t/* __lint */\n") < 0) {
		(void) fprintf(stderr, Errmsg_wrte, fldefs, strerror(errno));
		return (1);
	}

	if (fprintf(fddefs, "\n#endif\n") < 0) {
		(void) fprintf(stderr, Errmsg_wrte, fldefs, strerror(errno));
		return (1);
	}

	return (0);
}

/*
 * The entire messaging file has been scanned - and all strings have been
 * inserted into the string_table.  We can now walk the message queue
 * and create the '#define <DEFN>' for each string - with the strings
 * assigned offset into the string_table.
 */
static int
output_defs(void)
{
	msg_string	*msg;
	size_t		stbufsize;
	char		*stbuf;

	stbufsize = st_getstrtab_sz(stp);
	if ((stbuf = malloc(stbufsize)) == 0) {
		(void) fprintf(stderr, Errmsg_nmem, strerror(errno));
		exit(1);
	}
	(void) st_setstrbuf(stp, stbuf, stbufsize);
	for (msg = msg_head; msg; msg = msg->ms_next) {
		size_t	stoff;
		if ((st_setstring(stp, msg->ms_message, &stoff)) == -1) {
			(void) fprintf(stderr, Errmsg_mnfn, msg->ms_message);
			return (1);
		}
		if (fprintf(fddefs, "\n#define\t%s\t%ld\n",
		    msg->ms_defn, stoff) < 0) {
			(void) fprintf(stderr, Errmsg_wrte,
			    fldefs, strerror(errno));
			return (1);
		}
		if (fddefs && fprintf(fddefs, "#define\t%s_SIZE\t%d\n",
		    msg->ms_defn, strlen(msg->ms_message)) < 0) {
			(void) fprintf(stderr, Errmsg_wrte,
			    fldefs, strerror(errno));
			return (1);
		}
	}
	return (0);
}


/*
 * Finish off the data structure definition.
 */
static int
output_data(void)
{
	size_t		stbufsize;
	size_t		ndx;
	size_t		column = 1;
	const char	*stbuf;
	const char	*fmtstr;

	stbufsize = st_getstrtab_sz(stp);
	stbuf = st_getstrbuf(stp);

	assert(stbuf);

	/*
	 * Determine from the local flag whether the data declaration should
	 * be static.
	 */
	if (lflag)
		fmtstr = (const char *)"static const";
	else
		fmtstr = (const char *)"const";

	if (fprintf(fddata, "\n%s char __%s[%ld] = { ",
	    fmtstr, interface, stbufsize) < 0) {
		(void) fprintf(stderr, Errmsg_wrte, fldata, strerror(errno));
		return (1);
	}

	for (ndx = 0; ndx < (stbufsize - 1); ndx++) {
		if (column == 1) {
			if (fddata && fprintf(fddata,
			    "\n/* %4ld */ 0x%.2x,", ndx,
			    (unsigned char)stbuf[ndx]) < 0) {
				(void) fprintf(stderr, Errmsg_wrte,
				    fldata, strerror(errno));
				return (1);
			}
		} else {
			if (fddata && fprintf(fddata, "  0x%.2x,",
			    (unsigned char)stbuf[ndx]) < 0) {
				(void) fprintf(stderr, Errmsg_wrte,
				    fldata, strerror(errno));
				return (1);
			}
		}

		if (column++ == 10)
			column = 1;
	}

	if (column == 1)
		fmtstr = "\n\t0x%.2x };\n";
	else
		fmtstr = "  0x%.2x };\n";

	if (fprintf(fddata, fmtstr, (unsigned char)stbuf[stbufsize - 1]) < 0) {
		(void) fprintf(stderr, Errmsg_wrte, fldata, strerror(errno));
		return (1);
	}

	return (0);
}

static int
file()
{
	char	buffer[LINE_MAX], * token;
	uint_t	bufsize;
	char	*token_buffer;
	int	escape = 0;

	if ((token_buffer = malloc(LINE_MAX)) == 0) {
		(void) fprintf(stderr, Errmsg_nmem, strerror(errno));
		return (1);
	}
	bufsize = LINE_MAX;

	line = 1;

	while ((token = fgets(buffer, LINE_MAX, fddesc)) != NULL) {
		char	defn[PATH_MAX], * _defn, * str;
		int	len;

		switch (*token) {
		case '#':
		case '$':
			if (escape) {
				(void) fprintf(stderr, Errmsg_malt, fldesc,
				    line);
				return (1);
			}

			/*
			 * If a msgid has been output a msgstr must follow
			 * before we digest the new token.  A msgid is only set
			 * if fdmsgs is in use.
			 */
			if (msgid) {
				msgid = 0;
				if (fprintf(fdmsgs, "msgstr\t\"\"\n") < 0) {
					(void) fprintf(stderr, Errmsg_wrte,
					    flmsgs, strerror(errno));
					return (1);
				}
			}

			/*
			 * Pass lines directly through to the output message
			 * file.
			 */
			if (fdmsgs && (prtmsgs == 1)) {
				char	comment;

				if (cflag == 0)
					comment = '#';
				else
					comment = '$';

				if (fprintf(fdmsgs, "%c%s", comment,
				    ++token) < 0) {
					(void) fprintf(stderr, Errmsg_wrte,
					    flmsgs, strerror(errno));
					return (1);
				}
			}
			break;

		case '@':
			if (escape) {
				(void) fprintf(stderr, Errmsg_malt, fldesc,
				    line);
				return (1);
			}

			/*
			 * If a msgid has been output a msgstr must follow
			 * before we digest the new token.
			 */
			if (msgid) {
				msgid = 0;
				if (fprintf(fdmsgs, "msgstr\t\"\"\n") < 0) {
					(void) fprintf(stderr, Errmsg_wrte,
					    flmsgs, strerror(errno));
					return (1);
				}
			}

			/*
			 * Determine whether we have one or more tokens.
			 */
			token++;
			while (isspace(*token))		/* rid any whitespace */
				token++;
			_defn = token;			/* definition start */
			while (!(isspace(*token)))
				token++;
			*token++ = 0;

			while (isspace(*token))		/* rid any whitespace */
				token++;

			/*
			 * Determine whether the single token is one of the
			 * reserved message output delimiters otherwise
			 * translate it as a message identifier.
			 */
			if (*token == 0) {
				if (strcmp(_defn, start) == 0)
					prtmsgs = 1;
				else if (strcmp(_defn, end) == 0)
					prtmsgs = -1;
				else if (getmesgid(_defn) == 1)
					return (1);
				break;
			}

			/*
			 * Multiple tokens are translated by taking the first
			 * token as the message definition, and the rest of the
			 * line as the message itself.  A message line ending
			 * with an escape ('\') is expected to be continued on
			 * the next line.
			 */
			if (prtmsgs != -1)
				prtmsgs = 1;
			if (fdmsgs && (prtmsgs == 1)) {
				/*
				 * For catgets(3c) make sure a message
				 * identifier has been established (this is
				 * normally a domain for gettext(3i), but for
				 * sgsmsg use this could be argued as being
				 * redundent).  Also make sure that the message
				 * definitions haven't exceeeded the maximum
				 * value allowed by gencat(1) before generating
				 * any message file entries.
				 */
				if (cflag == 1) {
					if (setid == 0) {
						(void) fprintf(stderr, "file "
						    "%s: no message identifier "
						    "has been established\n",
						    fldesc);
						return (1);
					}
					if (ptr	> NL_MSGMAX) {
						(void) fprintf(stderr, "file "
						    "%s: message definition "
						    "(%d) exceeds allowable "
						    "limit (NL_MSGMAX)\n",
						    fldesc, ptr);
						return (1);
					}
				}

				/*
				 * For catgets(3c) write the definition and the
				 * message string to the message file.  For
				 * gettext(3i) write the message string as a
				 * mesgid - indicate a mesgid has been output
				 * so that a msgstr can follow.
				 */
				if (cflag == 1) {
					if (fprintf(fdmsgs, "%d\t%s", ptr,
					    token) < 0) {
						(void) fprintf(stderr,
						    Errmsg_wrte, flmsgs,
						    strerror(errno));
						return (1);
					}
				} else {
					if (fprintf(fdmsgs, "msgid\t\"") < 0) {
						(void) fprintf(stderr,
						    Errmsg_wrte, flmsgs,
						    strerror(errno));
						return (1);
					}
					msgid = 1;
				}
			}

			/*
			 * The message itself is a quoted string as this makes
			 * embedding spaces at the start (or the end) of the
			 * string very easy.
			 */
			if (*token != '"') {
				(void) fprintf(stderr, Errmsg_malt, fldesc,
				    line);
				return (1);
			}

			(void) strcpy(defn, _defn);

			/*
			 * Write the tag to the lint definitions.
			 */
			if (fdlint) {
				if (fprintf(fdlint, "\n#define\t%s\t",
				    _defn) < 0) {
					(void) fprintf(stderr, Errmsg_wrte,
					    fllint, strerror(errno));
					return (1);
				}
			}

			len = 0;

			/*
			 * Write each character of the message string to the
			 * data array.  Translate any escaped characters - use
			 * the same specially recognized characters as defined
			 * by gencat(1).
			 */
message:
			if (*token == '"') {
				if (fdlint &&
				    (fprintf(fdlint, "%c", *token) < 0)) {
					(void) fprintf(stderr, Errmsg_wrte,
					    fllint, strerror(errno));
					return (1);
				}
				token++;
			}
			while (*token) {
				char	_token;

				if ((*token == '\\') && (escape == 0)) {
					escape = 1;
					if (fdlint && (*(token + 1) != '\n') &&
					    fprintf(fdlint, "%c", *token) < 0) {
						(void) fprintf(stderr,
						    Errmsg_wrte, fllint,
						    strerror(errno));
						return (1);
					}
					token++;
					continue;
				}
				if (escape) {
					if (*token == 'n')
						_token = '\n';
					else if (*token == 't')
						_token = '\t';
					else if (*token == 'v')
						_token = '\v';
					else if (*token == 'b')
						_token = '\b';
					else if (*token == 'f')
						_token = '\f';
					else if (*token == '\\')
						_token = '\\';
					else if (*token == '"')
						_token = '"';
					else if (*token == '\n')
						break;
					else
						_token = *token;

					if (fdmsgs && (prtmsgs == 1) &&
					    (fprintf(fdmsgs, "\\") < 0)) {
						(void) fprintf(stderr,
						    Errmsg_wrte, flmsgs,
						    strerror(errno));
						return (1);
					}
				} else {
					/*
					 * If this is the trailing quote then
					 * thats the last of the message string.
					 * Eat up any remaining white space and
					 * unless an escape character is found
					 * terminate the data string with a 0.
					 */
					/* BEGIN CSTYLED */
					if (*token == '"') {
					    if (fdlint && (fprintf(fdlint,
						"%c", *token) < 0)) {
						(void) fprintf(stderr,
						    Errmsg_wrte, fllint,
						    strerror(errno));
						return (1);
					    }

					    if (fdmsgs && (prtmsgs == 1) &&
						(fprintf(fdmsgs, "%c",
						*token) < 0)) {
						(void) fprintf(stderr,
						    Errmsg_wrte, flmsgs,
						    strerror(errno));
						return (1);
					    }

					    while (*++token) {
						if (*token == '\n')
							break;
					    }
					    _token = '\0';
					} else
					    _token = *token;
					/* END CSTYLED */
				}

				if (fdmsgs && (prtmsgs == 1) &&
				    (fprintf(fdmsgs, "%c", *token) < 0)) {
					(void) fprintf(stderr, Errmsg_wrte,
					    flmsgs, strerror(errno));
					return (1);
				}

				if (fdlint && fprintf(fdlint,
				    "%c", *token) < 0) {
					(void) fprintf(stderr, Errmsg_wrte,
					    fllint, strerror(errno));
					return (1);
				}

				if (len >= bufsize) {
					bufsize += LINE_MAX;
					if ((token_buffer = realloc(
					    token_buffer, bufsize)) == 0) {
						(void) fprintf(stderr,
						    Errmsg_nmem,
						    strerror(errno));
						return (1);
					}
				}
				token_buffer[len] = _token;
				ptr++, token++, len++;
				escape = 0;

				if (_token == '\0')
					break;
			}

			/*
			 * After the complete message string has been processed
			 * (including its continuation beyond one line), create
			 * a string size definition.
			 */
			if (escape == 0) {
				const char *form = "#define\t%s_SIZE\t%d\n";

				token_buffer[len] = '\0';

				message_append(defn, token_buffer);

				if (fdlint && fprintf(fdlint, form, defn,
				    (len - 1)) < 0) {
					(void) fprintf(stderr, Errmsg_wrte,
					    fllint, strerror(errno));
					return (1);
				}
			}
			break;

		default:
			/*
			 * Empty lines are passed through to the message file.
			 */
			while (isspace(*token))
				token++;

			if (*token == 0) {
				if (msgid || (fdmsgs && (prtmsgs == 1))) {
					/*
					 * If a msgid has been output a msgstr
					 * must follow before we digest the new
					 * token.
					 */
					if (msgid) {
						msgid = 0;
						str = "msgstr\t\"\"\n\n";
					} else
						str = "\n";

					if (fprintf(fdmsgs, str) < 0) {
						(void) fprintf(stderr,
						    Errmsg_wrte, flmsgs,
						    strerror(errno));
						return (1);
					}
				}
				break;
			}

			/*
			 * If an escape is in effect then any tokens are taken
			 * to be message continuations.
			 */
			if (escape) {
				escape = 0;
				goto message;
			}

			(void) fprintf(stderr, "file %s: line %d: invalid "
			    "input does not start with #, $ or @\n", fldesc,
			    line);
			return (1);
		}
		line++;
	}

	free(token_buffer);

	return (0);
}

int
main(int argc, char ** argv)
{
	opterr = 0;
	while ((line = getopt(argc, argv, "cd:h:lm:n:i:v")) != EOF) {
		switch (line) {
		case 'c':			/* catgets instead of gettext */
			cflag = 1;
			break;
		case 'd':			/* new message data filename */
			fldata = optarg;	/*	(msg.c is default) */
			break;
		case 'h':			/* new message defs filename */
			fldefs = optarg;	/*	(msg.h is default) */
			break;
		case 'i':			/* input message ids from */
			flmids = optarg;	/*	from this file */
			break;
		case 'l':			/* define message data arrays */
			lflag = 1;		/*	to be local (static) */
			break;
		case 'm':			/* generate message database */
			flmsgs = optarg;	/*	to this file */
			break;
		case 'n':			/* new data array and func */
			interface = optarg;	/*	name (msg is default) */
			break;
		case 'v':
			vflag = 1;		/* set verbose flag */
			break;
		case '?':
			(void) fprintf(stderr, Errmsg_use, argv[0]);
			exit(1);
		default:
			break;
		}
	}

	/*
	 * Validate the we have been given at least one input file.
	 */
	if ((argc - optind) < 1) {
		(void) fprintf(stderr, Errmsg_use);
		exit(1);
	}

	/*
	 * Open all the required output files.
	 */
	if (fldefs) {
		if ((fddefs = fopen(fldefs, "w+")) == NULL) {
			(void) fprintf(stderr, Errmsg_opne, fldefs,
			    strerror(errno));
			return (1);
		}
	}
	if (fldata) {
		if (fldefs && (strcmp(fldefs, fldata) == 0))
			fddata = fddefs;
		else if ((fddata = fopen(fldata, "w+")) == NULL) {
			(void) fprintf(stderr, Errmsg_opne, fldata,
			    strerror(errno));
			return (1);
		}
	}
	if (fddefs && fddata) {
		(void) sprintf(fllint, "%s.%d", nmlint, (int)getpid());
		if ((fdlint = fopen(fllint, "w+")) == NULL) {
			(void) fprintf(stderr, Errmsg_opne, fllint,
			    strerror(errno));
			return (1);
		}
	}
	if (flmsgs) {
		if ((fdmsgs = fopen(flmsgs, "w+")) == NULL) {
			(void) fprintf(stderr, Errmsg_opne, flmsgs,
			    strerror(errno));
			return (1);
		}
	}
	if (flmids) {
		if ((fdmids = fopen(flmids, "r")) == NULL) {
			(void) fprintf(stderr, Errmsg_opne, flmids,
			    strerror(errno));
			return (1);
		}
	}


	/*
	 * Initialize the message definition and message data streams.
	 */
	if (fddefs) {
		if (init_defs())
			return (1);
	}

	/*
	 * Read the input message file, and for each line process accordingly.
	 */
	for (; optind < argc; optind++) {
		int	err;

		fldesc = argv[optind];

		if ((fddesc = fopen(fldesc, "r")) == NULL) {
			(void) fprintf(stderr, Errmsg_opne, fldesc,
			    strerror(errno));
			return (1);
		}
		err = file();
		(void) fclose(fddesc);

		if (err != 0)
			return (1);
	}

	/*
	 * If a msgid has been output a msgstr must follow before we end the
	 * file.
	 */
	if (msgid) {
		msgid = 0;
		if (fprintf(fdmsgs, "msgstr\t\"\"\n") < 0) {
			(void) fprintf(stderr, Errmsg_wrte, flmsgs,
			    strerror(errno));
			return (1);
		}
	}

	if (fdmids)
		(void) fclose(fdmids);
	if (fdmsgs)
		(void) fclose(fdmsgs);

	if (fddefs) {
		if (output_defs())
			return (1);
	}

	/*
	 * Finish off any generated data and header file.
	 */
	if (fldata) {
		if (output_data())
			return (1);
	}
	if (fddefs) {
		if (fini_defs())
			return (1);
	}

	if (vflag)
		dump_stringtab(stp);

	/*
	 * Close up everything and go home.
	 */
	if (fddata)
		(void) fclose(fddata);
	if (fddefs && (fddefs != fddata))
		(void) fclose(fddefs);
	if (fddefs && fddata) {
		(void) fclose(fdlint);
		(void) unlink(fllint);
	}

	if (stp)
		st_destroy(stp);

	return (0);
}