WebSVN – HelenOS – Blame – /trunk/kernel/generic/src/printf/printf_core.c

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

Subversion Repositories HelenOS

(root)/trunk/kernel/generic/src/printf/printf_core.c – Rev 4603