?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
use the override options if specified
[AROS.git] / compiler / fmtprintf / fmtprintf.c
blob3338b43ce8941018c35719f8f2f94fa4c33bca75
1 /*
2 Copyright © 2018, The AROS Development Team. All rights reserved.
3 $Id:$
4
5 Common code block to format a string like printf().
6 */
7
8 /*
9 * This code is used by debug functions during early startup.
10 * Please keep it self-contained, at least when compiled with -DSTDC_STATIC.
11 */
12
13 size_t outcount=0;
14
15 while (*format)
16 {
17 if (*format == '%')
18 {
19 static const char flagc[] = { '#', '0', '-', ' ', '+' };
20 size_t width=0, preci=ULONG_MAX, flags=0; /* Specifications */
21 char type, subtype = 'i';
22 #ifdef AROS_HAVE_LONG_LONG
23 char lltype=0;
24 #endif
25 char buffer1[2]; /* Signs and that like */
26 char buffer[REQUIREDBUFFER]; /* The body */
27 char *buffer2 = buffer; /* So we can set this to any other strings */
28 size_t size1 = 0, size2 = 0; /* How many chars in buffer? */
29 const char *ptr = format + 1; /* pointer to format string */
30 size_t i, pad; /* Some temporary variables */
31 #if defined(FULL_SPECIFIERS)
32 union { /* floating point arguments %[aAeEfFgG] */
33 double dbl;
34 long double ldbl;
35 } fparg;
36 #endif
37 do /* read flags */
38 for (i = 0; i < sizeof(flagc); i++)
39 if (flagc[i] == *ptr)
40 {
41 flags |= 1<<i;
42 ptr++;
43 break;
44 }
45 while (i < sizeof(flagc));
46
47 if (*ptr == '*') /* read width from arguments */
48 {
49 signed int a;
50 ptr++;
51 a = va_arg(args, signed int);
52 if (a < 0)
53 {
54 flags |= LALIGNFLAG;
55 width = -a;
56 }
57 else
58 width = a;
59 }else
60 while (isdigit(*ptr))
61 width = width * 10 + (*ptr++ - '0');
62
63 if (*ptr == '.')
64 {
65 ptr++;
66 if (*ptr == '*') /* read precision from arguments */
67 {
68 signed int a;
69 ptr++;
70 a = va_arg(args, signed int);
71 if (a >= 0)
72 preci = a;
73 }else
74 {
75 preci = 0;
76 while (isdigit(*ptr))
77 preci = preci * 10 + (*ptr++ - '0');
78 }
79 }
80
81 if (*ptr == 'h' || *ptr == 'l' || *ptr == 'L' || *ptr == 'z')
82 subtype=*ptr++;
83
84 if (*ptr == 'l' || *ptr == 'q')
85 {
86 #ifdef AROS_HAVE_LONG_LONG
87 lltype = 1;
88 subtype = 'l';
89 #endif
90 ptr++;
91 }
92
93 type = *ptr++;
94
95 switch(type)
96 {
97 case 'd':
98 case 'i':
99 case 'o':
100 case 'p':
101 case 'u':
102 case 'x':
103 case 'X':
104 {
105 #ifdef AROS_HAVE_LONG_LONG
106 unsigned long long llv = 0;
107 #endif
108 unsigned long v = 0;
109 int base = 10;
110
111 if (type=='p') /* This is written as 0x08lx (or 0x016lx on 64 bits) */
112 {
113 subtype = 'l';
114 type = 'x';
115 if (!width)
116 width = sizeof(void *) * 2;
117 flags |= ZEROPADFLAG;
118 }
119
120 if (type=='d' || type=='i') /* These are signed */
121 {
122 signed long v2;
123
124 if (subtype=='l')
125 {
126 #ifdef AROS_HAVE_LONG_LONG
127 if (lltype)
128 {
129 signed long long llv2;
130
131 llv2 = va_arg(args, signed long long);
132 if (llv2 < 0)
133 {
134 llv = - llv2;
135 v2 = -1; /* Assign a dummy value to v2 in order to process sign below */
136 }
137 else
138 {
139 llv = llv2;
140 v2 = llv2 ? 1 : 0;
141 }
142 }
143 else
144 #endif
145 v2=va_arg(args, signed long);
146 }
147 else if (subtype == 'z')
148 v2 = va_arg(args, size_t);
149 else
150 v2 = va_arg(args, signed int);
151
152 if (v2 < 0)
153 {
154 buffer1[size1++] = '-';
155 v = -v2;
156 }
157 else
158 {
159 if (flags & SIGNFLAG)
160 buffer1[size1++] = '+';
161 else if (flags & BLANKFLAG)
162 buffer1[size1++] = ' ';
163 v = v2;
164 }
165 }
166 else /* These are unsigned */
167 {
168 if (subtype=='l')
169 {
170 #ifdef AROS_HAVE_LONG_LONG
171 if (lltype)
172 llv = va_arg(args, unsigned long long);
173 else
174 #endif
175 v = va_arg(args, unsigned long);
176 }
177 else if (subtype == 'z')
178 v = va_arg(args, size_t);
179 else
180 v = va_arg(args, unsigned int);
181
182 if (flags & ALTERNATEFLAG)
183 {
184 if (type == 'o' && preci && v)
185 buffer1[size1++] = '0';
186 if ((type == 'x' || type == 'X') && v)
187 {
188 buffer1[size1++] = '0';
189 buffer1[size1++] = type;
190 }
191 }
192 }
193
194 buffer2 = &buffer[sizeof(buffer)]; /* Calculate body string */
195
196 #ifdef AROS_HAVE_LONG_LONG
197 /*
198 * For long long type we have actual value in llv.
199 * For long we have actual value in v.
200 * This avoids slow 64-bit operations on 32-bit processors
201 * when not needed.
202 */
203 if (lltype)
204 size2 = format_longlong(buffer2, type, base, llv);
205 else
206 #endif
207 size2 = format_long(buffer2, type, base, v);
208 /* Position to the beginning of the string */
209 buffer2 -= size2;
210
211 if (preci == ULONG_MAX) /* default */
212 preci = 0;
213 else
214 flags &= ~ZEROPADFLAG;
215 break;
216 }
217
218 case 'c':
219 if (subtype=='l')
220 {
221 #ifdef AROS_HAVE_LONG_LONG
222 if (lltype)
223 *buffer2 = va_arg(args, long long);
224 else
225 #endif
226 *buffer2 = va_arg(args, long);
227 }
228 else
229 *buffer2 = va_arg(args, int);
230
231 size2 = 1;
232 preci = 0;
233 break;
234
235 case 's':
236 buffer2 = va_arg(args, char *);
237 if (!buffer2)
238 buffer2 = "(null)";
239 size2 = FMTPRINTF_STRLEN(buffer2);
240 size2 = size2 <= preci ? size2 : preci;
241 preci = 0;
242 break;
243
244 case 'b':
245 buffer2 = BADDR(va_arg(args, BPTR));
246 if (buffer2)
247 #if AROS_FAST_BSTR
248 size2 = FMTPRINTF_STRLEN(buffer2);
249 #else
250 size2 = *(unsigned char *)buffer2++;
251 #endif
252 else
253 {
254 buffer2 = "(null)";
255 size2 = 6;
256 }
257
258 size2 = size2 <= preci ? size2 : preci;
259 preci = 0;
260 break;
261
262 #ifdef FULL_SPECIFIERS
263 case 'a':
264 case 'A':
265 case 'f':
266 case 'F':
267 case 'e':
268 case 'E':
269 case 'g':
270 case 'G':
271 {
272 char killzeros=0, sign=0; /* some flags */
273 int ex1, ex2; /* Some temporary variables */
274 size_t size, dnum, dreq;
275 char *udstr = NULL;
276
277 if (subtype == 'L')
278 {
279 flags |= LDBLFLAG;
280 fparg.ldbl = va_arg(args, long double);
281 } else {
282 flags &= ~LDBLFLAG;
283 fparg.dbl = va_arg(args, double);
284 }
285
286 if (isinf(fparg.dbl))
287 {
288 if (fparg.dbl>0)
289 udstr = "+inf";
290 else
291 udstr = "-inf";
292 } else if (isnan(fparg.dbl))
293 udstr = "NaN";
294
295 if (udstr != NULL)
296 {
297 size2 = FMTPRINTF_STRLEN(udstr);
298 preci = 0;
299 buffer2 = udstr;
300 break; }
301
302 if (preci == ULONG_MAX) /* old default */
303 preci = 6; /* new default */
304
305 if (((subtype != 'L') && (fparg.dbl < 0.0)) || ((subtype == 'L') && (fparg.ldbl < 0.0)))
306 {
307 sign = '-';
308 if (subtype == 'L')
309 fparg.ldbl = -fparg.ldbl;
310 else
311 fparg.dbl = -fparg.dbl;
312 } else {
313 if (flags & SIGNFLAG)
314 sign = '+';
315 else if (flags & BLANKFLAG)
316 sign = ' ';
317 }
318
319 ex1 = 0;
320 if (tolower(type) != 'a')
321 {
322 if (subtype != 'L')
323 {
324 if (fparg.dbl != 0.0)
325 {
326 ex1 = log10(fparg.dbl);
327 if (fparg.dbl < 1.0)
328 fparg.dbl = fparg.dbl * pow(10,- --ex1); /* Caution: (int)log10(.5)!=-1 */
329 else
330 fparg.dbl=fparg.dbl / pow(10, ex1);
331 if (fparg.dbl < 1.0) /* adjust if we are too low (log10(.1)=-.999999999) */
332 {
333 fparg.dbl *= 10.0; /* luckily this cannot happen with FLT_MAX and FLT_MIN */
334 ex1--; /* The case too high (log(10.)=.999999999) is done later */
335 }
336 }
337 } else {
338 if (fparg.ldbl != 0.0)
339 {
340 ex1 = log10l(fparg.ldbl);
341 if (fparg.ldbl < 1.0)
342 fparg.ldbl= fparg.ldbl * powl(10,- --ex1);
343 else
344 fparg.ldbl=fparg.ldbl / powl(10, ex1);
345 if (fparg.ldbl < 1.0)
346 {
347 fparg.ldbl *= 10.0;
348 ex1--;
349 }
350 }
351 }
352 }
353
354 ex2 = preci;
355 if (tolower(type) == 'f')
356 ex2 += ex1;
357 if (tolower(type) == 'g')
358 ex2--;
359 if (subtype != 'L')
360 {
361 fparg.dbl += .5 / pow(10, ex2 < MINFLOATSIZE ? ex2 : MINFLOATSIZE); /* Round up */
362 if (fparg.dbl >= 10.0) /* Adjusts log10(10.)=.999999999 too */
363 {
364 fparg.dbl /= 10.0;
365 ex1++;
366 }
367 } else {
368 fparg.ldbl += .5 / powl(10, ex2 < MINFLOATSIZE ? ex2 : MINFLOATSIZE); /* Round up */
369 if (fparg.ldbl >= 10.0) /* Adjusts log10(10.)=.999999999 too */
370 {
371 fparg.ldbl /= 10.0;
372 ex1++;
373 }
374 }
375
376 if (tolower(type) == 'g') /* This changes to one of the other types */
377 {
378 if (ex1 < (signed long)preci && ex1 >= -4)
379 {
380 type = 'f';
381 preci -= ex1;
382 } else
383 type = type == 'g' ? 'e' : 'E';
384 preci--;
385 if (!(flags & ALTERNATEFLAG))
386 killzeros = 1; /* set flag to kill trailing zeros */
387 }
388
389 dreq = preci + 1; /* Calculate number of decimal places required */
390 if (type == 'f')
391 dreq += ex1; /* even more before the decimal point */
392
393 dnum = 0;
394 while (dnum < dreq && dnum < MINFLOATSIZE) /* Calculate all decimal places needed */
395 {
396 if (subtype != 'L')
397 {
398 buffer[dnum++] = (char)fparg.dbl + '0';
399 fparg.dbl = (fparg.dbl - (double)(char)fparg.dbl) * 10.0;
400 } else {
401 buffer[dnum++] = (char)fparg.ldbl + '0';
402 fparg.ldbl = (fparg.ldbl - (long double)(char)fparg.ldbl) * 10.0;
403 }
404 }
405 if (killzeros) /* Kill trailing zeros if possible */
406 while(preci && (dreq-- > dnum || buffer[dreq] == '0'))
407 preci--;
408
409 if (tolower(type) == 'f') /* Calculate actual size of string (without sign) */
410 {
411 size = preci + 1; /* numbers after decimal point + 1 before */
412 if (ex1 > 0)
413 size += ex1; /* numbers >= 10 */
414 if (preci || flags & ALTERNATEFLAG)
415 size++; /* 1 for decimal point */
416 }else
417 {
418 size = preci + 5; /* 1 for the number before the decimal point, and 4 for the exponent */
419 if (preci || flags & ALTERNATEFLAG)
420 size++;
421 if (ex1 > 99 || ex1 < -99)
422 size++; /* exponent needs an extra decimal place */
423 }
424
425 pad = size + (sign != 0);
426 pad = pad >= width ? 0 : width - pad;
427
428 if (sign && flags & ZEROPADFLAG)
429 FMTPRINTF_COUT(sign);
430
431 if (!(flags & LALIGNFLAG))
432 for (i = 0; i < pad; i++)
433 FMTPRINTF_COUT(flags & ZEROPADFLAG ? '0' : ' ');
434
435 if (sign && !(flags & ZEROPADFLAG))
436 FMTPRINTF_COUT(sign);
437
438 dreq = 0;
439 if (tolower(type) == 'a')
440 {
441 // TODO: Implement hexfloat literals
442 FMTPRINTF_COUT('0');
443 FMTPRINTF_COUT('x');
444 FMTPRINTF_COUT('0');
445 FMTPRINTF_COUT('.');
446 FMTPRINTF_COUT('0');
447 if (type=='A')
448 FMTPRINTF_COUT('P');
449 else
450 FMTPRINTF_COUT('p');
451 FMTPRINTF_COUT('0');
452 } else if (tolower(type) == 'f') {
453 if (ex1 < 0)
454 FMTPRINTF_COUT('0');
455 else
456 while(ex1 >= 0)
457 {
458 FMTPRINTF_COUT(dreq < dnum ? buffer[dreq++] : '0');
459 ex1--;
460 }
461 if (preci || flags & ALTERNATEFLAG)
462 {
463 FMTPRINTF_COUT(FMTPRINTF_DECIMALPOINT[0]);
464 while(preci--)
465 if (++ex1 < 0)
466 FMTPRINTF_COUT('0');
467 else
468 FMTPRINTF_COUT(dreq < dnum ? buffer[dreq++] : '0');
469 }
470 } else {
471 FMTPRINTF_COUT(buffer[dreq++]);
472 if (preci || flags & ALTERNATEFLAG)
473 {
474 FMTPRINTF_COUT(FMTPRINTF_DECIMALPOINT[0]);
475 while(preci--)
476 FMTPRINTF_COUT(dreq < dnum ? buffer[dreq++] : '0');
477 }
478 FMTPRINTF_COUT(type);
479 if (ex1 < 0)
480 {
481 FMTPRINTF_COUT('-');
482 ex1 = -ex1;
483 }
484 else
485 FMTPRINTF_COUT('+');
486 if (ex1 > 99)
487 FMTPRINTF_COUT(ex1 / 100 + '0');
488 FMTPRINTF_COUT(ex1 / 10 % 10 + '0');
489 FMTPRINTF_COUT(ex1 % 10 + '0');
490 }
491
492 if (flags & LALIGNFLAG)
493 for (i = 0; i < pad; i++)
494 FMTPRINTF_COUT(' ');
495
496 width = preci = 0; /* Everything already done */
497 break;
498 }
499 #endif
500 case '%':
501 buffer2 = "%";
502 size2 = 1;
503 preci = 0;
504 break;
505 case 'n':
506 *va_arg(args, int *) = outcount;
507 width = preci = 0;
508 break;
509 default:
510 if (!type)
511 ptr--; /* We've gone too far - step one back */
512 buffer2 = (char *)format;
513 size2 = ptr - format;
514 width = preci = 0;
515 break;
516 }
517 pad = size1 + (size2 >= preci ? size2 : preci); /* Calculate the number of characters */
518 pad = pad >= width ? 0 : width - pad; /* and the number of resulting pad bytes */
519
520 if (flags & ZEROPADFLAG) /* print sign and that like */
521 for (i = 0; i < size1; i++)
522 FMTPRINTF_COUT(buffer1[i]);
523
524 if (!(flags & LALIGNFLAG)) /* Pad left */
525 for (i = 0; i < pad; i++)
526 FMTPRINTF_COUT(flags & ZEROPADFLAG ? '0' : ' ');
527
528 if (!(flags & ZEROPADFLAG)) /* print sign if not zero padded */
529 for (i = 0; i < size1; i++)
530 FMTPRINTF_COUT(buffer1[i]);
531
532 for (i = size2; i < preci; i++) /* extend to precision */
533 FMTPRINTF_COUT('0');
534
535 for (i = 0; i < size2; i++) /* print body */
536 FMTPRINTF_COUT(buffer2[i]);
537
538 if (flags & LALIGNFLAG) /* Pad right */
539 for (i = 0; i < pad; i++)
540 FMTPRINTF_COUT(' ');
541
542 format = ptr;
543 }
544 else
545 FMTPRINTF_COUT(*format++);
546 }
Mirror of AROS' svn.