kit

utils.c (4992B)

---

 /*
  * Utility functions: arena-backed allocation, diagnostics that longjmp instead
  * of exit(), and output routed through the KitWriter sinks. Ported from
  * pdpmake utils.c. Part of the src/api/make.c amalgamation.
  */
 #include "make.h"
 
 /* ---- allocation (arena; OOM longjmps via mk_error) ----------------------- */
 
 static void* mk_alloc(MakeCtx* mc, size_t n) {
   void* p = arena_alloc(&mc->arena, n ? n : 1, 16);
   if (!p) mk_error(mc, "out of memory");
   return p;
 }
 
 static void* mk_realloc(MakeCtx* mc, void* p, size_t oldn, size_t newn) {
   void* q = mk_alloc(mc, newn);
   if (p && oldn) memcpy(q, p, oldn < newn ? oldn : newn);
   return q;
 }
 
 static char* mk_strdup(MakeCtx* mc, const char* s) {
   size_t len;
   char* t;
   if (s == NULL) return NULL;
   len = strlen(s);
   t = mk_alloc(mc, len + 1);
   memcpy(t, s, len + 1);
   return t;
 }
 
 static char* mk_strndup(MakeCtx* mc, const char* s, size_t n) {
   size_t len = 0;
   char* t;
   while (len < n && s[len] != '\0') ++len;
   t = mk_alloc(mc, len + 1);
   memcpy(t, s, len);
   t[len] = '\0';
   return t;
 }
 
 static char* mk_concat3(MakeCtx* mc, const char* s1, const char* s2,
                         const char* s3) {
   const size_t len1 = strlen(s1);
   const size_t len2 = strlen(s2);
   const size_t len3 = strlen(s3);
   char* t = mk_alloc(mc, len1 + len2 + len3 + 1);
   char* s = t;
   s = (char*)memcpy(s, s1, len1) + len1;
   s = (char*)memcpy(s, s2, len2) + len2;
   s = (char*)memcpy(s, s3, len3) + len3;
   *s = '\0';
   return t;
 }
 
 /*
  * Append a word to a space-separated string of words. The first call should
  * pass NULL for str. Unlike pdpmake there is no free() -- the arena owns the
  * old string, which is left to be reclaimed wholesale.
  */
 static char* mk_appendword(MakeCtx* mc, const char* str, const char* word) {
   return str ? mk_concat3(mc, str, " ", word) : mk_strdup(mc, word);
 }
 
 /* ---- error handling: longjmp back to kit_make_run ------------------------ */
 
 static void mk_exit(MakeCtx* mc, int code) {
   mc->exit_code = code;
   longjmp(mc->jmpbuf, 1);
 }
 
 /*
  * Format "myname: (makefile:line): message\n" to a writer. Mirrors pdpmake's
  * vwarning but targets a KitWriter instead of a stdio stream.
  */
 static void mk_vwarn(MakeCtx* mc, KitWriter* w, const char* fmt, va_list ap) {
   char buf[2048];
   size_t cap = sizeof buf;
   size_t n = 0;
   int r;
   const char* m = NULL;
   int d = 0;
 
   if (mc->curr_cmd) {
     m = mc->curr_cmd->c_makefile;
     d = mc->curr_cmd->c_dispno;
   } else if (mc->makefile) {
     m = mc->makefile;
     d = mc->dispno;
   }
 
   r = snprintf(buf + n, cap - n, "%s: ", mc->myname ? mc->myname : "make");
   if (r > 0) n += (size_t)r < cap - n ? (size_t)r : cap - n - 1;
   if (m) {
     r = snprintf(buf + n, cap - n, "(%s:%d): ", m, d);
     if (r > 0) n += (size_t)r < cap - n ? (size_t)r : cap - n - 1;
   }
   r = vsnprintf(buf + n, cap - n, fmt, ap);
   if (r > 0) n += (size_t)r < cap - n ? (size_t)r : cap - n - 1;
   if (n >= cap) n = cap - 1;
   buf[n] = '\n';
   n++;
   if (w) kit_writer_write(w, buf, n);
 }
 
 static void mk_error(MakeCtx* mc, const char* fmt, ...) {
   va_list ap;
   va_start(ap, fmt);
   mk_vwarn(mc, mc->err, fmt, ap);
   va_end(ap);
   mk_exit(mc, 2);
 }
 
 static void mk_warning(MakeCtx* mc, const char* fmt, ...) {
   va_list ap;
   va_start(ap, fmt);
   mk_vwarn(mc, mc->out, fmt, ap); /* pdpmake sends warnings to stdout */
   va_end(ap);
 }
 
 static void mk_diagnostic(MakeCtx* mc, const char* fmt, ...) {
   va_list ap;
   va_start(ap, fmt);
   mk_vwarn(mc, mc->err, fmt, ap);
   va_end(ap);
 }
 
 static void mk_error_unexpected(MakeCtx* mc, const char* s) {
   mk_error(mc, "unexpected %s", s);
 }
 
 static void mk_error_in_inference_rule(MakeCtx* mc, const char* s) {
   mk_error(mc, "%s in inference rule", s);
 }
 
 static void mk_error_not_allowed(MakeCtx* mc, const char* s, const char* t) {
   mk_error(mc, "%s not allowed for %s", s, t);
 }
 
 /* ---- output through the KitWriter sinks ---------------------------------- */
 
 static void mk_out_bytes(MakeCtx* mc, const char* p, size_t n) {
   if (mc->out && n) kit_writer_write(mc->out, p, n);
 }
 
 static void mk_out(MakeCtx* mc, const char* s) {
   if (s) mk_out_bytes(mc, s, strlen(s));
 }
 
 static void mk_outc(MakeCtx* mc, char c) { mk_out_bytes(mc, &c, 1); }
 
 static void mk_outf(MakeCtx* mc, const char* fmt, ...) {
   char buf[2048];
   va_list ap;
   int r;
   va_start(ap, fmt);
   r = vsnprintf(buf, sizeof buf, fmt, ap);
   va_end(ap);
   if (r < 0) return;
   mk_out_bytes(mc, buf, (size_t)r < sizeof buf ? (size_t)r : sizeof buf - 1);
 }
 
 /* ---- misc ---------------------------------------------------------------- */
 
 static unsigned mk_getbucket(const char* name) {
   unsigned hashval = 0;
   const unsigned char* p = (const unsigned char*)name;
   while (*p) hashval ^= (unsigned)(hashval << 5) + (hashval >> 2) + *p++;
   return hashval % HTABSIZE;
 }
 
 static const char* mk_path(MakeCtx* mc, const char* name) {
   if (!mc->root || !name || name[0] == '/') return name;
   return mk_concat3(mc, mc->root, "/", name);
 }