summaryrefslogtreecommitdiff
path: root/lib/console/argtable3/arg_int.c
diff options
context:
space:
mode:
Diffstat (limited to 'lib/console/argtable3/arg_int.c')
-rw-r--r--lib/console/argtable3/arg_int.c294
1 files changed, 294 insertions, 0 deletions
diff --git a/lib/console/argtable3/arg_int.c b/lib/console/argtable3/arg_int.c
new file mode 100644
index 00000000..5be40e12
--- /dev/null
+++ b/lib/console/argtable3/arg_int.c
@@ -0,0 +1,294 @@
+/*
+ * SPDX-FileCopyrightText: 1998-2001,2003-2011,2013 Stewart Heitmann
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+/*******************************************************************************
+ * arg_int: Implements the int command-line option
+ *
+ * This file is part of the argtable3 library.
+ *
+ * Copyright (C) 1998-2001,2003-2011,2013 Stewart Heitmann
+ * <sheitmann@users.sourceforge.net>
+ * 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 <ctype.h>
+#include <limits.h>
+#include <stdlib.h>
+
+static void arg_int_resetfn(struct arg_int* parent) {
+ ARG_TRACE(("%s:resetfn(%p)\n", __FILE__, parent));
+ parent->count = 0;
+}
+
+/* strtol0x() is like strtol() except that the numeric string is */
+/* expected to be prefixed by "0X" where X is a user supplied char. */
+/* The string may optionally be prefixed by white space and + or - */
+/* as in +0X123 or -0X123. */
+/* Once the prefix has been scanned, the remainder of the numeric */
+/* string is converted using strtol() with the given base. */
+/* eg: to parse hex str="-0X12324", specify X='X' and base=16. */
+/* eg: to parse oct str="+0o12324", specify X='O' and base=8. */
+/* eg: to parse bin str="-0B01010", specify X='B' and base=2. */
+/* Failure of conversion is indicated by result where *endptr==str. */
+static long int strtol0X(const char* str, const char** endptr, char X, int base) {
+ long int val; /* stores result */
+ int s = 1; /* sign is +1 or -1 */
+ const char* ptr = str; /* ptr to current position in str */
+
+ /* skip leading whitespace */
+ while (isspace((int)(*ptr)))
+ ptr++;
+ /* printf("1) %s\n",ptr); */
+
+ /* scan optional sign character */
+ switch (*ptr) {
+ case '+':
+ ptr++;
+ s = 1;
+ break;
+ case '-':
+ ptr++;
+ s = -1;
+ break;
+ default:
+ s = 1;
+ break;
+ }
+ /* printf("2) %s\n",ptr); */
+
+ /* '0X' prefix */
+ if ((*ptr++) != '0') {
+ /* printf("failed to detect '0'\n"); */
+ *endptr = str;
+ return 0;
+ }
+ /* printf("3) %s\n",ptr); */
+ if (toupper(*ptr++) != toupper(X)) {
+ /* printf("failed to detect '%c'\n",X); */
+ *endptr = str;
+ return 0;
+ }
+ /* printf("4) %s\n",ptr); */
+
+ /* attempt conversion on remainder of string using strtol() */
+ val = strtol(ptr, (char**)endptr, base);
+ if (*endptr == ptr) {
+ /* conversion failed */
+ *endptr = str;
+ return 0;
+ }
+
+ /* success */
+ return s * val;
+}
+
+/* Returns 1 if str matches suffix (case insensitive). */
+/* Str may contain trailing whitespace, but nothing else. */
+static int detectsuffix(const char* str, const char* suffix) {
+ /* scan pairwise through strings until mismatch detected */
+ while (toupper(*str) == toupper(*suffix)) {
+ /* printf("'%c' '%c'\n", *str, *suffix); */
+
+ /* return 1 (success) if match persists until the string terminator */
+ if (*str == '\0')
+ return 1;
+
+ /* next chars */
+ str++;
+ suffix++;
+ }
+ /* printf("'%c' '%c' mismatch\n", *str, *suffix); */
+
+ /* return 0 (fail) if the matching did not consume the entire suffix */
+ if (*suffix != 0)
+ return 0; /* failed to consume entire suffix */
+
+ /* skip any remaining whitespace in str */
+ while (isspace((int)(*str)))
+ str++;
+
+ /* return 1 (success) if we have reached end of str else return 0 (fail) */
+ return (*str == '\0') ? 1 : 0;
+}
+
+static int arg_int_scanfn(struct arg_int* parent, const char* argval) {
+ int errorcode = 0;
+
+ if (parent->count == parent->hdr.maxcount) {
+ /* maximum number of arguments exceeded */
+ errorcode = ARG_ERR_MAXCOUNT;
+ } else if (!argval) {
+ /* a valid argument with no argument value was given. */
+ /* This happens when an optional argument value was invoked. */
+ /* leave parent arguiment value unaltered but still count the argument. */
+ parent->count++;
+ } else {
+ long int val;
+ const char* end;
+
+ /* attempt to extract hex integer (eg: +0x123) from argval into val conversion */
+ val = strtol0X(argval, &end, 'X', 16);
+ if (end == argval) {
+ /* hex failed, attempt octal conversion (eg +0o123) */
+ val = strtol0X(argval, &end, 'O', 8);
+ if (end == argval) {
+ /* octal failed, attempt binary conversion (eg +0B101) */
+ val = strtol0X(argval, &end, 'B', 2);
+ if (end == argval) {
+ /* binary failed, attempt decimal conversion with no prefix (eg 1234) */
+ val = strtol(argval, (char**)&end, 10);
+ if (end == argval) {
+ /* all supported number formats failed */
+ return ARG_ERR_BADINT;
+ }
+ }
+ }
+ }
+
+ /* Safety check for integer overflow. WARNING: this check */
+ /* achieves nothing on machines where size(int)==size(long). */
+ if (val > INT_MAX || val < INT_MIN)
+ errorcode = ARG_ERR_OVERFLOW;
+
+ /* Detect any suffixes (KB,MB,GB) and multiply argument value appropriately. */
+ /* We need to be mindful of integer overflows when using such big numbers. */
+ if (detectsuffix(end, "KB")) /* kilobytes */
+ {
+ if (val > (INT_MAX / 1024) || val < (INT_MIN / 1024))
+ errorcode = ARG_ERR_OVERFLOW; /* Overflow would occur if we proceed */
+ else
+ val *= 1024; /* 1KB = 1024 */
+ } else if (detectsuffix(end, "MB")) /* megabytes */
+ {
+ if (val > (INT_MAX / 1048576) || val < (INT_MIN / 1048576))
+ errorcode = ARG_ERR_OVERFLOW; /* Overflow would occur if we proceed */
+ else
+ val *= 1048576; /* 1MB = 1024*1024 */
+ } else if (detectsuffix(end, "GB")) /* gigabytes */
+ {
+ if (val > (INT_MAX / 1073741824) || val < (INT_MIN / 1073741824))
+ errorcode = ARG_ERR_OVERFLOW; /* Overflow would occur if we proceed */
+ else
+ val *= 1073741824; /* 1GB = 1024*1024*1024 */
+ } else if (!detectsuffix(end, ""))
+ errorcode = ARG_ERR_BADINT; /* invalid suffix detected */
+
+ /* if success then store result in parent->ival[] array */
+ if (errorcode == 0)
+ parent->ival[parent->count++] = (int)val;
+ }
+
+ /* printf("%s:scanfn(%p,%p) returns %d\n",__FILE__,parent,argval,errorcode); */
+ return errorcode;
+}
+
+static int arg_int_checkfn(struct arg_int* parent) {
+ int errorcode = (parent->count < parent->hdr.mincount) ? ARG_ERR_MINCOUNT : 0;
+ /*printf("%s:checkfn(%p) returns %d\n",__FILE__,parent,errorcode);*/
+ return errorcode;
+}
+
+static void arg_int_errorfn(struct arg_int* parent, arg_dstr_t ds, int errorcode, const char* argval, const char* progname) {
+ const char* shortopts = parent->hdr.shortopts;
+ const char* longopts = parent->hdr.longopts;
+ const char* datatype = parent->hdr.datatype;
+
+ /* make argval NULL safe */
+ argval = argval ? argval : "";
+
+ arg_dstr_catf(ds, "%s: ", progname);
+ switch (errorcode) {
+ case ARG_ERR_MINCOUNT:
+ arg_dstr_cat(ds, "missing option ");
+ arg_print_option_ds(ds, shortopts, longopts, datatype, "\n");
+ break;
+
+ case ARG_ERR_MAXCOUNT:
+ arg_dstr_cat(ds, "excess option ");
+ arg_print_option_ds(ds, shortopts, longopts, argval, "\n");
+ break;
+
+ case ARG_ERR_BADINT:
+ arg_dstr_catf(ds, "invalid argument \"%s\" to option ", argval);
+ arg_print_option_ds(ds, shortopts, longopts, datatype, "\n");
+ break;
+
+ case ARG_ERR_OVERFLOW:
+ arg_dstr_cat(ds, "integer overflow at option ");
+ arg_print_option_ds(ds, shortopts, longopts, datatype, " ");
+ arg_dstr_catf(ds, "(%s is too large)\n", argval);
+ break;
+ }
+}
+
+struct arg_int* arg_int0(const char* shortopts, const char* longopts, const char* datatype, const char* glossary) {
+ return arg_intn(shortopts, longopts, datatype, 0, 1, glossary);
+}
+
+struct arg_int* arg_int1(const char* shortopts, const char* longopts, const char* datatype, const char* glossary) {
+ return arg_intn(shortopts, longopts, datatype, 1, 1, glossary);
+}
+
+struct arg_int* arg_intn(const char* shortopts, const char* longopts, const char* datatype, int mincount, int maxcount, const char* glossary) {
+ size_t nbytes;
+ struct arg_int* result;
+
+ /* foolproof things by ensuring maxcount is not less than mincount */
+ maxcount = (maxcount < mincount) ? mincount : maxcount;
+
+ nbytes = sizeof(struct arg_int) /* storage for struct arg_int */
+ + (size_t)maxcount * sizeof(int); /* storage for ival[maxcount] array */
+
+ result = (struct arg_int*)xmalloc(nbytes);
+
+ /* init the arg_hdr struct */
+ result->hdr.flag = ARG_HASVALUE;
+ result->hdr.shortopts = shortopts;
+ result->hdr.longopts = longopts;
+ result->hdr.datatype = datatype ? datatype : "<int>";
+ result->hdr.glossary = glossary;
+ result->hdr.mincount = mincount;
+ result->hdr.maxcount = maxcount;
+ result->hdr.parent = result;
+ result->hdr.resetfn = (arg_resetfn*)arg_int_resetfn;
+ result->hdr.scanfn = (arg_scanfn*)arg_int_scanfn;
+ result->hdr.checkfn = (arg_checkfn*)arg_int_checkfn;
+ result->hdr.errorfn = (arg_errorfn*)arg_int_errorfn;
+
+ /* store the ival[maxcount] array immediately after the arg_int struct */
+ result->ival = (int*)(result + 1);
+ result->count = 0;
+
+ ARG_TRACE(("arg_intn() returns %p\n", result));
+ return result;
+}
generated by cgit v1.2.3 (git 2.25.1) at 2026-04-29 15:17:33 +0000