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