esp-idf/components/console/argtable3/arg_cmd.c
2022-11-10 11:05:23 +01:00

286 lines
9.1 KiB
C

/*
* SPDX-FileCopyrightText: 2013-2019 Tom G. Huang
*
* SPDX-License-Identifier: BSD-3-Clause
*/
/*******************************************************************************
* arg_cmd: Provides the sub-command mechanism
*
* This file is part of the argtable3 library.
*
* Copyright (C) 2013-2019 Tom G. Huang
* <tomghuang@gmail.com>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of STEWART HEITMANN nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL STEWART HEITMANN BE LIABLE FOR ANY DIRECT,
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
******************************************************************************/
#include "argtable3.h"
#ifndef ARG_AMALGAMATION
#include "argtable3_private.h"
#endif
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#define MAX_MODULE_VERSION_SIZE 128
static arg_hashtable_t* s_hashtable = NULL;
static char* s_module_name = NULL;
static int s_mod_ver_major = 0;
static int s_mod_ver_minor = 0;
static int s_mod_ver_patch = 0;
static char* s_mod_ver_tag = NULL;
static char* s_mod_ver = NULL;
void arg_set_module_name(const char* name) {
size_t slen;
xfree(s_module_name);
slen = strlen(name);
s_module_name = (char*)xmalloc(slen + 1);
memset(s_module_name, 0, slen + 1);
#if (defined(__STDC_LIB_EXT1__) && defined(__STDC_WANT_LIB_EXT1__)) || (defined(__STDC_SECURE_LIB__) && defined(__STDC_WANT_SECURE_LIB__))
strncpy_s(s_module_name, slen + 1, name, slen);
#else
memcpy(s_module_name, name, slen);
#endif
}
void arg_set_module_version(int major, int minor, int patch, const char* tag) {
size_t slen_tag, slen_ds;
arg_dstr_t ds;
s_mod_ver_major = major;
s_mod_ver_minor = minor;
s_mod_ver_patch = patch;
xfree(s_mod_ver_tag);
slen_tag = strlen(tag);
s_mod_ver_tag = (char*)xmalloc(slen_tag + 1);
memset(s_mod_ver_tag, 0, slen_tag + 1);
#if (defined(__STDC_LIB_EXT1__) && defined(__STDC_WANT_LIB_EXT1__)) || (defined(__STDC_SECURE_LIB__) && defined(__STDC_WANT_SECURE_LIB__))
strncpy_s(s_mod_ver_tag, slen_tag + 1, tag, slen_tag);
#else
memcpy(s_mod_ver_tag, tag, slen_tag);
#endif
ds = arg_dstr_create();
arg_dstr_catf(ds, "%d.", s_mod_ver_major);
arg_dstr_catf(ds, "%d.", s_mod_ver_minor);
arg_dstr_catf(ds, "%d.", s_mod_ver_patch);
arg_dstr_cat(ds, s_mod_ver_tag);
xfree(s_mod_ver);
slen_ds = strlen(arg_dstr_cstr(ds));
s_mod_ver = (char*)xmalloc(slen_ds + 1);
memset(s_mod_ver, 0, slen_ds + 1);
#if (defined(__STDC_LIB_EXT1__) && defined(__STDC_WANT_LIB_EXT1__)) || (defined(__STDC_SECURE_LIB__) && defined(__STDC_WANT_SECURE_LIB__))
strncpy_s(s_mod_ver, slen_ds + 1, arg_dstr_cstr(ds), slen_ds);
#else
memcpy(s_mod_ver, arg_dstr_cstr(ds), slen_ds);
#endif
arg_dstr_destroy(ds);
}
static unsigned int hash_key(const void* key) {
const char* str = (const char*)key;
int c;
unsigned int hash = 5381;
while ((c = *str++) != 0)
hash = ((hash << 5) + hash) + (unsigned int)c; /* hash * 33 + c */
return hash;
}
static int equal_keys(const void* key1, const void* key2) {
char* k1 = (char*)key1;
char* k2 = (char*)key2;
return (0 == strcmp(k1, k2));
}
void arg_cmd_init(void) {
s_hashtable = arg_hashtable_create(32, hash_key, equal_keys);
}
void arg_cmd_uninit(void) {
arg_hashtable_destroy(s_hashtable, 1);
}
void arg_cmd_register(const char* name, arg_cmdfn* proc, const char* description) {
arg_cmd_info_t* cmd_info;
size_t slen_name;
void* k;
assert(strlen(name) < ARG_CMD_NAME_LEN);
assert(strlen(description) < ARG_CMD_DESCRIPTION_LEN);
/* Check if the command already exists. */
/* If the command exists, replace the existing command. */
/* If the command doesn't exist, insert the command. */
cmd_info = (arg_cmd_info_t*)arg_hashtable_search(s_hashtable, name);
if (cmd_info) {
arg_hashtable_remove(s_hashtable, name);
cmd_info = NULL;
}
cmd_info = (arg_cmd_info_t*)xmalloc(sizeof(arg_cmd_info_t));
memset(cmd_info, 0, sizeof(arg_cmd_info_t));
#if (defined(__STDC_LIB_EXT1__) && defined(__STDC_WANT_LIB_EXT1__)) || (defined(__STDC_SECURE_LIB__) && defined(__STDC_WANT_SECURE_LIB__))
strncpy_s(cmd_info->name, ARG_CMD_NAME_LEN, name, strlen(name));
strncpy_s(cmd_info->description, ARG_CMD_DESCRIPTION_LEN, description, strlen(description));
#else
memcpy(cmd_info->name, name, strlen(name));
memcpy(cmd_info->description, description, strlen(description));
#endif
cmd_info->proc = proc;
slen_name = strlen(name);
k = xmalloc(slen_name + 1);
memset(k, 0, slen_name + 1);
#if (defined(__STDC_LIB_EXT1__) && defined(__STDC_WANT_LIB_EXT1__)) || (defined(__STDC_SECURE_LIB__) && defined(__STDC_WANT_SECURE_LIB__))
strncpy_s((char*)k, slen_name + 1, name, slen_name);
#else
memcpy((char*)k, name, slen_name);
#endif
arg_hashtable_insert(s_hashtable, k, cmd_info);
}
void arg_cmd_unregister(const char* name) {
arg_hashtable_remove(s_hashtable, name);
}
int arg_cmd_dispatch(const char* name, int argc, char* argv[], arg_dstr_t res) {
arg_cmd_info_t* cmd_info = arg_cmd_info(name);
assert(cmd_info != NULL);
assert(cmd_info->proc != NULL);
return cmd_info->proc(argc, argv, res);
}
arg_cmd_info_t* arg_cmd_info(const char* name) {
return (arg_cmd_info_t*)arg_hashtable_search(s_hashtable, name);
}
unsigned int arg_cmd_count(void) {
return arg_hashtable_count(s_hashtable);
}
arg_cmd_itr_t arg_cmd_itr_create(void) {
return (arg_cmd_itr_t)arg_hashtable_itr_create(s_hashtable);
}
int arg_cmd_itr_advance(arg_cmd_itr_t itr) {
return arg_hashtable_itr_advance((arg_hashtable_itr_t*)itr);
}
char* arg_cmd_itr_key(arg_cmd_itr_t itr) {
return (char*)arg_hashtable_itr_key((arg_hashtable_itr_t*)itr);
}
arg_cmd_info_t* arg_cmd_itr_value(arg_cmd_itr_t itr) {
return (arg_cmd_info_t*)arg_hashtable_itr_value((arg_hashtable_itr_t*)itr);
}
void arg_cmd_itr_destroy(arg_cmd_itr_t itr) {
arg_hashtable_itr_destroy((arg_hashtable_itr_t*)itr);
}
int arg_cmd_itr_search(arg_cmd_itr_t itr, void* k) {
return arg_hashtable_itr_search((arg_hashtable_itr_t*)itr, s_hashtable, k);
}
static const char* module_name(void) {
if (s_module_name == NULL || strlen(s_module_name) == 0)
return "<name>";
return s_module_name;
}
static const char* module_version(void) {
if (s_mod_ver == NULL || strlen(s_mod_ver) == 0)
return "0.0.0.0";
return s_mod_ver;
}
void arg_make_get_help_msg(arg_dstr_t res) {
arg_dstr_catf(res, "%s v%s\n", module_name(), module_version());
arg_dstr_catf(res, "Please type '%s help' to get more information.\n", module_name());
}
void arg_make_help_msg(arg_dstr_t ds, char* cmd_name, void** argtable) {
arg_cmd_info_t* cmd_info = (arg_cmd_info_t*)arg_hashtable_search(s_hashtable, cmd_name);
if (cmd_info) {
arg_dstr_catf(ds, "%s: %s\n", cmd_name, cmd_info->description);
}
arg_dstr_cat(ds, "Usage:\n");
arg_dstr_catf(ds, " %s", module_name());
arg_print_syntaxv_ds(ds, argtable, "\n \nAvailable options:\n");
arg_print_glossary_ds(ds, argtable, " %-23s %s\n");
arg_dstr_cat(ds, "\n");
}
void arg_make_syntax_err_msg(arg_dstr_t ds, void** argtable, struct arg_end* end) {
arg_print_errors_ds(ds, end, module_name());
arg_dstr_cat(ds, "Usage: \n");
arg_dstr_catf(ds, " %s", module_name());
arg_print_syntaxv_ds(ds, argtable, "\n");
arg_dstr_cat(ds, "\n");
}
int arg_make_syntax_err_help_msg(arg_dstr_t ds, char* name, int help, int nerrors, void** argtable, struct arg_end* end, int* exitcode) {
/* help handling
* note: '-h|--help' takes precedence over error reporting
*/
if (help > 0) {
arg_make_help_msg(ds, name, argtable);
*exitcode = EXIT_SUCCESS;
return 1;
}
/* syntax error handling */
if (nerrors > 0) {
arg_make_syntax_err_msg(ds, argtable, end);
*exitcode = EXIT_FAILURE;
return 1;
}
return 0;
}