kit

make.c (7637B)

---

 #include <kit/core.h>
 #include <kit/make.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include "driver.h"
 #include "env.h"
 
 #define MAKE_TOOL "make"
 
 void driver_help_make(void) {
   driver_printf(
       "kit make — bring targets up to date from a makefile (POSIX make)\n"
       "\n"
       "USAGE\n"
       "  kit make [-f MAKEFILE] [OPTION]... [MACRO=VALUE]... [TARGET]...\n"
       "\n"
       "DESCRIPTION\n"
       "  Reads one or more makefiles, builds a dependency graph, and runs the\n"
       "  recipes needed to bring the requested targets up to date. Recipes run\n"
       "  through /bin/sh (or the SHELL macro). Ported from the public-domain\n"
       "  pdpmake; supports POSIX-2024 make plus common extensions (include,\n"
       "  ifdef/ifeq, ::, ::=/:=, $(shell), -C).\n"
       "\n"
       "OPTIONS\n"
       "  -f FILE      read FILE as a makefile ('-' reads stdin); may repeat\n"
       "  -C DIR       change to DIR before reading makefiles\n"
       "  -e           environment variables override makefile macros\n"
       "  -i           ignore errors from recipe commands\n"
       "  -k           keep going with unrelated targets after an error\n"
       "  -n           print recipes without running them (dry run)\n"
       "  -p           print the macro and target database\n"
       "  -q           question mode: exit 0 if up to date, 1 if not\n"
       "  -r           do not use the built-in inference rules and macros\n"
       "  -s           do not echo recipe lines\n"
       "  -S           stop on the first error (undo -k)\n"
       "  -t           touch targets instead of running recipes\n"
       "  -j N         accepted for compatibility; recipes run serially\n"
       "  --posix      enforce strict POSIX mode\n"
       "  -h, --help   show this help and exit\n"
       "\n"
       "EXIT CODES\n"
       "  0   success        1   -q: a target is out of date\n"
       "  2   build error or bad command-line usage\n");
 }
 
 /* --- KitMakeHost callbacks, backed by the driver host shims --------------- */
 
 static int mk_mtime(void* user, const char* path, int64_t* out_ns) {
   (void)user;
   return driver_path_mtime_ns(path, out_ns);
 }
 
 static int mk_touch(void* user, const char* path) {
   (void)user;
   return driver_touch(path);
 }
 
 static int mk_remove(void* user, const char* path) {
   (void)user;
   return driver_remove_file(path);
 }
 
 /* An operand of the form NAME=VALUE (with NAME non-empty) is a macro. */
 static const char* macro_eq(const char* s) {
   const char* eq = driver_strchr(s, '=');
   return (eq && eq != s) ? eq : NULL;
 }
 
 int driver_make(int argc, char** argv) {
   DriverEnv env;
   KitContext ctx;
   KitExec ex;
   KitMakeHost host;
   KitMakeOptions opts = {0};
   KitMakeResult result;
   KitWriter* out = NULL;
   KitWriter* err = NULL;
   const char** makefiles = NULL;
   const char** targets = NULL;
   KitMakeVar* macros = NULL;
   size_t nmf = 0, ntg = 0, nmac = 0;
   const char* chdir_to = NULL;
   int want_stdin = 0;
   uint8_t* stdin_buf = NULL;
   size_t stdin_len = 0;
   char* curdir_buf = NULL;
   size_t curdir_size = 0;
   size_t cap = (size_t)(argc > 0 ? argc : 1);
   int rc = 2;
   int i;
 
   if (driver_argv_wants_help(argc, argv, 1)) {
     driver_help_make();
     return 0;
   }
 
   driver_env_init(&env);
   ex = driver_exec(&env);
 
   makefiles = driver_alloc_zeroed(&env, cap * sizeof *makefiles);
   targets = driver_alloc_zeroed(&env, cap * sizeof *targets);
   macros = driver_alloc_zeroed(&env, cap * sizeof *macros);
   if (!makefiles || !targets || !macros) {
     driver_errf(MAKE_TOOL, "out of memory");
     goto done;
   }
 
   for (i = 1; i < argc; ++i) {
     const char* a = argv[i];
     const char* eq;
 
     if (a[0] == '-' && a[1] != '\0') {
       const char* p;
       if (driver_streq(a, "--posix")) {
         opts.flags |= KIT_MAKE_F_POSIX;
         continue;
       }
       if (a[1] == '-') {
         driver_errf(MAKE_TOOL, "unknown option: %s", a);
         goto done;
       }
       for (p = a + 1; *p; ++p) {
         char c = *p;
         if (c == 'f' || c == 'C' || c == 'j') {
           const char* val = p[1] ? p + 1 : NULL;
           if (!val) {
             if (i + 1 < argc)
               val = argv[++i];
             else {
               driver_errf(MAKE_TOOL, "option -%c requires an argument", c);
               goto done;
             }
           }
           if (c == 'f') {
             if (driver_streq(val, "-")) want_stdin = 1;
             makefiles[nmf++] = val;
           } else if (c == 'C') {
             chdir_to = val;
           } else {
             opts.jobs = 1; /* -j: recipes run serially in v1 */
           }
           break; /* the rest of the cluster was the argument */
         }
         switch (c) {
           case 'e': opts.flags |= KIT_MAKE_F_ENV_OVERRIDE; break;
           case 'i': opts.flags |= KIT_MAKE_F_IGNORE_ERR; break;
           case 'k': opts.flags |= KIT_MAKE_F_KEEP_GOING; break;
           case 'n': opts.flags |= KIT_MAKE_F_DRY_RUN; break;
           case 'p': opts.flags |= KIT_MAKE_F_PRINT_DB; break;
           case 'q': opts.flags |= KIT_MAKE_F_QUESTION; break;
           case 'r': opts.flags |= KIT_MAKE_F_NO_BUILTINS; break;
           case 's': opts.flags |= KIT_MAKE_F_SILENT; break;
           case 'S': opts.flags &= ~(uint32_t)KIT_MAKE_F_KEEP_GOING; break;
           case 't': opts.flags |= KIT_MAKE_F_TOUCH; break;
           default:
             driver_errf(MAKE_TOOL, "unknown option: -%c", c);
             goto done;
         }
       }
     } else if ((eq = macro_eq(a)) != NULL) {
       macros[nmac].name.s = a;
       macros[nmac].name.len = (size_t)(eq - a);
       macros[nmac].value.s = eq + 1;
       macros[nmac].value.len = driver_strlen(eq + 1);
       nmac++;
     } else {
       targets[ntg++] = a;
     }
   }
 
   if (want_stdin && !driver_read_stdin(&env, &stdin_buf, &stdin_len)) {
     driver_errf(MAKE_TOOL, "failed to read stdin");
     goto done;
   }
 
   /* Root/working directory: make resolves relative makefile/target paths
    * against it and runs recipes there (the engine never chdir()s). -C selects
    * it, otherwise the current directory. Also becomes $(CURDIR). */
   {
     const char* dir = chdir_to ? chdir_to : ".";
     if (driver_path_canonicalize(&env, dir, &curdir_buf, &curdir_size) != 0) {
       if (chdir_to) {
         driver_errf(MAKE_TOOL, "can't resolve directory %s", chdir_to);
         goto done;
       }
     } else {
       opts.curdir = curdir_buf;
     }
   }
 
   out = driver_stdout_writer(&env);
   err = driver_stderr_writer(&env);
   if (!out || !err) {
     driver_errf(MAKE_TOOL, "failed to open output streams");
     goto done;
   }
 
   host.mtime = mk_mtime;
   host.exec = &ex;
   host.touch = mk_touch;
   host.remove_file = mk_remove;
   host.user = &env;
 
   opts.makefiles = makefiles;
   opts.nmakefiles = nmf;
   opts.targets = targets;
   opts.ntargets = ntg;
   opts.macros = macros;
   opts.nmacros = nmac;
   opts.env = driver_environ();
   opts.shell = NULL; /* engine defaults to /bin/sh; SHELL macro can override */
   opts.stdin_makefile = stdin_buf;
   opts.stdin_makefile_len = stdin_len;
   opts.out = out;
   opts.err = err;
 
   ctx = driver_env_to_context(&env);
   result.exit_code = 2;
   if (kit_make_run(&ctx, &host, &opts, &result) == KIT_OK) rc = result.exit_code;
 
 done:
   if (out) kit_writer_close(out);
   if (err) kit_writer_close(err);
   if (stdin_buf) driver_free(&env, stdin_buf, stdin_len);
   if (curdir_buf) driver_free(&env, curdir_buf, curdir_size);
   if (makefiles) driver_free(&env, makefiles, cap * sizeof *makefiles);
   if (targets) driver_free(&env, targets, cap * sizeof *targets);
   if (macros) driver_free(&env, macros, cap * sizeof *macros);
   driver_env_fini(&env);
   return rc;
 }