init.c

Go to the documentation of this file.

/** @file init.c
    @brief Initialization for Menu Application Programs
    @author Bill Waller
    Copyright (c) 2025
    MIT License
    billxwaller@gmail.com
    @date 2026-02-09
 */
 
/**
   @defgroup init C-Menu Initialization
   @brief Capture Data from the Environment, Command Line, and
   Configuration File and Populate the Init and SIO Data Structures
   @verbatim
       SIO   Struct for screen I/O settings (colors, gamma, etc.)
       Init  Struct for application settings (file paths, commands, flags, etc.)
   @endverbatim
 */
 
#include <argp.h>
#include <common.h>
#include <locale.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
 
typedef enum {
    IN_SPEC = 257,
    OUT_SPEC,
    BG_XCLR,
    BO_XCLR,
    FG_XCLR,
    LN_BG_CLR,
    LN_XCLR,
    GM_BLUE,
    GM_GRAY,
    GM_GREEN,
    GM_RED,
    XBBLACK,
    XBBLUE,
    XBCYAN,
    XBGREEN,
    XBLACK,
    XBLUE,
    XBMAGENTA,
    XBRED,
    XBWHITE,
    XBYELLOW,
    XCYAN,
    CM_EDITOR,
    XGREEN,
    XMAGENTA,
    XRED,
    XWHITE,
    XYELLOW,
    MAPP_DATA,
    MAPP_HELP,
    MAPP_HOME,
    MAPP_MSRC,
    MAPP_USER,
    MAPP_HELP_DIR,
    MAPP_DATA_DIR,
    MAPP_SPEC,
    HELP_SPEC,
} InitVariables;
 
bool f_write_config = false;
bool f_dump_config = false;
 
int write_config(Init *init);
void display_version();
 
Init *init = nullptr;
void mapp_initialization(Init *, int, char **);
void zero_opt_args(Init *);
int parse_config(Init *);
int parse_opt_args(Init *, int, char **);
void dump_config(Init *, char *);
 
bool derive_file_spec(char *, char *, char *);
int executor = 0;
 
const char *argp_program_version = CM_VERSION;
const char *argp_program_bug_address = "billxwaller@gmail.com";
static char doc[] = "C-Menu - User Interface Toolkit";
static char args_doc[] = "[INPUT] [OUTPUT] [HELP] [ARG4] [ARG5]";
// const int opt_doc_col = 33;
 
static struct argp_option options[] = {
    {"f_dump_config", 'D', 0, 0, "dump configuration", 0},
    {"f_write_config", 'W', 0, 0, "write configuration", 0},
    {"minitrc", 'a', "file_spec", 0, "configuration file spec", 1},
    {"parent_cmd", 'k', 0, 0, "parent command", 1},
    {"begx", 'X', "number", 0, "begin on column", 2},
    {"begy", 'Y', "number", 0, "begin on line", 2},
    {"cols", 'C', "number", 0, "width in columns", 2},
    {"lines", 'L', "number", 0, "height in lines", 2},
    {"out_spec", 'o', "file_spec", 0, "output spec", 2},
    {"select_max", 'n', "number", 0, "number of selections", 2},
    {"cmd", 'c', "file_spec", 0, "view cmd, first file", 3},
    {"cmd_all", 'A', "file_spec", 0, "view cmd, all files", 3},
    {"help_spec", 'H', "file_spec", 0, "help spec", 3},
    {"in_spec", 'i', "file_spec", 0, "input spec", 3},
    {"mapp_spec", 'd', "file_spec", 0, "description spec", 3},
    {"provider_cmd", 'S', "file_spec", 0, "execute provider of piped input", 3},
    {"receiver_cmd", 'R', "file_spec", 0, "execute receiver of piped output",
     3},
    {"title", 'T', "text", 0, "Window title", 3},
    {"wait_timeout", 'w', "seconds", 0, "Wait timer", 3},
    {"f_erase_remainder", 'e', "bool", 0, "erase remainder of line on enter",
     4},
    {"f_strip_ansi", 'j', "bool", 0, "always strip ansi when writing", 4},
    {"f_squeeze", 's', "bool", 0, "squeeze multiple blank lines", 4},
    {"f_ignore_case", 'x', "bool", 0, "ignore case in search", 4},
    {"f_ln", 'N', "bool", OPTION_ARG_OPTIONAL, "line numbers in view", 5},
    {"fill_char", 'f', "char", 0, "field fill_char", 5},
    {"brackets", 'u', "text", 0, "brackets around fields", 5},
    {"editor", CM_EDITOR, "text", 0, "default editor", 8},
    {"tab_stop", 't', "number", 0, "number of spaces per tab", 5},
    {"bg_clr_x", BG_XCLR, "hex_clr", 0, "background color", 6},
    {"bo_clr_x", BO_XCLR, "hex_clr", 0, "border color", 6},
    {"fg_clr_x", FG_XCLR, "hex_clr", 0, "foreground color", 6},
    {"ln__bg_clr_x", LN_BG_CLR, "hex_clr", 0, "line number background", 6},
    {"ln_clr_x", LN_XCLR, "hex_clr", 0, "line number color", 6},
    {"blue_gamma", GM_BLUE, "float", 0, "blue_gamma (View)", 7},
    {"gray_gamma", GM_GRAY, "float", 0, "gray gamma (View)", 7},
    {"green_gamma", GM_GREEN, "float", 0, "green gamma (View)", 7},
    {"red_gamma", GM_RED, "float", 0, "red gamma (View)", 7},
    {"black", XBLACK, "hex_clr", 0, "black (#000000)", 8},
    {"red", XRED, "hex_clr", 0, "red (#bf0000)", 8},
    {"green", XGREEN, "hex_clr", 0, "green (#00cf00)", 8},
    {"yellow", XYELLOW, "hex_clr", 0, "yellow (#efbf00)", 8},
    {"blue", XBLUE, "hex_clr", 0, "blue (#0000FF)", 8},
    {"magenta", XMAGENTA, "hex_clr", 0, "magenta (#9f009f)", 8},
    {"cyan", XCYAN, "hex_clr", 0, "cyan (#00dfdf)", 8},
    {"white", XWHITE, "hex_clr", 0, "white (#d0d0d0)", 8},
    {"bblack", XBBLACK, "hex_clr", 0, "bright black (#7f7f7f)", 8},
    {"bred", XBRED, "hex_clr", 0, "bright red (#FF3737)", 8},
    {"bgreen", XBGREEN, "hex_clr", 0, "bright green (#00FF7f)", 8},
    {"byellow", XBYELLOW, "hex_clr", 0, "bright yellow (#FFeF00)", 8},
    {"bblue", XBBLUE, "hex_clr", 0, "bright blue (#00cfFF)", 8},
    {"bmagenta", XMAGENTA, "hex_clr", 0, "bright magenta (#FF00FF)", 8},
    {"bcyan", XBCYAN, "hex_clr", 0, "bright cyan (#00FFFF)", 8},
    {"bwhite", XBWHITE, "hex_clr", 0, "bright white (#FFFFFF)", 8},
    {"mapp_data", MAPP_DATA, "directory", 0, "data directory", 9},
    {"mapp_help", MAPP_HELP, "directory", 0, "help directory", 9},
    {"mapp_home", MAPP_HOME, "directory", 0, "home directory", 9},
    {"mapp_msrc", MAPP_MSRC, "directory", 0, "source directory", 9},
    {"mapp_user", MAPP_USER, "directory", 0, "user directory", 9},
    {0},
};
 
