1 | /* |
---|
2 | FUNCTION |
---|
3 | <<vscanf>>, <<vfscanf>>, <<vsscanf>>---format argument list |
---|
4 | |
---|
5 | INDEX |
---|
6 | vscanf |
---|
7 | INDEX |
---|
8 | vfscanf |
---|
9 | INDEX |
---|
10 | vsscanf |
---|
11 | |
---|
12 | SYNOPSIS |
---|
13 | #include <stdio.h> |
---|
14 | #include <stdarg.h> |
---|
15 | int vscanf(const char *restrict <[fmt]>, va_list <[list]>); |
---|
16 | int vfscanf(FILE *restrict <[fp]>, const char *restrict <[fmt]>, va_list <[list]>); |
---|
17 | int vsscanf(const char *restrict <[str]>, const char *restrict <[fmt]>, va_list <[list]>); |
---|
18 | |
---|
19 | int _vscanf_r(void *<[reent]>, const char *restrict <[fmt]>, |
---|
20 | va_list <[list]>); |
---|
21 | int _vfscanf_r(void *<[reent]>, FILE *restrict <[fp]>, const char *restrict <[fmt]>, |
---|
22 | va_list <[list]>); |
---|
23 | int _vsscanf_r(void *<[reent]>, const char *restrict <[str]>, const char *restrict <[fmt]>, |
---|
24 | va_list <[list]>); |
---|
25 | |
---|
26 | DESCRIPTION |
---|
27 | <<vscanf>>, <<vfscanf>>, and <<vsscanf>> are (respectively) variants |
---|
28 | of <<scanf>>, <<fscanf>>, and <<sscanf>>. They differ only in |
---|
29 | allowing their caller to pass the variable argument list as a |
---|
30 | <<va_list>> object (initialized by <<va_start>>) rather than |
---|
31 | directly accepting a variable number of arguments. |
---|
32 | |
---|
33 | RETURNS |
---|
34 | The return values are consistent with the corresponding functions: |
---|
35 | <<vscanf>> returns the number of input fields successfully scanned, |
---|
36 | converted, and stored; the return value does not include scanned |
---|
37 | fields which were not stored. |
---|
38 | |
---|
39 | If <<vscanf>> attempts to read at end-of-file, the return value |
---|
40 | is <<EOF>>. |
---|
41 | |
---|
42 | If no fields were stored, the return value is <<0>>. |
---|
43 | |
---|
44 | The routines <<_vscanf_r>>, <<_vfscanf_f>>, and <<_vsscanf_r>> are |
---|
45 | reentrant versions which take an additional first parameter which points to the |
---|
46 | reentrancy structure. |
---|
47 | |
---|
48 | PORTABILITY |
---|
49 | These are GNU extensions. |
---|
50 | |
---|
51 | Supporting OS subroutines required: |
---|
52 | */ |
---|
53 | |
---|
54 | /*- |
---|
55 | * Copyright (c) 1990 The Regents of the University of California. |
---|
56 | * All rights reserved. |
---|
57 | * |
---|
58 | * Redistribution and use in source and binary forms are permitted |
---|
59 | * provided that the above copyright notice and this paragraph are |
---|
60 | * duplicated in all such forms and that any documentation, |
---|
61 | * advertising materials, and other materials related to such |
---|
62 | * distribution and use acknowledge that the software was developed |
---|
63 | * by the University of California, Berkeley. The name of the |
---|
64 | * University may not be used to endorse or promote products derived |
---|
65 | * from this software without specific prior written permission. |
---|
66 | * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR |
---|
67 | * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED |
---|
68 | * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. |
---|
69 | */ |
---|
70 | |
---|
71 | #include <_ansi.h> |
---|
72 | #include <reent.h> |
---|
73 | #include <newlib.h> |
---|
74 | #include <ctype.h> |
---|
75 | #include <stdio.h> |
---|
76 | #include <stdlib.h> |
---|
77 | #include <limits.h> |
---|
78 | #include <wchar.h> |
---|
79 | #include <string.h> |
---|
80 | #include <stdarg.h> |
---|
81 | #include "local.h" |
---|
82 | |
---|
83 | #ifndef NO_FLOATING_POINT |
---|
84 | #define FLOATING_POINT |
---|
85 | #endif |
---|
86 | |
---|
87 | #ifdef FLOATING_POINT |
---|
88 | #include <float.h> |
---|
89 | |
---|
90 | /* Currently a test is made to see if long double processing is warranted. |
---|
91 | This could be changed in the future should the _ldtoa_r code be |
---|
92 | preferred over _dtoa_r. */ |
---|
93 | #define _NO_LONGDBL |
---|
94 | #if defined _WANT_IO_LONG_DOUBLE && (LDBL_MANT_DIG > DBL_MANT_DIG) |
---|
95 | #undef _NO_LONGDBL |
---|
96 | #endif |
---|
97 | |
---|
98 | #define _NO_LONGLONG |
---|
99 | #if defined _WANT_IO_LONG_LONG && defined __GNUC__ |
---|
100 | # undef _NO_LONGLONG |
---|
101 | #endif |
---|
102 | |
---|
103 | #include "floatio.h" |
---|
104 | #define BUF (MAXEXP+MAXFRACT+3) /* 3 = sign + decimal point + NUL */ |
---|
105 | /* An upper bound for how long a long prints in decimal. 4 / 13 approximates |
---|
106 | log (2). Add one char for roundoff compensation and one for the sign. */ |
---|
107 | #define MAX_LONG_LEN ((CHAR_BIT * sizeof (long) - 1) * 4 / 13 + 2) |
---|
108 | #else |
---|
109 | #define BUF 40 |
---|
110 | #endif |
---|
111 | |
---|
112 | /* |
---|
113 | * Flags used during conversion. |
---|
114 | */ |
---|
115 | |
---|
116 | #define LONG 0x01 /* l: long or double */ |
---|
117 | #define LONGDBL 0x02 /* L: long double or long long */ |
---|
118 | #define SHORT 0x04 /* h: short */ |
---|
119 | #define SUPPRESS 0x10 /* suppress assignment */ |
---|
120 | #define POINTER 0x20 /* weird %p pointer (`fake hex') */ |
---|
121 | #define NOSKIP 0x40 /* do not skip blanks */ |
---|
122 | |
---|
123 | /* |
---|
124 | * The following are used in numeric conversions only: |
---|
125 | * SIGNOK, NDIGITS, DPTOK, and EXPOK are for floating point; |
---|
126 | * SIGNOK, NDIGITS, PFXOK, and NZDIGITS are for integral. |
---|
127 | */ |
---|
128 | |
---|
129 | #define SIGNOK 0x80 /* +/- is (still) legal */ |
---|
130 | #define NDIGITS 0x100 /* no digits detected */ |
---|
131 | |
---|
132 | #define DPTOK 0x200 /* (float) decimal point is still legal */ |
---|
133 | #define EXPOK 0x400 /* (float) exponent (e+3, etc) still legal */ |
---|
134 | |
---|
135 | #define PFXOK 0x200 /* 0x prefix is (still) legal */ |
---|
136 | #define NZDIGITS 0x400 /* no zero digits detected */ |
---|
137 | #define NNZDIGITS 0x800 /* no non-zero digits detected */ |
---|
138 | |
---|
139 | #define VECTOR 0x2000 /* v: vector */ |
---|
140 | #define FIXEDPOINT 0x4000 /* r/R: fixed-point */ |
---|
141 | #define SIGNED 0x8000 /* r: signed fixed-point */ |
---|
142 | |
---|
143 | /* |
---|
144 | * Conversion types. |
---|
145 | */ |
---|
146 | |
---|
147 | #define CT_CHAR 0 /* %c conversion */ |
---|
148 | #define CT_CCL 1 /* %[...] conversion */ |
---|
149 | #define CT_STRING 2 /* %s conversion */ |
---|
150 | #define CT_INT 3 /* integer, i.e., strtol or strtoul */ |
---|
151 | #define CT_FLOAT 4 /* floating, i.e., strtod */ |
---|
152 | |
---|
153 | #if 0 |
---|
154 | #define u_char unsigned char |
---|
155 | #endif |
---|
156 | #define u_char char |
---|
157 | #define u_long unsigned long |
---|
158 | |
---|
159 | #ifndef _NO_LONGLONG |
---|
160 | typedef unsigned long long u_long_long; |
---|
161 | #endif |
---|
162 | |
---|
163 | typedef union |
---|
164 | { |
---|
165 | char c[16] __attribute__ ((__aligned__ (16))); |
---|
166 | short h[8]; |
---|
167 | long l[4]; |
---|
168 | int i[4]; |
---|
169 | float f[4]; |
---|
170 | } vec_union; |
---|
171 | |
---|
172 | /* |
---|
173 | * vfscanf |
---|
174 | */ |
---|
175 | |
---|
176 | #define BufferEmpty (fp->_r <= 0 && __srefill(fp)) |
---|
177 | |
---|
178 | #ifndef _REENT_ONLY |
---|
179 | |
---|
180 | int |
---|
181 | vfscanf (register FILE *__restrict fp, |
---|
182 | const char *__restrict fmt, |
---|
183 | va_list ap) |
---|
184 | { |
---|
185 | CHECK_INIT(_REENT, fp); |
---|
186 | return __svfscanf_r (_REENT, fp, fmt, ap); |
---|
187 | } |
---|
188 | |
---|
189 | int |
---|
190 | __svfscanf (fp, fmt0, ap) |
---|
191 | register FILE *fp; |
---|
192 | char const *fmt0; |
---|
193 | va_list ap; |
---|
194 | { |
---|
195 | return __svfscanf_r (_REENT, fp, fmt0, ap); |
---|
196 | } |
---|
197 | |
---|
198 | #endif /* !_REENT_ONLY */ |
---|
199 | |
---|
200 | int |
---|
201 | _vfscanf_r (struct _reent *data, |
---|
202 | register FILE *__restrict fp, |
---|
203 | const char *__restrict fmt, |
---|
204 | va_list ap) |
---|
205 | { |
---|
206 | return __svfscanf_r (data, fp, fmt, ap); |
---|
207 | } |
---|
208 | |
---|
209 | |
---|
210 | int |
---|
211 | __svfscanf_r (rptr, fp, fmt0, ap) |
---|
212 | struct _reent *rptr; |
---|
213 | register FILE *fp; |
---|
214 | char const *fmt0; |
---|
215 | va_list ap; |
---|
216 | { |
---|
217 | register u_char *fmt = (u_char *) fmt0; |
---|
218 | register int c; /* character from format, or conversion */ |
---|
219 | register int type; /* conversion type */ |
---|
220 | register size_t width; /* field width, or 0 */ |
---|
221 | register char *p; /* points into all kinds of strings */ |
---|
222 | register int n; /* handy integer */ |
---|
223 | register int flags; /* flags as defined above */ |
---|
224 | register char *p0; /* saves original value of p when necessary */ |
---|
225 | int orig_flags; /* saved flags used when processing vector */ |
---|
226 | int int_width; /* tmp area to store width when processing int */ |
---|
227 | int nassigned; /* number of fields assigned */ |
---|
228 | int nread; /* number of characters consumed from fp */ |
---|
229 | int base = 0; /* base argument to strtol/strtoul */ |
---|
230 | int nbytes = 1; /* number of bytes read from fmt string */ |
---|
231 | wchar_t wc; /* wchar to use to read format string */ |
---|
232 | char vec_sep; /* vector separator char */ |
---|
233 | char last_space_char; /* last white-space char eaten - needed for vec support */ |
---|
234 | int vec_read_count; /* number of vector items to read separately */ |
---|
235 | int looped; /* has vector processing looped */ |
---|
236 | u_long (*ccfn) () = 0; /* conversion function (strtol/strtoul) */ |
---|
237 | char ccltab[256]; /* character class table for %[...] */ |
---|
238 | char buf[BUF]; /* buffer for numeric conversions */ |
---|
239 | vec_union vec_buf; |
---|
240 | char *lptr; /* literal pointer */ |
---|
241 | #ifdef _MB_CAPABLE |
---|
242 | mbstate_t state; /* value to keep track of multibyte state */ |
---|
243 | #endif |
---|
244 | |
---|
245 | char *ch_dest; |
---|
246 | short *sp; |
---|
247 | int *ip; |
---|
248 | float *flp; |
---|
249 | _LONG_DOUBLE *ldp; |
---|
250 | double *dp; |
---|
251 | long *lp; |
---|
252 | #ifndef _NO_LONGLONG |
---|
253 | long long *llp; |
---|
254 | #else |
---|
255 | u_long _uquad; |
---|
256 | #endif |
---|
257 | |
---|
258 | /* `basefix' is used to avoid `if' tests in the integer scanner */ |
---|
259 | static const short basefix[17] = |
---|
260 | {10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}; |
---|
261 | |
---|
262 | nassigned = 0; |
---|
263 | nread = 0; |
---|
264 | for (;;) |
---|
265 | { |
---|
266 | #ifndef _MB_CAPABLE |
---|
267 | wc = *fmt; |
---|
268 | #else |
---|
269 | memset (&state, '\0', sizeof (state)); |
---|
270 | nbytes = _mbtowc_r (rptr, &wc, fmt, MB_CUR_MAX, &state); |
---|
271 | #endif |
---|
272 | fmt += nbytes; |
---|
273 | if (wc == 0) |
---|
274 | return nassigned; |
---|
275 | if (nbytes == 1 && isspace (wc)) |
---|
276 | { |
---|
277 | for (;;) |
---|
278 | { |
---|
279 | if (BufferEmpty) |
---|
280 | return nassigned; |
---|
281 | if (!isspace (*fp->_p)) |
---|
282 | break; |
---|
283 | nread++, fp->_r--, fp->_p++; |
---|
284 | } |
---|
285 | continue; |
---|
286 | } |
---|
287 | if (wc != '%') |
---|
288 | goto literal; |
---|
289 | width = 0; |
---|
290 | flags = 0; |
---|
291 | vec_sep = ' '; |
---|
292 | vec_read_count = 0; |
---|
293 | looped = 0; |
---|
294 | |
---|
295 | /* |
---|
296 | * switch on the format. continue if done; break once format |
---|
297 | * type is derived. |
---|
298 | */ |
---|
299 | |
---|
300 | again: |
---|
301 | c = *fmt++; |
---|
302 | |
---|
303 | switch (c) |
---|
304 | { |
---|
305 | case '%': |
---|
306 | literal: |
---|
307 | lptr = fmt - nbytes; |
---|
308 | for (n = 0; n < nbytes; ++n) |
---|
309 | { |
---|
310 | if (BufferEmpty) |
---|
311 | goto input_failure; |
---|
312 | if (*fp->_p != *lptr) |
---|
313 | goto match_failure; |
---|
314 | fp->_r--, fp->_p++; |
---|
315 | nread++; |
---|
316 | ++lptr; |
---|
317 | } |
---|
318 | continue; |
---|
319 | |
---|
320 | case '*': |
---|
321 | flags |= SUPPRESS; |
---|
322 | goto again; |
---|
323 | case ',': |
---|
324 | case ';': |
---|
325 | case ':': |
---|
326 | case '_': |
---|
327 | if (flags == SUPPRESS || flags == 0) |
---|
328 | vec_sep = c; |
---|
329 | goto again; |
---|
330 | case 'l': |
---|
331 | if (flags & SHORT) |
---|
332 | continue; /* invalid format, don't process any further */ |
---|
333 | if (flags & LONG) |
---|
334 | { |
---|
335 | flags &= ~LONG; |
---|
336 | flags &= ~VECTOR; |
---|
337 | flags |= LONGDBL; |
---|
338 | } |
---|
339 | else |
---|
340 | { |
---|
341 | flags |= LONG; |
---|
342 | if (flags & VECTOR) |
---|
343 | vec_read_count = 4; |
---|
344 | } |
---|
345 | goto again; |
---|
346 | case 'L': |
---|
347 | flags |= LONGDBL; |
---|
348 | flags &= ~VECTOR; |
---|
349 | goto again; |
---|
350 | case 'h': |
---|
351 | flags |= SHORT; |
---|
352 | if (flags & LONG) |
---|
353 | continue; /* invalid format, don't process any further */ |
---|
354 | if (flags & VECTOR) |
---|
355 | vec_read_count = 8; |
---|
356 | goto again; |
---|
357 | #ifdef __ALTIVEC__ |
---|
358 | case 'v': |
---|
359 | flags |= VECTOR; |
---|
360 | vec_read_count = (flags & SHORT) ? 8 : ((flags & LONG) ? 4 : 16); |
---|
361 | goto again; |
---|
362 | #endif |
---|
363 | case '0': |
---|
364 | case '1': |
---|
365 | case '2': |
---|
366 | case '3': |
---|
367 | case '4': |
---|
368 | case '5': |
---|
369 | case '6': |
---|
370 | case '7': |
---|
371 | case '8': |
---|
372 | case '9': |
---|
373 | width = width * 10 + c - '0'; |
---|
374 | goto again; |
---|
375 | |
---|
376 | /* |
---|
377 | * Conversions. Those marked `compat' are for |
---|
378 | * 4.[123]BSD compatibility. |
---|
379 | * |
---|
380 | * (According to ANSI, E and X formats are supposed to |
---|
381 | * the same as e and x. Sorry about that.) |
---|
382 | */ |
---|
383 | |
---|
384 | case 'D': /* compat */ |
---|
385 | flags |= LONG; |
---|
386 | /* FALLTHROUGH */ |
---|
387 | case 'd': |
---|
388 | type = CT_INT; |
---|
389 | ccfn = (u_long (*)())_strtol_r; |
---|
390 | base = 10; |
---|
391 | break; |
---|
392 | |
---|
393 | case 'i': |
---|
394 | type = CT_INT; |
---|
395 | ccfn = (u_long (*)())_strtol_r; |
---|
396 | base = 0; |
---|
397 | break; |
---|
398 | |
---|
399 | case 'O': /* compat */ |
---|
400 | flags |= LONG; |
---|
401 | /* FALLTHROUGH */ |
---|
402 | case 'o': |
---|
403 | type = CT_INT; |
---|
404 | ccfn = _strtoul_r; |
---|
405 | base = 8; |
---|
406 | break; |
---|
407 | |
---|
408 | case 'u': |
---|
409 | type = CT_INT; |
---|
410 | ccfn = _strtoul_r; |
---|
411 | base = 10; |
---|
412 | break; |
---|
413 | |
---|
414 | case 'X': /* compat XXX */ |
---|
415 | case 'x': |
---|
416 | flags |= PFXOK; /* enable 0x prefixing */ |
---|
417 | type = CT_INT; |
---|
418 | ccfn = _strtoul_r; |
---|
419 | base = 16; |
---|
420 | break; |
---|
421 | |
---|
422 | #ifdef FLOATING_POINT |
---|
423 | case 'E': /* compat XXX */ |
---|
424 | case 'G': /* compat XXX */ |
---|
425 | /* ANSI says that E,G and X behave the same way as e,g,x */ |
---|
426 | /* FALLTHROUGH */ |
---|
427 | case 'e': |
---|
428 | case 'f': |
---|
429 | case 'g': |
---|
430 | type = CT_FLOAT; |
---|
431 | if (flags & VECTOR) |
---|
432 | vec_read_count = 4; |
---|
433 | break; |
---|
434 | |
---|
435 | # ifdef __SPE__ |
---|
436 | /* treat fixed-point like %f floating point */ |
---|
437 | case 'r': |
---|
438 | flags |= SIGNED; |
---|
439 | /* fallthrough */ |
---|
440 | case 'R': |
---|
441 | flags |= FIXEDPOINT; |
---|
442 | type = CT_FLOAT; |
---|
443 | break; |
---|
444 | # endif |
---|
445 | #endif |
---|
446 | |
---|
447 | case 's': |
---|
448 | flags &= ~VECTOR; |
---|
449 | type = CT_STRING; |
---|
450 | break; |
---|
451 | |
---|
452 | case '[': |
---|
453 | fmt = __sccl (ccltab, fmt); |
---|
454 | flags |= NOSKIP; |
---|
455 | flags &= ~VECTOR; |
---|
456 | type = CT_CCL; |
---|
457 | break; |
---|
458 | |
---|
459 | case 'c': |
---|
460 | flags |= NOSKIP; |
---|
461 | type = CT_CHAR; |
---|
462 | if (flags & VECTOR) |
---|
463 | { |
---|
464 | /* not allowed to have h or l with c specifier */ |
---|
465 | if (flags & (LONG | SHORT)) |
---|
466 | continue; /* invalid format don't process any further */ |
---|
467 | width = 0; |
---|
468 | vec_read_count = 16; |
---|
469 | } |
---|
470 | break; |
---|
471 | |
---|
472 | case 'p': /* pointer format is like hex */ |
---|
473 | flags |= POINTER | PFXOK; |
---|
474 | type = CT_INT; |
---|
475 | ccfn = _strtoul_r; |
---|
476 | base = 16; |
---|
477 | break; |
---|
478 | |
---|
479 | case 'n': |
---|
480 | if (flags & SUPPRESS) /* ??? */ |
---|
481 | continue; |
---|
482 | flags &= ~VECTOR; |
---|
483 | if (flags & SHORT) |
---|
484 | { |
---|
485 | sp = va_arg (ap, short *); |
---|
486 | *sp = nread; |
---|
487 | } |
---|
488 | else if (flags & LONG) |
---|
489 | { |
---|
490 | lp = va_arg (ap, long *); |
---|
491 | *lp = nread; |
---|
492 | } |
---|
493 | #ifndef _NO_LONGLONG |
---|
494 | else if (flags & LONGDBL) |
---|
495 | { |
---|
496 | llp = va_arg (ap, long long*); |
---|
497 | *llp = nread; |
---|
498 | } |
---|
499 | #endif |
---|
500 | else |
---|
501 | { |
---|
502 | ip = va_arg (ap, int *); |
---|
503 | *ip = nread; |
---|
504 | } |
---|
505 | continue; |
---|
506 | |
---|
507 | /* |
---|
508 | * Disgusting backwards compatibility hacks. XXX |
---|
509 | */ |
---|
510 | case '\0': /* compat */ |
---|
511 | return EOF; |
---|
512 | |
---|
513 | default: /* compat */ |
---|
514 | if (isupper (c)) |
---|
515 | flags |= LONG; |
---|
516 | type = CT_INT; |
---|
517 | ccfn = (u_long (*)())_strtol_r; |
---|
518 | base = 10; |
---|
519 | break; |
---|
520 | } |
---|
521 | |
---|
522 | process: |
---|
523 | /* |
---|
524 | * We have a conversion that requires input. |
---|
525 | */ |
---|
526 | if (BufferEmpty) |
---|
527 | goto input_failure; |
---|
528 | |
---|
529 | /* |
---|
530 | * Consume leading white space, except for formats that |
---|
531 | * suppress this. |
---|
532 | */ |
---|
533 | last_space_char = '\0'; |
---|
534 | |
---|
535 | if ((flags & NOSKIP) == 0) |
---|
536 | { |
---|
537 | while (isspace (*fp->_p)) |
---|
538 | { |
---|
539 | last_space_char = *fp->_p; |
---|
540 | nread++; |
---|
541 | if (--fp->_r > 0) |
---|
542 | fp->_p++; |
---|
543 | else |
---|
544 | #ifndef CYGNUS_NEC |
---|
545 | if (__srefill (fp)) |
---|
546 | #endif |
---|
547 | goto input_failure; |
---|
548 | } |
---|
549 | /* |
---|
550 | * Note that there is at least one character in the |
---|
551 | * buffer, so conversions that do not set NOSKIP ca |
---|
552 | * no longer result in an input failure. |
---|
553 | */ |
---|
554 | } |
---|
555 | |
---|
556 | /* for vector formats process separator characters after first loop */ |
---|
557 | if (looped && (flags & VECTOR)) |
---|
558 | { |
---|
559 | flags = orig_flags; |
---|
560 | /* all formats other than default char have a separator char */ |
---|
561 | if (vec_sep != ' ' || type != CT_CHAR) |
---|
562 | { |
---|
563 | if (vec_sep == ' ' && last_space_char != ' ' || |
---|
564 | vec_sep != ' ' && *fp->_p != vec_sep) |
---|
565 | goto match_failure; |
---|
566 | if (vec_sep != ' ') |
---|
567 | { |
---|
568 | nread++; |
---|
569 | if (--fp->_r > 0) |
---|
570 | fp->_p++; |
---|
571 | else |
---|
572 | #ifndef CYGNUS_NEC |
---|
573 | if (__srefill (fp)) |
---|
574 | #endif |
---|
575 | goto input_failure; |
---|
576 | } |
---|
577 | } |
---|
578 | /* after eating the separator char, we must eat any white-space |
---|
579 | after the separator char that precedes the data to convert */ |
---|
580 | if ((flags & NOSKIP) == 0) |
---|
581 | { |
---|
582 | while (isspace (*fp->_p)) |
---|
583 | { |
---|
584 | last_space_char = *fp->_p; |
---|
585 | nread++; |
---|
586 | if (--fp->_r > 0) |
---|
587 | fp->_p++; |
---|
588 | else |
---|
589 | #ifndef CYGNUS_NEC |
---|
590 | if (__srefill (fp)) |
---|
591 | #endif |
---|
592 | goto input_failure; |
---|
593 | } |
---|
594 | } |
---|
595 | |
---|
596 | } |
---|
597 | else /* save to counter-act changes made to flags when processing */ |
---|
598 | orig_flags = flags; |
---|
599 | |
---|
600 | /* |
---|
601 | * Do the conversion. |
---|
602 | */ |
---|
603 | switch (type) |
---|
604 | { |
---|
605 | |
---|
606 | case CT_CHAR: |
---|
607 | /* scan arbitrary characters (sets NOSKIP) */ |
---|
608 | if (width == 0) |
---|
609 | width = 1; |
---|
610 | if (flags & SUPPRESS) |
---|
611 | { |
---|
612 | size_t sum = 0; |
---|
613 | |
---|
614 | for (;;) |
---|
615 | { |
---|
616 | if ((n = fp->_r) < (int)width) |
---|
617 | { |
---|
618 | sum += n; |
---|
619 | width -= n; |
---|
620 | fp->_p += n; |
---|
621 | #ifndef CYGNUS_NEC |
---|
622 | if (__srefill (fp)) |
---|
623 | { |
---|
624 | #endif |
---|
625 | if (sum == 0) |
---|
626 | goto input_failure; |
---|
627 | break; |
---|
628 | #ifndef CYGNUS_NEC |
---|
629 | } |
---|
630 | #endif |
---|
631 | } |
---|
632 | else |
---|
633 | { |
---|
634 | sum += width; |
---|
635 | fp->_r -= width; |
---|
636 | fp->_p += width; |
---|
637 | break; |
---|
638 | } |
---|
639 | } |
---|
640 | nread += sum; |
---|
641 | } |
---|
642 | else |
---|
643 | { |
---|
644 | int n = width; |
---|
645 | if (!looped) |
---|
646 | { |
---|
647 | if (flags & VECTOR) |
---|
648 | ch_dest = vec_buf.c; |
---|
649 | else |
---|
650 | ch_dest = va_arg (ap, char *); |
---|
651 | } |
---|
652 | #ifdef CYGNUS_NEC |
---|
653 | /* Kludge city for the moment */ |
---|
654 | if (fp->_r == 0) |
---|
655 | goto input_failure; |
---|
656 | |
---|
657 | while (n && fp->_r) |
---|
658 | { |
---|
659 | *ch_dest++ = *(fp->_p++); |
---|
660 | n--; |
---|
661 | fp->_r--; |
---|
662 | nread++; |
---|
663 | } |
---|
664 | #else |
---|
665 | size_t r = fread (ch_dest, 1, width, fp); |
---|
666 | |
---|
667 | if (r == 0) |
---|
668 | goto input_failure; |
---|
669 | nread += r; |
---|
670 | ch_dest += r; |
---|
671 | #endif |
---|
672 | if (!(flags & VECTOR)) |
---|
673 | nassigned++; |
---|
674 | } |
---|
675 | break; |
---|
676 | |
---|
677 | case CT_CCL: |
---|
678 | /* scan a (nonempty) character class (sets NOSKIP) */ |
---|
679 | if (width == 0) |
---|
680 | width = ~0; /* `infinity' */ |
---|
681 | /* take only those things in the class */ |
---|
682 | if (flags & SUPPRESS) |
---|
683 | { |
---|
684 | n = 0; |
---|
685 | while (ccltab[*fp->_p]) |
---|
686 | { |
---|
687 | n++, fp->_r--, fp->_p++; |
---|
688 | if (--width == 0) |
---|
689 | break; |
---|
690 | if (BufferEmpty) |
---|
691 | { |
---|
692 | if (n == 0) |
---|
693 | goto input_failure; |
---|
694 | break; |
---|
695 | } |
---|
696 | } |
---|
697 | if (n == 0) |
---|
698 | goto match_failure; |
---|
699 | } |
---|
700 | else |
---|
701 | { |
---|
702 | p0 = p = va_arg (ap, char *); |
---|
703 | while (ccltab[*fp->_p]) |
---|
704 | { |
---|
705 | fp->_r--; |
---|
706 | *p++ = *fp->_p++; |
---|
707 | if (--width == 0) |
---|
708 | break; |
---|
709 | if (BufferEmpty) |
---|
710 | { |
---|
711 | if (p == p0) |
---|
712 | goto input_failure; |
---|
713 | break; |
---|
714 | } |
---|
715 | } |
---|
716 | n = p - p0; |
---|
717 | if (n == 0) |
---|
718 | goto match_failure; |
---|
719 | *p = 0; |
---|
720 | nassigned++; |
---|
721 | } |
---|
722 | nread += n; |
---|
723 | break; |
---|
724 | |
---|
725 | case CT_STRING: |
---|
726 | /* like CCL, but zero-length string OK, & no NOSKIP */ |
---|
727 | if (width == 0) |
---|
728 | width = ~0; |
---|
729 | if (flags & SUPPRESS) |
---|
730 | { |
---|
731 | n = 0; |
---|
732 | while (!isspace (*fp->_p)) |
---|
733 | { |
---|
734 | n++, fp->_r--, fp->_p++; |
---|
735 | if (--width == 0) |
---|
736 | break; |
---|
737 | if (BufferEmpty) |
---|
738 | break; |
---|
739 | } |
---|
740 | nread += n; |
---|
741 | } |
---|
742 | else |
---|
743 | { |
---|
744 | p0 = p = va_arg (ap, char *); |
---|
745 | while (!isspace (*fp->_p)) |
---|
746 | { |
---|
747 | fp->_r--; |
---|
748 | *p++ = *fp->_p++; |
---|
749 | if (--width == 0) |
---|
750 | break; |
---|
751 | if (BufferEmpty) |
---|
752 | break; |
---|
753 | } |
---|
754 | *p = 0; |
---|
755 | nread += p - p0; |
---|
756 | nassigned++; |
---|
757 | } |
---|
758 | continue; |
---|
759 | |
---|
760 | case CT_INT: |
---|
761 | { |
---|
762 | unsigned int_width_left = 0; |
---|
763 | int skips = 0; |
---|
764 | int_width = width; |
---|
765 | #ifdef hardway |
---|
766 | if (int_width == 0 || int_width > sizeof (buf) - 1) |
---|
767 | #else |
---|
768 | /* size_t is unsigned, hence this optimisation */ |
---|
769 | if (int_width - 1 > sizeof (buf) - 2) |
---|
770 | #endif |
---|
771 | { |
---|
772 | int_width_left = width - (sizeof (buf) - 1); |
---|
773 | int_width = sizeof (buf) - 1; |
---|
774 | } |
---|
775 | flags |= SIGNOK | NDIGITS | NZDIGITS | NNZDIGITS; |
---|
776 | for (p = buf; int_width; int_width--) |
---|
777 | { |
---|
778 | c = *fp->_p; |
---|
779 | /* |
---|
780 | * Switch on the character; `goto ok' if we |
---|
781 | * accept it as a part of number. |
---|
782 | */ |
---|
783 | switch (c) |
---|
784 | { |
---|
785 | /* |
---|
786 | * The digit 0 is always legal, but is special. |
---|
787 | * For %i conversions, if no digits (zero or nonzero) |
---|
788 | * have been scanned (only signs), we will have base==0. |
---|
789 | * In that case, we should set it to 8 and enable 0x |
---|
790 | * prefixing. Also, if we have not scanned zero digits |
---|
791 | * before this, do not turn off prefixing (someone else |
---|
792 | * will turn it off if we have scanned any nonzero digits). |
---|
793 | */ |
---|
794 | case '0': |
---|
795 | if (! (flags & NNZDIGITS)) |
---|
796 | goto ok; |
---|
797 | if (base == 0) |
---|
798 | { |
---|
799 | base = 8; |
---|
800 | flags |= PFXOK; |
---|
801 | } |
---|
802 | if (flags & NZDIGITS) |
---|
803 | { |
---|
804 | flags &= ~(SIGNOK | NZDIGITS | NDIGITS); |
---|
805 | goto ok; |
---|
806 | } |
---|
807 | flags &= ~(SIGNOK | PFXOK | NDIGITS); |
---|
808 | if (int_width_left) |
---|
809 | { |
---|
810 | int_width_left--; |
---|
811 | int_width++; |
---|
812 | } |
---|
813 | ++skips; |
---|
814 | goto skip; |
---|
815 | |
---|
816 | /* 1 through 7 always legal */ |
---|
817 | case '1': |
---|
818 | case '2': |
---|
819 | case '3': |
---|
820 | case '4': |
---|
821 | case '5': |
---|
822 | case '6': |
---|
823 | case '7': |
---|
824 | base = basefix[base]; |
---|
825 | flags &= ~(SIGNOK | PFXOK | NDIGITS | NNZDIGITS); |
---|
826 | goto ok; |
---|
827 | |
---|
828 | /* digits 8 and 9 ok iff decimal or hex */ |
---|
829 | case '8': |
---|
830 | case '9': |
---|
831 | base = basefix[base]; |
---|
832 | if (base <= 8) |
---|
833 | break; /* not legal here */ |
---|
834 | flags &= ~(SIGNOK | PFXOK | NDIGITS | NNZDIGITS); |
---|
835 | goto ok; |
---|
836 | |
---|
837 | /* letters ok iff hex */ |
---|
838 | case 'A': |
---|
839 | case 'B': |
---|
840 | case 'C': |
---|
841 | case 'D': |
---|
842 | case 'E': |
---|
843 | case 'F': |
---|
844 | case 'a': |
---|
845 | case 'b': |
---|
846 | case 'c': |
---|
847 | case 'd': |
---|
848 | case 'e': |
---|
849 | case 'f': |
---|
850 | /* no need to fix base here */ |
---|
851 | if (base <= 10) |
---|
852 | break; /* not legal here */ |
---|
853 | flags &= ~(SIGNOK | PFXOK | NDIGITS | NNZDIGITS); |
---|
854 | goto ok; |
---|
855 | |
---|
856 | /* sign ok only as first character */ |
---|
857 | case '+': |
---|
858 | case '-': |
---|
859 | if (flags & SIGNOK) |
---|
860 | { |
---|
861 | flags &= ~SIGNOK; |
---|
862 | goto ok; |
---|
863 | } |
---|
864 | break; |
---|
865 | |
---|
866 | /* x ok iff flag still set & 2nd char */ |
---|
867 | case 'x': |
---|
868 | case 'X': |
---|
869 | if (flags & PFXOK && p == buf + 1) |
---|
870 | { |
---|
871 | base = 16;/* if %i */ |
---|
872 | flags &= ~PFXOK; |
---|
873 | /* We must reset the NZDIGITS and NDIGITS |
---|
874 | flags that would have been unset by seeing |
---|
875 | the zero that preceded the X or x. */ |
---|
876 | flags |= NZDIGITS | NDIGITS; |
---|
877 | goto ok; |
---|
878 | } |
---|
879 | break; |
---|
880 | } |
---|
881 | |
---|
882 | /* |
---|
883 | * If we got here, c is not a legal character |
---|
884 | * for a number. Stop accumulating digits. |
---|
885 | */ |
---|
886 | break; |
---|
887 | ok: |
---|
888 | /* |
---|
889 | * c is legal: store it and look at the next. |
---|
890 | */ |
---|
891 | *p++ = c; |
---|
892 | skip: |
---|
893 | if (--fp->_r > 0) |
---|
894 | fp->_p++; |
---|
895 | else |
---|
896 | #ifndef CYGNUS_NEC |
---|
897 | if (__srefill (fp)) |
---|
898 | #endif |
---|
899 | break; /* EOF */ |
---|
900 | } |
---|
901 | /* |
---|
902 | * If we had only a sign, it is no good; push back the sign. |
---|
903 | * If the number ends in `x', it was [sign] '0' 'x', so push back |
---|
904 | * the x and treat it as [sign] '0'. |
---|
905 | */ |
---|
906 | if (flags & NDIGITS) |
---|
907 | { |
---|
908 | if (p > buf) |
---|
909 | (void) ungetc (*(u_char *)-- p, fp); |
---|
910 | goto match_failure; |
---|
911 | } |
---|
912 | c = ((u_char *) p)[-1]; |
---|
913 | if (c == 'x' || c == 'X') |
---|
914 | { |
---|
915 | --p; |
---|
916 | /*(void)*/ ungetc (c, fp); |
---|
917 | } |
---|
918 | if ((flags & SUPPRESS) == 0) |
---|
919 | { |
---|
920 | u_long res; |
---|
921 | |
---|
922 | *p = 0; |
---|
923 | res = (*ccfn) (rptr, buf, (char **) NULL, base); |
---|
924 | if ((flags & POINTER) && !(flags & VECTOR)) |
---|
925 | *(va_arg (ap, void **)) = (void *) (unsigned _POINTER_INT) res; |
---|
926 | else if (flags & SHORT) |
---|
927 | { |
---|
928 | if (!(flags & VECTOR)) |
---|
929 | sp = va_arg (ap, short *); |
---|
930 | else if (!looped) |
---|
931 | sp = vec_buf.h; |
---|
932 | *sp++ = res; |
---|
933 | } |
---|
934 | else if (flags & LONG) |
---|
935 | { |
---|
936 | if (!(flags & VECTOR)) |
---|
937 | lp = va_arg (ap, long *); |
---|
938 | else if (!looped) |
---|
939 | lp = vec_buf.l; |
---|
940 | *lp++ = res; |
---|
941 | } |
---|
942 | #ifndef _NO_LONGLONG |
---|
943 | else if (flags & LONGDBL) |
---|
944 | { |
---|
945 | u_long_long resll; |
---|
946 | if (ccfn == _strtoul_r) |
---|
947 | resll = _strtoull_r (rptr, buf, (char **) NULL, base); |
---|
948 | else |
---|
949 | resll = _strtoll_r (rptr, buf, (char **) NULL, base); |
---|
950 | llp = va_arg (ap, long long*); |
---|
951 | *llp = resll; |
---|
952 | } |
---|
953 | #endif |
---|
954 | else |
---|
955 | { |
---|
956 | if (!(flags & VECTOR)) |
---|
957 | { |
---|
958 | ip = va_arg (ap, int *); |
---|
959 | *ip++ = res; |
---|
960 | } |
---|
961 | else |
---|
962 | { |
---|
963 | if (!looped) |
---|
964 | ch_dest = vec_buf.c; |
---|
965 | *ch_dest++ = (char)res; |
---|
966 | } |
---|
967 | } |
---|
968 | if (!(flags & VECTOR)) |
---|
969 | nassigned++; |
---|
970 | } |
---|
971 | nread += p - buf + skips; |
---|
972 | break; |
---|
973 | } |
---|
974 | |
---|
975 | #ifdef FLOATING_POINT |
---|
976 | case CT_FLOAT: |
---|
977 | { |
---|
978 | /* scan a floating point number as if by strtod */ |
---|
979 | /* This code used to assume that the number of digits is reasonable. |
---|
980 | However, ANSI / ISO C makes no such stipulation; we have to get |
---|
981 | exact results even when there is an unreasonable amount of |
---|
982 | leading zeroes. */ |
---|
983 | long leading_zeroes = 0; |
---|
984 | long zeroes, exp_adjust; |
---|
985 | char *exp_start = NULL; |
---|
986 | unsigned fl_width = width; |
---|
987 | unsigned width_left = 0; |
---|
988 | #ifdef hardway |
---|
989 | if (fl_width == 0 || fl_width > sizeof (buf) - 1) |
---|
990 | #else |
---|
991 | /* size_t is unsigned, hence this optimisation */ |
---|
992 | if (fl_width - 1 > sizeof (buf) - 2) |
---|
993 | #endif |
---|
994 | { |
---|
995 | width_left = fl_width - (sizeof (buf) - 1); |
---|
996 | fl_width = sizeof (buf) - 1; |
---|
997 | } |
---|
998 | flags |= SIGNOK | NDIGITS | DPTOK | EXPOK; |
---|
999 | zeroes = 0; |
---|
1000 | exp_adjust = 0; |
---|
1001 | for (p = buf; fl_width; ) |
---|
1002 | { |
---|
1003 | c = *fp->_p; |
---|
1004 | /* |
---|
1005 | * This code mimicks the integer conversion |
---|
1006 | * code, but is much simpler. |
---|
1007 | */ |
---|
1008 | switch (c) |
---|
1009 | { |
---|
1010 | |
---|
1011 | case '0': |
---|
1012 | if (flags & NDIGITS) |
---|
1013 | { |
---|
1014 | flags &= ~SIGNOK; |
---|
1015 | zeroes++; |
---|
1016 | if (width_left) |
---|
1017 | { |
---|
1018 | width_left--; |
---|
1019 | fl_width++; |
---|
1020 | } |
---|
1021 | goto fskip; |
---|
1022 | } |
---|
1023 | /* Fall through. */ |
---|
1024 | case '1': |
---|
1025 | case '2': |
---|
1026 | case '3': |
---|
1027 | case '4': |
---|
1028 | case '5': |
---|
1029 | case '6': |
---|
1030 | case '7': |
---|
1031 | case '8': |
---|
1032 | case '9': |
---|
1033 | flags &= ~(SIGNOK | NDIGITS); |
---|
1034 | goto fok; |
---|
1035 | |
---|
1036 | case '+': |
---|
1037 | case '-': |
---|
1038 | if (flags & SIGNOK) |
---|
1039 | { |
---|
1040 | flags &= ~SIGNOK; |
---|
1041 | goto fok; |
---|
1042 | } |
---|
1043 | break; |
---|
1044 | case '.': |
---|
1045 | if (flags & DPTOK) |
---|
1046 | { |
---|
1047 | flags &= ~(SIGNOK | DPTOK); |
---|
1048 | leading_zeroes = zeroes; |
---|
1049 | goto fok; |
---|
1050 | } |
---|
1051 | break; |
---|
1052 | case 'e': |
---|
1053 | case 'E': |
---|
1054 | /* no exponent without some digits */ |
---|
1055 | if ((flags & (NDIGITS | EXPOK)) == EXPOK |
---|
1056 | || ((flags & EXPOK) && zeroes)) |
---|
1057 | { |
---|
1058 | if (! (flags & DPTOK)) |
---|
1059 | { |
---|
1060 | exp_adjust = zeroes - leading_zeroes; |
---|
1061 | exp_start = p; |
---|
1062 | } |
---|
1063 | flags = |
---|
1064 | (flags & ~(EXPOK | DPTOK)) | |
---|
1065 | SIGNOK | NDIGITS; |
---|
1066 | zeroes = 0; |
---|
1067 | goto fok; |
---|
1068 | } |
---|
1069 | break; |
---|
1070 | } |
---|
1071 | break; |
---|
1072 | fok: |
---|
1073 | *p++ = c; |
---|
1074 | fskip: |
---|
1075 | fl_width--; |
---|
1076 | ++nread; |
---|
1077 | if (--fp->_r > 0) |
---|
1078 | fp->_p++; |
---|
1079 | else |
---|
1080 | #ifndef CYGNUS_NEC |
---|
1081 | if (__srefill (fp)) |
---|
1082 | #endif |
---|
1083 | break; /* EOF */ |
---|
1084 | } |
---|
1085 | if (zeroes) |
---|
1086 | flags &= ~NDIGITS; |
---|
1087 | /* |
---|
1088 | * If no digits, might be missing exponent digits |
---|
1089 | * (just give back the exponent) or might be missing |
---|
1090 | * regular digits, but had sign and/or decimal point. |
---|
1091 | */ |
---|
1092 | if (flags & NDIGITS) |
---|
1093 | { |
---|
1094 | if (flags & EXPOK) |
---|
1095 | { |
---|
1096 | /* no digits at all */ |
---|
1097 | while (p > buf) |
---|
1098 | { |
---|
1099 | ungetc (*(u_char *)-- p, fp); |
---|
1100 | --nread; |
---|
1101 | } |
---|
1102 | goto match_failure; |
---|
1103 | } |
---|
1104 | /* just a bad exponent (e and maybe sign) */ |
---|
1105 | c = *(u_char *)-- p; |
---|
1106 | --nread; |
---|
1107 | if (c != 'e' && c != 'E') |
---|
1108 | { |
---|
1109 | (void) ungetc (c, fp); /* sign */ |
---|
1110 | c = *(u_char *)-- p; |
---|
1111 | --nread; |
---|
1112 | } |
---|
1113 | (void) ungetc (c, fp); |
---|
1114 | } |
---|
1115 | if ((flags & SUPPRESS) == 0) |
---|
1116 | { |
---|
1117 | #ifdef _NO_LONGDBL |
---|
1118 | double res; |
---|
1119 | #else /* !_NO_LONG_DBL */ |
---|
1120 | long double res; |
---|
1121 | #endif /* !_NO_LONG_DBL */ |
---|
1122 | long new_exp = 0; |
---|
1123 | |
---|
1124 | *p = 0; |
---|
1125 | if ((flags & (DPTOK | EXPOK)) == EXPOK) |
---|
1126 | { |
---|
1127 | exp_adjust = zeroes - leading_zeroes; |
---|
1128 | new_exp = -exp_adjust; |
---|
1129 | exp_start = p; |
---|
1130 | } |
---|
1131 | else if (exp_adjust) |
---|
1132 | new_exp = _strtol_r (rptr, (exp_start + 1), NULL, 10) - exp_adjust; |
---|
1133 | if (exp_adjust) |
---|
1134 | { |
---|
1135 | |
---|
1136 | /* If there might not be enough space for the new exponent, |
---|
1137 | truncate some trailing digits to make room. */ |
---|
1138 | if (exp_start >= buf + sizeof (buf) - MAX_LONG_LEN) |
---|
1139 | exp_start = buf + sizeof (buf) - MAX_LONG_LEN - 1; |
---|
1140 | sprintf (exp_start, "e%ld", new_exp); |
---|
1141 | } |
---|
1142 | #ifdef __SPE__ |
---|
1143 | if (flags & FIXEDPOINT) |
---|
1144 | { |
---|
1145 | __uint64_t ufix64; |
---|
1146 | if (flags & SIGNED) |
---|
1147 | ufix64 = (__uint64_t)_strtosfix64_r (rptr, buf, NULL); |
---|
1148 | else |
---|
1149 | ufix64 = _strtoufix64_r (rptr, buf, NULL); |
---|
1150 | if (flags & SHORT) |
---|
1151 | { |
---|
1152 | __uint16_t *sp = va_arg (ap, __uint16_t *); |
---|
1153 | *sp = (__uint16_t)(ufix64 >> 48); |
---|
1154 | } |
---|
1155 | else if (flags & LONG) |
---|
1156 | { |
---|
1157 | __uint64_t *llp = va_arg (ap, __uint64_t *); |
---|
1158 | *llp = ufix64; |
---|
1159 | } |
---|
1160 | else |
---|
1161 | { |
---|
1162 | __uint32_t *lp = va_arg (ap, __uint32_t *); |
---|
1163 | *lp = (__uint32_t)(ufix64 >> 32); |
---|
1164 | } |
---|
1165 | nassigned++; |
---|
1166 | break; |
---|
1167 | } |
---|
1168 | |
---|
1169 | #endif /* __SPE__ */ |
---|
1170 | #ifdef _NO_LONGDBL |
---|
1171 | res = _strtod_r (rptr, buf, NULL); |
---|
1172 | #else /* !_NO_LONGDBL */ |
---|
1173 | res = _strtold_r (rptr, buf, NULL); |
---|
1174 | #endif /* !_NO_LONGDBL */ |
---|
1175 | if (flags & LONG) |
---|
1176 | { |
---|
1177 | dp = va_arg (ap, double *); |
---|
1178 | *dp = res; |
---|
1179 | } |
---|
1180 | else if (flags & LONGDBL) |
---|
1181 | { |
---|
1182 | ldp = va_arg (ap, _LONG_DOUBLE *); |
---|
1183 | *ldp = res; |
---|
1184 | } |
---|
1185 | else |
---|
1186 | { |
---|
1187 | if (!(flags & VECTOR)) |
---|
1188 | flp = va_arg (ap, float *); |
---|
1189 | else if (!looped) |
---|
1190 | flp = vec_buf.f; |
---|
1191 | *flp++ = res; |
---|
1192 | } |
---|
1193 | if (!(flags & VECTOR)) |
---|
1194 | nassigned++; |
---|
1195 | } |
---|
1196 | break; |
---|
1197 | } |
---|
1198 | #endif /* FLOATING_POINT */ |
---|
1199 | } |
---|
1200 | if (vec_read_count-- > 1) |
---|
1201 | { |
---|
1202 | looped = 1; |
---|
1203 | goto process; |
---|
1204 | } |
---|
1205 | if (flags & VECTOR) |
---|
1206 | { |
---|
1207 | int i; |
---|
1208 | unsigned long *vp = va_arg (ap, unsigned long *); |
---|
1209 | for (i = 0; i < 4; ++i) |
---|
1210 | *vp++ = vec_buf.l[i]; |
---|
1211 | nassigned++; |
---|
1212 | } |
---|
1213 | } |
---|
1214 | input_failure: |
---|
1215 | return nassigned ? nassigned : -1; |
---|
1216 | match_failure: |
---|
1217 | return nassigned; |
---|
1218 | } |
---|
1219 | |
---|