![[BACK]](/icons/back.gif){kind=icon}
Return to genlib.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / gencat|
Return to genlib.c CVS log | Up to [local] / src / usr.bin / gencat |
1.1 deraadt 1: /* -*-c++-*- */
2:
3:
4: /***********************************************************
5: Copyright 1990, by Alfalfa Software Incorporated, Cambridge, Massachusetts.
6:
7: All Rights Reserved
8:
9: Permission to use, copy, modify, and distribute this software and its
10: documentation for any purpose and without fee is hereby granted,
11: provided that the above copyright notice appear in all copies and that
12: both that copyright notice and this permission notice appear in
13: supporting documentation, and that Alfalfa's name not be used in
14: advertising or publicity pertaining to distribution of the software
15: without specific, written prior permission.
16:
17: ALPHALPHA DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
18: ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
19: ALPHALPHA BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
20: ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
21: WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
22: ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
23: SOFTWARE.
24:
25: If you make any modifications, bugfixes or other changes to this software
26: we'd appreciate it if you could send a copy to us so we can keep things
27: up-to-date. Many thanks.
28: Kee Hinckley
29: Alfalfa Software, Inc.
30: 267 Allston St., #3
31: Cambridge, MA 02139 USA
32: nazgul@alfalfa.com
33:
34: ******************************************************************/
35:
36: /* Edit History
37:
38: 02/25/91 5 nazgul Added flag for MS byteorder
39: 01/14/91 4 nazgul Off by one on number specified entries
40: */
41:
42: #include <stdio.h>
43: #include <stdlib.h>
44: #include <string.h>
45: #ifdef SYSV
46: #include <sys/types.h>
47: #include <unistd.h>
48: #define L_SET SEEK_SET
49: #define L_INCR SEEK_CUR
50: #include <memory.h>
51: static int bcopy(src, dst, length)
52: char *src, *dst;
53: int length;
54: {
55: memcpy(dst, src, length);
56: }
57: static int bzero(b, length)
58: char *b;
59: int length;
60: {
61: memset(b, '\0', length);
62: }
63: #endif
64: #include <sys/file.h>
65: #include <ctype.h>
66: #include "msgcat.h"
67: #include "gencat.h"
68:
69: static char *curline = NULL;
70: static long lineno = 0;
71:
72: static void warning(cptr, msg)
73: char *cptr;
74: char *msg;
75: {
76: fprintf(stderr, "gencat: %s on line %d\n", msg, lineno);
77: fprintf(stderr, "%s\n", curline);
78: if (cptr) {
79: char *tptr;
80: for (tptr = curline; tptr < cptr; ++tptr) putc(' ', stderr);
81: fprintf(stderr, "^\n");
82: }
83: }
84:
85: static void error(cptr, msg)
86: char *cptr;
87: char *msg;
88: {
89: warning(cptr, msg);
90: exit(1);
91: }
92:
93: static void corrupt() {
94: error(NULL, "corrupt message catalog");
95: }
96: static void nomem() {
97: error(NULL, "out of memory");
98: }
99:
100: static char *getline(fd)
101: int fd;
102: {
103: static long len = 0, curlen = BUFSIZ;
104: static char buf[BUFSIZ], *bptr = buf, *bend = buf;
105: char *cptr, *cend;
106: long buflen;
107:
108: if (!curline) {
109: curline = (char *) malloc(curlen);
110: if (!curline) nomem();
111: }
112: ++lineno;
113:
114: cptr = curline;
115: cend = curline + curlen;
116: while (True) {
117: for (; bptr < bend && cptr < cend; ++cptr, ++bptr) {
118: if (*bptr == '\n') {
119: *cptr = '\0';
120: ++bptr;
121: return(curline);
122: } else *cptr = *bptr;
123: }
124: if (bptr == bend) {
125: buflen = read(fd, buf, BUFSIZ);
126: if (buflen <= 0) {
127: if (cptr > curline) {
128: *cptr = '\0';
129: return(curline);
130: }
131: return(NULL);
132: }
133: bend = buf + buflen;
134: bptr = buf;
135: }
136: if (cptr == cend) {
137: cptr = curline = (char *) realloc(curline, curlen *= 2);
138: cend = curline + curlen;
139: }
140: }
141: }
142:
143:
144: static char *token(cptr)
145: char *cptr;
146: {
147: static char tok[MAXTOKEN+1];
148: char *tptr = tok;
149:
150: while (*cptr && isspace(*cptr)) ++cptr;
151: while (*cptr && !isspace(*cptr)) *tptr++ = *cptr++;
152: *tptr = '\0';
153: return(tok);
154: }
155: static char *wskip(cptr)
156: char *cptr;
157: {
158: if (!*cptr || !isspace(*cptr)) {
159: warning(cptr, "expected a space");
160: return(cptr);
161: }
162: while (*cptr && isspace(*cptr)) ++cptr;
163: return(cptr);
164: }
165: static char *cskip(cptr)
166: char *cptr;
167: {
168: if (!*cptr || isspace(*cptr)) {
169: warning(cptr, "wasn't expecting a space");
170: return(cptr);
171: }
172: while (*cptr && !isspace(*cptr)) ++cptr;
173: return(cptr);
174: }
175:
176: static char *getmsg(fd, cptr, quote)
177: int fd;
178: char *cptr;
179: char quote;
180: {
181: static char *msg = NULL;
182: static long msglen = 0;
183: long clen, i;
184: char *tptr;
185:
186: int needq;
187:
188: if (quote && *cptr == quote) {
189: needq = True;
190: ++cptr;
191: } else needq = False;
192:
193: clen = strlen(cptr) + 1;
194: if (clen > msglen) {
195: if (msglen) msg = (char *) realloc(msg, clen);
196: else msg = (char *) malloc(clen);
197: msglen = clen;
198: }
199: tptr = msg;
200:
201: while (*cptr) {
202: if (quote && *cptr == quote) {
203: char *tmp;
204: tmp = cptr+1;
205: if (*tmp && (!isspace(*tmp) || *wskip(tmp))) {
206: warning(cptr, "unexpected quote character, ignoreing");
207: *tptr++ = *cptr++;
208: } else {
209: *cptr = '\0';
210: }
211: } else if (*cptr == '\\') {
212: ++cptr;
213: switch (*cptr) {
214: case '\0':
215: cptr = getline(fd);
216: if (!cptr) error(NULL, "premature end of file");
217: msglen += strlen(cptr);
218: i = tptr - msg;
219: msg = (char *) realloc(msg, msglen);
220: tptr = msg + i;
221: break;
222: case 'n':
223: *tptr++ = '\n';
224: ++cptr;
225: break;
226: case 't':
227: *tptr++ = '\t';
228: ++cptr;
229: break;
230: case 'v':
231: *tptr++ = '\v';
232: ++cptr;
233: break;
234: case 'b':
235: *tptr++ = '\b';
236: ++cptr;
237: break;
238: case 'r':
239: *tptr++ = '\r';
240: ++cptr;
241: break;
242: case 'f':
243: *tptr++ = '\f';
244: ++cptr;
245: break;
246: case '\\':
247: *tptr++ = '\\';
248: ++cptr;
249: break;
250: default:
251: if (isdigit(*cptr)) {
252: *tptr = 0;
253: for (i = 0; i < 3; ++i) {
254: if (!isdigit(*cptr)) break;
255: if (*cptr > '7') warning(cptr, "octal number greater than 7?!");
256: *tptr *= 8;
257: *tptr += (*cptr - '0');
258: ++cptr;
259: }
260: } else {
261: warning(cptr, "unrecognized escape sequence");
262: }
263: }
264: } else {
265: *tptr++ = *cptr++;
266: }
267: }
268: *tptr = '\0';
269: return(msg);
270: }
271:
272:
273:
274: static char *dupstr(ostr)
275: char *ostr;
276: {
277: char *nstr;
278:
279: nstr = (char *) malloc(strlen(ostr) + 1);
280: if (!nstr) error(NULL, "unable to allocate storage");
281: strcpy(nstr, ostr);
282: return(nstr);
283: }
284:
285:
286: /*
287: * The Global Stuff
288: */
289:
290:
291: typedef struct _msgT {
292: long msgId;
293: char *str;
294: char *hconst;
295: long offset;
296: struct _msgT *prev, *next;
297: } msgT;
298: typedef struct _setT {
299: long setId;
300: char *hconst;
301: msgT *first, *last;
302: struct _setT *prev, *next;
303: } setT;
304: typedef struct {
305: setT *first, *last;
306: } catT;
307:
308: static setT *curSet;
309: static catT *cat;
310:
311: /*
312: * Find the current byte order. There are of course some others, but this will do
313: * for now. Note that all we care about is "long".
314: */
315: long MCGetByteOrder() {
316: long l = 0x00010203;
317: char *cptr = (char *) &l;
318:
319: if (cptr[0] == 0 && cptr[1] == 1 && cptr[2] == 2 && cptr[3] == 3)
320: return MC68KByteOrder;
321: else return MCn86ByteOrder;
322: }
323:
324:
325: void MCParse(
326: #if PROTO
327: int fd)
328: #else
329: fd)
330: int fd;
331: #endif
332: {
333: char *cptr, *str;
334: int setid, msgid = 0;
335: char hconst[MAXTOKEN+1];
336: char quote = 0;
337: int i;
338:
339: if (!cat) {
340: cat = (catT *) malloc(sizeof(catT));
341: if (!cat) nomem();
342: bzero(cat, sizeof(catT));
343: }
344:
345: hconst[0] = '\0';
346:
347: while (cptr = getline(fd)) {
348: if (*cptr == '$') {
349: ++cptr;
350: if (strncmp(cptr, "set", 3) == 0) {
351: cptr += 3;
352: cptr = wskip(cptr);
353: setid = atoi(cptr);
354: cptr = cskip(cptr);
355: if (*cptr) cptr = wskip(cptr);
356: if (*cptr == '#') {
357: ++cptr;
358: MCAddSet(setid, token(cptr));
359: } else MCAddSet(setid, NULL);
360: msgid = 0;
361: } else if (strncmp(cptr, "delset", 6) == 0) {
362: cptr += 6;
363: cptr = wskip(cptr);
364: setid = atoi(cptr);
365: MCDelSet(setid);
366: } else if (strncmp(cptr, "quote", 5) == 0) {
367: cptr += 5;
368: if (!*cptr) quote = 0;
369: else {
370: cptr = wskip(cptr);
371: if (!*cptr) quote = 0;
372: else quote = *cptr;
373: }
374: } else if (isspace(*cptr)) {
375: cptr = wskip(cptr);
376: if (*cptr == '#') {
377: ++cptr;
378: strcpy(hconst, token(cptr));
379: }
380: } else {
381: if (*cptr) {
382: cptr = wskip(cptr);
383: if (*cptr) warning(cptr, "unrecognized line");
384: }
385: }
386: } else {
387: if (isdigit(*cptr) || *cptr == '#') {
388: if (*cptr == '#') {
389: ++msgid;
390: ++cptr;
391: if (!*cptr) {
392: MCAddMsg(msgid, "", hconst);
393: hconst[0] = '\0';
394: continue;
395: }
396: if (!isspace(*cptr)) warning(cptr, "expected a space");
397: ++cptr;
398: if (!*cptr) {
399: MCAddMsg(msgid, "", hconst);
400: hconst[0] = '\0';
401: continue;
402: }
403: } else {
404: msgid = atoi(cptr);
405: cptr = cskip(cptr);
406: cptr = wskip(cptr);
407: /* if (*cptr) ++cptr; */
408: }
409: if (!*cptr) MCDelMsg(msgid);
410: else {
411: str = getmsg(fd, cptr, quote);
412: MCAddMsg(msgid, str, hconst);
413: hconst[0] = '\0';
414: }
415: }
416: }
417: }
418: }
419:
420: void MCReadCat(
421: #if PROTO
422: int fd)
423: #else
424: fd)
425: int fd;
426: #endif
427: {
428: MCHeaderT mcHead;
429: MCMsgT mcMsg;
430: MCSetT mcSet;
431: msgT *msg;
432: setT *set;
433: int i;
434: char *data;
435:
436: cat = (catT *) malloc(sizeof(catT));
437: if (!cat) nomem();
438: bzero(cat, sizeof(catT));
439:
440: if (read(fd, &mcHead, sizeof(mcHead)) != sizeof(mcHead)) corrupt();
441: if (strncmp(mcHead.magic, MCMagic, MCMagicLen) != 0) corrupt();
442: if (mcHead.majorVer != MCMajorVer) error(NULL, "unrecognized catalog version");
443: if ((mcHead.flags & MCGetByteOrder()) == 0) error(NULL, "wrong byte order");
444:
445: if (lseek(fd, mcHead.firstSet, L_SET) == -1) corrupt();
446:
447: while (True) {
448: if (read(fd, &mcSet, sizeof(mcSet)) != sizeof(mcSet)) corrupt();
449: if (mcSet.invalid) continue;
450:
451: set = (setT *) malloc(sizeof(setT));
452: if (!set) nomem();
453: bzero(set, sizeof(*set));
454: if (cat->first) {
455: cat->last->next = set;
456: set->prev = cat->last;
457: cat->last = set;
458: } else cat->first = cat->last = set;
459:
460: set->setId = mcSet.setId;
461:
462: /* Get the data */
463: if (mcSet.dataLen) {
464: data = (char *) malloc(mcSet.dataLen);
465: if (!data) nomem();
466: if (lseek(fd, mcSet.data.off, L_SET) == -1) corrupt();
467: if (read(fd, data, mcSet.dataLen) != mcSet.dataLen) corrupt();
468: if (lseek(fd, mcSet.u.firstMsg, L_SET) == -1) corrupt();
469:
470: for (i = 0; i < mcSet.numMsgs; ++i) {
471: if (read(fd, &mcMsg, sizeof(mcMsg)) != sizeof(mcMsg)) corrupt();
472: if (mcMsg.invalid) {
473: --i;
474: continue;
475: }
476:
477: msg = (msgT *) malloc(sizeof(msgT));
478: if (!msg) nomem();
479: bzero(msg, sizeof(*msg));
480: if (set->first) {
481: set->last->next = msg;
482: msg->prev = set->last;
483: set->last = msg;
484: } else set->first = set->last = msg;
485:
486: msg->msgId = mcMsg.msgId;
487: msg->str = dupstr((char *) (data + mcMsg.msg.off));
488: }
489: free(data);
490: }
491: if (!mcSet.nextSet) break;
492: if (lseek(fd, mcSet.nextSet, L_SET) == -1) corrupt();
493: }
494: }
495:
496:
497: static void printS(fd, str)
498: int fd;
499: char *str;
500: {
501: write(fd, str, strlen(str));
502: }
503: static void printL(fd, l)
504: int fd;
505: long l;
506: {
507: char buf[32];
508: sprintf(buf, "%ld", l);
509: write(fd, buf, strlen(buf));
510: }
511: static void printLX(fd, l)
512: int fd;
513: long l;
514: {
515: char buf[32];
516: sprintf(buf, "%lx", l);
517: write(fd, buf, strlen(buf));
518: }
519:
520: static void genconst(fd, type, setConst, msgConst, val)
521: int fd;
522: int type;
523: char *setConst;
524: char *msgConst;
525: long val;
526: {
527: switch (type) {
528: case MCLangC:
529: if (!msgConst) {
530: printS(fd, "\n#define ");
531: printS(fd, setConst);
532: printS(fd, "Set");
533: } else {
534: printS(fd, "#define ");
535: printS(fd, setConst);
536: printS(fd, msgConst);
537: }
538: printS(fd, "\t0x");
539: printLX(fd, val);
540: printS(fd, "\n");
541: break;
542: case MCLangCPlusPlus:
543: case MCLangANSIC:
544: if (!msgConst) {
545: printS(fd, "\nconst long ");
546: printS(fd, setConst);
547: printS(fd, "Set");
548: } else {
549: printS(fd, "const long ");
550: printS(fd, setConst);
551: printS(fd, msgConst);
552: }
553: printS(fd, "\t= ");
554: printL(fd, val);
555: printS(fd, ";\n");
556: break;
557: default:
558: error(NULL, "not a recognized (programming) language type");
559: }
560: }
561:
562: void MCWriteConst(
563: #if PROTO
564: int fd, int type, int orConsts)
565: #else
566: fd, type, orConsts)
567: int fd;
568: int type;
569: int orConsts;
570: #endif
571: {
572: msgT *msg;
573: setT *set;
574: long id;
575:
576: if (orConsts && (type == MCLangC || type == MCLangCPlusPlus || type == MCLangANSIC)) {
577: printS(fd, "/* Use these Macros to compose and decompose setId's and msgId's */\n");
578: printS(fd, "#ifndef MCMakeId\n");
579: printS(fd, "# define MCMakeId(s,m)\t(unsigned long)(((unsigned short)s<<(sizeof(short)*8))\\\n");
580: printS(fd, "\t\t\t\t\t|(unsigned short)m)\n");
581: printS(fd, "# define MCSetId(id)\t(unsigned int) (id >> (sizeof(short) * 8))\n");
582: printS(fd, "# define MCMsgId(id)\t(unsigned int) ((id << (sizeof(short) * 8))\\\n");
583: printS(fd, "\t\t\t\t\t>> (sizeof(short) * 8))\n");
584: printS(fd, "#endif\n");
585: }
586:
587: for (set = cat->first; set; set = set->next) {
588: if (set->hconst) genconst(fd, type, set->hconst, NULL, set->setId);
589:
590: for (msg = set->first; msg; msg = msg->next) {
591: if (msg->hconst) {
592: if (orConsts) id = MCMakeId(set->setId, msg->msgId);
593: else id = msg->msgId;
594: genconst(fd, type, set->hconst, msg->hconst, id);
595: free(msg->hconst);
596: msg->hconst = NULL;
597: }
598: }
599: if (set->hconst) {
600: free(set->hconst);
601: set->hconst = NULL;
602: }
603: }
604: }
605:
606: void MCWriteCat(
607: #if PROTO
608: int fd)
609: #else
610: fd)
611: int fd;
612: #endif
613: {
614: MCHeaderT mcHead;
615: int cnt;
616: setT *set;
617: msgT *msg;
618: MCSetT mcSet;
619: MCMsgT mcMsg;
620: off_t pos;
621:
622: bcopy(MCMagic, mcHead.magic, MCMagicLen);
623: mcHead.majorVer = MCMajorVer;
624: mcHead.minorVer = MCMinorVer;
625: mcHead.flags = MCGetByteOrder();
626: mcHead.firstSet = 0; /* We'll be back to set this in a minute */
627:
628: for (cnt = 0, set = cat->first; set; set = set->next) ++cnt;
629: mcHead.numSets = cnt;
630:
631: lseek(fd, 0L, L_SET);
632: write(fd, &mcHead, sizeof(mcHead));
633: mcHead.firstSet = lseek(fd, 0, L_INCR);
634: lseek(fd, 0L, L_SET);
635: write(fd, &mcHead, sizeof(mcHead));
636:
637: for (set = cat->first; set; set = set->next) {
638: bzero(&mcSet, sizeof(mcSet));
639:
640: mcSet.setId = set->setId;
641: mcSet.invalid = False;
642:
643: /* The rest we'll have to come back and change in a moment */
644: pos = lseek(fd, 0, L_INCR);
645: write(fd, &mcSet, sizeof(mcSet));
646:
647: /* Now write all the string data */
648: mcSet.data.off = lseek(fd, 0, L_INCR);
649: cnt = 0;
650: for (msg = set->first; msg; msg = msg->next) {
651: msg->offset = lseek(fd, 0, L_INCR) - mcSet.data.off;
652: mcSet.dataLen += write(fd, msg->str, strlen(msg->str) + 1);
653: ++cnt;
654: }
655: mcSet.u.firstMsg = lseek(fd, 0, L_INCR);
656: mcSet.numMsgs = cnt;
657:
658: /* Now write the message headers */
659: for (msg = set->first; msg; msg = msg->next) {
660: mcMsg.msgId = msg->msgId;
661: mcMsg.msg.off = msg->offset;
662: mcMsg.invalid = False;
663: write(fd, &mcMsg, sizeof(mcMsg));
664: }
665:
666: /* Go back and fix things up */
667:
668: if (set == cat->last) {
669: mcSet.nextSet = 0;
670: lseek(fd, pos, L_SET);
671: write(fd, &mcSet, sizeof(mcSet));
672: } else {
673: mcSet.nextSet = lseek(fd, 0, L_INCR);
674: lseek(fd, pos, L_SET);
675: write(fd, &mcSet, sizeof(mcSet));
676: lseek(fd, mcSet.nextSet, L_SET);
677: }
678: }
679: }
680:
681:
682: void MCAddSet(
683: #if PROTO
684: int setId, char *hconst)
685: #else
686: setId, hconst)
687: int setId;
688: char *hconst;
689: #endif
690: {
691: setT *set;
692:
693: if (setId <= 0) {
694: error(NULL, "setId's must be greater than zero");
695: return;
696: }
697:
698: if (hconst && !*hconst) hconst = NULL;
699: for (set = cat->first; set; set = set->next) {
700: if (set->setId == setId) {
701: if (set->hconst && hconst) free(set->hconst);
702: set->hconst = NULL;
703: break;
704: } else if (set->setId > setId) {
705: setT *newSet;
706:
707: newSet = (setT *) malloc(sizeof(setT));
708: if (!newSet) nomem();
709: bzero(newSet, sizeof(setT));
710: newSet->prev = set->prev;
711: newSet->next = set;
712: if (set->prev) set->prev->next = newSet;
713: else cat->first = newSet;
714: set->prev = newSet;
715: set = newSet;
716: break;
717: }
718: }
719: if (!set) {
720: set = (setT *) malloc(sizeof(setT));
721: if (!set) nomem();
722: bzero(set, sizeof(setT));
723:
724: if (cat->first) {
725: set->prev = cat->last;
726: set->next = NULL;
727: cat->last->next = set;
728: cat->last = set;
729: } else {
730: set->prev = set->next = NULL;
731: cat->first = cat->last = set;
732: }
733: }
734: set->setId = setId;
735: if (hconst) set->hconst = dupstr(hconst);
736: curSet = set;
737: }
738:
739: void MCAddMsg(
740: #if PROTO
741: int msgId, char *str, char *hconst)
742: #else
743: msgId, str, hconst)
744: int msgId;
745: char *str;
746: char *hconst;
747: #endif
748: {
749: msgT *msg;
750:
751: if (!curSet) error(NULL, "can't specify a message when no set exists");
752:
753: if (msgId <= 0) {
754: error(NULL, "msgId's must be greater than zero");
755: return;
756: }
757:
758: if (hconst && !*hconst) hconst = NULL;
759: for (msg = curSet->first; msg; msg = msg->next) {
760: if (msg->msgId == msgId) {
761: if (msg->hconst && hconst) free(msg->hconst);
762: if (msg->str) free(msg->str);
763: msg->hconst = msg->str = NULL;
764: break;
765: } else if (msg->msgId > msgId) {
766: msgT *newMsg;
767:
768: newMsg = (msgT *) malloc(sizeof(msgT));
769: if (!newMsg) nomem();
770: bzero(newMsg, sizeof(msgT));
771: newMsg->prev = msg->prev;
772: newMsg->next = msg;
773: if (msg->prev) msg->prev->next = newMsg;
774: else curSet->first = newMsg;
775: msg->prev = newMsg;
776: msg = newMsg;
777: break;
778: }
779: }
780: if (!msg) {
781: msg = (msgT *) malloc(sizeof(msgT));
782: if (!msg) nomem();
783: bzero(msg, sizeof(msgT));
784:
785: if (curSet->first) {
786: msg->prev = curSet->last;
787: msg->next = NULL;
788: curSet->last->next = msg;
789: curSet->last = msg;
790: } else {
791: msg->prev = msg->next = NULL;
792: curSet->first = curSet->last = msg;
793: }
794: }
795: msg->msgId = msgId;
796: if (hconst) msg->hconst = dupstr(hconst);
797: msg->str = dupstr(str);
798: }
799:
800: void MCDelSet(
801: #if PROTO
802: int setId)
803: #else
804: setId)
805: int setId;
806: #endif
807: {
808: setT *set;
809: msgT *msg;
810:
811: for (set = cat->first; set; set = set->next) {
812: if (set->setId == setId) {
813: for (msg = set->first; msg; msg = msg->next) {
814: if (msg->hconst) free(msg->hconst);
815: if (msg->str) free(msg->str);
816: free(msg);
817: }
818: if (set->hconst) free(set->hconst);
819:
820: if (set->prev) set->prev->next = set->next;
821: else cat->first = set->next;
822:
823: if (set->next) set->next->prev = set->prev;
824: else cat->last = set->prev;
825:
826: free(set);
827: return;
828: } else if (set->setId > setId) break;
829: }
830: warning(NULL, "specified set doesn't exist");
831: }
832:
833: void MCDelMsg(
834: #if PROTO
835: int msgId)
836: #else
837: msgId)
838: int msgId;
839: #endif
840: {
841: msgT *msg;
842:
843: if (!curSet) error(NULL, "you can't delete a message before defining the set");
844:
845: for (msg = curSet->first; msg; msg = msg->next) {
846: if (msg->msgId == msgId) {
847: if (msg->hconst) free(msg->hconst);
848: if (msg->str) free(msg->str);
849:
850: if (msg->prev) msg->prev->next = msg->next;
851: else curSet->first = msg->next;
852:
853: if (msg->next) msg->next->prev = msg->prev;
854: else curSet->last = msg->prev;
855:
856: free(msg);
857: return;
858: } else if (msg->msgId > msgId) break;
859: }
860: warning(NULL, "specified msg doesn't exist");
861: }
862:
863: void MCDumpcat(fp)
864: FILE *fp;
865: {
866: msgT *msg;
867: setT *set;
868:
869: if (!cat) {
870: fprintf(stderr, "No catalog open\n");
871: exit (1);
872: }
873:
874: for (set = cat->first; set; set = set->next) {
875: fprintf(fp, "$set %d", set->setId);
876: if (set->hconst)
877: fprintf(fp, " # %s", set->hconst);
878: fprintf(fp, "\n\n");
879:
880: for (msg = set->first; msg; msg = msg->next) {
881: if (msg->hconst)
882: fprintf(fp, "# %s\n", msg->hconst);
883: fprintf(fp, "%d\t%s\n", msg->msgId, msg->str);
884: }
885: fprintf(fp, "\n");
886: }
887:
888: }