Loading...
1// SPDX-License-Identifier: GPL-2.0-only
2/* -*- linux-c -*- ------------------------------------------------------- *
3 *
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 * Copyright 2007 rPath, Inc. - All Rights Reserved
6 *
7 * ----------------------------------------------------------------------- */
8
9/*
10 * Oh, it's a waste of space, but oh-so-yummy for debugging. This
11 * version of printf() does not include 64-bit support. "Live with
12 * it."
13 *
14 */
15
16#include "boot.h"
17
18static int skip_atoi(const char **s)
19{
20 int i = 0;
21
22 while (isdigit(**s))
23 i = i * 10 + *((*s)++) - '0';
24 return i;
25}
26
27#define ZEROPAD 1 /* pad with zero */
28#define SIGN 2 /* unsigned/signed long */
29#define PLUS 4 /* show plus */
30#define SPACE 8 /* space if plus */
31#define LEFT 16 /* left justified */
32#define SMALL 32 /* Must be 32 == 0x20 */
33#define SPECIAL 64 /* 0x */
34
35#define __do_div(n, base) ({ \
36int __res; \
37__res = ((unsigned long) n) % (unsigned) base; \
38n = ((unsigned long) n) / (unsigned) base; \
39__res; })
40
41static char *number(char *str, long num, int base, int size, int precision,
42 int type)
43{
44 /* we are called with base 8, 10 or 16, only, thus don't need "G..." */
45 static const char digits[16] = "0123456789ABCDEF"; /* "GHIJKLMNOPQRSTUVWXYZ"; */
46
47 char tmp[66];
48 char c, sign, locase;
49 int i;
50
51 /* locase = 0 or 0x20. ORing digits or letters with 'locase'
52 * produces same digits or (maybe lowercased) letters */
53 locase = (type & SMALL);
54 if (type & LEFT)
55 type &= ~ZEROPAD;
56 if (base < 2 || base > 16)
57 return NULL;
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)] | locase);
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++ = ('X' | locase);
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
113int 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 |= SMALL;
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
283int 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
294int 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}
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
20static 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) ({ \
38int __res; \
39__res = ((unsigned long) n) % (unsigned) base; \
40n = ((unsigned long) n) / (unsigned) base; \
41__res; })
42
43static 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 > 16)
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
115int 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
285int 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
296int 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}