ra8_fmt_portable_main.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <stdint.h>
#include <string.h>
#include <unistd.h>
 
#include "ra8_attributes.h"
#include "ra8_fmt_host_fd_internal.h"
#include "ra8_fmt_portable_main_internal.h"
#include "ra8_fmt_stream.h"

typedef enum : uint32_t {
  k_cli_exit_ok       = 0U,         
  k_cli_exit_fail     = 1U,         
  k_cli_exit_usage    = 2U,         
  k_cli_input_cap     = 268435456U, 
  k_cli_decimal_radix = 10U,        
  k_cli_decimal_chars = 20U,        
} cli_const_t;

typedef enum : uint8_t {
  k_cli_format_none   = 0U, 
  k_cli_format_jof    = 1U, 
  k_cli_format_rabook = 2U, 
} cli_format_t;

RA8_INTERNAL
static ra8_err_t internal_text(const ra8_fmt_sink_t* sink, const char* text)
{
  return sink->write(sink->ctx, (const uint8_t*)text, strlen(text));
}

RA8_INTERNAL
static ra8_err_t internal_u64(const ra8_fmt_sink_t* sink, uint64_t value)
{
  char   reverse[k_cli_decimal_chars];
  size_t count = 0U;
  do {
    reverse[count++] = (char)('0' + (char)(value % k_cli_decimal_radix));
    value /= k_cli_decimal_radix;
  } while (value != 0U);
  char text[k_cli_decimal_chars];
  for (size_t i = 0U; i < count; ++i) {
    text[i] = reverse[count - i - 1U];
  }
  return sink->write(sink->ctx, (const uint8_t*)text, count);
}

RA8_INTERNAL
static void internal_error_status(const ra8_fmt_sink_t* sink, const char* prefix, ra8_err_t status)
{
  ra8_err_t rc = internal_text(sink, prefix);
  if (rc == k_ra8_ok) {
    rc = internal_u64(sink, (uint64_t)status);
  }
  if (rc == k_ra8_ok) {
    (void)internal_text(sink, ")\n");
  }
}

RA8_INTERNAL
static bool
internal_parse(int argc, char** argv, const char** input, const char** format, bool* verbose)
{
  for (int i = 2; i < argc; ++i) {
    if ((strcmp(argv[i], "--verbose") == 0) || (strcmp(argv[i], "-v") == 0)) {
      *verbose = true;
    } else if ((strcmp(argv[i], "--format") == 0) && ((i + 1) < argc)) {
      *format = argv[++i];
    } else if ((strcmp(argv[i], "--in") == 0) && ((i + 1) < argc)) {
      *input = argv[++i];
    } else if ((strcmp(argv[i], "--out") == 0) && ((i + 1) < argc)) {
      ++i;
    } else if ((argv[i][0] != '-') && (*input == nullptr)) {
      *input = argv[i];
    } else {
      return false;
    }
  }
  return true;
}

RA8_INTERNAL
static ra8_err_t
internal_format(const ra8_fmt_source_t* source, const char* explicit_name, cli_format_t* format)
{
  *format = k_cli_format_none;
  if (explicit_name != nullptr) {
    if (strcmp(explicit_name, "jof") == 0) {
      *format = k_cli_format_jof;
    } else if (strcmp(explicit_name, "rabook") == 0) {
      *format = k_cli_format_rabook;
    }
    return k_ra8_ok;
  }
  uint8_t         magic[4U];
  size_t          got = 0U;
  const ra8_err_t rc  = source->read_at(source->ctx, 0U, magic, sizeof(magic), &got);
  if (rc != k_ra8_ok) {
    return rc;
  }
  if ((got == sizeof(magic)) && (memcmp(magic, "JOF1", sizeof(magic)) == 0)) {
    *format = k_cli_format_jof;
  } else if ((got == sizeof(magic)) && (memcmp(magic, "RBKC", sizeof(magic)) == 0)) {
    *format = k_cli_format_rabook;
  }
  return k_ra8_ok;
}

RA8_INTERNAL
static void internal_workspace_error(const ra8_fmt_sink_t*           sink,
                                     const jof_audit_requirements_t* need)
{
  ra8_err_t rc = internal_text(sink, "ra8_fmt: JOF inspect workspace too small: records ");
  if (rc == k_ra8_ok) {
    rc = internal_u64(sink, need->record_count);
  }
  if (rc == k_ra8_ok) {
    rc = internal_text(sink, "/65536, tile ");
  }
  if (rc == k_ra8_ok) {
    rc = internal_u64(sink, need->tile_bytes);
  }
  if (rc == k_ra8_ok) {
    rc = internal_text(sink, "/4194304, scratch ");
  }
  if (rc == k_ra8_ok) {
    rc = internal_u64(sink, need->scratch_bytes);
  }
  if (rc == k_ra8_ok) {
    (void)internal_text(sink, "/4718848\n");
  }
}

