mdl_cli_nums.c

Go to the documentation of this file.

#include <errno.h>
#include <math.h>
#include <stdint.h>
#include <stdlib.h>
 
#include "mdl_cli.h"
#include "mdl_cli_internal.h"
#include "ra8_attributes.h"

typedef enum : uint8_t {
  k_cli_dec_base = 10, 
} mdl_cli_parse_t;

typedef enum : uint32_t {
  k_req_timeout_def = 25000U, 
} mdl_cli_timeout_t;

typedef struct {
  unsigned long timeout;   
  unsigned long chapters;  
  unsigned long max_imgs;  
  unsigned long pick;      
  uint64_t      max_bytes; 
} mdl_cli_raw_nums_t;

RA8_INTERNAL static bool internal_cli_parse_ul(const char* s, unsigned long* out)
{
  if (s == nullptr) {
    return false;
  }
  if (s[0] < '0') {
    return false;
  }
  if (s[0] > '9') {
    return false;
  }
  errno                   = 0;
  char*               end = nullptr;
  const unsigned long v   = strtoul(s, &end, k_cli_dec_base);
  if (errno != 0) {
    return false;
  }
  if (*end != '\0') {
    return false;
  }
  *out = v;
  return true;
}

RA8_INTERNAL static bool internal_cli_parse_u64(const char* s, uint64_t* out)
{
  if (s == nullptr) {
    return false;
  }
  if (s[0] < '0') {
    return false;
  }
  if (s[0] > '9') {
    return false;
  }
  errno                        = 0;
  char*                    end = nullptr;
  const unsigned long long v   = strtoull(s, &end, k_cli_dec_base);
  if (errno != 0) {
    return false;
  }
  if (*end != '\0') {
    return false;
  }
  *out = (uint64_t)v;
  return true;
}

RA8_INTERNAL static bool internal_cli_parse_chapter(const char* s, double* out)
{
  if ((s == nullptr) || (out == nullptr) || (s[0] == '\0')) {
    return false;
  }
  errno            = 0;
  char*        end = nullptr;
  const double v   = strtod(s, &end);
  if ((errno != 0) || (end == s) || (*end != '\0') || !isfinite(v)) {
    return false;
  }
  *out = v;
  return true;
}

RA8_INTERNAL static ra8_err_t
internal_cli_reject_integer(ra8_io_stream_t* diagnostic, const char* name, const char* value)
{
  const char* const parts[] = {"mdl: --",
                               name,
                               " expects a non-negative integer, got '",
                               value,
                               "'\n"};
  return priv_mdl_cli_reject_parts(diagnostic, parts, sizeof(parts) / sizeof(parts[0]));
}

RA8_INTERNAL static ra8_err_t internal_cli_reject_limit(ra8_io_stream_t* diagnostic,
                                                        const char*      prefix,
                                                        uint64_t         value,
                                                        const char*      suffix)
{
  const char* const first[] = {prefix};
  ra8_err_t         err     = priv_mdl_cli_put_parts(diagnostic, first, 1U);
  if (err == k_ra8_ok) {
    err = ra8_io_stream_put_u64(diagnostic, value);
  }
  if (err == k_ra8_ok) {
    const char* const last[] = {suffix};
    err                      = priv_mdl_cli_reject_parts(diagnostic, last, 1U);
  }
  return err;
}

