Subversion Repositories HelenOS

Rev

Rev 2745 | Rev 4055 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
1271 cejka 1
/*
2071 jermar 2
 * Copyright (c) 2001-2004 Jakub Jermar
3
 * Copyright (c) 2006 Josef Cejka
1271 cejka 4
 * All rights reserved.
5
 *
6
 * Redistribution and use in source and binary forms, with or without
7
 * modification, are permitted provided that the following conditions
8
 * are met:
9
 *
10
 * - Redistributions of source code must retain the above copyright
11
 *   notice, this list of conditions and the following disclaimer.
12
 * - Redistributions in binary form must reproduce the above copyright
13
 *   notice, this list of conditions and the following disclaimer in the
14
 *   documentation and/or other materials provided with the distribution.
15
 * - The name of the author may not be used to endorse or promote products
16
 *   derived from this software without specific prior written permission.
17
 *
18
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28
 */
29
 
1888 jermar 30
/** @addtogroup generic	
1702 cejka 31
 * @{
32
 */
1271 cejka 33
/**
1702 cejka 34
 * @file
1271 cejka 35
 * @brief	Printing functions.
36
 */
37
 
38
#include <printf/printf_core.h>
39
#include <putchar.h>
40
#include <print.h>
41
#include <arch/arg.h>
2572 jermar 42
#include <macros.h>
43
#include <func.h>
1271 cejka 44
#include <arch.h>
45
 
2572 jermar 46
/** show prefixes 0x or 0 */
47
#define __PRINTF_FLAG_PREFIX		0x00000001
48
/** signed / unsigned number */
49
#define __PRINTF_FLAG_SIGNED		0x00000002
50
/** print leading zeroes */
51
#define __PRINTF_FLAG_ZEROPADDED	0x00000004
52
/** align to left */
53
#define __PRINTF_FLAG_LEFTALIGNED	0x00000010
54
/** always show + sign */
55
#define __PRINTF_FLAG_SHOWPLUS		0x00000020
56
/** print space instead of plus */
57
#define __PRINTF_FLAG_SPACESIGN		0x00000040
58
/** show big characters */
59
#define __PRINTF_FLAG_BIGCHARS		0x00000080
60
/** number has - sign */
61
#define __PRINTF_FLAG_NEGATIVE		0x00000100
1271 cejka 62
 
2572 jermar 63
/**
64
 * Buffer big enough for 64-bit number printed in base 2, sign, prefix and 0
65
 * to terminate string... (last one is only for better testing end of buffer by
66
 * zero-filling subroutine)
67
 */
68
#define PRINT_NUMBER_BUFFER_SIZE	(64 + 5)	
1271 cejka 69
 
70
/** Enumeration of possible arguments types.
71
 */
72
typedef enum {
73
	PrintfQualifierByte = 0,
74
	PrintfQualifierShort,
75
	PrintfQualifierInt,
76
	PrintfQualifierLong,
77
	PrintfQualifierLongLong,
78
	PrintfQualifierNative,
79
	PrintfQualifierPointer
80
} qualifier_t;
81
 
2572 jermar 82
static char digits_small[] = "0123456789abcdef";
83
static char digits_big[] = "0123456789ABCDEF";
1271 cejka 84
 
2572 jermar 85
/** Print one or more characters without adding newline.
86
 *
87
 * @param buf		Buffer with size at least count bytes. NULL pointer is
88
 *			not allowed!
89
 * @param count		Number of characters to print.
90
 * @param ps		Output method and its data.
91
 * @return		Number of characters printed.
1271 cejka 92
 */
2572 jermar 93
static int printf_putnchars(const char * buf, size_t count,
94
    struct printf_spec *ps)
1271 cejka 95
{
2745 decky 96
	return ps->write((void *) buf, count, ps->data);
1271 cejka 97
}
98
 
2572 jermar 99
/** Print a string without adding a newline.
100
 *
101
 * @param str		String to print.
102
 * @param ps		Write function specification and support data.
103
 * @return		Number of characters printed.
1271 cejka 104
 */
