WebSVN – HelenOS-historic – Diff – /kernel/trunk/generic/src/debug/print.c


/*
 * Copyright (C) 2001-2004 Jakub Jermar
 * 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.
 */
 
#include <putchar.h>
#include <print.h>
#include <synch/spinlock.h>
#include <arch/arg.h>
#include <arch/asm.h>
#include <arch/fmath.h>
 
#include <arch.h>
 
static char digits[] = "0123456789abcdef"; /**< Hexadecimal characters */
static spinlock_t printflock;              /**< printf spinlock */
 
#define DEFAULT_DOUBLE_PRECISION 16
#define DEFAULT_DOUBLE_BUFFER_SIZE 128
 
 
/** Print NULL terminated string
 *
 * Print characters from str using putchar() until
 * \\0 character is reached.
 *
 * @param str Characters to print.
 *
 */
static void print_str(const char *str)
{
    int i = 0;
    char c;
   
    while ((c = str[i++]))
        putchar(c);
}
 
 
/** 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 __u64 num, const int width)
{
    int i;
   
    for (i = width*8 - 4; i >= 0; i -= 4)
        putchar(digits[(num>>i) & 0xf]);
}
 
 
/** 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 __native num, const unsigned int base)
{
    int val = num;
    char d[sizeof(__native)*8+1];       /* this is good enough even for base == 2 */
    int i = sizeof(__native)*8-1;
   
    do {
        d[i--] = digits[val % base];
    } while (val /= base);
   
    d[sizeof(__native)*8] = 0; 
    print_str(&d[i + 1]);
}
 
 
static void print_double(double num, __u8 modifier, __u16 precision)
{
    double intval,intval2;
    int counter;
    int exponent,exponenttmp;
    unsigned char buf[DEFAULT_DOUBLE_BUFFER_SIZE];
    unsigned long in1,in2; 
   
 
    if (fmath_is_nan(num)) {
        print_str("NaN");
        return;
    }
   
    if (num<0.0) {
        putchar('-');
        num=num*-1.0;
    }
 
 
    if (fmath_is_infinity(num)) {
        print_str("Inf");
        return;
    }
 
    if ((modifier=='E')||(modifier=='e')) {
        intval2=fmath_fint(fmath_get_decimal_exponent(num),&intval);
        exponent=intval;
        if ((intval2<0.0)) exponent--;
        num = num / ((fmath_dpow(10.0,exponent)));
       
        print_double(num,modifier+1,precision); /* modifier+1 = E => F or e => f */
        putchar(modifier);
        if (exponent<0) {
            putchar('-');
            exponent*=-1;
        }
        print_number(exponent,10);
        return;
    }
       
    /* TODO: rounding constant - when we got fraction >= 0.5, we must increment last printed number */
 
    /*
     * Here is a problem with cumulative error while printing big double values -> we will divide
     * the number with a power of 10, print new number with better method for small numbers and
     * then print decimal point at correct position.
     */
   
    fmath_fint(fmath_get_decimal_exponent(num),&intval);
   
    exponent=(intval>0.0?intval:0);
   
    precision+=exponent;
   
    if (exponent>0) num = num / ((fmath_dpow(10.0,exponent)));
       
    num=fmath_fint(num,&intval);
   
    if (precision>0) {
        counter=precision-1;
        if (exponent>0) counter++;
       
        if (counter>=DEFAULT_DOUBLE_BUFFER_SIZE) {
            counter=DEFAULT_DOUBLE_BUFFER_SIZE;
        }
        exponenttmp=exponent;
        while(counter>=0) {
            num *= 10.0;
            num = fmath_fint(num,&intval2);
            buf[counter--]=((int)intval2)+'0';
            exponenttmp--;
            if ((exponenttmp==0)&&(counter>=0)) buf[counter--]='.';
        }
        counter=precision;
        if ((exponent==0)&&(counter<DEFAULT_DOUBLE_BUFFER_SIZE)) buf[counter]='.';
        counter++; 
    } else {
        counter=0; 
    }
   
    in1=intval;
    if (in1==0.0) {
        if (counter<DEFAULT_DOUBLE_BUFFER_SIZE) buf[counter++]='0';
    } else {
        while(( in1>0 )&&(counter<DEFAULT_DOUBLE_BUFFER_SIZE)) {
           
            in2=in1;
            in1/=10;
            buf[counter]=in2-in1*10 + '0';
            counter++;
        }
    }
   
    counter = (counter>=DEFAULT_DOUBLE_BUFFER_SIZE?DEFAULT_DOUBLE_BUFFER_SIZE:counter);
    while (counter>0) {
        putchar(buf[--counter]);
    }
    return;
}
 
 
/** 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.
 *
 * .    The decimal number following period will be treated as precision
 *      for printing floating point numbers. One of 'e', 'E', 'f' or 'F'
 *      must follow.
 *
 * e    The next variant argument is treated as double precision float
 *      and printed in exponent notation with only one digit before decimal point
 *      in specified precision. The exponent sign is printed as 'e'.
 *
 * E    As with 'e', but the exponent sign is printed as 'E'.
 *
 * f    The next variant argument is treated as double precision float
 *      and printed in decimal notation in specified precision.
 *
 * F    As with 'f'.
 *
 * 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 irqpri, i = 0;
    va_list ap;
    char c;
   
    __u16 precision;
   
    va_start(ap, fmt);
 
    irqpri = interrupts_disable();
    spinlock_lock(&printflock);
 
    while ((c = fmt[i++])) {
        switch (c) {
 
            /* control character */
            case '%':
            precision = DEFAULT_DOUBLE_PRECISION;
            if (fmt[i]=='.') {
                precision=0;
                c=fmt[++i];
                while((c>='0')&&(c<='9')) {
                    precision = precision*10 + c - '0';
                    c=fmt[++i];
                }
            }
           
            switch (c = fmt[i++]) {
 
                /* percentile itself */
                case '%':
                break;
 
                /*
                 * String and character conversions.
                 */
                case 's':
                print_str(va_arg(ap, char_ptr));
                goto loop;
 
                case 'c':
                c = (char) va_arg(ap, int);
                break;
 
                /*
                     * Hexadecimal conversions with fixed width.
                     */
                case 'P':
                print_str("0x");
                case 'p':
                    print_fixed_hex(va_arg(ap, __native), sizeof(__native));
                goto loop;
 
                case 'Q':
                print_str("0x");
                case 'q':
                    print_fixed_hex(va_arg(ap, __u64), INT64);
                goto loop;
 
                case 'L':
                print_str("0x");
                case 'l':
                    print_fixed_hex(va_arg(ap, __native), INT32);
                goto loop;
 
                case 'W':
                print_str("0x");
                case 'w':
                    print_fixed_hex(va_arg(ap, __native), INT16);
                goto loop;
 
                case 'B':
                print_str("0x");
                case 'b':
                    print_fixed_hex(va_arg(ap, __native), INT8);
                goto loop;
 
                /*
                     * Floating point conversions.
                     */
                case 'F':
                    print_double(va_arg(ap, double),'F',precision);
                goto loop;
                   
                case 'f':
                    print_double(va_arg(ap, double),'f',precision);
                goto loop;
               
                case 'E':
                    print_double(va_arg(ap, double),'E',precision);
                goto loop;
                case 'e':
                    print_double(va_arg(ap, double),'e',precision);
                goto loop;
               
                /*
                     * Decimal and hexadecimal conversions.
                     */
                case 'd':
                    print_number(va_arg(ap, __native), 10);
                goto loop;
 
                case 'X':
                print_str("0x");
                case 'x':
                    print_number(va_arg(ap, __native), 16);
                goto loop;
       
                /*
                 * Bad formatting.
                 */
                default:
                goto out;
            }
 
            default: putchar(c);
        }
   