RA8_INTERNAL static ra8_err_t internal_cli_opt_ul(ra8_io_stream_t* diagnostic,
                                                  const char*      name,
                                                  const char*      text,
                                                  unsigned long    dflt,
                                                  unsigned long*   out)
{
  if (text == nullptr) {
    *out = dflt;
    return k_ra8_ok;
  }
  unsigned long candidate = 0UL;
  if (!internal_cli_parse_ul(text, &candidate)) {
    return internal_cli_reject_integer(diagnostic, name, text);
  }
  *out = candidate;
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_cli_opt_u64(ra8_io_stream_t* diagnostic,
                                                   const char*      name,
                                                   const char*      text,
                                                   uint64_t         dflt,
                                                   uint64_t*        out)
{
  if (text == nullptr) {
    *out = dflt;
    return k_ra8_ok;
  }
  uint64_t candidate = 0U;
  if (!internal_cli_parse_u64(text, &candidate)) {
    return internal_cli_reject_integer(diagnostic, name, text);
  }
  *out = candidate;
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_cli_parse_num_values(const mdl_args_t*   a,
                                                            ra8_io_stream_t*    diagnostic,
                                                            mdl_nums_t*         out,
                                                            mdl_cli_raw_nums_t* raw)
{
  ra8_err_t err = internal_cli_opt_ul(diagnostic,
                                      "timeout",
                                      a->timeout,
                                      (unsigned long)k_req_timeout_def,
                                      &raw->timeout);
  if (err == k_ra8_ok) {
    err = internal_cli_opt_ul(diagnostic, "chapters", a->chapters, 1UL, &raw->chapters);
  }
  if (err == k_ra8_ok) {
    err = internal_cli_opt_ul(diagnostic, "max", a->max, 0UL, &raw->max_imgs);
  }
  if (err == k_ra8_ok) {
    err = internal_cli_opt_u64(diagnostic, "seed", a->seed, 1U, &out->seed);
  }
  if (err == k_ra8_ok) {
    err = internal_cli_opt_u64(diagnostic, "max-bytes", a->max_bytes, 0U, &raw->max_bytes);
  }
  return err;
}

RA8_INTERNAL static ra8_err_t internal_cli_parse_chapter_pick(const mdl_args_t*   a,
                                                              ra8_io_stream_t*    diagnostic,
                                                              mdl_nums_t*         out,
                                                              mdl_cli_raw_nums_t* raw)
{
  out->from_present = a->from != nullptr;
  out->from_num     = 0.0;
  if ((a->from != nullptr) && !internal_cli_parse_chapter(a->from, &out->from_num)) {
    const char* const parts[] = {"mdl: --from expects a finite chapter number, got '",
                                 a->from,
                                 "'\n"};
    return priv_mdl_cli_reject_parts(diagnostic, parts, sizeof(parts) / sizeof(parts[0]));
  }
  return internal_cli_opt_ul(diagnostic, "pick", a->pick, 0UL, &raw->pick);
}

RA8_INTERNAL static ra8_err_t internal_cli_validate_num_ranges(const mdl_args_t*         a,
                                                               ra8_io_stream_t*          diagnostic,
                                                               const mdl_cli_raw_nums_t* raw)
{
  if ((raw->timeout == 0UL) || (raw->timeout > (unsigned long)UINT32_MAX)) {
    return internal_cli_reject_limit(diagnostic, "mdl: --timeout must be in 1..", UINT32_MAX, "\n");
  }
  if ((raw->chapters == 0UL) || ((uintmax_t)raw->chapters > (uintmax_t)SIZE_MAX)) {
    return internal_cli_reject_limit(diagnostic,
                                     "mdl: --chapters must be in 1..",
                                     (uint64_t)SIZE_MAX,
                                     "\n");
  }
  if (raw->max_imgs > (unsigned long)UINT32_MAX) {
    return internal_cli_reject_limit(diagnostic, "mdl: --max must not exceed ", UINT32_MAX, "\n");
  }
  if ((a->max_bytes != nullptr) && (raw->max_bytes == 0U)) {
    const char* const parts[] = {"mdl: --max-bytes must be greater than zero\n"};
    return priv_mdl_cli_reject_parts(diagnostic, parts, 1U);
  }
  if ((a->pick != nullptr) &&
      ((raw->pick == 0UL) || ((uintmax_t)raw->pick > (uintmax_t)SIZE_MAX))) {
    return internal_cli_reject_limit(diagnostic,
                                     "mdl: --pick must be in 1..",
                                     (uint64_t)SIZE_MAX,
                                     "\n");
  }
  return k_ra8_ok;
}
 
ra8_err_t mdl_cli_parse_nums(const mdl_args_t* a, ra8_io_stream_t* diagnostic, mdl_nums_t* n)
{
  if ((a == nullptr) || (diagnostic == nullptr) || (n == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  mdl_nums_t         candidate = {};
  mdl_cli_raw_nums_t raw       = {};
  ra8_err_t          err       = internal_cli_parse_num_values(a, diagnostic, &candidate, &raw);
  if (err == k_ra8_ok) {
    err = internal_cli_parse_chapter_pick(a, diagnostic, &candidate, &raw);
  }
  if (err == k_ra8_ok) {
    err = internal_cli_validate_num_ranges(a, diagnostic, &raw);
  }
  if (err == k_ra8_ok) {
    candidate.timeout  = (uint32_t)raw.timeout;
    candidate.chapters = (size_t)raw.chapters;
    candidate.max_imgs = (uint32_t)raw.max_imgs;
    candidate.pick     = (size_t)raw.pick;
    *n                 = candidate;
  }
  return err;
}