105
static int printf_putstr(const char * str, struct printf_spec *ps)
106
{
107
	size_t count;
108
 
109
	if (str == NULL) {
2572 jermar 110
		char *nullstr = "(NULL)";
111
		return printf_putnchars(nullstr, strlen(nullstr), ps);
1271 cejka 112
	}
113
 
114
	count = strlen(str);
115
 
1604 cejka 116
	return ps->write((void *) str, count, ps->data);
1271 cejka 117
}
118
 
2572 jermar 119
/** Print one character.
120
 *
121
 * @param c		Character to be printed.
122
 * @param ps		Output method.
123
 *
124
 * @return		Number of characters printed.
1271 cejka 125
 */
126
static int printf_putchar(int c, struct printf_spec *ps)
127
{
128
	unsigned char ch = c;
129
 
1604 cejka 130
	return ps->write((void *) &ch, 1, ps->data);
1271 cejka 131
}
132
 
2572 jermar 133
/** Print one formatted character.
134
 *
135
 * @param c		Character to print.
136
 * @param width		Width modifier.
137
 * @param flags		Flags that change the way the character is printed.
138
 *
139
 * @return		Number of characters printed, negative value on failure.
1271 cejka 140
 */
1780 jermar 141
static int print_char(char c, int width, uint64_t flags, struct printf_spec *ps)
1271 cejka 142
{
143
	int counter = 0;
144
 
145
	if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
2572 jermar 146
		while (--width > 0) {
147
			/*
148
			 * One space is consumed by the character itself, hence
149
			 * the predecrement.
150
			 */
1604 cejka 151
			if (printf_putchar(' ', ps) > 0)	
152
				++counter;
1271 cejka 153
		}
154
	}
155
 
1604 cejka 156
 	if (printf_putchar(c, ps) > 0)
157
		counter++;
1271 cejka 158
 
2572 jermar 159
	while (--width > 0) {
160
			/*
161
			 * One space is consumed by the character itself, hence
162
			 * the predecrement.
163
			 */
1604 cejka 164
		if (printf_putchar(' ', ps) > 0)
165
			++counter;
1271 cejka 166
	}
167
 
168
	return ++counter;
169
}
170
 
2572 jermar 171
/** Print string.
172
 *
173
 * @param s		String to be printed.
174
 * @param width		Width modifier.
175
 * @param precision	Precision modifier.
176
 * @param flags		Flags that modify the way the string is printed.
177
 *
178
 * @return		Number of characters printed, negative value on	failure.
179
 */ 
2745 decky 180
static int print_string(char *s, int width, unsigned int precision,
181
	uint64_t flags, struct printf_spec *ps)
1271 cejka 182
{
183
	int counter = 0;
184
	size_t size;
1604 cejka 185
	int retval;
1271 cejka 186
 
187
	if (s == NULL) {
188
		return printf_putstr("(NULL)", ps);
189
	}
190
 
191
	size = strlen(s);
192
 
193
	/* print leading spaces */
194
 
195
	if (precision == 0) 
196
		precision = size;
197
 
198
	width -= precision;
199
 
200
	if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
201
		while (width-- > 0) { 	
1604 cejka 202
			if (printf_putchar(' ', ps) == 1)	
203
				counter++;
1271 cejka 204
		}
205
	}
206
 
2572 jermar 207
 	if ((retval = printf_putnchars(s, min(size, precision), ps)) < 0) {
1604 cejka 208
		return -counter;
1271 cejka 209
	}
1604 cejka 210
	counter += retval;	
1271 cejka 211
 
212
	while (width-- > 0) {
1604 cejka 213
		if (printf_putchar(' ', ps) == 1)	
214
			++counter;
1271 cejka 215
	}
216
 
1604 cejka 217
	return counter;
1271 cejka 218
}
219
 
220
 
