From 5fd83771641d15c418f747bd343ba6738d3875f7 Mon Sep 17 00:00:00 2001 From: Cameron Katri Date: Sun, 9 May 2021 14:20:58 -0400 Subject: Import macOS userland adv_cmds-176 basic_cmds-55 bootstrap_cmds-116.100.1 developer_cmds-66 diskdev_cmds-667.40.1 doc_cmds-53.60.1 file_cmds-321.40.3 mail_cmds-35 misc_cmds-34 network_cmds-606.40.1 patch_cmds-17 remote_cmds-63 shell_cmds-216.60.1 system_cmds-880.60.2 text_cmds-106 --- adv_cmds/gencat/genlib.c | 836 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 836 insertions(+) create mode 100644 adv_cmds/gencat/genlib.c (limited to 'adv_cmds/gencat/genlib.c') diff --git a/adv_cmds/gencat/genlib.c b/adv_cmds/gencat/genlib.c new file mode 100644 index 0000000..42b7ae2 --- /dev/null +++ b/adv_cmds/gencat/genlib.c @@ -0,0 +1,836 @@ +/*********************************************************** +Copyright 1990, by Alfalfa Software Incorporated, Cambridge, Massachusetts. + + All Rights Reserved + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that copyright notice and this permission notice appear in +supporting documentation, and that Alfalfa's name not be used in +advertising or publicity pertaining to distribution of the software +without specific, written prior permission. + +ALPHALPHA DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING +ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL +ALPHALPHA BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR +ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, +WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, +ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS +SOFTWARE. + +If you make any modifications, bugfixes or other changes to this software +we'd appreciate it if you could send a copy to us so we can keep things +up-to-date. Many thanks. + Kee Hinckley + Alfalfa Software, Inc. + 267 Allston St., #3 + Cambridge, MA 02139 USA + nazgul@alfalfa.com + +******************************************************************/ + +#include +__FBSDID("$FreeBSD: src/usr.bin/gencat/genlib.c,v 1.13 2002/12/24 07:40:10 davidxu Exp $"); + +#include +#include +#include +#include +#include +#include +#include "msgcat.h" +#include "gencat.h" +#include +/* libkern/OSByteOrder is needed for the 64 bit byte swap */ +#include + +#ifndef htonll +#define htonll(x) OSSwapHostToBigInt64(x) +#define ntohll(x) OSSwapBigToHostInt64(x) +#endif + +static char *curline = NULL; +static long lineno = 0; + +static void +warning(char *cptr, const char *msg) +{ + warnx("%s on line %ld\n%s", msg, lineno, (curline == NULL ? "" : curline) ); + if (cptr) { + char *tptr; + for (tptr = curline; tptr < cptr; ++tptr) putc(' ', stderr); + fprintf(stderr, "^\n"); + } +} + +static void +error(char *cptr, const char *msg) +{ + warning(cptr, msg); + exit(1); +} + +static void +corrupt(void) { + error(NULL, "corrupt message catalog"); +} + +static void +nomem(void) { + error(NULL, "out of memory"); +} + +static char * +gencat_getline(int fd) +{ + static size_t curlen = BUFSIZ; + static char buf[BUFSIZ], *bptr = buf, *bend = buf; + char *cptr, *cend; + long buflen; + + if (!curline) { + curline = (char *) malloc(curlen); + if (!curline) nomem(); + } + ++lineno; + + cptr = curline; + cend = curline + curlen; + while (TRUE) { + for (; bptr < bend && cptr < cend; ++cptr, ++bptr) { + if (*bptr == '\n') { + *cptr = '\0'; + ++bptr; + return(curline); + } else *cptr = *bptr; + } + if (bptr == bend) { + buflen = read(fd, buf, BUFSIZ); + if (buflen <= 0) { + if (cptr > curline) { + *cptr = '\0'; + return(curline); + } + return(NULL); + } + bend = buf + buflen; + bptr = buf; + } + if (cptr == cend) { + cptr = curline = (char *) realloc(curline, curlen *= 2); + if (!curline) nomem(); + cend = curline + curlen; + } + } +} + +static char * +token(char *cptr) +{ + static char tok[MAXTOKEN+1]; + char *tptr = tok; + + while (*cptr && isspace((unsigned char)*cptr)) ++cptr; + while (*cptr && !isspace((unsigned char)*cptr)) *tptr++ = *cptr++; + *tptr = '\0'; + return(tok); +} + +static char * +wskip(char *cptr) +{ + if (!*cptr || !isspace((unsigned char)*cptr)) { + warning(cptr, "expected a space"); + return(cptr); + } + while (*cptr && isspace((unsigned char)*cptr)) ++cptr; + return(cptr); +} + +static char * +cskip(char *cptr) +{ + if (!*cptr || isspace((unsigned char)*cptr)) { + warning(cptr, "wasn't expecting a space"); + return(cptr); + } + while (*cptr && !isspace((unsigned char)*cptr)) ++cptr; + return(cptr); +} + +static char * +getmsg(int fd, char *cptr, char quote) +{ + static char *msg = NULL; + static size_t msglen = 0; + size_t clen, i; + char *tptr; + int needq; + + if (quote && *cptr == quote) { + needq = TRUE; + ++cptr; + } else needq = FALSE; + + clen = strlen(cptr) + 1; + if (clen > msglen) { + if (msglen) msg = (char *) realloc(msg, clen); + else msg = (char *) malloc(clen); + if (!msg) nomem(); + msglen = clen; + } + tptr = msg; + + while (*cptr) { + if (quote && *cptr == quote) { + char *tmp; + tmp = cptr+1; + if (*tmp && (!isspace((unsigned char)*tmp) || *wskip(tmp))) { + warning(cptr, "unexpected quote character, ignoring"); + *tptr++ = *cptr++; + } else { + *cptr = '\0'; + } + } else if (*cptr == '\\') { + ++cptr; + switch (*cptr) { + case '\0': + cptr = gencat_getline(fd); + if (!cptr) error(NULL, "premature end of file"); + msglen += strlen(cptr); + i = tptr - msg; + msg = (char *) realloc(msg, msglen); + if (!msg) nomem(); + tptr = msg + i; + break; + +#define CASEOF(CS, CH) \ + case CS: \ + *tptr++ = CH; \ + ++cptr; \ + break; + + CASEOF('n', '\n') + CASEOF('t', '\t') + CASEOF('v', '\v') + CASEOF('b', '\b') + CASEOF('r', '\r') + CASEOF('f', '\f') + CASEOF('"', '"') + CASEOF('\'', '\'') + CASEOF('\\', '\\') + + default: + if (isdigit((unsigned char)*cptr)) { + *tptr = 0; + for (i = 0; i < 3; ++i) { + if (!isdigit((unsigned char)*cptr)) break; + if (*cptr > '7') warning(cptr, "octal number greater than 7?!"); + *tptr *= 8; + *tptr += (*cptr - '0'); + ++cptr; + } + ++tptr; + } else { + warning(cptr, "unrecognized escape sequence"); + } + } + } else { + *tptr++ = *cptr++; + } + } + *tptr = '\0'; + return(msg); +} + +static char * +dupstr(const char *ostr) +{ + char *nstr; + + nstr = strdup(ostr); + if (!nstr) error(NULL, "unable to allocate storage"); + return(nstr); +} + +/* + * The Global Stuff + */ + +typedef struct _msgT { + long msgId; + char *str; + char *hconst; + long offset; + struct _msgT *prev, *next; +} msgT; + +typedef struct _setT { + long setId; + char *hconst; + msgT *first, *last; + struct _setT *prev, *next; +} setT; + +typedef struct { + setT *first, *last; +} catT; + +static setT *curSet; +static catT *cat; + +/* + * Find the current byte order. There are of course some others, but + * this will do for now. Note that all we care about is "long". + */ +long +MCGetByteOrder(void) { + long l = 0x00010203; + char *cptr = (char *) &l; + + if (cptr[0] == 0 && cptr[1] == 1 && cptr[2] == 2 && cptr[3] == 3) + return MC68KByteOrder; + else return MCn86ByteOrder; +} + +void +MCParse(int fd) +{ + char *cptr, *str; + int setid = 1, msgid = 0; + char hconst[MAXTOKEN+1]; + char quote = 0; + + if (!cat) { + cat = (catT *) malloc(sizeof(catT)); + if (!cat) nomem(); + bzero(cat, sizeof(catT)); + } + + hconst[0] = '\0'; + + while ((cptr = gencat_getline(fd)) != NULL) { + if (*cptr == '$') { + ++cptr; + if (strncmp(cptr, "set", 3) == 0) { + cptr += 3; + cptr = wskip(cptr); + setid = atoi(cptr); + cptr = cskip(cptr); + if (*cptr) cptr = wskip(cptr); + if (*cptr == '#') { + ++cptr; + MCAddSet(setid, token(cptr)); + } else MCAddSet(setid, NULL); + msgid = 0; + } else if (strncmp(cptr, "delset", 6) == 0) { + cptr += 6; + cptr = wskip(cptr); + setid = atoi(cptr); + MCDelSet(setid); + } else if (strncmp(cptr, "quote", 5) == 0) { + cptr += 5; + if (!*cptr) quote = 0; + else { + cptr = wskip(cptr); + if (!*cptr) quote = 0; + else quote = *cptr; + } + } else if (isspace((unsigned char)*cptr)) { + cptr = wskip(cptr); + if (*cptr == '#') { + ++cptr; + strcpy(hconst, token(cptr)); + } + } else { + if (*cptr) { + cptr = wskip(cptr); + if (*cptr) warning(cptr, "unrecognized line"); + } + } + } else { + if (!curSet) MCAddSet(setid, NULL); + if (isdigit((unsigned char)*cptr) || *cptr == '#') { + if (*cptr == '#') { + ++msgid; + ++cptr; + if (!*cptr) { + MCAddMsg(msgid, "", hconst); + hconst[0] = '\0'; + continue; + } + if (!isspace((unsigned char)*cptr)) warning(cptr, "expected a space"); + ++cptr; + if (!*cptr) { + MCAddMsg(msgid, "", hconst); + hconst[0] = '\0'; + continue; + } + } else { + msgid = atoi(cptr); + cptr = cskip(cptr); + if (isspace(*cptr)) + cptr++; + /* if (*cptr) ++cptr; */ + } + if (!*cptr) { + if (isspace(cptr[-1])) { + MCAddMsg(msgid, "", hconst); + hconst[0] = '\0'; + } else { + MCDelMsg(msgid); + } + } else { + str = getmsg(fd, cptr, quote); + MCAddMsg(msgid, str, hconst); + hconst[0] = '\0'; + } + } + } + } +} + +void +MCReadCat(int fd) +{ + MCHeaderT mcHead; + MCMsgT mcMsg; + MCSetT mcSet; + msgT *msg; + setT *set; + int i; + char *data; + + cat = (catT *) malloc(sizeof(catT)); + if (!cat) nomem(); + bzero(cat, sizeof(catT)); + + /* While we deal with read/write this in network byte order we do NOT + deal with struct member padding issues, or even sizeof(long) issues, + those are left for a future genneration to curse either me, or the + original author for */ + + if (read(fd, &mcHead, sizeof(mcHead)) != sizeof(mcHead)) corrupt(); + if (strncmp(mcHead.magic, MCMagic, MCMagicLen) != 0) corrupt(); + if (ntohl(mcHead.majorVer) != MCMajorVer) error(NULL, "unrecognized catalog version"); + if ((ntohl(mcHead.flags) & MC68KByteOrder) == 0) error(NULL, "wrong byte order"); + + if (lseek(fd, ntohll(mcHead.firstSet), L_SET) == -1) corrupt(); + + while (TRUE) { + if (read(fd, &mcSet, sizeof(mcSet)) != sizeof(mcSet)) corrupt(); + if (mcSet.invalid) continue; + + set = (setT *) malloc(sizeof(setT)); + if (!set) nomem(); + bzero(set, sizeof(*set)); + if (cat->first) { + cat->last->next = set; + set->prev = cat->last; + cat->last = set; + } else cat->first = cat->last = set; + + set->setId = ntohl(mcSet.setId); + + /* Get the data */ + if (mcSet.dataLen) { + data = (char *) malloc((size_t)ntohl(mcSet.dataLen)); + if (!data) nomem(); + if (lseek(fd, ntohll(mcSet.data.off), L_SET) == -1) corrupt(); + if (read(fd, data, (size_t)ntohl(mcSet.dataLen)) != ntohl(mcSet.dataLen)) corrupt(); + if (lseek(fd, ntohll(mcSet.u.firstMsg), L_SET) == -1) corrupt(); + + for (i = 0; i < ntohl(mcSet.numMsgs); ++i) { + if (read(fd, &mcMsg, sizeof(mcMsg)) != sizeof(mcMsg)) corrupt(); + if (mcMsg.invalid) { + --i; + continue; + } + + msg = (msgT *) malloc(sizeof(msgT)); + if (!msg) nomem(); + bzero(msg, sizeof(*msg)); + if (set->first) { + set->last->next = msg; + msg->prev = set->last; + set->last = msg; + } else set->first = set->last = msg; + + msg->msgId = ntohl(mcMsg.msgId); + msg->str = dupstr((char *) (data + ntohll(mcMsg.msg.off))); + } + free(data); + } + if (!mcSet.nextSet) break; + if (lseek(fd, ntohll(mcSet.nextSet), L_SET) == -1) corrupt(); + } +} + + +static void +printS(int fd, const char *str) +{ + if (str) + write(fd, str, strlen(str)); +} + +static void +printL(int fd, long l) +{ + char buf[32]; + sprintf(buf, "%ld", l); + write(fd, buf, strlen(buf)); +} + +static void +printLX(int fd, long l) +{ + char buf[32]; + sprintf(buf, "%lx", l); + write(fd, buf, strlen(buf)); +} + +static void +genconst(int fd, int type, char *setConst, char *msgConst, long val) +{ + switch (type) { + case MCLangC: + if (!msgConst) { + printS(fd, "\n#define "); + printS(fd, setConst); + printS(fd, "Set"); + } else { + printS(fd, "#define "); + printS(fd, setConst); + printS(fd, msgConst); + } + printS(fd, "\t0x"); + printLX(fd, val); + printS(fd, "\n"); + break; + case MCLangCPlusPlus: + case MCLangANSIC: + if (!msgConst) { + printS(fd, "\nconst long "); + printS(fd, setConst); + printS(fd, "Set"); + } else { + printS(fd, "const long "); + printS(fd, setConst); + printS(fd, msgConst); + } + printS(fd, "\t= "); + printL(fd, val); + printS(fd, ";\n"); + break; + default: + error(NULL, "not a recognized (programming) language type"); + } +} + +void +MCWriteConst(int fd, int type, int orConsts) +{ + msgT *msg; + setT *set; + long id; + + if (orConsts && (type == MCLangC || type == MCLangCPlusPlus || type == MCLangANSIC)) { + printS(fd, "/* Use these Macros to compose and decompose setId's and msgId's */\n"); + printS(fd, "#ifndef MCMakeId\n"); + printS(fd, "# define MCMakeId(s,m)\t(unsigned long)(((unsigned short)s<<(sizeof(short)*8))\\\n"); + printS(fd, "\t\t\t\t\t|(unsigned short)m)\n"); + printS(fd, "# define MCSetId(id)\t(unsigned int) (id >> (sizeof(short) * 8))\n"); + printS(fd, "# define MCMsgId(id)\t(unsigned int) ((id << (sizeof(short) * 8))\\\n"); + printS(fd, "\t\t\t\t\t>> (sizeof(short) * 8))\n"); + printS(fd, "#endif\n"); + } + + for (set = cat->first; set; set = set->next) { + if (set->hconst) genconst(fd, type, set->hconst, NULL, set->setId); + + for (msg = set->first; msg; msg = msg->next) { + if (msg->hconst) { + if (orConsts) id = MCMakeId(set->setId, msg->msgId); + else id = msg->msgId; + genconst(fd, type, set->hconst, msg->hconst, id); + free(msg->hconst); + msg->hconst = NULL; + } + } + if (set->hconst) { + free(set->hconst); + set->hconst = NULL; + } + } +} + +void +MCWriteCat(int fd) +{ + MCHeaderT mcHead; + int cnt; + setT *set; + msgT *msg; + MCSetT mcSet; + MCMsgT mcMsg; + off_t pos; + + bcopy(MCMagic, mcHead.magic, MCMagicLen); + mcHead.majorVer = htonl(MCMajorVer); + mcHead.minorVer = htonl(MCMinorVer); + mcHead.flags = htonl(MC68KByteOrder); + mcHead.firstSet = 0; /* We'll be back to set this in a minute */ + + if (cat == NULL) + error(NULL, "cannot write empty catalog set"); + + for (cnt = 0, set = cat->first; set; set = set->next) ++cnt; + mcHead.numSets = htonl(cnt); + + /* I'm not inclined to mess with it, but it looks odd that we write + the header twice...and that we get the firstSet value from another + lseek rather then just 'sizeof(mcHead)' */ + + /* Also, this code doesn't seem to check returns from write! */ + + lseek(fd, (off_t)0L, L_SET); + write(fd, &mcHead, sizeof(mcHead)); + mcHead.firstSet = htonll(lseek(fd, (off_t)0L, L_INCR)); + lseek(fd, (off_t)0L, L_SET); + write(fd, &mcHead, sizeof(mcHead)); + + for (set = cat->first; set; set = set->next) { + bzero(&mcSet, sizeof(mcSet)); + + mcSet.setId = htonl(set->setId); + mcSet.invalid = FALSE; + + /* The rest we'll have to come back and change in a moment */ + pos = lseek(fd, (off_t)0L, L_INCR); + write(fd, &mcSet, sizeof(mcSet)); + + /* Now write all the string data */ + mcSet.data.off = htonll(lseek(fd, (off_t)0L, L_INCR)); + cnt = 0; + for (msg = set->first; msg; msg = msg->next) { + msg->offset = lseek(fd, (off_t)0L, L_INCR) - ntohll(mcSet.data.off); + mcSet.dataLen += write(fd, msg->str, strlen(msg->str) + 1); + ++cnt; + } + mcSet.u.firstMsg = htonll(lseek(fd, (off_t)0L, L_INCR)); + mcSet.numMsgs = htonl(cnt); + mcSet.dataLen = htonl(mcSet.dataLen); + + /* Now write the message headers */ + for (msg = set->first; msg; msg = msg->next) { + mcMsg.msgId = htonl(msg->msgId); + mcMsg.msg.off = htonll(msg->offset); + mcMsg.invalid = FALSE; + write(fd, &mcMsg, sizeof(mcMsg)); + } + + /* Go back and fix things up */ + + if (set == cat->last) { + mcSet.nextSet = 0; + lseek(fd, pos, L_SET); + write(fd, &mcSet, sizeof(mcSet)); + } else { + mcSet.nextSet = htonll(lseek(fd, (off_t)0L, L_INCR)); + lseek(fd, pos, L_SET); + write(fd, &mcSet, sizeof(mcSet)); + lseek(fd, ntohll(mcSet.nextSet), L_SET); + } + } +} + +void +MCAddSet(int setId, char *hconst) +{ + setT *set; + + if (setId <= 0) { + error(NULL, "setId's must be greater than zero"); + return; + } + + if (hconst && !*hconst) hconst = NULL; + for (set = cat->first; set; set = set->next) { + if (set->setId == setId) { + if (set->hconst && hconst) free(set->hconst); + set->hconst = NULL; + break; + } else if (set->setId > setId) { + setT *newSet; + + newSet = (setT *) malloc(sizeof(setT)); + if (!newSet) nomem(); + bzero(newSet, sizeof(setT)); + newSet->prev = set->prev; + newSet->next = set; + if (set->prev) set->prev->next = newSet; + else cat->first = newSet; + set->prev = newSet; + set = newSet; + break; + } + } + if (!set) { + set = (setT *) malloc(sizeof(setT)); + if (!set) nomem(); + bzero(set, sizeof(setT)); + + if (cat->first) { + set->prev = cat->last; + set->next = NULL; + cat->last->next = set; + cat->last = set; + } else { + set->prev = set->next = NULL; + cat->first = cat->last = set; + } + } + set->setId = setId; + if (hconst) set->hconst = dupstr(hconst); + curSet = set; +} + +void +MCAddMsg(int msgId, const char *str, char *hconst) +{ + msgT *msg; + + if (!curSet) + error(NULL, "can't specify a message when no set exists"); + + if (msgId <= 0) { + error(NULL, "msgId's must be greater than zero"); + return; + } + + if (hconst && !*hconst) hconst = NULL; + for (msg = curSet->first; msg; msg = msg->next) { + if (msg->msgId == msgId) { + if (msg->hconst && hconst) free(msg->hconst); + if (msg->str) free(msg->str); + msg->hconst = msg->str = NULL; + break; + } else if (msg->msgId > msgId) { + msgT *newMsg; + + newMsg = (msgT *) malloc(sizeof(msgT)); + if (!newMsg) nomem(); + bzero(newMsg, sizeof(msgT)); + newMsg->prev = msg->prev; + newMsg->next = msg; + if (msg->prev) msg->prev->next = newMsg; + else curSet->first = newMsg; + msg->prev = newMsg; + msg = newMsg; + break; + } + } + if (!msg) { + msg = (msgT *) malloc(sizeof(msgT)); + if (!msg) nomem(); + bzero(msg, sizeof(msgT)); + + if (curSet->first) { + msg->prev = curSet->last; + msg->next = NULL; + curSet->last->next = msg; + curSet->last = msg; + } else { + msg->prev = msg->next = NULL; + curSet->first = curSet->last = msg; + } + } + msg->msgId = msgId; + if (hconst) msg->hconst = dupstr(hconst); + msg->str = dupstr(str); +} + +void +MCDelSet(int setId) +{ + setT *set; + msgT *msg; + + for (set = cat->first; set; set = set->next) { + if (set->setId == setId) { + for (msg = set->first; msg; msg = msg->next) { + if (msg->hconst) free(msg->hconst); + if (msg->str) free(msg->str); + free(msg); + } + if (set->hconst) free(set->hconst); + + if (set->prev) set->prev->next = set->next; + else cat->first = set->next; + + if (set->next) set->next->prev = set->prev; + else cat->last = set->prev; + + free(set); + return; + } else if (set->setId > setId) break; + } + warning(NULL, "specified set doesn't exist"); +} + +void +MCDelMsg(int msgId) +{ + msgT *msg; + + if (!curSet) + error(NULL, "you can't delete a message before defining the set"); + + for (msg = curSet->first; msg; msg = msg->next) { + if (msg->msgId == msgId) { + if (msg->hconst) free(msg->hconst); + if (msg->str) free(msg->str); + + if (msg->prev) msg->prev->next = msg->next; + else curSet->first = msg->next; + + if (msg->next) msg->next->prev = msg->prev; + else curSet->last = msg->prev; + + free(msg); + return; + } else if (msg->msgId > msgId) break; + } + warning(NULL, "specified msg doesn't exist"); +} + +#if 0 /* this function is unsed and looks like debug thing */ + +void +MCDumpcat(fp) +FILE *fp; +{ + msgT *msg; + setT *set; + + if (!cat) + errx(1, "no catalog open"); + + for (set = cat->first; set; set = set->next) { + fprintf(fp, "$set %ld", set->setId); + if (set->hconst) + fprintf(fp, " # %s", set->hconst); + fprintf(fp, "\n\n"); + + for (msg = set->first; msg; msg = msg->next) { + if (msg->hconst) + fprintf(fp, "# %s\n", msg->hconst); + fprintf(fp, "%ld\t%s\n", msg->msgId, msg->str); + } + fprintf(fp, "\n"); + } + +} +#endif /* 0 */ -- cgit v1.2.3-56-ge451