static error_t parse_opt(int key, char *arg, struct argp_state *state) {
    Init *init = state->input;
    SIO *sio = init->sio;
    switch (key) {
    case 'a':
        strnz__cpy(init->minitrc, arg, MAXLEN - 1);
        break;
    case 'b':
        sio->blue_gamma = str_to_double(arg);
        break;
    case 'c':
        strnz__cpy(init->cmd, arg, MAXLEN - 1);
        break;
    case 'd':
        strnz__cpy(init->mapp_spec, arg, MAXLEN - 1);
        break;
    case 'e':
        init->f_erase_remainder = str_to_bool(arg);
        break;
    case 'f':
        strnz__cpy(init->fill_char, arg, 1);
        break;
    case 'g':
        sio->green_gamma = str_to_double(arg);
        break;
    case 'i':
        strnz__cpy(init->in_spec, arg, MAXLEN - 1);
        break;
    case 'j':
        init->f_strip_ansi = true;
        break;
    case 'k':
        strnz__cpy(init->parent_cmd, arg, MAXLEN - 1);
        break;
    case 'm':
        strnz__cpy(init->mapp_home, arg, MAXLEN - 1);
        break;
    case 'n':
        init->select_max = atoi(arg);
        break;
    case 'o':
        strnz__cpy(init->out_spec, arg, MAXLEN - 1);
        break;
    case 'r':
        sio->red_gamma = str_to_double(arg);
        break;
    case 's':
        init->f_squeeze = str_to_bool(arg);
        break;
    case 't':
        init->tab_stop = atoi(arg);
        if (init->tab_stop < 1)
            init->tab_stop = 1;
        break;
    case 'w':
        wait_timeout = atoi(arg);
        wait_timeout = min(wait_timeout, 1);
        wait_timeout = max(wait_timeout, 29);
        break;
    case 'u':
        strnz__cpy(init->brackets, arg, 2);
        break;
    case 'x':
        init->f_ignore_case = str_to_bool(arg);
        break;
    case 'A':
        strnz__cpy(init->cmd_all, arg, MAXLEN - 1);
        break;
    case 'B':
        strnz__cpy(sio->bg_clr_x, arg, MAXLEN - 1);
        break;
    case 'C':
        init->cols = atoi(arg);
        break;
    case 'D':
        f_dump_config = true;
        break;
    case 'F':
        strnz__cpy(sio->fg_clr_x, arg, MAXLEN - 1);
        break;
    case 'G':
        sio->gray_gamma = str_to_double(arg);
        break;
    case 'H':
        strnz__cpy(init->help_spec, arg, MAXLEN - 1);
        break;
    case 'L':
        init->lines = atoi(arg);
        break;
    case 'M':
        init->f_multiple_cmd_args = str_to_bool(arg);
        break;
    case 'N':
        if (arg)
            init->f_ln = str_to_bool(arg);
        else
            init->f_ln = true;
        break;
    case 'O':
        strnz__cpy(sio->bo_clr_x, arg, MAXLEN - 1);
        break;
    case 'R':
        strnz__cpy(init->receiver_cmd, arg, MAXLEN - 1);
        break;
    case 'S':
        strnz__cpy(init->provider_cmd, arg, MAXLEN - 1);
        break;
    case 'T':
        strnz__cpy(init->title, arg, MAXLEN - 1);
        break;
    case 'U':
        strnz__cpy(init->mapp_user, arg, MAXLEN - 1);
        break;
    case 'W':
        f_write_config = true;
        break;
    case 'X':
        init->begx = atoi(arg);
        break;
    case 'Y':
        init->begy = atoi(arg);
        break;
    case MAPP_DATA_DIR:
        strnz__cpy(init->mapp_data, arg, MAXLEN - 1);
        break;
    case MAPP_HELP_DIR:
        strnz__cpy(init->mapp_help, arg, MAXLEN - 1);
        break;
    case MAPP_SPEC:
        strnz__cpy(init->mapp_spec, arg, MAXLEN - 1);
        break;
    case HELP_SPEC:
        strnz__cpy(init->help_spec, arg, MAXLEN - 1);
        break;
    case IN_SPEC:
        strnz__cpy(init->in_spec, arg, MAXLEN - 1);
        break;
    case OUT_SPEC:
        strnz__cpy(init->out_spec, arg, MAXLEN - 1);
        break;
    case MAPP_MSRC:
        strnz__cpy(init->mapp_msrc, arg, MAXLEN - 1);
        break;
    case ARGP_KEY_ARG:
        if (state->arg_num >= 35)
            argp_usage(state);
        init->argv[state->arg_num] = strdup(arg);
        break;
    case ARGP_KEY_END:
        init->argc = state->arg_num;
        init->argv[state->arg_num + 1] = nullptr;
        break;
    default:
        return ARGP_ERR_UNKNOWN;
    }
    return 0;
}
 