loop:
        ;
    }
 
out:
    spinlock_unlock(&printflock);
    interrupts_restore(irqpri);
   
    va_end(ap);
}
 

Rev 534	Rev 615
1	/*	1	/*
2	* Copyright (C) 2001-2004 Jakub Jermar	2	* Copyright (C) 2001-2004 Jakub Jermar
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	#include <putchar.h>	29	#include <putchar.h>
30	#include <print.h>	30	#include <print.h>
31	#include <synch/spinlock.h>	31	#include <synch/spinlock.h>
32	#include <arch/arg.h>	32	#include <arch/arg.h>
33	#include <arch/asm.h>	33	#include <arch/asm.h>
34	#include <arch/fmath.h>	34	#include <arch/fmath.h>
35		35
36	#include <arch.h>	36	#include <arch.h>
37		37
38	static char digits[] = "0123456789abcdef"; /*< Hexadecimal characters /	38	static char digits[] = "0123456789abcdef"; /*< Hexadecimal characters /
39	static spinlock_t printflock; /*< printf spinlock /	39	static spinlock_t printflock; /*< printf spinlock /
40		40
41	#define DEFAULT_DOUBLE_PRECISION 16	41	#define DEFAULT_DOUBLE_PRECISION 16
42	#define DEFAULT_DOUBLE_BUFFER_SIZE 128	42	#define DEFAULT_DOUBLE_BUFFER_SIZE 128
43		43
44		44
45	/** Print NULL terminated string	45	/** Print NULL terminated string
46	*	46	*
47	* Print characters from str using putchar() until	47	* Print characters from str using putchar() until
48	* \\0 character is reached.	48	* \\0 character is reached.
49	*	49	*
50	* @param str Characters to print.	50	* @param str Characters to print.
51	*	51	*
52	*/	52	*/
53	static void print_str(const char *str)	53	static void print_str(const char *str)
54	{	54	{
55	int i = 0;	55	int i = 0;
56	char c;	56	char c;
57		57
58	while (c = str[i++])	58	while ((c = str[i++]))
59	putchar(c);	59	putchar(c);
60	}	60	}
61		61
62		62
63	/** Print hexadecimal digits	63	/** Print hexadecimal digits
64	*	64	*
65	* Print fixed count of hexadecimal digits from	65	* Print fixed count of hexadecimal digits from
66	* the number num. The digits are printed in	66	* the number num. The digits are printed in
67	* natural left-to-right order starting with	67	* natural left-to-right order starting with
68	* the width-th digit.	68	* the width-th digit.
69	*	69	*
70	* @param num Number containing digits.	70	* @param num Number containing digits.
71	* @param width Count of digits to print.	71	* @param width Count of digits to print.
72	*	72	*
73	*/	73	*/
74	static void print_fixed_hex(const __u64 num, const int width)	74	static void print_fixed_hex(const __u64 num, const int width)
75	{	75	{
76	int i;	76	int i;
77		77
78	for (i = width*8 - 4; i >= 0; i -= 4)	78	for (i = width*8 - 4; i >= 0; i -= 4)
79	putchar(digits[(num>>i) & 0xf]);	79	putchar(digits[(num>>i) & 0xf]);
80	}	80	}
81		81
82		82
83	/** Print number in given base	83	/** Print number in given base
84	*	84	*
85	* Print significant digits of a number in given	85	* Print significant digits of a number in given
86	* base.	86	* base.
87	*	87	*
88	* @param num Number to print.	88	* @param num Number to print.
89	* @param base Base to print the number in (should	89	* @param base Base to print the number in (should
90	* be in range 2 .. 16).	90	* be in range 2 .. 16).
91	*	91	*
92	*/	92	*/
93	static void print_number(const __native num, const unsigned int base)	93	static void print_number(const __native num, const unsigned int base)
94	{	94	{
95	int val = num;	95	int val = num;
96	char d[sizeof(__native)8+1]; / this is good enough even for base == 2 */	96	char d[sizeof(__native)8+1]; / this is good enough even for base == 2 */
97	int i = sizeof(__native)*8-1;	97	int i = sizeof(__native)*8-1;
98		98
99	do {	99	do {
100	d[i--] = digits[val % base];	100	d[i--] = digits[val % base];
101	} while (val /= base);	101	} while (val /= base);
102		102
103	d[sizeof(__native)*8] = 0;	103	d[sizeof(__native)*8] = 0;
104	print_str(&d[i + 1]);	104	print_str(&d[i + 1]);
105	}	105	}
106		106
107		107
108	static void print_double(double num, __u8 modifier, __u16 precision)	108	static void print_double(double num, __u8 modifier, __u16 precision)
109	{	109	{
110	double intval,intval2;	110	double intval,intval2;
111	int counter;	111	int counter;
112	int exponent,exponenttmp;	112	int exponent,exponenttmp;
113	unsigned char buf[DEFAULT_DOUBLE_BUFFER_SIZE];	113	unsigned char buf[DEFAULT_DOUBLE_BUFFER_SIZE];
114	unsigned long in1,in2;	114	unsigned long in1,in2;
115		115
116		116
117	if (fmath_is_nan(num)) {	117	if (fmath_is_nan(num)) {
118	print_str("NaN");	118	print_str("NaN");
119	return;	119	return;
120	}	120	}
121		121
122	if (num<0.0) {	122	if (num<0.0) {
123	putchar('-');	123	putchar('-');
124	num=num*-1.0;	124	num=num*-1.0;
125	}	125	}
126		126
127		127
128	if (fmath_is_infinity(num)) {	128	if (fmath_is_infinity(num)) {
129	print_str("Inf");	129	print_str("Inf");
130	return;	130	return;
131	}	131	}
132		132
133	if ((modifier=='E')\|\|(modifier=='e')) {	133	if ((modifier=='E')\|\|(modifier=='e')) {
134	intval2=fmath_fint(fmath_get_decimal_exponent(num),&intval);	134	intval2=fmath_fint(fmath_get_decimal_exponent(num),&intval);
135	exponent=intval;	135	exponent=intval;
136	if ((intval2<0.0)) exponent--;	136	if ((intval2<0.0)) exponent--;
137	num = num / ((fmath_dpow(10.0,exponent)));	137	num = num / ((fmath_dpow(10.0,exponent)));
138		138
139	print_double(num,modifier+1,precision); /* modifier+1 = E => F or e => f */	139	print_double(num,modifier+1,precision); /* modifier+1 = E => F or e => f */
140	putchar(modifier);	140	putchar(modifier);
141	if (exponent<0) {	141	if (exponent<0) {
142	putchar('-');	142	putchar('-');
143	exponent*=-1;	143	exponent*=-1;
144	}	144	}
145	print_number(exponent,10);	145	print_number(exponent,10);
146	return;	146	return;
147	}	147	}
148		148
149	/* TODO: rounding constant - when we got fraction >= 0.5, we must increment last printed number */	149	/* TODO: rounding constant - when we got fraction >= 0.5, we must increment last printed number */
150		150
151	/*	151	/*
152	* Here is a problem with cumulative error while printing big double values -> we will divide	152	* Here is a problem with cumulative error while printing big double values -> we will divide
153	* the number with a power of 10, print new number with better method for small numbers and	153	* the number with a power of 10, print new number with better method for small numbers and
154	* then print decimal point at correct position.	154	* then print decimal point at correct position.
155	*/	155	*/
156		156
157	fmath_fint(fmath_get_decimal_exponent(num),&intval);	157	fmath_fint(fmath_get_decimal_exponent(num),&intval);
158		158
159	exponent=(intval>0.0?intval:0);	159	exponent=(intval>0.0?intval:0);
160		160
161	precision+=exponent;	161	precision+=exponent;
162		162
163	if (exponent>0) num = num / ((fmath_dpow(10.0,exponent)));	163	if (exponent>0) num = num / ((fmath_dpow(10.0,exponent)));
164		164
165	num=fmath_fint(num,&intval);	165	num=fmath_fint(num,&intval);
166		166
167	if (precision>0) {	167	if (precision>0) {
168	counter=precision-1;	168	counter=precision-1;
169	if (exponent>0) counter++;	169	if (exponent>0) counter++;
170		170
171	if (counter>=DEFAULT_DOUBLE_BUFFER_SIZE) {	171	if (counter>=DEFAULT_DOUBLE_BUFFER_SIZE) {
172	counter=DEFAULT_DOUBLE_BUFFER_SIZE;	172	counter=DEFAULT_DOUBLE_BUFFER_SIZE;
173	}	173	}
174	exponenttmp=exponent;	174	exponenttmp=exponent;
175	while(counter>=0) {	175	while(counter>=0) {
176	num *= 10.0;	176	num *= 10.0;
177	num = fmath_fint(num,&intval2);	177	num = fmath_fint(num,&intval2);
178	buf[counter--]=((int)intval2)+'0';	178	buf[counter--]=((int)intval2)+'0';
179	exponenttmp--;	179	exponenttmp--;
180	if ((exponenttmp==0)&&(counter>=0)) buf[counter--]='.';	180	if ((exponenttmp==0)&&(counter>=0)) buf[counter--]='.';
181	}	181	}
182	counter=precision;	182	counter=precision;
183	if ((exponent==0)&&(counter<DEFAULT_DOUBLE_BUFFER_SIZE)) buf[counter]='.';	183	if ((exponent==0)&&(counter<DEFAULT_DOUBLE_BUFFER_SIZE)) buf[counter]='.';
184	counter++;	184	counter++;
185	} else {	185	} else {
186	counter=0;	186	counter=0;
187	}	187	}
188		188
189	in1=intval;	189	in1=intval;
190	if (in1==0.0) {	190	if (in1==0.0) {
191	if (counter<DEFAULT_DOUBLE_BUFFER_SIZE) buf[counter++]='0';	191	if (counter<DEFAULT_DOUBLE_BUFFER_SIZE) buf[counter++]='0';
192	} else {	192	} else {
193	while(( in1>0 )&&(counter<DEFAULT_DOUBLE_BUFFER_SIZE)) {	193	while(( in1>0 )&&(counter<DEFAULT_DOUBLE_BUFFER_SIZE)) {
194		194
195	in2=in1;	195	in2=in1;
196	in1/=10;	196	in1/=10;
197	buf[counter]=in2-in1*10 + '0';	197	buf[counter]=in2-in1*10 + '0';
198	counter++;	198	counter++;
199	}	199	}
200	}	200	}
201		201
202	counter = (counter>=DEFAULT_DOUBLE_BUFFER_SIZE?DEFAULT_DOUBLE_BUFFER_SIZE:counter);	202	counter = (counter>=DEFAULT_DOUBLE_BUFFER_SIZE?DEFAULT_DOUBLE_BUFFER_SIZE:counter);
203	while (counter>0) {	203	while (counter>0) {
204	putchar(buf[--counter]);	204	putchar(buf[--counter]);
205	}	205	}
206	return;	206	return;
207	}	207	}
208		208
209		209
210	/** General formatted text print	210	/** General formatted text print
211	*	211	*
212	* Print text formatted according the fmt parameter	212	* Print text formatted according the fmt parameter
213	* and variant arguments. Each formatting directive	213	* and variant arguments. Each formatting directive
214	* begins with \% (percentage) character and one of the	214	* begins with \% (percentage) character and one of the
215	* following character:	215	* following character:
216	*	216	*
217	* \% Prints the percentage character.	217	* \% Prints the percentage character.
218	*	218	*
219	* s The next variant argument is treated as char*	219	* s The next variant argument is treated as char*
220	* and printed as a NULL terminated string.	220	* and printed as a NULL terminated string.
221	*	221	*
222	* c The next variant argument is treated as a single char.	222	* c The next variant argument is treated as a single char.
223	*	223	*
224	* p The next variant argument is treated as a maximum	224	* p The next variant argument is treated as a maximum
225	* bit-width integer with respect to architecture	225	* bit-width integer with respect to architecture
226	* and printed in full hexadecimal width.	226	* and printed in full hexadecimal width.
227	*	227	*
228	* P As with 'p', but '0x' is prefixed.	228	* P As with 'p', but '0x' is prefixed.
229	*	229	*
230	* q The next variant argument is treated as a 64b integer	230	* q The next variant argument is treated as a 64b integer
231	* and printed in full hexadecimal width.	231	* and printed in full hexadecimal width.
232	*	232	*
233	* Q As with 'q', but '0x' is prefixed.	233	* Q As with 'q', but '0x' is prefixed.
234	*	234	*
235	* l The next variant argument is treated as a 32b integer	235	* l The next variant argument is treated as a 32b integer
236	* and printed in full hexadecimal width.	236	* and printed in full hexadecimal width.
237	*	237	*
238	* L As with 'l', but '0x' is prefixed.	238	* L As with 'l', but '0x' is prefixed.
239	*	239	*
240	* w The next variant argument is treated as a 16b integer	240	* w The next variant argument is treated as a 16b integer
241	* and printed in full hexadecimal width.	241	* and printed in full hexadecimal width.
242	*	242	*
243	* W As with 'w', but '0x' is prefixed.	243	* W As with 'w', but '0x' is prefixed.
244	*	244	*
245	* b The next variant argument is treated as a 8b integer	245	* b The next variant argument is treated as a 8b integer
246	* and printed in full hexadecimal width.	246	* and printed in full hexadecimal width.
247	*	247	*
248	* B As with 'b', but '0x' is prefixed.	248	* B As with 'b', but '0x' is prefixed.
249	*	249	*
250	* d The next variant argument is treated as integer	250	* d The next variant argument is treated as integer
251	* and printed in standard decimal format (only significant	251	* and printed in standard decimal format (only significant
252	* digits).	252	* digits).
253	*	253	*
254	* x The next variant argument is treated as integer	254	* x The next variant argument is treated as integer
255	* and printed in standard hexadecimal format (only significant	255	* and printed in standard hexadecimal format (only significant
256	* digits).	256	* digits).
257	*	257	*
258	* X As with 'x', but '0x' is prefixed.	258	* X As with 'x', but '0x' is prefixed.
259	*	259	*
260	* . The decimal number following period will be treated as precision	260	* . The decimal number following period will be treated as precision
261	* for printing floating point numbers. One of 'e', 'E', 'f' or 'F'	261	* for printing floating point numbers. One of 'e', 'E', 'f' or 'F'
262	* must follow.	262	* must follow.
263	*	263	*
264	* e The next variant argument is treated as double precision float	264	* e The next variant argument is treated as double precision float
265	* and printed in exponent notation with only one digit before decimal point	265	* and printed in exponent notation with only one digit before decimal point
266	* in specified precision. The exponent sign is printed as 'e'.	266	* in specified precision. The exponent sign is printed as 'e'.
267	*	267	*
268	* E As with 'e', but the exponent sign is printed as 'E'.	268	* E As with 'e', but the exponent sign is printed as 'E'.
269	*	269	*
270	* f The next variant argument is treated as double precision float	270	* f The next variant argument is treated as double precision float
271	* and printed in decimal notation in specified precision.	271	* and printed in decimal notation in specified precision.
272	*	272	*
273	* F As with 'f'.	273	* F As with 'f'.
274	*	274	*
275	* All other characters from fmt except the formatting directives	275	* All other characters from fmt except the formatting directives
276	* are printed in verbatim.	276	* are printed in verbatim.
277	*	277	*
278	* @param fmt Formatting NULL terminated string.	278	* @param fmt Formatting NULL terminated string.
279	*/	279	*/
280	void printf(const char *fmt, ...)	280	void printf(const char *fmt, ...)
281	{	281	{
282	int irqpri, i = 0;	282	int irqpri, i = 0;
283	va_list ap;	283	va_list ap;
284	char c;	284	char c;
285		285
286	__u16 precision;	286	__u16 precision;
287		287
288	va_start(ap, fmt);	288	va_start(ap, fmt);
289		289
290	irqpri = interrupts_disable();	290	irqpri = interrupts_disable();
291	spinlock_lock(&printflock);	291	spinlock_lock(&printflock);
292		292
293	while (c = fmt[i++]) {	293	while ((c = fmt[i++])) {
294	switch (c) {	294	switch (c) {
295		295
296	/* control character */	296	/* control character */
297	case '%':	297	case '%':
298	precision = DEFAULT_DOUBLE_PRECISION;	298	precision = DEFAULT_DOUBLE_PRECISION;
299	if (fmt[i]=='.') {	299	if (fmt[i]=='.') {
300	precision=0;	300	precision=0;
301	c=fmt[++i];	301	c=fmt[++i];
302	while((c>='0')&&(c<='9')) {	302	while((c>='0')&&(c<='9')) {
303	precision = precision*10 + c - '0';	303	precision = precision*10 + c - '0';
304	c=fmt[++i];	304	c=fmt[++i];
305	}	305	}
306	}	306	}
307		307
308	switch (c = fmt[i++]) {	308	switch (c = fmt[i++]) {
309		309
310	/* percentile itself */	310	/* percentile itself */
311	case '%':	311	case '%':
312	break;	312	break;
313		313
314	/*	314	/*
315	* String and character conversions.	315	* String and character conversions.
316	*/	316	*/
317	case 's':	317	case 's':
318	print_str(va_arg(ap, char_ptr));	318	print_str(va_arg(ap, char_ptr));
319	goto loop;	319	goto loop;
320		320
321	case 'c':	321	case 'c':
322	c = (char) va_arg(ap, int);	322	c = (char) va_arg(ap, int);
323	break;	323	break;
324		324
325	/*	325	/*
326	* Hexadecimal conversions with fixed width.	326	* Hexadecimal conversions with fixed width.
327	*/	327	*/
328	case 'P':	328	case 'P':
329	print_str("0x");	329	print_str("0x");
330	case 'p':	330	case 'p':
331	print_fixed_hex(va_arg(ap, __native), sizeof(__native));	331	print_fixed_hex(va_arg(ap, __native), sizeof(__native));
332	goto loop;	332	goto loop;
333		333
334	case 'Q':	334	case 'Q':
335	print_str("0x");	335	print_str("0x");
336	case 'q':	336	case 'q':
337	print_fixed_hex(va_arg(ap, __u64), INT64);	337	print_fixed_hex(va_arg(ap, __u64), INT64);
338	goto loop;	338	goto loop;
339		339
340	case 'L':	340	case 'L':
341	print_str("0x");	341	print_str("0x");
342	case 'l':	342	case 'l':
343	print_fixed_hex(va_arg(ap, __native), INT32);	343	print_fixed_hex(va_arg(ap, __native), INT32);
344	goto loop;	344	goto loop;
345		345
346	case 'W':	346	case 'W':
347	print_str("0x");	347	print_str("0x");
348	case 'w':	348	case 'w':
349	print_fixed_hex(va_arg(ap, __native), INT16);	349	print_fixed_hex(va_arg(ap, __native), INT16);
350	goto loop;	350	goto loop;
351		351
352	case 'B':	352	case 'B':
353	print_str("0x");	353	print_str("0x");
354	case 'b':	354	case 'b':
355	print_fixed_hex(va_arg(ap, __native), INT8);	355	print_fixed_hex(va_arg(ap, __native), INT8);
356	goto loop;	356	goto loop;
357		357
358	/*	358	/*
359	* Floating point conversions.	359	* Floating point conversions.
360	*/	360	*/
361	case 'F':	361	case 'F':
362	print_double(va_arg(ap, double),'F',precision);	362	print_double(va_arg(ap, double),'F',precision);
363	goto loop;	363	goto loop;
364		364
365	case 'f':	365	case 'f':
366	print_double(va_arg(ap, double),'f',precision);	366	print_double(va_arg(ap, double),'f',precision);
367	goto loop;	367	goto loop;
368		368
369	case 'E':	369	case 'E':
370	print_double(va_arg(ap, double),'E',precision);	370	print_double(va_arg(ap, double),'E',precision);
371	goto loop;	371	goto loop;
372	case 'e':	372	case 'e':
373	print_double(va_arg(ap, double),'e',precision);	373	print_double(va_arg(ap, double),'e',precision);
374	goto loop;	374	goto loop;
375		375
376	/*	376	/*
377	* Decimal and hexadecimal conversions.	377	* Decimal and hexadecimal conversions.
378	*/	378	*/
379	case 'd':	379	case 'd':
380	print_number(va_arg(ap, __native), 10);	380	print_number(va_arg(ap, __native), 10);
381	goto loop;	381	goto loop;
382		382
383	case 'X':	383	case 'X':
384	print_str("0x");	384	print_str("0x");
385	case 'x':	385	case 'x':
386	print_number(va_arg(ap, __native), 16);	386	print_number(va_arg(ap, __native), 16);
387	goto loop;	387	goto loop;
388		388
389	/*	389	/*
390	* Bad formatting.	390	* Bad formatting.
391	*/	391	*/
392	default:	392	default:
393	goto out;	393	goto out;
394	}	394	}
395		395
396	default: putchar(c);	396	default: putchar(c);
397	}	397	}
398		398
399	loop:	399	loop:
400	;	400	;
401	}	401	}
402		402
403	out:	403	out:
404	spinlock_unlock(&printflock);	404	spinlock_unlock(&printflock);
405	interrupts_restore(irqpri);	405	interrupts_restore(irqpri);
406		406
407	va_end(ap);	407	va_end(ap);
408	}	408	}
409		409

Subversion Repositories HelenOS-historic

(root)/kernel/trunk/generic/src/debug/print.c – Rev 534 → 615