2572 jermar 221
/** Print a number in a given base.
1271 cejka 222
 *
2572 jermar 223
 * Print significant digits of a number in given base.
1271 cejka 224
 *
2572 jermar 225
 * @param num		Number to print.
226
 * @param widt		Width modifier.h
227
 * @param precision	Precision modifier.
228
 * @param base		Base to print the number in (must be between 2 and 16).
229
 * @param flags		Flags that modify the way the number is printed.	
1271 cejka 230
 *
2572 jermar 231
 * @return		Number of characters printed.
232
 *
1271 cejka 233
 */
2572 jermar 234
static int print_number(uint64_t num, int width, int precision, int base,
235
    uint64_t flags, struct printf_spec *ps)
1271 cejka 236
{
237
	char *digits = digits_small;
2572 jermar 238
	char d[PRINT_NUMBER_BUFFER_SIZE];
1271 cejka 239
	char *ptr = &d[PRINT_NUMBER_BUFFER_SIZE - 1];
2572 jermar 240
	int size = 0;		/* size of number with all prefixes and signs */
241
	int number_size; 	/* size of plain number */
1271 cejka 242
	char sgn;
1604 cejka 243
	int retval;
244
	int counter = 0;
1271 cejka 245
 
246
	if (flags & __PRINTF_FLAG_BIGCHARS) 
247
		digits = digits_big;	
248
 
249
	*ptr-- = 0; /* Put zero at end of string */
250
 
251
	if (num == 0) {
252
		*ptr-- = '0';
253
		size++;
254
	} else {
255
		do {
256
			*ptr-- = digits[num % base];
257
			size++;
258
		} while (num /= base);
259
	}
260
 
261
	number_size = size;
262
 
2572 jermar 263
	/*
264
	 * Collect the sum of all prefixes/signs/... to calculate padding and
265
	 * leading zeroes.
266
	 */
1271 cejka 267
	if (flags & __PRINTF_FLAG_PREFIX) {
268
		switch(base) {
2070 jermar 269
		case 2:	/* Binary formating is not standard, but usefull */
270
			size += 2;
271
			break;
272
		case 8:
273
			size++;
274
			break;
275
		case 16:
276
			size += 2;
277
			break;
1271 cejka 278
		}
279
	}
280
 
281
	sgn = 0;
282
	if (flags & __PRINTF_FLAG_SIGNED) {
283
		if (flags & __PRINTF_FLAG_NEGATIVE) {
284
			sgn = '-';
285
			size++;
286
		} else if (flags & __PRINTF_FLAG_SHOWPLUS) {
2572 jermar 287
			sgn = '+';
288
			size++;
289
		} else if (flags & __PRINTF_FLAG_SPACESIGN) {
290
			sgn = ' ';
291
			size++;
292
		}
1271 cejka 293
	}
294
 
295
	if (flags & __PRINTF_FLAG_LEFTALIGNED) {
296
		flags &= ~__PRINTF_FLAG_ZEROPADDED;
297
	}
298
 
2572 jermar 299
	/*
300
	 * If the number is leftaligned or precision is specified then
301
	 * zeropadding is ignored.
302
	 */
1271 cejka 303
	if (flags & __PRINTF_FLAG_ZEROPADDED) {
304
		if ((precision == 0) && (width > size)) {
305
			precision = width - size + number_size;
306
		}
307
	}
308
 
309
	/* print leading spaces */
2572 jermar 310
	if (number_size > precision) {
311
		/* print the whole number not only a part */
1271 cejka 312
		precision = number_size;
2572 jermar 313
	}
1271 cejka 314
 
315
	width -= precision + size - number_size;
316
 
317
	if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
318
		while (width-- > 0) { 	
1604 cejka 319
			if (printf_putchar(' ', ps) == 1)	
320
				counter++;
1271 cejka 321
		}
322
	}
323
 
1604 cejka 324
 
1271 cejka 325
	/* print sign */
326
	if (sgn) {
1604 cejka 327
		if (printf_putchar(sgn, ps) == 1)
328
			counter++;
1271 cejka 329
	}
