param.c

Go to the documentation of this file.

// Copyright (c) 2026 The YAC Authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <float.h>
#include <limits.h>
 
#include "parameter/param_internal.h"
#include "utils_common.h"
#include "yac_assert.h"
#include "geometry.h"
 
static char error_buf[ERROR_BUF_SIZE] = {'\0'};
 
struct yac_param {
  struct yac_param_vtable const *vtable;
  // ... implementation-specific fields ...
};
 
enum yac_param_type yac_param_get_type(const struct yac_param *param) {
  if (!param) {
    // Empty parameter
    return YAC_PARAM_TYPE_EMPTY;
  }
  YAC_ASSERT_F(
    param->vtable && param->vtable->get_type,
    "vtable or get_type is NULL for parameter '%s'",
    (param->vtable && param->vtable->get_name) ?
      yac_param_get_name(param) : "(unknown)");
  return param->vtable->get_type(param);
}
 
int yac_param_is_default(const struct yac_param *param) {
  if (!param) {
    // Empty parameter is always default
    return 1;
  }
  YAC_ASSERT_F(
    param->vtable && param->vtable->is_default,
    "vtable or is_default is NULL for parameter '%s'",
    (param->vtable && param->vtable->get_name) ?
      yac_param_get_name(param) : "(unknown)");
  return param->vtable->is_default(param);
}
 
const char *yac_param_get_name(const struct yac_param *param) {
  if (!param) {
    // Empty parameter has no name
    return NULL;
  }
  YAC_ASSERT(
    param->vtable && param->vtable->get_name,
    "vtable or get_name is NULL");
  return param->vtable->get_name(param);
}
 
int yac_param_get_sub_count(const struct yac_param *param, size_t *count) {
  YAC_ASSERT(count, "count is NULL");
  if (!param) {
    *count = 0;
    return 0;
  }
  YAC_ASSERT_F(
    param->vtable && param->vtable->get_sub_count,
    "vtable or get_sub_count is NULL for parameter '%s'",
    (param->vtable && param->vtable->get_name) ?
      yac_param_get_name(param) : "(unknown)");
  return param->vtable->get_sub_count(param, count);
}
 
int yac_param_get_sub_by_name(
  struct yac_param *param, const char *name, struct yac_param **sub_param) {
  YAC_ASSERT(name, "name is NULL");
  YAC_ASSERT(sub_param, "sub_param is NULL");
  *sub_param = NULL;
  YAC_PARAM_ASSERT(param, "param is NULL");
  YAC_ASSERT_F(
    param->vtable && param->vtable->get_sub_by_name,
    "vtable or get_sub_by_name is NULL for parameter '%s'",
    (param->vtable && param->vtable->get_name) ?
      yac_param_get_name(param) : "(unknown)");
  return param->vtable->get_sub_by_name(param, name, sub_param);
}
 
int yac_param_get_sub_by_index(
  struct yac_param *param, size_t idx, struct yac_param **sub_param) {
  YAC_ASSERT(sub_param, "sub_param is NULL");
  *sub_param = NULL;
  YAC_PARAM_ASSERT(param, "param is NULL");
  YAC_ASSERT_F(
    param->vtable && param->vtable->get_sub_by_index,
    "vtable or get_sub_by_index is NULL for parameter '%s'",
    (param->vtable && param->vtable->get_name) ?
      yac_param_get_name(param) : "(unknown)");
  return param->vtable->get_sub_by_index(param, idx, sub_param);
}
 
int yac_param_append(struct yac_param *param, struct yac_param **sub_param) {
  YAC_PARAM_ASSERT(
    param, "unsupported operation for empty parameter");
  YAC_ASSERT_F(
    param->vtable && param->vtable->append,
    "vtable or append is NULL for parameter '%s'",
    (param->vtable && param->vtable->get_name) ?
      yac_param_get_name(param) : "(unknown)");
  return param->vtable->append(param, sub_param);
}
 