static struct argp argp = {options, parse_opt, args_doc, doc,
                           nullptr, nullptr, nullptr};
 
/** @brief Main initialization function for MAPP - Menu Application
    @ingroup init
    @param init - pointer to Init struct to be initialized
    @param argc - argument count from main()
    @param argv - argument vector from main()
    @code
    1. Read environment variables and set defaults
    2. Parse configuration file
    3. Parse command-line options
    4. Set up SIO struct with colors and other settings
    5. Handle special options like help and version
    @endcode
 */
void mapp_initialization(Init *init, int argc, char **argv) {
    char term[MAXLEN];
    char tmp_str[MAXLEN];
    char *e;
    setlocale(LC_ALL, "en_US.UTF-8");
    SIO *sio = init->sio;
    if (!init) {
        ssnprintf(tmp_str, sizeof(tmp_str), "%s",
                  "init struct not allocated on entry");
        abend(-1, tmp_str);
        exit(-1);
    }
#ifdef DEBUG_LOG
    open_cmenu_log();
#endif
    e = getenv("CMENU_HOME");
    if (!e || *e == '\0')
        strnz__cpy(init->mapp_home, "~/menuapp", MAXLEN);
    else
        strnz__cpy(init->mapp_home, e, MAXLEN);
 
    if (init->mapp_home[0] != '\0') {
        expand_tilde(init->mapp_home, MAXLEN - 1);
        if (!verify_dir(init->mapp_home, R_OK))
            abend(-1, "MAPP_HOME directory invalid");
    }
    // CMENU_RC should be an absolute path
    e = getenv("CMENU_RC");
    if (!e || *e == '\0') {
        strnz__cpy(init->minitrc, init->mapp_home, MAXLEN - 1);
        strnz__cat(init->minitrc, "/.minitrc", MAXLEN);
    } else
        strnz__cpy(init->minitrc, e, MAXLEN);
    if (init->mapp_user[0] == '\0') {
        strnz__cpy(init->mapp_user, init->mapp_home, MAXLEN - 1);
        strnz__cat(init->mapp_user, "/user", MAXLEN - 1);
    }
    if (init->mapp_msrc[0] == '\0') {
        strnz__cpy(init->mapp_msrc, init->mapp_home, MAXLEN - 1);
        strnz__cat(init->mapp_msrc, "/msrc", MAXLEN - 1);
    }
    if (init->mapp_data[0] == '\0') {
        strnz__cpy(init->mapp_data, init->mapp_home, MAXLEN - 1);
        strnz__cat(init->mapp_data, "/data", MAXLEN - 1);
    }
    if (init->mapp_help[0] == '\0') {
        strnz__cpy(init->mapp_help, init->mapp_home, MAXLEN - 1);
        strnz__cat(init->mapp_help, "/help", MAXLEN - 1);
    }
    init->mapp_spec[0] = '\0'; /**< menu specification file */
    // Set default colors and settings in SIO struct
    // These can be overridden by the config file or command-line options
    // Included here to ensure SIO has valid defaults even if config parsing fails
    strnz__cpy(sio->bg_clr_x, "#000007",
               COLOR_LEN - 1); /**< background color */
    strnz__cpy(sio->fg_clr_x, "#c0c0c0",
               COLOR_LEN - 1);                           /**< foreground color */
    strnz__cpy(sio->bo_clr_x, "#f00000", COLOR_LEN - 1); /**< bold color */
    strnz__cpy(sio->ln_clr_x, "#0070ff",
               COLOR_LEN - 1); /**< line number olor */
    strnz__cpy(sio->ln_bg_clr_x, "#101010",
               COLOR_LEN - 1);                    /**< line number background */
    init->f_erase_remainder = true;               /**< erase remainder on enter */
    init->brackets[0] = '\0';                     /**< field enclosure brackets */
    strnz__cpy(init->fill_char, "_", MAXLEN - 1); /**< field fill character */
    e = getenv("TERM");
    if (e == nullptr || *e == '\0')
        strnz__cpy(term, "xterm-256color", MAXLEN);
    else
        strnz__cpy(term, e, MAXLEN - 1);
    e = getenv("EDITOR");
    if (e && *e != '\0')
        strnz__cpy(init->editor, "vi", MAXLEN - 1);
    else
        strnz__cpy(init->editor, e, MAXLEN - 1);
    parse_config(init);
    init->mapp_spec[0] = '\0';
    init->argc = argc;
    argp_parse(&argp, argc, argv, 0, 0, init);
    if (f_write_config) {
        write_config(init);
        exit(EXIT_SUCCESS);
    }
    if (f_dump_config) {
        dump_config(init, "Current Configuration");
        exit(EXIT_SUCCESS);
    }
}
/** @brief Parse command-line options and set Init struct values accordingly
    @ingroup init
    @param init - pointer to Init struct to be populated with option values
    @param argc - argument count from main()
    @param argv - argument vector from main()
    @returns 0 on success, -1 on failure
    @details This function uses the argp library to parse command-line
   options defined in the options array. It updates the Init struct with
   values from the options and handles any special flags for dumping or
   writing configuration.
 */
int parse_opt_args(Init *init, int argc, char **argv) {
    init->argc = destroy_argv(init->argc, init->argv);
    argp_parse(&argp, argc, argv, 0, 0, init);
    return 0;
}
 