RA8_INTERNAL
static int internal_run_jof(const ra8_fmt_source_t*  source,
                            bool                     verbose,
                            ra8_fmt_cli_workspace_t* workspace,
                            const ra8_fmt_sink_t*    output,
                            const ra8_fmt_sink_t*    errors)
{
  jof_audit_requirements_t need = {};
  ra8_err_t rc = jof_audit_requirements(source->read_at, source->ctx, source->size, &need);
  if (rc != k_ra8_ok) {
    internal_error_status(errors, "JOF parse FAILED (rc=", rc);
    return (int)k_cli_exit_fail;
  }
  if ((need.record_count > k_ra8_fmt_cli_record_cap) ||
      (need.tile_bytes > k_ra8_fmt_cli_tile_cap) ||
      (need.scratch_bytes > k_ra8_fmt_cli_scratch_cap)) {
    internal_workspace_error(errors, &need);
    return (int)k_cli_exit_fail;
  }
  const size_t records_bytes = sizeof(jof_audit_record_t) * (size_t)k_ra8_fmt_cli_record_cap;
  ra8_fmt_jof_inspect_workspace_t inspect_workspace = {
    .records     = (jof_audit_record_t*)workspace->bytes,
    .record_cap  = k_ra8_fmt_cli_record_cap,
    .tile        = &workspace->bytes[records_bytes],
    .tile_cap    = k_ra8_fmt_cli_tile_cap,
    .scratch     = &workspace->bytes[records_bytes + k_ra8_fmt_cli_tile_cap],
    .scratch_cap = k_ra8_fmt_cli_scratch_cap,
  };
  rc = ra8_fmt_jof_inspect_stream(source, verbose, &inspect_workspace, output);
  return (rc == k_ra8_ok) ? (int)k_cli_exit_ok : (int)k_cli_exit_fail;
}

RA8_INTERNAL
static int internal_run_rabook(const ra8_fmt_source_t*  source,
                               bool                     verbose,
                               ra8_fmt_cli_workspace_t* workspace,
                               const ra8_fmt_sink_t*    output)
{
  const size_t table_bytes = (size_t)k_ra8_fmt_cli_rbkc_table_cap * sizeof(uint64_t);
  ra8_fmt_rabook_inspect_workspace_t inspect_workspace = {
    .table          = (uint64_t*)workspace->bytes,
    .table_cap      = k_ra8_fmt_cli_rbkc_table_cap,
    .compressed     = &workspace->bytes[table_bytes],
    .compressed_cap = k_ra8_fmt_cli_rbkc_compressed_cap,
    .chunk          = &workspace->bytes[table_bytes + k_ra8_fmt_cli_rbkc_compressed_cap],
    .chunk_cap      = k_ra8_fmt_cli_rbkc_chunk_cap,
    .scratch =
      &workspace
         ->bytes[table_bytes + k_ra8_fmt_cli_rbkc_compressed_cap + k_ra8_fmt_cli_rbkc_chunk_cap],
    .scratch_cap = k_ra8_fmt_cli_rbkc_scratch_cap,
  };
  const ra8_err_t rc = ra8_fmt_rabook_inspect_stream(source, verbose, &inspect_workspace, output);
  return (rc == k_ra8_ok) ? (int)k_cli_exit_ok : (int)k_cli_exit_fail;
}

RA8_INTERNAL
static int internal_open(const char*              input,
                         const char*              explicit_name,
                         bool                     verbose,
                         ra8_fmt_cli_workspace_t* workspace,
                         bool*                    handled,
                         const ra8_fmt_sink_t*    errors)
{
  ra8_fmt_host_source_t host_source = {.fd = -1};
  ra8_err_t             rc     = priv_fmt_host_source_open(input, k_cli_input_cap, &host_source);
  cli_format_t          format = k_cli_format_none;
  if (rc == k_ra8_ok) {
    rc = internal_format(&host_source.source, explicit_name, &format);
  }
  if (rc != k_ra8_ok) {
    internal_error_status(errors, "ra8_fmt: cannot open inspect input (rc=", rc);
    return (int)k_cli_exit_fail;
  }
  if (format == k_cli_format_none) {
    priv_fmt_host_source_close(&host_source);
    *handled = false;
    return (int)k_cli_exit_ok;
  }
  ra8_fmt_host_fd_sink_t output_state = {.fd = STDOUT_FILENO};
  const ra8_fmt_sink_t   output       = priv_fmt_host_fd_sink(&output_state);
  const int status = (format == k_cli_format_jof)
                       ? internal_run_jof(&host_source.source, verbose, workspace, &output, errors)
                       : internal_run_rabook(&host_source.source, verbose, workspace, &output);
  priv_fmt_host_source_close(&host_source);
  return status;
}
 
RA8_PRIV int priv_fmt_try_portable_inspect(int                      argc,
                                           char**                   argv,
                                           ra8_fmt_cli_workspace_t* workspace,
                                           bool*                    handled)
{
  if ((handled == nullptr) || (workspace == nullptr)) {
    return (int)k_cli_exit_fail;
  }
  *handled = false;
  if ((argc < 2) || (strcmp(argv[1], "inspect") != 0)) {
    return (int)k_cli_exit_ok;
  }
  const char*            input       = nullptr;
  const char*            format      = nullptr;
  bool                   verbose     = false;
  ra8_fmt_host_fd_sink_t error_state = {.fd = STDERR_FILENO};
  const ra8_fmt_sink_t   errors      = priv_fmt_host_fd_sink(&error_state);
  if (!internal_parse(argc, argv, &input, &format, &verbose)) {
    *handled = true;
    (void)internal_text(&errors, "ra8_fmt: invalid inspect arguments\n");
    return (int)k_cli_exit_usage;
  }
  *handled = true;
  if (input == nullptr) {
    (void)internal_text(&errors, "ra8_fmt: no input file given\n");
    return (int)k_cli_exit_usage;
  }
  return internal_open(input, format, verbose, workspace, handled, &errors);
}