URL https://opencores.org/ocsvn/or1k_soc_on_altera_embedded_dev_kit/or1k_soc_on_altera_embedded_dev_kit/trunk

Subversion Repositories or1k_soc_on_altera_embedded_dev_kit

[/] [or1k_soc_on_altera_embedded_dev_kit/] [trunk/] [linux-2.6/] [linux-2.6.24/] [arch/] [x86/] [boot/] [printf.c] - Blame information for rev 17

Go to most recent revision | Details | Compare with Previous | View Log


/* -*- linux-c -*- ------------------------------------------------------- *
 *
 *   Copyright (C) 1991, 1992 Linus Torvalds
 *   Copyright 2007 rPath, Inc. - All Rights Reserved
 *
 *   This file is part of the Linux kernel, and is made available under
 *   the terms of the GNU General Public License version 2.
 *
 * ----------------------------------------------------------------------- */
 
/*
 * arch/i386/boot/printf.c
 *
 * Oh, it's a waste of space, but oh-so-yummy for debugging.  This
 * version of printf() does not include 64-bit support.  "Live with
 * it."
 *
 */
 
#include "boot.h"
 
static int skip_atoi(const char **s)
{
        int i = 0;
 
        while (isdigit(**s))
                i = i * 10 + *((*s)++) - '0';
        return i;
}
 
#define ZEROPAD 1               /* pad with zero */
#define SIGN    2               /* unsigned/signed long */
#define PLUS    4               /* show plus */
#define SPACE   8               /* space if plus */
#define LEFT    16              /* left justified */
#define SPECIAL 32              /* 0x */
#define LARGE   64              /* use 'ABCDEF' instead of 'abcdef' */
 
#define do_div(n,base) ({ \
int __res; \
__res = ((unsigned long) n) % (unsigned) base; \
n = ((unsigned long) n) / (unsigned) base; \
__res; })
 
static char *number(char *str, long num, int base, int size, int precision,
                    int type)
{
        char c, sign, tmp[66];
        const char *digits = "0123456789abcdefghijklmnopqrstuvwxyz";
        int i;
 
        if (type & LARGE)
                digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
        if (type & LEFT)
                type &= ~ZEROPAD;
        if (base < 2 || base > 36)
                return 0;
        c = (type & ZEROPAD) ? '0' : ' ';
        sign = 0;
        if (type & SIGN) {
                if (num < 0) {
                        sign = '-';
                        num = -num;
                        size--;
                } else if (type & PLUS) {
                        sign = '+';
                        size--;
                } else if (type & SPACE) {
                        sign = ' ';
                        size--;
                }
        }
        if (type & SPECIAL) {
                if (base == 16)
                        size -= 2;
                else if (base == 8)
                        size--;
        }
        i = 0;
        if (num == 0)
                tmp[i++] = '0';
        else
                while (num != 0)
                        tmp[i++] = digits[do_div(num, base)];
        if (i > precision)
                precision = i;
        size -= precision;
        if (!(type & (ZEROPAD + LEFT)))
                while (size-- > 0)
                        *str++ = ' ';
        if (sign)
                *str++ = sign;
        if (type & SPECIAL) {
                if (base == 8)
                        *str++ = '0';
                else if (base == 16) {
                        *str++ = '0';
                        *str++ = digits[33];
                }
        }
        if (!(type & LEFT))
                while (size-- > 0)
                        *str++ = c;
        while (i < precision--)
                *str++ = '0';
        while (i-- > 0)
                *str++ = tmp[i];
        while (size-- > 0)
                *str++ = ' ';
        return str;
}
 