/** @brief Initialize optional arguments in the Init struct to default
   values
    @ingroup init
    @param init - pointer to Init struct to be initialized This function
   sets all optional argument fields in the Init struct to their default
   values before parsing command-line options or configuration file. This
   ensures that any fields not specified by the user will have known default
   values.
 */
void zero_opt_args(Init *init) {
    init->lines = 0;
    init->cols = 0;
    init->begx = 0;
    init->begy = 0;
    init->f_mapp_desc = false;
    init->f_provider_cmd = false;
    init->f_receiver_cmd = false;
    init->f_title = false;
    init->f_mapp_spec = false;
    init->f_help_spec = false;
    init->f_in_spec = false;
    init->f_out_spec = false;
    init->mapp_spec[0] = init->help_spec[0] = '\0';
    init->provider_cmd[0] = init->receiver_cmd[0] = '\0';
    init->title[0] = '\0';
    init->cmd[0] = init->cmd_all[0] = '\0';
    init->parent_cmd[0] = '\0';
    init->in_spec[0] = init->out_spec[0] = '\0';
    init->help_spec[0] = '\0';
    init->in_spec[0] = '\0';
    init->out_spec[0] = '\0';
}
/** @brief parse the configuration file specified in init->minitrc and set
   Init struct values accordingly
    @ingroup init
    @returns on success, -1 on failure
    @details Lines beginning with '#" are comments, discard.
    Copy line to tmp_str removing quotes, spaces, semicolons, and
   newlines.
    Record structure is "parse key=value pairs".
    Skip lines without '='.
    Set init struct values based on key.
    Skip unknown keys. */
