ref: ae9a74441cba3160943ad18bf500781143bff096
dir: /parse/util.c/
#include <stdlib.h> #include <stdio.h> #include <inttypes.h> #include <stdarg.h> #include <ctype.h> #include <string.h> #include <assert.h> #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #include <unistd.h> #include "parse.h" /* malloc wrappers */ void *zalloc(size_t sz) { void *mem; mem = calloc(1, sz); if (!mem && sz) die("Out of memory"); return mem; } void *xalloc(size_t sz) { void *mem; mem = malloc(sz); if (!mem && sz) die("Out of memory"); return mem; } void *zrealloc(void *mem, size_t oldsz, size_t sz) { char *p; p = xrealloc(mem, sz); if (sz > oldsz) memset(&p[oldsz], 0, sz - oldsz); return p; } void *xrealloc(void *mem, size_t sz) { mem = realloc(mem, sz); if (!mem && sz) die("Out of memory"); return mem; } /* errors */ void die(char *msg, ...) { va_list ap; va_start(ap, msg); vfprintf(stderr, msg, ap); fprintf(stderr, "\n"); va_end(ap); abort(); } void fatal(Node *n, char *msg, ...) { va_list ap; va_start(ap, msg); lfatalv(n->loc, msg, ap); va_end(ap); } void lfatal(Srcloc l, char *msg, ...) { va_list ap; va_start(ap, msg); lfatalv(l, msg, ap); va_end(ap); } void lfatalv(Srcloc l, char *msg, va_list ap) { fprintf(stdout, "%s:%d: ", fname(l), lnum(l)); vfprintf(stdout, msg, ap); fprintf(stdout, "\n"); exit(1); } /* Some systems don't have strndup. */ char *strdupn(char *s, size_t len) { char *ret; ret = xalloc(len + 1); memcpy(ret, s, len); ret[len] = '\0'; return ret; } char *strjoin(char *u, char *v) { size_t n; char *s; n = strlen(u) + strlen(v) + 1; s = xalloc(n); bprintf(s, n + 1, "%s%s", u, v); return s; } void *memdup(void *mem, size_t len) { void *ret; ret = xalloc(len); return memcpy(ret, mem, len); } /* lists */ void lappend(void *l, size_t *len, void *n) { void ***pl; pl = l; *pl = xrealloc(*pl, (*len + 1)*sizeof(void*)); (*pl)[*len] = n; (*len)++; } void *lpop(void *l, size_t *len) { void ***pl; void *v; pl = l; (*len)--; v = (*pl)[*len]; *pl = xrealloc(*pl, *len * sizeof(void*)); return v; } void linsert(void *p, size_t *len, size_t idx, void *v) { void ***pl, **l; pl = p; *pl = xrealloc(*pl, (*len + 1)*sizeof(void*)); l = *pl; memmove(&l[idx + 1], &l[idx], (*len - idx)*sizeof(void*)); l[idx] = v; (*len)++; } void ldel(void *p, size_t *len, size_t idx) { void ***pl, **l; assert(p != NULL); assert(idx < *len); pl = p; l = *pl; memmove(&l[idx], &l[idx + 1], (*len - idx - 1)*sizeof(void*)); (*len)--; *pl = xrealloc(l, *len * sizeof(void*)); } void lfree(void *l, size_t *len) { void ***pl; assert(l != NULL); pl = l; free(*pl); *pl = NULL; *len = 0; } /* endian packing */ void be64(vlong v, byte buf[8]) { buf[0] = (v >> 56) & 0xff; buf[1] = (v >> 48) & 0xff; buf[2] = (v >> 40) & 0xff; buf[3] = (v >> 32) & 0xff; buf[4] = (v >> 24) & 0xff; buf[5] = (v >> 16) & 0xff; buf[6] = (v >> 8) & 0xff; buf[7] = (v >> 0) & 0xff; } vlong host64(byte buf[8]) { vlong v = 0; v |= ((vlong)buf[0] << 56LL); v |= ((vlong)buf[1] << 48LL); v |= ((vlong)buf[2] << 40LL); v |= ((vlong)buf[3] << 32LL); v |= ((vlong)buf[4] << 24LL); v |= ((vlong)buf[5] << 16LL); v |= ((vlong)buf[6] << 8LL); v |= ((vlong)buf[7] << 0LL); return v; } void be32(long v, byte buf[4]) { buf[0] = (v >> 24) & 0xff; buf[1] = (v >> 16) & 0xff; buf[2] = (v >> 8) & 0xff; buf[3] = (v >> 0) & 0xff; } long host32(byte buf[4]) { int32_t v = 0; v |= ((long)buf[0] << 24); v |= ((long)buf[1] << 16); v |= ((long)buf[2] << 8); v |= ((long)buf[3] << 0); return v; } void wrbuf(FILE *fd, void *p, size_t sz) { size_t n; char *buf; n = 0; buf = p; while (n < sz) { n += fwrite(buf + n, 1, sz - n, fd); if (feof(fd)) die("Unexpected EOF"); if (ferror(fd)) die("Error writing"); } } void rdbuf(FILE *fd, void *buf, size_t sz) { size_t n; n = sz; while (n > 0) { n -= fread(buf, 1, n, fd); if (feof(fd)) die("Unexpected EOF"); if (ferror(fd)) die("Error writing"); } } void wrbyte(FILE *fd, char val) { if (fputc(val, fd) == EOF) die("Unexpected EOF"); } char rdbyte(FILE *fd) { int c; c = fgetc(fd); if (c == EOF) die("Unexpected EOF"); return c; } void wrint(FILE *fd, long val) { byte buf[4]; be32(val, buf); wrbuf(fd, buf, 4); } long rdint(FILE *fd) { byte buf[4]; rdbuf(fd, buf, 4); return host32(buf); } void wrstr(FILE *fd, char *val) { size_t len; if (!val) { wrint(fd, -1); } else { wrint(fd, strlen(val)); len = strlen(val); wrbuf(fd, val, len); } } char *rdstr(FILE *fd) { ssize_t len; char *s; len = rdint(fd); if (len == -1) { return NULL; } else { s = xalloc(len + 1); rdbuf(fd, s, len); s[len] = '\0'; return s; } } void wrlenstr(FILE *fd, Str str) { wrint(fd, str.len); wrbuf(fd, str.buf, str.len); } void rdlenstr(FILE *fd, Str *str) { str->len = rdint(fd); str->buf = xalloc(str->len + 1); rdbuf(fd, str->buf, str->len); str->buf[str->len] = '\0'; } void wrflt(FILE *fd, double val) { byte buf[8]; /* Assumption: We have 'val' in 64 bit IEEE format */ union { uvlong ival; double fval; } u; u.fval = val; be64(u.ival, buf); wrbuf(fd, buf, 8); } double rdflt(FILE *fd) { byte buf[8]; union { uvlong ival; double fval; } u; if (fread(buf, 8, 1, fd) < 8) die("Unexpected EOF"); u.ival = host64(buf); return u.fval; } size_t bprintf(char *buf, size_t sz, char *fmt, ...) { va_list ap; size_t n; va_start(ap, fmt); n = vsnprintf(buf, sz, fmt, ap); assert(n <= sz); va_end(ap); return n; } void wrbool(FILE *fd, int val) { wrbyte(fd, val); } int rdbool(FILE *fd) { return rdbyte(fd); } char *swapsuffix(char *buf, size_t sz, char *s, char *suf, char *swap) { size_t slen, suflen, swaplen; slen = strlen(s); suflen = strlen(suf); swaplen = strlen(swap); if (slen < suflen) return NULL; if (slen + swaplen >= sz) die("swapsuffix: buf too small"); buf[0] = '\0'; /* if we have matching suffixes */ if (suflen < slen && !strcmp(suf, &s[slen - suflen])) { strncat(buf, s, slen - suflen); strncat(buf, swap, swaplen); } else { bprintf(buf, sz, "%s%s", s, swap); } return buf; } size_t max(size_t a, size_t b) { if (a > b) return a; else return b; } size_t min(size_t a, size_t b) { if (a < b) return a; else return b; } size_t align(size_t sz, size_t a) { /* align to 0 just returns sz */ if (a == 0) return sz; return (sz + a - 1) & ~(a - 1); } void indentf(int depth, char *fmt, ...) { va_list ap; va_start(ap, fmt); vfindentf(stdout, depth, fmt, ap); va_end(ap); } void findentf(FILE *fd, int depth, char *fmt, ...) { va_list ap; va_start(ap, fmt); vfindentf(fd, depth, fmt, ap); va_end(ap); } void vfindentf(FILE *fd, int depth, char *fmt, va_list ap) { ssize_t i; for (i = 0; i < depth; i++) fprintf(fd, "\t"); vfprintf(fd, fmt, ap); } static int optinfo(Optctx *ctx, char arg, int *take, int *mand) { char *s; for (s = ctx->optstr; *s != '\0'; s++) { if (*s == arg) { s++; if (*s == ':') { *take = 1; *mand = 1; return 1; } else if (*s == '?') { *take = 1; *mand = 0; return 1; } else { *take = 0; *mand = 0; return 1; } } } return 0; } static int findnextopt(Optctx *ctx) { size_t i; for (i = ctx->argidx + 1; i < ctx->noptargs; i++) { if (ctx->optargs[i][0] == '-') goto foundopt; else lappend(&ctx->args, &ctx->nargs, ctx->optargs[i]); } ctx->finished = 1; return 0; foundopt: ctx->argidx = i; ctx->curarg = ctx->optargs[i] + 1; /* skip initial '-' */ return 1; } void optinit(Optctx *ctx, char *optstr, char **optargs, size_t noptargs) { ctx->args = NULL; ctx->nargs = 0; ctx->optstr = optstr; ctx->optargs = optargs; ctx->noptargs = noptargs; ctx->optdone = 0; ctx->finished = 0; ctx->argidx = 0; ctx->curarg = ""; findnextopt(ctx); } int optnext(Optctx *ctx) { int take, mand; int c; c = *ctx->curarg; ctx->curarg++; if (!optinfo(ctx, c, &take, &mand)) { printf("Unexpected argument %c\n", *ctx->curarg); exit(1); } ctx->optarg = NULL; if (take) { if (*ctx->curarg) { ctx->optarg = ctx->curarg; ctx->curarg += strlen(ctx->optarg); } else if (ctx->argidx < ctx->noptargs - 1) { ctx->optarg = ctx->optargs[ctx->argidx + 1]; ctx->argidx++; } else if (mand) { fprintf(stderr, "expected argument for %c\n", *ctx->curarg); } findnextopt(ctx); } else { if (*ctx->curarg == '\0') findnextopt(ctx); } return c; } int optdone(Optctx *ctx) { return *ctx->curarg == '\0' && ctx->finished; }