int yac_param_set_scalar(
  struct yac_param *param, const char *value_str) {
  YAC_PARAM_ASSERT(
    param, "unsupported operation for empty parameter");
  YAC_PARAM_ASSERT(
    param->vtable && param->vtable->set_scalar,
    "string-based setter not supported by this parameter");
  return param->vtable->set_scalar(param, value_str);
}
 
int yac_param_get_scalar(
  const struct yac_param *param, char *buf, size_t buflen) {
  if (!param && buf && buflen) buf[0] = '\0';
  YAC_PARAM_ASSERT(
    param, "unsupported operation for empty parameter");
  YAC_PARAM_ASSERT(
    param->vtable && param->vtable->get_scalar,
    "string-based getter not supported by this parameter");
  return param->vtable->get_scalar(param, buf, buflen);
}
 
int yac_param_set_scalar_int(struct yac_param *param, int value) {
  YAC_PARAM_ASSERT(
    param, "unsupported operation for empty parameter");
  YAC_PARAM_ASSERT(
    param->vtable && param->vtable->set_scalar_int,
    "integer-based setter not supported by this parameter");
  return param->vtable->set_scalar_int(param, value);
}
 
int yac_param_set_scalar_dble(struct yac_param *param, double value) {
  YAC_PARAM_ASSERT(
    param, "unsupported operation for empty parameter");
  YAC_PARAM_ASSERT(
    param->vtable && param->vtable->set_scalar_dble,
    "double-based setter not supported by this parameter");
  return param->vtable->set_scalar_dble(param, value);
}
 
int yac_param_get_scalar_int(const struct yac_param *param, int *value) {
  YAC_PARAM_ASSERT(
    param, "unsupported operation for empty parameter");
  YAC_PARAM_ASSERT(
    param->vtable && param->vtable->get_scalar_int,
    "integer-based getter not supported by this parameter");
  return param->vtable->get_scalar_int(param, value);
}
 
int yac_param_get_scalar_dble(const struct yac_param *param, double *value) {
  YAC_PARAM_ASSERT(
    param, "unsupported operation for empty parameter");
  YAC_PARAM_ASSERT(
    param->vtable && param->vtable->get_scalar_dble,
    "double-based getter not supported by this parameter");
  return param->vtable->get_scalar_dble(param, value);
}
 
// Error handling and cleanup
 
void yac_param_get_error_buffer(char **buffer, size_t *buffer_size) {
  if (buffer) *buffer = error_buf;
  if (buffer_size) *buffer_size = ERROR_BUF_SIZE;
}
 
int yac_param_parse_dble(
  const char *value_str, const char *param_name, double *value) {
  YAC_PARAM_ASSERT(
    value_str,
    "No value provided for parameter '%s'", param_name);
  char *endptr = NULL;
  *value = strtod(value_str, &endptr);
  YAC_PARAM_ASSERT(
    (endptr != value_str) && (*endptr == '\0'),
    "'%s' is not a valid double for parameter '%s'",
    value_str, param_name);
  return 0;
}
 
