OpenSolaris_b135/cmd/gencat/gencat.c
/*
* 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);
}