330
 
331
	/* print prefix */
332
 
333
	if (flags & __PRINTF_FLAG_PREFIX) {
334
		switch(base) {
2070 jermar 335
		case 2:	/* Binary formating is not standard, but usefull */
336
			if (printf_putchar('0', ps) == 1)
337
				counter++;
338
			if (flags & __PRINTF_FLAG_BIGCHARS) {
339
				if (printf_putchar('B', ps) == 1)
1604 cejka 340
					counter++;
2070 jermar 341
			} else {
342
				if (printf_putchar('b', ps) == 1)
1604 cejka 343
					counter++;
2070 jermar 344
			}
345
			break;
346
		case 8:
347
			if (printf_putchar('o', ps) == 1)
348
				counter++;
349
			break;
350
		case 16:
351
			if (printf_putchar('0', ps) == 1)
352
				counter++;
353
			if (flags & __PRINTF_FLAG_BIGCHARS) {
354
				if (printf_putchar('X', ps) == 1)
1604 cejka 355
					counter++;
2070 jermar 356
			} else {
357
				if (printf_putchar('x', ps) == 1)
358
					counter++;
359
			}
360
			break;
1271 cejka 361
		}
362
	}
363
 
364
	/* print leading zeroes */
365
	precision -= number_size;
366
	while (precision-- > 0) { 	
1604 cejka 367
		if (printf_putchar('0', ps) == 1)
368
			counter++;
1271 cejka 369
	}
370
 
371
 
372
	/* print number itself */
373
 
1604 cejka 374
	if ((retval = printf_putstr(++ptr, ps)) > 0) {
375
		counter += retval;
376
	}
1271 cejka 377
 
378
	/* print ending spaces */
379
 
380
	while (width-- > 0) { 	
1604 cejka 381
		if (printf_putchar(' ', ps) == 1)	
382
			counter++;
1271 cejka 383
	}
384
 
1604 cejka 385
	return counter;
1271 cejka 386
}
387
 
388
 
