Subversion Repositories HelenOS

Rev

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

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