int parse_config(Init *init) {
    char ts[MAXLEN];
    char *sp, *dp;
    char tmp_str[MAXLEN];
    SIO *sio = init->sio;
    if (!init->minitrc[0]) {
        char *e = getenv("MINITRC");
        if (e)
            strnz__cpy(init->minitrc, e, MAXLEN - 1);
        else
            strnz__cpy(init->minitrc, "~/.minitrc", MAXLEN - 1);
    }
    expand_tilde(init->minitrc, MAXLEN - 1);
    FILE *config_fp = fopen(init->minitrc, "r");
    if (!config_fp) {
        fprintf(stderr, "failed to read file: %s\n", init->minitrc);
        return (-1);
    }
    while (fgets(ts, sizeof(ts), config_fp)) {
        if (ts[0] != '#') {
            sp = ts;
            dp = tmp_str;
            while (*sp != '\0') {
                if (*sp == '\n') {
                    *dp = *sp = '\0';
                } else {
                    if (*sp != '"' && *sp != ' ' && *sp != ';') {
                        *dp++ = *sp;
                    }
                    sp++;
                }
            }
            *dp = '\0';
            char *key = strtok(tmp_str, "=");
            char *value = strtok(nullptr, "=");
            if (value == nullptr)
                continue;
            if (!strcmp(key, "minitrc")) {
                strnz__cpy(init->minitrc, value, MAXLEN - 1);
                continue;
            }
            if (!strcmp(key, "lines")) {
                init->lines = atoi(value);
                continue;
            }
            if (!strcmp(key, "cols")) {
                init->cols = atoi(value);
                continue;
            }
            if (!strcmp(key, "begy")) {
                init->begy = atoi(value);
                continue;
            }
            if (!strcmp(key, "begx")) {
                init->begx = atoi(value);
                continue;
            }
            if (!strcmp(key, "fg_clr_x")) {
                strnz__cpy(sio->fg_clr_x, value, COLOR_LEN - 1);
                continue;
            }
            if (!strcmp(key, "bg_clr_x")) {
                strnz__cpy(sio->bg_clr_x, value, COLOR_LEN - 1);
                continue;
            }
            if (!strcmp(key, "f_ln")) {
                init->f_ln = str_to_bool(value);
                continue;
            }
            if (!strcmp(key, "bo_clr_x")) {
                strnz__cpy(sio->bo_clr_x, value, COLOR_LEN - 1);
                continue;
            }
            if (!strcmp(key, "ln_clr_x")) {
                strnz__cpy(sio->ln_clr_x, value, COLOR_LEN - 1);
                continue;
            }
            if (!strcmp(key, "ln_bg_clr_x")) {
                strnz__cpy(sio->ln_bg_clr_x, value, COLOR_LEN - 1);
                continue;
            }
            if (!strcmp(key, "red_gamma")) {
                sio->red_gamma = str_to_double(value);
                continue;
            }
            if (!strcmp(key, "green_gamma")) {
                sio->green_gamma = str_to_double(value);
                continue;
            }
            if (!strcmp(key, "blue_gamma")) {
                sio->blue_gamma = str_to_double(value);
                continue;
            }
            if (!strcmp(key, "gray_gamma")) {
                sio->gray_gamma = str_to_double(value);
                continue;
            }
            if (!strcmp(key, "f_at_end_remove")) {
                init->f_at_end_remove = str_to_bool(value);
                continue;
            }
            if (!strcmp(key, "f_erase_remainder")) {
                init->f_erase_remainder = str_to_bool(value);
                continue;
            }
            if (!strcmp(key, "brackets")) {
                strnz__cpy(init->brackets, value, 2);
                continue;
            }
            if (!strcmp(key, "fill_char")) {
                strnz__cpy(init->fill_char, value, 2);
                continue;
            }
            if (!strcmp(key, "f_ignore_case")) {
                init->f_ignore_case = str_to_bool(value);
                continue;
            }
            if (!strcmp(key, "f_squeeze")) {
                init->f_squeeze = str_to_bool(value);
                continue;
            }
            if (!strcmp(key, "f_strip_ansi")) {
                init->f_strip_ansi = str_to_bool(value);
                continue;
            }
            if (!strcmp(key, "select_max")) {
                init->select_max = atoi(value);
                continue;
            }
            if (!strcmp(key, "tab_stop")) {
                init->tab_stop = atoi(value);
                continue;
            }
            if (!strcmp(key, "wait_timeout")) {
                wait_timeout = atoi(value);
                continue;
            }
            if (!strcmp(key, "title")) {
                strnz__cpy(init->title, value, MAXLEN - 1);
                continue;
            }
            if (!strcmp(key, "cmd")) {
                strnz__cpy(init->cmd, value, MAXLEN - 1);
                continue;
            }
            if (!strcmp(key, "cmd_all")) {
                strnz__cpy(init->cmd_all, value, MAXLEN - 1);
                continue;
            }
            if (!strcmp(key, "parent_cmd")) {
                strnz__cpy(init->parent_cmd, value, MAXLEN - 1);
                continue;
            }
            if (!strcmp(key, "provider_cmd")) {
                strnz__cpy(init->provider_cmd, value, MAXLEN - 1);
                continue;
            }
            if (!strcmp(key, "receiver_cmd")) {
                strnz__cpy(init->receiver_cmd, value, MAXLEN - 1);
                continue;
            }
            if (!strcmp(key, "nt_fg")) {
                strnz__cpy(sio->nt_fg, value, COLOR_LEN - 1);
                continue;
            }
            if (!strcmp(key, "nt_bg")) {
                strnz__cpy(sio->nt_bg, value, COLOR_LEN - 1);
                continue;
            }
            if (!strcmp(key, "nt_rev_fg")) {
                strnz__cpy(sio->nt_rev_fg, value, COLOR_LEN - 1);
                continue;
            }
            if (!strcmp(key, "nt_rev_bg")) {
                strnz__cpy(sio->nt_rev_bg, value, COLOR_LEN - 1);
                continue;
            }
            if (!strcmp(key, "nt_hl_fg")) {
                strnz__cpy(sio->nt_hl_fg, value, COLOR_LEN - 1);
                continue;
            }
            if (!strcmp(key, "nt_hl_bg")) {
                strnz__cpy(sio->nt_hl_bg, value, COLOR_LEN - 1);
                continue;
            }
            if (!strcmp(key, "nt_hl_rev_fg")) {
                strnz__cpy(sio->nt_hl_rev_fg, value, COLOR_LEN - 1);
                continue;
            }
            if (!strcmp(key, "nt_hl_rev_bg")) {
                strnz__cpy(sio->nt_hl_rev_bg, value, COLOR_LEN - 1);
                continue;
            }
            if (!strcmp(key, "nt_hl_rev_fg")) {
                strnz__cpy(sio->nt_hl_rev_fg, value, COLOR_LEN - 1);
                continue;
            }
            if (!strcmp(key, "bg")) {
                strnz__cpy(sio->bg, value, COLOR_LEN - 1);
                continue;
            }
            if (!strcmp(key, "black")) {
                strnz__cpy(sio->black, value, COLOR_LEN - 1);
                continue;
            }
            if (!strcmp(key, "red")) {
                strnz__cpy(sio->red, value, COLOR_LEN - 1);
                continue;
            }
            if (!strcmp(key, "green")) {
                strnz__cpy(sio->green, value, COLOR_LEN - 1);
                continue;
            }
            if (!strcmp(key, "yellow")) {
                strnz__cpy(sio->yellow, value, COLOR_LEN - 1);
                continue;
            }
            if (!strcmp(key, "blue")) {
                strnz__cpy(sio->blue, value, COLOR_LEN - 1);
                continue;
            }
            if (!strcmp(key, "magenta")) {
                strnz__cpy(sio->magenta, value, COLOR_LEN - 1);
                continue;
            }
            if (!strcmp(key, "cyan")) {
                strnz__cpy(sio->cyan, value, COLOR_LEN - 1);
                continue;
            }
            if (!strcmp(key, "white")) {
                strnz__cpy(sio->white, value, COLOR_LEN - 1);
                continue;
            }
            if (!strcmp(key, "orange")) {
                strnz__cpy(sio->orange, value, COLOR_LEN - 1);
                continue;
            }
            if (!strcmp(key, "bblack")) {
                strnz__cpy(sio->bblack, value, COLOR_LEN - 1);
                continue;
            }
            if (!strcmp(key, "bred")) {
                strnz__cpy(sio->bred, value, COLOR_LEN - 1);
                continue;
            }
            if (!strcmp(key, "bgreen")) {
                strnz__cpy(sio->bgreen, value, COLOR_LEN - 1);
                continue;
            }
            if (!strcmp(key, "byellow")) {
                strnz__cpy(sio->byellow, value, COLOR_LEN - 1);
                continue;
            }
            if (!strcmp(key, "bblue")) {
                strnz__cpy(sio->bblue, value, COLOR_LEN - 1);
                continue;
            }
            if (!strcmp(key, "bmagenta")) {
                strnz__cpy(sio->bmagenta, value, COLOR_LEN - 1);
                continue;
            }
            if (!strcmp(key, "bcyan")) {
                strnz__cpy(sio->bcyan, value, COLOR_LEN - 1);
                continue;
            }
            if (!strcmp(key, "bwhite")) {
                strnz__cpy(sio->bwhite, value, COLOR_LEN - 1);
                continue;
            }
            if (!strcmp(key, "borange")) {
                strnz__cpy(sio->borange, value, COLOR_LEN - 1);
                continue;
            }
            if (!strcmp(key, "bg")) {
                strnz__cpy(sio->bg, value, COLOR_LEN - 1);
                continue;
            }
            if (!strcmp(key, "editor")) {
                strnz__cpy(init->editor, value, MAXLEN - 1);
                continue;
            }
            if (!strcmp(key, "mapp_spec")) {
                strnz__cpy(init->mapp_spec, value, MAXLEN - 1);
                continue;
            }
            if (!strcmp(key, "mapp_data")) {
                strnz__cpy(init->mapp_data, value, MAXLEN - 1);
                continue;
            }
            if (!strcmp(key, "mapp_help")) {
                strnz__cpy(init->mapp_help, value, MAXLEN - 1);
                continue;
            }
            if (!strcmp(key, "mapp_home")) {
                strnz__cpy(init->mapp_home, value, MAXLEN - 1);
                continue;
            }
            if (!strcmp(key, "mapp_msrc")) {
                strnz__cpy(init->mapp_msrc, value, MAXLEN - 1);
                continue;
            }
            if (!strcmp(key, "mapp_user")) {
                strnz__cpy(init->mapp_user, value, MAXLEN - 1);
                continue;
            }
        }
    }
    (void)fclose(config_fp);
    return 0;
}
/** @brief Write the current configuration to a file specified in
   init->minitrc
    @ingroup init
    @param init - pointer to Init struct containing current configuration
    @returns 0 on success, -1 on failure
    @details The configuration is written in key=value format, one per line.
    Lines beginning with '#' are comments and are ignored when reading
   the config file.
    The file is created if it does not exist, and overwritten if it
   does exist
 */
