jory/upx
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

upx-clang-format -i snprintf.cpp

Browse Source
This commit is contained in:
Markus F.X.J. Oberhumer
2016-09-20 13:03:48 +02:00
parent 7acf150ac5
commit c97765de14
1 changed files with 159 additions and 184 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/snprintf.cpp
+159 -184
View File
@@ -58,7 +58,6 @@
* *
**************************************************************/ **************************************************************/
#if 1 #if 1
#include "conf.h" #include "conf.h"
#else #else
@@ -73,26 +72,26 @@
#undef LLONG #undef LLONG
#undef ULLONG #undef ULLONG
#if 1 #if 1
# define LLONG upx_int64_t #define LLONG upx_int64_t
# define ULLONG upx_uint64_t #define ULLONG upx_uint64_t
#else #else
# define LLONG long int #define LLONG long int
# define ULLONG unsigned long int #define ULLONG unsigned long int
#endif #endif
#undef NO_FLOAT #undef NO_FLOAT
#undef LDOUBLE #undef LDOUBLE
#if 1 #if 1
# define NO_FLOAT 1 #define NO_FLOAT 1
# if (ACC_CC_SUNPROC) #if (ACC_CC_SUNPROC)
# else
# define float error no_float
# define double error no_float
# endif
#elif 0 || (HAVE_LONG_DOUBLE)
# define LDOUBLE long double
#else #else
# define LDOUBLE double #define float error no_float
#define double error no_float
#endif
#elif 0 || (HAVE_LONG_DOUBLE)
#define LDOUBLE long double
#else
#define LDOUBLE double
#endif #endif
/* /*
@@ -101,50 +100,46 @@
/* format read states */ /* format read states */
#define DP_S_DEFAULT 0 #define DP_S_DEFAULT 0
#define DP_S_FLAGS 1 #define DP_S_FLAGS 1
#define DP_S_MIN 2 #define DP_S_MIN 2
#define DP_S_DOT 3 #define DP_S_DOT 3
#define DP_S_MAX 4 #define DP_S_MAX 4
#define DP_S_MOD 5 #define DP_S_MOD 5
#define DP_S_CONV 6 #define DP_S_CONV 6
#define DP_S_DONE 7 #define DP_S_DONE 7
/* format flags - Bits */ /* format flags - Bits */
#define DP_F_MINUS (1 << 0) #define DP_F_MINUS (1 << 0)
#define DP_F_PLUS (1 << 1) #define DP_F_PLUS (1 << 1)
#define DP_F_SPACE (1 << 2) #define DP_F_SPACE (1 << 2)
#define DP_F_NUM (1 << 3) #define DP_F_NUM (1 << 3)
#define DP_F_ZERO (1 << 4) #define DP_F_ZERO (1 << 4)
#define DP_F_UP (1 << 5) #define DP_F_UP (1 << 5)
#define DP_F_UNSIGNED (1 << 6) #define DP_F_UNSIGNED (1 << 6)
/* Conversion Flags */ /* Conversion Flags */
#define DP_C_SHORT 1 #define DP_C_SHORT 1
#define DP_C_LONG 2 #define DP_C_LONG 2
#define DP_C_LDOUBLE 3 #define DP_C_LDOUBLE 3
#define DP_C_LLONG 4 #define DP_C_LLONG 4
#define char_to_int(p) ((p)- '0') #define char_to_int(p) ((p) - '0')
#undef MAX #undef MAX
#define MAX(p,q) (((p) >= (q)) ? (p) : (q)) #define MAX(p, q) (((p) >= (q)) ? (p) : (q))
/************************************************************************* /*************************************************************************
// //
**************************************************************************/ **************************************************************************/
static void dopr_outch(char *buffer, size_t *currlen, size_t maxlen, int c) static void dopr_outch(char *buffer, size_t *currlen, size_t maxlen, int c) {
{
if (*currlen < maxlen) if (*currlen < maxlen)
buffer[*currlen] = (char) c; buffer[*currlen] = (char) c;
*currlen += 1; *currlen += 1;
} }
static void fmtstr(char *buffer, size_t *currlen, size_t maxlen, const char *value, int flags,
static void fmtstr(char *buffer, size_t *currlen, size_t maxlen, int min, int max) {
const char *value, int flags, int min, int max) int padlen, strln; /* amount to pad */
{
int padlen, strln; /* amount to pad */
int cnt = 0; int cnt = 0;
#ifdef DEBUG_SNPRINTF #ifdef DEBUG_SNPRINTF
@@ -153,7 +148,7 @@ static void fmtstr(char *buffer, size_t *currlen, size_t maxlen,
if (value == NULL) if (value == NULL)
value = "<NULL>"; value = "<NULL>";
for (strln = 0; value[strln]; ) /* strlen */ for (strln = 0; value[strln];) /* strlen */
++strln; ++strln;
padlen = min - strln; padlen = min - strln;
if (padlen < 0) if (padlen < 0)
@@ -162,29 +157,27 @@ static void fmtstr(char *buffer, size_t *currlen, size_t maxlen,
padlen = -padlen; /* Left Justify */ padlen = -padlen; /* Left Justify */
while ((padlen > 0) && (cnt < max)) { while ((padlen > 0) && (cnt < max)) {
dopr_outch (buffer, currlen, maxlen, ' '); dopr_outch(buffer, currlen, maxlen, ' ');
--padlen; --padlen;
++cnt; ++cnt;
} }
while (*value && (cnt < max)) { while (*value && (cnt < max)) {
dopr_outch (buffer, currlen, maxlen, *value++); dopr_outch(buffer, currlen, maxlen, *value++);
++cnt; ++cnt;
} }
while ((padlen < 0) && (cnt < max)) { while ((padlen < 0) && (cnt < max)) {
dopr_outch (buffer, currlen, maxlen, ' '); dopr_outch(buffer, currlen, maxlen, ' ');
++padlen; ++padlen;
++cnt; ++cnt;
} }
} }
/* Have to handle DP_F_NUM (ie 0x and 0 alternates) */ /* Have to handle DP_F_NUM (ie 0x and 0 alternates) */
static void fmtint(char *buffer, size_t *currlen, size_t maxlen, static void fmtint(char *buffer, size_t *currlen, size_t maxlen, LLONG value, unsigned base,
LLONG value, unsigned base, int min, int max, int flags) int min, int max, int flags) {
{
int signvalue = 0; int signvalue = 0;
ULLONG uvalue; ULLONG uvalue;
char convert[64+1]; char convert[64 + 1];
int place = 0; int place = 0;
int spadlen = 0; /* amount to space pad */ int spadlen = 0; /* amount to space pad */
int zpadlen = 0; /* amount to zero pad */ int zpadlen = 0; /* amount to zero pad */
@@ -197,11 +190,11 @@ static void fmtint(char *buffer, size_t *currlen, size_t maxlen,
uvalue = value; uvalue = value;
if (!(flags & DP_F_UNSIGNED)) { if (!(flags & DP_F_UNSIGNED)) {
if( value < 0 ) { if (value < 0) {
signvalue = '-'; signvalue = '-';
uvalue = -value; uvalue = -value;
} else { } else {
if (flags & DP_F_PLUS) /* Do a sign (+/i) */ if (flags & DP_F_PLUS) /* Do a sign (+/i) */
signvalue = '+'; signvalue = '+';
else if (flags & DP_F_SPACE) else if (flags & DP_F_SPACE)
signvalue = ' '; signvalue = ' ';
@@ -212,13 +205,15 @@ static void fmtint(char *buffer, size_t *currlen, size_t maxlen,
do { do {
convert[place] = digits[(unsigned) (uvalue % base)]; convert[place] = digits[(unsigned) (uvalue % base)];
uvalue /= base; uvalue /= base;
} while (++place < (int)sizeof(convert) - 1 && uvalue); } while (++place < (int) sizeof(convert) - 1 && uvalue);
convert[place] = 0; convert[place] = 0;
zpadlen = max - place; zpadlen = max - place;
spadlen = min - MAX (max, place) - (signvalue ? 1 : 0); spadlen = min - MAX(max, place) - (signvalue ? 1 : 0);
if (zpadlen < 0) zpadlen = 0; if (zpadlen < 0)
if (spadlen < 0) spadlen = 0; zpadlen = 0;
if (spadlen < 0)
spadlen = 0;
if (flags & DP_F_ZERO) { if (flags & DP_F_ZERO) {
zpadlen = MAX(zpadlen, spadlen); zpadlen = MAX(zpadlen, spadlen);
spadlen = 0; spadlen = 0;
@@ -227,46 +222,43 @@ static void fmtint(char *buffer, size_t *currlen, size_t maxlen,
spadlen = -spadlen; /* Left Justifty */ spadlen = -spadlen; /* Left Justifty */
#ifdef DEBUG_SNPRINTF #ifdef DEBUG_SNPRINTF
printf("zpad: %d, spad: %d, min: %d, max: %d, place: %d\n", printf("zpad: %d, spad: %d, min: %d, max: %d, place: %d\n", zpadlen, spadlen, min, max, place);
zpadlen, spadlen, min, max, place);
#endif #endif
/* Spaces */ /* Spaces */
while (spadlen > 0) { while (spadlen > 0) {
dopr_outch (buffer, currlen, maxlen, ' '); dopr_outch(buffer, currlen, maxlen, ' ');
--spadlen; --spadlen;
} }
/* Sign */ /* Sign */
if (signvalue) if (signvalue)
dopr_outch (buffer, currlen, maxlen, signvalue); dopr_outch(buffer, currlen, maxlen, signvalue);
/* Zeros */ /* Zeros */
while (zpadlen > 0) { while (zpadlen > 0) {
dopr_outch (buffer, currlen, maxlen, '0'); dopr_outch(buffer, currlen, maxlen, '0');
--zpadlen; --zpadlen;
} }
/* Digits */ /* Digits */
while (place > 0) while (place > 0)
dopr_outch (buffer, currlen, maxlen, convert[--place]); dopr_outch(buffer, currlen, maxlen, convert[--place]);
/* Left Justified spaces */ /* Left Justified spaces */
while (spadlen < 0) { while (spadlen < 0) {
dopr_outch (buffer, currlen, maxlen, ' '); dopr_outch(buffer, currlen, maxlen, ' ');
++spadlen; ++spadlen;
} }
} }
/************************************************************************* /*************************************************************************
// floating format support // floating format support
**************************************************************************/ **************************************************************************/
#if !(NO_FLOAT) #if !(NO_FLOAT)
static LDOUBLE abs_val(LDOUBLE value) static LDOUBLE abs_val(LDOUBLE value) {
{
LDOUBLE result = value; LDOUBLE result = value;
if (value < 0) if (value < 0)
@@ -275,8 +267,7 @@ static LDOUBLE abs_val(LDOUBLE value)
return result; return result;
} }
static LDOUBLE POW10(int exp) static LDOUBLE POW10(int exp) {
{
LDOUBLE result = 1; LDOUBLE result = 1;
while (exp) { while (exp) {
@@ -287,29 +278,29 @@ static LDOUBLE POW10(int exp)
return result; return result;
} }
static LLONG ROUND(LDOUBLE value) static LLONG ROUND(LDOUBLE value) {
{
LLONG intpart; LLONG intpart;
intpart = (LLONG)value; intpart = (LLONG) value;
value = value - intpart; value = value - intpart;
if (value >= 0.5) intpart++; if (value >= 0.5)
intpart++;
return intpart; return intpart;
} }
/* a replacement for modf that doesn't need the math library. Should /* a replacement for modf that doesn't need the math library. Should
be portable, but slow */ be portable, but slow */
static double my_modf(double x0, double *iptr) static double my_modf(double x0, double *iptr) {
{
int i; int i;
long l; long l;
double x = x0; double x = x0;
double f = 1.0; double f = 1.0;
for (i = 0; i < 100; i++) { for (i = 0; i < 100; i++) {
l = (long)x; l = (long) x;
if (l <= (x+1) && l >= (x-1)) break; if (l <= (x + 1) && l >= (x - 1))
break;
x *= 0.1; x *= 0.1;
f *= 10.0; f *= 10.0;
} }
@@ -323,8 +314,8 @@ static double my_modf(double x0, double *iptr)
if (i != 0) { if (i != 0) {
double i2, ret; double i2, ret;
ret = my_modf(x0-l*f, &i2); ret = my_modf(x0 - l * f, &i2);
*iptr = l*f + i2; *iptr = l * f + i2;
return ret; return ret;
} }
@@ -332,17 +323,15 @@ static double my_modf(double x0, double *iptr)
return x - *iptr; return x - *iptr;
} }
static void fmtfp(char *buffer, size_t *currlen, size_t maxlen, LDOUBLE fvalue, int min, int max,
static void fmtfp (char *buffer, size_t *currlen, size_t maxlen, int flags) {
LDOUBLE fvalue, int min, int max, int flags) /* avoid warnings with 'gcc -Wshadow' */
{
/* avoid warnings with 'gcc -Wshadow' */
#undef index #undef index
#define index iindex #define index iindex
int signvalue = 0; int signvalue = 0;
double ufvalue; double ufvalue;
char iconvert[311+1]; char iconvert[311 + 1];
char fconvert[311+1]; char fconvert[311 + 1];
int iplace = 0; int iplace = 0;
int fplace = 0; int fplace = 0;
int padlen = 0; /* amount to pad */ int padlen = 0; /* amount to pad */
@@ -362,7 +351,7 @@ static void fmtfp (char *buffer, size_t *currlen, size_t maxlen,
if (max < 0) if (max < 0)
max = 6; max = 6;
ufvalue = abs_val (fvalue); ufvalue = abs_val(fvalue);
if (fvalue < 0) { if (fvalue < 0) {
signvalue = '-'; signvalue = '-';
@@ -408,34 +397,34 @@ static void fmtfp (char *buffer, size_t *currlen, size_t maxlen,
/* Convert integer part */ /* Convert integer part */
do { do {
temp = intpart; temp = intpart;
my_modf(intpart*0.1, &intpart); my_modf(intpart * 0.1, &intpart);
temp = temp*0.1; temp = temp * 0.1;
index = (int) ((temp - intpart + 0.05) * 10.0); index = (int) ((temp - intpart + 0.05) * 10.0);
/* index = (int) (((double)(temp*0.1) -intpart +0.05) *10.0); */ /* index = (int) (((double)(temp*0.1) -intpart +0.05) *10.0); */
/* printf ("%llf, %f, %x\n", temp, intpart, index); */ /* printf ("%llf, %f, %x\n", temp, intpart, index); */
iconvert[iplace] = digits[index]; iconvert[iplace] = digits[index];
} while (++iplace < (int)sizeof(iconvert) - 1 && intpart); } while (++iplace < (int) sizeof(iconvert) - 1 && intpart);
iconvert[iplace] = 0; iconvert[iplace] = 0;
/* Convert fractional part */ /* Convert fractional part */
if (fracpart) if (fracpart) {
{
do { do {
temp = fracpart; temp = fracpart;
my_modf(fracpart*0.1, &fracpart); my_modf(fracpart * 0.1, &fracpart);
temp = temp*0.1; temp = temp * 0.1;
index = (int) ((temp - fracpart + 0.05) * 10.0); index = (int) ((temp - fracpart + 0.05) * 10.0);
/* index = (int) ((((temp/10) -fracpart) +0.05) *10); */ /* index = (int) ((((temp/10) -fracpart) +0.05) *10); */
/* printf ("%lf, %lf, %ld\n", temp, fracpart, index); */ /* printf ("%lf, %lf, %ld\n", temp, fracpart, index); */
fconvert[fplace] = digits[index]; fconvert[fplace] = digits[index];
} while (++fplace < (int)sizeof(fconvert) - 1 && fracpart); } while (++fplace < (int) sizeof(fconvert) - 1 && fracpart);
} }
fconvert[fplace] = 0; fconvert[fplace] = 0;
/* -1 for decimal point, another -1 if we are printing a sign */ /* -1 for decimal point, another -1 if we are printing a sign */
padlen = min - iplace - max - 1 - ((signvalue) ? 1 : 0); padlen = min - iplace - max - 1 - ((signvalue) ? 1 : 0);
zpadlen = max - fplace; zpadlen = max - fplace;
if (zpadlen < 0) zpadlen = 0; if (zpadlen < 0)
zpadlen = 0;
if (padlen < 0) if (padlen < 0)
padlen = 0; padlen = 0;
if (flags & DP_F_MINUS) if (flags & DP_F_MINUS)
@@ -443,24 +432,24 @@ static void fmtfp (char *buffer, size_t *currlen, size_t maxlen,
if ((flags & DP_F_ZERO) && (padlen > 0)) { if ((flags & DP_F_ZERO) && (padlen > 0)) {
if (signvalue) { if (signvalue) {
dopr_outch (buffer, currlen, maxlen, signvalue); dopr_outch(buffer, currlen, maxlen, signvalue);
--padlen; --padlen;
signvalue = 0; signvalue = 0;
} }
while (padlen > 0) { while (padlen > 0) {
dopr_outch (buffer, currlen, maxlen, '0'); dopr_outch(buffer, currlen, maxlen, '0');
--padlen; --padlen;
} }
} }
while (padlen > 0) { while (padlen > 0) {
dopr_outch (buffer, currlen, maxlen, ' '); dopr_outch(buffer, currlen, maxlen, ' ');
--padlen; --padlen;
} }
if (signvalue) if (signvalue)
dopr_outch (buffer, currlen, maxlen, signvalue); dopr_outch(buffer, currlen, maxlen, signvalue);
while (iplace > 0) while (iplace > 0)
dopr_outch (buffer, currlen, maxlen, iconvert[--iplace]); dopr_outch(buffer, currlen, maxlen, iconvert[--iplace]);
#ifdef DEBUG_SNPRINTF #ifdef DEBUG_SNPRINTF
printf("fmtfp: fplace=%d zpadlen=%d\n", fplace, zpadlen); printf("fmtfp: fplace=%d zpadlen=%d\n", fplace, zpadlen);
@@ -471,34 +460,31 @@ static void fmtfp (char *buffer, size_t *currlen, size_t maxlen,
* char to print out. * char to print out.
*/ */
if (max > 0) { if (max > 0) {
dopr_outch (buffer, currlen, maxlen, '.'); dopr_outch(buffer, currlen, maxlen, '.');
while (fplace > 0) while (fplace > 0)
dopr_outch (buffer, currlen, maxlen, fconvert[--fplace]); dopr_outch(buffer, currlen, maxlen, fconvert[--fplace]);
} }
while (zpadlen > 0) { while (zpadlen > 0) {
dopr_outch (buffer, currlen, maxlen, '0'); dopr_outch(buffer, currlen, maxlen, '0');
--zpadlen; --zpadlen;
} }
while (padlen < 0) { while (padlen < 0) {
dopr_outch (buffer, currlen, maxlen, ' '); dopr_outch(buffer, currlen, maxlen, ' ');
++padlen; ++padlen;
} }
#undef index #undef index
} }
#endif /* !(NO_FLOAT) */ #endif /* !(NO_FLOAT) */
/************************************************************************* /*************************************************************************
// dopr() // dopr()
**************************************************************************/ **************************************************************************/
static size_t dopr(char *buffer, size_t maxlen, const char *format, va_list args) static size_t dopr(char *buffer, size_t maxlen, const char *format, va_list args) {
{
char ch; char ch;
LLONG value; LLONG value;
#if !(NO_FLOAT) #if !(NO_FLOAT)
@@ -521,12 +507,12 @@ static size_t dopr(char *buffer, size_t maxlen, const char *format, va_list args
if (ch == '\0') if (ch == '\0')
state = DP_S_DONE; state = DP_S_DONE;
switch(state) { switch (state) {
case DP_S_DEFAULT: case DP_S_DEFAULT:
if (ch == '%') if (ch == '%')
state = DP_S_FLAGS; state = DP_S_FLAGS;
else else
dopr_outch (buffer, &currlen, maxlen, ch); dopr_outch(buffer, &currlen, maxlen, ch);
ch = *format++; ch = *format++;
break; break;
case DP_S_FLAGS: case DP_S_FLAGS:
@@ -557,11 +543,11 @@ static size_t dopr(char *buffer, size_t maxlen, const char *format, va_list args
} }
break; break;
case DP_S_MIN: case DP_S_MIN:
if (isdigit((unsigned char)ch)) { if (isdigit((unsigned char) ch)) {
min = 10*min + char_to_int(ch); min = 10 * min + char_to_int(ch);
ch = *format++; ch = *format++;
} else if (ch == '*') { } else if (ch == '*') {
min = va_arg (args, int); min = va_arg(args, int);
ch = *format++; ch = *format++;
state = DP_S_DOT; state = DP_S_DOT;
} else { } else {
@@ -577,13 +563,13 @@ static size_t dopr(char *buffer, size_t maxlen, const char *format, va_list args
} }
break; break;
case DP_S_MAX: case DP_S_MAX:
if (isdigit((unsigned char)ch)) { if (isdigit((unsigned char) ch)) {
if (max < 0) if (max < 0)
max = 0; max = 0;
max = 10*max + char_to_int(ch); max = 10 * max + char_to_int(ch);
ch = *format++; ch = *format++;
} else if (ch == '*') { } else if (ch == '*') {
max = va_arg (args, int); max = va_arg(args, int);
ch = *format++; ch = *format++;
state = DP_S_MOD; state = DP_S_MOD;
} else { } else {
@@ -599,7 +585,7 @@ static size_t dopr(char *buffer, size_t maxlen, const char *format, va_list args
case 'l': case 'l':
cflags = DP_C_LONG; cflags = DP_C_LONG;
ch = *format++; ch = *format++;
if (ch == 'l') { /* It's a long long */ if (ch == 'l') { /* It's a long long */
cflags = DP_C_LLONG; cflags = DP_C_LLONG;
ch = *format++; ch = *format++;
} }
@@ -618,77 +604,77 @@ static size_t dopr(char *buffer, size_t maxlen, const char *format, va_list args
case 'd': case 'd':
case 'i': case 'i':
if (cflags == DP_C_SHORT) if (cflags == DP_C_SHORT)
value = va_arg (args, int); value = va_arg(args, int);
else if (cflags == DP_C_LONG) else if (cflags == DP_C_LONG)
value = va_arg (args, long int); value = va_arg(args, long int);
else if (cflags == DP_C_LLONG) else if (cflags == DP_C_LLONG)
value = va_arg (args, LLONG); value = va_arg(args, LLONG);
else else
value = va_arg (args, int); value = va_arg(args, int);
fmtint (buffer, &currlen, maxlen, value, 10, min, max, flags); fmtint(buffer, &currlen, maxlen, value, 10, min, max, flags);
break; break;
case 'o': case 'o':
flags |= DP_F_UNSIGNED; flags |= DP_F_UNSIGNED;
if (cflags == DP_C_SHORT) if (cflags == DP_C_SHORT)
value = va_arg (args, unsigned int); value = va_arg(args, unsigned int);
else if (cflags == DP_C_LONG) else if (cflags == DP_C_LONG)
value = (long)va_arg (args, unsigned long int); value = (long) va_arg(args, unsigned long int);
else if (cflags == DP_C_LLONG) else if (cflags == DP_C_LLONG)
value = (long)va_arg (args, ULLONG); value = (long) va_arg(args, ULLONG);
else else
value = (long)va_arg (args, unsigned int); value = (long) va_arg(args, unsigned int);
fmtint (buffer, &currlen, maxlen, value, 8, min, max, flags); fmtint(buffer, &currlen, maxlen, value, 8, min, max, flags);
break; break;
case 'u': case 'u':
flags |= DP_F_UNSIGNED; flags |= DP_F_UNSIGNED;
if (cflags == DP_C_SHORT) if (cflags == DP_C_SHORT)
value = va_arg (args, unsigned int); value = va_arg(args, unsigned int);
else if (cflags == DP_C_LONG) else if (cflags == DP_C_LONG)
value = (long)va_arg (args, unsigned long int); value = (long) va_arg(args, unsigned long int);
else if (cflags == DP_C_LLONG) else if (cflags == DP_C_LLONG)
value = (LLONG)va_arg (args, ULLONG); value = (LLONG) va_arg(args, ULLONG);
else else
value = (long)va_arg (args, unsigned int); value = (long) va_arg(args, unsigned int);
fmtint (buffer, &currlen, maxlen, value, 10, min, max, flags); fmtint(buffer, &currlen, maxlen, value, 10, min, max, flags);
break; break;
case 'X': case 'X':
flags |= DP_F_UP; flags |= DP_F_UP;
case 'x': case 'x':
flags |= DP_F_UNSIGNED; flags |= DP_F_UNSIGNED;
if (cflags == DP_C_SHORT) if (cflags == DP_C_SHORT)
value = va_arg (args, unsigned int); value = va_arg(args, unsigned int);
else if (cflags == DP_C_LONG) else if (cflags == DP_C_LONG)
value = (long)va_arg (args, unsigned long int); value = (long) va_arg(args, unsigned long int);
else if (cflags == DP_C_LLONG) else if (cflags == DP_C_LLONG)
value = (LLONG)va_arg (args, ULLONG); value = (LLONG) va_arg(args, ULLONG);
else else
value = (long)va_arg (args, unsigned int); value = (long) va_arg(args, unsigned int);
fmtint (buffer, &currlen, maxlen, value, 16, min, max, flags); fmtint(buffer, &currlen, maxlen, value, 16, min, max, flags);
break; break;
#if !(NO_FLOAT) #if !(NO_FLOAT)
case 'f': case 'f':
if (cflags == DP_C_LDOUBLE) if (cflags == DP_C_LDOUBLE)
fvalue = va_arg (args, LDOUBLE); fvalue = va_arg(args, LDOUBLE);
else else
fvalue = va_arg (args, double); fvalue = va_arg(args, double);
/* um, floating point? */ /* um, floating point? */
fmtfp (buffer, &currlen, maxlen, fvalue, min, max, flags); fmtfp(buffer, &currlen, maxlen, fvalue, min, max, flags);
break; break;
case 'E': case 'E':
flags |= DP_F_UP; flags |= DP_F_UP;
case 'e': case 'e':
if (cflags == DP_C_LDOUBLE) if (cflags == DP_C_LDOUBLE)
fvalue = va_arg (args, LDOUBLE); fvalue = va_arg(args, LDOUBLE);
else else
fvalue = va_arg (args, double); fvalue = va_arg(args, double);
break; break;
case 'G': case 'G':
flags |= DP_F_UP; flags |= DP_F_UP;
case 'g': case 'g':
if (cflags == DP_C_LDOUBLE) if (cflags == DP_C_LDOUBLE)
fvalue = va_arg (args, LDOUBLE); fvalue = va_arg(args, LDOUBLE);
else else
fvalue = va_arg (args, double); fvalue = va_arg(args, double);
break; break;
#else #else
case 'f': case 'f':
@@ -700,42 +686,45 @@ static size_t dopr(char *buffer, size_t maxlen, const char *format, va_list args
exit(255); exit(255);
#endif /* !(NO_FLOAT) */ #endif /* !(NO_FLOAT) */
case 'c': case 'c':
dopr_outch (buffer, &currlen, maxlen, va_arg (args, int)); dopr_outch(buffer, &currlen, maxlen, va_arg(args, int));
break; break;
case 's': case 's':
strvalue = va_arg (args, const char *); strvalue = va_arg(args, const char *);
if (!strvalue) strvalue = "(NULL)"; if (!strvalue)
strvalue = "(NULL)";
if (max == -1) { if (max == -1) {
max = (int) strlen(strvalue); max = (int) strlen(strvalue);
} }
if (min > 0 && max >= 0 && min > max) max = min; if (min > 0 && max >= 0 && min > max)
fmtstr (buffer, &currlen, maxlen, strvalue, flags, min, max); max = min;
fmtstr(buffer, &currlen, maxlen, strvalue, flags, min, max);
break; break;
case 'p': case 'p':
strvalue = (const char *) va_arg (args, const void *); strvalue = (const char *) va_arg(args, const void *);
fmtint (buffer, &currlen, maxlen, (LLONG) (upx_uintptr_t) strvalue, 16, min, max, flags); fmtint(buffer, &currlen, maxlen, (LLONG)(upx_uintptr_t) strvalue, 16, min, max,
flags);
break; break;
case 'n': case 'n':
if (cflags == DP_C_SHORT) { if (cflags == DP_C_SHORT) {
short int *num; short int *num;
num = va_arg (args, short int *); num = va_arg(args, short int *);
*num = (short int)currlen; *num = (short int) currlen;
} else if (cflags == DP_C_LONG) { } else if (cflags == DP_C_LONG) {
long int *num; long int *num;
num = va_arg (args, long int *); num = va_arg(args, long int *);
*num = (long int)currlen; *num = (long int) currlen;
} else if (cflags == DP_C_LLONG) { } else if (cflags == DP_C_LLONG) {
LLONG *num; LLONG *num;
num = va_arg (args, LLONG *); num = va_arg(args, LLONG *);
*num = (LLONG)currlen; *num = (LLONG) currlen;
} else { } else {
int *num; int *num;
num = va_arg (args, int *); num = va_arg(args, int *);
*num = (int) currlen; *num = (int) currlen;
} }
break; break;
case '%': case '%':
dopr_outch (buffer, &currlen, maxlen, ch); dopr_outch(buffer, &currlen, maxlen, ch);
break; break;
case 'w': case 'w':
/* not supported yet, treat as next char */ /* not supported yet, treat as next char */
@@ -767,29 +756,26 @@ static size_t dopr(char *buffer, size_t maxlen, const char *format, va_list args
return currlen; return currlen;
} }
/************************************************************************* /*************************************************************************
// public entries // public entries
**************************************************************************/ **************************************************************************/
// UPX version with assertions // UPX version with assertions
static int xdopr(char *buffer, size_t maxlen, const char *format, va_list args) static int xdopr(char *buffer, size_t maxlen, const char *format, va_list args) {
{
size_t ret; size_t ret;
// preconditions // preconditions
assert(maxlen < INT_MAX); assert(maxlen < INT_MAX);
if (buffer != NULL) if (buffer != NULL)
assert((int)maxlen > 0); assert((int) maxlen > 0);
else else
assert(maxlen == 0); assert(maxlen == 0);
ret = dopr(buffer, maxlen, format, args); ret = dopr(buffer, maxlen, format, args);
// postconditions // postconditions
if (buffer != NULL) if (buffer != NULL) {
{ assert((int) ret >= 0);
assert((int)ret >= 0);
assert(ret < maxlen); assert(ret < maxlen);
assert(buffer[ret] == '\0'); assert(buffer[ret] == '\0');
} }
@@ -797,15 +783,11 @@ static int xdopr(char *buffer, size_t maxlen, const char *format, va_list args)
return (int) ret; return (int) ret;
} }
int upx_vsnprintf(char *str, size_t count, const char *format, va_list ap) {
int upx_vsnprintf(char *str, size_t count, const char *format, va_list ap)
{
return xdopr(str, count, format, ap); return xdopr(str, count, format, ap);
} }
int __acc_cdecl_va upx_snprintf(char *str, size_t count, const char *format, ...) {
int __acc_cdecl_va upx_snprintf(char *str, size_t count, const char *format,...)
{
va_list ap; va_list ap;
int ret; int ret;
@@ -815,28 +797,23 @@ int __acc_cdecl_va upx_snprintf(char *str, size_t count, const char *format,...)
return ret; return ret;
} }
int upx_vasprintf(char **ptr, const char *format, va_list ap) {
int upx_vasprintf(char **ptr, const char *format, va_list ap)
{
int ret; int ret;
assert(ptr != NULL); assert(ptr != NULL);
*ptr = NULL; *ptr = NULL;
ret = xdopr(NULL, 0, format, ap); ret = xdopr(NULL, 0, format, ap);
if (ret > 0) if (ret > 0) {
{
*ptr = (char *) malloc(ret + 1); *ptr = (char *) malloc(ret + 1);
assert(*ptr != NULL); assert(*ptr != NULL);
if (*ptr == NULL) if (*ptr == NULL)
return -1; return -1;
ret = xdopr(*ptr, ret+1, format, ap); ret = xdopr(*ptr, ret + 1, format, ap);
} }
return ret; return ret;
} }
int __acc_cdecl_va upx_asprintf(char **ptr, const char *format, ...) {
int __acc_cdecl_va upx_asprintf(char **ptr, const char *format, ...)
{
va_list ap; va_list ap;
int ret; int ret;
@@ -846,7 +823,6 @@ int __acc_cdecl_va upx_asprintf(char **ptr, const char *format, ...)
return ret; return ret;
} }
/************************************************************************* /*************************************************************************
// //
**************************************************************************/ **************************************************************************/
@@ -859,7 +835,7 @@ int __acc_cdecl_va upx_asprintf(char **ptr, const char *format, ...)
#include <math.h> #include <math.h>
#undef snprintf #undef snprintf
#define snprintf upx_snprintf #define snprintf upx_snprintf
//int sprintf(char *str,const char *fmt,...); //int sprintf(char *str,const char *fmt,...);
int main(void) int main(void)
@@ -998,4 +974,3 @@ int main(void)
/* /*
vi:ts=4:et vi:ts=4:et
*/ */