helpers.h

Go to the documentation of this file.

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license in the file COPYING
 * or http://www.opensource.org/licenses/CDDL-1.0.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file COPYING.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2023 Saso Kiselkov. All rights reserved.
 */
#ifndef _ACF_UTILS_HELPERS_H_
#define _ACF_UTILS_HELPERS_H_
 
#include <ctype.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <math.h>
#if APL || LIN
#include <sys/stat.h>
#include <dirent.h> /* to bring in DIR, opendir, readdir & friends */
#include <unistd.h>
#endif
 
#if IBM
#include <windows.h>
#endif  /* IBM */
 
#define _LACF_GETLINE_INCLUDED
#include "lacf_getline_impl.h"
#define _LACF_PARSER_FUNCS_INCLUDED
#include "parser_funcs.h"
#include "math_core.h"
#include "sysmacros.h"
#include "safe_alloc.h"
#include "time.h"
#include "types.h"
 
#ifdef  __cplusplus
extern "C" {
#endif
 
#define IS_VALID_GEO_POS3(pos) \
    (is_valid_lat((pos).lat) && is_valid_lon((pos).lon) && \
    is_valid_elev((pos).elev))
#define IS_VALID_GEO_POS2(pos) \
    (is_valid_lat((pos).lat) && is_valid_lon((pos).lon))
static inline bool_t
is_valid_lat(double lat)
{
    return (!isnan(lat) && fabs(lat) <= 90);
}
static inline bool_t
is_valid_lat_polar(double lat)
{
    return (!isnan(lat) && fabs(lat) <= 90);
}
static inline bool_t
is_valid_lon(double lon)
{
    return (!isnan(lon) && fabs(lon) <= 180.0);
}
static inline bool_t
is_valid_elev(double elev)
{
    return (!isnan(elev) && elev >= MIN_ELEV && elev <= MAX_ELEV);
}
 
#ifdef  LACF_ENABLE_LEGACY_IS_VALID_ALT
#define is_valid_alt(alt)   is_valid_alt_ft(alt)
#endif
static inline bool_t
is_valid_alt_ft(double alt_ft)
{
    return (!isnan(alt_ft) && alt_ft >= MIN_ALT && alt_ft <= MAX_ALT);
}
static inline bool_t
is_valid_alt_m(double alt_m)
{
    return (!isnan(alt_m) && alt_m >= MIN_ALT / 3.2808398950131 &&
        alt_m <= MAX_ALT / 3.2808398950131);
}
static inline bool_t
is_valid_spd(double spd)
{
    return (!isnan(spd) && spd >= 0.0 && spd <= MAX_SPD);
}
static inline bool_t
is_valid_hdg(double hdg)
{
    return (!isnan(hdg) && hdg >= 0.0 && hdg <= 360.0);
}
#define rel_hdg(hdg1, hdg2) rel_hdg_impl(hdg1, hdg2, __FILE__, __LINE__)
API_EXPORT double rel_hdg_impl(double hdg1, double hdg2, const char *file,
    int line);
 
static inline double
normalize_hdg(double hdg)
{
    if (isnan(hdg))
        return (hdg);
    hdg = fmod(hdg, 360);
    /* Flip negative into positive */
    if (hdg < 0.0)
        hdg += 360.0;
    /* Necessary to avoid FP rounding errors */
    if (hdg <= 0.0 || hdg > 360.0) {
        hdg = clamp(hdg, 0, 360);
        /* Avoid negative zero */
        if (hdg == -0.0)
            hdg = 0.0;
    }
    return (hdg);
}
 
static inline double
normalize_hdg_rad(double hdg_rad)
{
    if (isnan(hdg_rad)) {
        return (hdg_rad);
    }
    hdg_rad = fmod(hdg_rad, 360);
    /* Flip negative into positive */
    if (hdg_rad < 0.0) {
        hdg_rad += 2.0 * M_PI;
    }
    /* Necessary to avoid FP rounding errors */
    if (hdg_rad <= 0.0 || hdg_rad > 2.0 * M_PI) {
        hdg_rad = clamp(hdg_rad, 0, 2.0 * M_PI);
        /* Avoid negative zero */
        if (hdg_rad == -0.0) {
            hdg_rad = 0.0;
        }
    }
    return (hdg_rad);
}
 
static inline double
normalize_lon(double lon)
{
    while (lon > 180.0)
        lon -= 360.0;
    while (lon < -180.0)
        lon += 360.0;
    return (clamp(lon, -180, 180));
}
 
API_EXPORT bool_t is_valid_icao_code(const char *icao);
API_EXPORT bool_t is_valid_iata_code(const char *iata);
API_EXPORT const char *extract_icao_country_code(const char *icao);
 
API_EXPORT bool_t is_valid_xpdr_code(int code);
API_EXPORT bool_t is_valid_vor_freq(double freq_mhz);
static inline bool_t
is_valid_vor_freq_hz(uint32_t freq_hz)
{
    return (is_valid_vor_freq(freq_hz / 1000000.0));
}
static inline bool_t
is_valid_vor_freq_khz(uint32_t freq_khz)
{
    return (is_valid_vor_freq(freq_khz / 1000.0));
}
 
API_EXPORT bool_t is_valid_loc_freq(double freq_mhz);
static inline bool_t
is_valid_loc_freq_hz(uint32_t freq_hz)
{
    return (is_valid_loc_freq(freq_hz / 1000000.0));
}
static inline bool_t
is_valid_loc_freq_khz(uint32_t freq_khz)
{
    return (is_valid_loc_freq(freq_khz / 1000.0));
}
 
API_EXPORT bool_t is_valid_ndb_freq(double freq_khz);
static inline bool_t is_valid_ndb_freq_hz(uint32_t freq_hz)
{
    return (is_valid_ndb_freq(freq_hz / 1000.0));
}
 
API_EXPORT bool_t is_valid_tacan_freq(double freq_mhz);
API_EXPORT bool_t is_valid_rwy_ID(const char *rwy_ID);
API_EXPORT void copy_rwy_ID(const char *src, char dst[4]);
 
/* AIRAC date functions */
API_EXPORT const char *airac_cycle2eff_date(int cycle);
API_EXPORT time_t airac_cycle2eff_date2(int cycle);
API_EXPORT bool_t airac_cycle2exp_date(int cycle, char buf[16],
    time_t *cycle_end_p);
API_EXPORT int airac_time2cycle(time_t t);
 
/* CSV file & string processing helpers */
UNUSED_ATTR static ssize_t
parser_get_next_line(FILE *fp, char **linep, size_t *linecap, unsigned *linenum)
{
#if defined(ACFUTILS_BUILD) || defined(ACFUTILS_GZIP_PARSER)
    return (parser_get_next_line_impl(fp, linep, linecap, linenum,
        B_FALSE));
#else   /* !defined(ACFUTILS_BUILD) && !defined(ACFUTILS_GZIP_PARSER) */
    return (parser_get_next_line_impl(fp, linep, linecap, linenum));
#endif  /* !defined(ACFUTILS_BUILD) && !defined(ACFUTILS_GZIP_PARSER) */
}
 
#if defined(ACFUTILS_BUILD) || defined(ACFUTILS_GZIP_PARSER)
/*
 * Same as parser_get_next_line, but for gzip-compressed files.
 */
UNUSED_ATTR static ssize_t
parser_get_next_gzline(void *gz_fp, char **linep, size_t *linecap,
    unsigned *linenum)
{
    return (parser_get_next_line_impl(gz_fp, linep, linecap, linenum,
        B_TRUE));
}
#endif  /* defined(ACFUTILS_BUILD) || defined(ACFUTILS_GZIP_PARSER) */
 
UNUSED_ATTR static char *
parser_get_next_quoted_str(FILE *fp)
{
    return (parser_get_next_quoted_str2(fp, NULL));
}
 
API_EXPORT ssize_t explode_line(char *line, char delim, char **comps,
    size_t capacity);
API_EXPORT void append_format(char **str, size_t *sz,
    PRINTF_FORMAT(const char *format), ...) PRINTF_ATTR(3);
static inline void
normalize_whitespace(char *str)
{
    for (int i = 0, n = strlen(str); i < n; i++) {
        if (isspace(str[i]))
            str[i] = ' ';
    }
}
 
/* string processing helpers */
API_EXPORT char **strsplit(const char *input, const char *sep,
    bool_t skip_empty, size_t *num);
#define DESTROY_STRLIST(comps, num) \
    do { \
        free_strlist((comps), (num)); \
        (comps) = NULL; \
        (num) = 0; \
    } while (0)
API_EXPORT void free_strlist(char **comps, size_t num);
API_EXPORT void unescape_percent(char *str);
 
API_EXPORT char *mkpathname(const char *comp, ...) SENTINEL_ATTR;
API_EXPORT char *mkpathname_v(const char *comp, va_list ap);
API_EXPORT void fix_pathsep(char *str);
 
API_EXPORT char *path_last_comp_subst(const char *path, const char *replace);
API_EXPORT char *path_last_comp(const char *path);
API_EXPORT char *path_ext_subst(const char *path, const char *ext);
API_EXPORT void path_normalize(char *path);
 
API_EXPORT char *file2str(const char *comp, ...) SENTINEL_ATTR;
API_EXPORT char *file2str_ext(long *len_p, const char *comp, ...) SENTINEL_ATTR;
API_EXPORT char *file2str_name(long *len_p, const char *filename);
API_EXPORT void *file2buf(const char *filename, size_t *bufsz);
API_EXPORT ssize_t filesz(const char *filename);
 
/*
 * strlcpy is a BSD function not available on Windows, so we roll a simple
 * version of it ourselves. Can't inline this function, because GCC's fucked
 * up array bounds checker will squawk endlessly when this is used to copy
 * strings to a fixed-size array.
 */
#if IBM || LIN
#define strlcpy             lacf_strlcpy
#endif
API_EXPORT void lacf_strlcpy(char *restrict dest, const char *restrict src,
    size_t cap);
 
static inline const char *
lacf_basename(const char *str)
{
    const char *sep = strrchr(str, DIRSEP);
 
#if IBM
    const char *sep2 = strrchr(str, '/');
    if (sep2 > sep)
        sep = sep2;
#endif  /* IBM */
 
    if (sep == NULL)
        return (str);
    return (&sep[1]);
}
 
UNUSED_ATTR static ssize_t
lacf_getline(char **lineptr, size_t *n, FILE *stream)
{
#if defined(ACFUTILS_BUILD) || defined(ACFUTILS_GZIP_PARSER)
    return (lacf_getline_impl(lineptr, n, stream, B_FALSE));
#else
    return (lacf_getline_impl(lineptr, n, stream));
#endif
}
 
#if IBM && !defined(__cplusplus) && \
    (defined(_GNU_SOURCE) || defined(_POSIX_C_SOURCE))
#define getline             lacf_getline
#endif
 
API_EXPORT void strtolower(char *str);
API_EXPORT void strtoupper(char *str);
 
static inline char *
vsprintf_alloc(const char *fmt, va_list ap)
{
    va_list ap2;
    int l;
    char *str;
 
    ASSERT(fmt != NULL);
 
    va_copy(ap2, ap);
    l = vsnprintf(NULL, 0, fmt, ap2);
    va_end(ap2);
 
    ASSERT(l >= 0);
    str = (char *)safe_malloc(l + 1);
    (void)vsnprintf(str, l + 1, fmt, ap);
 
    return (str);
}
 
PRINTF_ATTR(1) static inline char *
sprintf_alloc(PRINTF_FORMAT(const char *fmt), ...)
{
    va_list ap;
    char *str;
 
    ASSERT(fmt != NULL);
 
    va_start(ap, fmt);
    str = vsprintf_alloc(fmt, ap);
    va_end(ap);
 
    return (str);
}
 
static inline int
lacf_strncasecmp(const char *s1, const char *s2, size_t n)
{
    int l1, l2, res;
    enum { STACKBUFSZ_LIM = 1024 };
 
    ASSERT(s1 != NULL);
    ASSERT(s2 != NULL);
 
    l1 = strlen(s1);
    l2 = strlen(s2);
 
    if (l1 < STACKBUFSZ_LIM && l2 < STACKBUFSZ_LIM) {
        char s1_lower[STACKBUFSZ_LIM], s2_lower[STACKBUFSZ_LIM];
 
        lacf_strlcpy(s1_lower, s1, sizeof (s1_lower));
        lacf_strlcpy(s2_lower, s2, sizeof (s2_lower));
        strtolower(s1_lower);
        strtolower(s2_lower);
        res = strncmp(s1_lower, s2_lower, n);
    } else {
        char *s1_lower = (char *)safe_malloc(l1 + 1);
        char *s2_lower = (char *)safe_malloc(l2 + 1);
 
        lacf_strlcpy(s1_lower, s1, l1 + 1);
        lacf_strlcpy(s2_lower, s2, l2 + 1);
        strtolower(s1_lower);
        strtolower(s2_lower);
        res = strncmp(s1_lower, s2_lower, n);
        free(s1_lower);
        free(s2_lower);
    }
    return (res);
}
 
static inline int
lacf_strcasecmp(const char *s1, const char *s2)
{
    return (lacf_strncasecmp(s1, s2, MAX(strlen(s1), strlen(s2))));
}
 
static inline char *
lacf_strcasestr(const char *haystack, const char *needle)
{
    int l1, l2;
    char *res;
    enum { STACKBUFSZ_LIM = 1024 };
 
    ASSERT(haystack != NULL);
    ASSERT(needle != NULL);
 
    l1 = strlen(haystack);
    l2 = strlen(needle);
 
    if (l1 < STACKBUFSZ_LIM && l2 < STACKBUFSZ_LIM) {
        char haystack_lower[STACKBUFSZ_LIM];
        char needle_lower[STACKBUFSZ_LIM];
 
        lacf_strlcpy(haystack_lower, haystack, sizeof (haystack_lower));
        lacf_strlcpy(needle_lower, needle, sizeof (needle_lower));
        strtolower(haystack_lower);
        strtolower(needle_lower);
        res = strstr(haystack_lower, needle_lower);
        if (res != NULL)
            res = (char *)haystack + (res - haystack_lower);
    } else {
        char *haystack_lower = (char *)safe_malloc(l1 + 1);
        char *needle_lower = (char *)safe_malloc(l2 + 1);
 
        lacf_strlcpy(haystack_lower, haystack, l1 + 1);
        lacf_strlcpy(needle_lower, needle, l2 + 1);
        strtolower(haystack_lower);
        strtolower(needle_lower);
        res = strstr(haystack_lower, needle_lower);
        if (res != NULL)
            res = (char *)haystack + (res - haystack_lower);
        free(haystack_lower);
        free(needle_lower);
    }
    return (res);
}
 
static inline int
fixed_decimals(double x, int digits)
{
    if (x > -1e-10 && x < 1e-10)
        return (MAX(digits - 1, 0));
    if (x < 0)
        x *= -1;
    /* This avoids the leading "0." not counting to the digit number */
    if (x < 1)
        digits = MAX(digits - 1, 0);
    return (clampi(digits - ceil(log10(x)), 0, digits));
}
 
API_EXPORT size_t utf8_char_get_num_bytes(const char *str);
API_EXPORT size_t utf8_get_num_chars(const char *str);
 
#define P2ROUNDUP(x)    (-(-(x) & -(1 << highbit64(x))))
static inline double
roundmul(double x, double y)
{
    return (round(x / y) * y);
}
static inline double
floormul(double x, double y)
{
    return (floor(x / y) * y);
}
#define SET_BITFIELD_1(out_var, bit_mask, bit_value) \
    do { \
        if (bit_value) \
            (out_var) |= (bit_mask); \
        else \
            (out_var) &= ~(bit_mask); \
    } while (0)
 
/* file/directory manipulation */
API_EXPORT bool_t file_exists(const char *path, bool_t *isdir);
API_EXPORT bool_t create_directory(const char *dirname);
API_EXPORT bool_t create_directory_recursive(const char *dirname);
API_EXPORT bool_t remove_directory(const char *dirname);
API_EXPORT bool_t remove_file(const char *filename, bool_t notfound_ok);
 
API_EXPORT char *lacf_dirname(const char *filename);
 
#if IBM && (defined(_GNU_SOURCE) || defined(_POSIX_C_SOURCE))
 
/* A minimally compatible POSIX-style directory reading implementation */
struct dirent {
    char        d_name[256];
};
typedef struct {
    HANDLE      handle;
    WIN32_FIND_DATA find_data;
    bool_t      first;
    struct dirent   de;
} DIR;
 
API_EXPORT DIR *opendir(const char *path);
API_EXPORT struct dirent *readdir(DIR *dirp);
API_EXPORT void closedir(DIR *dirp);
 
#define sleep(x)    SleepEx((x) * 1000, FALSE)
#define usleep(x)   SleepEx((x) / 1000, FALSE)
 
#endif  /* IBM && (defined(_GNU_SOURCE) || defined(_POSIX_C_SOURCE)) */
 
#if IBM
 
API_EXPORT void win_perror(DWORD err, PRINTF_FORMAT(const char *fmt), ...)
    PRINTF_ATTR(2);
 
#endif  /* IBM */
 
API_EXPORT void lacf_qsort_r(void *base, size_t nmemb, size_t size,
    int (*compar)(const void *, const void *, void *), void *arg);
 
static inline bool_t
lacf_gmtime_r(const time_t *tim, struct tm *tm)
{
#if defined(__STDC_LIB_EXT1__) || IBM
    return (_gmtime64_s(tm, tim) == 0);
#else   /* !defined(__STDC_LIB_EXT1__) && !IBM */
    return (gmtime_r(tim, tm) != NULL);
#endif  /* !defined(__STDC_LIB_EXT1__) && !IBM */
}
 
 
#ifdef  __cplusplus
}
#endif
 
#endif  /* _ACF_UTILS_HELPERS_H_ */