1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright (c) 1995, 2010, Oracle and/or its affiliates. All rights reserved.
  23  *
  24  * sgsmsg generates several message files from an input template file.  Messages
  25  * are constructed for use with gettext(3i) - the default - or catgets(3c).  The
  26  * files generate are:
  27  *
  28  * msg.h        a header file containing definitions for each message.  The -h
  29  *              option triggers the creation of these definitions and specifies
  30  *              the name to use.
  31  *
  32  * msg.c        a data array of message strings.  The msg.h definitions are
  33  *              offsets into this array.  The -d option triggers the creation of
  34  *              these definitions and specifies the name to use.
  35  *
  36  * messages     a message file suitable for catgets(3c) or gettext(3i) use.  The
  37  *              -m option triggers this output and specifies the filename to be
  38  *              used.
  39  *
  40  * The template file is processed based on the first character of each line:
  41  *
  42  * # or $       entries are copied (as is) to the message file (messages).
  43  *
  44  * @ token(s)   entries are translated.  Two translations are possible dependent
  45  *              on whether one or more tokens are supplied:
  46  *
  47  *              A single token is interpreted as one of two reserved message
  48  *              output indicators, or a message identifier.  The reserved output
  49  *              indicator _START_ enables output to the message file - Note that
  50  *              the occurance of any other @ token will also enable message
  51  *              output.  The reserved output indicator _END_ disables output to
  52  *              the message file.  The use of these two indicators provides for
  53  *              only those message strings that require translation to be output
  54  *              to the message file.
  55  *
  56  *              Besides the reserved output indicators, a single token is taken
  57  *              to be a message identifier which will be subsituted for a
  58  *              `setid' for catgets(3c) output, or a `domain' name for
  59  *              gettext(3i) output.  This value is determine by substituting the
  60  *              token for the associated definition found in the message
  61  *              identifier file (specified with the -i option).
  62  *
  63  *              Multiple tokens are taken to be a message definition followed by
  64  *              the associated message string.  The message string is copied to
  65  *              the data array being built in msg.c.  The index into this array
  66  *              becomes the `message' identifier created in the msg.h file.
  67  */
  68 
  69 #include        <fcntl.h>
  70 #include        <stdlib.h>
  71 #include        <stdio.h>
  72 #include        <unistd.h>
  73 #include        <limits.h>
  74 #include        <string.h>
  75 #include        <ctype.h>
  76 #include        <errno.h>
  77 #include        <sys/param.h>
  78 
  79 #include        <sgs.h>
  80 #include        <_string_table.h>
  81 
  82 /*
  83  * Define any error message strings.
  84  */
  85 static const char
  86         * Errmsg_malt = "sgsmsg: file %s: line %d: malformed input "
  87                         "at line\n",
  88         * Errmsg_nmem = "sgsmsg: memory allocation failed: %s\n",
  89         * Errmsg_opne = "sgsmsg: file %s: open failed: %s\n",
  90         * Errmsg_wrte = "sgsmsg: file %s: write failed: %s\n",
  91         * Errmsg_read = "sgsmsg: file %s: read failed %s\n",
  92         * Errmsg_stnw = "sgsmsg: st_new(): failed: %s\n",
  93         * Errmsg_stin = "sgsmsg: Str_tbl insert failed: %s\n",
  94         * Errmsg_mnfn = "sgsmsg: message not found in Str_tbl: %s\n",
  95         * Errmsg_use  = "usage: sgsmsg [-clv] [-d mesgdata] [-h mesgdefs] "
  96                         "[-m messages] [-n name] [-i mesgident] file ...\n";
  97 
  98 /*
  99  * Define all output filenames and associated descriptors.
 100  */
 101 static FILE     *fddefs, *fddata, *fdmsgs, *fdmids, *fddesc;
 102 static char     *fldefs, *fldata, *flmsgs, *flmids, *fldesc;
 103 static FILE     *fdlint;
 104 static char     fllint[MAXPATHLEN];
 105 
 106 static uint_t           vflag;  /* verbose flag */
 107 static Str_tbl          *stp;   /* string table */
 108 
 109 /*
 110  * Define any default strings.
 111  */
 112 static const char
 113         *nmlint =       "/tmp/sgsmsg.lint",
 114         *interface =    "sgs_msg",
 115         *start =        "_START_",
 116         *end =          "_END_";
 117 
 118 /*
 119  * Define any default flags and data items.
 120  */
 121 static int      cflag = 0, lflag = 0, prtmsgs = 0, line, ptr = 1, msgid = 0;
 122 static char     *mesgid = 0, *setid = 0, *domain = 0;
 123 
 124 typedef struct msg_string {
 125         char                    *ms_defn;
 126         char                    *ms_message;
 127         struct msg_string       *ms_next;
 128 } msg_string;
 129 
 130 static msg_string       *msg_head;
 131 static msg_string       *msg_tail;
 132 
 133 /*
 134  * message_append() is responsible for both inserting strings into
 135  * the master Str_tbl as well as maintaining a list of the
 136  * DEFINITIONS associated with each string.
 137  *
 138  * The list of strings is traversed at the end once the full
 139  * Str_tbl has been constructed - and string offsets can be
 140  * assigned.
 141  */
 142 static void
 143 message_append(const char *defn, const char *message)
 144 {
 145         msg_string      *msg;
 146         if ((msg = calloc(sizeof (msg_string), 1)) == 0) {
 147                 (void) fprintf(stderr, Errmsg_nmem, strerror(errno));
 148                 exit(1);
 149         }
 150 
 151         /*
 152          * Initialize the string table.
 153          */
 154         if ((stp == 0) && ((stp = st_new(FLG_STNEW_COMPRESS)) == NULL)) {
 155                 (void) fprintf(stderr, Errmsg_stnw, strerror(errno));
 156                 exit(1);
 157         }
 158 
 159 
 160         if ((msg->ms_defn = strdup(defn)) == 0) {
 161                 (void) fprintf(stderr, Errmsg_nmem, strerror(errno));
 162                 exit(1);
 163         }
 164         if ((msg->ms_message = strdup(message)) == 0) {
 165                 (void) fprintf(stderr, Errmsg_nmem, strerror(errno));
 166                 exit(1);
 167         }
 168 
 169         if (st_insert(stp, msg->ms_message) == -1) {
 170                 (void) fprintf(stderr, Errmsg_stin,
 171                     message);
 172                 exit(1);
 173         }
 174 
 175         if (msg_head == 0) {
 176                 msg_head = msg_tail = msg;
 177                 return;
 178         }
 179         msg_tail->ms_next = msg;
 180         msg_tail = msg;
 181 }
 182 
 183 /*
 184  * Initialize a setid value.  Given a setid definition determine its numeric
 185  * value from the specified message identifier file (specified with the -i
 186  * option).  Return a pointer to the numeric string.
 187  */
 188 static int
 189 getmesgid(char *id)
 190 {
 191         char    *buffer, *token, *_mesgid = 0, *_setid = 0, *_domain = 0;
 192 
 193         /*
 194          * If we're being asked to interpret a message id but the user didn't
 195          * provide the required message identifier file (-i option) we're in
 196          * trouble.
 197          */
 198         if (flmids == 0) {
 199                 (void) fprintf(stderr, "sgsmsg: file %s: line %d: mesgid %s: "
 200                     "unable to process mesgid\n\t"
 201                     "no message identifier file specified "
 202                     "(see -i option)\n", fldesc, line, id);
 203                 return (1);
 204         }
 205 
 206         if ((buffer = malloc(LINE_MAX)) == 0) {
 207                 (void) fprintf(stderr, Errmsg_nmem, strerror(errno));
 208                 return (1);
 209         }
 210 
 211         /*
 212          * Read the message identifier file and locate the required mesgid.
 213          */
 214         rewind(fdmids);
 215         while (fgets(buffer, LINE_MAX, fdmids) != NULL) {
 216                 if ((token = strstr(buffer, id)) == NULL)
 217                         continue;
 218 
 219                 /*
 220                  * Establish individual strings for the mesgid, setid and domain
 221                  * values.
 222                  */
 223                 _mesgid = token;
 224                 while (!(isspace(*token)))
 225                         token++;
 226                 *token++ = 0;
 227 
 228                 while (isspace(*token))
 229                         token++;
 230                 _setid = token;
 231                 while (!(isspace(*token)))
 232                         token++;
 233                 *token++ = 0;
 234 
 235                 while (isspace(*token))
 236                         token++;
 237                 _domain = token;
 238                 while (!(isspace(*token)))
 239                         token++;
 240                 *token = 0;
 241                 break;
 242         }
 243 
 244         /*
 245          * Did we find a match?
 246          */
 247         if ((_mesgid == 0) || (_setid == 0) || (_domain == 0)) {
 248                 (void) fprintf(stderr, "sgsmsg: file %s: line %d: mesgid %s: "
 249                     "unable to process mesgid\n\t"
 250                     "identifier does not exist in file %s\n",
 251                     fldesc, line, id, flmids);
 252                 return (1);
 253         }
 254 
 255         /*
 256          * Have we been here before?
 257          */
 258         if (mesgid) {
 259                 if (cflag == 1) {
 260                         /*
 261                          * If we're being asked to process more than one mesgid
 262                          * warn the user that only one mesgid can be used for
 263                          * the catgets(3c) call.
 264                          */
 265                         (void) fprintf(stderr, "sgsmsg: file %s: line %d: "
 266                             "setid %s: warning: multiple mesgids "
 267                             "encountered\n\t"
 268                             "last setting used in messaging code\n",
 269                             fldesc, line, id);
 270                 }
 271         }
 272 
 273         mesgid = _mesgid;
 274         setid = _setid;
 275         domain = _domain;
 276 
 277         /*
 278          * Generate the message file output (insure output flag is enabled).
 279          */
 280         if (prtmsgs != -1)
 281                 prtmsgs = 1;
 282         if (fdmsgs && (prtmsgs == 1)) {
 283                 if (cflag == 1) {
 284                         if (fprintf(fdmsgs, "$quote \"\n$set %s\n",
 285                             setid) < 0) {
 286                                 (void) fprintf(stderr, Errmsg_wrte, flmsgs,
 287                                     strerror(errno));
 288                                 return (1);
 289                         }
 290                 } else {
 291                         if (fprintf(fdmsgs, "domain\t\"%s\"\n", domain) < 0) {
 292                                 (void) fprintf(stderr, Errmsg_wrte, flmsgs,
 293                                     strerror(errno));
 294                                 return (1);
 295                         }
 296                 }
 297         }
 298 
 299         /*
 300          * For catgets(3c) output generate a setid definition in the message
 301          * definition file.
 302          */
 303         if (fddefs && (cflag == 1) &&
 304             (fprintf(fddefs, "#define\t%s\t%s\n\n", mesgid, setid) < 0)) {
 305                 (void) fprintf(stderr, Errmsg_wrte, fldefs, strerror(errno));
 306                 return (1);
 307         }
 308 
 309         return (0);
 310 }
 311 
 312 /*
 313  * Dump contents of String Table to standard out
 314  */
 315 static void
 316 dump_stringtab(Str_tbl *stp)
 317 {
 318         uint_t  cnt;
 319 
 320         if ((stp->st_flags & FLG_STTAB_COMPRESS) == 0) {
 321                 (void) printf("string table full size: %ld: uncompressed\n",
 322                     stp->st_fullstrsize);
 323                 return;
 324         }
 325 
 326         (void) printf("string table full size: %ld compressed down to: %ld\n\n",
 327             stp->st_fullstrsize, stp->st_strsize);
 328         (void) printf("string table compression information [%d buckets]:\n",
 329             stp->st_hbckcnt);
 330 
 331         for (cnt = 0; cnt < stp->st_hbckcnt; cnt++) {
 332                 Str_hash        *sthash = stp->st_hashbcks[cnt];
 333 
 334                 if (sthash == 0)
 335                         continue;
 336 
 337                 (void) printf(" bucket: [%d]\n", cnt);
 338 
 339                 while (sthash) {
 340                         size_t  stroff = sthash->hi_mstr->sm_strlen -
 341                             sthash->hi_strlen;
 342 
 343                         if (stroff == 0) {
 344                                 (void) printf("  [%ld]: '%s'  <master>\n",
 345                                     sthash->hi_refcnt, sthash->hi_mstr->sm_str);
 346                         } else {
 347                                 (void) printf("  [%ld]: '%s'  <suffix of: "
 348                                     "'%s'>\n", sthash->hi_refcnt,
 349                                     &sthash->hi_mstr->sm_str[stroff],
 350                                     sthash->hi_mstr->sm_str);
 351                         }
 352                         sthash = sthash->hi_next;
 353                 }
 354         }
 355 }
 356 
 357 /*
 358  * Initialize the message definition header file stream.
 359  */
 360 static int
 361 init_defs(void)
 362 {
 363         static char     guard[FILENAME_MAX + 6];
 364         char            *optr;
 365         const char      *iptr, *_ptr;
 366 
 367         /*
 368          * Establish a header guard name using the files basename.
 369          */
 370         for (iptr = 0, _ptr = fldefs; _ptr && (*_ptr != '\0'); _ptr++) {
 371                 if (*_ptr == '/')
 372                         iptr = _ptr + 1;
 373         }
 374         if (iptr == 0)
 375                 iptr = fldefs;
 376 
 377         optr = guard;
 378         for (*optr++ = '_'; iptr && (*iptr != '\0'); iptr++, optr++) {
 379                 if (*iptr == '.') {
 380                         *optr++ = '_';
 381                         *optr++ = 'D';
 382                         *optr++ = 'O';
 383                         *optr++ = 'T';
 384                         *optr = '_';
 385                 } else
 386                         *optr = toupper(*iptr);
 387         }
 388 
 389         if (fprintf(fddefs, "#ifndef\t%s\n#define\t%s\n\n", guard, guard) < 0) {
 390                 (void) fprintf(stderr, Errmsg_wrte, fldefs, strerror(errno));
 391                 return (1);
 392         }
 393 
 394         if (fprintf(fddefs, "#include <sgsmsg.h>\t/* Msg typedef */\n\n") < 0) {
 395                 (void) fprintf(stderr, Errmsg_wrte, fldefs, strerror(errno));
 396                 return (1);
 397         }
 398 
 399         if (fprintf(fddefs, "#ifndef\t__lint\n\n") < 0) {
 400                 (void) fprintf(stderr, Errmsg_wrte, fldefs, strerror(errno));
 401                 return (1);
 402         }
 403 
 404         /*
 405          * The MSG_SGS_ARRAY_NAME macro supplies a generic way to
 406          * reference the string table regardless of its name.
 407          */
 408         if (fprintf(fddefs, "#define\tMSG_SGS_LOCAL_ARRAY\t__%s\n\n",
 409             interface) < 0) {
 410                 (void) fprintf(stderr, Errmsg_wrte, fldefs, strerror(errno));
 411                 return (1);
 412         }
 413 
 414         /*
 415          * If the associated data array is global define a prototype.
 416          * Define a macro to access the array elements.
 417          */
 418         if (lflag == 0) {
 419                 if (fprintf(fddefs, "extern\tconst char\t__%s[];\n\n",
 420                     interface) < 0) {
 421                         (void) fprintf(stderr, Errmsg_wrte, fldefs,
 422                             strerror(errno));
 423                         return (1);
 424                 }
 425         }
 426         if (fprintf(fddefs,
 427             "#define\tMSG_ORIG_STRTAB(_x, _s)\t&_s[_x]\n\n") < 0) {
 428                 (void) fprintf(stderr, Errmsg_wrte, fldefs, strerror(errno));
 429                 return (1);
 430         }
 431         if (fprintf(fddefs,
 432             "#define\tMSG_ORIG(x)\tMSG_ORIG_STRTAB(x, __%s)\n\n",
 433             interface) < 0) {
 434                 (void) fprintf(stderr, Errmsg_wrte, fldefs, strerror(errno));
 435                 return (1);
 436         }
 437 
 438         /*
 439          * Generate a prototype to access the associated data array.
 440          */
 441         if (fprintf(fddefs, "extern\tconst char *\t_%s(Msg);\n\n",
 442             interface) < 0) {
 443                 (void) fprintf(stderr, Errmsg_wrte, fldefs, strerror(errno));
 444                 return (1);
 445         }
 446         if (fprintf(fddefs, "#define\tMSG_INTL(x)\t_%s(x)\n\n",
 447             interface) < 0) {
 448                 (void) fprintf(stderr, Errmsg_wrte, fldefs, strerror(errno));
 449                 return (1);
 450         }
 451 
 452         return (0);
 453 }
 454 
 455 
 456 /*
 457  * Finish the message definition header file.
 458  */
 459 static int
 460 fini_defs(void)
 461 {
 462         if (fprintf(fddefs, "\n#else\t/* __lint */\n\n") < 0) {
 463                 (void) fprintf(stderr, Errmsg_wrte, fldefs, strerror(errno));
 464                 return (1);
 465         }
 466 
 467         if (fprintf(fddefs, "extern\tconst char *\t_%s(Msg);\n\n",
 468             interface) < 0) {
 469                 (void) fprintf(stderr, Errmsg_wrte, fldefs, strerror(errno));
 470                 return (1);
 471         }
 472 
 473         if (fprintf(fddefs, "#ifndef MSG_SGS_LOCAL_ARRAY\n"
 474             "#define\tMSG_SGS_LOCAL_ARRAY\t\"\"\n#endif\n\n") < 0) {
 475                 (void) fprintf(stderr, Errmsg_wrte, fldefs, strerror(errno));
 476                 return (1);
 477         }
 478 
 479         if (lflag == 0) {
 480                 if (fprintf(fddefs, "extern\tconst char\t__%s[];\n\n",
 481                     interface) < 0) {
 482                         (void) fprintf(stderr, Errmsg_wrte, fldefs,
 483                             strerror(errno));
 484                         return (1);
 485                 }
 486         }
 487 
 488         if (fprintf(fddefs,
 489             "#define MSG_ORIG_STRTAB(_x, _s)\t_x\n"
 490             "#define MSG_ORIG(x)\tx\n#define MSG_INTL(x)\tx\n") < 0) {
 491                 (void) fprintf(stderr, Errmsg_wrte, fldefs, strerror(errno));
 492                 return (1);
 493         }
 494 
 495         /*
 496          * Provide a way to get the array and function declarations above
 497          * without also getting the actual messages. This is useful in
 498          * our lintsup.c files that include more than one message header.
 499          * lintsup doesn't need the actual messages, and this prevents
 500          * macro name collisions.
 501          */
 502         if (fprintf(fddefs, "\n#ifndef LINTSUP_SUPPRESS_STRINGS\n") < 0) {
 503                 (void) fprintf(stderr, Errmsg_wrte, fldefs, strerror(errno));
 504                 return (1);
 505         }
 506 
 507         /*
 508          * Copy the temporary lint defs file into the new header.
 509          */
 510         if (fdlint) {
 511                 long    size;
 512                 char    *buf;
 513 
 514                 size = ftell(fdlint);
 515                 (void) rewind(fdlint);
 516 
 517                 if ((buf = malloc(size)) == 0) {
 518                         (void) fprintf(stderr, Errmsg_nmem, strerror(errno));
 519                         return (1);
 520                 }
 521                 if (fread(buf, size, 1, fdlint) == 0) {
 522                         (void) fprintf(stderr, Errmsg_read, fllint,
 523                             strerror(errno));
 524                         return (1);
 525                 }
 526                 if (fwrite(buf, size, 1, fddefs) == 0) {
 527                         (void) fprintf(stderr, Errmsg_wrte, fldefs,
 528                             strerror(errno));
 529                         return (1);
 530                 }
 531                 (void) free(buf);
 532         }
 533 
 534         if (fprintf(fddefs, "\n#endif\t/* LINTSUP_SUPPRESS_STRINGS */\n") < 0) {
 535                 (void) fprintf(stderr, Errmsg_wrte, fldefs, strerror(errno));
 536                 return (1);
 537         }
 538 
 539         if (fprintf(fddefs, "\n#endif\t/* __lint */\n") < 0) {
 540                 (void) fprintf(stderr, Errmsg_wrte, fldefs, strerror(errno));
 541                 return (1);
 542         }
 543 
 544         if (fprintf(fddefs, "\n#endif\n") < 0) {
 545                 (void) fprintf(stderr, Errmsg_wrte, fldefs, strerror(errno));
 546                 return (1);
 547         }
 548 
 549         return (0);
 550 }
 551 
 552 /*
 553  * The entire messaging file has been scanned - and all strings have been
 554  * inserted into the string_table.  We can now walk the message queue
 555  * and create the '#define <DEFN>' for each string - with the strings
 556  * assigned offset into the string_table.
 557  */
 558 static int
 559 output_defs(void)
 560 {
 561         msg_string      *msg;
 562         size_t          stbufsize;
 563         char            *stbuf;
 564 
 565         stbufsize = st_getstrtab_sz(stp);
 566         if ((stbuf = malloc(stbufsize)) == 0) {
 567                 (void) fprintf(stderr, Errmsg_nmem, strerror(errno));
 568                 exit(1);
 569         }
 570         (void) st_setstrbuf(stp, stbuf, stbufsize);
 571         for (msg = msg_head; msg; msg = msg->ms_next) {
 572                 size_t  stoff;
 573                 if ((st_setstring(stp, msg->ms_message, &stoff)) == -1) {
 574                         (void) fprintf(stderr, Errmsg_mnfn, msg->ms_message);
 575                         return (1);
 576                 }
 577                 if (fprintf(fddefs, "\n#define\t%s\t%ld\n",
 578                     msg->ms_defn, stoff) < 0) {
 579                         (void) fprintf(stderr, Errmsg_wrte,
 580                             fldefs, strerror(errno));
 581                         return (1);
 582                 }
 583                 if (fddefs && fprintf(fddefs, "#define\t%s_SIZE\t%d\n",
 584                     msg->ms_defn, strlen(msg->ms_message)) < 0) {
 585                         (void) fprintf(stderr, Errmsg_wrte,
 586                             fldefs, strerror(errno));
 587                         return (1);
 588                 }
 589         }
 590         return (0);
 591 }
 592 
 593 
 594 /*
 595  * Finish off the data structure definition.
 596  */
 597 static int
 598 output_data(void)
 599 {
 600         size_t          stbufsize;
 601         size_t          ndx;
 602         size_t          column = 1;
 603         const char      *stbuf;
 604         const char      *fmtstr;
 605 
 606         stbufsize = st_getstrtab_sz(stp);
 607         stbuf = st_getstrbuf(stp);
 608 
 609         assert(stbuf);
 610 
 611         /*
 612          * Determine from the local flag whether the data declaration should
 613          * be static.
 614          */
 615         if (lflag)
 616                 fmtstr = (const char *)"static const";
 617         else
 618                 fmtstr = (const char *)"const";
 619 
 620         if (fprintf(fddata, "\n%s char __%s[%ld] = { ",
 621             fmtstr, interface, stbufsize) < 0) {
 622                 (void) fprintf(stderr, Errmsg_wrte, fldata, strerror(errno));
 623                 return (1);
 624         }
 625 
 626         for (ndx = 0; ndx < (stbufsize - 1); ndx++) {
 627                 if (column == 1) {
 628                         if (fddata && fprintf(fddata,
 629                             "\n/* %4ld */ 0x%.2x,", ndx,
 630                             (unsigned char)stbuf[ndx]) < 0) {
 631                                 (void) fprintf(stderr, Errmsg_wrte,
 632                                     fldata, strerror(errno));
 633                                 return (1);
 634                         }
 635                 } else {
 636                         if (fddata && fprintf(fddata, "  0x%.2x,",
 637                             (unsigned char)stbuf[ndx]) < 0) {
 638                                 (void) fprintf(stderr, Errmsg_wrte,
 639                                     fldata, strerror(errno));
 640                                 return (1);
 641                         }
 642                 }
 643 
 644                 if (column++ == 10)
 645                         column = 1;
 646         }
 647 
 648         if (column == 1)
 649                 fmtstr = "\n\t0x%.2x };\n";
 650         else
 651                 fmtstr = "  0x%.2x };\n";
 652 
 653         if (fprintf(fddata, fmtstr, (unsigned char)stbuf[stbufsize - 1]) < 0) {
 654                 (void) fprintf(stderr, Errmsg_wrte, fldata, strerror(errno));
 655                 return (1);
 656         }
 657 
 658         return (0);
 659 }
 660 
 661 static int
 662 file()
 663 {
 664         char    buffer[LINE_MAX], * token;
 665         uint_t  bufsize;
 666         char    *token_buffer;
 667         int     escape = 0;
 668 
 669         if ((token_buffer = malloc(LINE_MAX)) == 0) {
 670                 (void) fprintf(stderr, Errmsg_nmem, strerror(errno));
 671                 return (1);
 672         }
 673         bufsize = LINE_MAX;
 674 
 675         line = 1;
 676 
 677         while ((token = fgets(buffer, LINE_MAX, fddesc)) != NULL) {
 678                 char    defn[PATH_MAX], * _defn, * str;
 679                 int     len;
 680 
 681                 switch (*token) {
 682                 case '#':
 683                 case '$':
 684                         if (escape) {
 685                                 (void) fprintf(stderr, Errmsg_malt, fldesc,
 686                                     line);
 687                                 return (1);
 688                         }
 689 
 690                         /*
 691                          * If a msgid has been output a msgstr must follow
 692                          * before we digest the new token.  A msgid is only set
 693                          * if fdmsgs is in use.
 694                          */
 695                         if (msgid) {
 696                                 msgid = 0;
 697                                 if (fprintf(fdmsgs, "msgstr\t\"\"\n") < 0) {
 698                                         (void) fprintf(stderr, Errmsg_wrte,
 699                                             flmsgs, strerror(errno));
 700                                         return (1);
 701                                 }
 702                         }
 703 
 704                         /*
 705                          * Pass lines directly through to the output message
 706                          * file.
 707                          */
 708                         if (fdmsgs && (prtmsgs == 1)) {
 709                                 char    comment;
 710 
 711                                 if (cflag == 0)
 712                                         comment = '#';
 713                                 else
 714                                         comment = '$';
 715 
 716                                 if (fprintf(fdmsgs, "%c%s", comment,
 717                                     ++token) < 0) {
 718                                         (void) fprintf(stderr, Errmsg_wrte,
 719                                             flmsgs, strerror(errno));
 720                                         return (1);
 721                                 }
 722                         }
 723                         break;
 724 
 725                 case '@':
 726                         if (escape) {
 727                                 (void) fprintf(stderr, Errmsg_malt, fldesc,
 728                                     line);
 729                                 return (1);
 730                         }
 731 
 732                         /*
 733                          * If a msgid has been output a msgstr must follow
 734                          * before we digest the new token.
 735                          */
 736                         if (msgid) {
 737                                 msgid = 0;
 738                                 if (fprintf(fdmsgs, "msgstr\t\"\"\n") < 0) {
 739                                         (void) fprintf(stderr, Errmsg_wrte,
 740                                             flmsgs, strerror(errno));
 741                                         return (1);
 742                                 }
 743                         }
 744 
 745                         /*
 746                          * Determine whether we have one or more tokens.
 747                          */
 748                         token++;
 749                         while (isspace(*token))         /* rid any whitespace */
 750                                 token++;
 751                         _defn = token;                  /* definition start */
 752                         while (!(isspace(*token)))
 753                                 token++;
 754                         *token++ = 0;
 755 
 756                         while (isspace(*token))         /* rid any whitespace */
 757                                 token++;
 758 
 759                         /*
 760                          * Determine whether the single token is one of the
 761                          * reserved message output delimiters otherwise
 762                          * translate it as a message identifier.
 763                          */
 764                         if (*token == 0) {
 765                                 if (strcmp(_defn, start) == 0)
 766                                         prtmsgs = 1;
 767                                 else if (strcmp(_defn, end) == 0)
 768                                         prtmsgs = -1;
 769                                 else if (getmesgid(_defn) == 1)
 770                                         return (1);
 771                                 break;
 772                         }
 773 
 774                         /*
 775                          * Multiple tokens are translated by taking the first
 776                          * token as the message definition, and the rest of the
 777                          * line as the message itself.  A message line ending
 778                          * with an escape ('\') is expected to be continued on
 779                          * the next line.
 780                          */
 781                         if (prtmsgs != -1)
 782                                 prtmsgs = 1;
 783                         if (fdmsgs && (prtmsgs == 1)) {
 784                                 /*
 785                                  * For catgets(3c) make sure a message
 786                                  * identifier has been established (this is
 787                                  * normally a domain for gettext(3i), but for
 788                                  * sgsmsg use this could be argued as being
 789                                  * redundent).  Also make sure that the message
 790                                  * definitions haven't exceeeded the maximum
 791                                  * value allowed by gencat(1) before generating
 792                                  * any message file entries.
 793                                  */
 794                                 if (cflag == 1) {
 795                                         if (setid == 0) {
 796                                                 (void) fprintf(stderr, "file "
 797                                                     "%s: no message identifier "
 798                                                     "has been established\n",
 799                                                     fldesc);
 800                                                 return (1);
 801                                         }
 802                                         if (ptr > NL_MSGMAX) {
 803                                                 (void) fprintf(stderr, "file "
 804                                                     "%s: message definition "
 805                                                     "(%d) exceeds allowable "
 806                                                     "limit (NL_MSGMAX)\n",
 807                                                     fldesc, ptr);
 808                                                 return (1);
 809                                         }
 810                                 }
 811 
 812                                 /*
 813                                  * For catgets(3c) write the definition and the
 814                                  * message string to the message file.  For
 815                                  * gettext(3i) write the message string as a
 816                                  * mesgid - indicate a mesgid has been output
 817                                  * so that a msgstr can follow.
 818                                  */
 819                                 if (cflag == 1) {
 820                                         if (fprintf(fdmsgs, "%d\t%s", ptr,
 821                                             token) < 0) {
 822                                                 (void) fprintf(stderr,
 823                                                     Errmsg_wrte, flmsgs,
 824                                                     strerror(errno));
 825                                                 return (1);
 826                                         }
 827                                 } else {
 828                                         if (fprintf(fdmsgs, "msgid\t\"") < 0) {
 829                                                 (void) fprintf(stderr,
 830                                                     Errmsg_wrte, flmsgs,
 831                                                     strerror(errno));
 832                                                 return (1);
 833                                         }
 834                                         msgid = 1;
 835                                 }
 836                         }
 837 
 838                         /*
 839                          * The message itself is a quoted string as this makes
 840                          * embedding spaces at the start (or the end) of the
 841                          * string very easy.
 842                          */
 843                         if (*token != '"') {
 844                                 (void) fprintf(stderr, Errmsg_malt, fldesc,
 845                                     line);
 846                                 return (1);
 847                         }
 848 
 849                         (void) strcpy(defn, _defn);
 850 
 851                         /*
 852                          * Write the tag to the lint definitions.
 853                          */
 854                         if (fdlint) {
 855                                 if (fprintf(fdlint, "\n#define\t%s\t",
 856                                     _defn) < 0) {
 857                                         (void) fprintf(stderr, Errmsg_wrte,
 858                                             fllint, strerror(errno));
 859                                         return (1);
 860                                 }
 861                         }
 862 
 863                         len = 0;
 864 
 865                         /*
 866                          * Write each character of the message string to the
 867                          * data array.  Translate any escaped characters - use
 868                          * the same specially recognized characters as defined
 869                          * by gencat(1).
 870                          */
 871 message:
 872                         if (*token == '"') {
 873                                 if (fdlint &&
 874                                     (fprintf(fdlint, "%c", *token) < 0)) {
 875                                         (void) fprintf(stderr, Errmsg_wrte,
 876                                             fllint, strerror(errno));
 877                                         return (1);
 878                                 }
 879                                 token++;
 880                         }
 881                         while (*token) {
 882                                 char    _token;
 883 
 884                                 if ((*token == '\\') && (escape == 0)) {
 885                                         escape = 1;
 886                                         if (fdlint && (*(token + 1) != '\n') &&
 887                                             fprintf(fdlint, "%c", *token) < 0) {
 888                                                 (void) fprintf(stderr,
 889                                                     Errmsg_wrte, fllint,
 890                                                     strerror(errno));
 891                                                 return (1);
 892                                         }
 893                                         token++;
 894                                         continue;
 895                                 }
 896                                 if (escape) {
 897                                         if (*token == 'n')
 898                                                 _token = '\n';
 899                                         else if (*token == 't')
 900                                                 _token = '\t';
 901                                         else if (*token == 'v')
 902                                                 _token = '\v';
 903                                         else if (*token == 'b')
 904                                                 _token = '\b';
 905                                         else if (*token == 'f')
 906                                                 _token = '\f';
 907                                         else if (*token == '\\')
 908                                                 _token = '\\';
 909                                         else if (*token == '"')
 910                                                 _token = '"';
 911                                         else if (*token == '\n')
 912                                                 break;
 913                                         else
 914                                                 _token = *token;
 915 
 916                                         if (fdmsgs && (prtmsgs == 1) &&
 917                                             (fprintf(fdmsgs, "\\") < 0)) {
 918                                                 (void) fprintf(stderr,
 919                                                     Errmsg_wrte, flmsgs,
 920                                                     strerror(errno));
 921                                                 return (1);
 922                                         }
 923                                 } else {
 924                                         /*
 925                                          * If this is the trailing quote then
 926                                          * thats the last of the message string.
 927                                          * Eat up any remaining white space and
 928                                          * unless an escape character is found
 929                                          * terminate the data string with a 0.
 930                                          */
 931                                         /* BEGIN CSTYLED */
 932                                         if (*token == '"') {
 933                                             if (fdlint && (fprintf(fdlint,
 934                                                 "%c", *token) < 0)) {
 935                                                 (void) fprintf(stderr,
 936                                                     Errmsg_wrte, fllint,
 937                                                     strerror(errno));
 938                                                 return (1);
 939                                             }
 940 
 941                                             if (fdmsgs && (prtmsgs == 1) &&
 942                                                 (fprintf(fdmsgs, "%c",
 943                                                 *token) < 0)) {
 944                                                 (void) fprintf(stderr,
 945                                                     Errmsg_wrte, flmsgs,
 946                                                     strerror(errno));
 947                                                 return (1);
 948                                             }
 949 
 950                                             while (*++token) {
 951                                                 if (*token == '\n')
 952                                                         break;
 953                                             }
 954                                             _token = '\0';
 955                                         } else
 956                                             _token = *token;
 957                                         /* END CSTYLED */
 958                                 }
 959 
 960                                 if (fdmsgs && (prtmsgs == 1) &&
 961                                     (fprintf(fdmsgs, "%c", *token) < 0)) {
 962                                         (void) fprintf(stderr, Errmsg_wrte,
 963                                             flmsgs, strerror(errno));
 964                                         return (1);
 965                                 }
 966 
 967                                 if (fdlint && fprintf(fdlint,
 968                                     "%c", *token) < 0) {
 969                                         (void) fprintf(stderr, Errmsg_wrte,
 970                                             fllint, strerror(errno));
 971                                         return (1);
 972                                 }
 973 
 974                                 if (len >= bufsize) {
 975                                         bufsize += LINE_MAX;
 976                                         if ((token_buffer = realloc(
 977                                             token_buffer, bufsize)) == 0) {
 978                                                 (void) fprintf(stderr,
 979                                                     Errmsg_nmem,
 980                                                     strerror(errno));
 981                                                 return (1);
 982                                         }
 983                                 }
 984                                 token_buffer[len] = _token;
 985                                 ptr++, token++, len++;
 986                                 escape = 0;
 987 
 988                                 if (_token == '\0')
 989                                         break;
 990                         }
 991 
 992                         /*
 993                          * After the complete message string has been processed
 994                          * (including its continuation beyond one line), create
 995                          * a string size definition.
 996                          */
 997                         if (escape == 0) {
 998                                 const char *form = "#define\t%s_SIZE\t%d\n";
 999 
1000                                 token_buffer[len] = '\0';
1001 
1002                                 message_append(defn, token_buffer);
1003 
1004                                 if (fdlint && fprintf(fdlint, form, defn,
1005                                     (len - 1)) < 0) {
1006                                         (void) fprintf(stderr, Errmsg_wrte,
1007                                             fllint, strerror(errno));
1008                                         return (1);
1009                                 }
1010                         }
1011                         break;
1012 
1013                 default:
1014                         /*
1015                          * Empty lines are passed through to the message file.
1016                          */
1017                         while (isspace(*token))
1018                                 token++;
1019 
1020                         if (*token == 0) {
1021                                 if (msgid || (fdmsgs && (prtmsgs == 1))) {
1022                                         /*
1023                                          * If a msgid has been output a msgstr
1024                                          * must follow before we digest the new
1025                                          * token.
1026                                          */
1027                                         if (msgid) {
1028                                                 msgid = 0;
1029                                                 str = "msgstr\t\"\"\n\n";
1030                                         } else
1031                                                 str = "\n";
1032 
1033                                         if (fprintf(fdmsgs, str) < 0) {
1034                                                 (void) fprintf(stderr,
1035                                                     Errmsg_wrte, flmsgs,
1036                                                     strerror(errno));
1037                                                 return (1);
1038                                         }
1039                                 }
1040                                 break;
1041                         }
1042 
1043                         /*
1044                          * If an escape is in effect then any tokens are taken
1045                          * to be message continuations.
1046                          */
1047                         if (escape) {
1048                                 escape = 0;
1049                                 goto message;
1050                         }
1051 
1052                         (void) fprintf(stderr, "file %s: line %d: invalid "
1053                             "input does not start with #, $ or @\n", fldesc,
1054                             line);
1055                         return (1);
1056                 }
1057                 line++;
1058         }
1059 
1060         free(token_buffer);
1061 
1062         return (0);
1063 }
1064 
1065 int
1066 main(int argc, char ** argv)
1067 {
1068         opterr = 0;
1069         while ((line = getopt(argc, argv, "cd:h:lm:n:i:v")) != EOF) {
1070                 switch (line) {
1071                 case 'c':                       /* catgets instead of gettext */
1072                         cflag = 1;
1073                         break;
1074                 case 'd':                       /* new message data filename */
1075                         fldata = optarg;        /*      (msg.c is default) */
1076                         break;
1077                 case 'h':                       /* new message defs filename */
1078                         fldefs = optarg;        /*      (msg.h is default) */
1079                         break;
1080                 case 'i':                       /* input message ids from */
1081                         flmids = optarg;        /*      from this file */
1082                         break;
1083                 case 'l':                       /* define message data arrays */
1084                         lflag = 1;              /*      to be local (static) */
1085                         break;
1086                 case 'm':                       /* generate message database */
1087                         flmsgs = optarg;        /*      to this file */
1088                         break;
1089                 case 'n':                       /* new data array and func */
1090                         interface = optarg;     /*      name (msg is default) */
1091                         break;
1092                 case 'v':
1093                         vflag = 1;              /* set verbose flag */
1094                         break;
1095                 case '?':
1096                         (void) fprintf(stderr, Errmsg_use, argv[0]);
1097                         exit(1);
1098                 default:
1099                         break;
1100                 }
1101         }
1102 
1103         /*
1104          * Validate the we have been given at least one input file.
1105          */
1106         if ((argc - optind) < 1) {
1107                 (void) fprintf(stderr, Errmsg_use);
1108                 exit(1);
1109         }
1110 
1111         /*
1112          * Open all the required output files.
1113          */
1114         if (fldefs) {
1115                 if ((fddefs = fopen(fldefs, "w+")) == NULL) {
1116                         (void) fprintf(stderr, Errmsg_opne, fldefs,
1117                             strerror(errno));
1118                         return (1);
1119                 }
1120         }
1121         if (fldata) {
1122                 if (fldefs && (strcmp(fldefs, fldata) == 0))
1123                         fddata = fddefs;
1124                 else if ((fddata = fopen(fldata, "w+")) == NULL) {
1125                         (void) fprintf(stderr, Errmsg_opne, fldata,
1126                             strerror(errno));
1127                         return (1);
1128                 }
1129         }
1130         if (fddefs && fddata) {
1131                 (void) sprintf(fllint, "%s.%d.XXXXXX", nmlint, (int)getpid());
1132                 if ((mkstemp(fllint) == -1) ||
1133                     ((fdlint = fopen(fllint, "w+")) == NULL)) {
1134                         (void) fprintf(stderr, Errmsg_opne, fllint,
1135                             strerror(errno));
1136                         return (1);
1137                 }
1138         }
1139         if (flmsgs) {
1140                 if ((fdmsgs = fopen(flmsgs, "w+")) == NULL) {
1141                         (void) fprintf(stderr, Errmsg_opne, flmsgs,
1142                             strerror(errno));
1143                         return (1);
1144                 }
1145         }
1146         if (flmids) {
1147                 if ((fdmids = fopen(flmids, "r")) == NULL) {
1148                         (void) fprintf(stderr, Errmsg_opne, flmids,
1149                             strerror(errno));
1150                         return (1);
1151                 }
1152         }
1153 
1154 
1155         /*
1156          * Initialize the message definition and message data streams.
1157          */
1158         if (fddefs) {
1159                 if (init_defs())
1160                         return (1);
1161         }
1162 
1163         /*
1164          * Read the input message file, and for each line process accordingly.
1165          */
1166         for (; optind < argc; optind++) {
1167                 int     err;
1168 
1169                 fldesc = argv[optind];
1170 
1171                 if ((fddesc = fopen(fldesc, "r")) == NULL) {
1172                         (void) fprintf(stderr, Errmsg_opne, fldesc,
1173                             strerror(errno));
1174                         return (1);
1175                 }
1176                 err = file();
1177                 (void) fclose(fddesc);
1178 
1179                 if (err != 0)
1180                         return (1);
1181         }
1182 
1183         /*
1184          * If a msgid has been output a msgstr must follow before we end the
1185          * file.
1186          */
1187         if (msgid) {
1188                 msgid = 0;
1189                 if (fprintf(fdmsgs, "msgstr\t\"\"\n") < 0) {
1190                         (void) fprintf(stderr, Errmsg_wrte, flmsgs,
1191                             strerror(errno));
1192                         return (1);
1193                 }
1194         }
1195 
1196         if (fdmids)
1197                 (void) fclose(fdmids);
1198         if (fdmsgs)
1199                 (void) fclose(fdmsgs);
1200 
1201         if (fddefs) {
1202                 if (output_defs())
1203                         return (1);
1204         }
1205 
1206         /*
1207          * Finish off any generated data and header file.
1208          */
1209         if (fldata) {
1210                 if (output_data())
1211                         return (1);
1212         }
1213         if (fddefs) {
1214                 if (fini_defs())
1215                         return (1);
1216         }
1217 
1218         if (vflag)
1219                 dump_stringtab(stp);
1220 
1221         /*
1222          * Close up everything and go home.
1223          */
1224         if (fddata)
1225                 (void) fclose(fddata);
1226         if (fddefs && (fddefs != fddata))
1227                 (void) fclose(fddefs);
1228         if (fddefs && fddata) {
1229                 (void) fclose(fdlint);
1230                 (void) unlink(fllint);
1231         }
1232 
1233         if (stp)
1234                 st_destroy(stp);
1235 
1236         return (0);
1237 }