389
/** Print formatted string.
390
 *
2572 jermar 391
 * Print string formatted according to the fmt parameter and variadic arguments.
392
 * Each formatting directive must have the following form:
1271 cejka 393
 * 
394
 * 	\% [ FLAGS ] [ WIDTH ] [ .PRECISION ] [ TYPE ] CONVERSION
395
 *
396
 * FLAGS:@n
2572 jermar 397
 * 	- "#"	Force to print prefix.For \%o conversion, the prefix is 0, for
398
 *		\%x and \%X prefixes are 0x and	0X and for conversion \%b the
399
 *		prefix is 0b.
1271 cejka 400
 *
401
 * 	- "-"	Align to left.
402
 *
403
 * 	- "+"	Print positive sign just as negative.
404
 *
2572 jermar 405
 * 	- " "	If the printed number is positive and "+" flag is not set,
406
 *		print space in place of sign.
1271 cejka 407
 *
2572 jermar 408
 * 	- "0"	Print 0 as padding instead of spaces. Zeroes are placed between
409
 *		sign and the rest of the number. This flag is ignored if "-"
410
 *		flag is specified.
1271 cejka 411
 * 
412
 * WIDTH:@n
2572 jermar 413
 * 	- Specify the minimal width of a printed argument. If it is bigger,
414
 *	width is ignored. If width is specified with a "*" character instead of
415
 *	number, width is taken from parameter list. And integer parameter is
416
 *	expected before parameter for processed conversion specification. If
417
 *	this value is negative its absolute value is taken and the "-" flag is
418
 *	set.
1271 cejka 419
 *
420
 * PRECISION:@n
421
 * 	- Value precision. For numbers it specifies minimum valid numbers.
2572 jermar 422
 *	Smaller numbers are printed with leading zeroes. Bigger numbers are not
423
 *	affected. Strings with more than precision characters are cut off. Just
424
 *	as with width, an "*" can be used used instead of a number. An integer
425
 *	value is then expected in parameters. When both width and precision are
426
 *	specified using "*", the first parameter is used for width and the
427
 *	second one for precision.
1271 cejka 428
 * 
429
 * TYPE:@n
430
 * 	- "hh"	Signed or unsigned char.@n
2441 decky 431
 * 	- "h"	Signed or unsigned short.@n
432
 * 	- ""	Signed or unsigned int (default value).@n
433
 * 	- "l"	Signed or unsigned long int.@n
434
 * 	- "ll"	Signed or unsigned long long int.@n
1780 jermar 435
 * 	- "z"	unative_t (non-standard extension).@n
1271 cejka 436
 * 
437
 * 
438
 * CONVERSION:@n
439
 * 	- %	Print percentile character itself.
440
 *
441
 * 	- c	Print single character.
442
 *
2572 jermar 443
 * 	- s	Print zero terminated string. If a NULL value is passed as
444
 *		value, "(NULL)" is printed instead.
1271 cejka 445
 * 
2572 jermar 446
 * 	- P, p	Print value of a pointer. Void * value is expected and it is
447
 *		printed in hexadecimal notation with prefix (as with \%#X / \%#x
448
 *		for 32-bit or \%#X / \%#x for 64-bit long pointers).
1271 cejka 449
 *
2572 jermar 450
 * 	- b	Print value as unsigned binary number. Prefix is not printed by
451
 *		default. (Nonstandard extension.)
1271 cejka 452
 * 
2572 jermar 453
 * 	- o	Print value as unsigned octal number. Prefix is not printed by
454
 *		default. 
1271 cejka 455
 *
2572 jermar 456
 * 	- d, i	Print signed decimal number. There is no difference between d
457
 *		and i conversion.
1271 cejka 458
 *
459
 * 	- u	Print unsigned decimal number.
460
 *
2712 decky 461
 * 	- X, x	Print hexadecimal number with upper- or lower-case. Prefix is
2572 jermar 462
 *		not printed by default.
1271 cejka 463
 * 
2572 jermar 464
 * All other characters from fmt except the formatting directives are printed in
465
 * verbatim.
1271 cejka 466
 *
2572 jermar 467
 * @param fmt		Formatting NULL terminated string.
468
 * @return		Number of characters printed, negative value on failure.
1271 cejka 469
 */
