mprintf.c

Last change on this file was 108048, checked in by vboxsync, 3 months ago
curl-8.11.1: Applied and adjusted our curl changes to 8.7.1. jiraref:VBP-1535
Property svn:eol-style set to `native`
File size: 31.4 KB

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

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

source: vbox/trunk/src/libs/curl-8.11.1/lib/mprintf.c

Download in other formats: