kit

cflags.c (5526B)

---

 #include "cflags.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 int driver_cflags_init(DriverCflags* cf, DriverEnv* env, int argc_bound) {
   size_t bound = argc_bound > 0 ? (size_t)argc_bound + 4u : 4u;
   cf->_cap = bound;
   cf->include_dirs =
       driver_alloc_zeroed(env, bound * sizeof(*cf->include_dirs));
   cf->system_include_dirs =
       driver_alloc_zeroed(env, bound * sizeof(*cf->system_include_dirs));
   cf->defines = driver_alloc_zeroed(env, bound * sizeof(*cf->defines));
   cf->_owned_define_names =
       driver_alloc_zeroed(env, bound * sizeof(*cf->_owned_define_names));
   cf->_owned_define_name_sizes =
       driver_alloc_zeroed(env, bound * sizeof(*cf->_owned_define_name_sizes));
   cf->undefines = driver_alloc_zeroed(env, bound * sizeof(*cf->undefines));
   if (!cf->include_dirs || !cf->system_include_dirs || !cf->defines ||
       !cf->_owned_define_names || !cf->_owned_define_name_sizes ||
       !cf->undefines) {
     return 1;
   }
   return 0;
 }
 
 void driver_cflags_fini(DriverCflags* cf, DriverEnv* env) {
   size_t cap = cf->_cap;
   uint32_t i;
   if (cf->_owned_define_names) {
     for (i = 0; i < cf->ndefines; ++i) {
       if (cf->_owned_define_names[i]) {
         driver_free(env, cf->_owned_define_names[i],
                     cf->_owned_define_name_sizes[i]);
       }
     }
   }
   driver_free(env, cf->include_dirs, cap * sizeof(*cf->include_dirs));
   driver_free(env, cf->system_include_dirs,
               cap * sizeof(*cf->system_include_dirs));
   driver_free(env, cf->defines, cap * sizeof(*cf->defines));
   driver_free(env, cf->_owned_define_names,
               cap * sizeof(*cf->_owned_define_names));
   driver_free(env, cf->_owned_define_name_sizes,
               cap * sizeof(*cf->_owned_define_name_sizes));
   driver_free(env, cf->undefines, cap * sizeof(*cf->undefines));
   cf->_cap = 0;
 }
 
 /* Split `name[=body]` into a heap-owned NUL-terminated name and a body that
  * aliases the original argv tail. Returns 0 on success, 1 on alloc failure. */
 static int cflags_record_define(DriverCflags* cf, DriverEnv* env,
                                 const char* arg) {
   const char* eq = driver_strchr(arg, '=');
   KitDefine* d = &cf->defines[cf->ndefines];
   if (eq) {
     size_t n = (size_t)(eq - arg);
     size_t bytes = n + 1;
     char* name = driver_alloc(env, bytes);
     if (!name) return 1;
     driver_memcpy(name, arg, n);
     name[n] = '\0';
     cf->_owned_define_names[cf->ndefines] = name;
     cf->_owned_define_name_sizes[cf->ndefines] = bytes;
     d->name = (KitSlice){.s = name, .len = n};
     d->body = kit_slice_cstr(eq + 1);
   } else {
     d->name = kit_slice_cstr(arg);
     d->body = KIT_SLICE_NULL;
   }
   cf->ndefines++;
   return 0;
 }
 
 /* Pull the value for a flag that accepts either `-Xvalue` or `-X value`.
  * `prefix_len` is the byte length of `-X` itself (e.g. 2 for `-I`/`-D`/`-U`,
  * larger for `-isystem`). On the attached form (`-Xvalue`) returns argv[*i]
  * + prefix_len without advancing. On the separate form, advances *i to the
  * value slot and returns argv[*i]; if no value follows, reports a diagnostic
  * and returns NULL. */
 static const char* cflags_pull_value(const char* tool, int argc, char** argv,
                                      int* i, size_t prefix_len,
                                      const char* flag_label) {
   const char* a = argv[*i];
   if (a[prefix_len]) return a + prefix_len;
   if (++(*i) >= argc) {
     driver_errf(tool, "%.*s requires an argument",
                 KIT_SLICE_ARG(kit_slice_cstr(flag_label)));
     return NULL;
   }
   return argv[*i];
 }
 
 int driver_cflags_try_consume(DriverCflags* cf, DriverEnv* env,
                               const char* tool, int argc, char** argv, int* i) {
   const char* a = argv[*i];
 
   if (driver_strneq(a, "-I", 2)) {
     const char* dir = cflags_pull_value(tool, argc, argv, i, 2, "-I");
     if (!dir) return -1;
     cf->include_dirs[cf->ninclude_dirs++] = dir;
     return 1;
   }
 
   if (driver_streq(a, "-isystem")) {
     if (++(*i) >= argc) {
       driver_errf(tool, "-isystem requires an argument");
       return -1;
     }
     cf->system_include_dirs[cf->nsystem_include_dirs++] = argv[*i];
     return 1;
   }
 
   if (driver_strneq(a, "-iquote", 7)) {
     const char* dir = cflags_pull_value(tool, argc, argv, i, 7, "-iquote");
     if (!dir) return -1;
     cf->include_dirs[cf->ninclude_dirs++] = dir;
     return 1;
   }
 
   if (driver_strneq(a, "-idirafter", 10)) {
     const char* dir = cflags_pull_value(tool, argc, argv, i, 10, "-idirafter");
     if (!dir) return -1;
     cf->system_include_dirs[cf->nsystem_include_dirs++] = dir;
     return 1;
   }
 
   if (driver_strneq(a, "-D", 2)) {
     const char* arg = cflags_pull_value(tool, argc, argv, i, 2, "-D");
     if (!arg) return -1;
     if (cflags_record_define(cf, env, arg) != 0) {
       driver_errf(tool, "out of memory");
       return -1;
     }
     return 1;
   }
 
   if (driver_strneq(a, "-U", 2)) {
     const char* arg = cflags_pull_value(tool, argc, argv, i, 2, "-U");
     if (!arg) return -1;
     cf->undefines[cf->nundefines++] = kit_slice_cstr(arg);
     return 1;
   }
 
   return 0;
 }
 
 void driver_cflags_fill_pp(const DriverCflags* cf, KitPreprocessOptions* pp) {
   KitPreprocessOptions z = {0};
   *pp = z;
   pp->include_dirs = cf->include_dirs;
   pp->ninclude_dirs = cf->ninclude_dirs;
   pp->system_include_dirs = cf->system_include_dirs;
   pp->nsystem_include_dirs = cf->nsystem_include_dirs;
   pp->defines = cf->defines;
   pp->ndefines = cf->ndefines;
   pp->undefines = cf->undefines;
   pp->nundefines = cf->nundefines;
 }