int write_config(Init *init) {
    char *e;
    char minitrc_dmp[MAXLEN];
    char tmp_str[MAXLEN];
    SIO *sio = init->sio;
    e = getenv("HOME");
    if (e) {
        strnz__cpy(minitrc_dmp, e, MAXLEN - 1);
        strnz__cat(minitrc_dmp, "/", MAXLEN - 1);
        strnz__cat(minitrc_dmp, "menuapp/minitrc.dmp", MAXLEN - 1);
        ;
    } else {
        strnz__cpy(minitrc_dmp, "./minitrc.dmp", MAXLEN - 1);
    }
    FILE *minitrc_fp = fopen(minitrc_dmp, "w");
    if (minitrc_fp == (FILE *)0) {
        fprintf(stderr, "failed to open file: %s\n", minitrc_dmp);
        return (-1);
    }
    (void)fprintf(minitrc_fp, "# %s\n", "~/.minitrc");
    (void)fprintf(minitrc_fp, "%s=%s\n", "parent_cmd", init->parent_cmd);
    (void)fprintf(minitrc_fp, "%s=%d\n", "cols", init->cols);
    (void)fprintf(minitrc_fp, "%s=%d\n", "lines", init->lines);
    (void)fprintf(minitrc_fp, "%s=%d\n", "select_max", init->select_max);
    (void)fprintf(minitrc_fp, "%s=%s\n", "out_spec", init->out_spec);
    (void)fprintf(minitrc_fp, "%s=%d\n", "begx", init->begx);
    (void)fprintf(minitrc_fp, "%s=%d\n", "begy", init->begy);
    (void)fprintf(minitrc_fp, "%s=%s\n", "cmd_all", init->cmd_all);
    (void)fprintf(minitrc_fp, "%s=%s\n", "cmd", init->cmd);
    (void)fprintf(minitrc_fp, "%s=%s\n", "mapp_spec", init->mapp_spec);
    (void)fprintf(minitrc_fp, "%s=%s\n", "help_spec", init->help_spec);
    (void)fprintf(minitrc_fp, "%s=%s\n", "in_spec", init->in_spec);
    (void)fprintf(minitrc_fp, "%s=%s\n", "receiver_cmd", init->receiver_cmd);
    (void)fprintf(minitrc_fp, "%s=%s\n", "provider_cmd", init->provider_cmd);
    (void)fprintf(minitrc_fp, "%s=%s\n", "title", init->title);
    (void)fprintf(minitrc_fp, "%s=%s\n", "f_erase_remainder",
                  init->f_erase_remainder ? "true" : "false");
    (void)fprintf(minitrc_fp, "%s=%s\n", "f_strip_ansi",
                  init->f_strip_ansi ? "true" : "false");
    (void)fprintf(minitrc_fp, "%s=%s\n", "f_squeeze",
                  init->f_squeeze ? "true" : "false");
    (void)fprintf(minitrc_fp, "%s=%s\n", "f_ignore_case",
                  init->f_ignore_case ? "true" : "false");
    (void)fprintf(minitrc_fp, "%s=%s\n", "f_ln", init->f_ln ? "true" : "false");
    (void)fprintf(minitrc_fp, "%s=%s\n", "brackets", init->brackets);
    (void)fprintf(minitrc_fp, "%s=%s\n", "fill_char", init->fill_char);
    (void)fprintf(minitrc_fp, "%s=%s\n", "editor", init->editor);
    (void)fprintf(minitrc_fp, "%s=%d\n", "tab_stop", init->tab_stop);
    (void)fprintf(minitrc_fp, "%s=%d\n", "wait_timeout", wait_timeout);
    (void)fprintf(minitrc_fp, "%s=%s\n", "bg_clr_x", sio->bg_clr_x);
    (void)fprintf(minitrc_fp, "%s=%s\n", "bo_clr_x", sio->bo_clr_x);
    (void)fprintf(minitrc_fp, "%s=%s\n", "fg_clr_x", sio->fg_clr_x);
    (void)fprintf(minitrc_fp, "%s=%s\n", "ln_bg_clr_x", sio->ln_bg_clr_x);
    (void)fprintf(minitrc_fp, "%s=%s\n", "ln_clr_x", sio->ln_clr_x);
    (void)fprintf(minitrc_fp, "%s=%0.2f\n", "blue_gamma", sio->blue_gamma);
    (void)fprintf(minitrc_fp, "%s=%0.2f\n", "gray_gamma", sio->gray_gamma);
    (void)fprintf(minitrc_fp, "%s=%0.2f\n", "green_gamma", sio->green_gamma);
    (void)fprintf(minitrc_fp, "%s=%0.2f\n", "red_gamma", sio->red_gamma);
 
    (void)fprintf(minitrc_fp, "%s=%s\n", "nt_fg", sio->nt_fg);
    (void)fprintf(minitrc_fp, "%s=%s\n", "nt_bg", sio->nt_bg);
 
    (void)fprintf(minitrc_fp, "%s=%s\n", "nt_hl_fg", sio->nt_hl_fg);
    (void)fprintf(minitrc_fp, "%s=%s\n", "nt_hl_bg", sio->nt_hl_bg);
 
    (void)fprintf(minitrc_fp, "%s=%s\n", "nt_rev_fg", sio->nt_rev_fg);
    (void)fprintf(minitrc_fp, "%s=%s\n", "nt_rev_bg", sio->nt_rev_bg);
 
    (void)fprintf(minitrc_fp, "%s=%s\n", "nt_hl_rev_fg", sio->nt_hl_rev_fg);
    (void)fprintf(minitrc_fp, "%s=%s\n", "nt_hl_rev_bg", sio->nt_hl_rev_bg);
 
    (void)fprintf(minitrc_fp, "%s=%s\n", "black", sio->black);
    (void)fprintf(minitrc_fp, "%s=%s\n", "red", sio->red);
    (void)fprintf(minitrc_fp, "%s=%s\n", "green", sio->green);
    (void)fprintf(minitrc_fp, "%s=%s\n", "yellow", sio->yellow);
    (void)fprintf(minitrc_fp, "%s=%s\n", "blue", sio->blue);
    (void)fprintf(minitrc_fp, "%s=%s\n", "magenta", sio->magenta);
    (void)fprintf(minitrc_fp, "%s=%s\n", "cyan", sio->cyan);
    (void)fprintf(minitrc_fp, "%s=%s\n", "white", sio->white);
    (void)fprintf(minitrc_fp, "%s=%s\n", "bblack", sio->bblack);
    (void)fprintf(minitrc_fp, "%s=%s\n", "bred", sio->bred);
    (void)fprintf(minitrc_fp, "%s=%s\n", "bgreen", sio->bgreen);
    (void)fprintf(minitrc_fp, "%s=%s\n", "byellow", sio->byellow);
    (void)fprintf(minitrc_fp, "%s=%s\n", "bblue", sio->bblue);
    (void)fprintf(minitrc_fp, "%s=%s\n", "bmagenta", sio->bmagenta);
    (void)fprintf(minitrc_fp, "%s=%s\n", "bcyan", sio->bcyan);
    (void)fprintf(minitrc_fp, "%s=%s\n", "bwhite", sio->bwhite);
    (void)fprintf(minitrc_fp, "%s=%s\n", "editor", init->editor);
    (void)fprintf(minitrc_fp, "%s=%s\n", "mapp_data", init->mapp_data);
    (void)fprintf(minitrc_fp, "%s=%s\n", "mapp_help", init->mapp_help);
    (void)fprintf(minitrc_fp, "%s=%s\n", "mapp_home", init->mapp_home);
    (void)fprintf(minitrc_fp, "%s=%s\n", "mapp_msrc", init->mapp_msrc);
    (void)fprintf(minitrc_fp, "%s=%s\n", "mapp_user", init->mapp_user);
    (void)fclose(minitrc_fp);
    strnz__cpy(tmp_str, "Configuration written to file: ", MAXLEN - 1);
    strnz__cat(tmp_str, minitrc_dmp, MAXLEN - 1);
    Perror(tmp_str);
    return 0;
}
/** @brief Derive full file specification from directory and file name
    @ingroup init
    @param file_spec - output full file specification
    @param dir - directory path
    @param file_name - file name
    @returns true if file_spec is derived, false otherwise
    @details If dir is nullptr, use MAPP_DIR environment variable or default
   directory, ~/menuapp.
    file_spec should be a pre-allocated char array of size MAXLEN to
   hold the resulting file specification
 */
