XOR64/xap
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
xap/xap.h

601 lines
20 KiB
C
Raw Blame History

// Copyright (C) 2024 Gvidas Juknevicius <mcorange@mcorangehq.xyz>
//
// Copyright (C) <year> <name of author>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
// Portions of this code (marked with "From nob"),
// were adapted from <https://github.com/tsoding/musializer/blob/master/src/nob.h>,
// originally authored by Alexey Kutepov <reximkut@gmail.com>
// All rights reserved by the original creator.
/// # Configurable macros
/// | macro name | Description |
/// |---------------------|-------------------------------------------------------|
/// | XAP_DISPLAY_VERSION | If defined, enables the version flag |
/// | XAP_EXIT_ON_ERROR | If defined, the program exits immediately on an error |
/// | XAP_USE_COLOR | If defined, enables the use of color and styles |
///
/// Redefinable macros:
/// | Macro name | Description |
/// |--------------|-------------|
/// | XAP_ASSERT | Assert |
/// | XAP_REALLOC | Mem |
/// | XAP_ALLOC | Mem |
/// | XAP_FREE | Mem |
///
/// # Public functions
///
/// Note: s_size_t is a macro of ptrdiff_t
///
/// | Description | Function Definition |
/// |-----------------------------|--------------------------------------------------------------|
/// | Main entry func for XAP | xap_result_t xap_parse(xap_t* xap, int argc, char** argv); |
/// | Free all allocated memory | void xap_free(xap_t* xap); |
/// | Get char* value by name | char* xap_get_arg_value_str(xap_t* xap, char* arg_name); |
/// | Get size_t* value by name | size_t* xap_get_arg_value_uint(xap_t* xap, char* arg_name); |
/// | Get s_size_t* value by name | s_size_t* xap_get_arg_value_int(xap_t* xap, char* arg_name); |
/// | Get float* value by name | float* xap_get_arg_value_float(xap_t* xap, char* arg_name); |
/// | Get bool* value by name | bool* xap_get_arg_value_bool(xap_t* xap, char* arg_name); |
/// | Make all text uppercase | void xap_to_upper(char* str); |
/// | Make all text lowercase | void xap_to_lower(char* str); |
#ifndef _H_XAP
#define _H_XAP
#include <assert.h>
#include <stdbool.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stddef.h>
#include <stdarg.h>
#define s_size_t ptrdiff_t
#ifndef xap_log_error
#define xap_log_error(fmt, ...) _xap_log_error(fmt, __VA_ARGS__)
#endif
#ifndef XAP_ASSERT
#define XAP_ASSERT assert
#endif
#ifndef XAP_REALLOC
#define XAP_REALLOC realloc
#endif
#ifndef XAP_ALLOC
#define XAP_ALLOC malloc
#endif
#ifndef XAP_FREE
#define XAP_FREE free
#endif
#ifdef XAP_USE_COLOR
#define XAP_C_UL "\e[4m"
#define XAP_C_RED "\e[0;31m"
#define XAP_C_RS "\e[0m"
#define XAP_C_BL "\e[1m"
#else
#define XAP_C_UL ""
#define XAP_C_RED ""
#define XAP_C_RS ""
#define XAP_C_BL ""
#endif
// From nob, starting from here
#define XAP_DA_INIT_CAP 256
#define XAP_ARRAY_LEN(array) (sizeof(array)/sizeof(array[0]))
#define XAP_ARRAY_GET(array, index) \
(XAP_ASSERT(index >= 0), XAP_ASSERT(index < XAP_ARRAY_LEN(array)), array[index])
#define XAP_DA_PUSH(da, item) \
do { \
if ((da)->count >= (da)->capacity) { \
(da)->capacity = (da)->capacity == 0 ? XAP_DA_INIT_CAP : (da)->capacity*2; \
(da)->items = XAP_REALLOC((da)->items, (da)->capacity*sizeof(*(da)->items)); \
XAP_ASSERT((da)->items != NULL && "Buy more RAM lol"); \
} \
\
(da)->items[(da)->count++] = (item); \
} while (0)
#define XAP_DA_FREE(da) XAP_FREE((da).items)
/proc/sys/kernel/core_pattern
#define XAP_DA_APPEND(da, new_items, new_items_count) \
do { \
if ((da)->count + (new_items_count) > (da)->capacity) { \
if ((da)->capacity == 0) { \
(da)->capacity = XAP_DA_INIT_CAP; \
} \
while ((da)->count + (new_items_count) > (da)->capacity) { \
(da)->capacity *= 2; \
} \
(da)->items = XAP_REALLOC((da)->items, (da)->capacity*sizeof(*(da)->items)); \
XAP_ASSERT((da)->items != NULL && "Buy more RAM lol"); \
} \
memcpy((da)->items + (da)->count, (new_items), (new_items_count)*sizeof(*(da)->items)); \
(da)->count += (new_items_count); \
} while (0)
// Nob code ends here
#define xap_arg_add(xap, arg) XAP_DA_PUSH(&(xap)->args, arg)
typedef enum xap_arg_type_e {
XAP_ARG_STR,
XAP_ARG_INT,
XAP_ARG_UINT,
XAP_ARG_FLOAT,
XAP_ARG_BOOL,
XAP_ARG_TOGGLE,
} xap_arg_type_e;
typedef struct xap_arg_t {
char* s_long;
char s_short;
char* description;
void* value;
void* default_value;
bool required;
xap_arg_type_e type;
} xap_arg_t;
typedef struct xap_args_t {
xap_arg_t* items;
size_t count;
size_t capacity;
} xap_args_t;
typedef struct xap_t {
xap_args_t args;
char* version;
char* program;
char* description;
char* footer;
char** post_args;
size_t post_arg_len;
char* post_args_name; // Display name for the left over args without the -
char* post_args_description; // Description for the left over args
} xap_t;
typedef enum xap_result_t {
XAP_ERR = 0,
XAP_OK = 1,
XAP_EXIT = 1,
} xap_result_t;
xap_arg_t* xap_get_arg(xap_t* xap, char* arg_name);
xap_result_t _xap_parse(xap_t* xap, int argc, char** argv); // used internally
xap_result_t xap_parse(xap_t* xap, int argc, char** argv);
char* xap_get_arg_value_str(xap_t* xap, char* arg_name);
size_t* xap_get_arg_value_uint(xap_t* xap, char* arg_name);
s_size_t* xap_get_arg_value_int(xap_t* xap, char* arg_name);
float* xap_get_arg_value_float(xap_t* xap, char* arg_name);
bool* xap_get_arg_value_bool(xap_t* xap, char* arg_name);
xap_result_t xap_parse_arg(xap_arg_t* arg, char* arg_text);
void xap_free(xap_t* xap);
void xap_to_upper(char* str);
void xap_to_lower(char* str);
void xap_show_help(xap_t* xap);
void _xap_log_error(char* format, ...);
#ifdef XAP_IMPL
// From nob
char* xap_shift_args(int* argc, char*** argv) {
XAP_ASSERT(*argc > 0);
char* result = **argv;
(*argv) += 1;
(*argc) -= 1;
return result;
}
xap_result_t xap_pre_parse(xap_t* xap) {
xap_arg_t help = {
.s_short = 'h',
.s_long = "help",
.description = "Shows this help text",
.type = XAP_ARG_TOGGLE,
};
xap_arg_add(xap, help);
#ifdef XAP_DISPLAY_VERSION
xap_arg_t version = {
.s_short = 'v',
.s_long = "version",
.description = "Shows the program version",
.type = XAP_ARG_TOGGLE,
};
xap_arg_add(xap, version);
#endif
}
xap_result_t xap_post_check(xap_t* xap) {
for (size_t i = 0; i < xap->args.count; i++) {
xap_arg_t* arg_def = &xap->args.items[i];
if (arg_def->required) {
if (arg_def->value == NULL) {
xap_show_help(xap);
xap_log_error("Missing required value --%s\n", arg_def->s_long);
return XAP_EXIT;
}
}
}
return XAP_OK;
}
xap_result_t xap_parse(xap_t* xap, int argc, char** argv) {
xap_result_t res = _xap_parse(xap, argc, argv);
#ifdef XAP_EXIT_ON_ERROR
if (res == XAP_EXIT) {
exit(1);
}
#endif
return res;
}
xap_result_t _xap_parse(xap_t* xap, int argc, char** argv) {
xap->program = xap_shift_args(&argc, &argv);
xap_pre_parse(xap);
while (argc > 0) {
char* arg_str = xap_shift_args(&argc, &argv);
size_t arg_len = strlen(arg_str);
if (arg_len > 0 && (*arg_str) == '-') {
if (arg_len == 2 && (*(arg_str+1)) == '-') {
// -- means stop parsing or something
xap->post_args = argv;
xap->post_arg_len = argc;
break;
} else if (arg_len > 1 && (*(arg_str+1)) == '-') {
// Long
arg_str = arg_str + 2;
for (size_t i = 0; i < xap->args.count; i++) {
xap_arg_t* arg_def = &xap->args.items[i];
if (strcmp(arg_def->s_long, arg_str) == 0) {
xap_result_t res = xap_parse_arg(arg_def, arg_str);
if (res != XAP_OK) return res;
break;
}
}
} else {
// Short
arg_str = arg_str + 1;
for (size_t i = 0; i < xap->args.count; i++) {
xap_arg_t* arg_def = &xap->args.items[i];
if (arg_len > 2) { // with -
// TODO: Print err for invalid arg
XAP_ASSERT(0 && "Invalid short flag, it can only contain 1 char");
return XAP_ERR;
}
if (arg_def->s_short == arg_str[0]) {
xap_result_t res = xap_parse_arg(arg_def, arg_str);
if (res != XAP_OK) return res;
break;
}
}
}
} else {
argv += 1;
argc -= 1;
xap->post_args = argv;
xap->post_arg_len = argc;
break;
}
}
bool* show_help = xap_get_arg_value_bool(xap, "help");
if (show_help && *show_help) {
xap_show_help(xap);
return XAP_EXIT;
}
#ifdef XAP_DISPLAY_VERSION
bool* show_version = xap_get_arg_value_bool(xap, "version");
if (show_version && *show_version) {
printf("%s version %s", xap->program, xap->version ? xap->version : "None");
return XAP_EXIT;
}
#endif
return xap_post_check(xap);
}
void xap_free(xap_t* xap) {
for (size_t i = 0; i < xap->args.count; i++) {
xap_arg_t* arg_def = &xap->args.items[i];
XAP_FREE(arg_def->value);
}
XAP_FREE(xap->args.items);
}
void xap_show_help(xap_t* xap) {
char buf[256];
if (xap->description) {
printf("%s\n", xap->description);
}
printf(XAP_C_UL "" XAP_C_BL "Usage" XAP_C_RS "" XAP_C_BL ": %s " XAP_C_RS "[options] ", xap->program);
size_t indent_size = 0;
for (size_t i = 0; i < xap->args.count; i++) {
xap_arg_t* arg_def = &xap->args.items[i];
size_t len = strlen(arg_def->s_long);
if (arg_def->required) {
memcpy(buf, arg_def->s_long, 256);
xap_to_upper(buf);
printf(XAP_C_BL "--%s" XAP_C_RS " <%s> ", arg_def->s_long, buf);
len = (len * 2) + 3;
if (len > indent_size) indent_size = len;
} else {
if (len > indent_size) indent_size = len;
}
}
if (xap->post_args_name != NULL) {
printf("[args]");
}
printf("...\n\n");
if (xap->post_args_name && xap->post_args_description) {
printf(XAP_C_UL "" XAP_C_BL "Arguments:\n" XAP_C_RS);
printf(" [%s]... %s\n\n",xap->post_args_name, xap->post_args_description);
}
if (xap->args.count > 0) {
printf(XAP_C_UL "" XAP_C_BL "Options:\n" XAP_C_RS);
for (size_t i = 0; i < xap->args.count; i++) {
xap_arg_t* arg_def = &xap->args.items[i];
printf(" " XAP_C_BL "-%c" XAP_C_RS ", " XAP_C_BL "--%s" XAP_C_RS, arg_def->s_short, arg_def->s_long);
size_t len = strlen(arg_def->s_long);
if (arg_def->required) {
memcpy(buf, arg_def->s_long, 256);
xap_to_upper(buf);
len = (len * 2) + 3;
printf(" <%s>", buf);
}
for (size_t y = 0; y <= indent_size - len; y++) {
printf(" ");
}
printf("%s ", arg_def->description);
if (arg_def->default_value) {
switch (arg_def->type) {
case XAP_ARG_STR: {
printf("[default: \"%s\"]\n", (char*)arg_def->default_value);
} break;
case XAP_ARG_UINT: {
printf("[default: %zu]\n", *(size_t*)arg_def->default_value);
} break;
case XAP_ARG_INT: {
printf("[default: %ti]\n", *(s_size_t*)arg_def->default_value);
} break;
case XAP_ARG_FLOAT: {
printf("[default: %.6f]\n", *(float*)arg_def->default_value);
} break;
case XAP_ARG_BOOL: {
printf("[default: %s]\n",
(*(bool*)arg_def->default_value) ? "true" : "false");
} break;
default:
break;
}
} else {
printf("\n");
}
}
}
if (xap->footer) {
printf("\n%s\n", xap->footer);
}
}
void _xap_log_error(char* format, ...) {
va_list args;
va_start(args, format);
fprintf(stderr, XAP_C_BL"[" XAP_C_RED "ERROR" XAP_C_RS "" XAP_C_BL "] " XAP_C_RS);
vfprintf(stderr, format, args);
va_end(args);
}
void xap_print_args(xap_t* xap) {
for (size_t i = 0; i < xap->args.count; i++) {
xap_arg_t* arg_def = &xap->args.items[i];
printf("%s -> ", arg_def->s_long);
void* def = arg_def->default_value;
void* val = arg_def->value;
switch (arg_def->type) {
case XAP_ARG_STR: {
printf("%s (\"%s\") (XAP_ARG_STR)\n",
val ? (char*)val : "NULL",
def ? (char*)def : "NULL");
} break;
case XAP_ARG_UINT: {
printf("%zu (%zu) (XAP_ARG_UINT)\n",
val ? *(size_t*)val : 0,
def ? *(size_t*)def : 0);
} break;
case XAP_ARG_INT: {
printf("%ti (%ti) (XAP_ARG_INT)\n",
val ? *(s_size_t*)val : 0,
def ? *(s_size_t*)def : 0);
} break;
case XAP_ARG_FLOAT: {
printf("%.6f (%.6f) (XAP_ARG_FLOAT)\n",
val ? *(float*)val : 0.0f,
def ? *(float*)def : 0.0f);
} break;
case XAP_ARG_BOOL: {
bool v = val ? *(bool*)val : false;
bool d = def ? *(bool*)def : false;
printf("%s (%s) (XAP_ARG_BOOL)\n",
v ? "true" : "false",
d ? "true" : "false");
} break;
case XAP_ARG_TOGGLE: {
bool v = val ? *(bool*)val : false;
printf("%s (NULL) (XAP_ARG_TOGGLE)\n",
v ? "true" : "false");
} break;
default:
break;
}
}
}
xap_arg_t* xap_get_arg(xap_t* xap, char* arg_name) {
for (size_t i = 0; i < xap->args.count; i++) {
xap_arg_t* arg_def = &xap->args.items[i];
if (strcmp(arg_def->s_long, arg_name) == 0) {
return arg_def;
}
}
return NULL;
}
char* xap_get_arg_value_str(xap_t* xap, char* arg_name) {
xap_arg_t* arg_def = xap_get_arg(xap, arg_name);
if (!arg_def) return NULL;
return (char*)arg_def->value;
}
size_t* xap_get_arg_value_uint(xap_t* xap, char* arg_name) {
xap_arg_t* arg_def = xap_get_arg(xap, arg_name);
if (!arg_def) return NULL;
return (size_t*)arg_def->value;
}
s_size_t* xap_get_arg_value_int(xap_t* xap, char* arg_name) {
xap_arg_t* arg_def = xap_get_arg(xap, arg_name);
if (!arg_def) return NULL;
return (s_size_t*)arg_def->value;
}
float* xap_get_arg_value_float(xap_t* xap, char* arg_name) {
xap_arg_t* arg_def = xap_get_arg(xap, arg_name);
if (!arg_def) return NULL;
return (float*)arg_def->value;
}
bool* xap_get_arg_value_bool(xap_t* xap, char* arg_name) {
xap_arg_t* arg_def = xap_get_arg(xap, arg_name);
if (!arg_def) return NULL;
return (bool*)arg_def->value;
}
xap_result_t xap_parse_arg(xap_arg_t* arg, char* arg_text) {
switch (arg->type) {
case XAP_ARG_STR: {
size_t len = strlen(arg_text) + 1; // for null byte
char* arg_val = XAP_ALLOC(sizeof(char)*len);
memmove(arg_val, arg_text, len);
arg->value = arg_val;
} break;
case XAP_ARG_UINT: {
size_t val = strtoul(arg_text, NULL, 0); // supports dec, hex, bin, oct, i think
size_t* arg_val = XAP_ALLOC(sizeof(size_t));
*arg_val = val;
arg->value = arg_val;
} break;
case XAP_ARG_INT: {
s_size_t val = strtol(arg_text, NULL, 0); // supports dec, hex, bin, oct, i think
s_size_t* arg_val = XAP_ALLOC(sizeof(s_size_t));
*arg_val = val;
arg->value = arg_val;
} break;
case XAP_ARG_FLOAT: {
float val = strtof(arg_text, NULL);
float* arg_val = XAP_ALLOC(sizeof(float));
*arg_val = val;
arg->value = arg_val;
} break;
case XAP_ARG_BOOL: {
bool* arg_val = XAP_ALLOC(sizeof(bool));
xap_to_lower(arg_text);
if (strcmp(arg_text, "true") == 0) {
*arg_val = false;
} if (strcmp(arg_text, "true") == 0) {
*arg_val = true;
} else {
// TODO: Print error
XAP_ASSERT(0 && "Invalid bool text");
return XAP_ERR;
}
arg->value = arg_val;
} break;
case XAP_ARG_TOGGLE: {
bool* arg_val = XAP_ALLOC(sizeof(bool));
*arg_val = true;
arg->value = arg_val;
} break;
default:
XAP_ASSERT(0 && "Invalid arg type");
return XAP_ERR;
}
return XAP_OK;
}
void xap_to_lower(char* str) {
for(int i = 0; str[i]; i++){
str[i] = tolower(str[i]);
}
}
void xap_to_upper(char* str) {
for(int i = 0; str[i]; i++){
str[i] = toupper(str[i]);
}
}
#endif
#endif
Reference in New Issue View Git Blame Copy Permalink