mprintf.c@ 86643

Last change on this file since 86643 was 85671, checked in by vboxsync, 4 years ago
Export out internal curl copy to make it a lot simpler to build VBox (OSE) on Windows. bugref:9814
Property svn:eol-style set to `native`
File size: 29.7 KB

Line
1	/***************************************************************************
2	* _ _ ____ _
3	* Project ___\| \| \| \| _ \\| \|
4	* / __\| \| \| \| \|_) \| \|
5	* \| (__\| \|_\| \| _ <\| \|___
6	* \___\|\___/\|_\| \_\_____\|
7	*
8	* Copyright (C) 1999 - 2017, 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_FALSE
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	}

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/libs/curl-7.64.0/lib/mprintf.c@ 86643

Download in other formats: