/* * 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 * * 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 #include #include 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 : ""; 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; }