int yac_param_parse_dble_with_unit(
  const char *value_str, const char *param_name, double *value,
  enum yac_param_angle_unit *unit) {
 
  YAC_ASSERT(param_name, "param_name is NULL");
  YAC_ASSERT_F(value, "value is NULL for parameter '%s'", param_name);
  YAC_ASSERT_F(unit, "unit is NULL for parameter '%s'", param_name);
 
  YAC_PARAM_ASSERT(value_str, "value_str is NULL");
 
  // Parse the double value first.
  char *endptr = NULL;
  *value = strtod(value_str, &endptr);
  YAC_PARAM_ASSERT(
    (endptr != value_str),
    "'%s' is not a valid double for parameter '%s'", value_str, param_name);
 
  // If there are non-whitespace characters after the number,
  // try to parse a unit.
  if (*endptr != '\0') {
 
    // skip optional single whitespace between number and unit
    if (isspace((unsigned char)*endptr)) {
      endptr++;
    }
 
    DEF_NAME_TYPE_PAIRS(
      yac_param_unit_table,
      DEF_NAME_TYPE_PAIR(deg, YAC_PARAM_ANGLE_UNIT_DEG),
      DEF_NAME_TYPE_PAIR(d, YAC_PARAM_ANGLE_UNIT_DEG),
      DEF_NAME_TYPE_PAIR(rad, YAC_PARAM_ANGLE_UNIT_RAD),
      DEF_NAME_TYPE_PAIR(r, YAC_PARAM_ANGLE_UNIT_RAD),
      DEF_NAME_TYPE_PAIR(DEG, YAC_PARAM_ANGLE_UNIT_DEG),
      DEF_NAME_TYPE_PAIR(D, YAC_PARAM_ANGLE_UNIT_DEG),
      DEF_NAME_TYPE_PAIR(RAD, YAC_PARAM_ANGLE_UNIT_RAD),
      DEF_NAME_TYPE_PAIR(R, YAC_PARAM_ANGLE_UNIT_RAD));
 
    int unit_type = yac_name_type_pair_get_type(
      yac_param_unit_table, yac_param_unit_table_size, endptr);
 
    YAC_PARAM_ASSERT(
      unit_type != INT_MAX,
      "'%s' has invalid unit suffix for parameter '%s'",
      value_str, param_name);
 
    *unit = (enum yac_param_angle_unit)unit_type;
 
  } else {
 
    // No unit suffix, use default
    *unit = YAC_PARAM_ANGLE_UNIT_DEG;
  }
 
  return 0;
}
 
int yac_param_format_scalar_dble(
  char *buf, size_t buflen, double value, const char *value_desc,
  const char *param_name) {
 
  enum {
    // DBL_DECIMAL_DIG is the number of decimal digits that are necessary to
    // uniquely represent all distinct double values, but the shortest possible
    // representation of a specific value may require fewer digits, so we try
    // all precisions down to 1 to find the shortest one that fits into the
    // buffer.
#if defined(DBL_DECIMAL_DIG)
    MAX_PRECISION = DBL_DECIMAL_DIG,
#else
    MAX_PRECISION = 17,
#endif
    MIN_BUF_LEN = 16,
  };
 
  YAC_ASSERT(buf, "buf is NULL");
 
  YAC_PARAM_ASSERT(
    buflen >= MIN_BUF_LEN,
    "buffer too small for %s of parameter '%s' (need at least %d bytes)",
    value_desc, param_name, MIN_BUF_LEN);
 
  // Print with the highest significant-digit precision that still fits.
  int ret = 1;
  for (int precision = MAX_PRECISION; (precision >= 1) && ret; --precision) {
    int n = snprintf(buf, buflen, "%.*g", precision, value);
    if ((n >= 0) && ((size_t)n < buflen)) ret = 0;
  }
 
  YAC_ASSERT_F(
    ret == 0, "failed to format double value '%g' with any precision",  value);
 
  return ret;
}
 
const char *yac_param_get_last_error(void) {
  char *buf = NULL;
  yac_param_get_error_buffer(&buf, NULL);
  return buf ? buf : "";
}
 
void yac_param_delete(
  struct yac_param *param) {
  if (!param) return;
  YAC_ASSERT_F(
    param->vtable && param->vtable->delete,
    "vtable or delete is NULL for parameter '%s'",
    (param->vtable && param->vtable->get_name) ?
      yac_param_get_name(param) : "(unknown)");
  param->vtable->delete(param);
}
 
/*
 * Utility functions for angle parameters (degrees <-> radians conversion)
 */
 
