WebSVN – HelenOS – Blame – /branches/tracing/uspace/lib/libc/generic/io/printf_core.c

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

Subversion Repositories HelenOS

(root)/branches/tracing/uspace/lib/libc/generic/io/printf_core.c – Rev 4692