kit

inputs.h (5787B)

---

 #ifndef KIT_DRIVER_INPUTS_H
 #define KIT_DRIVER_INPUTS_H
 
 #include <kit/compile.h>
 #include <kit/link.h>
 #include <kit/object.h>
 
 #include "driver.h"
 
 /* Shared input handling for tools that take a mixed list of C sources,
  * stdin source, object files, and static archives — `kit run` and
  * `kit dbg` today. Owns parallel arrays sized to the worst-case argv
  * slot count plus an optional one-shot stdin slurp.
  *
  * Usage:
  *   DriverInputs in = {0};
  *   if (driver_inputs_init(&in, env, TOOL, argc) != 0) return 1;
  *   for (i = 1; i < argc; ++i) {
  *       int r = driver_inputs_classify(&in, argv[i]);
  *       if (r < 0) { driver_inputs_release(&in); return 1; }
  *       if (r) continue;
  *       ... handle other flags / positionals ...
  *   }
  *   if (driver_inputs_count(&in) == 0) { ... no inputs ... }
  *   rc = driver_inputs_compile_and_jit(&in, compiler, host, &copts, &pp, entry,
  *                                      driver_dlsym_resolver, NULL, &jit);
  *   driver_inputs_release(&in);
  *
  * Path strings (`.c`, `.o`, `.a`) are borrowed from argv. The stdin
  * buffer is heap-owned and freed by driver_inputs_release. */
 typedef struct DriverInputs {
   DriverEnv* env;
   const char* tool;
   size_t bound;
 
   const char** sources; /* .c .cc .cpp paths (borrowed) */
   uint32_t nsources;
   KitSourceInput* source_memory; /* "-" stdin slurp; at most one entry */
   uint32_t nsource_memory;
   uint8_t* stdin_buf; /* owning storage for the one stdin slurp */
   size_t stdin_size;
   const char** object_files; /* .o .obj paths (borrowed) */
   uint32_t nobject_files;
   const char** archives; /* .a paths (borrowed) */
   uint32_t narchives;
 } DriverInputs;
 
 /* Allocate the parallel arrays. `argc` is the worst-case input count
  * (typically the program's argc). `tool` is the short name used in
  * driver_errf messages. Returns 0 on success, 1 on allocation failure
  * (already reported). */
 int driver_inputs_init(DriverInputs*, DriverEnv*, const char* tool, int argc);
 
 /* Release every allocation held by *in, including the stdin buffer.
  * Safe to call even after a failed init. */
 void driver_inputs_release(DriverInputs*);
 
 /* Try to consume one positional input at `arg`. Recognized:
  *   "-"                read C source from stdin (at most once)
  *   *.c *.toy *.s *.wat *.wasm
  *                      source path
  *   *.o *.obj          object-file path
  *   *.a                static-archive path
  *
  * Returns:
  *   1  arg matched and was recorded.
  *   0  arg is not a recognized input shape (caller decides whether to
  *      treat it as an unknown flag, etc.).
  *  -1  arg matched a recognized shape but recording failed (duplicate
  *      stdin, stdin read failure, allocation failure); the error has
  *      already been reported via driver_errf. */
 int driver_inputs_classify(DriverInputs*, const char* arg);
 
 /* Total recorded inputs across every kind. */
 uint32_t driver_inputs_count(const DriverInputs*);
 
 /* Display name of the first recorded input (sources, then source_memory,
  * then object_files, then archives — matches the order used by the
  * link/compile loop). Used by callers to synthesize argv[0] for the
  * JITed program. Returns NULL when no inputs are recorded. */
 const char* driver_inputs_first_name(const DriverInputs*);
 
 /* Load every input through env.file_io, compile sources via `compiler`
  * with `copts` (code/diagnostics) and `pp` (preprocessor settings, applied to
  * preprocessor-enabled frontends), and JIT-link the result. `host` carries
  * execmem/tls; `extern_resolver` populates the JIT link options. `pp` may be
  * NULL for no preprocessor configuration. On success *out_jit owns the JIT
  * image; on failure an error has already been reported. Returns 0 on success,
  * 1 otherwise. */
 int driver_inputs_compile_and_jit(DriverInputs*, KitCompiler*,
                                   const KitJitHost*,
                                   const KitCCompileOptions* copts,
                                   const KitPreprocessOptions* pp,
                                   const char* entry,
                                   void* (*extern_resolver)(void*, KitSlice),
                                   void* extern_resolver_user, KitJit** out_jit);
 
 /* ----------------------------------------------------------------------
  * Per-object global-symbol collection
  *
  * ar / ranlib / strip all need to enumerate the globally-defined symbols
  * of an object file so the archive symbol index (ar/ranlib) or the
  * --strip-unneeded keep-set (strip) can be populated. The shape is
  * always the same: open the object, walk symbols, copy out the names
  * of every SB_GLOBAL symbol with a defining section.
  *
  * driver_collect_obj_global_syms allocates a single heap block laid out
  * as [KitSlice names[count]][NUL-separated name bytes]. The caller
  * frees the block via driver_collect_obj_global_syms_free. Each name
  * slice points into the name-byte region and is NUL-terminated there.
  *
  * Returns:
  *   0  member parsed, output filled (count may be 0 if the object has
  *      no globally-defined symbols, or the member is not a recognized
  *      object file at all — in that case *blob_out is NULL).
  *   1  fatal failure (out of memory, etc.); an error has been reported
  *      via driver_errf using the supplied tool tag.
  */
 int driver_collect_obj_global_syms(DriverEnv* env, const KitContext* ctx,
                                    const char* tool, const KitSlice* member,
                                    void** blob_out, size_t* blob_size_out,
                                    const KitSlice** names_out,
                                    uint32_t* count_out);
 
 void driver_collect_obj_global_syms_free(DriverEnv* env, void* blob,
                                          size_t blob_size);
 
 #endif