1 /***********************************************************************
2 * *
3 * This software is part of the ast package *
4 * Copyright (c) 1985-2012 AT&T Intellectual Property *
5 * and is licensed under the *
6 * Eclipse Public License, Version 1.0 *
7 * by AT&T Intellectual Property *
8 * *
9 * A copy of the License is available at *
10 * http://www.eclipse.org/org/documents/epl-v10.html *
11 * (with md5 checksum b35adb5213ca9657e911e9befb180842) *
12 * *
13 * Information and Software Systems Research *
14 * AT&T Research *
15 * Florham Park NJ *
16 * *
17 * Glenn Fowler <gsf@research.att.com> *
18 * David Korn <dgk@research.att.com> *
19 * Phong Vo <kpv@research.att.com> *
20 * *
21 ***********************************************************************/
22 #include "sfhdr.h"
23
24 /* The main engine for reading formatted data
25 **
26 ** Written by Kiem-Phong Vo.
27 */
28
29 #define MAXWIDTH (int)(((uint)~0)>>1) /* max amount to scan */
30
31 /*
32 * pull in a private strtold()
33 */
34
35 #include "sfstrtof.h"
36
37 /* refresh stream buffer - taking care of unseekable/share streams too */
38 #if __STD_C
_sfbuf(Sfio_t * f,int * peek)39 static void _sfbuf(Sfio_t* f, int* peek)
40 #else
41 static void _sfbuf(f, peek)
42 Sfio_t* f;
43 int* peek;
44 #endif
45 {
46 if(f->next >= f->endb)
47 { if(*peek) /* try peeking for a share stream if possible */
48 { f->mode |= SF_RV;
49 if(SFFILBUF(f,-1) > 0)
50 { f->mode |= SF_PEEK;
51 return;
52 }
53 *peek = 0; /* can't peek, back to normal reads */
54 }
55 (void)SFFILBUF(f,-1);
56 }
57 }
58
59 /* buffer used during scanning of a double value or a multi-byte
60 character. the fields mirror certain local variables in sfvscanf. */
61 typedef struct _scan_s
62 { int error; /* get set by _sfdscan if no value specified */
63 int inp; /* last input character read */
64 int width; /* field width */
65 Sfio_t *f; /* stream being scanned */
66 uchar *d, *endd, *data; /* local buffering system */
67 int peek; /* != 0 if unseekable/share stream */
68 int n_input;/* number of input bytes processed */
69 } Scan_t;
70
71 /* ds != 0 for scanning double values */
72 #define SCinit(sc,ds) ((sc)->inp = (sc)->error = -1, (sc)->f = f, \
73 ((sc)->width = (ds) ? width : -1), \
74 (sc)->d = d, (sc)->endd = endd, (sc)->data = data, \
75 (sc)->peek = peek, (sc)->n_input = n_input)
76 #define SCend(sc,ds) (inp = (sc)->inp, f = (sc)->f, \
77 (width = (ds) ? (sc)->width : width), \
78 d = (sc)->d, endd = (sc)->endd, data = (sc)->data, \
79 peek = (sc)->peek, n_input = (sc)->n_input)
80
81 #if __STD_C
_scgetc(void * arg,int flag)82 static int _scgetc(void* arg, int flag)
83 #else
84 static int _scgetc(arg, flag)
85 void* arg;
86 int flag;
87 #endif
88 {
89 Scan_t *sc = (Scan_t*)arg;
90
91 if (flag)
92 { sc->error = flag;
93 return 0;
94 }
95
96 /* if width >= 0, do not allow to exceed width number of bytes */
97 if(sc->width == 0)
98 { sc->inp = -1;
99 return 0;
100 }
101
102 if(sc->d >= sc->endd) /* refresh local buffer */
103 { sc->n_input += sc->d - sc->data;
104 if(sc->peek)
105 SFREAD(sc->f, sc->data, sc->d - sc->data);
106 else sc->f->next = sc->d;
107
108 _sfbuf(sc->f, &sc->peek);
109 sc->data = sc->d = sc->f->next;
110 sc->endd = sc->f->endb;
111
112 if(sc->d >= sc->endd)
113 { sc->inp = -1;
114 return 0;
115 }
116 }
117
118 if((sc->width -= 1) >= 0) /* from _sfdscan */
119 return (sc->inp = (int)(*sc->d++));
120 else return ((int)(*sc->d++));
121 }
122
123 /* structure to match characters in a character class */
124 typedef struct _accept_s
125 { char ok[SF_MAXCHAR+1];
126 int yes;
127 char *form, *endf;
128 #if _has_multibyte
129 wchar_t wc;
130 #endif
131 } Accept_t;
132
133 #if __STD_C
_sfsetclass(const char * form,Accept_t * ac,int flags)134 static char* _sfsetclass(const char* form, Accept_t* ac, int flags)
135 #else
136 static char* _sfsetclass(form, ac, flags)
137 char* form; /* format string */
138 Accept_t* ac; /* values of accepted characters */
139 int flags; /* SFFMT_LONG for wchar_t */
140 #endif
141 {
142 int c, endc, n;
143 SFMBDCL(mbs)
144
145 if(*form == '^') /* complementing this set */
146 { ac->yes = 0;
147 form += 1;
148 }
149 else ac->yes = 1;
150
151 for(c = 0; c <= SF_MAXCHAR; ++c)
152 ac->ok[c] = !ac->yes;
153
154 if(*form == ']' || *form == '-') /* special first char */
155 { ac->ok[*form] = ac->yes;
156 form += 1;
157 }
158 ac->form = (char*)form;
159
160 if(flags&SFFMT_LONG)
161 SFMBCLR(&mbs);
162 for(n = 1; *form != ']'; form += n)
163 { if((c = *((uchar*)form)) == 0)
164 return NIL(char*);
165
166 if(*(form+1) == '-')
167 { endc = *((uchar*)(form+2));
168 #if _has_multibyte
169 if(c >= 128 || endc >= 128 ) /* range must be ascii */
170 goto one_char;
171 #endif
172 for(; c <= endc; ++c)
173 ac->ok[c] = ac->yes;
174 n = 3;
175 }
176 else
177 { one_char:
178 #if _has_multibyte /* true multi-byte chars must be checked differently */
179 if((flags&SFFMT_LONG) && (n = (int)SFMBLEN(form,&mbs)) <= 0)
180 return NIL(char*);
181 if(n == 1)
182 #endif
183 ac->ok[c] = ac->yes;
184 }
185 }
186
187 ac->endf = (char*)form;
188 return (char*)(form+1);
189 }
190
191 #if _has_multibyte
192 #if __STD_C
_sfwaccept(wchar_t wc,Accept_t * ac)193 static int _sfwaccept(wchar_t wc, Accept_t* ac)
194 #else
195 static int _sfwaccept(wc, ac)
196 wchar_t wc;
197 Accept_t* ac;
198 #endif
199 {
200 int endc, c, n;
201 wchar_t fwc;
202 char *form = ac->form;
203 SFMBDCL(mbs)
204
205 SFMBCLR(&mbs);
206 for(n = 1; *form != ']'; form += n)
207 { if((c = *((uchar*)form)) == 0)
208 return 0;
209
210 if(*(form+1) == '-')
211 { endc = *((uchar*)(form+2));
212 if(c >= 128 || endc >= 128 ) /* range must be ascii */
213 goto one_char;
214 n = 3;
215 }
216 else
217 { one_char:
218 if((n = mbrtowc(&fwc, form, ac->endf-form, &mbs)) > 1 &&
219 wc == fwc )
220 return ac->yes;
221 }
222 }
223
224 return !ac->yes;
225 }
226
227 #if _has_multibyte == 1
228 #define SFgetwc(sc,wc,fmt,ac,mbs) _sfgetwc(sc,wc,fmt,ac,(Void_t*)(mbs))
229 #else
230 #define SFgetwc(sc,wc,fmt,ac,mbs) _sfgetwc(sc,wc,fmt,ac,NIL(Void_t*))
231 #endif
232
233 #if __STD_C
_sfgetwc(Scan_t * sc,wchar_t * wc,int fmt,Accept_t * ac,Void_t * mbs)234 static int _sfgetwc(Scan_t* sc, wchar_t* wc, int fmt, Accept_t* ac, Void_t *mbs)
235 #else
236 static int _sfgetwc(sc, wc, fmt, ac, mbs)
237 Scan_t* sc; /* the scanning handle */
238 wchar_t* wc; /* to return a scanned wchar_t */
239 int fmt; /* %s, %c, %[ */
240 Accept_t* ac; /* accept handle for %[ */
241 Void_t* mbs; /* multibyte parsing state */
242 #endif
243 {
244 int n, v;
245 char b[16]; /* assuming that SFMBMAX <= 16! */
246
247 /* shift left data so that there will be more room to back up on error.
248 this won't help streams with small buffers - c'est la vie! */
249 if(sc->d > sc->f->data && (n = sc->endd - sc->d) > 0 && n < SFMBMAX)
250 { memcpy(sc->f->data, sc->d, n);
251 if(sc->f->endr == sc->f->endb)
252 sc->f->endr = sc->f->data+n;
253 if(sc->f->endw == sc->f->endb)
254 sc->f->endw = sc->f->data+n;
255 sc->f->endb = sc->f->data+n;
256 sc->d = sc->data = sc->f->data;
257 sc->endd = sc->f->endb;
258 if(!mbs) sc->f->endb = sc->endd; /* stop cc's "unused mbs" warning */
259 }
260
261 for(n = 0; n < SFMBMAX; )
262 { if((v = _scgetc((Void_t*)sc, 0)) <= 0)
263 goto no_match;
264 else b[n++] = v;
265
266 if(mbrtowc(wc, b, n, (mbstate_t*)mbs) == (size_t)(-1))
267 goto no_match; /* malformed multi-byte char */
268 else
269 { /* multi-byte char converted successfully */
270 if(fmt == 'c')
271 return 1;
272 else if(fmt == 's')
273 { if(n > 1 || (n == 1 && !isspace(b[0]) ) )
274 return 1;
275 else goto no_match;
276 }
277 else if(fmt == '[')
278 { if((n == 1 && ac->ok[b[0]]) ||
279 (n > 1 && _sfwaccept(*wc,ac)) )
280 return 1;
281 else goto no_match;
282 }
283 else /* if(fmt == '1') match a single wchar_t */
284 { if(*wc == ac->wc)
285 return 1;
286 else goto no_match;
287 }
288 }
289 }
290
291 no_match: /* this unget is lossy on a stream with small buffer */
292 if((sc->d -= n) < sc->data)
293 sc->d = sc->data;
294 return 0;
295 }
296 #endif /*_has_multibyte*/
297
298
299 #if __STD_C
sfvscanf(Sfio_t * f,reg const char * form,va_list args)300 int sfvscanf(Sfio_t* f, reg const char* form, va_list args)
301 #else
302 int sfvscanf(f,form,args)
303 Sfio_t* f; /* file to be scanned */
304 reg char* form; /* scanning format */
305 va_list args;
306 #endif
307 {
308 reg int inp, shift, base, width;
309 ssize_t size;
310 int fmt, flags, dot, n_assign, v, n, n_input;
311 char *sp;
312
313 Accept_t acc;
314
315 Argv_t argv;
316 Sffmt_t *ft;
317 Fmt_t *fm, *fmstk;
318
319 Fmtpos_t* fp;
320 char *oform;
321 va_list oargs;
322 int argp, argn;
323
324 int decimal = 0, thousand = 0;
325
326 #if _has_multibyte
327 wchar_t wc;
328 SFMBDCL(fmbs)
329 SFMBDCL(mbs)
330 #endif
331
332 Void_t* value; /* location to assign scanned value */
333 char* t_str;
334 ssize_t n_str;
335
336 /* local buffering system */
337 Scan_t scd;
338 uchar *d, *endd, *data;
339 int peek;
340 #define SFbuf(f) (_sfbuf(f,&peek), (data = d = f->next), (endd = f->endb) )
341 #define SFlen(f) (d - data)
342 #define SFinit(f) ((peek = f->extent < 0 && (f->flags&SF_SHARE)), SFbuf(f) )
343 #define SFend(f) ((n_input += SFlen(f)), \
344 (peek ? SFREAD(f,(Void_t*)data,SFlen(f)) : ((f->next = d),0)) )
345 #define SFgetc(f,c) ((c) = (d < endd || (SFend(f), SFbuf(f), d < endd)) ? \
346 (int)(*d++) : -1 )
347 #define SFungetc(f,c) (d -= 1)
348
349 SFMTXDECL(f);
350
351 SFCVINIT(); /* initialize conversion tables */
352
353 SFMTXENTER(f,-1);
354
355 if(!form || f->mode != SF_READ && _sfmode(f,SF_READ,0) < 0)
356 SFMTXRETURN(f, -1);
357 SFLOCK(f,0);
358
359 SFinit(f); /* initialize local buffering system */
360
361 n_assign = n_input = 0; inp = -1;
362
363 fmstk = NIL(Fmt_t*);
364 ft = NIL(Sffmt_t*);
365
366 fp = NIL(Fmtpos_t*);
367 argn = -1;
368 oform = (char*)form;
369 va_copy(oargs,args);
370
371 SFSETLOCALE(&decimal, &thousand);
372
373 loop_fmt:
374 SFMBCLR(&fmbs);
375 while((fmt = *form++))
376 { if(fmt != '%')
377 { if(isspace(fmt))
378 { if(fmt != '\n' || !(f->flags&SF_LINE))
379 fmt = -1;
380 for(;;)
381 { if(SFgetc(f,inp) < 0 || inp == fmt)
382 goto loop_fmt;
383 else if(!isspace(inp))
384 { SFungetc(f,inp);
385 goto loop_fmt;
386 }
387 }
388 }
389 else
390 { match_1:
391 #if _has_multibyte
392 if((n = (int)mbrtowc(&wc,form-1,SFMBMAX,&fmbs)) <= 0)
393 goto pop_fmt;
394 if(n > 1)
395 { acc.wc = wc;
396 SCinit(&scd,0); SFMBCLR(&mbs);
397 v = SFgetwc(&scd, &wc, '1', &acc, &mbs);
398 SCend(&scd,0);
399 if(v == 0)
400 goto pop_fmt;
401 form += n-1;
402 }
403 else
404 #endif
405 if(SFgetc(f,inp) != fmt)
406 { if(inp < 0)
407 goto done;
408 SFungetc(f,inp);
409 goto pop_fmt;
410 }
411 }
412 continue;
413 }
414
415 if(*form == '%')
416 { form += 1;
417 do SFgetc(f,inp); while(isspace(inp)); /* skip starting blanks */
418 SFungetc(f,inp);
419 goto match_1;
420 }
421
422 if(*form == '\0')
423 goto pop_fmt;
424
425 if(*form == '*')
426 { flags = SFFMT_SKIP;
427 form += 1;
428 }
429 else flags = 0;
430
431 /* matching some pattern */
432 base = 10; size = -1;
433 width = dot = 0;
434 t_str = NIL(char*); n_str = 0;
435 value = NIL(Void_t*);
436 argp = -1;
437
438 loop_flags: /* LOOP FOR FLAGS, WIDTH, BASE, TYPE */
439 switch((fmt = *form++) )
440 {
441 case LEFTP : /* get the type which is enclosed in balanced () */
442 t_str = (char*)form;
443 for(v = 1;;)
444 { switch(*form++)
445 {
446 case 0 : /* not balanceable, retract */
447 form = t_str;
448 t_str = NIL(char*);
449 n_str = 0;
450 goto loop_flags;
451 case LEFTP : /* increasing nested level */
452 v += 1;
453 continue;
454 case RIGHTP : /* decreasing nested level */
455 if((v -= 1) != 0)
456 continue;
457 if(*t_str != '*' )
458 n_str = (form-1) - t_str;
459 else
460 { t_str = (*_Sffmtintf)(t_str+1,&n);
461 if(*t_str == '$')
462 { if(!fp &&
463 !(fp = (*_Sffmtposf)(f,oform,oargs,ft,1)) )
464 goto pop_fmt;
465 n = FP_SET(n,argn);
466 }
467 else n = FP_SET(-1,argn);
468
469 if(fp)
470 { t_str = fp[n].argv.s;
471 n_str = fp[n].ft.size;
472 }
473 else if(ft && ft->extf )
474 { FMTSET(ft, form,args,
475 LEFTP, 0, 0, 0,0,0,
476 NIL(char*),0);
477 n = (*ft->extf)
478 (f,(Void_t*)&argv,ft);
479 if(n < 0)
480 goto pop_fmt;
481 if(!(ft->flags&SFFMT_VALUE) )
482 goto t_arg;
483 if((t_str = argv.s) &&
484 (n_str = (int)ft->size) < 0)
485 n_str = strlen(t_str);
486 }
487 else
488 { t_arg:
489 if((t_str = va_arg(args,char*)) )
490 n_str = strlen(t_str);
491 }
492 }
493 goto loop_flags;
494 }
495 }
496
497 case '#' : /* alternative format */
498 flags |= SFFMT_ALTER;
499 goto loop_flags;
500
501 case '.' : /* width & base */
502 dot += 1;
503 if(isdigit(*form))
504 { fmt = *form++;
505 goto dot_size;
506 }
507 else if(*form == '*')
508 { form = (*_Sffmtintf)(form+1,&n);
509 if(*form == '$')
510 { form += 1;
511 if(!fp &&
512 !(fp = (*_Sffmtposf)(f,oform,oargs,ft,1)) )
513 goto pop_fmt;
514 n = FP_SET(n,argn);
515 }
516 else n = FP_SET(-1,argn);
517
518 if(fp)
519 v = fp[n].argv.i;
520 else if(ft && ft->extf )
521 { FMTSET(ft, form,args, '.',dot, 0, 0,0,0,
522 NIL(char*), 0);
523 if((*ft->extf)(f, (Void_t*)(&argv), ft) < 0)
524 goto pop_fmt;
525 if(ft->flags&SFFMT_VALUE)
526 v = argv.i;
527 else v = (dot <= 2) ? va_arg(args,int) : 0;
528 }
529 else v = (dot <= 2) ? va_arg(args,int) : 0;
530 if(v < 0)
531 v = 0;
532 goto dot_set;
533 }
534 else goto loop_flags;
535
536 case '0' : case '1' : case '2' : case '3' : case '4' :
537 case '5' : case '6' : case '7' : case '8' : case '9' :
538 dot_size :
539 for(v = fmt-'0'; isdigit(*form); ++form)
540 v = v*10 + (*form - '0');
541
542 if(*form == '$')
543 { form += 1;
544 if(!fp && !(fp = (*_Sffmtposf)(f,oform,oargs,ft,1)) )
545 goto pop_fmt;
546 argp = v-1;
547 goto loop_flags;
548 }
549
550 dot_set :
551 if(dot == 0 || dot == 1)
552 width = v;
553 else if(dot == 2)
554 base = v;
555 goto loop_flags;
556
557 case 'z' : /* ssize_t or object size */
558 case 'I' : /* object size */
559 size = -1; flags = (flags & ~SFFMT_TYPES) | SFFMT_IFLAG;
560 if(*form == '*')
561 { form = (*_Sffmtintf)(form+1,&n);
562 if(*form == '$')
563 { form += 1;
564 if(!fp &&
565 !(fp = (*_Sffmtposf)(f,oform,oargs,ft,1)))
566 goto pop_fmt;
567 n = FP_SET(n,argn);
568 }
569 else n = FP_SET(-1,argn);
570
571 if(fp) /* use position list */
572 size = fp[n].argv.i;
573 else if(ft && ft->extf )
574 { FMTSET(ft, form,args, 'I',sizeof(int), 0, 0,0,0,
575 NIL(char*), 0);
576 if((*ft->extf)(f, (Void_t*)(&argv), ft) < 0)
577 goto pop_fmt;
578 if(ft->flags&SFFMT_VALUE)
579 size = argv.i;
580 else size = va_arg(args,int);
581 }
582 else size = va_arg(args,int);
583 }
584 else if (fmt == 'z')
585 flags = (flags&~SFFMT_TYPES) | SFFMT_ZFLAG;
586 else if(isdigit(*form))
587 for(size = 0, n = *form; isdigit(n); n = *++form)
588 size = size*10 + (n - '0');
589 goto loop_flags;
590
591 case 'l' :
592 size = -1; flags &= ~SFFMT_TYPES;
593 if(*form == 'l')
594 { form += 1;
595 flags |= SFFMT_LLONG;
596 }
597 else flags |= SFFMT_LONG;
598 goto loop_flags;
599 case 'h' :
600 size = -1; flags &= ~SFFMT_TYPES;
601 if(*form == 'h')
602 { form += 1;
603 flags |= SFFMT_SSHORT;
604 }
605 else flags |= SFFMT_SHORT;
606 goto loop_flags;
607 case 'L' :
608 size = -1; flags = (flags&~SFFMT_TYPES) | SFFMT_LDOUBLE;
609 goto loop_flags;
610 case 'j' :
611 size = -1; flags = (flags&~SFFMT_TYPES) | SFFMT_JFLAG;
612 goto loop_flags;
613 case 't' :
614 size = -1; flags = (flags&~SFFMT_TYPES) | SFFMT_TFLAG;
615 goto loop_flags;
616 case QUOTE :
617 if(thousand > 0)
618 flags |= SFFMT_THOUSAND;
619 goto loop_flags;
620 }
621
622 /* set object size for scalars */
623 if(flags & SFFMT_TYPES)
624 { if((_Sftype[fmt]&(SFFMT_INT|SFFMT_UINT)) || fmt == 'n')
625 { if(flags&SFFMT_LONG)
626 size = sizeof(long);
627 else if(flags&SFFMT_SHORT)
628 size = sizeof(short);
629 else if(flags&SFFMT_SSHORT)
630 size = sizeof(char);
631 else if(flags&SFFMT_TFLAG)
632 size = sizeof(ptrdiff_t);
633 else if(flags&SFFMT_ZFLAG)
634 size = sizeof(size_t);
635 else if(flags&(SFFMT_LLONG|SFFMT_JFLAG) )
636 size = sizeof(Sflong_t);
637 else if(flags&SFFMT_IFLAG)
638 { if(size <= 0 ||
639 size == sizeof(Sflong_t)*CHAR_BIT )
640 size = sizeof(Sflong_t);
641 }
642 else if(size < 0)
643 size = sizeof(int);
644 }
645 else if(_Sftype[fmt]&SFFMT_FLOAT)
646 { if(flags&(SFFMT_LONG|SFFMT_LLONG))
647 size = sizeof(double);
648 else if(flags&SFFMT_LDOUBLE)
649 size = sizeof(Sfdouble_t);
650 else if(flags&SFFMT_IFLAG)
651 { if(size <= 0)
652 size = sizeof(Sfdouble_t);
653 }
654 else if(size < 0)
655 size = sizeof(float);
656 }
657 else if(_Sftype[fmt]&SFFMT_CHAR)
658 {
659 #if _has_multibyte
660 if((flags&SFFMT_LONG) || fmt == 'C')
661 { size = sizeof(wchar_t) > sizeof(int) ?
662 sizeof(wchar_t) : sizeof(int);
663 } else
664 #endif
665 if(size < 0)
666 size = sizeof(int);
667 }
668 }
669
670 argp = FP_SET(argp,argn);
671 if(fp)
672 { if(!(fp[argp].ft.flags&SFFMT_SKIP) )
673 { n_assign += 1;
674 value = fp[argp].argv.vp;
675 size = fp[argp].ft.size;
676 if(ft && ft->extf && fp[argp].ft.fmt != fp[argp].fmt)
677 fmt = fp[argp].ft.fmt;
678 }
679 else flags |= SFFMT_SKIP;
680 }
681 else if(ft && ft->extf)
682 { FMTSET(ft, form,args, fmt, size,flags, width,0,base, t_str,n_str);
683 SFend(f); SFOPEN(f,0);
684 v = (*ft->extf)(f, (Void_t*)&argv, ft);
685 SFLOCK(f,0); SFbuf(f);
686
687 if(v < 0)
688 goto pop_fmt;
689 else if(v > 0) /* extf comsumed v input bytes */
690 { n_input += v;
691 if(!(ft->flags&SFFMT_SKIP) )
692 n_assign += 1;
693 continue;
694 }
695 else /* if(v == 0): extf did not use input stream */
696 { FMTGET(ft, form,args, fmt, size, flags, width,n,base);
697
698 if((ft->flags&SFFMT_VALUE) && !(ft->flags&SFFMT_SKIP) )
699 value = argv.vp;
700 }
701 }
702
703 if(_Sftype[fmt] == 0) /* unknown pattern */
704 goto pop_fmt;
705
706 if(fmt == '!')
707 { if(!fp)
708 fp = (*_Sffmtposf)(f,oform,oargs,ft,1);
709 else goto pop_fmt;
710
711 if(!(argv.ft = va_arg(args,Sffmt_t*)) )
712 continue;
713 if(!argv.ft->form && ft ) /* change extension functions */
714 { if(ft->eventf &&
715 (*ft->eventf)(f,SF_DPOP,(Void_t*)form,ft) < 0)
716 continue;
717 fmstk->ft = ft = argv.ft;
718 }
719 else /* stack a new environment */
720 { if(!(fm = (Fmt_t*)malloc(sizeof(Fmt_t))) )
721 goto done;
722
723 ft = fm->ft = argv.ft;
724 SFMBSET(ft->mbs, &fmbs);
725 if(ft->form)
726 { fm->form = (char*)form; SFMBCPY(&fm->mbs,&fmbs);
727 va_copy(fm->args,args);
728
729 fm->oform = oform;
730 va_copy(fm->oargs,oargs);
731 fm->argn = argn;
732 fm->fp = fp;
733
734 form = ft->form; SFMBCLR(ft->mbs);
735 va_copy(args,ft->args);
736 argn = -1;
737 fp = NIL(Fmtpos_t*);
738 oform = (char*)form;
739 va_copy(oargs,args);
740 }
741 else fm->form = NIL(char*);
742
743 fm->eventf = ft->eventf;
744 fm->next = fmstk;
745 fmstk = fm;
746 }
747 continue;
748 }
749
750 /* get the address to assign value */
751 if(!value && !(flags&SFFMT_SKIP) )
752 value = va_arg(args,Void_t*);
753
754 if(fmt == 'n') /* return length of consumed input */
755 {
756 #if !_ast_intmax_long
757 if(size == sizeof(Sflong_t) )
758 *((Sflong_t*)value) = (Sflong_t)(n_input+SFlen(f));
759 else
760 #endif
761 if(size == sizeof(long) )
762 *((long*)value) = (long)(n_input+SFlen(f));
763 else if(size == sizeof(short) )
764 *((short*)value) = (short)(n_input+SFlen(f));
765 else if(size == sizeof(uchar))
766 *((uchar*)value) = (uchar)(n_input+SFlen(f));
767 else *((int*)value) = (int)(n_input+SFlen(f));
768 continue;
769 }
770
771 /* if get here, start scanning input */
772 if(width == 0)
773 width = fmt == 'c' ? 1 : MAXWIDTH;
774
775 /* define the first input character */
776 if(fmt == 'c' || fmt == '[' || fmt == 'C' )
777 SFgetc(f,inp);
778 else
779 { do { SFgetc(f,inp); }
780 while(isspace(inp)); /* skip starting blanks */
781 }
782 if(inp < 0)
783 goto done;
784
785 if(_Sftype[fmt] == SFFMT_FLOAT)
786 { SFungetc(f,inp); SCinit(&scd,1);
787 argv.ld = _sfdscan((Void_t*)(&scd), _scgetc);
788 SCend(&scd,1);
789
790 if(scd.error >= 0)
791 { if(inp >= 0)
792 SFungetc(f, inp);
793 goto pop_fmt;
794 }
795
796 if(value)
797 {
798 #if !_ast_fltmax_double
799 if(size == sizeof(Sfdouble_t))
800 *((Sfdouble_t*)value) = argv.ld;
801 else
802 #endif
803 if(size == sizeof(double))
804 *((double*)value) = (double)argv.ld;
805 else *((float*)value) = (float)argv.ld;
806
807 n_assign += 1;
808 }
809 }
810 else if(_Sftype[fmt] == SFFMT_UINT || fmt == 'p')
811 { if(inp == '-')
812 { SFungetc(f,inp);
813 goto pop_fmt;
814 }
815 else goto int_cvt;
816 }
817 else if(_Sftype[fmt] == SFFMT_INT)
818 { int_cvt:
819 if(inp == '-' || inp == '+')
820 { if(inp == '-')
821 flags |= SFFMT_MINUS;
822 while(--width > 0 && SFgetc(f,inp) >= 0)
823 if(!isspace(inp))
824 break;
825 }
826 if(inp < 0)
827 goto done;
828
829 if(fmt == 'o')
830 base = 8;
831 else if(fmt == 'x' || fmt == 'X' || fmt == 'p')
832 base = 16;
833 else if(fmt == 'i' && inp == '0') /* self-described data */
834 { base = 8;
835 if(width > 1) /* peek to see if it's a base-16 */
836 { if(SFgetc(f,inp) >= 0)
837 { if(inp == 'x' || inp == 'X')
838 base = 16;
839 SFungetc(f,inp);
840 }
841 inp = '0';
842 }
843 }
844
845 /* now convert */
846 argv.lu = 0;
847 if(base == 16)
848 { sp = (char*)_Sfcv36;
849 shift = 4;
850 if(sp[inp] >= 16)
851 { SFungetc(f,inp);
852 goto pop_fmt;
853 }
854 if(inp == '0' && --width > 0)
855 { /* skip leading 0x or 0X */
856 if(SFgetc(f,inp) >= 0 &&
857 (inp == 'x' || inp == 'X') && --width > 0)
858 SFgetc(f,inp);
859 }
860 if(inp >= 0 && sp[inp] < 16)
861 goto base_shift;
862 }
863 else if(base == 10)
864 { for(n = v = 0;; )
865 { /* fast base 10 conversion */
866 #define TEN(x) (((x) << 3) + ((x) << 1) )
867 if (inp >= '0' && inp <= '9')
868 { argv.lu = TEN(argv.lu) + (inp-'0');
869 n += 1;
870 }
871 else if(inp == thousand)
872 { if((v && n != 3) || (!v && n > 3) )
873 break;
874 v = 1; n = 0;
875 }
876 else break;
877 if((width -= 1) <= 0 || SFgetc(f,inp) < 0)
878 break;
879 }
880 if (!n && !v)
881 { SFungetc(f,inp);
882 goto pop_fmt;
883 }
884
885 if(fmt == 'i' && inp == '#' && !(flags&SFFMT_ALTER) )
886 { base = (int)argv.lu;
887 if(base < 2 || base > SF_RADIX)
888 goto pop_fmt;
889 argv.lu = 0;
890 sp = (char*)(base <= 36 ? _Sfcv36 : _Sfcv64);
891 if(--width > 0 &&
892 SFgetc(f,inp) >= 0 && sp[inp] < base)
893 goto base_conv;
894 }
895 }
896 else
897 { /* other bases */
898 sp = (char*)(base <= 36 ? _Sfcv36 : _Sfcv64);
899 if(base < 2 || base > SF_RADIX || sp[inp] >= base)
900 { SFungetc(f,inp);
901 goto pop_fmt;
902 }
903
904 base_conv: /* check for power of 2 conversions */
905 if((base & ~(base-1)) == base)
906 { if(base < 8)
907 shift = base < 4 ? 1 : 2;
908 else if(base < 32)
909 shift = base < 16 ? 3 : 4;
910 else shift = base < 64 ? 5 : 6;
911
912 base_shift: do
913 { argv.lu = (argv.lu << shift) + sp[inp];
914 } while(--width > 0 &&
915 SFgetc(f,inp) >= 0 && sp[inp] < base);
916 }
917 else
918 { do
919 { argv.lu = (argv.lu * base) + sp[inp];
920 } while(--width > 0 &&
921 SFgetc(f,inp) >= 0 && sp[inp] < base);
922 }
923 }
924
925 if(flags&SFFMT_MINUS)
926 argv.ll = -argv.ll;
927
928 if(value)
929 { n_assign += 1;
930
931 if(fmt == 'p')
932 #if _more_void_int
933 *((Void_t**)value) = (Void_t*)((ulong)argv.lu);
934 #else
935 *((Void_t**)value) = (Void_t*)((uint)argv.lu);
936 #endif
937 #if !_ast_intmax_long
938 else if(size == sizeof(Sflong_t))
939 *((Sflong_t*)value) = argv.ll;
940 #endif
941 else if(size == sizeof(long))
942 { if(fmt == 'd' || fmt == 'i')
943 *((long*)value) = (long)argv.ll;
944 else *((ulong*)value) = (ulong)argv.lu;
945 }
946 else if(size == sizeof(short))
947 { if(fmt == 'd' || fmt == 'i')
948 *((short*)value) = (short)argv.ll;
949 else *((ushort*)value) = (ushort)argv.lu;
950 }
951 else if(size == sizeof(char) )
952 { if(fmt == 'd' || fmt == 'i')
953 *((char*)value) = (char)argv.ll;
954 else *((uchar*)value) = (uchar)argv.lu;
955 }
956 else
957 { if(fmt == 'd' || fmt == 'i')
958 *((int*)value) = (int)argv.ll;
959 else *((uint*)value) = (uint)argv.lu;
960 }
961 }
962 }
963 else if(fmt == 'C' || fmt == 'S')
964 { fmt = fmt == 'C' ? 'c' : 's';
965 flags = (flags & ~SFFMT_TYPES) | SFFMT_LONG;
966 goto do_string;
967 }
968 else if(fmt == 's' || fmt == 'c' || fmt == '[' )
969 { do_string:
970 if(value)
971 { if(size < 0)
972 size = MAXWIDTH;
973 if(fmt != 'c')
974 size -= 1;
975 #if _has_multibyte
976 if(flags&SFFMT_LONG)
977 argv.ws = (wchar_t*)value;
978 else
979 #endif
980 argv.s = (char*)value;
981 }
982 else size = 0;
983
984 if(fmt == '[' && !(form = _sfsetclass(form,&acc,flags)) )
985 { SFungetc(f,inp);
986 goto pop_fmt;
987 }
988
989 n = 0; /* count number of scanned characters */
990 #if _has_multibyte
991 if(flags&SFFMT_LONG)
992 { SFungetc(f,inp); SCinit(&scd,0); SFMBCLR(&mbs);
993 for(; width > 0; --width)
994 { if(SFgetwc(&scd,&wc,fmt,&acc,&mbs) == 0)
995 break;
996 if((n += 1) <= size)
997 *argv.ws++ = wc;
998 }
999 SCend(&scd,0);
1000 }
1001 else
1002 #endif
1003
1004 if(fmt == 's')
1005 { do
1006 { if(isspace(inp))
1007 break;
1008 if((n += 1) <= size)
1009 *argv.s++ = inp;
1010 } while(--width > 0 && SFgetc(f,inp) >= 0);
1011 }
1012 else if(fmt == 'c')
1013 { do
1014 { if((n += 1) <= size)
1015 *argv.s++ = inp;
1016 } while(--width > 0 && SFgetc(f,inp) >= 0);
1017 }
1018 else /* if(fmt == '[') */
1019 { do
1020 { if(!acc.ok[inp])
1021 { if(n > 0 || (flags&SFFMT_ALTER) )
1022 break;
1023 else
1024 { SFungetc(f,inp);
1025 goto pop_fmt;
1026 }
1027 }
1028 if((n += 1) <= size)
1029 *argv.s++ = inp;
1030 } while(--width > 0 && SFgetc(f,inp) >= 0);
1031 }
1032
1033 if(value && (n > 0 || fmt == '[') )
1034 { n_assign += 1;
1035 if(fmt != 'c' && size >= 0)
1036 {
1037 #if _has_multibyte
1038 if(flags&SFFMT_LONG)
1039 *argv.ws = 0;
1040 else
1041 #endif
1042 *argv.s = 0;
1043 }
1044 }
1045 }
1046
1047 if(width > 0 && inp >= 0)
1048 SFungetc(f,inp);
1049 }
1050
1051 pop_fmt:
1052 if(fp)
1053 { free(fp);
1054 fp = NIL(Fmtpos_t*);
1055 }
1056 while((fm = fmstk) ) /* pop the format stack and continue */
1057 { if(fm->eventf)
1058 { if(!form || !form[0])
1059 (*fm->eventf)(f,SF_FINAL,NIL(Void_t*),ft);
1060 else if((*fm->eventf)(f,SF_DPOP,(Void_t*)form,ft) < 0)
1061 goto loop_fmt;
1062 }
1063
1064 fmstk = fm->next;
1065 if((form = fm->form) )
1066 { SFMBCPY(&fmbs,&fm->mbs);
1067 va_copy(args, fm->args);
1068 oform = fm->oform;
1069 va_copy(oargs,fm->oargs);
1070 argn = fm->argn;
1071 fp = fm->fp;
1072 }
1073 ft = fm->ft;
1074 free(fm);
1075 if(form && form[0])
1076 goto loop_fmt;
1077 }
1078
1079 done:
1080 if(fp)
1081 free(fp);
1082 while((fm = fmstk) )
1083 { if(fm->eventf)
1084 (*fm->eventf)(f,SF_FINAL,NIL(Void_t*),fm->ft);
1085 fmstk = fm->next;
1086 free(fm);
1087 }
1088
1089 SFend(f);
1090
1091 SFOPEN(f,0);
1092
1093 if(n_assign == 0 && inp < 0)
1094 n_assign = -1;
1095
1096 SFMTXRETURN(f,n_assign);
1097 }
1098