Graphviz 14.1.1~dev.20251208.1034
Loading...
Searching...
No Matches
sfprint.c
Go to the documentation of this file.
1/*************************************************************************
2 * Copyright (c) 2011 AT&T Intellectual Property
3 * All rights reserved. This program and the accompanying materials
4 * are made available under the terms of the Eclipse Public License v1.0
5 * which accompanies this distribution, and is available at
6 * https://www.eclipse.org/legal/epl-v10.html
7 *
8 * Contributors: Details at https://graphviz.org
9 *************************************************************************/
10
11#include <assert.h>
12#include <inttypes.h>
13#include <sfio/sfhdr.h>
14#include <stddef.h>
15#include <stdio.h>
16#include <string.h>
17#include <util/gv_ctype.h>
18#include <util/gv_math.h>
19
20/* The engine for formatting data
21**
22** Written by Kiem-Phong Vo.
23*/
24
25#define HIGHBITI (~((~0u) >> 1))
26#define HIGHBITL (~((~0ull) >> 1))
27
28#define SFFMT_PREFIX (SFFMT_MINUS|SFFMT_SIGN|SFFMT_BLANK)
29
30#define FPRECIS 6 /* default precision for floats */
31
36int sfprint(FILE *f, Sffmt_t *format) {
37 int v = 0, n_s, base, fmt, flags;
38 long long lv;
39 char *sp, *ssp, *endsp, *ep, *endep;
40 int dot, width, precis, n, n_output = 0;
41 int sign, decpt;
42 ssize_t size;
43 double dval;
44 char *tls[2], **ls; /* for %..[separ]s */
45 const char *t_str; /* stuff between () */
46 ssize_t n_str; /* its length */
47
48 Argv_t argv; /* for extf to return value */
49 Sffmt_t *ft; /* format environment */
50
51 int argn; /* arg position and number */
52
53#define SLACK 1024
54 char buf[SF_MAXDIGITS + SLACK];
55 char decimal = 0, thousand = 0;
56
57#define SFputc(f,c) do { \
58 if (putc((c), (f)) == EOF) { \
59 goto done; \
60 } \
61} while (0)
62#define SFnputc(f,c,n) do { \
63 for (int i_ = 0; i_ < (n); ++i_) { \
64 if (putc((c), (f)) == EOF) { \
65 goto done; \
66 } \
67 } \
68 (n) = 0; \
69} while (0)
70#define SFwrite(f,s,n) do { \
71 if ((n) > 0 && fwrite((s), (size_t)(n), 1, (f)) < 1) { \
72 goto done; \
73 } \
74} while (0)
75
76 tls[1] = NULL;
77
78 ft = NULL;
79
80 argn = -1;
81
82 // stack a new environment
83 argv.ft = format;
84 assert(argv.ft != NULL);
85 assert(argv.ft->form != NULL);
86
87 const char *form = argv.ft->form;
88
89 ft = argv.ft;
90
91 while ((n = *form)) {
92 if (n != '%') { /* collect the non-pattern chars */
93 size_t form_len = 1;
94 while (form[form_len] != '\0' && form[form_len] != '%')
95 ++form_len;
96 SFwrite(f, form, form_len);
97 form += form_len;
98 continue;
99 } else
100 form += 1;
101
102 flags = 0;
103 size = width = precis = base = n_s = -1;
104 ssp = _Sfdigits;
105 endep = ep = NULL;
106 endsp = sp = buf + (sizeof(buf) - 1);
107 t_str = NULL;
108 n_str = dot = 0;
109
110 loop_flags: /* LOOP FOR \0, %, FLAGS, WIDTH, PRECISION, BASE, TYPE */
111 switch ((fmt = *form++)) {
112 case '\0':
113 SFputc(f, '%');
114 goto done;
115 case '%':
116 SFputc(f, '%');
117 continue;
118
119 case LEFTP: /* get the type enclosed in balanced parens */
120 t_str = form;
121 for (v = 1;;) {
122 switch (*form++) {
123 case 0: /* not balancable, retract */
124 form = t_str;
125 t_str = NULL;
126 n_str = 0;
127 goto loop_flags;
128 case LEFTP: /* increasing nested level */
129 v += 1;
130 continue;
131 case RIGHTP: /* decreasing nested level */
132 if ((v -= 1) != 0)
133 continue;
134 if (*t_str != '*')
135 n_str = (form - 1) - t_str;
136 else {
137 ++argn;
138
139 FMTSET(ft, form, LEFTP, 0, 0, 0, 0, 0, NULL, 0);
140 n = ft->extf(&argv, ft);
141 if (n < 0)
142 goto done;
143 assert(ft->flags & SFFMT_VALUE);
144 if ((t_str = argv.s) && (n_str = (int)ft->size) < 0)
145 n_str = (ssize_t)strlen(t_str);
146 }
147 goto loop_flags;
148 default:
149 // skip over
150 break;
151 }
152 }
153
154 case '-':
155 flags = (flags & ~SFFMT_ZERO) | SFFMT_LEFT;
156 goto loop_flags;
157 case '0':
158 if (!(flags & SFFMT_LEFT))
159 flags |= SFFMT_ZERO;
160 goto loop_flags;
161 case ' ':
162 if (!(flags & SFFMT_SIGN))
163 flags |= SFFMT_BLANK;
164 goto loop_flags;
165 case '+':
166 flags = (flags & ~SFFMT_BLANK) | SFFMT_SIGN;
167 goto loop_flags;
168 case '#':
169 flags |= SFFMT_ALTER;
170 goto loop_flags;
171 case QUOTE:
172 SFSETLOCALE(decimal, thousand);
173 if (thousand)
174 flags |= SFFMT_THOUSAND;
175 goto loop_flags;
176
177 case '.':
178 dot += 1;
179 if (dot == 1) { /* so base can be defined without setting precis */
180 if (*form != '.')
181 precis = 0;
182 } else if (dot == 2) {
183 base = 0; /* for %s,%c */
184 if (*form == 'c' || *form == 's')
185 goto loop_flags;
186 if (*form && !gv_isalnum(*form) &&
187 (form[1] == 'c' || form[1] == 's')) {
188 if (*form == '*')
189 goto do_star;
190 else {
191 base = *form++;
192 goto loop_flags;
193 }
194 }
195 }
196
197 if (gv_isdigit(*form)) {
198 fmt = *form++;
199 goto dot_size;
200 } else if (*form != '*')
201 goto loop_flags;
202 do_star:
203 form += 1; /* fall through */
204 case '*':
205 form = _Sffmtintf(form);
206 n = ++argn;
207
208 FMTSET(ft, form, '.', dot, 0, 0, 0, 0, NULL, 0);
209 if (ft->extf(&argv, ft) < 0)
210 goto done;
211 assert(ft->flags & SFFMT_VALUE);
212 v = argv.i;
213 goto dot_set;
214
215 case '1':
216 case '2':
217 case '3':
218 case '4':
219 case '5':
220 case '6':
221 case '7':
222 case '8':
223 case '9':
224 dot_size:
225 for (v = fmt - '0'; gv_isdigit(*form); ++form)
226 v = v * 10 + (*form - '0');
227 dot_set:
228 if (dot == 0) {
229 if ((width = v) < 0) {
230 width = -width;
231 flags = (flags & ~SFFMT_ZERO) | SFFMT_LEFT;
232 }
233 } else if (dot == 1)
234 precis = v;
235 else if (dot == 2)
236 base = v;
237 goto loop_flags;
238
239 case 'I': /* object length */
240 size = 0;
241 flags = (flags & ~SFFMT_TYPES) | SFFMT_IFLAG;
242 if (gv_isdigit(*form)) {
243 for (n = *form; gv_isdigit(n); n = *++form)
244 size = size * 10 + (n - '0');
245 } else if (*form == '*') {
246 form = _Sffmtintf(form + 1);
247 n = ++argn;
248
249 FMTSET(ft, form, 'I', sizeof(int), 0, 0, 0, 0, NULL, 0);
250 if (ft->extf(&argv, ft) < 0)
251 goto done;
252 assert(ft->flags & SFFMT_VALUE);
253 size = argv.i;
254 }
255 goto loop_flags;
256
257 case 'l':
258 size = -1;
259 flags &= ~SFFMT_TYPES;
260 if (*form == 'l') {
261 form += 1;
262 flags |= SFFMT_LLONG;
263 } else
264 flags |= SFFMT_LONG;
265 goto loop_flags;
266 case 'h':
267 size = -1;
268 flags &= ~SFFMT_TYPES;
269 if (*form == 'h') {
270 form += 1;
271 flags |= SFFMT_SSHORT;
272 } else
273 flags |= SFFMT_SHORT;
274 goto loop_flags;
275 case 'L':
276 size = -1;
277 flags = (flags & ~SFFMT_TYPES) | SFFMT_LDOUBLE;
278 goto loop_flags;
279
280 case 'j':
281 size = -1;
282 flags = (flags & ~SFFMT_TYPES) | SFFMT_JFLAG;
283 goto loop_flags;
284 case 'z':
285 size = -1;
286 flags = (flags & ~SFFMT_TYPES) | SFFMT_ZFLAG;
287 goto loop_flags;
288 case 't':
289 size = -1;
290 flags = (flags & ~SFFMT_TYPES) | SFFMT_TFLAG;
291 goto loop_flags;
292 default: // continue with logic below
293 break;
294 }
295
296 /* set the correct size */
297 if (flags & (SFFMT_TYPES & ~SFFMT_IFLAG)) {
298 if (_Sftype[fmt] & (SFFMT_INT | SFFMT_UINT)) {
299 size = (flags & SFFMT_LLONG) ? (ssize_t)sizeof(long long) :
300 (flags & SFFMT_LONG) ? (ssize_t)sizeof(long) :
301 (flags & SFFMT_SHORT) ? (ssize_t)sizeof(short) :
302 (flags & SFFMT_SSHORT) ? (ssize_t)sizeof(char) :
303 (flags & SFFMT_JFLAG) ? (ssize_t)sizeof(long long) :
304 (flags & SFFMT_TFLAG) ? (ssize_t)sizeof(ptrdiff_t) :
305 (flags & SFFMT_ZFLAG) ? (ssize_t)sizeof(size_t) : -1;
306 } else if (_Sftype[fmt] & SFFMT_FLOAT) {
307 size = (flags & SFFMT_LDOUBLE) ? (ssize_t)sizeof(long double) :
308 (flags & (SFFMT_LONG | SFFMT_LLONG)) ? (ssize_t)sizeof(double) : -1;
309 }
310 }
311
312 ++argn;
313 FMTSET(ft, form, fmt, size, flags, width, precis, base, t_str, n_str);
314 v = ft->extf(&argv, ft);
315
316 if (v < 0)
317 goto done;
318 else if (v == 0) { // extf did not output
319 FMTGET(ft, form, fmt, size, flags, width, precis, base);
320 assert(ft->flags & SFFMT_VALUE);
321 } else if (v > 0) { // extf output v bytes
322 n_output += v;
323 continue;
324 }
325
326 switch (fmt) { /* PRINTF DIRECTIVES */
327 default: /* unknown directive */
328 form -= 1;
329 argn -= 1;
330 continue;
331
332 case 's':
333 if (base >= 0) { /* list of strings */
334 if (!(ls = argv.sp) || !ls[0])
335 continue;
336 } else {
337 if (!(sp = argv.s))
338 sp = "(null)";
339 ls = tls;
340 tls[0] = sp;
341 }
342 for (sp = *ls;;) {
343 if ((v = size) >= 0) {
344 if (precis >= 0 && v > precis)
345 v = precis;
346 } else if (precis < 0)
347 v = strlen(sp);
348 else { /* precis >= 0 means min(strlen,precis) */
349 for (v = 0; v < precis; ++v)
350 if (sp[v] == 0)
351 break;
352 }
353 if ((n = width - v) > 0) {
354 if (flags & SFFMT_ZERO) {
355 SFnputc(f, '0', n);
356 } else if (!(flags & SFFMT_LEFT)) {
357 SFnputc(f, ' ', n);
358 }
359 }
360 SFwrite(f, sp, v);
361 if (n > 0) {
362 SFnputc(f, ' ', n);
363 }
364 if (!(sp = *++ls))
365 break;
366 else if (base > 0) {
367 SFputc(f, base);
368 }
369 }
370 continue;
371
372 case 'c': /* an array of characters */
373 if (base >= 0) {
374 if (!(sp = argv.s) || !sp[0])
375 continue;
376 } else {
377 fmt = (int) argv.c;
378 sp = buf;
379 buf[0] = fmt;
380 buf[1] = 0;
381 }
382 if (precis <= 0)
383 precis = 1;
384 for (fmt = *sp;;) {
385 if ((n = width - precis) > 0 && !(flags & SFFMT_LEFT)) {
386 SFnputc(f, ' ', n);
387 }
388 v = precis;
389 SFnputc(f, fmt, v);
390 if (n > 0) {
391 SFnputc(f, ' ', n);
392 }
393 if (!(fmt = *++sp))
394 break;
395 else if (base > 0) {
396 SFputc(f, base);
397 }
398 }
399 continue;
400
401 case 'p': /* pointer value */
402 fmt = 'x';
403 base = 16;
404 n_s = 15;
405 n = 4;
406 flags =
407 (flags & ~(SFFMT_SIGN | SFFMT_BLANK | SFFMT_ZERO)) |
408 SFFMT_ALTER;
409 if (sizeof(void*) > sizeof(int)) {
410 lv = (long long)(intptr_t)argv.vp;
411 goto long_cvt;
412 } else {
413 v = (int)(intptr_t)argv.vp;
414 goto int_cvt;
415 }
416 case 'o':
417 base = 8;
418 n_s = 7;
419 n = 3;
420 flags &= ~(SFFMT_SIGN | SFFMT_BLANK);
421 goto int_arg;
422 case 'X':
423 ssp = "0123456789ABCDEF";
424 // fall through
425 case 'x':
426 base = 16;
427 n_s = 15;
428 n = 4;
429 flags &= ~(SFFMT_SIGN | SFFMT_BLANK);
430 goto int_arg;
431 case 'i':
432 fmt = 'd';
433 goto d_format;
434 case 'u':
435 flags &= ~(SFFMT_SIGN | SFFMT_BLANK);
436 // fall through
437 case 'd':
438 d_format:
439 if (base < 2 || base > SF_RADIX)
440 base = 10;
441 if ((base & (n_s = base - 1)) == 0) {
442 if (base < 8)
443 n = base < 4 ? 1 : 2;
444 else if (base < 32)
445 n = base < 16 ? 3 : 4;
446 else
447 n = base < 64 ? 5 : 6;
448 } else
449 n_s = base == 10 ? -1 : 0;
450
451 int_arg:
452 if ((sizeof(long) > sizeof(int) || sizeof(void*) > sizeof(int))
453 && FMTCMP(size, long long, long long)) {
454 lv = argv.ll;
455 goto long_cvt;
456 } else if ((sizeof(long) > sizeof(int) || sizeof(void*) > sizeof(int))
457 && FMTCMP(size, long, long long)) {
458 if (fmt == 'd')
459 lv = (long long)argv.l;
460 else
461 lv = (long long)(ulong)argv.l;
462 long_cvt:
463 if (lv == 0 && precis == 0)
464 break;
465 if (lv < 0 && fmt == 'd') {
466 flags |= SFFMT_MINUS;
467 if ((unsigned long long)lv == HIGHBITL) { // avoid overflow
468 lv = (long long)(HIGHBITL / (unsigned long long)base);
469 *--sp = _Sfdigits[HIGHBITL -
470 (unsigned long long)lv * (unsigned long long)base];
471 } else
472 lv = -lv;
473 }
474 if (n_s < 0) { /* base 10 */
475 char scratch[41]; // space to print ≤128-bit integer
476 const int nv = snprintf(scratch, sizeof(scratch), "%lld", lv);
477 sp -= nv;
478 memcpy(sp, scratch, (size_t)nv);
479 } else if (n_s > 0) { /* base power-of-2 */
480 do {
481 *--sp = ssp[lv & n_s];
482 } while ((lv = (unsigned long long)lv >> n));
483 } else { /* general base */
484 do {
485 *--sp = ssp[(unsigned long long)lv % (unsigned long long)base];
486 } while ((lv = (unsigned long long)lv / (unsigned long long)base));
487 }
488 } else
489 if (sizeof(short) < sizeof(int) && FMTCMP(size, short, long long)) {
490 if (ft->flags & SFFMT_VALUE) {
491 if (fmt == 'd')
492 v = (int) ((short) argv.h);
493 else
494 v = (int) ((ushort) argv.h);
495 } else {
496 if (fmt == 'd')
497 v = (int) ((short) argv.i);
498 else
499 v = (int) ((ushort) argv.i);
500 }
501 goto int_cvt;
502 } else if (size == sizeof(char)) {
503 if (ft->flags & SFFMT_VALUE) {
504 if (fmt == 'd')
505 v = (int) ((char) argv.c);
506 else
507 v = (int) ((uchar) argv.c);
508 } else {
509 if (fmt == 'd')
510 v = (int) ((char) argv.i);
511 else
512 v = (int) ((uchar) argv.i);
513 }
514 goto int_cvt;
515 } else {
516 v = argv.i;
517 int_cvt:
518 if (v == 0 && precis == 0)
519 break;
520 if (v < 0 && fmt == 'd') {
521 flags |= SFFMT_MINUS;
522 if ((unsigned)v == HIGHBITI) { // avoid overflow
523 v = (int)(HIGHBITI / (unsigned)base);
524 *--sp = _Sfdigits[HIGHBITI - (unsigned)v * (unsigned)base];
525 } else
526 v = -v;
527 }
528 if (n_s < 0) { /* base 10 */
529 char scratch[41]; // space to print ≤128-bit integer
530 const int nv = snprintf(scratch, sizeof(scratch), "%d", v);
531 sp -= nv;
532 memcpy(sp, scratch, (size_t)nv);
533 } else if (n_s > 0) { /* base power-of-2 */
534 do {
535 *--sp = ssp[v & n_s];
536 } while ((v = (unsigned)v >> n));
537 } else { /* n_s == 0, general base */
538 do {
539 *--sp = ssp[(unsigned)v % (unsigned)base];
540 } while ((v = (unsigned)v / (unsigned)base));
541 }
542 }
543
544 if (n_s < 0 && (flags & SFFMT_THOUSAND)
545 && (n = endsp - sp) > 3) {
546 if ((n %= 3) == 0)
547 n = 3;
548 for (ep = buf + SLACK, endep = ep + n;;) {
549 while (ep < endep)
550 *ep++ = *sp++;
551 if (sp == endsp)
552 break;
553 if (sp <= endsp - 3)
554 *ep++ = thousand;
555 endep = ep + 3;
556 }
557 sp = buf + SLACK;
558 endsp = ep;
559 }
560
561 /* zero padding for precision if have room in buffer */
562 if (precis > 0 && (precis -= (endsp - sp)) < (sp - buf) - 64)
563 while (precis-- > 0)
564 *--sp = '0';
565
566 if (flags & SFFMT_ALTER) { /* prefix */
567 if (fmt == 'o') {
568 if (*sp != '0')
569 *--sp = '0';
570 } else {
571 if (width > 0 && (flags & SFFMT_ZERO)) { /* do 0 padding first */
572 if (fmt == 'x' || fmt == 'X')
573 n = 0;
574 else if (dot < 2)
575 n = width;
576 else
577 n = base < 10 ? 2 : 3;
578 n += (flags & (SFFMT_MINUS | SFFMT_SIGN)) ? 1 : 0;
579 n = width - (n + (endsp - sp));
580 while (n-- > 0)
581 *--sp = '0';
582 }
583 if (fmt == 'x' || fmt == 'X') {
584 *--sp = (char) fmt;
585 *--sp = '0';
586 } else if (dot >= 2) { /* base#value notation */
587 *--sp = '#';
588 if (base < 10)
589 *--sp = (char) ('0' + base);
590 else {
591 *--sp = _Sfdec[(base <<= 1) + 1];
592 *--sp = _Sfdec[base];
593 }
594 }
595 }
596 }
597
598 break;
599
600 case 'g':
601 case 'G': /* these ultimately become %e or %f */
602 case 'e':
603 case 'E':
604 case 'f':
605 if (!(ft->flags & SFFMT_VALUE) || FMTCMP(size, double, long double))
606 dval = argv.d;
607 else
608 dval = (double) argv.f;
609
610 if (fmt == 'e' || fmt == 'E') {
611 n = (precis = precis < 0 ? FPRECIS : precis) + 1;
612 {
613 ep = _sfcvt(&dval, imin(n, SF_FDIGITS),
614 &decpt, &sign, SFFMT_EFORMAT);
615 }
616 goto e_format;
617 } else if (fmt == 'f' || fmt == 'F') {
618 precis = precis < 0 ? FPRECIS : precis;
619 {
620 ep = _sfcvt(&dval, imin(precis, SF_FDIGITS),
621 &decpt, &sign, 0);
622 }
623 goto f_format;
624 }
625
626 /* 'g' or 'G' format */
627 precis = precis < 0 ? FPRECIS : precis == 0 ? 1 : precis;
628 {
629 ep = _sfcvt(&dval, imin(precis, SF_FDIGITS),
630 &decpt, &sign, SFFMT_EFORMAT);
631 if (dval == 0.)
632 decpt = 1;
633 else if (*ep == 'I')
634 goto infinite;
635 }
636
637 if (!(flags & SFFMT_ALTER)) { /* zap trailing 0s */
638 if ((n = sfslen()) > precis)
639 n = precis;
640 while ((n -= 1) >= 1 && ep[n] == '0');
641 n += 1;
642 } else
643 n = precis;
644
645 if (decpt < -3 || decpt > precis) {
646 precis = n - 1;
647 goto e_format;
648 } else {
649 precis = n - decpt;
650 goto f_format;
651 }
652
653 e_format: /* build the x.yyyy string */
654 if (gv_isalpha(*ep))
655 goto infinite;
656 sp = endsp = buf + 1; /* reserve space for sign */
657 *endsp++ = *ep ? *ep++ : '0';
658
659 SFSETLOCALE(decimal, thousand);
660 if (precis > 0 || (flags & SFFMT_ALTER))
661 *endsp++ = decimal;
662 ssp = endsp;
663 endep = ep + precis;
664 while ((*endsp++ = *ep++) && ep <= endep);
665 precis -= (endsp -= 1) - ssp;
666
667 /* build the exponent */
668 ep = endep = buf + (sizeof(buf) - 1);
669 if (dval != 0.) {
670 if ((n = decpt - 1) < 0)
671 n = -n;
672 while (n > 9) {
673 v = n;
674 n /= 10;
675 *--ep = (char) ('0' + (v - n * 10));
676 }
677 } else
678 n = 0;
679 *--ep = (char) ('0' + n);
680 if (endep - ep <= 1) /* at least 2 digits */
681 *--ep = '0';
682
683 /* the e/Exponent separator and sign */
684 *--ep = (decpt > 0 || dval == 0.) ? '+' : '-';
685 *--ep = gv_isupper(fmt) ? 'E' : 'e';
686
687 goto end_efg;
688
689 f_format: /* data before the decimal point */
690 if (gv_isalpha(*ep)) {
691 infinite:
692 endsp = (sp = ep) + sfslen();
693 ep = endep;
694 precis = 0;
695 goto end_efg;
696 }
697
698 SFSETLOCALE(decimal, thousand);
699 endsp = sp = buf + 1; /* save a space for sign */
700 endep = ep + decpt;
701 if (decpt > 3 && (flags & SFFMT_THOUSAND)) {
702 if ((n = decpt % 3) == 0)
703 n = 3;
704 while (ep < endep && (*endsp++ = *ep++)) {
705 if (--n == 0 && (ep <= endep - 3)) {
706 *endsp++ = thousand;
707 n = 3;
708 }
709 }
710 } else {
711 while (ep < endep && (*endsp++ = *ep++));
712 }
713 if (endsp == sp)
714 *endsp++ = '0';
715
716 if (precis > 0 || (flags & SFFMT_ALTER))
717 *endsp++ = decimal;
718
719 if ((n = -decpt) > 0) { /* output zeros for negative exponent */
720 ssp = endsp + imin(n, precis);
721 precis -= n;
722 while (endsp < ssp)
723 *endsp++ = '0';
724 }
725
726 ssp = endsp;
727 endep = ep + precis;
728 while ((*endsp++ = *ep++) && ep <= endep);
729 precis -= (endsp -= 1) - ssp;
730 ep = endep;
731 end_efg:
732 flags |= SFFMT_FLOAT;
733 if (sign)
734 flags |= SFFMT_MINUS;
735 break;
736 }
737
738 if (flags == 0 && width <= 0)
739 goto do_output;
740
741 if (flags & SFFMT_PREFIX)
742 fmt =
743 (flags & SFFMT_MINUS) ? '-' : (flags & SFFMT_SIGN) ? '+' :
744 ' ';
745
746 n = (endsp - sp) + (endep - ep) + (precis <= 0 ? 0 : precis) +
747 ((flags & SFFMT_PREFIX) ? 1 : 0);
748 if ((v = width - n) <= 0)
749 v = 0;
750 else if (!(flags & SFFMT_ZERO)) { /* right padding */
751 if (flags & SFFMT_LEFT)
752 v = -v;
753 else if (flags & SFFMT_PREFIX) { /* blank padding, output prefix now */
754 *--sp = fmt;
755 flags &= ~SFFMT_PREFIX;
756 }
757 }
758
759 if (flags & SFFMT_PREFIX) { /* put out the prefix */
760 SFputc(f, fmt);
761 if (fmt != ' ')
762 flags |= SFFMT_ZERO;
763 }
764
765 if ((n = v) > 0) { /* left padding */
766 v = (flags & SFFMT_ZERO) ? '0' : ' ';
767 SFnputc(f, v, n);
768 }
769
770 if ((n = precis) > 0 && !(flags & SFFMT_FLOAT)) { /* padding for integer precision */
771 SFnputc(f, '0', n);
772 precis = 0;
773 }
774
775 do_output:
776 if ((n = endsp - sp) > 0)
777 SFwrite(f, sp, n);
778
779 if (flags & (SFFMT_FLOAT | SFFMT_LEFT)) { /* SFFMT_FLOAT: right padding for float precision */
780 if ((n = precis) > 0)
781 SFnputc(f, '0', n);
782
783 /* SFFMT_FLOAT: the exponent of %eE */
784 if ((n = endep - (sp = ep)) > 0)
785 SFwrite(f, sp, n);
786
787 /* SFFMT_LEFT: right padding */
788 if ((n = -v) > 0)
789 SFnputc(f, ' ', n);
790 }
791 }
792
793 done:
794
795 return n_output;
796}
flags
static int flags
Definition gc.c:61
dot
#define dot(v, w)
Definition geom.c:191
NULL
node NULL
Definition grammar.y:181
gv_ctype.h
replacements for ctype.h functions
gv_isupper
static bool gv_isupper(int c)
Definition gv_ctype.h:27
gv_isalnum
static bool gv_isalnum(int c)
Definition gv_ctype.h:43
gv_isdigit
static bool gv_isdigit(int c)
Definition gv_ctype.h:41
gv_isalpha
static bool gv_isalpha(int c)
Definition gv_ctype.h:29
gv_math.h
Arithmetic helper functions.
imin
static int imin(int a, int b)
minimum of two integers
Definition gv_math.h:32
format
GVIO_API const char * format
Definition gvio.h:51
sign
static int sign(double v)
Definition legal.c:43
_sfcvt
char * _sfcvt(void *dv, int n_digit, int *decpt, int *sign, int format)
Definition sfcvt.c:33
RIGHTP
#define RIGHTP
Definition sfhdr.h:83
FMTCMP
#define FMTCMP(sz, type, maxtype)
Definition sfhdr.h:96
LEFTP
#define LEFTP
Definition sfhdr.h:82
FMTGET
#define FMTGET(ft, frm, fv, sz, flgs, wid, pr, bs)
Definition sfhdr.h:92
SFSETLOCALE
#define SFSETLOCALE(decimal, thousand)
Definition sfhdr.h:52
SF_MAXDIGITS
#define SF_MAXDIGITS
Definition sfhdr.h:122
_Sftype
#define _Sftype
Definition sfhdr.h:132
ushort
#define ushort
Definition sfhdr.h:47
ulong
#define ulong
Definition sfhdr.h:44
SF_FDIGITS
#define SF_FDIGITS
Definition sfhdr.h:120
_Sfdec
#define _Sfdec
Definition sfhdr.h:127
QUOTE
#define QUOTE
Definition sfhdr.h:84
SFFMT_EFORMAT
#define SFFMT_EFORMAT
Definition sfhdr.h:101
_Sffmtintf
#define _Sffmtintf
Definition sfhdr.h:129
SF_RADIX
#define SF_RADIX
Definition sfhdr.h:116
SFFMT_TYPES
#define SFFMT_TYPES
Definition sfhdr.h:104
uchar
#define uchar
Definition sfhdr.h:41
FMTSET
#define FMTSET(ft, frm, fv, sz, flgs, wid, pr, bs, ts, ns)
Definition sfhdr.h:86
SFFMT_MINUS
#define SFFMT_MINUS
Definition sfhdr.h:102
SFFMT_INT
#define SFFMT_INT
Definition sfhdr.h:109
SFFMT_UINT
#define SFFMT_UINT
Definition sfhdr.h:110
SFFMT_FLOAT
#define SFFMT_FLOAT
Definition sfhdr.h:111
_Sfdigits
#define _Sfdigits
Definition sfhdr.h:128
SFFMT_THOUSAND
#define SFFMT_THOUSAND
Definition sfio.h:56
SFFMT_ZFLAG
#define SFFMT_ZFLAG
Definition sfio.h:49
SFFMT_BLANK
#define SFFMT_BLANK
Definition sfio.h:53
SFFMT_SIGN
#define SFFMT_SIGN
Definition sfio.h:52
SFFMT_LEFT
#define SFFMT_LEFT
Definition sfio.h:51
SFFMT_ALTER
#define SFFMT_ALTER
Definition sfio.h:55
SFFMT_LONG
#define SFFMT_LONG
Definition sfio.h:59
sfslen
ssize_t sfslen(void)
Definition _sfslen.c:13
SFFMT_JFLAG
#define SFFMT_JFLAG
Definition sfio.h:65
SFFMT_SSHORT
#define SFFMT_SSHORT
Definition sfio.h:47
SFFMT_SHORT
#define SFFMT_SHORT
Definition sfio.h:58
SFFMT_IFLAG
#define SFFMT_IFLAG
Definition sfio.h:64
SFFMT_ZERO
#define SFFMT_ZERO
Definition sfio.h:54
SFFMT_LDOUBLE
#define SFFMT_LDOUBLE
Definition sfio.h:61
SFFMT_VALUE
#define SFFMT_VALUE
Definition sfio.h:62
SFFMT_TFLAG
#define SFFMT_TFLAG
Definition sfio.h:48
SFFMT_LLONG
#define SFFMT_LLONG
Definition sfio.h:60
SFFMT_PREFIX
#define SFFMT_PREFIX
Definition sfprint.c:28
FPRECIS
#define FPRECIS
Definition sfprint.c:30
SFputc
#define SFputc(f, c)
HIGHBITI
#define HIGHBITI
Definition sfprint.c:25
HIGHBITL
#define HIGHBITL
Definition sfprint.c:26
sfprint
int sfprint(FILE *f, Sffmt_t *format)
Definition sfprint.c:36
SFnputc
#define SFnputc(f, c, n)
SLACK
#define SLACK
SFwrite
#define SFwrite(f, s, n)
_sffmt_s
Definition sfio.h:31
_sffmt_s::form
char * form
Definition sfio.h:34
_sffmt_s::flags
int flags
Definition sfio.h:38
_sffmt_s::size
ssize_t size
Definition sfio.h:37
_sffmt_s::extf
Sffmtext_f extf
Definition sfio.h:32
Argv_t
Definition sfhdr.h:65
Argv_t::h
short h
Definition sfhdr.h:68
Argv_t::ft
Sffmt_t * ft
Definition sfhdr.h:79
Argv_t::c
char c
Definition sfhdr.h:77
Argv_t::sp
char ** sp
Definition sfhdr.h:77
Argv_t::vp
void * vp
Definition sfhdr.h:78
Argv_t::ll
long long ll
Definition sfhdr.h:72
Argv_t::d
double d
Definition sfhdr.h:75
Argv_t::s
char * s
Definition sfhdr.h:77
Argv_t::l
long l
Definition sfhdr.h:67
Argv_t::i
int i
Definition sfhdr.h:66
Argv_t::f
float f
Definition sfhdr.h:76