int vsprintf(char *buf, const char *fmt, va_list args)
{
        int len;
        unsigned long num;
        int i, base;
        char *str;
        const char *s;
 
        int flags;              /* flags to number() */
 
        int field_width;        /* width of output field */
        int precision;          /* min. # of digits for integers; max
                                   number of chars for from string */
        int qualifier;          /* 'h', 'l', or 'L' for integer fields */
 
        for (str = buf; *fmt; ++fmt) {
                if (*fmt != '%') {
                        *str++ = *fmt;
                        continue;
                }
 
                /* process flags */
                flags = 0;
              repeat:
                ++fmt;          /* this also skips first '%' */
                switch (*fmt) {
                case '-':
                        flags |= LEFT;
                        goto repeat;
                case '+':
                        flags |= PLUS;
                        goto repeat;
                case ' ':
                        flags |= SPACE;
                        goto repeat;
                case '#':
                        flags |= SPECIAL;
                        goto repeat;
                case '0':
                        flags |= ZEROPAD;
                        goto repeat;
                }
 
                /* get field width */
                field_width = -1;
                if (isdigit(*fmt))
                        field_width = skip_atoi(&fmt);
                else if (*fmt == '*') {
                        ++fmt;
                        /* it's the next argument */
                        field_width = va_arg(args, int);
                        if (field_width < 0) {
                                field_width = -field_width;
                                flags |= LEFT;
                        }
                }
 
                /* get the precision */
                precision = -1;
                if (*fmt == '.') {
                        ++fmt;
                        if (isdigit(*fmt))
                                precision = skip_atoi(&fmt);
                        else if (*fmt == '*') {
                                ++fmt;
                                /* it's the next argument */
                                precision = va_arg(args, int);
                        }
                        if (precision < 0)
                                precision = 0;
                }
 
                /* get the conversion qualifier */
                qualifier = -1;
                if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L') {
                        qualifier = *fmt;
                        ++fmt;
                }
 
                /* default base */
                base = 10;
 
                switch (*fmt) {
                case 'c':
                        if (!(flags & LEFT))
                                while (--field_width > 0)
                                        *str++ = ' ';
                        *str++ = (unsigned char)va_arg(args, int);
                        while (--field_width > 0)
                                *str++ = ' ';
                        continue;
 
                case 's':
                        s = va_arg(args, char *);
                        len = strnlen(s, precision);
 
                        if (!(flags & LEFT))
                                while (len < field_width--)
                                        *str++ = ' ';
                        for (i = 0; i < len; ++i)
                                *str++ = *s++;
                        while (len < field_width--)
                                *str++ = ' ';
                        continue;
 
                case 'p':
                        if (field_width == -1) {
                                field_width = 2 * sizeof(void *);
                                flags |= ZEROPAD;
                        }
                        str = number(str,
                                     (unsigned long)va_arg(args, void *), 16,
                                     field_width, precision, flags);
                        continue;
 
                case 'n':
                        if (qualifier == 'l') {
                                long *ip = va_arg(args, long *);
                                *ip = (str - buf);
                        } else {
                                int *ip = va_arg(args, int *);
                                *ip = (str - buf);
                        }
                        continue;
 
                case '%':
                        *str++ = '%';
                        continue;
 
                        /* integer number formats - set up the flags and "break" */
                case 'o':
                        base = 8;
                        break;
 
                case 'X':
                        flags |= LARGE;
                case 'x':
                        base = 16;
                        break;
 
                case 'd':
                case 'i':
                        flags |= SIGN;
                case 'u':
                        break;
 
                default:
                        *str++ = '%';
                        if (*fmt)
                                *str++ = *fmt;
                        else
                                --fmt;
                        continue;
                }
                if (qualifier == 'l')
                        num = va_arg(args, unsigned long);
                else if (qualifier == 'h') {
                        num = (unsigned short)va_arg(args, int);
                        if (flags & SIGN)
                                num = (short)num;
                } else if (flags & SIGN)
                        num = va_arg(args, int);
                else
                        num = va_arg(args, unsigned int);
                str = number(str, num, base, field_width, precision, flags);
        }
        *str = '\0';
        return str - buf;
}
 
int sprintf(char *buf, const char *fmt, ...)
{
        va_list args;
        int i;
 
        va_start(args, fmt);
        i = vsprintf(buf, fmt, args);
        va_end(args);
        return i;
}
 
int printf(const char *fmt, ...)
{
        char printf_buf[1024];
        va_list args;
        int printed;
 
        va_start(args, fmt);
        printed = vsprintf(printf_buf, fmt, args);
        va_end(args);
 
        puts(printf_buf);
 
        return printed;
}

Browse

Tools

Subversion Repositories or1k_soc_on_altera_embedded_dev_kit

[/] [or1k_soc_on_altera_embedded_dev_kit/] [trunk/] [linux-2.6/] [linux-2.6.24/] [arch/] [x86/] [boot/] [printf.c] - Blame information for rev 17