bool derive_file_spec(char *file_spec, char *dir, char *file_name) {
    char ts[MAXLEN];
    char ts2[MAXLEN];
    char *e;
 
    if (!file_name || !*file_name) {
        *file_spec = '\0';
        return false;
    }
    if (dir) {
        strnz__cpy(ts, dir, MAXLEN - 1);
    } else {
        e = getenv("MAPP_DIR");
        if (e) {
            strnz__cpy(ts, e, MAXLEN - 1);
        } else {
            strnz__cpy(ts, "~/menuapp", MAXLEN - 1);
        }
    }
    trim_path(ts);
    strnz__cpy(ts2, ts, MAXLEN - 1);
    // construct the full file specification
    // check that the file exists and is readable
    strnz__cpy(file_spec, ts2, MAXLEN - 1);
    strnz__cat(file_spec, "/", MAXLEN - 1);
    strnz__cat(file_spec, file_name, MAXLEN - 1);
    return true;
}
/** @brief Display the version information of the application
    @ingroup init
    @details The version information is defined in the mapp_version variable
   and is printed to stdout when this function is called. */
void display_version() {
    fprintf(stdout, "\nC-Menu %s\n", CM_VERSION);
    fprintf(stdout, "\nC-Menu %s\n", CM_VERSION);
    fprintf(stdout, "C version: %ld\n", __STDC_VERSION__);
}
/** @brief Print an option and its value in a formatted manner
    @ingroup init
    @param o - option flag (e.g., "-a:")
    @param name - option name (e.g., "--minitrc")
    @param value - option value to print
    @details This function is used to display the current configuration options
   and their values in a readable format. */
void opt_prt_char(const char *o, const char *name, const char *value) {
    fprintf(stdout, "%3s %-15s: %s\n", o, name, value);
}
/** @brief Print an option and its value in a formatted manner for integer
   values
    @ingroup init
    @param o - option flag (e.g., "-C:")
    @param name - option name (e.g., "--cols")
    @param value - integer option value to print
    @details This function is used to display the current configuration options
   and their integer values in a readable format. */
