?  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 / libc / port / stdio / doscan.c
blobe375d9824fb3f6ade3db83406b6377dbde0238b7
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 (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright 2008 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 #include "lint.h"
33 #include <sys/types.h>
34 #include "mtlib.h"
35 #include "file64.h"
36 #include <stdio.h>
37 #include <ctype.h>
38 #include <stdarg.h>
39 #include <values.h>
40 #include <errno.h>
41 #include <stdlib.h>
42 #include <string.h>
43 #include <math.h>
44 #include <thread.h>
45 #include <synch.h>
46 #include <stdlib.h>
47 #include <fnmatch.h>
48 #include <limits.h>
49 #include <wchar.h>
50 #include <unistd.h>
51 #include "libc.h"
52 #include "stdiom.h"
53 #include "xpg6.h"
54
55 #define NCHARS (1 << BITSPERBYTE)
56
57 /* if the _IOWRT flag is set, this must be a call from sscanf */
58 #define locgetc(cnt) (cnt += 1, (iop->_flag & _IOWRT) ? \
59 ((*iop->_ptr == '\0') ? EOF : *iop->_ptr++) : \
60 GETC(iop))
61 #define locungetc(cnt, x) (cnt -= 1, (x == EOF) ? EOF : \
62 ((iop->_flag & _IOWRT) ? *(--iop->_ptr) : \
63 (++iop->_cnt, *(--iop->_ptr))))
64
65 #define wlocgetc() ((iop->_flag & _IOWRT) ? \
66 ((*iop->_ptr == '\0') ? EOF : *iop->_ptr++) : \
67 GETC(iop))
68 #define wlocungetc(x) ((x == EOF) ? EOF : \
69 ((iop->_flag & _IOWRT) ? *(--iop->_ptr) : \
70 UNGETC(x, iop)))
71
72 #define MAXARGS 30 /* max. number of args for fast positional paramters */
73
74 /*
75 * stva_list is used to subvert C's restriction that a variable with an
76 * array type can not appear on the left hand side of an assignment operator.
77 * By putting the array inside a structure, the functionality of assigning to
78 * the whole array through a simple assignment is achieved..
79 */
80 typedef struct stva_list {
81 va_list ap;
82 } stva_list;
83
84 static int number(int *, int *, int, int, int, int, FILE *, va_list *);
85 static int readchar(FILE *, int *);
86 static int string(int *, int *, int, int, int, char *, FILE *, va_list *);
87 static int wstring(int *, int *, int, int, int, FILE *, va_list *);
88 static int wbrstring(int *, int *, int, int, int, FILE *,
89 unsigned char *, va_list *);
90 #ifdef _WIDE
91 static int brstring(int *, int *, int, int, int, FILE *,
92 unsigned char *, va_list *);
93 #endif
94 static int _bi_getwc(FILE *);
95 static int _bi_ungetwc(wint_t, FILE *);
96
97 #ifdef _WIDE
98 static int _mkarglst(const wchar_t *, stva_list, stva_list[]);
99 static wint_t _wd_getwc(int *, FILE *);
100 static wint_t _wd_ungetwc(int *, wchar_t, FILE *);
101 static int _watoi(wchar_t *);
102 #else /* _WIDE */
103 static int _mkarglst(const char *, stva_list, stva_list[]);
104 #endif /* _WIDE */
105
106 #ifndef _WIDE
107 int
108 _doscan(FILE *iop, const char *fmt, va_list va_Alist)
109 {
110 int ret;
111 rmutex_t *lk;
112
113 if (iop->_flag & _IOWRT)
114 ret = __doscan_u(iop, fmt, va_Alist, 0);
115 else {
116 FLOCKFILE(lk, iop);
117 ret = __doscan_u(iop, fmt, va_Alist, 0);
118 FUNLOCKFILE(lk);
119 }
120 return (ret);
121 }
122 #endif /* _WIDE */
123
124 /* ARGSUSED3 */
125 #ifdef _WIDE
126 int
127 __wdoscan_u(FILE *iop, const wchar_t *fmt, va_list va_Alist, int scflag)
128 #else /* _WIDE */
129 int
130 __doscan_u(FILE *iop, const char *sfmt, va_list va_Alist, int scflag)
131 #endif /* _WIDE */
132 {
133 #ifdef _WIDE
134 wchar_t ch;
135 wchar_t inchar, size;
136 int nmatch = 0, len, stow;
137 #else /* _WIDE */
138 int ch;
139 int nmatch = 0, len, inchar, stow, size;
140 #endif /* _WIDE */
141
142 unsigned char *bracket_str = NULL;
143 int chcount, flag_eof;
144 char tab[NCHARS];
145
146 /* variables for postional parameters */
147 #ifdef _WIDE
148 const wchar_t *sformat = fmt; /* save the beginning of the format */
149 #else /* _WIDE */
150 const unsigned char *fmt = (const unsigned char *)sfmt;
151 const char *sformat = sfmt; /* save the beginning of the format */
152 #endif /* _WIDE */
153 int fpos = 1; /* 1 if first postional parameter */
154 stva_list args; /* used to step through the argument list */
155 stva_list sargs; /* used to save start of the argument list */
156 stva_list arglst[MAXARGS];
157 /*
158 * array giving the appropriate values
159 * for va_arg() to retrieve the
160 * corresponding argument:
161 * arglst[0] is the first argument
162 * arglst[1] is the second argument,etc.
163 */
164 /* Check if readable stream */
165 if (!(iop->_flag & (_IOREAD | _IORW))) {
166 errno = EBADF;
167 return (EOF);
168 }
169
170 /*
171 * Initialize args and sargs to the start of the argument list.
172 * We don't know any portable way to copy an arbitrary C object
173 * so we use a system-specific routine(probably a macro) from
174 * stdarg.h. (Remember that if va_list is an array, in_args will
175 * be a pointer and &in_args won't be what we would want for
176 * memcpy.)
177 */
178 va_copy(args.ap, va_Alist);
179
180 sargs = args;
181
182 chcount = 0; flag_eof = 0;
183
184 /*
185 * ****************************************************
186 * Main loop: reads format to determine a pattern,
187 * and then goes to read input stream
188 * in attempt to match the pattern.
189 * ****************************************************
190 */
191 for (; ; ) {
192 if ((ch = *fmt++) == '\0') {
193 return (nmatch); /* end of format */
194 }
195 #ifdef _WIDE
196 if (iswspace(ch)) {
197 if (!flag_eof) {
198 while (iswspace(inchar =
199 _wd_getwc(&chcount, iop)))
200 ;
201 if (_wd_ungetwc(&chcount, inchar, iop) == WEOF)
202 flag_eof = 1;
203 }
204 continue;
205 }
206 if (ch != '%' || (ch = *fmt++) == '%') {
207 if (ch == '%') {
208 if (!flag_eof) {
209 while (iswspace(inchar =
210 _wd_getwc(&chcount, iop)))
211 ;
212 if (_wd_ungetwc(&chcount, inchar, iop)
213 == WEOF)
214 flag_eof = 1;
215 }
216 }
217 if ((inchar = _wd_getwc(&chcount, iop)) == ch)
218 continue;
219 if (_wd_ungetwc(&chcount, inchar, iop) != WEOF) {
220 return (nmatch); /* failed to match input */
221 }
222 break;
223 }
224 #else /* _WIDE */
225 if (isspace(ch)) {
226 if (!flag_eof) {
227 while (isspace(inchar = locgetc(chcount)))
228 ;
229 if (locungetc(chcount, inchar) == EOF)
230 flag_eof = 1;
231
232 }
233 continue;
234 }
235 if (ch != '%' || (ch = *fmt++) == '%') {
236 if (ch == '%') {
237 if (!flag_eof) {
238 while (isspace(inchar =
239 locgetc(chcount)))
240 ;
241 if (locungetc(chcount, inchar) == EOF)
242 flag_eof = 1;
243 }
244 }
245 if ((inchar = locgetc(chcount)) == ch)
246 continue;
247 if (locungetc(chcount, inchar) != EOF) {
248 return (nmatch); /* failed to match input */
249 }
250 break;
251 }
252 #endif /* _WIDE */
253
254 charswitch: /* target of a goto 8-( */
255
256 if (ch == '*') {
257 stow = 0;
258 ch = *fmt++;
259 } else
260 stow = 1;
261
262 #ifdef _WIDE
263 for (len = 0; ((ch >= 0) && (ch < 256) && isdigit(ch));
264 ch = *fmt++)
265 len = len * 10 + ch - '0';
266 #else /* _WIDE */
267 for (len = 0; isdigit(ch); ch = *fmt++)
268 len = len * 10 + ch - '0';
269 #endif /* _WIDE */
270
271 if (ch == '$') {
272 /*
273 * positional parameter handling - the number
274 * specified in len gives the argument to which
275 * the next conversion should be applied.
276 * WARNING: This implementation of positional
277 * parameters assumes that the sizes of all pointer
278 * types are the same. (Code similar to that
279 * in the portable doprnt.c should be used if this
280 * assumption does not hold for a particular
281 * port.)
282 */
283 if (fpos) {
284 if (_mkarglst(sformat, sargs, arglst) != 0) {
285 return (EOF);
286 } else {
287 fpos = 0;
288 }
289 }
290 if (len <= MAXARGS) {
291 args = arglst[len - 1];
292 } else {
293 args = arglst[MAXARGS - 1];
294 for (len -= MAXARGS; len > 0; len--)
295 (void) va_arg(args.ap, void *);
296 }
297 len = 0;
298 ch = *fmt++;
299 goto charswitch;
300 }
301
302 if (len == 0)
303 len = MAXINT;
304 #ifdef _WIDE
305 if ((size = ch) == 'l' || (size == 'h') || (size == 'L') ||
306 (size == 'j') || (size == 't') || (size == 'z'))
307 ch = *fmt++;
308 #else /* _WIDE */
309 if ((size = ch) == 'l' || (size == 'h') || (size == 'L') ||
310 (size == 'w') || (size == 'j') || (size == 't') ||
311 (size == 'z'))
312 ch = *fmt++;
313 #endif /* _WIDE */
314 if (size == 'l' && ch == 'l') {
315 size = 'm'; /* size = 'm' if long long */
316 ch = *fmt++;
317 } else if (size == 'h' && ch == 'h') {
318 size = 'b'; /* use size = 'b' if char */
319 ch = *fmt++;
320 } else if ((size == 't') || (size == 'z')) {
321 size = 'l';
322 } else if (size == 'j') {
323 #ifndef _LP64
324 /* check scflag for size of u/intmax_t (32-bit libc) */
325 if (!(scflag & _F_INTMAX32)) {
326 #endif
327 size = 'm';
328 #ifndef _LP64
329 }
330 #endif
331 }
332 if (ch == '\0') {
333 return (EOF); /* unexpected end of format */
334 }
335 #ifdef _WIDE
336 if (ch == '[') {
337 wchar_t c;
338 size_t len;
339 int negflg = 0;
340 wchar_t *p;
341 wchar_t *wbracket_str;
342 size_t wlen, clen;
343
344 /* p points to the address of '[' */
345 p = (wchar_t *)fmt - 1;
346 len = 0;
347 if (*fmt == '^') {
348 len++;
349 fmt++;
350 negflg = 1;
351 }
352 if (((c = *fmt) == ']') || (c == '-')) {
353 len++;
354 fmt++;
355 }
356 while ((c = *fmt) != ']') {
357 if (c == '\0') {
358 return (EOF); /* unexpected EOF */
359 } else {
360 len++;
361 fmt++;
362 }
363 }
364 fmt++;
365 len += 2;
366 wbracket_str = (wchar_t *)
367 malloc(sizeof (wchar_t) * (len + 1));
368 if (wbracket_str == NULL) {
369 errno = ENOMEM;
370 return (EOF);
371 } else {
372 (void) wmemcpy(wbracket_str,
373 (const wchar_t *)p, len);
374 *(wbracket_str + len) = L'\0';
375 if (negflg && *(wbracket_str + 1) == '^') {
376 *(wbracket_str + 1) = L'!';
377 }
378 }
379 wlen = wcslen(wbracket_str);
380 clen = wcstombs((char *)NULL, wbracket_str, 0);
381 if (clen == (size_t)-1) {
382 free(wbracket_str);
383 return (EOF);
384 }
385 bracket_str = (unsigned char *)
386 malloc(sizeof (unsigned char) * (clen + 1));
387 if (bracket_str == NULL) {
388 free(wbracket_str);
389 errno = ENOMEM;
390 return (EOF);
391 }
392 clen = wcstombs((char *)bracket_str, wbracket_str,
393 wlen + 1);
394 free(wbracket_str);
395 if (clen == (size_t)-1) {
396 free(bracket_str);
397 return (EOF);
398 }
399 }
400 #else /* _WIDE */
401 if (ch == '[') {
402 if (size == 'l') {
403 int c, len, i;
404 int negflg = 0;
405 unsigned char *p;
406
407 p = (unsigned char *)(fmt - 1);
408 len = 0;
409 if (*fmt == '^') {
410 len++;
411 fmt++;
412 negflg = 1;
413 }
414 if (((c = *fmt) == ']') || (c == '-')) {
415 len++;
416 fmt++;
417 }
418 while ((c = *fmt) != ']') {
419 if (c == '\0') {
420 return (EOF);
421 } else if (isascii(c)) {
422 len++;
423 fmt++;
424 } else {
425 i = mblen((const char *)fmt,
426 MB_CUR_MAX);
427 if (i <= 0) {
428 return (EOF);
429 } else {
430 len += i;
431 fmt += i;
432 }
433 }
434 }
435 fmt++;
436 len += 2;
437 bracket_str = (unsigned char *)
438 malloc(sizeof (unsigned char) * (len + 1));
439 if (bracket_str == NULL) {
440 errno = ENOMEM;
441 return (EOF);
442 } else {
443 (void) strncpy((char *)bracket_str,
444 (const char *)p, len);
445 *(bracket_str + len) = '\0';
446 if (negflg &&
447 *(bracket_str + 1) == '^') {
448 *(bracket_str + 1) = '!';
449 }
450 }
451 } else {
452 int t = 0;
453 int b, c, d;
454
455 if (*fmt == '^') {
456 t++;
457 fmt++;
458 }
459 (void) memset(tab, !t, NCHARS);
460 if ((c = *fmt) == ']' || c == '-') {
461 tab[c] = t;
462 fmt++;
463 }
464
465 while ((c = *fmt) != ']') {
466 if (c == '\0') {
467 return (EOF);
468 }
469 b = *(fmt - 1);
470 d = *(fmt + 1);
471 if ((c == '-') && (d != ']') &&
472 (b < d)) {
473 (void) memset(&tab[b], t,
474 d - b + 1);
475 fmt += 2;
476 } else {
477 tab[c] = t;
478 fmt++;
479 }
480 }
481 fmt++;
482 }
483 }
484 #endif /* _WIDE */
485
486 #ifdef _WIDE
487 if ((ch >= 0) && (ch < 256) &&
488 isupper((int)ch)) { /* no longer documented */
489 if (_lib_version == c_issue_4) {
490 if (size != 'm' && size != 'L')
491 size = 'l';
492 }
493 ch = _tolower((int)ch);
494 }
495 if (ch != 'n' && !flag_eof) {
496 if (ch != 'c' && ch != 'C' && ch != '[') {
497 while (iswspace(inchar =
498 _wd_getwc(&chcount, iop)))
499 ;
500 if (_wd_ungetwc(&chcount, inchar, iop) == WEOF)
501 break;
502
503 }
504 }
505 #else /* _WIDE */
506 if (isupper(ch)) { /* no longer documented */
507 if (_lib_version == c_issue_4) {
508 if (size != 'm' && size != 'L')
509 size = 'l';
510 }
511 ch = _tolower(ch);
512 }
513 if (ch != 'n' && !flag_eof) {
514 if (ch != 'c' && ch != 'C' && ch != '[') {
515 while (isspace(inchar = locgetc(chcount)))
516 ;
517 if (locungetc(chcount, inchar) == EOF)
518 break;
519 }
520 }
521 #endif /* _WIDE */
522
523 switch (ch) {
524 case 'C':
525 case 'S':
526 case 'c':
527 case 's':
528 #ifdef _WIDE
529 if ((size == 'l') || (size == 'C') || (size == 'S'))
530 #else /* _WIDE */
531 if ((size == 'w') || (size == 'l') || (size == 'C') ||
532 (size == 'S'))
533 #endif /* _WIDE */
534 {
535 size = wstring(&chcount, &flag_eof, stow,
536 (int)ch, len, iop, &args.ap);
537 } else {
538 size = string(&chcount, &flag_eof, stow,
539 (int)ch, len, tab, iop, &args.ap);
540 }
541 break;
542 case '[':
543 if (size == 'l') {
544 size = wbrstring(&chcount, &flag_eof, stow,
545 (int)ch, len, iop, bracket_str, &args.ap);
546 free(bracket_str);
547 bracket_str = NULL;
548 } else {
549 #ifdef _WIDE
550 size = brstring(&chcount, &flag_eof, stow,
551 (int)ch, len, iop, bracket_str, &args.ap);
552 free(bracket_str);
553 bracket_str = NULL;
554 #else /* _WIDE */
555 size = string(&chcount, &flag_eof, stow,
556 ch, len, tab, iop, &args.ap);
557 #endif /* _WIDE */
558 }
559 break;
560
561 case 'n':
562 if (stow == 0)
563 continue;
564 if (size == 'b') /* char */
565 *va_arg(args.ap, char *) = (char)chcount;
566 else if (size == 'h')
567 *va_arg(args.ap, short *) = (short)chcount;
568 else if (size == 'l')
569 *va_arg(args.ap, long *) = (long)chcount;
570 else if (size == 'm') /* long long */
571 *va_arg(args.ap, long long *) =
572 (long long) chcount;
573 else
574 *va_arg(args.ap, int *) = (int)chcount;
575 continue;
576
577 case 'i':
578 default:
579 size = number(&chcount, &flag_eof, stow, (int)ch,
580 len, (int)size, iop, &args.ap);
581 break;
582 }
583 if (size)
584 nmatch += stow;
585 else {
586 return ((flag_eof && !nmatch) ? EOF : nmatch);
587 }
588 continue;
589 }
590 if (bracket_str)
591 free(bracket_str);
592 return (nmatch != 0 ? nmatch : EOF); /* end of input */
593 }
594
595 /* ****************************************************************** */
596 /* Functions to read the input stream in an attempt to match incoming */
597 /* data to the current pattern from the main loop of _doscan(). */
598 /* ****************************************************************** */
599 static int
600 number(int *chcount, int *flag_eof, int stow, int type, int len, int size,
601 FILE *iop, va_list *listp)
602 {
603 char numbuf[64];
604 char *np = numbuf;
605 int c, base, inchar, lookahead;
606 int digitseen = 0, floater = 0, negflg = 0;
607 int lc;
608 long long lcval = 0LL;
609
610 switch (type) {
611 case 'e':
612 case 'f':
613 case 'g':
614 /*
615 * lc = 0 corresponds to c90 mode: do not recognize
616 * hexadecimal fp strings; attempt to push back
617 * all unused characters read
618 *
619 * lc = -1 corresponds to c99 mode: recognize hexa-
620 * decimal fp strings; push back at most one
621 * unused character
622 */
623 lc = (__xpg6 & _C99SUSv3_recognize_hexfp)? -1 : 0;
624 floater = 1;
625 break;
626
627 case 'a':
628 lc = -1;
629 floater = 1;
630 break;
631
632 case 'd':
633 case 'u':
634 case 'i':
635 base = 10;
636 break;
637 case 'o':
638 base = 8;
639 break;
640 case 'p':
641 #ifdef _LP64
642 size = 'l'; /* pointers are long in LP64 */
643 #endif /* _LP64 */
644 /* FALLTHROUGH */
645 case 'x':
646 base = 16;
647 break;
648 default:
649 return (0); /* unrecognized conversion character */
650 }
651
652 if (floater != 0) {
653 /*
654 * Handle floating point with
655 * file_to_decimal.
656 */
657 decimal_mode dm;
658 decimal_record dr;
659 fp_exception_field_type efs;
660 enum decimal_string_form form;
661 char *echar;
662 int nread;
663 char buffer[1024+1];
664 char *nb = buffer;
665
666 if (len > 1024)
667 len = 1024;
668 file_to_decimal(&nb, len, lc, &dr, &form, &echar, iop, &nread);
669 if (lc == -1) {
670 /*
671 * In C99 mode, the entire string read has to be
672 * accepted in order to qualify as a match
673 */
674 if (nb != buffer + nread)
675 form = invalid_form;
676 }
677 if (stow && (form != invalid_form)) {
678 #if defined(__sparc)
679 dm.rd = _QgetRD();
680 if (size == 'L') { /* long double */
681 if ((int)form < 0)
682 __hex_to_quadruple(&dr, dm.rd,
683 va_arg(*listp, quadruple *), &efs);
684 else
685 decimal_to_quadruple(
686 va_arg(*listp, quadruple *),
687 &dm, &dr, &efs);
688 }
689 #elif defined(__i386) || defined(__amd64)
690 dm.rd = __xgetRD();
691 if (size == 'L') { /* long double */
692 if ((int)form < 0)
693 __hex_to_extended(&dr, dm.rd,
694 va_arg(*listp, extended *), &efs);
695 else
696 decimal_to_extended(
697 va_arg(*listp, extended *),
698 &dm, &dr, &efs);
699 }
700 #else
701 #error Unknown architecture
702 #endif
703 else if (size == 'l') { /* double */
704 if ((int)form < 0)
705 __hex_to_double(&dr, dm.rd,
706 va_arg(*listp, double *), &efs);
707 else
708 decimal_to_double(
709 va_arg(*listp, double *),
710 &dm, &dr, &efs);
711 } else { /* float */
712 if ((int)form < 0)
713 __hex_to_single(&dr, dm.rd,
714 va_arg(*listp, single *), &efs);
715 else
716 decimal_to_single((single *)
717 va_arg(*listp, single *),
718 &dm, &dr, &efs);
719 }
720 if ((efs & (1 << fp_overflow)) != 0) {
721 errno = ERANGE;
722 }
723 if ((efs & (1 << fp_underflow)) != 0) {
724 errno = ERANGE;
725 }
726 }
727 (*chcount) += nread; /* Count characters read. */
728 c = locgetc((*chcount));
729 if (locungetc((*chcount), c) == EOF)
730 *flag_eof = 1;
731 return ((form == invalid_form) ? 0 : 1);
732 /* successful match if non-zero */
733 }
734
735 switch (c = locgetc((*chcount))) {
736 case '-':
737 negflg++;
738 /* FALLTHROUGH */
739 case '+':
740 if (--len <= 0)
741 break;
742 if ((c = locgetc((*chcount))) != '0')
743 break;
744 /* FALLTHROUGH */
745 case '0':
746 /*
747 * If %i or %x, the characters 0x or 0X may optionally precede
748 * the sequence of letters and digits (base 16).
749 */
750 if ((type != 'i' && type != 'x') || (len <= 1))
751 break;
752 if (((inchar = locgetc((*chcount))) == 'x') ||
753 (inchar == 'X')) {
754 lookahead = readchar(iop, chcount);
755 if (isxdigit(lookahead)) {
756 base = 16;
757
758 if (len <= 2) {
759 (void) locungetc((*chcount), lookahead);
760 /* Take into account the 'x' */
761 len -= 1;
762 } else {
763 c = lookahead;
764 /* Take into account '0x' */
765 len -= 2;
766 }
767 } else {
768 (void) locungetc((*chcount), lookahead);
769 (void) locungetc((*chcount), inchar);
770 }
771 } else {
772 /* inchar wans't 'x'. */
773 (void) locungetc((*chcount), inchar); /* Put it back. */
774 if (type == 'i') /* Only %i accepts an octal. */
775 base = 8;
776 }
777 }
778 for (; --len >= 0; *np++ = (char)c, c = locgetc((*chcount))) {
779 if (np > numbuf + 62) {
780 errno = ERANGE;
781 return (0);
782 }
783 if (isdigit(c) || base == 16 && isxdigit(c)) {
784 int digit = c - (isdigit(c) ? '0' :
785 isupper(c) ? 'A' - 10 : 'a' - 10);
786 if (digit >= base)
787 break;
788 if (stow)
789 lcval = base * lcval + digit;
790 digitseen++;
791 continue;
792 }
793 break;
794 }
795
796 if (stow && digitseen) {
797 /* suppress possible overflow on 2's-comp negation */
798 if (negflg && lcval != (1ULL << 63))
799 lcval = -lcval;
800 switch (size) {
801 case 'm':
802 *va_arg(*listp, long long *) = lcval;
803 break;
804 case 'l':
805 *va_arg(*listp, long *) = (long)lcval;
806 break;
807 case 'h':
808 *va_arg(*listp, short *) = (short)lcval;
809 break;
810 case 'b':
811 *va_arg(*listp, char *) = (char)lcval;
812 break;
813 default:
814 *va_arg(*listp, int *) = (int)lcval;
815 break;
816 }
817 }
818 if (locungetc((*chcount), c) == EOF)
819 *flag_eof = 1;
820 return (digitseen); /* successful match if non-zero */
821 }
822
823 /* Get a character. If not using sscanf and at the buffer's end */
824 /* then do a direct read(). Characters read via readchar() */
825 /* can be pushed back on the input stream by locungetc((*chcount),) */
826 /* since there is padding allocated at the end of the stream buffer. */
827 static int
828 readchar(FILE *iop, int *chcount)
829 {
830 int inchar;
831 char buf[1];
832
833 if ((iop->_flag & _IOWRT) || (iop->_cnt != 0))
834 inchar = locgetc((*chcount));
835 else {
836 if (read(FILENO(iop), buf, 1) != 1)
837 return (EOF);
838 inchar = (int)buf[0];
839 (*chcount) += 1;
840 }
841 return (inchar);
842 }
843
844 static int
845 string(int *chcount, int *flag_eof, int stow, int type, int len, char *tab,
846 FILE *iop, va_list *listp)
847 {
848 int ch;
849 char *ptr;
850 char *start;
851
852 start = ptr = stow ? va_arg(*listp, char *) : NULL;
853 if (((type == 'c') || (type == 'C')) && len == MAXINT)
854 len = 1;
855 #ifdef _WIDE
856 while ((ch = locgetc((*chcount))) != EOF &&
857 !(((type == 's') || (type == 'S')) && isspace(ch))) {
858 #else /* _WIDE */
859 while ((ch = locgetc((*chcount))) != EOF &&
860 !(((type == 's') || (type == 'S')) &&
861 isspace(ch) || type == '[' && tab[ch])) {
862 #endif /* _WIDE */
863 if (stow)
864 *ptr = (char)ch;
865 ptr++;
866 if (--len <= 0)
867 break;
868 }
869 if (ch == EOF) {
870 (*flag_eof) = 1;
871 (*chcount) -= 1;
872 } else if (len > 0 && locungetc((*chcount), ch) == EOF)
873 (*flag_eof) = 1;
874 if (ptr == start)
875 return (0); /* no match */
876 if (stow && ((type != 'c') && (type != 'C')))
877 *ptr = '\0';
878 return (1); /* successful match */
879 }
880
881 /* This function initializes arglst, to contain the appropriate */
882 /* va_list values for the first MAXARGS arguments. */
883 /* WARNING: this code assumes that the sizes of all pointer types */
884 /* are the same. (Code similar to that in the portable doprnt.c */
885 /* should be used if this assumption is not true for a */
886 /* particular port.) */
887
888 #ifdef _WIDE
889 static int
890 _mkarglst(const wchar_t *fmt, stva_list args, stva_list arglst[])
891 #else /* _WIDE */
892 static int
893 _mkarglst(const char *fmt, stva_list args, stva_list arglst[])
894 #endif /* _WIDE */
895 {
896 #ifdef _WIDE
897 #define STRCHR wcschr
898 #define STRSPN wcsspn
899 #define ATOI(x) _watoi((wchar_t *)x)
900 #define SPNSTR1 L"01234567890"
901 #define SPNSTR2 L"# +-.0123456789hL$"
902 #else /* _WIDE */
903 #define STRCHR strchr
904 #define STRSPN strspn
905 #define ATOI(x) atoi(x)
906 #define SPNSTR1 "01234567890"
907 #define SPNSTR2 "# +-.0123456789hL$"
908 #endif /* _WIDE */
909
910 int maxnum, curargno;
911 size_t n;
912
913 maxnum = -1;
914 curargno = 0;
915
916 while ((fmt = STRCHR(fmt, '%')) != NULL) {
917 fmt++; /* skip % */
918 if (*fmt == '*' || *fmt == '%')
919 continue;
920 if (fmt[n = STRSPN(fmt, SPNSTR1)] == L'$') {
921 /* convert to zero base */
922 curargno = ATOI(fmt) - 1;
923 fmt += n + 1;
924 }
925
926 if (maxnum < curargno)
927 maxnum = curargno;
928 curargno++; /* default to next in list */
929
930 fmt += STRSPN(fmt, SPNSTR2);
931 if (*fmt == '[') {
932 int i;
933 fmt++; /* has to be at least on item in scan list */
934 if (*fmt == ']') {
935 fmt++;
936 }
937 while (*fmt != ']') {
938 if (*fmt == L'\0') {
939 return (-1); /* bad format */
940 #ifdef _WIDE
941 } else {
942 fmt++;
943 }
944 #else /* _WIDE */
945 } else if (isascii(*fmt)) {
946 fmt++;
947 } else {
948 i = mblen((const char *)
949 fmt, MB_CUR_MAX);
950 if (i <= 0) {
951 return (-1);
952 } else {
953 fmt += i;
954 }
955 }
956 #endif /* _WIDE */
957 }
958 }
959 }
960 if (maxnum > MAXARGS)
961 maxnum = MAXARGS;
962 for (n = 0; n <= maxnum; n++) {
963 arglst[n] = args;
964 (void) va_arg(args.ap, void *);
965 }
966 return (0);
967 }
968
969
970 /*
971 * For wide character handling
972 */
973
974 #ifdef _WIDE
975 static int
976 wstring(int *chcount, int *flag_eof, int stow, int type,
977 int len, FILE *iop, va_list *listp)
978 {
979 wint_t wch;
980 wchar_t *ptr;
981 wchar_t *wstart;
982 int dummy;
983
984 wstart = ptr = stow ? va_arg(*listp, wchar_t *) : NULL;
985
986 if ((type == 'c') && len == MAXINT)
987 len = 1;
988 while (((wch = _wd_getwc(chcount, iop)) != WEOF) &&
989 !(type == 's' && iswspace(wch))) {
990 if (stow)
991 *ptr = wch;
992 ptr++;
993 if (--len <= 0)
994 break;
995 }
996 if (wch == WEOF) {
997 *flag_eof = 1;
998 (*chcount) -= 1;
999 } else {
1000 if (len > 0 && _wd_ungetwc(chcount, wch, iop) == WEOF)
1001 *flag_eof = 1;
1002 }
1003 if (ptr == wstart)
1004 return (0); /* no match */
1005 if (stow && (type != 'c'))
1006 *ptr = '\0';
1007 return (1); /* successful match */
1008 }
1009
1010 #else /* _WIDE */
1011 static int
1012 wstring(int *chcount, int *flag_eof, int stow, int type, int len, FILE *iop,
1013 va_list *listp)
1014 {
1015 int wch;
1016 wchar_t *ptr;
1017 wchar_t *wstart;
1018
1019 wstart = ptr = stow ? va_arg(*listp, wchar_t *) : NULL;
1020
1021 if ((type == 'c') && len == MAXINT)
1022 len = 1;
1023 while (((wch = _bi_getwc(iop)) != EOF) &&
1024 !(type == 's' && (isascii(wch) ? isspace(wch) : 0))) {
1025 (*chcount) += _scrwidth((wchar_t)wch);
1026 if (stow)
1027 *ptr = wch;
1028 ptr++;
1029 if (--len <= 0)
1030 break;
1031 }
1032 if (wch == EOF) {
1033 (*flag_eof) = 1;
1034 (*chcount) -= 1;
1035 } else {
1036 if (len > 0 && _bi_ungetwc(wch, iop) == EOF)
1037 (*flag_eof) = 1;
1038 }
1039 if (ptr == wstart)
1040 return (0); /* no match */
1041 if (stow && (type != 'c'))
1042 *ptr = '\0';
1043 return (1); /* successful match */
1044 }
1045 #endif /* _WIDE */
1046
1047 #ifdef _WIDE
1048 static wint_t
1049 _wd_getwc(int *chcount, FILE *iop)
1050 {
1051 wint_t wc;
1052 int len;
1053
1054 if (!(iop->_flag & _IOWRT)) {
1055 /* call from fwscanf, wscanf */
1056 wc = __fgetwc_xpg5(iop);
1057 (*chcount)++;
1058 return (wc);
1059 } else {
1060 /* call from swscanf */
1061 if (*iop->_ptr == '\0')
1062 return (WEOF);
1063 len = mbtowc((wchar_t *)&wc, (const char *)iop->_ptr,
1064 MB_CUR_MAX);
1065 if (len == -1)
1066 return (WEOF);
1067 iop->_ptr += len;
1068 (*chcount)++;
1069 return (wc);
1070 }
1071 }
1072
1073 static wint_t
1074 _wd_ungetwc(int *chcount, wchar_t wc, FILE *iop)
1075 {
1076 wint_t ret;
1077 int len;
1078 char mbs[MB_LEN_MAX];
1079
1080 if (wc == WEOF)
1081 return (WEOF);
1082
1083 if (!(iop->_flag & _IOWRT)) {
1084 /* call from fwscanf, wscanf */
1085 ret = __ungetwc_xpg5((wint_t)wc, iop);
1086 if (ret != (wint_t)wc)
1087 return (WEOF);
1088 (*chcount)--;
1089 return (ret);
1090 } else {
1091 /* call from swscanf */
1092 len = wctomb(mbs, wc);
1093 if (len == -1)
1094 return (WEOF);
1095 iop->_ptr -= len;
1096 (*chcount)--;
1097 return ((wint_t)wc);
1098 }
1099 }
1100
1101 static int
1102 _watoi(wchar_t *fmt)
1103 {
1104 int n = 0;
1105 wchar_t ch;
1106
1107 ch = *fmt;
1108 if ((ch >= 0) && (ch < 256) && isdigit((int)ch)) {
1109 n = ch - '0';
1110 while (((ch = *++fmt) >= 0) && (ch < 256) &&
1111 isdigit((int)ch)) {
1112 n *= 10;
1113 n += ch - '0';
1114 }
1115 }
1116 return (n);
1117 }
1118 #endif /* _WIDE */
1119
1120 /* ARGSUSED3 */
1121 static int
1122 wbrstring(int *chcount, int *flag_eof, int stow, int type,
1123 int len, FILE *iop, unsigned char *brstr, va_list *listp)
1124 {
1125 wint_t wch;
1126 int i;
1127 char str[MB_LEN_MAX + 1]; /* include null termination */
1128 wchar_t *ptr, *start;
1129 #ifdef _WIDE
1130 int dummy;
1131 #endif /* _WIDE */
1132
1133 start = ptr = stow ? va_arg(*listp, wchar_t *) : NULL;
1134
1135 #ifdef _WIDE
1136 while ((wch = _wd_getwc(&dummy, iop)) != WEOF) {
1137 #else /* _WIDE */
1138 while ((wch = _bi_getwc(iop)) != WEOF) {
1139 #endif /* _WIDE */
1140 i = wctomb(str, (wchar_t)wch);
1141 if (i == -1) {
1142 return (0);
1143 }
1144 str[i] = '\0';
1145 if (fnmatch((const char *)brstr, (const char *)str,
1146 FNM_NOESCAPE)) {
1147 break;
1148 } else {
1149 if (len > 0) {
1150 #ifdef _WIDE
1151 (*chcount)++;
1152 #else /* _WIDE */
1153 (*chcount) += _scrwidth(wch);
1154 #endif /* _WIDE */
1155 len--;
1156 if (stow) {
1157 *ptr = wch;
1158 }
1159 ptr++;
1160 if (len <= 0)
1161 break;
1162 } else {
1163 break;
1164 }
1165 }
1166 }
1167 if (wch == WEOF) {
1168 *flag_eof = 1;
1169 } else {
1170 #ifdef _WIDE
1171 if (len > 0 && _wd_ungetwc(&dummy, wch, iop) == WEOF)
1172 #else /* _WIDE */
1173 if (len > 0 && _bi_ungetwc(wch, iop) == WEOF)
1174 #endif /* _WIDE */
1175 *flag_eof = 1;
1176 }
1177 if (ptr == start)
1178 return (0); /* no match */
1179 if (stow)
1180 *ptr = L'\0';
1181 return (1); /* successful match */
1182 }
1183
1184 #ifdef _WIDE
1185 static int
1186 brstring(int *chcount, int *flag_eof, int stow, int type,
1187 int len, FILE *iop, unsigned char *brstr, va_list *listp)
1188 {
1189 wint_t wch;
1190 int i;
1191 char str[MB_LEN_MAX + 1]; /* include null termination */
1192 char *ptr, *start, *p;
1193 int dummy;
1194
1195 start = ptr = stow ? va_arg(*listp, char *) : NULL;
1196
1197 while ((wch = _wd_getwc(&dummy, iop)) != WEOF) {
1198 p = str;
1199 i = wctomb(str, (wchar_t)wch);
1200 if (i == -1) {
1201 return (0);
1202 }
1203 str[i] = '\0';
1204 if (fnmatch((const char *)brstr, (const char *)str,
1205 FNM_NOESCAPE)) {
1206 break;
1207 } else {
1208 if (len >= i) {
1209 (*chcount)++;
1210 len -= i;
1211 if (stow) {
1212 while (i-- > 0) {
1213 *ptr++ = *p++;
1214 }
1215 } else {
1216 while (i-- > 0) {
1217 ptr++;
1218 }
1219 }
1220 if (len <= 0)
1221 break;
1222 } else {
1223 break;
1224 }
1225 }
1226 }
1227 if (wch == WEOF) {
1228 *flag_eof = 1;
1229 } else {
1230 if (len > 0 && _wd_ungetwc(&dummy, wch, iop) == WEOF)
1231 *flag_eof = 1;
1232 }
1233 if (ptr == start)
1234 return (0); /* no match */
1235 if (stow)
1236 *ptr = '\0';
1237 return (1); /* successful match */
1238 }
1239 #endif /* _WIDE */
1240
1241 /*
1242 * Locally define getwc and ungetwc
1243 */
1244 static int
1245 _bi_getwc(FILE *iop)
1246 {
1247 int c;
1248 wchar_t intcode;
1249 int i, nbytes, cur_max;
1250 char buff[MB_LEN_MAX];
1251
1252 if ((c = wlocgetc()) == EOF)
1253 return (WEOF);
1254
1255 if (isascii(c)) /* ASCII code */
1256 return ((wint_t)c);
1257
1258 buff[0] = (char)c;
1259
1260 cur_max = (int)MB_CUR_MAX;
1261 /* MB_CUR_MAX doen't exeed the value of MB_LEN_MAX */
1262 /* So we use MB_CUR_MAX instead of MB_LEN_MAX for */
1263 /* improving the performance. */
1264 for (i = 1; i < cur_max; i++) {
1265 c = wlocgetc();
1266 if (c == '\n') {
1267 (void) wlocungetc(c);
1268 break;
1269 }
1270 if (c == EOF) {
1271 /* this still may be a valid multibyte character */
1272 break;
1273 }
1274 buff[i] = (char)c;
1275 }
1276
1277 if ((nbytes = mbtowc(&intcode, buff, i)) == -1) {
1278 /*
1279 * If mbtowc fails, the input was not a legal character.
1280 * ungetc all but one character.
1281 *
1282 * Note: the number of pushback characters that
1283 * ungetc() can handle must be >= (MB_LEN_MAX - 1).
1284 * In Solaris 2.x, the number of pushback
1285 * characters is 4.
1286 */
1287 while (i-- > 1) {
1288 (void) wlocungetc((signed char)buff[i]);
1289 }
1290 errno = EILSEQ;
1291 return (WEOF); /* Illegal EUC sequence. */
1292 }
1293
1294 while (i-- > nbytes) {
1295 /*
1296 * Note: the number of pushback characters that
1297 * ungetc() can handle must be >= (MB_LEN_MAX - 1).
1298 * In Solaris 2.x, the number of pushback
1299 * characters is 4.
1300 */
1301 (void) wlocungetc((signed char)buff[i]);
1302 }
1303 return ((int)intcode);
1304 }
1305
1306 static int
1307 _bi_ungetwc(wint_t wc, FILE *iop)
1308 {
1309 char mbs[MB_LEN_MAX];
1310 unsigned char *p;
1311 int n;
1312
1313 if ((wc == WEOF) || ((iop->_flag & _IOREAD) == 0))
1314 return (WEOF);
1315
1316 n = wctomb(mbs, (wchar_t)wc);
1317 if (n <= 0)
1318 return (WEOF);
1319
1320 if (iop->_ptr <= iop->_base) {
1321 if (iop->_base == NULL) {
1322 return (WEOF);
1323 }
1324 if ((iop->_ptr == iop->_base) && (iop->_cnt == 0)) {
1325 ++iop->_ptr;
1326 } else if ((iop->_ptr - n) < (iop->_base - PUSHBACK)) {
1327 return (WEOF);
1328 }
1329 }
1330
1331 p = (unsigned char *)(mbs+n-1); /* p points the last byte */
1332 /* if _IOWRT is set to iop->_flag, it means this is */
1333 /* an invocation from sscanf(), and in that time we */
1334 /* don't touch iop->_cnt. Otherwise, which means an */
1335 /* invocation from fscanf() or scanf(), we touch iop->_cnt */
1336 if ((iop->_flag & _IOWRT) == 0) {
1337 /* scanf() and fscanf() */
1338 iop->_cnt += n;
1339 while (n--) {
1340 *--iop->_ptr = *(p--);
1341 }
1342 } else {
1343 /* sscanf() */
1344 iop->_ptr -= n;
1345 }
1346 return (wc);
1347 }
unleashed repo fork