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

Subversion Repositories HelenOS

(root)//branches/dynload/kernel/generic/src/printf/printf_core.c – Rev 4347