double yac_wrap_rad(double value, char const * param_name) {
  double const two_pi = 2.0 * M_PI;
 
  YAC_ASSERT_F(
    !isnan(value) && !isinf(value),
    "value is NaN or Inf for parameter '%s'", param_name);
 
  while (value < -M_PI) value += two_pi;
  while (value >= M_PI) value -= two_pi;
 
  return value;
}
 
double yac_wrap_deg(double value, char const * param_name) {
 
  YAC_ASSERT_F(
    !isnan(value) && !isinf(value),
    "value is NaN or Inf for parameter '%s'", param_name);
 
  while (value < -180.0) value += 360.0;
  while (value >= 180.0) value -= 360.0;
 
  return value;
}
 
static struct {
  double deg;
  double rad;
} const deg_rad_lookup[] = {
#ifdef M_PI
  {.deg = -180.0, .rad = - M_PI}, // first match with - M_PI
  {.deg = -540.0, .rad = - M_PI},
  {.deg =  180.0, .rad = - M_PI},
  {.deg =  540.0, .rad = - M_PI},
#endif
#ifdef M_PI_2
  {.deg =  -90.0, .rad = -M_PI_2}, // first match with - M_PI_2
  {.deg =   90.0, .rad =  M_PI_2}, // first match with M_PI_2
  {.deg = -450.0, .rad = -M_PI_2},
  {.deg = -270.0, .rad =  M_PI_2},
  {.deg =  270.0, .rad = -M_PI_2},
  {.deg =  450.0, .rad =  M_PI_2},
#endif
#ifdef M_PI_4
  {.deg =  -135.0, .rad = - M_PI + M_PI_4}, // first match with - M_PI + M_PI_4
  {.deg =   -45.0, .rad = - M_PI_4},        // first match with - M_PI_4
  {.deg =    45.0, .rad =   M_PI_4},        // first match with   M_PI_4
  {.deg =   135.0, .rad =   M_PI - M_PI_4}, // first match with   M_PI - M_PI_4
  {.deg =  -495.0, .rad = - M_PI + M_PI_4},
  {.deg =  -405.0, .rad = - M_PI_4},
  {.deg =  -315.0, .rad =   M_PI_4},
  {.deg =  -225.0, .rad =   M_PI - M_PI_4},
  {.deg =   225.0, .rad = - M_PI + M_PI_4},
  {.deg =   315.0, .rad = - M_PI_4},
  {.deg =   405.0, .rad =   M_PI_4},
  {.deg =   495.0, .rad =   M_PI - M_PI_4},
#endif
  {.deg =    0.0, .rad =  0.0}, // first match with 0.0
  {.deg = -720.0, .rad =  0.0},
  {.deg = -360.0, .rad =  0.0},
  {.deg =  360.0, .rad =  0.0},
  {.deg =  720.0, .rad =  0.0},
};
enum {
  DEG_RAD_LOOKUP_COUNT = sizeof(deg_rad_lookup) / sizeof(deg_rad_lookup[0]) };
 
double yac_deg_to_rad(double deg, char const * param_name) {
 
  YAC_ASSERT_F(
    !isnan(deg) && !isinf(deg),
    "value is NaN or Inf for parameter '%s'", param_name);
 
  for (size_t i = 0; i < DEG_RAD_LOOKUP_COUNT; ++i) {
    if (deg == deg_rad_lookup[i].deg) return deg_rad_lookup[i].rad;
  }
 
  return yac_wrap_deg(deg, param_name) * YAC_RAD;
}
 
double yac_rad_to_deg(double rad, char const * param_name) {
 
  YAC_ASSERT_F(
    !isnan(rad) && !isinf(rad),
    "value is NaN or Inf for parameter '%s'", param_name);
 
  for (size_t i = 0; i < DEG_RAD_LOOKUP_COUNT; ++i) {
    if (rad == deg_rad_lookup[i].rad) return deg_rad_lookup[i].deg;
  }
 
  return yac_wrap_rad(rad, param_name) / YAC_RAD;
}