Line No.	Rev	Author	Line
1	3	xianfeng	`/* -- linux-c -- ------------------------------------------------------- *`
2			`*`
3			`* Copyright (C) 1991, 1992 Linus Torvalds`
4			`* Copyright 2007 rPath, Inc. - All Rights Reserved`
5			`*`
6			`* This file is part of the Linux kernel, and is made available under`
7			`* the terms of the GNU General Public License version 2.`
8			`*`
9			`* ----------------------------------------------------------------------- */`
10
11			`/*`
12			`* arch/i386/boot/printf.c`
13			`*`
14			`* Oh, it's a waste of space, but oh-so-yummy for debugging. This`
15			`* version of printf() does not include 64-bit support. "Live with`
16			`* it."`
17			`*`
18			`*/`
19
20			`#include "boot.h"`
21
22			`static int skip_atoi(const char **s)`
23			`{`
24			`int i = 0;`
25
26			`while (isdigit(**s))`
27			`i = i * 10 + ((s)++) - '0';`
28			`return i;`
29			`}`
30
31			`#define ZEROPAD 1 /* pad with zero */`
32			`#define SIGN 2 /* unsigned/signed long */`
33			`#define PLUS 4 /* show plus */`
34			`#define SPACE 8 /* space if plus */`
35			`#define LEFT 16 /* left justified */`
36			`#define SPECIAL 32 /* 0x */`
37			`#define LARGE 64 /* use 'ABCDEF' instead of 'abcdef' */`
38
39			`#define do_div(n,base) ({ \`
40			`int __res; \`
41			`__res = ((unsigned long) n) % (unsigned) base; \`
42			`n = ((unsigned long) n) / (unsigned) base; \`
43			`__res; })`
44
45			`static char number(char str, long num, int base, int size, int precision,`
46			`int type)`
47			`{`
48			`char c, sign, tmp[66];`
49			`const char *digits = "0123456789abcdefghijklmnopqrstuvwxyz";`
50			`int i;`
51
52			`if (type & LARGE)`
53			`digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";`
54			`if (type & LEFT)`
55			`type &= ~ZEROPAD;`
56			`if (base < 2 \|\| base > 36)`
57			`return 0;`
58			`c = (type & ZEROPAD) ? '0' : ' ';`
59			`sign = 0;`
60			`if (type & SIGN) {`
61			`if (num < 0) {`
62			`sign = '-';`
63			`num = -num;`
64			`size--;`
65			`} else if (type & PLUS) {`
66			`sign = '+';`
67			`size--;`
68			`} else if (type & SPACE) {`
69			`sign = ' ';`
70			`size--;`
71			`}`
72			`}`
73			`if (type & SPECIAL) {`
74			`if (base == 16)`
75			`size -= 2;`
76			`else if (base == 8)`
77			`size--;`
78			`}`
79			`i = 0;`
80			`if (num == 0)`
81			`tmp[i++] = '0';`
82			`else`
83			`while (num != 0)`
84			`tmp[i++] = digits[do_div(num, base)];`
85			`if (i > precision)`
86			`precision = i;`
87			`size -= precision;`
88			`if (!(type & (ZEROPAD + LEFT)))`
89			`while (size-- > 0)`
90			`*str++ = ' ';`
91			`if (sign)`
92			`*str++ = sign;`
93			`if (type & SPECIAL) {`
94			`if (base == 8)`
95			`*str++ = '0';`
96			`else if (base == 16) {`
97			`*str++ = '0';`
98			`*str++ = digits[33];`
99			`}`
100			`}`
101			`if (!(type & LEFT))`
102			`while (size-- > 0)`
103			`*str++ = c;`
104			`while (i < precision--)`
105			`*str++ = '0';`
106			`while (i-- > 0)`
107			`*str++ = tmp[i];`
108			`while (size-- > 0)`
109			`*str++ = ' ';`
110			`return str;`
111			`}`
112
113			`int vsprintf(char buf, const char fmt, va_list args)`
114			`{`
115			`int len;`
116			`unsigned long num;`
117			`int i, base;`
118			`char *str;`
119			`const char *s;`
120
121			`int flags; /* flags to number() */`
122
123			`int field_width; /* width of output field */`
124			`int precision; /* min. # of digits for integers; max`
125			`number of chars for from string */`
126			`int qualifier; /* 'h', 'l', or 'L' for integer fields */`
127
128			`for (str = buf; *fmt; ++fmt) {`
129			`if (*fmt != '%') {`
130			`str++ = fmt;`
131			`continue;`
132			`}`
133
134			`/* process flags */`
135			`flags = 0;`
136			`repeat:`
137			`++fmt; /* this also skips first '%' */`
138			`switch (*fmt) {`
139			`case '-':`
140			`flags \|= LEFT;`
141			`goto repeat;`
142			`case '+':`
143			`flags \|= PLUS;`
144			`goto repeat;`
145			`case ' ':`
146			`flags \|= SPACE;`
147			`goto repeat;`
148			`case '#':`
149			`flags \|= SPECIAL;`
150			`goto repeat;`
151			`case '0':`
152			`flags \|= ZEROPAD;`
153			`goto repeat;`
154			`}`
155
156			`/* get field width */`
157			`field_width = -1;`
158			`if (isdigit(*fmt))`
159			`field_width = skip_atoi(&fmt);`
160			`else if (fmt == '') {`
161			`++fmt;`
162			`/* it's the next argument */`
163			`field_width = va_arg(args, int);`
164			`if (field_width < 0) {`
165			`field_width = -field_width;`
166			`flags \|= LEFT;`
167			`}`
168			`}`
169
170			`/* get the precision */`
171			`precision = -1;`
172			`if (*fmt == '.') {`
173			`++fmt;`
174			`if (isdigit(*fmt))`
175			`precision = skip_atoi(&fmt);`
176			`else if (fmt == '') {`
177			`++fmt;`
178			`/* it's the next argument */`
179			`precision = va_arg(args, int);`
180			`}`
181			`if (precision < 0)`
182			`precision = 0;`
183			`}`
184
185			`/* get the conversion qualifier */`
186			`qualifier = -1;`
187			`if (fmt == 'h' \|\| fmt == 'l' \|\| *fmt == 'L') {`
188			`qualifier = *fmt;`
189			`++fmt;`
190			`}`
191
192			`/* default base */`
193			`base = 10;`
194
195			`switch (*fmt) {`
196			`case 'c':`
197			`if (!(flags & LEFT))`
198			`while (--field_width > 0)`
199			`*str++ = ' ';`
200			`*str++ = (unsigned char)va_arg(args, int);`
201			`while (--field_width > 0)`
202			`*str++ = ' ';`
203			`continue;`
204
205			`case 's':`
206			`s = va_arg(args, char *);`
207			`len = strnlen(s, precision);`
208
209			`if (!(flags & LEFT))`
210			`while (len < field_width--)`
211			`*str++ = ' ';`
212			`for (i = 0; i < len; ++i)`
213			`str++ = s++;`
214			`while (len < field_width--)`
215			`*str++ = ' ';`
216			`continue;`
217
218			`case 'p':`
219			`if (field_width == -1) {`
220			`field_width = 2 * sizeof(void *);`
221			`flags \|= ZEROPAD;`
222			`}`
223			`str = number(str,`
224			`(unsigned long)va_arg(args, void *), 16,`
225			`field_width, precision, flags);`
226			`continue;`
227
228			`case 'n':`
229			`if (qualifier == 'l') {`
230			`long ip = va_arg(args, long );`
231			`*ip = (str - buf);`
232			`} else {`
233			`int ip = va_arg(args, int );`
234			`*ip = (str - buf);`
235			`}`
236			`continue;`
237
238			`case '%':`
239			`*str++ = '%';`
240			`continue;`
241
242			`/* integer number formats - set up the flags and "break" */`
243			`case 'o':`
244			`base = 8;`
245			`break;`
246
247			`case 'X':`
248			`flags \|= LARGE;`
249			`case 'x':`
250			`base = 16;`
251			`break;`
252
253			`case 'd':`
254			`case 'i':`
255			`flags \|= SIGN;`
256			`case 'u':`
257			`break;`
258
259			`default:`
260			`*str++ = '%';`
261			`if (*fmt)`
262			`str++ = fmt;`
263			`else`
264			`--fmt;`
265			`continue;`
266			`}`
267			`if (qualifier == 'l')`
268			`num = va_arg(args, unsigned long);`
269			`else if (qualifier == 'h') {`
270			`num = (unsigned short)va_arg(args, int);`
271			`if (flags & SIGN)`
272			`num = (short)num;`
273			`} else if (flags & SIGN)`
274			`num = va_arg(args, int);`
275			`else`
276			`num = va_arg(args, unsigned int);`
277			`str = number(str, num, base, field_width, precision, flags);`
278			`}`
279			`*str = '\0';`
280			`return str - buf;`
281			`}`
282
283			`int sprintf(char buf, const char fmt, ...)`
284			`{`
285			`va_list args;`
286			`int i;`
287
288			`va_start(args, fmt);`
289			`i = vsprintf(buf, fmt, args);`
290			`va_end(args);`
291			`return i;`
292			`}`
293
294			`int printf(const char *fmt, ...)`
295			`{`
296			`char printf_buf[1024];`
297			`va_list args;`
298			`int printed;`
299
300			`va_start(args, fmt);`
301			`printed = vsprintf(printf_buf, fmt, args);`
302			`va_end(args);`
303
304			`puts(printf_buf);`
305
306			`return printed;`
307			`}`