| 1 |
/*************************************************************************** |
| 2 |
* _ _ ____ _ |
| 3 |
* Project ___| | | | _ \| | |
| 4 |
* / __| | | | |_) | | |
| 5 |
* | (__| |_| | _ <| |___ |
| 6 |
* \___|\___/|_| \_\_____| |
| 7 |
* |
| 8 |
* Copyright (C) 1999 - 2019, Daniel Stenberg, <[email protected]>, et al. |
| 9 |
* |
| 10 |
* This software is licensed as described in the file COPYING, which |
| 11 |
* you should have received as part of this distribution. The terms |
| 12 |
* are also available at https://curl.haxx.se/docs/copyright.html. |
| 13 |
* |
| 14 |
* You may opt to use, copy, modify, merge, publish, distribute and/or sell |
| 15 |
* copies of the Software, and permit persons to whom the Software is |
| 16 |
* furnished to do so, under the terms of the COPYING file. |
| 17 |
* |
| 18 |
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY |
| 19 |
* KIND, either express or implied. |
| 20 |
* |
| 21 |
* |
| 22 |
* Purpose: |
| 23 |
* A merge of Bjorn Reese's format() function and Daniel's dsprintf() |
| 24 |
* 1.0. A full blooded printf() clone with full support for <num>$ |
| 25 |
* everywhere (parameters, widths and precisions) including variabled |
| 26 |
* sized parameters (like doubles, long longs, long doubles and even |
| 27 |
* void * in 64-bit architectures). |
| 28 |
* |
| 29 |
* Current restrictions: |
| 30 |
* - Max 128 parameters |
| 31 |
* - No 'long double' support. |
| 32 |
* |
| 33 |
* If you ever want truly portable and good *printf() clones, the project that |
| 34 |
* took on from here is named 'Trio' and you find more details on the trio web |
| 35 |
* page at https://daniel.haxx.se/projects/trio/ |
| 36 |
*/ |
| 37 |
|
| 38 |
#include "curl_setup.h" |
| 39 |
#include <curl/mprintf.h> |
| 40 |
|
| 41 |
#include "curl_memory.h" |
| 42 |
/* The last #include file should be: */ |
| 43 |
#include "memdebug.h" |
| 44 |
|
| 45 |
/* |
| 46 |
* If SIZEOF_SIZE_T has not been defined, default to the size of long. |
| 47 |
*/ |
| 48 |
|
| 49 |
#ifdef HAVE_LONGLONG |
| 50 |
# define LONG_LONG_TYPE long long |
| 51 |
# define HAVE_LONG_LONG_TYPE |
| 52 |
#else |
| 53 |
# if defined(_MSC_VER) && (_MSC_VER >= 900) && (_INTEGRAL_MAX_BITS >= 64) |
| 54 |
# define LONG_LONG_TYPE __int64 |
| 55 |
# define HAVE_LONG_LONG_TYPE |
| 56 |
# else |
| 57 |
# undef LONG_LONG_TYPE |
| 58 |
# undef HAVE_LONG_LONG_TYPE |
| 59 |
# endif |
| 60 |
#endif |
| 61 |
|
| 62 |
/* |
| 63 |
* Non-ANSI integer extensions |
| 64 |
*/ |
| 65 |
|
| 66 |
#if (defined(__BORLANDC__) && (__BORLANDC__ >= 0x520)) || \ |
| 67 |
(defined(__WATCOMC__) && defined(__386__)) || \ |
| 68 |
(defined(__POCC__) && defined(_MSC_VER)) || \ |
| 69 |
(defined(_WIN32_WCE)) || \ |
| 70 |
(defined(__MINGW32__)) || \ |
| 71 |
(defined(_MSC_VER) && (_MSC_VER >= 900) && (_INTEGRAL_MAX_BITS >= 64)) |
| 72 |
# define MP_HAVE_INT_EXTENSIONS |
| 73 |
#endif |
| 74 |
|
| 75 |
/* |
| 76 |
* Max integer data types that mprintf.c is capable |
| 77 |
*/ |
| 78 |
|
| 79 |
#ifdef HAVE_LONG_LONG_TYPE |
| 80 |
# define mp_intmax_t LONG_LONG_TYPE |
| 81 |
# define mp_uintmax_t unsigned LONG_LONG_TYPE |
| 82 |
#else |
| 83 |
# define mp_intmax_t long |
| 84 |
# define mp_uintmax_t unsigned long |
| 85 |
#endif |
| 86 |
|
| 87 |
#define BUFFSIZE 326 /* buffer for long-to-str and float-to-str calcs, should |
| 88 |
fit negative DBL_MAX (317 letters) */ |
| 89 |
#define MAX_PARAMETERS 128 /* lame static limit */ |
| 90 |
|
| 91 |
#ifdef __AMIGA__ |
| 92 |
# undef FORMAT_INT |
| 93 |
#endif |
| 94 |
|
| 95 |
/* Lower-case digits. */ |
| 96 |
static const char lower_digits[] = "0123456789abcdefghijklmnopqrstuvwxyz"; |
| 97 |
|
| 98 |
/* Upper-case digits. */ |
| 99 |
static const char upper_digits[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"; |
| 100 |
|
| 101 |
#define OUTCHAR(x) \ |
| 102 |
do{ \ |
| 103 |
if(stream((unsigned char)(x), (FILE *)data) != -1) \ |
| 104 |
done++; \ |
| 105 |
else \ |
| 106 |
return done; /* return immediately on failure */ \ |
| 107 |
} while(0) |
| 108 |
|
| 109 |
/* Data type to read from the arglist */ |
| 110 |
typedef enum { |
| 111 |
FORMAT_UNKNOWN = 0, |
| 112 |
FORMAT_STRING, |
| 113 |
FORMAT_PTR, |
| 114 |
FORMAT_INT, |
| 115 |
FORMAT_INTPTR, |
| 116 |
FORMAT_LONG, |
| 117 |
FORMAT_LONGLONG, |
| 118 |
FORMAT_DOUBLE, |
| 119 |
FORMAT_LONGDOUBLE, |
| 120 |
FORMAT_WIDTH /* For internal use */ |
| 121 |
} FormatType; |
| 122 |
|
| 123 |
/* conversion and display flags */ |
| 124 |
enum { |
| 125 |
FLAGS_NEW = 0, |
| 126 |
FLAGS_SPACE = 1<<0, |
| 127 |
FLAGS_SHOWSIGN = 1<<1, |
| 128 |
FLAGS_LEFT = 1<<2, |
| 129 |
FLAGS_ALT = 1<<3, |
| 130 |
FLAGS_SHORT = 1<<4, |
| 131 |
FLAGS_LONG = 1<<5, |
| 132 |
FLAGS_LONGLONG = 1<<6, |
| 133 |
FLAGS_LONGDOUBLE = 1<<7, |
| 134 |
FLAGS_PAD_NIL = 1<<8, |
| 135 |
FLAGS_UNSIGNED = 1<<9, |
| 136 |
FLAGS_OCTAL = 1<<10, |
| 137 |
FLAGS_HEX = 1<<11, |
| 138 |
FLAGS_UPPER = 1<<12, |
| 139 |
FLAGS_WIDTH = 1<<13, /* '*' or '*<num>$' used */ |
| 140 |
FLAGS_WIDTHPARAM = 1<<14, /* width PARAMETER was specified */ |
| 141 |
FLAGS_PREC = 1<<15, /* precision was specified */ |
| 142 |
FLAGS_PRECPARAM = 1<<16, /* precision PARAMETER was specified */ |
| 143 |
FLAGS_CHAR = 1<<17, /* %c story */ |
| 144 |
FLAGS_FLOATE = 1<<18, /* %e or %E */ |
| 145 |
FLAGS_FLOATG = 1<<19 /* %g or %G */ |
| 146 |
}; |
| 147 |
|
| 148 |
typedef struct { |
| 149 |
FormatType type; |
| 150 |
int flags; |
| 151 |
long width; /* width OR width parameter number */ |
| 152 |
long precision; /* precision OR precision parameter number */ |
| 153 |
union { |
| 154 |
char *str; |
| 155 |
void *ptr; |
| 156 |
union { |
| 157 |
mp_intmax_t as_signed; |
| 158 |
mp_uintmax_t as_unsigned; |
| 159 |
} num; |
| 160 |
double dnum; |
| 161 |
} data; |
| 162 |
} va_stack_t; |
| 163 |
|
| 164 |
struct nsprintf { |
| 165 |
char *buffer; |
| 166 |
size_t length; |
| 167 |
size_t max; |
| 168 |
}; |
| 169 |
|
| 170 |
struct asprintf { |
| 171 |
char *buffer; /* allocated buffer */ |
| 172 |
size_t len; /* length of string */ |
| 173 |
size_t alloc; /* length of alloc */ |
| 174 |
int fail; /* (!= 0) if an alloc has failed and thus |
| 175 |
the output is not the complete data */ |
| 176 |
}; |
| 177 |
|
| 178 |
static long dprintf_DollarString(char *input, char **end) |
| 179 |
{ |
| 180 |
int number = 0; |
| 181 |
while(ISDIGIT(*input)) { |
| 182 |
number *= 10; |
| 183 |
number += *input-'0'; |
| 184 |
input++; |
| 185 |
} |
| 186 |
if(number && ('$'==*input++)) { |
| 187 |
*end = input; |
| 188 |
return number; |
| 189 |
} |
| 190 |
return 0; |
| 191 |
} |
| 192 |
|
| 193 |
static bool dprintf_IsQualifierNoDollar(const char *fmt) |
| 194 |
{ |
| 195 |
#if defined(MP_HAVE_INT_EXTENSIONS) |
| 196 |
if(!strncmp(fmt, "I32", 3) || !strncmp(fmt, "I64", 3)) { |
| 197 |
return TRUE; |
| 198 |
} |
| 199 |
#endif |
| 200 |
|
| 201 |
switch(*fmt) { |
| 202 |
case '-': case '+': case ' ': case '#': case '.': |
| 203 |
case '0': case '1': case '2': case '3': case '4': |
| 204 |
case '5': case '6': case '7': case '8': case '9': |
| 205 |
case 'h': case 'l': case 'L': case 'z': case 'q': |
| 206 |
case '*': case 'O': |
| 207 |
#if defined(MP_HAVE_INT_EXTENSIONS) |
| 208 |
case 'I': |
| 209 |
#endif |
| 210 |
return TRUE; |
| 211 |
|
| 212 |
default: |
| 213 |
return FALSE; |
| 214 |
} |
| 215 |
} |
| 216 |
|
| 217 |
/****************************************************************** |
| 218 |
* |
| 219 |
* Pass 1: |
| 220 |
* Create an index with the type of each parameter entry and its |
| 221 |
* value (may vary in size) |
| 222 |
* |
| 223 |
* Returns zero on success. |
| 224 |
* |
| 225 |
******************************************************************/ |
| 226 |
|
| 227 |
static int dprintf_Pass1(const char *format, va_stack_t *vto, char **endpos, |
| 228 |
va_list arglist) |
| 229 |
{ |
| 230 |
char *fmt = (char *)format; |
| 231 |
int param_num = 0; |
| 232 |
long this_param; |
| 233 |
long width; |
| 234 |
long precision; |
| 235 |
int flags; |
| 236 |
long max_param = 0; |
| 237 |
long i; |
| 238 |
|
| 239 |
while(*fmt) { |
| 240 |
if(*fmt++ == '%') { |
| 241 |
if(*fmt == '%') { |
| 242 |
fmt++; |
| 243 |
continue; /* while */ |
| 244 |
} |
| 245 |
|
| 246 |
flags = FLAGS_NEW; |
| 247 |
|
| 248 |
/* Handle the positional case (N$) */ |
| 249 |
|
| 250 |
param_num++; |
| 251 |
|
| 252 |
this_param = dprintf_DollarString(fmt, &fmt); |
| 253 |
if(0 == this_param) |
| 254 |
/* we got no positional, get the next counter */ |
| 255 |
this_param = param_num; |
| 256 |
|
| 257 |
if(this_param > max_param) |
| 258 |
max_param = this_param; |
| 259 |
|
| 260 |
/* |
| 261 |
* The parameter with number 'i' should be used. Next, we need |
| 262 |
* to get SIZE and TYPE of the parameter. Add the information |
| 263 |
* to our array. |
| 264 |
*/ |
| 265 |
|
| 266 |
width = 0; |
| 267 |
precision = 0; |
| 268 |
|
| 269 |
/* Handle the flags */ |
| 270 |
|
| 271 |
while(dprintf_IsQualifierNoDollar(fmt)) { |
| 272 |
#if defined(MP_HAVE_INT_EXTENSIONS) |
| 273 |
if(!strncmp(fmt, "I32", 3)) { |
| 274 |
flags |= FLAGS_LONG; |
| 275 |
fmt += 3; |
| 276 |
} |
| 277 |
else if(!strncmp(fmt, "I64", 3)) { |
| 278 |
flags |= FLAGS_LONGLONG; |
| 279 |
fmt += 3; |
| 280 |
} |
| 281 |
else |
| 282 |
#endif |
| 283 |
|
| 284 |
switch(*fmt++) { |
| 285 |
case ' ': |
| 286 |
flags |= FLAGS_SPACE; |
| 287 |
break; |
| 288 |
case '+': |
| 289 |
flags |= FLAGS_SHOWSIGN; |
| 290 |
break; |
| 291 |
case '-': |
| 292 |
flags |= FLAGS_LEFT; |
| 293 |
flags &= ~FLAGS_PAD_NIL; |
| 294 |
break; |
| 295 |
case '#': |
| 296 |
flags |= FLAGS_ALT; |
| 297 |
break; |
| 298 |
case '.': |
| 299 |
if('*' == *fmt) { |
| 300 |
/* The precision is picked from a specified parameter */ |
| 301 |
|
| 302 |
flags |= FLAGS_PRECPARAM; |
| 303 |
fmt++; |
| 304 |
param_num++; |
| 305 |
|
| 306 |
i = dprintf_DollarString(fmt, &fmt); |
| 307 |
if(i) |
| 308 |
precision = i; |
| 309 |
else |
| 310 |
precision = param_num; |
| 311 |
|
| 312 |
if(precision > max_param) |
| 313 |
max_param = precision; |
| 314 |
} |
| 315 |
else { |
| 316 |
flags |= FLAGS_PREC; |
| 317 |
precision = strtol(fmt, &fmt, 10); |
| 318 |
} |
| 319 |
break; |
| 320 |
case 'h': |
| 321 |
flags |= FLAGS_SHORT; |
| 322 |
break; |
| 323 |
#if defined(MP_HAVE_INT_EXTENSIONS) |
| 324 |
case 'I': |
| 325 |
#if (SIZEOF_CURL_OFF_T > SIZEOF_LONG) |
| 326 |
flags |= FLAGS_LONGLONG; |
| 327 |
#else |
| 328 |
flags |= FLAGS_LONG; |
| 329 |
#endif |
| 330 |
break; |
| 331 |
#endif |
| 332 |
case 'l': |
| 333 |
if(flags & FLAGS_LONG) |
| 334 |
flags |= FLAGS_LONGLONG; |
| 335 |
else |
| 336 |
flags |= FLAGS_LONG; |
| 337 |
break; |
| 338 |
case 'L': |
| 339 |
flags |= FLAGS_LONGDOUBLE; |
| 340 |
break; |
| 341 |
case 'q': |
| 342 |
flags |= FLAGS_LONGLONG; |
| 343 |
break; |
| 344 |
case 'z': |
| 345 |
/* the code below generates a warning if -Wunreachable-code is |
| 346 |
used */ |
| 347 |
#if (SIZEOF_SIZE_T > SIZEOF_LONG) |
| 348 |
flags |= FLAGS_LONGLONG; |
| 349 |
#else |
| 350 |
flags |= FLAGS_LONG; |
| 351 |
#endif |
| 352 |
break; |
| 353 |
case 'O': |
| 354 |
#if (SIZEOF_CURL_OFF_T > SIZEOF_LONG) |
| 355 |
flags |= FLAGS_LONGLONG; |
| 356 |
#else |
| 357 |
flags |= FLAGS_LONG; |
| 358 |
#endif |
| 359 |
break; |
| 360 |
case '0': |
| 361 |
if(!(flags & FLAGS_LEFT)) |
| 362 |
flags |= FLAGS_PAD_NIL; |
| 363 |
/* FALLTHROUGH */ |
| 364 |
case '1': case '2': case '3': case '4': |
| 365 |
case '5': case '6': case '7': case '8': case '9': |
| 366 |
flags |= FLAGS_WIDTH; |
| 367 |
width = strtol(fmt-1, &fmt, 10); |
| 368 |
break; |
| 369 |
case '*': /* Special case */ |
| 370 |
flags |= FLAGS_WIDTHPARAM; |
| 371 |
param_num++; |
| 372 |
|
| 373 |
i = dprintf_DollarString(fmt, &fmt); |
| 374 |
if(i) |
| 375 |
width = i; |
| 376 |
else |
| 377 |
width = param_num; |
| 378 |
if(width > max_param) |
| 379 |
max_param = width; |
| 380 |
break; |
| 381 |
default: |
| 382 |
break; |
| 383 |
} |
| 384 |
} /* switch */ |
| 385 |
|
| 386 |
/* Handle the specifier */ |
| 387 |
|
| 388 |
i = this_param - 1; |
| 389 |
|
| 390 |
if((i < 0) || (i >= MAX_PARAMETERS)) |
| 391 |
/* out of allowed range */ |
| 392 |
return 1; |
| 393 |
|
| 394 |
switch (*fmt) { |
| 395 |
case 'S': |
| 396 |
flags |= FLAGS_ALT; |
| 397 |
/* FALLTHROUGH */ |
| 398 |
case 's': |
| 399 |
vto[i].type = FORMAT_STRING; |
| 400 |
break; |
| 401 |
case 'n': |
| 402 |
vto[i].type = FORMAT_INTPTR; |
| 403 |
break; |
| 404 |
case 'p': |
| 405 |
vto[i].type = FORMAT_PTR; |
| 406 |
break; |
| 407 |
case 'd': case 'i': |
| 408 |
vto[i].type = FORMAT_INT; |
| 409 |
break; |
| 410 |
case 'u': |
| 411 |
vto[i].type = FORMAT_INT; |
| 412 |
flags |= FLAGS_UNSIGNED; |
| 413 |
break; |
| 414 |
case 'o': |
| 415 |
vto[i].type = FORMAT_INT; |
| 416 |
flags |= FLAGS_OCTAL; |
| 417 |
break; |
| 418 |
case 'x': |
| 419 |
vto[i].type = FORMAT_INT; |
| 420 |
flags |= FLAGS_HEX|FLAGS_UNSIGNED; |
| 421 |
break; |
| 422 |
case 'X': |
| 423 |
vto[i].type = FORMAT_INT; |
| 424 |
flags |= FLAGS_HEX|FLAGS_UPPER|FLAGS_UNSIGNED; |
| 425 |
break; |
| 426 |
case 'c': |
| 427 |
vto[i].type = FORMAT_INT; |
| 428 |
flags |= FLAGS_CHAR; |
| 429 |
break; |
| 430 |
case 'f': |
| 431 |
vto[i].type = FORMAT_DOUBLE; |
| 432 |
break; |
| 433 |
case 'e': |
| 434 |
vto[i].type = FORMAT_DOUBLE; |
| 435 |
flags |= FLAGS_FLOATE; |
| 436 |
break; |
| 437 |
case 'E': |
| 438 |
vto[i].type = FORMAT_DOUBLE; |
| 439 |
flags |= FLAGS_FLOATE|FLAGS_UPPER; |
| 440 |
break; |
| 441 |
case 'g': |
| 442 |
vto[i].type = FORMAT_DOUBLE; |
| 443 |
flags |= FLAGS_FLOATG; |
| 444 |
break; |
| 445 |
case 'G': |
| 446 |
vto[i].type = FORMAT_DOUBLE; |
| 447 |
flags |= FLAGS_FLOATG|FLAGS_UPPER; |
| 448 |
break; |
| 449 |
default: |
| 450 |
vto[i].type = FORMAT_UNKNOWN; |
| 451 |
break; |
| 452 |
} /* switch */ |
| 453 |
|
| 454 |
vto[i].flags = flags; |
| 455 |
vto[i].width = width; |
| 456 |
vto[i].precision = precision; |
| 457 |
|
| 458 |
if(flags & FLAGS_WIDTHPARAM) { |
| 459 |
/* we have the width specified from a parameter, so we make that |
| 460 |
parameter's info setup properly */ |
| 461 |
long k = width - 1; |
| 462 |
vto[i].width = k; |
| 463 |
vto[k].type = FORMAT_WIDTH; |
| 464 |
vto[k].flags = FLAGS_NEW; |
| 465 |
/* can't use width or precision of width! */ |
| 466 |
vto[k].width = 0; |
| 467 |
vto[k].precision = 0; |
| 468 |
} |
| 469 |
if(flags & FLAGS_PRECPARAM) { |
| 470 |
/* we have the precision specified from a parameter, so we make that |
| 471 |
parameter's info setup properly */ |
| 472 |
long k = precision - 1; |
| 473 |
vto[i].precision = k; |
| 474 |
vto[k].type = FORMAT_WIDTH; |
| 475 |
vto[k].flags = FLAGS_NEW; |
| 476 |
/* can't use width or precision of width! */ |
| 477 |
vto[k].width = 0; |
| 478 |
vto[k].precision = 0; |
| 479 |
} |
| 480 |
*endpos++ = fmt + 1; /* end of this sequence */ |
| 481 |
} |
| 482 |
} |
| 483 |
|
| 484 |
/* Read the arg list parameters into our data list */ |
| 485 |
for(i = 0; i<max_param; i++) { |
| 486 |
/* Width/precision arguments must be read before the main argument |
| 487 |
they are attached to */ |
| 488 |
if(vto[i].flags & FLAGS_WIDTHPARAM) { |
| 489 |
vto[vto[i].width].data.num.as_signed = |
| 490 |
(mp_intmax_t)va_arg(arglist, int); |
| 491 |
} |
| 492 |
if(vto[i].flags & FLAGS_PRECPARAM) { |
| 493 |
vto[vto[i].precision].data.num.as_signed = |
| 494 |
(mp_intmax_t)va_arg(arglist, int); |
| 495 |
} |
| 496 |
|
| 497 |
switch(vto[i].type) { |
| 498 |
case FORMAT_STRING: |
| 499 |
vto[i].data.str = va_arg(arglist, char *); |
| 500 |
break; |
| 501 |
|
| 502 |
case FORMAT_INTPTR: |
| 503 |
case FORMAT_UNKNOWN: |
| 504 |
case FORMAT_PTR: |
| 505 |
vto[i].data.ptr = va_arg(arglist, void *); |
| 506 |
break; |
| 507 |
|
| 508 |
case FORMAT_INT: |
| 509 |
#ifdef HAVE_LONG_LONG_TYPE |
| 510 |
if((vto[i].flags & FLAGS_LONGLONG) && (vto[i].flags & FLAGS_UNSIGNED)) |
| 511 |
vto[i].data.num.as_unsigned = |
| 512 |
(mp_uintmax_t)va_arg(arglist, mp_uintmax_t); |
| 513 |
else if(vto[i].flags & FLAGS_LONGLONG) |
| 514 |
vto[i].data.num.as_signed = |
| 515 |
(mp_intmax_t)va_arg(arglist, mp_intmax_t); |
| 516 |
else |
| 517 |
#endif |
| 518 |
{ |
| 519 |
if((vto[i].flags & FLAGS_LONG) && (vto[i].flags & FLAGS_UNSIGNED)) |
| 520 |
vto[i].data.num.as_unsigned = |
| 521 |
(mp_uintmax_t)va_arg(arglist, unsigned long); |
| 522 |
else if(vto[i].flags & FLAGS_LONG) |
| 523 |
vto[i].data.num.as_signed = |
| 524 |
(mp_intmax_t)va_arg(arglist, long); |
| 525 |
else if(vto[i].flags & FLAGS_UNSIGNED) |
| 526 |
vto[i].data.num.as_unsigned = |
| 527 |
(mp_uintmax_t)va_arg(arglist, unsigned int); |
| 528 |
else |
| 529 |
vto[i].data.num.as_signed = |
| 530 |
(mp_intmax_t)va_arg(arglist, int); |
| 531 |
} |
| 532 |
break; |
| 533 |
|
| 534 |
case FORMAT_DOUBLE: |
| 535 |
vto[i].data.dnum = va_arg(arglist, double); |
| 536 |
break; |
| 537 |
|
| 538 |
case FORMAT_WIDTH: |
| 539 |
/* Argument has been read. Silently convert it into an integer |
| 540 |
* for later use |
| 541 |
*/ |
| 542 |
vto[i].type = FORMAT_INT; |
| 543 |
break; |
| 544 |
|
| 545 |
default: |
| 546 |
break; |
| 547 |
} |
| 548 |
} |
| 549 |
|
| 550 |
return 0; |
| 551 |
|
| 552 |
} |
| 553 |
|
| 554 |
static int dprintf_formatf( |
| 555 |
void *data, /* untouched by format(), just sent to the stream() function in |
| 556 |
the second argument */ |
| 557 |
/* function pointer called for each output character */ |
| 558 |
int (*stream)(int, FILE *), |
| 559 |
const char *format, /* %-formatted string */ |
| 560 |
va_list ap_save) /* list of parameters */ |
| 561 |
{ |
| 562 |
/* Base-36 digits for numbers. */ |
| 563 |
const char *digits = lower_digits; |
| 564 |
|
| 565 |
/* Pointer into the format string. */ |
| 566 |
char *f; |
| 567 |
|
| 568 |
/* Number of characters written. */ |
| 569 |
int done = 0; |
| 570 |
|
| 571 |
long param; /* current parameter to read */ |
| 572 |
long param_num = 0; /* parameter counter */ |
| 573 |
|
| 574 |
va_stack_t vto[MAX_PARAMETERS]; |
| 575 |
char *endpos[MAX_PARAMETERS]; |
| 576 |
char **end; |
| 577 |
|
| 578 |
char work[BUFFSIZE]; |
| 579 |
|
| 580 |
va_stack_t *p; |
| 581 |
|
| 582 |
/* 'workend' points to the final buffer byte position, but with an extra |
| 583 |
byte as margin to avoid the (false?) warning Coverity gives us |
| 584 |
otherwise */ |
| 585 |
char *workend = &work[sizeof(work) - 2]; |
| 586 |
|
| 587 |
/* Do the actual %-code parsing */ |
| 588 |
if(dprintf_Pass1(format, vto, endpos, ap_save)) |
| 589 |
return -1; |
| 590 |
|
| 591 |
end = &endpos[0]; /* the initial end-position from the list dprintf_Pass1() |
| 592 |
created for us */ |
| 593 |
|
| 594 |
f = (char *)format; |
| 595 |
while(*f != '\0') { |
| 596 |
/* Format spec modifiers. */ |
| 597 |
int is_alt; |
| 598 |
|
| 599 |
/* Width of a field. */ |
| 600 |
long width; |
| 601 |
|
| 602 |
/* Precision of a field. */ |
| 603 |
long prec; |
| 604 |
|
| 605 |
/* Decimal integer is negative. */ |
| 606 |
int is_neg; |
| 607 |
|
| 608 |
/* Base of a number to be written. */ |
| 609 |
unsigned long base; |
| 610 |
|
| 611 |
/* Integral values to be written. */ |
| 612 |
mp_uintmax_t num; |
| 613 |
|
| 614 |
/* Used to convert negative in positive. */ |
| 615 |
mp_intmax_t signed_num; |
| 616 |
|
| 617 |
char *w; |
| 618 |
|
| 619 |
if(*f != '%') { |
| 620 |
/* This isn't a format spec, so write everything out until the next one |
| 621 |
OR end of string is reached. */ |
| 622 |
do { |
| 623 |
OUTCHAR(*f); |
| 624 |
} while(*++f && ('%' != *f)); |
| 625 |
continue; |
| 626 |
} |
| 627 |
|
| 628 |
++f; |
| 629 |
|
| 630 |
/* Check for "%%". Note that although the ANSI standard lists |
| 631 |
'%' as a conversion specifier, it says "The complete format |
| 632 |
specification shall be `%%'," so we can avoid all the width |
| 633 |
and precision processing. */ |
| 634 |
if(*f == '%') { |
| 635 |
++f; |
| 636 |
OUTCHAR('%'); |
| 637 |
continue; |
| 638 |
} |
| 639 |
|
| 640 |
/* If this is a positional parameter, the position must follow immediately |
| 641 |
after the %, thus create a %<num>$ sequence */ |
| 642 |
param = dprintf_DollarString(f, &f); |
| 643 |
|
| 644 |
if(!param) |
| 645 |
param = param_num; |
| 646 |
else |
| 647 |
--param; |
| 648 |
|
| 649 |
param_num++; /* increase this always to allow "%2$s %1$s %s" and then the |
| 650 |
third %s will pick the 3rd argument */ |
| 651 |
|
| 652 |
p = &vto[param]; |
| 653 |
|
| 654 |
/* pick up the specified width */ |
| 655 |
if(p->flags & FLAGS_WIDTHPARAM) { |
| 656 |
width = (long)vto[p->width].data.num.as_signed; |
| 657 |
param_num++; /* since the width is extracted from a parameter, we |
| 658 |
must skip that to get to the next one properly */ |
| 659 |
if(width < 0) { |
| 660 |
/* "A negative field width is taken as a '-' flag followed by a |
| 661 |
positive field width." */ |
| 662 |
width = -width; |
| 663 |
p->flags |= FLAGS_LEFT; |
| 664 |
p->flags &= ~FLAGS_PAD_NIL; |
| 665 |
} |
| 666 |
} |
| 667 |
else |
| 668 |
width = p->width; |
| 669 |
|
| 670 |
/* pick up the specified precision */ |
| 671 |
if(p->flags & FLAGS_PRECPARAM) { |
| 672 |
prec = (long)vto[p->precision].data.num.as_signed; |
| 673 |
param_num++; /* since the precision is extracted from a parameter, we |
| 674 |
must skip that to get to the next one properly */ |
| 675 |
if(prec < 0) |
| 676 |
/* "A negative precision is taken as if the precision were |
| 677 |
omitted." */ |
| 678 |
prec = -1; |
| 679 |
} |
| 680 |
else if(p->flags & FLAGS_PREC) |
| 681 |
prec = p->precision; |
| 682 |
else |
| 683 |
prec = -1; |
| 684 |
|
| 685 |
is_alt = (p->flags & FLAGS_ALT) ? 1 : 0; |
| 686 |
|
| 687 |
switch(p->type) { |
| 688 |
case FORMAT_INT: |
| 689 |
num = p->data.num.as_unsigned; |
| 690 |
if(p->flags & FLAGS_CHAR) { |
| 691 |
/* Character. */ |
| 692 |
if(!(p->flags & FLAGS_LEFT)) |
| 693 |
while(--width > 0) |
| 694 |
OUTCHAR(' '); |
| 695 |
OUTCHAR((char) num); |
| 696 |
if(p->flags & FLAGS_LEFT) |
| 697 |
while(--width > 0) |
| 698 |
OUTCHAR(' '); |
| 699 |
break; |
| 700 |
} |
| 701 |
if(p->flags & FLAGS_OCTAL) { |
| 702 |
/* Octal unsigned integer. */ |
| 703 |
base = 8; |
| 704 |
goto unsigned_number; |
| 705 |
} |
| 706 |
else if(p->flags & FLAGS_HEX) { |
| 707 |
/* Hexadecimal unsigned integer. */ |
| 708 |
|
| 709 |
digits = (p->flags & FLAGS_UPPER)? upper_digits : lower_digits; |
| 710 |
base = 16; |
| 711 |
goto unsigned_number; |
| 712 |
} |
| 713 |
else if(p->flags & FLAGS_UNSIGNED) { |
| 714 |
/* Decimal unsigned integer. */ |
| 715 |
base = 10; |
| 716 |
goto unsigned_number; |
| 717 |
} |
| 718 |
|
| 719 |
/* Decimal integer. */ |
| 720 |
base = 10; |
| 721 |
|
| 722 |
is_neg = (p->data.num.as_signed < (mp_intmax_t)0) ? 1 : 0; |
| 723 |
if(is_neg) { |
| 724 |
/* signed_num might fail to hold absolute negative minimum by 1 */ |
| 725 |
signed_num = p->data.num.as_signed + (mp_intmax_t)1; |
| 726 |
signed_num = -signed_num; |
| 727 |
num = (mp_uintmax_t)signed_num; |
| 728 |
num += (mp_uintmax_t)1; |
| 729 |
} |
| 730 |
|
| 731 |
goto number; |
| 732 |
|
| 733 |
unsigned_number: |
| 734 |
/* Unsigned number of base BASE. */ |
| 735 |
is_neg = 0; |
| 736 |
|
| 737 |
number: |
| 738 |
/* Number of base BASE. */ |
| 739 |
|
| 740 |
/* Supply a default precision if none was given. */ |
| 741 |
if(prec == -1) |
| 742 |
prec = 1; |
| 743 |
|
| 744 |
/* Put the number in WORK. */ |
| 745 |
w = workend; |
| 746 |
while(num > 0) { |
| 747 |
*w-- = digits[num % base]; |
| 748 |
num /= base; |
| 749 |
} |
| 750 |
width -= (long)(workend - w); |
| 751 |
prec -= (long)(workend - w); |
| 752 |
|
| 753 |
if(is_alt && base == 8 && prec <= 0) { |
| 754 |
*w-- = '0'; |
| 755 |
--width; |
| 756 |
} |
| 757 |
|
| 758 |
if(prec > 0) { |
| 759 |
width -= prec; |
| 760 |
while(prec-- > 0) |
| 761 |
*w-- = '0'; |
| 762 |
} |
| 763 |
|
| 764 |
if(is_alt && base == 16) |
| 765 |
width -= 2; |
| 766 |
|
| 767 |
if(is_neg || (p->flags & FLAGS_SHOWSIGN) || (p->flags & FLAGS_SPACE)) |
| 768 |
--width; |
| 769 |
|
| 770 |
if(!(p->flags & FLAGS_LEFT) && !(p->flags & FLAGS_PAD_NIL)) |
| 771 |
while(width-- > 0) |
| 772 |
OUTCHAR(' '); |
| 773 |
|
| 774 |
if(is_neg) |
| 775 |
OUTCHAR('-'); |
| 776 |
else if(p->flags & FLAGS_SHOWSIGN) |
| 777 |
OUTCHAR('+'); |
| 778 |
else if(p->flags & FLAGS_SPACE) |
| 779 |
OUTCHAR(' '); |
| 780 |
|
| 781 |
if(is_alt && base == 16) { |
| 782 |
OUTCHAR('0'); |
| 783 |
if(p->flags & FLAGS_UPPER) |
| 784 |
OUTCHAR('X'); |
| 785 |
else |
| 786 |
OUTCHAR('x'); |
| 787 |
} |
| 788 |
|
| 789 |
if(!(p->flags & FLAGS_LEFT) && (p->flags & FLAGS_PAD_NIL)) |
| 790 |
while(width-- > 0) |
| 791 |
OUTCHAR('0'); |
| 792 |
|
| 793 |
/* Write the number. */ |
| 794 |
while(++w <= workend) { |
| 795 |
OUTCHAR(*w); |
| 796 |
} |
| 797 |
|
| 798 |
if(p->flags & FLAGS_LEFT) |
| 799 |
while(width-- > 0) |
| 800 |
OUTCHAR(' '); |
| 801 |
break; |
| 802 |
|
| 803 |
case FORMAT_STRING: |
| 804 |
/* String. */ |
| 805 |
{ |
| 806 |
static const char null[] = "(nil)"; |
| 807 |
const char *str; |
| 808 |
size_t len; |
| 809 |
|
| 810 |
str = (char *) p->data.str; |
| 811 |
if(str == NULL) { |
| 812 |
/* Write null[] if there's space. */ |
| 813 |
if(prec == -1 || prec >= (long) sizeof(null) - 1) { |
| 814 |
str = null; |
| 815 |
len = sizeof(null) - 1; |
| 816 |
/* Disable quotes around (nil) */ |
| 817 |
p->flags &= (~FLAGS_ALT); |
| 818 |
} |
| 819 |
else { |
| 820 |
str = ""; |
| 821 |
len = 0; |
| 822 |
} |
| 823 |
} |
| 824 |
else if(prec != -1) |
| 825 |
len = (size_t)prec; |
| 826 |
else |
| 827 |
len = strlen(str); |
| 828 |
|
| 829 |
width -= (len > LONG_MAX) ? LONG_MAX : (long)len; |
| 830 |
|
| 831 |
if(p->flags & FLAGS_ALT) |
| 832 |
OUTCHAR('"'); |
| 833 |
|
| 834 |
if(!(p->flags&FLAGS_LEFT)) |
| 835 |
while(width-- > 0) |
| 836 |
OUTCHAR(' '); |
| 837 |
|
| 838 |
for(; len && *str; len--) |
| 839 |
OUTCHAR(*str++); |
| 840 |
if(p->flags&FLAGS_LEFT) |
| 841 |
while(width-- > 0) |
| 842 |
OUTCHAR(' '); |
| 843 |
|
| 844 |
if(p->flags & FLAGS_ALT) |
| 845 |
OUTCHAR('"'); |
| 846 |
} |
| 847 |
break; |
| 848 |
|
| 849 |
case FORMAT_PTR: |
| 850 |
/* Generic pointer. */ |
| 851 |
{ |
| 852 |
void *ptr; |
| 853 |
ptr = (void *) p->data.ptr; |
| 854 |
if(ptr != NULL) { |
| 855 |
/* If the pointer is not NULL, write it as a %#x spec. */ |
| 856 |
base = 16; |
| 857 |
digits = (p->flags & FLAGS_UPPER)? upper_digits : lower_digits; |
| 858 |
is_alt = 1; |
| 859 |
num = (size_t) ptr; |
| 860 |
is_neg = 0; |
| 861 |
goto number; |
| 862 |
} |
| 863 |
else { |
| 864 |
/* Write "(nil)" for a nil pointer. */ |
| 865 |
static const char strnil[] = "(nil)"; |
| 866 |
const char *point; |
| 867 |
|
| 868 |
width -= (long)(sizeof(strnil) - 1); |
| 869 |
if(p->flags & FLAGS_LEFT) |
| 870 |
while(width-- > 0) |
| 871 |
OUTCHAR(' '); |
| 872 |
for(point = strnil; *point != '\0'; ++point) |
| 873 |
OUTCHAR(*point); |
| 874 |
if(! (p->flags & FLAGS_LEFT)) |
| 875 |
while(width-- > 0) |
| 876 |
OUTCHAR(' '); |
| 877 |
} |
| 878 |
} |
| 879 |
break; |
| 880 |
|
| 881 |
case FORMAT_DOUBLE: |
| 882 |
{ |
| 883 |
char formatbuf[32]="%"; |
| 884 |
char *fptr = &formatbuf[1]; |
| 885 |
size_t left = sizeof(formatbuf)-strlen(formatbuf); |
| 886 |
int len; |
| 887 |
|
| 888 |
width = -1; |
| 889 |
if(p->flags & FLAGS_WIDTH) |
| 890 |
width = p->width; |
| 891 |
else if(p->flags & FLAGS_WIDTHPARAM) |
| 892 |
width = (long)vto[p->width].data.num.as_signed; |
| 893 |
|
| 894 |
prec = -1; |
| 895 |
if(p->flags & FLAGS_PREC) |
| 896 |
prec = p->precision; |
| 897 |
else if(p->flags & FLAGS_PRECPARAM) |
| 898 |
prec = (long)vto[p->precision].data.num.as_signed; |
| 899 |
|
| 900 |
if(p->flags & FLAGS_LEFT) |
| 901 |
*fptr++ = '-'; |
| 902 |
if(p->flags & FLAGS_SHOWSIGN) |
| 903 |
*fptr++ = '+'; |
| 904 |
if(p->flags & FLAGS_SPACE) |
| 905 |
*fptr++ = ' '; |
| 906 |
if(p->flags & FLAGS_ALT) |
| 907 |
*fptr++ = '#'; |
| 908 |
|
| 909 |
*fptr = 0; |
| 910 |
|
| 911 |
if(width >= 0) { |
| 912 |
if(width >= (long)sizeof(work)) |
| 913 |
width = sizeof(work)-1; |
| 914 |
/* RECURSIVE USAGE */ |
| 915 |
len = curl_msnprintf(fptr, left, "%ld", width); |
| 916 |
fptr += len; |
| 917 |
left -= len; |
| 918 |
} |
| 919 |
if(prec >= 0) { |
| 920 |
/* for each digit in the integer part, we can have one less |
| 921 |
precision */ |
| 922 |
size_t maxprec = sizeof(work) - 2; |
| 923 |
double val = p->data.dnum; |
| 924 |
while(val >= 10.0) { |
| 925 |
val /= 10; |
| 926 |
maxprec--; |
| 927 |
} |
| 928 |
|
| 929 |
if(prec > (long)maxprec) |
| 930 |
prec = (long)maxprec-1; |
| 931 |
/* RECURSIVE USAGE */ |
| 932 |
len = curl_msnprintf(fptr, left, ".%ld", prec); |
| 933 |
fptr += len; |
| 934 |
} |
| 935 |
if(p->flags & FLAGS_LONG) |
| 936 |
*fptr++ = 'l'; |
| 937 |
|
| 938 |
if(p->flags & FLAGS_FLOATE) |
| 939 |
*fptr++ = (char)((p->flags & FLAGS_UPPER) ? 'E':'e'); |
| 940 |
else if(p->flags & FLAGS_FLOATG) |
| 941 |
*fptr++ = (char)((p->flags & FLAGS_UPPER) ? 'G' : 'g'); |
| 942 |
else |
| 943 |
*fptr++ = 'f'; |
| 944 |
|
| 945 |
*fptr = 0; /* and a final zero termination */ |
| 946 |
|
| 947 |
/* NOTE NOTE NOTE!! Not all sprintf implementations return number of |
| 948 |
output characters */ |
| 949 |
(sprintf)(work, formatbuf, p->data.dnum); |
| 950 |
DEBUGASSERT(strlen(work) <= sizeof(work)); |
| 951 |
for(fptr = work; *fptr; fptr++) |
| 952 |
OUTCHAR(*fptr); |
| 953 |
} |
| 954 |
break; |
| 955 |
|
| 956 |
case FORMAT_INTPTR: |
| 957 |
/* Answer the count of characters written. */ |
| 958 |
#ifdef HAVE_LONG_LONG_TYPE |
| 959 |
if(p->flags & FLAGS_LONGLONG) |
| 960 |
*(LONG_LONG_TYPE *) p->data.ptr = (LONG_LONG_TYPE)done; |
| 961 |
else |
| 962 |
#endif |
| 963 |
if(p->flags & FLAGS_LONG) |
| 964 |
*(long *) p->data.ptr = (long)done; |
| 965 |
else if(!(p->flags & FLAGS_SHORT)) |
| 966 |
*(int *) p->data.ptr = (int)done; |
| 967 |
else |
| 968 |
*(short *) p->data.ptr = (short)done; |
| 969 |
break; |
| 970 |
|
| 971 |
default: |
| 972 |
break; |
| 973 |
} |
| 974 |
f = *end++; /* goto end of %-code */ |
| 975 |
|
| 976 |
} |
| 977 |
return done; |
| 978 |
} |
| 979 |
|
| 980 |
/* fputc() look-alike */ |
| 981 |
static int addbyter(int output, FILE *data) |
| 982 |
{ |
| 983 |
struct nsprintf *infop = (struct nsprintf *)data; |
| 984 |
unsigned char outc = (unsigned char)output; |
| 985 |
|
| 986 |
if(infop->length < infop->max) { |
| 987 |
/* only do this if we haven't reached max length yet */ |
| 988 |
infop->buffer[0] = outc; /* store */ |
| 989 |
infop->buffer++; /* increase pointer */ |
| 990 |
infop->length++; /* we are now one byte larger */ |
| 991 |
return outc; /* fputc() returns like this on success */ |
| 992 |
} |
| 993 |
return -1; |
| 994 |
} |
| 995 |
|
| 996 |
int curl_mvsnprintf(char *buffer, size_t maxlength, const char *format, |
| 997 |
va_list ap_save) |
| 998 |
{ |
| 999 |
int retcode; |
| 1000 |
struct nsprintf info; |
| 1001 |
|
| 1002 |
info.buffer = buffer; |
| 1003 |
info.length = 0; |
| 1004 |
info.max = maxlength; |
| 1005 |
|
| 1006 |
retcode = dprintf_formatf(&info, addbyter, format, ap_save); |
| 1007 |
if((retcode != -1) && info.max) { |
| 1008 |
/* we terminate this with a zero byte */ |
| 1009 |
if(info.max == info.length) |
| 1010 |
/* we're at maximum, scrap the last letter */ |
| 1011 |
info.buffer[-1] = 0; |
| 1012 |
else |
| 1013 |
info.buffer[0] = 0; |
| 1014 |
} |
| 1015 |
return retcode; |
| 1016 |
} |
| 1017 |
|
| 1018 |
int curl_msnprintf(char *buffer, size_t maxlength, const char *format, ...) |
| 1019 |
{ |
| 1020 |
int retcode; |
| 1021 |
va_list ap_save; /* argument pointer */ |
| 1022 |
va_start(ap_save, format); |
| 1023 |
retcode = curl_mvsnprintf(buffer, maxlength, format, ap_save); |
| 1024 |
va_end(ap_save); |
| 1025 |
return retcode; |
| 1026 |
} |
| 1027 |
|
| 1028 |
/* fputc() look-alike */ |
| 1029 |
static int alloc_addbyter(int output, FILE *data) |
| 1030 |
{ |
| 1031 |
struct asprintf *infop = (struct asprintf *)data; |
| 1032 |
unsigned char outc = (unsigned char)output; |
| 1033 |
|
| 1034 |
if(!infop->buffer) { |
| 1035 |
infop->buffer = malloc(32); |
| 1036 |
if(!infop->buffer) { |
| 1037 |
infop->fail = 1; |
| 1038 |
return -1; /* fail */ |
| 1039 |
} |
| 1040 |
infop->alloc = 32; |
| 1041 |
infop->len = 0; |
| 1042 |
} |
| 1043 |
else if(infop->len + 1 >= infop->alloc) { |
| 1044 |
char *newptr = NULL; |
| 1045 |
size_t newsize = infop->alloc*2; |
| 1046 |
|
| 1047 |
/* detect wrap-around or other overflow problems */ |
| 1048 |
if(newsize > infop->alloc) |
| 1049 |
newptr = realloc(infop->buffer, newsize); |
| 1050 |
|
| 1051 |
if(!newptr) { |
| 1052 |
infop->fail = 1; |
| 1053 |
return -1; /* fail */ |
| 1054 |
} |
| 1055 |
infop->buffer = newptr; |
| 1056 |
infop->alloc = newsize; |
| 1057 |
} |
| 1058 |
|
| 1059 |
infop->buffer[ infop->len ] = outc; |
| 1060 |
|
| 1061 |
infop->len++; |
| 1062 |
|
| 1063 |
return outc; /* fputc() returns like this on success */ |
| 1064 |
} |
| 1065 |
|
| 1066 |
char *curl_maprintf(const char *format, ...) |
| 1067 |
{ |
| 1068 |
va_list ap_save; /* argument pointer */ |
| 1069 |
int retcode; |
| 1070 |
struct asprintf info; |
| 1071 |
|
| 1072 |
info.buffer = NULL; |
| 1073 |
info.len = 0; |
| 1074 |
info.alloc = 0; |
| 1075 |
info.fail = 0; |
| 1076 |
|
| 1077 |
va_start(ap_save, format); |
| 1078 |
retcode = dprintf_formatf(&info, alloc_addbyter, format, ap_save); |
| 1079 |
va_end(ap_save); |
| 1080 |
if((-1 == retcode) || info.fail) { |
| 1081 |
if(info.alloc) |
| 1082 |
free(info.buffer); |
| 1083 |
return NULL; |
| 1084 |
} |
| 1085 |
if(info.alloc) { |
| 1086 |
info.buffer[info.len] = 0; /* we terminate this with a zero byte */ |
| 1087 |
return info.buffer; |
| 1088 |
} |
| 1089 |
return strdup(""); |
| 1090 |
} |
| 1091 |
|
| 1092 |
char *curl_mvaprintf(const char *format, va_list ap_save) |
| 1093 |
{ |
| 1094 |
int retcode; |
| 1095 |
struct asprintf info; |
| 1096 |
|
| 1097 |
info.buffer = NULL; |
| 1098 |
info.len = 0; |
| 1099 |
info.alloc = 0; |
| 1100 |
info.fail = 0; |
| 1101 |
|
| 1102 |
retcode = dprintf_formatf(&info, alloc_addbyter, format, ap_save); |
| 1103 |
if((-1 == retcode) || info.fail) { |
| 1104 |
if(info.alloc) |
| 1105 |
free(info.buffer); |
| 1106 |
return NULL; |
| 1107 |
} |
| 1108 |
|
| 1109 |
if(info.alloc) { |
| 1110 |
info.buffer[info.len] = 0; /* we terminate this with a zero byte */ |
| 1111 |
return info.buffer; |
| 1112 |
} |
| 1113 |
return strdup(""); |
| 1114 |
} |
| 1115 |
|
| 1116 |
static int storebuffer(int output, FILE *data) |
| 1117 |
{ |
| 1118 |
char **buffer = (char **)data; |
| 1119 |
unsigned char outc = (unsigned char)output; |
| 1120 |
**buffer = outc; |
| 1121 |
(*buffer)++; |
| 1122 |
return outc; /* act like fputc() ! */ |
| 1123 |
} |
| 1124 |
|
| 1125 |
int curl_msprintf(char *buffer, const char *format, ...) |
| 1126 |
{ |
| 1127 |
va_list ap_save; /* argument pointer */ |
| 1128 |
int retcode; |
| 1129 |
va_start(ap_save, format); |
| 1130 |
retcode = dprintf_formatf(&buffer, storebuffer, format, ap_save); |
| 1131 |
va_end(ap_save); |
| 1132 |
*buffer = 0; /* we terminate this with a zero byte */ |
| 1133 |
return retcode; |
| 1134 |
} |
| 1135 |
|
| 1136 |
int curl_mprintf(const char *format, ...) |
| 1137 |
{ |
| 1138 |
int retcode; |
| 1139 |
va_list ap_save; /* argument pointer */ |
| 1140 |
va_start(ap_save, format); |
| 1141 |
|
| 1142 |
retcode = dprintf_formatf(stdout, fputc, format, ap_save); |
| 1143 |
va_end(ap_save); |
| 1144 |
return retcode; |
| 1145 |
} |
| 1146 |
|
| 1147 |
int curl_mfprintf(FILE *whereto, const char *format, ...) |
| 1148 |
{ |
| 1149 |
int retcode; |
| 1150 |
va_list ap_save; /* argument pointer */ |
| 1151 |
va_start(ap_save, format); |
| 1152 |
retcode = dprintf_formatf(whereto, fputc, format, ap_save); |
| 1153 |
va_end(ap_save); |
| 1154 |
return retcode; |
| 1155 |
} |
| 1156 |
|
| 1157 |
int curl_mvsprintf(char *buffer, const char *format, va_list ap_save) |
| 1158 |
{ |
| 1159 |
int retcode; |
| 1160 |
retcode = dprintf_formatf(&buffer, storebuffer, format, ap_save); |
| 1161 |
*buffer = 0; /* we terminate this with a zero byte */ |
| 1162 |
return retcode; |
| 1163 |
} |
| 1164 |
|
| 1165 |
int curl_mvprintf(const char *format, va_list ap_save) |
| 1166 |
{ |
| 1167 |
return dprintf_formatf(stdout, fputc, format, ap_save); |
| 1168 |
} |
| 1169 |
|
| 1170 |
int curl_mvfprintf(FILE *whereto, const char *format, va_list ap_save) |
| 1171 |
{ |
| 1172 |
return dprintf_formatf(whereto, fputc, format, ap_save); |
| 1173 |
} |