void opt_prt_str(const char *o, const char *name, const char *value) {
    fprintf(stdout, "%3s %-15s: %s\n", o, name, value);
}
/** @brief Print an option and its value in a formatted manner for integer
   values
    @ingroup init
    @param o - option flag (e.g., "-C:")
    @param name - option name (e.g., "--cols")
    @param value - integer option value to print
    @details This function is used to display the current configuration options
   and their integer values in a readable format. */
void opt_prt_int(const char *o, const char *name, int value) {
    fprintf(stdout, "%3s %-15s: %d\n", o, name, value);
}
/** @brief Print an option and its value in a formatted manner for double
   values
    @ingroup init
    @param o - option flag (e.g., "-r:")
    @param name - option name (e.g., "red_gamma")
    @param value - double option value to print
    @details This function is used to display the current configuration options
   and their double values in a readable format. */
void opt_prt_double(const char *o, const char *name, double value) {
    fprintf(stdout, "%3s %-15s: %0.2f\n", o, name, value);
}
/** @brief Print an option and its value in a formatted manner for boolean
   values
    @ingroup init
    @param o - option flag (e.g., "-z")
    @param name - option name (e.g., "f_squeeze")
    @param value - boolean option value to print
    @details This function is used to display the current configuration options
   and their boolean values in a readable format, printing "true" or "false"
   based on the value. */
void opt_prt_bool(const char *o, const char *name, bool value) {
    fprintf(stdout, "%3s %-15s: %s\n", o, name, value ? "true" : "false");
}
/** @brief Dump the current configuration to stdout for debugging purposes
    @ingroup init
    @param init - pointer to Init struct containing the current
   configuration
    @param msg - string to print before dumping the configuration to stdout
   in a readable format, prefixed by the provided title string. */
void dump_config(Init *init, char *msg) {
    SIO *sio = init->sio;
    opt_prt_str("-a:", "--minitrc", init->minitrc);
    opt_prt_str("-k:", "  parent_cmd", init->parent_cmd);
    opt_prt_int("-C:", "  cols", init->cols);
    opt_prt_int("-L:", "  lines", init->lines);
    opt_prt_int("-n:", "  select_max", init->select_max);
    opt_prt_str("-o:", "  out_spec", init->out_spec);
    opt_prt_int("-X:", "  begx", init->begx);
    opt_prt_int("-Y:", "  begy", init->begy);
    opt_prt_str("-A:", "  cmd_all", init->cmd_all);
    opt_prt_str("-c:", "  cmd", init->cmd);
    opt_prt_str("-d:", "--mapp_spec", init->mapp_spec);
    opt_prt_str("   ", "  help_spec", init->help_spec);
    opt_prt_str("-i:", "  in_spec", init->in_spec);
    opt_prt_str("-R:", "  receiver_cmd", init->receiver_cmd);
    opt_prt_str("-S:", "  provider_cmd", init->provider_cmd);
    opt_prt_str("   ", "  title", init->title);
    opt_prt_bool("-e:", "  f_erase_remainder", init->f_erase_remainder);
    opt_prt_bool("-a ", "  f_strip_ansi", init->f_strip_ansi);
    opt_prt_bool("-s ", "  f_squeeze", init->f_squeeze);
    opt_prt_bool("-x:", "  f_ignore_case", init->f_ignore_case);
    opt_prt_bool("-N:", "  f_ln", init->f_ln);
    opt_prt_int("-t:", "  tab_stop", init->tab_stop);
    opt_prt_int("-w:", "  wait_timeout", wait_timeout);
    opt_prt_str("-u ", "  brackets", init->brackets);
    opt_prt_str("-f:", "  fill_char", init->fill_char);
    opt_prt_str("   ", "  editor", init->editor);
    opt_prt_str("   ", "  bg_clr_x", sio->bg_clr_x);
    opt_prt_str("   ", "  bo_clr_x", sio->bo_clr_x);
    opt_prt_str("   ", "  fg_clr_x", sio->fg_clr_x);
    opt_prt_str("   ", "  ln_bg_clr_x", sio->ln_bg_clr_x);
    opt_prt_str("   ", "  ln_clr_x", sio->ln_clr_x);
    opt_prt_double("   ", "  blue_gamma", sio->blue_gamma);
    opt_prt_double("   ", "  gray_gamma", sio->gray_gamma);
    opt_prt_double("   ", "  green_gamma", sio->green_gamma);
    opt_prt_double("   ", "  red_gamma", sio->red_gamma);
    opt_prt_str("   ", "  black", sio->black);
    opt_prt_str("   ", "  red", sio->red);
    opt_prt_str("   ", "  green", sio->green);
    opt_prt_str("   ", "  yellow", sio->yellow);
    opt_prt_str("   ", "  blue", sio->blue);
    opt_prt_str("   ", "  magenta", sio->magenta);
    opt_prt_str("   ", "  cyan", sio->cyan);
    opt_prt_str("   ", "  white", sio->white);
    opt_prt_str("   ", "  orange", sio->orange);
    opt_prt_str("   ", "  bblack", sio->bblack);
    opt_prt_str("   ", "  bred", sio->bred);
    opt_prt_str("   ", "  bgreen", sio->bgreen);
    opt_prt_str("   ", "  byellow", sio->byellow);
    opt_prt_str("   ", "  bblue", sio->bblue);
    opt_prt_str("   ", "  bmagenta", sio->bmagenta);
    opt_prt_str("   ", "  bcyan", sio->bcyan);
    opt_prt_str("   ", "  bwhite", sio->bwhite);
    opt_prt_str("   ", "  borange", sio->borange);
    opt_prt_str("   ", "--mapp_data", init->mapp_data);
    opt_prt_str("   ", "--mapp_help", init->mapp_help);
    opt_prt_str("   ", "--mapp_home", init->mapp_home);
    opt_prt_str("   ", "--mapp_msrc", init->mapp_msrc);
    opt_prt_str("   ", "--mapp_user", init->mapp_user);
    (void)fprintf(stdout, "\n%s\n\n", msg);
}