kopia lustrzana https://github.com/espressif/esp-idf
295 wiersze
11 KiB
C
295 wiersze
11 KiB
C
/*
|
|
* 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;
|
|
}
|