?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
8322 nl: misleading-indentation
[unleashed/tickless.git] / usr / src / lib / libbc / libc / stdio / common / doprnt.c
blobeb5e3438cd57381f686543aa1f655ad18089be2d
1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22 /*
23 * Copyright 2005 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 /* Copyright (c) 1988 AT&T */
28 /* All Rights Reserved */
29
30 #pragma ident "%Z%%M% %I% %E% SMI"
31
32 /*
33 * _doprnt: common code for printf, fprintf, sprintf
34 * Floating-point code is included or not, depending
35 * on whether the preprocessor variable FLOAT is 1 or 0.
36 */
37 #define MAXARGS 50
38 #ifndef FLOAT
39 #define FLOAT 1 /* YES! we want floating */
40 #endif
41
42 #include <stdio.h>
43 #include <ctype.h>
44 #include <stdarg.h>
45 #include <values.h>
46 #include <locale.h>
47 #include "doprnt.h"
48 #include "stdiom.h"
49 #include <string.h> /* strchr, strlen, strspn */
50
51 #define max(a,b) ((a) > (b) ? (a) : (b))
52 #define min(a,b) ((a) < (b) ? (a) : (b))
53
54 /* If this symbol is nonzero, allow '0' as a flag */
55 /* If this symbol is nonzero, allow '0' as a flag */
56 #define FZERO 1
57
58 #if FLOAT
59 /*
60 * libc/gen/common functions for floating-point conversion
61 */
62 #include <floatingpoint.h>
63 extern void _fourdigitsquick();
64 #endif
65
66 #define emitchar(c) { if (--filecnt < 0) { \
67 FILE *iop = file; \
68 if (((iop->_flag & (_IOLBF|_IONBF)) == 0 \
69 || -filecnt >= iop->_bufsiz)) { \
70 iop->_ptr = fileptr; \
71 if (iop->_flag & _IOSTRG) \
72 return iop->_ptr - iop->_base; \
73 else \
74 (void) _xflsbuf(iop); \
75 fileptr = iop->_ptr; \
76 filecnt = iop->_cnt; \
77 filecnt--; \
78 } \
79 } \
80 *fileptr++ = (unsigned)(c); \
81 count++; \
82 }
83
84 static char *nullstr = "(null)";
85 static char *lowerhex = "0123456789abcdef";
86 static char *upperhex = "0123456789ABCDEF";
87
88 /* stva_list is used to subvert C's restriction that a variable with an
89 * array type can not appear on the left hand side of an assignment operator.
90 * By putting the array inside a structure, the functionality of assigning to
91 * the whole array through a simple assignment is achieved..
92 */
93 typedef struct stva_list {
94 va_list ap;
95 } stva_list;
96
97 void _mkarglst(char *, stva_list, stva_list []);
98 void _getarg(char *, stva_list *, int);
99 static char *_check_dol(char *, int *);
100
101 int
102 _doprnt(char *format, va_list in_args, FILE *file)
103 {
104 char convertbuffer[1024] ;
105
106 /* Current position in format */
107 char *cp;
108
109 /* Starting and ending points for value to be printed */
110 char *bp;
111 char *p;
112
113 /* Pointer and count for I/O buffer */
114 unsigned char *fileptr;
115 int filecnt;
116
117 /* Field width and precision */
118 int width;
119 int prec;
120
121 /* Format code */
122 char fcode;
123
124 /* Number of padding zeroes required on the left */
125 int lzero;
126
127 /* Flags - nonzero if corresponding character appears in format */
128 bool fplus; /* + */
129 bool fminus; /* - */
130 bool fblank; /* blank */
131 bool fsharp; /* # */
132 #if FZERO
133 bool ansi_fzero; /* 0 for ansi-dictated formats */
134 bool compat_fzero; /* 0 for backward compatibility */
135 #endif
136 bool Lsize; /* Capital L for size = long double = quadruple */
137
138 /* Pointer to sign, "0x", "0X", or empty */
139 char *prefix;
140
141 /* Scratch */
142 int nblank;
143
144 #if FLOAT
145 /* Exponent or empty */
146 char *suffix;
147
148 /* Buffer to create exponent */
149 char expbuf[7]; /* "e+xxxx\0" */
150
151 /* Number of padding zeroes required on the right */
152 int rzero;
153
154 /* Length of exponent suffix. */
155 int suffixlength;
156
157 /* The value being converted, if real or quadruple */
158 double dval;
159 quadruple qval;
160
161 /* Output values from fconvert and econvert */
162 int decpt, sign;
163
164 /* Values are developed in this buffer */
165 char buf[1034]; /* Size of convertbuffer, plus some for exponent and sign. */
166
167 /* Current locale's decimal point */
168 char decpt_char = *(localeconv()->decimal_point);
169
170 #else
171 /* Values are developed in this buffer */
172 char buf[MAXDIGS];
173 #endif
174
175
176 /* The value being converted, if integer */
177 unsigned long val;
178
179 /* Work variables */
180 int n;
181 char c;
182 char radix;
183 int svswitch = 0;
184 /* count of output characters */
185 int count;
186
187 /* variables for positional parameters */
188 char *sformat = format; /* save the beginning of the format */
189 int fpos = 1; /* 1 if first positional parameter */
190 stva_list args, /* used to step through the argument list */
191 args_width, /* for width */
192 args_prec, /* for prec */
193 sargs; /* used to save the start of the argument list */
194 stva_list arglst[MAXARGS];/* array giving the approriate values
195 * for va_arg() to retrieve the
196 * corresponding argument:
197 * arglst[0] is the first argument
198 * arglst[1] is the second argument, etc.
199 */
200 int index = 0; /* argument placeolder */
201 /* Initialize args and sargs to the start of the argument list.
202 * Note that ANSI guarantees that the address of the first member of
203 * a structure will be the same as the address of the structure. */
204 args_width = args_prec = args = sargs = *(struct stva_list *)&in_args;
205
206
207 /* initialize p an bp (starting and ending points) bugid 1141781 */
208
209 p = bp = NULL;
210
211 cp = format;
212 if ((c = *cp++) != '\0') {
213 /*
214 * We know we're going to write something; make sure
215 * we can write and set up buffers, etc..
216 */
217 if (_WRTCHK(file))
218 return(EOF);
219 } else
220 return(0); /* no fault, no error */
221
222 count = 0;
223 fileptr = file->_ptr;
224 filecnt = file->_cnt;
225
226 /*
227 * The main loop -- this loop goes through one iteration
228 * for each ordinary character or format specification.
229 */
230 do {
231 if (c != '%') {
232 /* Ordinary (non-%) character */
233 emitchar(c);
234 } else {
235 /*
236 * % has been spotted!
237 *
238 * First, try the 99% cases.
239 * then parse the format specification.
240 *
241 * Note that this code assumes the Sun
242 * Workstation environment (all params
243 * passed as int == long, no interrupts
244 * for fixed point overflow from negating
245 * the most negative number).
246 */
247 skipit:
248 switch(c = *cp++) {
249
250 case 'l':
251 case 'h':
252 /* Quickly ignore long & short specifiers */
253 goto skipit;
254
255 case 's':
256 bp = va_arg(args.ap, char *);
257 if (bp == NULL)
258 bp = nullstr;
259 while (c = *bp++)
260 emitchar(c);
261 p = bp;
262 continue;
263
264 case 'c':
265 c = va_arg(args.ap, int);
266 emitc:
267 emitchar(c);
268 continue;
269
270 case 'i':
271 case 'd':
272 case 'D':
273 val = va_arg(args.ap, int);
274 if ((long) val < 0) {
275 emitchar('-');
276 val = -val;
277 }
278 goto udcommon;
279
280 case 'U':
281 case 'u':
282 val = va_arg(args.ap, unsigned);
283 udcommon:
284 {
285 char *stringp = lowerhex;
286 bp = buf+MAXDIGS;
287 stringp = lowerhex;
288 do {
289 *--bp = stringp[val%10];
290 val /= 10;
291 } while (val);
292 }
293 goto intout;
294
295 case 'X':
296 {
297 char *stringp = upperhex;
298 val = va_arg(args.ap, unsigned);
299 bp = buf + MAXDIGS;
300 if (val == 0)
301 goto zero;
302 while (val) {
303 *--bp = stringp[val%16];
304 val /= 16;
305 }
306 }
307 goto intout;
308
309 case 'x':
310 case 'p':
311 {
312 char *stringp = lowerhex;
313 val = va_arg(args.ap, unsigned);
314 bp = buf + MAXDIGS;
315 if (val == 0)
316 goto zero;
317 while (val) {
318 *--bp = stringp[val%16];
319 val /= 16;
320 }
321 }
322 goto intout;
323
324 case 'O':
325 case 'o':
326 {
327 char *stringp = lowerhex;
328 val = va_arg(args.ap, unsigned);
329 bp = buf + MAXDIGS;
330 if (val == 0)
331 goto zero;
332 while (val) {
333 *--bp = stringp[val%8];
334 val /= 8;
335 }
336 }
337 /* Common code to output integers */
338 intout:
339 p = buf + MAXDIGS;
340 while (bp < p) {
341 c = *bp++;
342 emitchar(c);
343 }
344 continue;
345
346 zero:
347 c = '0';
348 goto emitc;
349
350 default:
351 /*
352 * let AT&T deal with it
353 */
354 cp-= 2;
355 }
356
357 Lsize = 0; /* Not long double unless we say so. */
358 /* Scan the <flags> */
359 fplus = 0;
360 fminus = 0;
361 fblank = 0;
362 fsharp = 0;
363 #if FZERO
364 ansi_fzero = 0;
365 compat_fzero = 0;
366 #endif
367 scan: switch (*++cp) {
368 case '+':
369 fplus = 1;
370 goto scan;
371 case '-':
372 fminus = 1;
373 goto scan;
374 case ' ':
375 fblank = 1;
376 goto scan;
377 case '#':
378 fsharp = 1;
379 goto scan;
380 #if FZERO
381 case '0':
382 ansi_fzero = 1;
383 compat_fzero = 1;
384 goto scan;
385 #endif
386 }
387
388 /* Scan the field width */
389 if (*cp == '*') {
390 char *p;
391 int val;
392
393 p = _check_dol(cp+1, &val);
394 if (p != (char *)NULL) {
395 /*
396 * argument re-order
397 */
398 if (fpos) {
399 _mkarglst(sformat, sargs, arglst);
400 fpos = 0;
401 }
402 if (val <= MAXARGS) {
403 args_width = arglst[val - 1];
404 } else {
405 args_width = arglst[MAXARGS - 1];
406 _getarg(sformat, &args_width, val);
407 }
408 width = va_arg(args_width.ap, int);
409 if (width < 0) {
410 width = -width;
411 fminus = 1;
412 }
413 cp = p;
414 }
415 else {
416 width = va_arg(args.ap, int);
417 if (width < 0) {
418 width = -width;
419 fminus = 1;
420 }
421 cp++;
422 }
423 } else {
424 index = width = 0;
425 while (isdigit(*cp)) {
426 n = tonumber(*cp++);
427 index = width = width * 10 + n;
428 }
429 }
430
431 /* Scan the precision */
432 if (*cp == '.') {
433
434 /* '*' instead of digits? */
435 if (*++cp == '*') {
436 char *p;
437 int val;
438
439 p = _check_dol(cp+1, &val);
440 if (p != (char *)NULL) {
441 /*
442 * argument re-order
443 */
444 if (fpos) {
445 _mkarglst(sformat, sargs, arglst);
446 fpos = 0;
447 }
448 if (val <= MAXARGS) {
449 args_prec = arglst[val - 1];
450 } else {
451 args_prec = arglst[MAXARGS - 1];
452 _getarg(sformat, &args_prec, val);
453 }
454 prec = va_arg(args_prec.ap, int);
455 cp = p;
456 }
457 else {
458 prec = va_arg(args.ap, int);
459 cp++;
460 }
461 } else {
462 prec = 0;
463 while (isdigit(*cp)) {
464 n = tonumber(*cp++);
465 prec = prec * 10 + n;
466 }
467 }
468 } else
469 prec = -1;
470
471 if (*cp == '$') {
472 if (fpos) {
473 _mkarglst(sformat, sargs, arglst);
474 fpos = 0;
475 }
476 if (index <= MAXARGS) {
477 args = arglst[index - 1];
478 } else {
479 args = arglst[MAXARGS - 1];
480 _getarg(sformat, &args, index);
481 }
482 goto scan;
483 }
484 /*
485 * The character addressed by cp must be the
486 * format letter -- there is nothing left for
487 * it to be.
488 *
489 * The status of the +, -, #, blank, and 0
490 * flags are reflected in the variables
491 * "fplus", "fminus", "fsharp", "fblank",
492 * and "ansi_fzero"/"compat_fzero", respectively.
493 * "width" and "prec" contain numbers
494 * corresponding to the digit strings
495 * before and after the decimal point,
496 * respectively. If there was no decimal
497 * point, "prec" is -1.
498 *
499 * The following switch sets things up
500 * for printing. What ultimately gets
501 * printed will be padding blanks, a prefix,
502 * left padding zeroes, a value, right padding
503 * zeroes, a suffix, and more padding
504 * blanks. Padding blanks will not appear
505 * simultaneously on both the left and the
506 * right. Each case in this switch will
507 * compute the value, and leave in several
508 * variables the information necessary to
509 * construct what is to be printed.
510 *
511 * The prefix is a sign, a blank, "0x", "0X",
512 * or null, and is addressed by "prefix".
513 *
514 * The suffix is either null or an exponent,
515 * and is addressed by "suffix".
516 *
517 * The value to be printed starts at "bp"
518 * and continues up to and not including "p".
519 *
520 * "lzero" and "rzero" will contain the number
521 * of padding zeroes required on the left
522 * and right, respectively. If either of
523 * these variables is negative, it will be
524 * treated as if it were zero.
525 *
526 * The number of padding blanks, and whether
527 * they go on the left or the right, will be
528 * computed on exit from the switch.
529 */
530
531 lzero = 0;
532 prefix = "";
533 #if FLOAT
534 rzero = 0;
535 suffix = prefix;
536 #endif
537
538 #if FZERO
539 /* if both zero-padding and left-justify flags
540 * are used, ignore zero-padding, per ansi c
541 */
542 if (ansi_fzero & fminus) {
543 ansi_fzero = 0;
544 compat_fzero = 0;
545 }
546
547 /* if zero-padding and precision are specified,
548 * ignore zero-padding for ansi-dictated formats,
549 * per ansi c
550 */
551 if (ansi_fzero & (prec != -1)) ansi_fzero = 0;
552 #endif
553
554 next:
555 switch (fcode = *cp++) {
556
557 /* toss the length modifier, if any */
558 case 'l':
559 case 'h':
560 goto next;
561
562 case 'L':
563 Lsize = 1; /* Remember long double size. */
564 goto next;
565
566 /*
567 * fixed point representations
568 *
569 * "radix" is the radix for the conversion.
570 * Conversion is unsigned unless fcode is 'd'.
571 * We assume a 2's complement machine and
572 * that fixed point overflow (from negating
573 * the largest negative int) is ignored.
574 */
575
576 case 'i':
577 case 'D':
578 case 'U':
579 case 'd':
580 case 'u':
581 radix = 10;
582 goto fixed;
583
584 case 'O':
585 case 'o':
586 radix = 8;
587 goto fixed;
588
589 case 'X':
590 case 'x':
591 radix = 16;
592
593 fixed:
594 /* Establish default precision */
595 if (prec < 0)
596 prec = 1;
597
598 /* Fetch the argument to be printed */
599 val = va_arg(args.ap, unsigned);
600
601 /* If signed conversion, establish sign */
602 if (fcode == 'd' || fcode == 'D' || fcode == 'i') {
603 if ((long) val < 0) {
604 prefix = "-";
605 val = -val;
606 } else if (fplus)
607 prefix = "+";
608 else if (fblank)
609 prefix = " ";
610 }
611 /* Set translate table for digits */
612 {
613 char *stringp;
614 if (fcode == 'X')
615 stringp = upperhex;
616 else
617 stringp = lowerhex;
618
619 /* Develop the digits of the value */
620 bp = buf + MAXDIGS;
621 switch(radix) {
622 case 8: /*octal*/
623 while (val) {
624 *--bp = stringp[val%8];
625 val /= 8;
626 }
627 break;
628 case 16:/*hex*/
629 while (val) {
630 *--bp = stringp[val%16];
631 val /= 16;
632 }
633 break;
634 default:
635 while (val) {
636 *--bp = stringp[val%10];
637 val /= 10;
638 }
639 break;
640 } /* switch */
641 }
642
643 /* Calculate padding zero requirement */
644 p = buf + MAXDIGS;
645
646 /* Handle the # flag */
647 if (fsharp && bp != p) {
648 switch (fcode) {
649 case 'x':
650 prefix = "0x";
651 break;
652 case 'X':
653 prefix = "0X";
654 break;
655 }
656 }
657 #if FZERO
658 if (ansi_fzero) {
659 n = width - strlen(prefix);
660 if (n > prec)
661 prec = n;
662 }
663 #endif
664 lzero = bp - p + prec;
665
666 /* Handle the # flag for 'o' */
667 if (fsharp && bp != p && fcode == 'o' &&
668 lzero < 1) {
669 lzero = 1;
670 }
671 break;
672 #if FLOAT
673
674 #if defined(__sparc)
675 #define GETQVAL /* Sun-4 macro to get a quad q from the argument list, passed as a pointer. */ \
676 { qval = *(va_arg(args.ap, quadruple*)) ; }
677 #else
678 #define GETQVAL /* Sun-3 macro to get a quad q from the argument list, passed as a value. */ \
679 { int iq ; unsigned long * pl = (unsigned long *) (&qval) ; for(iq=0;iq<4;iq++) pl[iq] = (unsigned long) va_arg(args.ap, unsigned long) ; }
680 #endif
681
682 case 'E':
683 case 'e':
684 /*
685 * E-format. The general strategy
686 * here is fairly easy: we take
687 * what econvert gives us and re-format it.
688 */
689
690 /* Establish default precision */
691 if (prec < 0)
692 prec = 6;
693
694 /* Fetch the value */
695 if (Lsize == 0) { /* Double */
696 dval = va_arg(args.ap, double);
697 bp = econvert(dval, prec + 1, &decpt, &sign, convertbuffer);
698 } else { /* Long Double = quadruple */
699 GETQVAL;
700 bp = qeconvert(&qval, prec + 1, &decpt, &sign, convertbuffer);
701 }
702
703 /* Determine the prefix */
704 if (sign)
705 prefix = "-";
706 else if (fplus)
707 prefix = "+";
708 else if (fblank)
709 prefix = " ";
710 if (convertbuffer[0] > '9')
711 { /* handle infinity, nan */
712 bp = &convertbuffer[0];
713 for (p = bp+1 ; *p != 0 ; p++) ;
714 goto ebreak ;
715 }
716 {
717 char *stringp;
718 /* Place the first digit in the buffer */
719 stringp = &buf[0];
720 *stringp++ = *bp != '\0'? *bp++: '0';
721
722 /* Put in a decimal point if needed */
723 if (prec != 0 || fsharp)
724 *stringp++ = decpt_char;
725
726 /* Create the rest of the mantissa */
727 rzero = prec;
728 while (rzero > 0 && *bp!= '\0') {
729 --rzero;
730 *stringp++ = *bp++;
731 }
732 p = stringp;
733 }
734
735 bp = &buf[0];
736
737 /* Create the exponent */
738 if (convertbuffer[0] != '0')
739 n = decpt - 1;
740 else
741 n = 0 ;
742 if (n < 0)
743 n = -n;
744 _fourdigitsquick( (short unsigned) n, &(expbuf[2]) ) ;
745 expbuf[6] = 0 ;
746 if (n < 100)
747 /*
748 * Normally two digit exponent field,
749 * three or four if required.
750 */
751 { suffix = &(expbuf[4]) ; suffixlength = 4 ; }
752 else if (n < 1000)
753 { suffix = &(expbuf[3]) ; suffixlength = 5 ; }
754 else
755 { suffix = &(expbuf[2]) ; suffixlength = 6 ; }
756 /* Put in the exponent sign */
757 *--suffix = (decpt > 0 || convertbuffer[0] == '0' )? '+': '-';
758
759 /* Put in the e; note kludge in 'g' format */
760 *--suffix = fcode;
761 ebreak:
762 #if FZERO
763 if (compat_fzero &! fminus)
764 /* Calculate padding zero requirement */
765 lzero = width - (strlen(prefix)
766 + (p - buf) + rzero + suffixlength);
767 #endif
768 break;
769
770 case 'f':
771 /*
772 * F-format floating point. This is
773 * a good deal less simple than E-format.
774 * The overall strategy will be to call
775 * fconvert, reformat its result into buf,
776 * and calculate how many trailing
777 * zeroes will be required. There will
778 * never be any leading zeroes needed.
779 */
780
781 /* Establish default precision */
782 if (prec < 0)
783 prec = 6;
784
785 if (Lsize == 0) {
786 dval = va_arg(args.ap, double);
787 bp = fconvert(dval, prec, &decpt, &sign, convertbuffer);
788 } else {
789 GETQVAL ;
790 bp = qfconvert(&qval, prec, &decpt, &sign, convertbuffer);
791 }
792
793 /* Determine the prefix */
794 if (sign)
795 prefix = "-";
796 else if (fplus)
797 prefix = "+";
798 else if (fblank)
799 prefix = " ";
800 if (convertbuffer[0] > '9')
801 { /* handle infinity, nan */
802 bp = &convertbuffer[0];
803 for (p = bp+1 ; *p != 0 ; p++) ;
804 goto fbreak ;
805 }
806 {
807 char *stringp;
808 /* Initialize buffer pointer */
809 stringp = &buf[0];
810
811 /* Emit the digits before the decimal point */
812 n = decpt;
813 if (n <= 0)
814 *stringp++ = '0';
815 else
816 do
817 if (*bp == '\0' )
818 *stringp++ = '0';
819 else {
820 *stringp++ = *bp++;
821 }
822 while (--n != 0);
823
824 /* Decide whether we need a decimal point */
825 if (fsharp || prec > 0)
826 *stringp++ = decpt_char;
827
828 /* Digits(if any) after the decimal point */
829 n = prec;
830 rzero = prec - n;
831 while (--n >= 0) {
832 if (++decpt <= 0 || *bp == '\0')
833 *stringp++ = '0';
834 else {
835 *stringp++ = *bp++;
836 }
837 }
838 #if FZERO
839 if (compat_fzero &! fminus)
840 /* Calculate padding zero requirement */
841 lzero = width - (strlen(prefix)
842 + (stringp - buf) + rzero);
843 #endif
844 p = stringp;
845 }
846
847 bp = &buf[0];
848 fbreak:
849 break;
850
851 case 'G':
852 case 'g':
853 /*
854 * g-format. We play around a bit
855 * and then jump into e or f, as needed.
856 */
857
858 /* Establish default precision */
859 if (prec < 0)
860 prec = 6;
861 else if (prec == 0)
862 prec = 1;
863
864 if (Lsize == 0) {
865 dval = va_arg(args.ap, double);
866 bp = gconvert(dval, prec, fsharp, convertbuffer);
867 } else {
868 GETQVAL;
869 bp = qgconvert(&qval, prec, fsharp, convertbuffer);
870 }
871 bp = convertbuffer ;
872 if (convertbuffer[0] == '-') {
873 prefix = "-" ;
874 bp++;
875 }
876 else if (fplus)
877 prefix = "+";
878 else if (fblank)
879 prefix = " ";
880 if (isupper(fcode))
881 { /* Put in a big E for small minds. */
882 for (p = bp ; (*p != NULL) && (*p != 'e') ; p++) ;
883 if (*p == 'e') *p = 'E' ;
884 for (; (*p != NULL) ; p++) ;
885 /* Find end of string. */
886 }
887 else
888 for (p = bp ; *p != NULL ; p++) ;
889 /* Find end of string. */
890 rzero = 0;
891 #if FZERO
892 if (compat_fzero & !fminus)
893 /* Calculate padding zero requirement */
894 lzero = width - (strlen(prefix)
895 + (p - bp) + rzero);
896 #endif
897 break ;
898
899 #endif
900 case 'c':
901 buf[0] = va_arg(args.ap, int);
902 bp = &buf[0];
903 p = bp + 1;
904 break;
905
906 case 's':
907 bp = va_arg(args.ap, char *);
908 if (prec < 0)
909 prec = MAXINT;
910 /* avoid *(0) */
911 if (bp == NULL)
912 bp = nullstr;
913 for (n=0; *bp++ != '\0' && n < prec; n++)
914 ;
915 #if FZERO
916 if (compat_fzero &! fminus)
917 lzero = width - n;
918 #endif
919 p = --bp;
920 bp -= n;
921 break;
922
923 case '\0':
924 /* well, what's the punch line? */
925 goto out;
926
927 case 'n':
928 svswitch = 1;
929 break;
930 default:
931 p = bp = &fcode;
932 p++;
933 break;
934
935 }
936 /* Calculate number of padding blanks */
937 nblank = width
938 #if FLOAT
939 - (rzero < 0? 0: rzero)
940 - strlen(suffix)
941 #endif
942 - (p - bp)
943 - (lzero < 0? 0: lzero)
944 - strlen(prefix);
945
946 /* Blanks on left if required */
947 if (!fminus)
948 while (--nblank >= 0)
949 emitchar(' ');
950
951 /* Prefix, if any */
952 while (*prefix != '\0') {
953 emitchar(*prefix);
954 prefix++;
955 }
956
957 /* Zeroes on the left */
958 while (--lzero >= 0)
959 emitchar('0');
960
961 /* The value itself */
962 while (bp < p) {
963 emitchar(*bp);
964 bp++;
965 }
966 #if FLOAT
967 /* Zeroes on the right */
968 while (--rzero >= 0)
969 emitchar('0');
970
971 /* The suffix */
972 while (*suffix != '\0') {
973 emitchar(*suffix);
974 suffix++;
975 }
976 #endif
977 /* Blanks on the right if required */
978 if (fminus)
979 while (--nblank >= 0)
980 emitchar(' ');
981 /* If %n is seen, save count in argument */
982 if (svswitch == 1) {
983 long *svcount;
984 svcount = va_arg (args.ap, long *);
985 *svcount = count;
986 svswitch = 0;
987 }
988 } /* else */
989 } while ((c = *cp++) != '\0'); /* do */
990 out:
991 file->_ptr = fileptr;
992 file->_cnt = filecnt;
993 if (file->_flag & (_IONBF | _IOLBF) &&
994 (file->_flag & _IONBF ||
995 memchr((char *)file->_base, '\n', fileptr - file->_base) != NULL))
996 (void) _xflsbuf(file);
997 return (ferror(file)? EOF: count);
998 }
999
1000 #if defined(__sparc)
1001 /*
1002 * We use "double *" instead of "quadruple *" to skip over the pointer to
1003 * long double on the argument list since a pointer is a pointer after all.
1004 */
1005 #define SKIPQVAL { \
1006 (void) va_arg(args.ap, double *); \
1007 }
1008 #else /* Sun-3 */
1009 #define SKIPQVAL { \
1010 int iq; \
1011 for (iq = 0; iq < 4; iq++) \
1012 (void) va_arg(args.ap, unsigned long); \
1013 }
1014 #endif
1015 /*
1016 * This function initializes arglst, to contain the appropriate va_list values
1017 * for the first MAXARGS arguments.
1018 */
1019 void
1020 _mkarglst(char *fmt, stva_list args, stva_list arglst[])
1021 {
1022 static char *digits = "01234567890", *skips = "# +-.0123456789h$";
1023
1024 enum types {INT = 1, LONG, CHAR_PTR, DOUBLE, LONG_DOUBLE, VOID_PTR,
1025 LONG_PTR, INT_PTR};
1026 enum types typelst[MAXARGS], curtype;
1027 int maxnum, n, curargno, flags;
1028
1029 /*
1030 * Algorithm 1. set all argument types to zero.
1031 * 2. walk through fmt putting arg types in typelst[].
1032 * 3. walk through args using va_arg(args.ap, typelst[n])
1033 * and set arglst[] to the appropriate values.
1034 * Assumptions: Cannot use %*$... to specify variable position.
1035 */
1036
1037 (void)memset((void *)typelst, 0, sizeof(typelst));
1038 maxnum = -1;
1039 curargno = 0;
1040 while ((fmt = strchr(fmt, '%')) != 0)
1041 {
1042 fmt++; /* skip % */
1043 if (fmt[n = strspn(fmt, digits)] == '$')
1044 {
1045 curargno = atoi(fmt) - 1; /* convert to zero base */
1046 fmt += n + 1;
1047 }
1048 flags = 0;
1049 again:;
1050 fmt += strspn(fmt, skips);
1051 switch (*fmt++)
1052 {
1053 case '%': /*there is no argument! */
1054 continue;
1055 case 'l':
1056 flags |= 0x1;
1057 goto again;
1058 case 'L':
1059 flags |= 0x8;
1060 goto again;
1061 case '*': /* int argument used for value */
1062 flags |= 0x2;
1063 curtype = INT;
1064 break;
1065 case 'e':
1066 case 'E':
1067 case 'f':
1068 case 'g':
1069 case 'G':
1070 if (flags & 0x8)
1071 curtype = LONG_DOUBLE;
1072 else
1073 curtype = DOUBLE;
1074 break;
1075 case 's':
1076 curtype = CHAR_PTR;
1077 break;
1078 case 'p':
1079 curtype = VOID_PTR;
1080 break;
1081 case 'n':
1082 if (flags & 0x1)
1083 curtype = LONG_PTR;
1084 else
1085 curtype = INT_PTR;
1086 break;
1087 default:
1088 if (flags & 0x1)
1089 curtype = LONG;
1090 else
1091 curtype = INT;
1092 break;
1093 }
1094 if (curargno >= 0 && curargno < MAXARGS)
1095 {
1096 typelst[curargno] = curtype;
1097 if (maxnum < curargno)
1098 maxnum = curargno;
1099 }
1100 curargno++; /* default to next in list */
1101 if (flags & 0x2) /* took care of *, keep going */
1102 {
1103 flags ^= 0x2;
1104 goto again;
1105 }
1106 }
1107 for (n = 0 ; n <= maxnum; n++)
1108 {
1109 arglst[n] = args;
1110 if (typelst[n] == 0)
1111 typelst[n] = INT;
1112
1113 switch (typelst[n])
1114 {
1115 case INT:
1116 va_arg(args.ap, int);
1117 break;
1118 case LONG:
1119 va_arg(args.ap, long);
1120 break;
1121 case CHAR_PTR:
1122 va_arg(args.ap, char *);
1123 break;
1124 case DOUBLE:
1125 va_arg(args.ap, double);
1126 break;
1127 case LONG_DOUBLE:
1128 SKIPQVAL
1129 break;
1130 case VOID_PTR:
1131 va_arg(args.ap, void *);
1132 break;
1133 case LONG_PTR:
1134 va_arg(args.ap, long *);
1135 break;
1136 case INT_PTR:
1137 va_arg(args.ap, int *);
1138 break;
1139 }
1140 }
1141 }
1142
1143 /*
1144 * This function is used to find the va_list value for arguments whose
1145 * position is greater than MAXARGS. This function is slow, so hopefully
1146 * MAXARGS will be big enough so that this function need only be called in
1147 * unusual circumstances.
1148 * pargs is assumed to contain the value of arglst[MAXARGS - 1].
1149 */
1150 void
1151 _getarg(char *fmt, stva_list *pargs, int argno)
1152 {
1153 static char *digits = "01234567890", *skips = "# +-.0123456789h$";
1154 int i, n, curargno, flags;
1155 char *sfmt = fmt;
1156 int found = 1;
1157
1158 curargno = i = MAXARGS;
1159 while (found)
1160 {
1161 fmt = sfmt;
1162 found = 0;
1163 while ((i != argno) && (fmt = strchr(fmt, '%')) != 0)
1164 {
1165 fmt++; /* skip % */
1166 if (fmt[n = strspn(fmt, digits)] == '$')
1167 {
1168 curargno = atoi(fmt);
1169 fmt += n + 1;
1170 }
1171
1172 /* find conversion specifier for next argument */
1173 if (i != curargno)
1174 {
1175 curargno++;
1176 continue;
1177 } else
1178 found = 1;
1179 flags = 0;
1180 again:;
1181 fmt += strspn(fmt, skips);
1182 switch (*fmt++)
1183 {
1184 case '%': /*there is no argument! */
1185 continue;
1186 case 'l':
1187 flags |= 0x1;
1188 goto again;
1189 case 'L':
1190 flags |= 0x8;
1191 goto again;
1192 case '*': /* int argument used for value */
1193 flags |= 0x2;
1194 (void)va_arg((*pargs).ap, int);
1195 break;
1196 case 'e':
1197 case 'E':
1198 case 'f':
1199 case 'g':
1200 case 'G':
1201 if (flags & 0x8) {
1202 #define args (*pargs)
1203 SKIPQVAL
1204 #undef args
1205 }
1206 else
1207 (void)va_arg((*pargs).ap, double);
1208 break;
1209 case 's':
1210 (void)va_arg((*pargs).ap, char *);
1211 break;
1212 case 'p':
1213 (void)va_arg((*pargs).ap, void *);
1214 break;
1215 case 'n':
1216 if (flags & 0x1)
1217 (void)va_arg((*pargs).ap, long *);
1218 else
1219 (void)va_arg((*pargs).ap, int *);
1220 break;
1221 default:
1222 if (flags & 0x1)
1223 (void)va_arg((*pargs).ap, long int);
1224 else
1225 (void)va_arg((*pargs).ap, int);
1226 break;
1227 }
1228 i++;
1229 curargno++; /* default to next in list */
1230 if (flags & 0x2) /* took care of *, keep going */
1231 {
1232 flags ^= 0x2;
1233 goto again;
1234 }
1235 }
1236
1237 /* missing specifier for parameter, assume parameter is an int */
1238 if (!found && i != argno) {
1239 (void)va_arg((*pargs).ap, int);
1240 i++;
1241 curargno++;
1242 found = 1;
1243 }
1244 }
1245 }
1246
1247
1248 /*
1249 * parse a string, mini parse
1250 */
1251 static char *
1252 _check_dol(char *s, int *val)
1253 {
1254 char *os; /* save old string */
1255 int tmp_val = 0;
1256 int flag = 0;
1257
1258 while (isdigit (*s)) {
1259 ++flag;
1260 tmp_val = tmp_val*10 + *s - '0';
1261 s++;
1262 }
1263 if (flag == 0)
1264 return ((char *)NULL);
1265 if (*s == '$') {
1266 *val = tmp_val;
1267 return(++s);
1268 }
1269 return ((char *)NULL);
1270 }
unleashed repo fork