WebSVN – HelenOS-historic – Blame – /uspace/trunk/libc/generic/io/printf_core.c

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

Subversion Repositories HelenOS-historic

(root)/uspace/trunk/libc/generic/io/printf_core.c – Rev 1444