kit

ranlib.c (7725B)

---

 #include <kit/archive.h>
 #include <kit/core.h>
 #include <kit/object.h>
 #include <stdint.h>
 
 #include "driver.h"
 #include "inputs.h"
 
 /* `kit ranlib` — refresh / add a System-V `/` symbol-index member at the
  * head of an existing POSIX `ar` archive. Equivalent to `kit ar s ARCHIVE`,
  * which is reserved by the POSIX ar grammar but not yet implemented in the
  * ar tool. ranlib is the conventional name and the one Makefiles invoke.
  *
  * Operation: read all members, rebuild the archive at the same path with
  * symbol_index=1 and per-member globally-defined symbols filled in. Long
  * member names are preserved via the `//` extended-name table. Reproducible
  * output via SOURCE_DATE_EPOCH (same epoch handling as `kit ar`).
  *
  * Per-member symbol collection lives in driver/inputs.c
  * (driver_collect_obj_global_syms) — shared with ar / strip. */
 
 #define RANLIB_TOOL "ranlib"
 
 void driver_help_ranlib(void) {
   driver_printf(
       "%.*s",
       KIT_SLICE_ARG(KIT_SLICE_LIT(
           "kit ranlib — refresh the symbol index of an `ar` archive\n"
           "\n"
           "USAGE\n"
           "  kit ranlib ARCHIVE.a\n"
           "\n"
           "DESCRIPTION\n"
           "  Reads every member of ARCHIVE.a, rebuilds the archive in place\n"
           "  with a System-V `/` symbol-index member at the head. Member "
           "names,\n"
           "  contents, and order are preserved. Reproducible: when\n"
           "  SOURCE_DATE_EPOCH is set to a positive integer, that value is\n"
           "  written to ar_date for every member.\n"
           "\n"
           "  Equivalent to `kit ar s ARCHIVE.a` (the bare `s` modifier is\n"
           "  reserved by the POSIX ar grammar but not yet implemented).\n"
           "\n"
           "OPTIONS\n"
           "  -h, --help        Show this help and exit\n"
           "\n"
           "EXIT CODES\n"
           "  0   success           1   archive I/O error           2   bad "
           "usage\n")));
 }
 
 static uint64_t ranlib_epoch_from_env(void) {
   const char* s = driver_getenv("SOURCE_DATE_EPOCH");
   uint64_t v = 0;
   if (!s || !*s) return 0;
   for (; *s; ++s) {
     if (*s < '0' || *s > '9') return 0;
     v = v * 10 + (uint64_t)(*s - '0');
   }
   return v;
 }
 
 int driver_ranlib(int argc, char** argv) {
   DriverEnv env;
   KitContext ctx;
   KitFileData old_fd = {0};
   KitSlice input;
   KitArIter* it = NULL;
   KitArMember m;
   KitArInput* members = NULL;
   char* name_storage = NULL;
   size_t name_bytes_total = 0;
   uint32_t nmembers = 0;
   uint32_t i;
   KitArMemberSymbols* msyms = NULL;
   void** sym_allocs = NULL;
   size_t* sym_alloc_szs = NULL;
   KitWriter* out = NULL;
   KitArWriteOptions opts = {0};
   const char* archive_path;
   int have_old = 0;
   int rc = 1;
 
   if (argc < 2 || driver_argv_wants_help(argc, argv, 1)) {
     driver_help_ranlib();
     return 0;
   }
   if (argc != 2) {
     driver_errf(RANLIB_TOOL, "usage: kit ranlib ARCHIVE.a");
     return 2;
   }
   archive_path = argv[1];
 
   driver_env_init(&env);
   ctx = driver_env_to_context(&env);
 
   if (ctx.file_io->read_all(ctx.file_io->user, archive_path, &old_fd) !=
       KIT_OK) {
     driver_errf(RANLIB_TOOL, "failed to read: %.*s",
                 KIT_SLICE_ARG(kit_slice_cstr(archive_path)));
     goto out;
   }
   have_old = 1;
   input.data = old_fd.data;
   input.len = old_fd.size;
 
   /* Pass 1: count members and total name bytes (member names returned by
    * the iterator alias an internal buffer overwritten on each next(), so
    * we stash a stable copy). */
   if (kit_ar_iter_new(&ctx, &input, &it) != KIT_OK) {
     driver_errf(RANLIB_TOOL, "not an archive: %.*s",
                 KIT_SLICE_ARG(kit_slice_cstr(archive_path)));
     goto out;
   }
   for (;;) {
     KitIterResult r = kit_ar_iter_next(it, &m);
     if (r != KIT_ITER_ITEM) break;
     nmembers++;
     name_bytes_total += m.name.len + 1;
   }
   kit_ar_iter_free(it);
   it = NULL;
 
   if (nmembers == 0) {
     /* Empty archive — still rewrite with an empty symbol index (matches
      * GNU ranlib's behaviour). */
     if (ctx.file_io->open_writer(ctx.file_io->user, archive_path, &out) !=
         KIT_OK) {
       driver_errf(RANLIB_TOOL, "failed to open: %.*s",
                   KIT_SLICE_ARG(kit_slice_cstr(archive_path)));
       goto out;
     }
     opts.epoch = ranlib_epoch_from_env();
     opts.long_names = 1;
     opts.symbol_index = 1;
     rc = kit_ar_write(out, NULL, 0, &opts) == KIT_OK ? 0 : 1;
     goto out;
   }
 
   members = (KitArInput*)driver_alloc_zeroed(
       &env, (size_t)nmembers * sizeof(*members));
   if (!members) {
     driver_errf(RANLIB_TOOL, "out of memory");
     goto out;
   }
   if (name_bytes_total > 0) {
     name_storage = (char*)driver_alloc_zeroed(&env, name_bytes_total);
     if (!name_storage) {
       driver_errf(RANLIB_TOOL, "out of memory");
       goto out;
     }
   }
 
   /* Pass 2: copy names and member byte-spans into our parallel arrays. */
   if (kit_ar_iter_new(&ctx, &input, &it) != KIT_OK) {
     driver_errf(RANLIB_TOOL, "iter re-open failed");
     goto out;
   }
   {
     size_t cursor = 0;
     uint32_t k = 0;
     while (k < nmembers) {
       KitIterResult r = kit_ar_iter_next(it, &m);
       char* dst;
       size_t j;
       if (r != KIT_ITER_ITEM) break;
       dst = name_storage + cursor;
       for (j = 0; j < m.name.len; ++j) *dst++ = m.name.s[j];
       *dst++ = '\0';
       members[k].name.s = name_storage + cursor;
       members[k].name.len = m.name.len;
       members[k].bytes.data = m.data;
       members[k].bytes.len = m.size;
       cursor = (size_t)(dst - name_storage);
       k++;
     }
   }
   kit_ar_iter_free(it);
   it = NULL;
 
   /* Pass 3: collect per-member global symbols. */
   msyms = (KitArMemberSymbols*)driver_alloc_zeroed(
       &env, (size_t)nmembers * sizeof(*msyms));
   sym_allocs =
       (void**)driver_alloc_zeroed(&env, (size_t)nmembers * sizeof(*sym_allocs));
   sym_alloc_szs = (size_t*)driver_alloc_zeroed(
       &env, (size_t)nmembers * sizeof(*sym_alloc_szs));
   if (!msyms || !sym_allocs || !sym_alloc_szs) {
     driver_errf(RANLIB_TOOL, "out of memory");
     goto out;
   }
   for (i = 0; i < nmembers; ++i) {
     void* blob = NULL;
     size_t blob_size = 0;
     const KitSlice* names = NULL;
     uint32_t count = 0;
     if (driver_collect_obj_global_syms(&env, &ctx, RANLIB_TOOL,
                                        &members[i].bytes, &blob, &blob_size,
                                        &names, &count) != 0) {
       goto out;
     }
     sym_allocs[i] = blob;
     sym_alloc_szs[i] = blob_size;
     msyms[i].names = names;
     msyms[i].count = count;
   }
 
   if (ctx.file_io->open_writer(ctx.file_io->user, archive_path, &out) !=
       KIT_OK) {
     driver_errf(RANLIB_TOOL, "failed to open: %.*s",
                 KIT_SLICE_ARG(kit_slice_cstr(archive_path)));
     goto out;
   }
   opts.epoch = ranlib_epoch_from_env();
   opts.long_names = 1;
   opts.symbol_index = 1;
   opts.member_symbols = msyms;
   rc = kit_ar_write(out, members, nmembers, &opts) == KIT_OK ? 0 : 1;
   if (rc == 0 && kit_writer_status(out) != KIT_OK) rc = 1;
 
 out:
   if (out) kit_writer_close(out);
   if (it) kit_ar_iter_free(it);
   if (sym_allocs) {
     for (i = 0; i < nmembers; ++i) {
       if (sym_allocs[i]) driver_free(&env, sym_allocs[i], sym_alloc_szs[i]);
     }
     driver_free(&env, sym_allocs, (size_t)nmembers * sizeof(*sym_allocs));
   }
   if (sym_alloc_szs)
     driver_free(&env, sym_alloc_szs, (size_t)nmembers * sizeof(*sym_alloc_szs));
   if (msyms) driver_free(&env, msyms, (size_t)nmembers * sizeof(*msyms));
   if (name_storage) driver_free(&env, name_storage, name_bytes_total);
   if (members) driver_free(&env, members, (size_t)nmembers * sizeof(*members));
   if (have_old) ctx.file_io->release(ctx.file_io->user, &old_fd);
   driver_env_fini(&env);
   return rc;
 }