usr.bin/gencat/gencat.c

   1 /*      $NetBSD: src/usr.bin/gencat/gencat.c,v 1.19 2004/01/05 23:23:34 jmmv Exp $      */
   2 /*      $DragonFly: src/usr.bin/gencat/gencat.c,v 1.5 2008/10/16 01:52:32 swildner Exp $ */
   3
   4 /*
   5  * Copyright (c) 1996 The NetBSD Foundation, Inc.
   6  * All rights reserved.
   7  *
   8  * This code is derived from software contributed to The NetBSD Foundation
   9  * by J.T. Conklin.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  * 3. All advertising materials mentioning features or use of this software
  20  *    must display the following acknowledgement:
  21  *        This product includes software developed by the NetBSD
  22  *        Foundation, Inc. and its contributors.
  23  * 4. Neither the name of The NetBSD Foundation nor the names of its
  24  *    contributors may be used to endorse or promote products derived
  25  *    from this software without specific prior written permission.
  26  *
  27  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  28  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  29  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  30  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  31  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  32  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  33  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  34  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  35  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  36  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  37  * POSSIBILITY OF SUCH DAMAGE.
  38  */
  39
  40 /***********************************************************
  41 Copyright 1990, by Alfalfa Software Incorporated, Cambridge, Massachusetts.
  42
  43                         All Rights Reserved
  44
  45 Permission to use, copy, modify, and distribute this software and its
  46 documentation for any purpose and without fee is hereby granted,
  47 provided that the above copyright notice appear in all copies and that
  48 both that copyright notice and this permission notice appear in
  49 supporting documentation, and that Alfalfa's name not be used in
  50 advertising or publicity pertaining to distribution of the software
  51 without specific, written prior permission.
  52
  53 ALPHALPHA DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  54 ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  55 ALPHALPHA BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  56 ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  57 WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  58 ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  59 SOFTWARE.
  60
  61 If you make any modifications, bugfixes or other changes to this software
  62 we'd appreciate it if you could send a copy to us so we can keep things
  63 up-to-date.  Many thanks.
  64                                 Kee Hinckley
  65                                 Alfalfa Software, Inc.
  66                                 267 Allston St., #3
  67                                 Cambridge, MA 02139  USA
  68                                 nazgul@alfalfa.com
  69
  70 ******************************************************************/
  71
  72 #include <sys/types.h>
  73 #include <sys/queue.h>
  74
  75 #include <arpa/inet.h>
  76
  77 #include <ctype.h>
  78 #include <err.h>
  79 #include <fcntl.h>
  80 #include <limits.h>
  81 #include <stdio.h>
  82 #include <stdlib.h>
  83 #include <string.h>
  84 #include <unistd.h>
  85
  86 #define _NLS_PRIVATE
  87 #include <nl_types.h>
  88
  89 #ifndef NL_SETMAX
  90 #define NL_SETMAX 255
  91 #endif
  92 #ifndef NL_MSGMAX
  93 #define NL_MSGMAX 2048
  94 #endif
  95
  96 struct _msgT {
  97         long    msgId;
  98         char   *str;
  99         LIST_ENTRY(_msgT) entries;
 100 };
 101
 102 struct _setT {
 103         long    setId;
 104         LIST_HEAD(msghead, _msgT) msghead;
 105         LIST_ENTRY(_setT) entries;
 106 };
 107
 108 LIST_HEAD(sethead, _setT) sethead;
 109 static struct _setT *curSet;
 110
 111 static char *curline = NULL;
 112 static long lineno = 0;
 113
 114 static char     *cskip(char *);
 115 static void      error(char *, char *);
 116 static void      nomem(void);
 117 static char     *getline(int);
 118 static char     *getmsg(int, char *, char);
 119 static void      warning(char *, char *);
 120 static char     *wskip(char *);
 121 static char     *xstrdup(const char *);
 122 static void     *xmalloc(size_t);
 123 static void     *xrealloc(void *, size_t);
 124
 125 void    MCParse(int fd);
 126 void    MCReadCat(int fd);
 127 void    MCWriteCat(int fd);
 128 void    MCDelMsg(int msgId);
 129 void    MCAddMsg(int msgId, const char *msg);
 130 void    MCAddSet(int setId);
 131 void    MCDelSet(int setId);
 132 int     main(int, char **);
 133 void    usage(void);
 134
 135
 136 void
 137 usage(void)
 138 {
 139         fprintf(stderr, "usage: %s catfile msgfile ...\n", getprogname());
 140         exit(1);
 141 }
 142
 143 int
 144 main(int argc, char *argv[])
 145 {
 146         int     ofd, ifd;
 147         char   *catfile = NULL;
 148         int     c;
 149
 150         while ((c = getopt(argc, argv, "")) != -1) {
 151                 switch (c) {
 152                 default:
 153                         usage();
 154                         /* NOTREACHED */
 155                 }
 156         }
 157         argc -= optind;
 158         argv += optind;
 159
 160         if (argc < 2) {
 161                 usage();
 162                 /* NOTREACHED */
 163         }
 164         catfile = *argv++;
 165
 166         for (; *argv; argv++) {
 167                 if ((ifd = open(*argv, O_RDONLY)) < 0)
 168                         err(1, "Unable to read %s", *argv);
 169                 MCParse(ifd);
 170                 close(ifd);
 171         }
 172
 173         if ((ofd = open(catfile, O_WRONLY | O_TRUNC | O_CREAT, 0666)) < 0)
 174                 err(1, "Unable to create a new %s", catfile);
 175         MCWriteCat(ofd);
 176         exit(0);
 177 }
 178
 179 static void
 180 warning(char *cptr, char *msg)
 181 {
 182         fprintf(stderr, "%s: %s on line %ld\n", getprogname(), msg, lineno);
 183         fprintf(stderr, "%s\n", curline);
 184         if (cptr) {
 185                 char   *tptr;
 186                 for (tptr = curline; tptr < cptr; ++tptr)
 187                         putc(' ', stderr);
 188                 fprintf(stderr, "^\n");
 189         }
 190 }
 191
 192 static void
 193 error(char *cptr, char *msg)
 194 {
 195         warning(cptr, msg);
 196         exit(1);
 197 }
 198
 199 #if 0   /* XXX unused */
 200 static void
 201 corrupt(void)
 202 {
 203         error(NULL, "corrupt message catalog");
 204 }
 205 #endif
 206
 207 static void
 208 nomem(void)
 209 {
 210         error(NULL, "out of memory");
 211 }
 212
 213 static void *
 214 xmalloc(size_t len)
 215 {
 216         void   *p;
 217
 218         if ((p = malloc(len)) == NULL)
 219                 nomem();
 220         return (p);
 221 }
 222
 223 static void *
 224 xrealloc(void *ptr, size_t size)
 225 {
 226         if ((ptr = realloc(ptr, size)) == NULL)
 227                 nomem();
 228         return (ptr);
 229 }
 230
 231 static char *
 232 xstrdup(const char *str)
 233 {
 234         char *nstr;
 235
 236         if ((nstr = strdup(str)) == NULL)
 237                 nomem();
 238         return (nstr);
 239 }
 240
 241 static char *
 242 getline(int fd)
 243 {
 244         static long curlen = BUFSIZ;
 245         static char buf[BUFSIZ], *bptr = buf, *bend = buf;
 246         char   *cptr, *cend;
 247         long    buflen;
 248
 249         if (!curline) {
 250                 curline = xmalloc(curlen);
 251         }
 252         ++lineno;
 253
 254         cptr = curline;
 255         cend = curline + curlen;
 256         for (;;) {
 257                 for (; bptr < bend && cptr < cend; ++cptr, ++bptr) {
 258                         if (*bptr == '\n') {
 259                                 *cptr = '\0';
 260                                 ++bptr;
 261                                 return (curline);
 262                         } else
 263                                 *cptr = *bptr;
 264                 }
 265                 if (cptr == cend) {
 266                         cptr = curline = xrealloc(curline, curlen *= 2);
 267                         cend = curline + curlen;
 268                 }
 269                 if (bptr == bend) {
 270                         buflen = read(fd, buf, BUFSIZ);
 271                         if (buflen <= 0) {
 272                                 if (cptr > curline) {
 273                                         *cptr = '\0';
 274                                         return (curline);
 275                                 }
 276                                 return (NULL);
 277                         }
 278                         bend = buf + buflen;
 279                         bptr = buf;
 280                 }
 281         }
 282 }
 283
 284 static char *
 285 wskip(char *cptr)
 286 {
 287         if (!*cptr || !isspace((unsigned char) *cptr)) {
 288                 warning(cptr, "expected a space");
 289                 return (cptr);
 290         }
 291         while (*cptr && isspace((unsigned char) *cptr))
 292                 ++cptr;
 293         return (cptr);
 294 }
 295
 296 static char *
 297 cskip(char *cptr)
 298 {
 299         if (!*cptr || isspace((unsigned char) *cptr)) {
 300                 warning(cptr, "wasn't expecting a space");
 301                 return (cptr);
 302         }
 303         while (*cptr && !isspace((unsigned char) *cptr))
 304                 ++cptr;
 305         return (cptr);
 306 }
 307
 308 static char *
 309 getmsg(int fd, char *cptr, char quote)
 310 {
 311         static char *msg = NULL;
 312         static long msglen = 0;
 313         long    clen, i;
 314         char   *tptr;
 315
 316         if (quote && *cptr == quote) {
 317                 ++cptr;
 318         }
 319
 320         clen = strlen(cptr) + 1;
 321         if (clen > msglen) {
 322                 if (msglen)
 323                         msg = xrealloc(msg, clen);
 324                 else
 325                         msg = xmalloc(clen);
 326                 msglen = clen;
 327         }
 328         tptr = msg;
 329
 330         while (*cptr) {
 331                 if (quote && *cptr == quote) {
 332                         char   *tmp;
 333                         tmp = cptr + 1;
 334                         if (*tmp && (!isspace((unsigned char) *tmp) || *wskip(tmp))) {
 335                                 warning(cptr, "unexpected quote character, ignoring");
 336                                 *tptr++ = *cptr++;
 337                         } else {
 338                                 *cptr = '\0';
 339                         }
 340                 } else
 341                         if (*cptr == '\\') {
 342                                 ++cptr;
 343                                 switch (*cptr) {
 344                                 case '\0':
 345                                         cptr = getline(fd);
 346                                         if (!cptr)
 347                                                 error(NULL, "premature end of file");
 348                                         msglen += strlen(cptr);
 349                                         i = tptr - msg;
 350                                         msg = xrealloc(msg, msglen);
 351                                         tptr = msg + i;
 352                                         break;
 353                                 case 'n':
 354                                         *tptr++ = '\n';
 355                                         ++cptr;
 356                                         break;
 357                                 case 't':
 358                                         *tptr++ = '\t';
 359                                         ++cptr;
 360                                         break;
 361                                 case 'v':
 362                                         *tptr++ = '\v';
 363                                         ++cptr;
 364                                         break;
 365                                 case 'b':
 366                                         *tptr++ = '\b';
 367                                         ++cptr;
 368                                         break;
 369                                 case 'r':
 370                                         *tptr++ = '\r';
 371                                         ++cptr;
 372                                         break;
 373                                 case 'f':
 374                                         *tptr++ = '\f';
 375                                         ++cptr;
 376                                         break;
 377                                 case '\\':
 378                                         *tptr++ = '\\';
 379                                         ++cptr;
 380                                         break;
 381                                 default:
 382                                         if (quote && *cptr == quote) {
 383                                                 *tptr++ = *cptr++;
 384                                         } else if (isdigit((unsigned char) *cptr)) {
 385                                                 *tptr = 0;
 386                                                 for (i = 0; i < 3; ++i) {
 387                                                         if (!isdigit((unsigned char) *cptr))
 388                                                                 break;
 389                                                         if (*cptr > '7')
 390                                                                 warning(cptr, "octal number greater than 7?!");
 391                                                         *tptr *= 8;
 392                                                         *tptr += (*cptr - '0');
 393                                                         ++cptr;
 394                                                 }
 395                                         } else {
 396                                                 warning(cptr, "unrecognized escape sequence");
 397                                         }
 398                                         break;
 399                                 }
 400                         } else {
 401                                 *tptr++ = *cptr++;
 402                         }
 403         }
 404         *tptr = '\0';
 405         return (msg);
 406 }
 407
 408 void
 409 MCParse(int fd)
 410 {
 411         char   *cptr, *str;
 412         int     setid, msgid = 0;
 413         char    quote = 0;
 414
 415         /* XXX: init sethead? */
 416
 417         while ((cptr = getline(fd))) {
 418                 if (*cptr == '$') {
 419                         ++cptr;
 420                         if (strncmp(cptr, "set", 3) == 0) {
 421                                 cptr += 3;
 422                                 cptr = wskip(cptr);
 423                                 setid = atoi(cptr);
 424                                 MCAddSet(setid);
 425                                 msgid = 0;
 426                         } else if (strncmp(cptr, "delset", 6) == 0) {
 427                                 cptr += 6;
 428                                 cptr = wskip(cptr);
 429                                 setid = atoi(cptr);
 430                                 MCDelSet(setid);
 431                         } else if (strncmp(cptr, "quote", 5) == 0) {
 432                                 cptr += 5;
 433                                 if (!*cptr)
 434                                         quote = 0;
 435                                 else {
 436                                         cptr = wskip(cptr);
 437                                         if (!*cptr)
 438                                                 quote = 0;
 439                                         else
 440                                                 quote = *cptr;
 441                                 }
 442                         } else if (isspace((unsigned char) *cptr)) {
 443                                 ;
 444                         } else {
 445                                 if (*cptr) {
 446                                         cptr = wskip(cptr);
 447                                         if (*cptr)
 448                                                 warning(cptr, "unrecognized line");
 449                                 }
 450                         }
 451                 } else {
 452                         /*
 453                          * First check for (and eat) empty lines....
 454                          */
 455                         if (!*cptr)
 456                                 continue;
 457                         /*
 458                          * We have a digit? Start of a message. Else,
 459                          * syntax error.
 460                          */
 461                         if (isdigit((unsigned char) *cptr)) {
 462                                 msgid = atoi(cptr);
 463                                 cptr = cskip(cptr);
 464                                 cptr = wskip(cptr);
 465                                 /* if (*cptr) ++cptr; */
 466                         } else {
 467                                 warning(cptr, "neither blank line nor start of a message id");
 468                                 continue;
 469                         }
 470                         /*
 471                          * If we have a message ID, but no message,
 472                          * then this means "delete this message id
 473                          * from the catalog".
 474                          */
 475                         if (!*cptr) {
 476                                 MCDelMsg(msgid);
 477                         } else {
 478                                 str = getmsg(fd, cptr, quote);
 479                                 MCAddMsg(msgid, str);
 480                         }
 481                 }
 482         }
 483 }
 484
 485 void
 486 MCReadCat(int fd)
 487 {
 488 #if 0
 489         MCHeaderT mcHead;
 490         MCMsgT  mcMsg;
 491         MCSetT  mcSet;
 492         msgT   *msg;
 493         setT   *set;
 494         int     i;
 495         char   *data;
 496
 497         /* XXX init sethead? */
 498
 499         if (read(fd, &mcHead, sizeof(mcHead)) != sizeof(mcHead))
 500                 corrupt();
 501         if (strncmp(mcHead.magic, MCMagic, MCMagicLen) != 0)
 502                 corrupt();
 503         if (mcHead.majorVer != MCMajorVer)
 504                 error(NULL, "unrecognized catalog version");
 505         if ((mcHead.flags & MCGetByteOrder()) == 0)
 506                 error(NULL, "wrong byte order");
 507
 508         if (lseek(fd, mcHead.firstSet, SEEK_SET) == -1)
 509                 corrupt();
 510
 511         for (;;) {
 512                 if (read(fd, &mcSet, sizeof(mcSet)) != sizeof(mcSet))
 513                         corrupt();
 514                 if (mcSet.invalid)
 515                         continue;
 516
 517                 set = xmalloc(sizeof(setT));
 518                 memset(set, '\0', sizeof(*set));
 519                 if (cat->first) {
 520                         cat->last->next = set;
 521                         set->prev = cat->last;
 522                         cat->last = set;
 523                 } else
 524                         cat->first = cat->last = set;
 525
 526                 set->setId = mcSet.setId;
 527
 528                 /* Get the data */
 529                 if (mcSet.dataLen) {
 530                         data = xmalloc(mcSet.dataLen);
 531                         if (lseek(fd, mcSet.data.off, SEEK_SET) == -1)
 532                                 corrupt();
 533                         if (read(fd, data, mcSet.dataLen) != mcSet.dataLen)
 534                                 corrupt();
 535                         if (lseek(fd, mcSet.u.firstMsg, SEEK_SET) == -1)
 536                                 corrupt();
 537
 538                         for (i = 0; i < mcSet.numMsgs; ++i) {
 539                                 if (read(fd, &mcMsg, sizeof(mcMsg)) != sizeof(mcMsg))
 540                                         corrupt();
 541                                 if (mcMsg.invalid) {
 542                                         --i;
 543                                         continue;
 544                                 }
 545                                 msg = xmalloc(sizeof(msgT));
 546                                 memset(msg, '\0', sizeof(*msg));
 547                                 if (set->first) {
 548                                         set->last->next = msg;
 549                                         msg->prev = set->last;
 550                                         set->last = msg;
 551                                 } else
 552                                         set->first = set->last = msg;
 553
 554                                 msg->msgId = mcMsg.msgId;
 555                                 msg->str = xstrdup((char *) (data + mcMsg.msg.off));
 556                         }
 557                         free(data);
 558                 }
 559                 if (!mcSet.nextSet)
 560                         break;
 561                 if (lseek(fd, mcSet.nextSet, SEEK_SET) == -1)
 562                         corrupt();
 563         }
 564 #endif
 565 }
 566
 567 /*
 568  * Write message catalog.
 569  *
 570  * The message catalog is first converted from its internal to its
 571  * external representation in a chunk of memory allocated for this
 572  * purpose.  Then the completed catalog is written.  This approach
 573  * avoids additional housekeeping variables and/or a lot of seeks
 574  * that would otherwise be required.
 575  */
 576 void
 577 MCWriteCat(int fd)
 578 {
 579         int     nsets;          /* number of sets */
 580         int     nmsgs;          /* number of msgs */
 581         int     string_size;    /* total size of string pool */
 582         int     msgcat_size;    /* total size of message catalog */
 583         void   *msgcat;         /* message catalog data */
 584         struct _nls_cat_hdr *cat_hdr;
 585         struct _nls_set_hdr *set_hdr;
 586         struct _nls_msg_hdr *msg_hdr;
 587         char   *strings;
 588         struct _setT *set;
 589         struct _msgT *msg;
 590         int     msg_index;
 591         int     msg_offset;
 592
 593         /* determine number of sets, number of messages, and size of the
 594          * string pool */
 595         nsets = 0;
 596         nmsgs = 0;
 597         string_size = 0;
 598
 599         for (set = sethead.lh_first; set != NULL;
 600             set = set->entries.le_next) {
 601                 nsets++;
 602
 603                 for (msg = set->msghead.lh_first; msg != NULL;
 604                     msg = msg->entries.le_next) {
 605                         nmsgs++;
 606                         string_size += strlen(msg->str) + 1;
 607                 }
 608         }
 609
 610 #ifdef DEBUG
 611         printf("number of sets: %d\n", nsets);
 612         printf("number of msgs: %d\n", nmsgs);
 613         printf("string pool size: %d\n", string_size);
 614 #endif
 615
 616         /* determine size and then allocate buffer for constructing external
 617          * message catalog representation */
 618         msgcat_size = sizeof(struct _nls_cat_hdr)
 619             + (nsets * sizeof(struct _nls_set_hdr))
 620             + (nmsgs * sizeof(struct _nls_msg_hdr))
 621             + string_size;
 622
 623         msgcat = xmalloc(msgcat_size);
 624         memset(msgcat, '\0', msgcat_size);
 625
 626         /* fill in msg catalog header */
 627         cat_hdr = (struct _nls_cat_hdr *) msgcat;
 628         cat_hdr->__magic = htonl(_NLS_MAGIC);
 629         cat_hdr->__nsets = htonl(nsets);
 630         cat_hdr->__mem = htonl(msgcat_size - sizeof(struct _nls_cat_hdr));
 631         cat_hdr->__msg_hdr_offset =
 632             htonl(nsets * sizeof(struct _nls_set_hdr));
 633         cat_hdr->__msg_txt_offset =
 634             htonl(nsets * sizeof(struct _nls_set_hdr) +
 635             nmsgs * sizeof(struct _nls_msg_hdr));
 636
 637         /* compute offsets for set & msg header tables and string pool */
 638         set_hdr = (struct _nls_set_hdr *) ((char *) msgcat +
 639             sizeof(struct _nls_cat_hdr));
 640         msg_hdr = (struct _nls_msg_hdr *) ((char *) msgcat +
 641             sizeof(struct _nls_cat_hdr) +
 642             nsets * sizeof(struct _nls_set_hdr));
 643         strings = (char *) msgcat +
 644             sizeof(struct _nls_cat_hdr) +
 645             nsets * sizeof(struct _nls_set_hdr) +
 646             nmsgs * sizeof(struct _nls_msg_hdr);
 647
 648         msg_index = 0;
 649         msg_offset = 0;
 650         for (set = sethead.lh_first; set != NULL;
 651             set = set->entries.le_next) {
 652
 653                 nmsgs = 0;
 654                 for (msg = set->msghead.lh_first; msg != NULL;
 655                     msg = msg->entries.le_next) {
 656                         int     msg_len = strlen(msg->str) + 1;
 657
 658                         msg_hdr->__msgno = htonl(msg->msgId);
 659                         msg_hdr->__msglen = htonl(msg_len);
 660                         msg_hdr->__offset = htonl(msg_offset);
 661
 662                         memcpy(strings, msg->str, msg_len);
 663                         strings += msg_len;
 664                         msg_offset += msg_len;
 665
 666                         nmsgs++;
 667                         msg_hdr++;
 668                 }
 669
 670                 set_hdr->__setno = htonl(set->setId);
 671                 set_hdr->__nmsgs = htonl(nmsgs);
 672                 set_hdr->__index = htonl(msg_index);
 673                 msg_index += nmsgs;
 674                 set_hdr++;
 675         }
 676
 677         /* write out catalog.  XXX: should this be done in small chunks? */
 678         write(fd, msgcat, msgcat_size);
 679 }
 680
 681 void
 682 MCAddSet(int setId)
 683 {
 684         struct _setT *p, *q;
 685
 686         if (setId <= 0) {
 687                 error(NULL, "setId's must be greater than zero");
 688                 /* NOTREACHED */
 689         }
 690         if (setId > NL_SETMAX) {
 691                 error(NULL, "setId exceeds limit");
 692                 /* NOTREACHED */
 693         }
 694
 695         p = sethead.lh_first;
 696         q = NULL;
 697         for (; p != NULL && p->setId < setId; q = p, p = p->entries.le_next);
 698
 699         if (p && p->setId == setId) {
 700                 ;
 701         } else {
 702                 p = xmalloc(sizeof(struct _setT));
 703                 memset(p, '\0', sizeof(struct _setT));
 704                 LIST_INIT(&p->msghead);
 705
 706                 p->setId = setId;
 707
 708                 if (q == NULL) {
 709                         LIST_INSERT_HEAD(&sethead, p, entries);
 710                 } else {
 711                         LIST_INSERT_AFTER(q, p, entries);
 712                 }
 713         }
 714
 715         curSet = p;
 716 }
 717
 718 void
 719 MCAddMsg(int msgId, const char *str)
 720 {
 721         struct _msgT *p, *q;
 722
 723         if (!curSet)
 724                 error(NULL, "can't specify a message when no set exists");
 725
 726         if (msgId <= 0) {
 727                 error(NULL, "msgId's must be greater than zero");
 728                 /* NOTREACHED */
 729         }
 730         if (msgId > NL_MSGMAX) {
 731                 error(NULL, "msgID exceeds limit");
 732                 /* NOTREACHED */
 733         }
 734
 735         p = curSet->msghead.lh_first;
 736         q = NULL;
 737         for (; p != NULL && p->msgId < msgId; q = p, p = p->entries.le_next);
 738
 739         if (p && p->msgId == msgId) {
 740                 free(p->str);
 741         } else {
 742                 p = xmalloc(sizeof(struct _msgT));
 743                 memset(p, '\0', sizeof(struct _msgT));
 744
 745                 if (q == NULL) {
 746                         LIST_INSERT_HEAD(&curSet->msghead, p, entries);
 747                 } else {
 748                         LIST_INSERT_AFTER(q, p, entries);
 749                 }
 750         }
 751
 752         p->msgId = msgId;
 753         p->str = xstrdup(str);
 754 }
 755
 756 void
 757 MCDelSet(int setId)
 758 {
 759         struct _setT *set;
 760         struct _msgT *msg;
 761
 762         set = sethead.lh_first;
 763         for (; set != NULL && set->setId < setId; set = set->entries.le_next);
 764
 765         if (set && set->setId == setId) {
 766
 767                 msg = set->msghead.lh_first;
 768                 while (msg) {
 769                         free(msg->str);
 770                         LIST_REMOVE(msg, entries);
 771                 }
 772
 773                 LIST_REMOVE(set, entries);
 774                 return;
 775         }
 776         warning(NULL, "specified set doesn't exist");
 777 }
 778
 779 void
 780 MCDelMsg(int msgId)
 781 {
 782         struct _msgT *msg;
 783
 784         if (!curSet)
 785                 error(NULL, "you can't delete a message before defining the set");
 786
 787         msg = curSet->msghead.lh_first;
 788         for (; msg != NULL && msg->msgId < msgId; msg = msg->entries.le_next);
 789
 790         if (msg && msg->msgId == msgId) {
 791                 free(msg->str);
 792                 LIST_REMOVE(msg, entries);
 793                 return;
 794         }
 795         warning(NULL, "specified msg doesn't exist");
 796 }