470
int printf_core(const char *fmt, struct printf_spec *ps, va_list ap)
471
{
2572 jermar 472
	int i = 0; /* index of the currently processed char from fmt */
473
	int j = 0; /* index to the first not printed nonformating character */
1271 cejka 474
	int end;
2572 jermar 475
	int counter; /* counter of printed characters */
476
	int retval; /* used to store return values from called functions */
1271 cejka 477
	char c;
2572 jermar 478
	qualifier_t qualifier; /* type of argument */
479
	int base; /* base in which a numeric parameter will be printed */
480
	uint64_t number; /* argument value */
481
	size_t	size; /* byte size of integer parameter */
1271 cejka 482
	int width, precision;
1780 jermar 483
	uint64_t flags;
1271 cejka 484
 
485
	counter = 0;
2208 decky 486
 
1271 cejka 487
	while ((c = fmt[i])) {
488
		/* control character */
489
		if (c == '%' ) { 
490
			/* print common characters if any processed */	
491
			if (i > j) {
2572 jermar 492
				if ((retval = printf_putnchars(&fmt[j],
493
				    (size_t)(i - j), ps)) < 0) { /* error */
1271 cejka 494
					counter = -counter;
495
					goto out;
496
				}
497
				counter += retval;
498
			}
499
 
500
			j = i;
501
			/* parse modifiers */
502
			flags = 0;
503
			end = 0;
504
 
505
			do {
506
				++i;
507
				switch (c = fmt[i]) {
2572 jermar 508
				case '#':
509
					flags |= __PRINTF_FLAG_PREFIX;
510
					break;
511
				case '-':
512
					flags |= __PRINTF_FLAG_LEFTALIGNED;
513
					break;
514
				case '+':
515
					flags |= __PRINTF_FLAG_SHOWPLUS;
516
					break;
517
				case ' ':
518
					flags |= __PRINTF_FLAG_SPACESIGN;
519
					break;
520
				case '0':
521
					flags |= __PRINTF_FLAG_ZEROPADDED;
522
					break;
523
				default:
524
					end = 1;
1271 cejka 525
				};	
526
 
527
			} while (end == 0);	
528
 
529
			/* width & '*' operator */
530
			width = 0;
531
			if (isdigit(fmt[i])) {
532
				while (isdigit(fmt[i])) {
533
					width *= 10;
534
					width += fmt[i++] - '0';
535
				}
536
			} else if (fmt[i] == '*') {
2572 jermar 537
				/* get width value from argument list */
1271 cejka 538
				i++;
539
				width = (int)va_arg(ap, int);
540
				if (width < 0) {
2572 jermar 541
					/* negative width sets '-' flag */
1271 cejka 542
					width *= -1;
543
					flags |= __PRINTF_FLAG_LEFTALIGNED;
544
				}
545
			}
546
 
547
			/* precision and '*' operator */	
548
			precision = 0;
549
			if (fmt[i] == '.') {
550
				++i;
551
				if (isdigit(fmt[i])) {
552
					while (isdigit(fmt[i])) {
553
						precision *= 10;
554
						precision += fmt[i++] - '0';
555
					}
556
				} else if (fmt[i] == '*') {
2572 jermar 557
					/*
558
					 * Get precision value from the argument
559
					 * list.
560
					 */
1271 cejka 561
					i++;
562
					precision = (int)va_arg(ap, int);
563
					if (precision < 0) {
2572 jermar 564
						/* ignore negative precision */
1271 cejka 565
						precision = 0;
566
					}
567
				}
568
			}
569
 
570
			switch (fmt[i++]) {
2572 jermar 571
			/** @todo unimplemented qualifiers:
1888 jermar 572
			 * t ptrdiff_t - ISO C 99
573
			 */
574
			case 'h':	/* char or short */
575
				qualifier = PrintfQualifierShort;
576
				if (fmt[i] == 'h') {
577
					i++;
578
					qualifier = PrintfQualifierByte;
579
				}
580
				break;
581
			case 'l':	/* long or long long*/
582
				qualifier = PrintfQualifierLong;
583
				if (fmt[i] == 'l') {
584
					i++;
585
					qualifier = PrintfQualifierLongLong;
586
				}
587
				break;
588
			case 'z':	/* unative_t */
589
				qualifier = PrintfQualifierNative;
590
				break;
591
			default:
2572 jermar 592
				/* default type */
593
				qualifier = PrintfQualifierInt; 
1888 jermar 594
				--i;
1271 cejka 595
			}	
596
 
597
			base = 10;
598
 
599
			switch (c = fmt[i]) {
600
 
1888 jermar 601
			/*
602
			* String and character conversions.
603
			*/
604
			case 's':
2572 jermar 605
				if ((retval = print_string(va_arg(ap, char *),
606
				    width, precision, flags, ps)) < 0) {
1888 jermar 607
					counter = -counter;
608
					goto out;
609
				};
610
 
611
				counter += retval;
612
				j = i + 1; 
613
				goto next_char;
614
			case 'c':
615
				c = va_arg(ap, unsigned int);
2572 jermar 616
				retval = print_char(c, width, flags, ps);
617
				if (retval < 0) {
1888 jermar 618
					counter = -counter;
619
					goto out;
620
				};
1271 cejka 621
 
1888 jermar 622
				counter += retval;
623
				j = i + 1;
624
				goto next_char;
1271 cejka 625
 
1888 jermar 626
			/* 
627
			 * Integer values
628
			 */
629
			case 'P': /* pointer */
630
			       	flags |= __PRINTF_FLAG_BIGCHARS;
631
			case 'p':
632
				flags |= __PRINTF_FLAG_PREFIX;
633
				base = 16;
634
				qualifier = PrintfQualifierPointer;
635
				break;	
636
			case 'b': 
637
				base = 2;
638
				break;
639
			case 'o':
640
				base = 8;
641
				break;
642
			case 'd':
643
			case 'i':
644
				flags |= __PRINTF_FLAG_SIGNED;  
645
			case 'u':
646
				break;
647
			case 'X':
648
				flags |= __PRINTF_FLAG_BIGCHARS;
649
			case 'x':
650
				base = 16;
651
				break;
652
			/* percentile itself */
653
			case '%': 
654
				j = i;
655
				goto next_char;
656
			/*
657
			 * Bad formatting.
658
			 */
659
			default:
2572 jermar 660
				/*
661
				 * Unknown format. Now, j is the index of '%'
662
				 * so we will print whole bad format sequence.
1888 jermar 663
				 */
664
				goto next_char;		
1271 cejka 665
			}
666
 
667
 
668
		/* Print integers */
669
			/* print number */
670
			switch (qualifier) {
1888 jermar 671
			case PrintfQualifierByte:
672
				size = sizeof(unsigned char);
673
				number = (uint64_t)va_arg(ap, unsigned int);
674
				break;
675
			case PrintfQualifierShort:
676
				size = sizeof(unsigned short);
677
				number = (uint64_t)va_arg(ap, unsigned int);
678
				break;
679
			case PrintfQualifierInt:
680
				size = sizeof(unsigned int);
681
				number = (uint64_t)va_arg(ap, unsigned int);
682
				break;
683
			case PrintfQualifierLong:
684
				size = sizeof(unsigned long);
685
				number = (uint64_t)va_arg(ap, unsigned long);
686
				break;
687
			case PrintfQualifierLongLong:
688
				size = sizeof(unsigned long long);
2572 jermar 689
				number = (uint64_t)va_arg(ap,
690
				    unsigned long long);
1888 jermar 691
				break;
692
			case PrintfQualifierPointer:
693
				size = sizeof(void *);
2572 jermar 694
				number = (uint64_t)(unsigned long)va_arg(ap,
695
				    void *);
1888 jermar 696
				break;
697
			case PrintfQualifierNative:
698
				size = sizeof(unative_t);
699
				number = (uint64_t)va_arg(ap, unative_t);
700
				break;
701
			default: /* Unknown qualifier */
702
				counter = -counter;
703
				goto out;
1271 cejka 704
			}
705
 
706
			if (flags & __PRINTF_FLAG_SIGNED) {
2572 jermar 707
				if (number & (0x1 << (size * 8 - 1))) {
1271 cejka 708
					flags |= __PRINTF_FLAG_NEGATIVE;
709
 
1780 jermar 710
					if (size == sizeof(uint64_t)) {
711
						number = -((int64_t)number);
1271 cejka 712
					} else {
713
						number = ~number;
2572 jermar 714
						number &=
715
						    ~(0xFFFFFFFFFFFFFFFFll <<
716
						    (size * 8));
1271 cejka 717
						number++;
718
					}
719
				}
720
			}
721
 
2572 jermar 722
			if ((retval = print_number(number, width, precision,
723
			    base, flags, ps)) < 0) {
1271 cejka 724
				counter = -counter;
725
				goto out;
2572 jermar 726
			}
1271 cejka 727
 
728
			counter += retval;
729
			j = i + 1;
730
		}	
731
next_char:
732
 
733
		++i;
734
	}
735
 
736
	if (i > j) {
2572 jermar 737
		if ((retval = printf_putnchars(&fmt[j], (unative_t)(i - j),
738
		    ps)) < 0) { /* error */
1271 cejka 739
			counter = -counter;
740
			goto out;
741
 
742
		}
743
		counter += retval;
744
	}
745
 
746
out:
747
 
748
	return counter;
749
}
750
 
1888 jermar 751
/** @}
1702 cejka 752
 */