WebSVN – HelenOS – Diff – /tags/0.3.0/boot/generic/printf.c


/*
 * Copyright (c) 2006 Martin Decky
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
/** @addtogroup generic
 * @{
 */
/** @file
 */
 
#include "printf.h"
#include "stdarg.h"
#include <types.h>
 
typedef char *char_ptr;
 
static char digits[] = "0123456789abcdef";  /**< Hexadecimal characters */
 
void puts(const char *str)
{
    int len = 0;
   
    while (str[len] != 0)
        len++;
   
    write(str, len);
}
 
 
/** Print hexadecimal digits
 *
 * Print fixed count of hexadecimal digits from
 * the number num. The digits are printed in
 * natural left-to-right order starting with
 * the width-th digit.
 *
 * @param num   Number containing digits.
 * @param width Count of digits to print.
 *
 */
static void print_fixed_hex(const uint64_t num, const int width)
{
    int i;
   
    for (i = width * 8 - 4; i >= 0; i -= 4)
        write(digits + ((num >> i) & 0xf), 1);
}
 
 
/** Print number in given base
 *
 * Print significant digits of a number in given
 * base.
 *
 * @param num  Number to print.
 * @param base Base to print the number in (should
 *             be in range 2 .. 16).
 *
 */
static void print_number(const unative_t num, const unsigned int base)
{
    int val = num;
    char d[sizeof(unative_t) * 8 + 1];      /* this is good enough even for base == 2 */
    int i = sizeof(unative_t) * 8 - 1;
   
    do {
        d[i--] = digits[val % base];
    } while (val /= base);
   
    d[sizeof(unative_t) * 8] = 0;  
    puts(&d[i + 1]);
}
 
 
/** General formatted text print
 *
 * Print text formatted according the fmt parameter
 * and variant arguments. Each formatting directive
 * begins with \% (percentage) character and one of the
 * following character:
 *
 * \%    Prints the percentage character.
 *
 * s    The next variant argument is treated as char*
 *      and printed as a NULL terminated string.
 *
 * c    The next variant argument is treated as a single char.
 *
 * p    The next variant argument is treated as a maximum
 *      bit-width integer with respect to architecture
 *      and printed in full hexadecimal width.
 *
 * P    As with 'p', but '0x' is prefixed.
 *
 * q    The next variant argument is treated as a 64b integer
 *      and printed in full hexadecimal width.
 *
 * Q    As with 'q', but '0x' is prefixed.
 *
 * l    The next variant argument is treated as a 32b integer
 *      and printed in full hexadecimal width.
 *
 * L    As with 'l', but '0x' is prefixed.
 *
 * w    The next variant argument is treated as a 16b integer
 *      and printed in full hexadecimal width.
 *
 * W    As with 'w', but '0x' is prefixed.
 *
 * b    The next variant argument is treated as a 8b integer
 *      and printed in full hexadecimal width.
 *
 * B    As with 'b', but '0x' is prefixed.
 *
 * d    The next variant argument is treated as integer
 *      and printed in standard decimal format (only significant
 *      digits).
 *
 * x    The next variant argument is treated as integer
 *      and printed in standard hexadecimal format (only significant
 *      digits).
 *
 * X    As with 'x', but '0x' is prefixed.
 *
 * All other characters from fmt except the formatting directives
 * are printed in verbatim.
 *
 * @param fmt Formatting NULL terminated string.
 */
void printf(const char *fmt, ...)
{
    int i = 0;
    va_list ap;
    char c;
   
    va_start(ap, fmt);
   
    while ((c = fmt[i++])) {
        switch (c) {
           
            /* control character */
            case '%':
               
                switch (c = fmt[i++]) {
                   
                    /* percentile itself */
                    case '%':
                        break;
                   
                    /*
                     * String and character conversions.
                     */
                    case 's':
                        puts(va_arg(ap, char_ptr));
                        goto loop;
                   
                    case 'c':
                        c = (char) va_arg(ap, int);
                        break;
                   
                    /*
                     * Hexadecimal conversions with fixed width.
                     */
                    case 'P':
                        puts("0x");
                    case 'p':
                        print_fixed_hex(va_arg(ap, unative_t), sizeof(unative_t));
                        goto loop;
                   
                    case 'Q':
                        puts("0x");
                    case 'q':
                        print_fixed_hex(va_arg(ap, uint64_t), INT64);
                        goto loop;
                   
                    case 'L':
                        puts("0x");
                    case 'l':
                        print_fixed_hex(va_arg(ap, unative_t), INT32);
                        goto loop;
                   
                    case 'W':
                        puts("0x");
                    case 'w':
                        print_fixed_hex(va_arg(ap, unative_t), INT16);
                        goto loop;
                   
                    case 'B':
                        puts("0x");
                    case 'b':
                        print_fixed_hex(va_arg(ap, unative_t), INT8);
                        goto loop;
                   
                    /*
                     * Decimal and hexadecimal conversions.
                     */
                    case 'd':
                        print_number(va_arg(ap, unative_t), 10);
                        goto loop;
                   
                    case 'X':
                        puts("0x");
                    case 'x':
                        print_number(va_arg(ap, unative_t), 16);
                        goto loop;
                   
                    /*
                     * Bad formatting.
                     */
                    default:
                        goto out;
            }
           
            default:
                write(&c, 1);
        }
   
loop:
        ;
    }
   
out:
   
    va_end(ap);
}
 
/** @}
 */
 

Rev 2465	Rev 2782
1	/*	1	/*
2	* Copyright (c) 2006 Martin Decky	2	* Copyright (c) 2006 Martin Decky
3	* All rights reserved.	3	* All rights reserved.
4	*	4	*
5	* Redistribution and use in source and binary forms, with or without	5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions	6	* modification, are permitted provided that the following conditions
7	* are met:	7	* are met:
8	*	8	*
9	* - Redistributions of source code must retain the above copyright	9	* - Redistributions of source code must retain the above copyright
10	* notice, this list of conditions and the following disclaimer.	10	* notice, this list of conditions and the following disclaimer.
11	* - Redistributions in binary form must reproduce the above copyright	11	* - Redistributions in binary form must reproduce the above copyright
12	* notice, this list of conditions and the following disclaimer in the	12	* notice, this list of conditions and the following disclaimer in the
13	* documentation and/or other materials provided with the distribution.	13	* documentation and/or other materials provided with the distribution.
14	* - The name of the author may not be used to endorse or promote products	14	* - The name of the author may not be used to endorse or promote products
15	* derived from this software without specific prior written permission.	15	* derived from this software without specific prior written permission.
16	*	16	*
17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES	18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF	25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27	*/	27	*/
28		28
29	/** @addtogroup generic	29	/** @addtogroup generic
30	* @{	30	* @{
31	*/	31	*/
32	/** @file	32	/** @file
33	*/	33	*/
34		34
35	#include "printf.h"	35	#include "printf.h"
36	#include "stdarg.h"	36	#include "stdarg.h"
37	#include <types.h>	37	#include <types.h>
38		38
39	typedef char *char_ptr;	39	typedef char *char_ptr;
40		40
41	static char digits[] = "0123456789abcdef"; /*< Hexadecimal characters /	41	static char digits[] = "0123456789abcdef"; /*< Hexadecimal characters /
42		42
43	void puts(const char *str)	43	void puts(const char *str)
44	{	44	{
45	int len = 0;	45	int len = 0;
46		46
47	while (str[len] != 0)	47	while (str[len] != 0)
48	len++;	48	len++;
49		49
50	write(str, len);	50	write(str, len);
51	}	51	}
52		52
53		53
54	/** Print hexadecimal digits	54	/** Print hexadecimal digits
55	*	55	*
56	* Print fixed count of hexadecimal digits from	56	* Print fixed count of hexadecimal digits from
57	* the number num. The digits are printed in	57	* the number num. The digits are printed in
58	* natural left-to-right order starting with	58	* natural left-to-right order starting with
59	* the width-th digit.	59	* the width-th digit.
60	*	60	*
61	* @param num Number containing digits.	61	* @param num Number containing digits.
62	* @param width Count of digits to print.	62	* @param width Count of digits to print.
63	*	63	*
64	*/	64	*/
65	static void print_fixed_hex(const uint64_t num, const int width)	65	static void print_fixed_hex(const uint64_t num, const int width)
66	{	66	{
67	int i;	67	int i;
68		68
69	for (i = width * 8 - 4; i >= 0; i -= 4)	69	for (i = width * 8 - 4; i >= 0; i -= 4)
70	write(digits + ((num >> i) & 0xf), 1);	70	write(digits + ((num >> i) & 0xf), 1);
71	}	71	}
72		72
73		73
74	/** Print number in given base	74	/** Print number in given base
75	*	75	*
76	* Print significant digits of a number in given	76	* Print significant digits of a number in given
77	* base.	77	* base.
78	*	78	*
79	* @param num Number to print.	79	* @param num Number to print.
80	* @param base Base to print the number in (should	80	* @param base Base to print the number in (should
81	* be in range 2 .. 16).	81	* be in range 2 .. 16).
82	*	82	*
83	*/	83	*/
84	static void print_number(const unative_t num, const unsigned int base)	84	static void print_number(const unative_t num, const unsigned int base)
85	{	85	{
86	int val = num;	86	int val = num;
87	char d[sizeof(unative_t) * 8 + 1]; /* this is good enough even for base == 2 */	87	char d[sizeof(unative_t) * 8 + 1]; /* this is good enough even for base == 2 */
88	int i = sizeof(unative_t) * 8 - 1;	88	int i = sizeof(unative_t) * 8 - 1;
89		89
90	do {	90	do {
91	d[i--] = digits[val % base];	91	d[i--] = digits[val % base];
92	} while (val /= base);	92	} while (val /= base);
93		93
94	d[sizeof(unative_t) * 8] = 0;	94	d[sizeof(unative_t) * 8] = 0;
95	puts(&d[i + 1]);	95	puts(&d[i + 1]);
96	}	96	}
97		97
98		98
99	/** General formatted text print	99	/** General formatted text print
100	*	100	*
101	* Print text formatted according the fmt parameter	101	* Print text formatted according the fmt parameter
102	* and variant arguments. Each formatting directive	102	* and variant arguments. Each formatting directive
103	* begins with \% (percentage) character and one of the	103	* begins with \% (percentage) character and one of the
104	* following character:	104	* following character:
105	*	105	*
106	* \% Prints the percentage character.	106	* \% Prints the percentage character.
107	*	107	*
108	* s The next variant argument is treated as char*	108	* s The next variant argument is treated as char*
109	* and printed as a NULL terminated string.	109	* and printed as a NULL terminated string.
110	*	110	*
111	* c The next variant argument is treated as a single char.	111	* c The next variant argument is treated as a single char.
112	*	112	*
113	* p The next variant argument is treated as a maximum	113	* p The next variant argument is treated as a maximum
114	* bit-width integer with respect to architecture	114	* bit-width integer with respect to architecture
115	* and printed in full hexadecimal width.	115	* and printed in full hexadecimal width.
116	*	116	*
117	* P As with 'p', but '0x' is prefixed.	117	* P As with 'p', but '0x' is prefixed.
118	*	118	*
119	* q The next variant argument is treated as a 64b integer	119	* q The next variant argument is treated as a 64b integer
120	* and printed in full hexadecimal width.	120	* and printed in full hexadecimal width.
121	*	121	*
122	* Q As with 'q', but '0x' is prefixed.	122	* Q As with 'q', but '0x' is prefixed.
123	*	123	*
124	* l The next variant argument is treated as a 32b integer	124	* l The next variant argument is treated as a 32b integer
125	* and printed in full hexadecimal width.	125	* and printed in full hexadecimal width.
126	*	126	*
127	* L As with 'l', but '0x' is prefixed.	127	* L As with 'l', but '0x' is prefixed.
128	*	128	*
129	* w The next variant argument is treated as a 16b integer	129	* w The next variant argument is treated as a 16b integer
130	* and printed in full hexadecimal width.	130	* and printed in full hexadecimal width.
131	*	131	*
132	* W As with 'w', but '0x' is prefixed.	132	* W As with 'w', but '0x' is prefixed.
133	*	133	*
134	* b The next variant argument is treated as a 8b integer	134	* b The next variant argument is treated as a 8b integer
135	* and printed in full hexadecimal width.	135	* and printed in full hexadecimal width.
136	*	136	*
137	* B As with 'b', but '0x' is prefixed.	137	* B As with 'b', but '0x' is prefixed.
138	*	138	*
139	* d The next variant argument is treated as integer	139	* d The next variant argument is treated as integer
140	* and printed in standard decimal format (only significant	140	* and printed in standard decimal format (only significant
141	* digits).	141	* digits).
142	*	142	*
143	* x The next variant argument is treated as integer	143	* x The next variant argument is treated as integer
144	* and printed in standard hexadecimal format (only significant	144	* and printed in standard hexadecimal format (only significant
145	* digits).	145	* digits).
146	*	146	*
147	* X As with 'x', but '0x' is prefixed.	147	* X As with 'x', but '0x' is prefixed.
148	*	148	*
149	* All other characters from fmt except the formatting directives	149	* All other characters from fmt except the formatting directives
150	* are printed in verbatim.	150	* are printed in verbatim.
151	*	151	*
152	* @param fmt Formatting NULL terminated string.	152	* @param fmt Formatting NULL terminated string.
153	*/	153	*/
154	void printf(const char *fmt, ...)	154	void printf(const char *fmt, ...)
155	{	155	{
156	int i = 0;	156	int i = 0;
157	va_list ap;	157	va_list ap;
158	char c;	158	char c;
159		159
160	va_start(ap, fmt);	160	va_start(ap, fmt);
161		161
162	while ((c = fmt[i++])) {	162	while ((c = fmt[i++])) {
163	switch (c) {	163	switch (c) {
164		164
165	/* control character */	165	/* control character */
166	case '%':	166	case '%':
167		167
168	switch (c = fmt[i++]) {	168	switch (c = fmt[i++]) {
169		169
170	/* percentile itself */	170	/* percentile itself */
171	case '%':	171	case '%':
172	break;	172	break;
173		173
174	/*	174	/*
175	* String and character conversions.	175	* String and character conversions.
176	*/	176	*/
177	case 's':	177	case 's':
178	puts(va_arg(ap, char_ptr));	178	puts(va_arg(ap, char_ptr));
179	goto loop;	179	goto loop;
180		180
181	case 'c':	181	case 'c':
182	c = (char) va_arg(ap, int);	182	c = (char) va_arg(ap, int);
183	break;	183	break;
184		184
185	/*	185	/*
186	* Hexadecimal conversions with fixed width.	186	* Hexadecimal conversions with fixed width.
187	*/	187	*/
188	case 'P':	188	case 'P':
189	puts("0x");	189	puts("0x");
190	case 'p':	190	case 'p':
191	print_fixed_hex(va_arg(ap, unative_t), sizeof(unative_t));	191	print_fixed_hex(va_arg(ap, unative_t), sizeof(unative_t));
192	goto loop;	192	goto loop;
193		193
194	case 'Q':	194	case 'Q':
195	puts("0x");	195	puts("0x");
196	case 'q':	196	case 'q':
197	print_fixed_hex(va_arg(ap, uint64_t), INT64);	197	print_fixed_hex(va_arg(ap, uint64_t), INT64);
198	goto loop;	198	goto loop;
199		199
200	case 'L':	200	case 'L':
201	puts("0x");	201	puts("0x");
202	case 'l':	202	case 'l':
203	print_fixed_hex(va_arg(ap, unative_t), INT32);	203	print_fixed_hex(va_arg(ap, unative_t), INT32);
204	goto loop;	204	goto loop;
205		205
206	case 'W':	206	case 'W':
207	puts("0x");	207	puts("0x");
208	case 'w':	208	case 'w':
209	print_fixed_hex(va_arg(ap, unative_t), INT16);	209	print_fixed_hex(va_arg(ap, unative_t), INT16);
210	goto loop;	210	goto loop;
211		211
212	case 'B':	212	case 'B':
213	puts("0x");	213	puts("0x");
214	case 'b':	214	case 'b':
215	print_fixed_hex(va_arg(ap, unative_t), INT8);	215	print_fixed_hex(va_arg(ap, unative_t), INT8);
216	goto loop;	216	goto loop;
217		217
218	/*	218	/*
219	* Decimal and hexadecimal conversions.	219	* Decimal and hexadecimal conversions.
220	*/	220	*/
221	case 'd':	221	case 'd':
222	print_number(va_arg(ap, unative_t), 10);	222	print_number(va_arg(ap, unative_t), 10);
223	goto loop;	223	goto loop;
224		224
225	case 'X':	225	case 'X':
226	puts("0x");	226	puts("0x");
227	case 'x':	227	case 'x':
228	print_number(va_arg(ap, unative_t), 16);	228	print_number(va_arg(ap, unative_t), 16);
229	goto loop;	229	goto loop;
230		230
231	/*	231	/*
232	* Bad formatting.	232	* Bad formatting.
233	*/	233	*/
234	default:	234	default:
235	goto out;	235	goto out;
236	}	236	}
237		237
238	default:	238	default:
239	write(&c, 1);	239	write(&c, 1);
240	}	240	}
241		241
242	loop:	242	loop:
243	;	243	;
244	}	244	}
245		245
246	out:	246	out:
247		247
248	va_end(ap);	248	va_end(ap);
249	}	249	}
250		250
251	/** @}	251	/** @}
252	*/	252	*/
253		253

Subversion Repositories HelenOS

(root)/tags/0.3.0/boot/generic/printf.c – Rev 2465 → 2782