?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
8354 sync regcomp(3C) with upstream (fix make catalog)
[unleashed/tickless.git] / usr / src / lib / libast / common / sfio / sftable.c
blobdf4760602eca8d5ed9d39b7fa264d59c4a41c7c6
1 /***********************************************************************
2 * *
3 * This software is part of the ast package *
4 * Copyright (c) 1985-2010 AT&T Intellectual Property *
5 * and is licensed under the *
6 * Common Public License, Version 1.0 *
7 * by AT&T Intellectual Property *
8 * *
9 * A copy of the License is available at *
10 * http://www.opensource.org/licenses/cpl1.0.txt *
11 * (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9) *
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 #include "FEATURE/float"
24
25 /* Dealing with $ argument addressing stuffs.
26 **
27 ** Written by Kiem-Phong Vo.
28 */
29
30 #if __STD_C
31 static char* sffmtint(const char* str, int* v)
32 #else
33 static char* sffmtint(str, v)
34 char* str;
35 int* v;
36 #endif
37 {
38 for(*v = 0; isdigit(*str); ++str)
39 *v = *v * 10 + (*str - '0');
40 *v -= 1;
41 return (char*)str;
42 }
43
44 #if __STD_C
45 static Fmtpos_t* sffmtpos(Sfio_t* f,const char* form,va_list args,Sffmt_t* ft,int type)
46 #else
47 static Fmtpos_t* sffmtpos(f,form,args,ft,type)
48 Sfio_t* f;
49 char* form;
50 va_list args;
51 Sffmt_t* ft;
52 int type; /* >0: scanf, =0: printf, -1: internal */
53 #endif
54 {
55 int base, fmt, flags, dot, width, precis;
56 ssize_t n_str, size;
57 char *t_str, *sp;
58 int v, n, skip, dollar, decimal, thousand;
59 Sffmt_t savft;
60 Fmtpos_t* fp; /* position array of arguments */
61 int argp, argn, maxp, need[FP_INDEX];
62 #if _has_multibyte
63 SFMBDCL(fmbs)
64 #endif
65
66 if(type < 0)
67 fp = NIL(Fmtpos_t*);
68 else if(!(fp = sffmtpos(f,form,args,ft,-1)) )
69 return NIL(Fmtpos_t*);
70
71 dollar = decimal = thousand = 0; argn = maxp = -1;
72 SFMBCLR(&fmbs);
73 while((n = *form) )
74 { if(n != '%') /* collect the non-pattern chars */
75 { sp = (char*)form;
76 for(;;)
77 { form += SFMBLEN(form, &fmbs);
78 if(*form == 0 || *form == '%')
79 break;
80 }
81 continue;
82 }
83 else form += 1;
84 if(*form == 0)
85 break;
86 else if(*form == '%')
87 { form += 1;
88 continue;
89 }
90
91 if(*form == '*' && type > 0) /* skip in scanning */
92 { skip = 1;
93 form += 1;
94 argp = -1;
95 }
96 else /* get the position of this argument */
97 { skip = 0;
98 sp = sffmtint(form,&argp);
99 if(*sp == '$')
100 { dollar = 1;
101 form = sp+1;
102 }
103 else argp = -1;
104 }
105
106 flags = dot = 0;
107 t_str = NIL(char*); n_str = 0;
108 size = width = precis = base = -1;
109 for(n = 0; n < FP_INDEX; ++n)
110 need[n] = -1;
111
112 loop_flags: /* LOOP FOR \0, %, FLAGS, WIDTH, PRECISION, BASE, TYPE */
113 switch((fmt = *form++) )
114 {
115 case LEFTP : /* get the type enclosed in balanced parens */
116 t_str = (char*)form;
117 for(v = 1;;)
118 { switch(*form++)
119 {
120 case 0 : /* not balancable, retract */
121 form = t_str;
122 t_str = NIL(char*);
123 n_str = 0;
124 goto loop_flags;
125 case LEFTP : /* increasing nested level */
126 v += 1;
127 continue;
128 case RIGHTP : /* decreasing nested level */
129 if((v -= 1) != 0)
130 continue;
131 n_str = form-t_str;
132 if(*t_str == '*')
133 { t_str = sffmtint(t_str+1,&n);
134 if(*t_str == '$')
135 dollar = 1;
136 else n = -1;
137 if((n = FP_SET(n,argn)) > maxp)
138 maxp = n;
139 if(fp && fp[n].ft.fmt == 0)
140 { fp[n].ft.fmt = LEFTP;
141 fp[n].ft.form = (char*)form;
142 }
143 need[FP_STR] = n;
144 }
145 goto loop_flags;
146 }
147 }
148
149 case '-' :
150 flags |= SFFMT_LEFT;
151 flags &= ~SFFMT_ZERO;
152 goto loop_flags;
153 case '0' :
154 if(!(flags&SFFMT_LEFT) )
155 flags |= SFFMT_ZERO;
156 goto loop_flags;
157 case ' ' :
158 if(!(flags&SFFMT_SIGN) )
159 flags |= SFFMT_BLANK;
160 goto loop_flags;
161 case '+' :
162 flags |= SFFMT_SIGN;
163 flags &= ~SFFMT_BLANK;
164 goto loop_flags;
165 case '#' :
166 flags |= SFFMT_ALTER;
167 goto loop_flags;
168 case QUOTE:
169 SFSETLOCALE(&decimal,&thousand);
170 if(thousand > 0)
171 flags |= SFFMT_THOUSAND;
172 goto loop_flags;
173
174 case '.' :
175 if((dot += 1) == 2)
176 base = 0; /* for %s,%c */
177 if(isdigit(*form))
178 { fmt = *form++;
179 goto dot_size;
180 }
181 else if(*form != '*')
182 goto loop_flags;
183 else form += 1; /* drop thru below */
184
185 case '*' :
186 form = sffmtint(form,&n);
187 if(*form == '$' )
188 { dollar = 1;
189 form += 1;
190 }
191 else n = -1;
192 if((n = FP_SET(n,argn)) > maxp)
193 maxp = n;
194 if(fp && fp[n].ft.fmt == 0)
195 { fp[n].ft.fmt = '.';
196 fp[n].ft.size = dot;
197 fp[n].ft.form = (char*)form;
198 }
199 if(dot <= 2)
200 need[dot] = n;
201 goto loop_flags;
202
203 case '1' : case '2' : case '3' :
204 case '4' : case '5' : case '6' :
205 case '7' : case '8' : case '9' :
206 dot_size :
207 for(v = fmt - '0', fmt = *form; isdigit(fmt); fmt = *++form)
208 v = v*10 + (fmt - '0');
209 if(dot == 0)
210 width = v;
211 else if(dot == 1)
212 precis = v;
213 else if(dot == 2)
214 base = v;
215 goto loop_flags;
216
217 case 'I' : /* object length */
218 size = -1; flags = (flags & ~SFFMT_TYPES) | SFFMT_IFLAG;
219 if(isdigit(*form) )
220 { for(size = 0, n = *form; isdigit(n); n = *++form)
221 size = size*10 + (n - '0');
222 }
223 else if(*form == '*')
224 { form = sffmtint(form+1,&n);
225 if(*form == '$' )
226 { dollar = 1;
227 form += 1;
228 }
229 else n = -1;
230 if((n = FP_SET(n,argn)) > maxp)
231 maxp = n;
232 if(fp && fp[n].ft.fmt == 0)
233 { fp[n].ft.fmt = 'I';
234 fp[n].ft.size = sizeof(int);
235 fp[n].ft.form = (char*)form;
236 }
237 need[FP_SIZE] = n;
238 }
239 goto loop_flags;
240
241 case 'l' :
242 size = -1; flags &= ~SFFMT_TYPES;
243 if(*form == 'l')
244 { form += 1;
245 flags |= SFFMT_LLONG;
246 }
247 else flags |= SFFMT_LONG;
248 goto loop_flags;
249 case 'h' :
250 size = -1; flags &= ~SFFMT_TYPES;
251 if(*form == 'h')
252 { form += 1;
253 flags |= SFFMT_SSHORT;
254 }
255 else flags |= SFFMT_SHORT;
256 goto loop_flags;
257 case 'L' :
258 size = -1; flags = (flags & ~SFFMT_TYPES) | SFFMT_LDOUBLE;
259 goto loop_flags;
260 }
261
262 /* set object size for scalars */
263 if(flags & SFFMT_TYPES)
264 { if((_Sftype[fmt]&(SFFMT_INT|SFFMT_UINT)) || fmt == 'n')
265 { if(flags&SFFMT_LONG)
266 size = sizeof(long);
267 else if(flags&SFFMT_SHORT)
268 size = sizeof(short);
269 else if(flags&SFFMT_SSHORT)
270 size = sizeof(char);
271 else if(flags&SFFMT_TFLAG)
272 size = sizeof(ptrdiff_t);
273 else if(flags&SFFMT_ZFLAG)
274 size = sizeof(size_t);
275 else if(flags&(SFFMT_LLONG|SFFMT_JFLAG) )
276 size = sizeof(Sflong_t);
277 else if(flags&SFFMT_IFLAG)
278 { if(size <= 0 ||
279 size == sizeof(Sflong_t)*CHAR_BIT )
280 size = sizeof(Sflong_t);
281 }
282 else if(size < 0)
283 size = sizeof(int);
284 }
285 else if(_Sftype[fmt]&SFFMT_FLOAT)
286 { if(flags&(SFFMT_LONG|SFFMT_LLONG))
287 size = sizeof(double);
288 else if(flags&SFFMT_LDOUBLE)
289 size = sizeof(Sfdouble_t);
290 else if(flags&SFFMT_IFLAG)
291 { if(size <= 0)
292 size = sizeof(Sfdouble_t);
293 }
294 else if(size < 0)
295 size = sizeof(float);
296 }
297 else if(_Sftype[fmt]&SFFMT_CHAR)
298 {
299 #if _has_multibyte
300 if((flags&SFFMT_LONG) || fmt == 'C')
301 { size = sizeof(wchar_t) > sizeof(int) ?
302 sizeof(wchar_t) : sizeof(int);
303 } else
304 #endif
305 if(size < 0)
306 size = sizeof(int);
307 }
308 }
309
310 if(skip)
311 continue;
312
313 if((argp = FP_SET(argp,argn)) > maxp)
314 maxp = argp;
315
316 if(dollar && fmt == '!')
317 return NIL(Fmtpos_t*);
318
319 if(fp && fp[argp].ft.fmt == 0)
320 { fp[argp].ft.form = (char*)form;
321 fp[argp].ft.fmt = fp[argp].fmt = fmt;
322 fp[argp].ft.size = size;
323 fp[argp].ft.flags = flags;
324 fp[argp].ft.width = width;
325 fp[argp].ft.precis = precis;
326 fp[argp].ft.base = base;
327 fp[argp].ft.t_str = t_str;
328 fp[argp].ft.n_str = n_str;
329 for(n = 0; n < FP_INDEX; ++n)
330 fp[argp].need[n] = need[n];
331 }
332 }
333
334 if(!fp) /* constructing position array only */
335 { if(!dollar || !(fp = (Fmtpos_t*)malloc((maxp+1)*sizeof(Fmtpos_t))) )
336 return NIL(Fmtpos_t*);
337 for(n = 0; n <= maxp; ++n)
338 fp[n].ft.fmt = 0;
339 return fp;
340 }
341
342 /* get value for positions */
343 if(ft)
344 memcpy(&savft, ft, sizeof(*ft));
345 for(n = 0; n <= maxp; ++n)
346 { if(fp[n].ft.fmt == 0) /* gap: pretend it's a 'd' pattern */
347 { fp[n].ft.fmt = 'd';
348 fp[n].ft.width = 0;
349 fp[n].ft.precis = 0;
350 fp[n].ft.base = 0;
351 fp[n].ft.size = 0;
352 fp[n].ft.t_str = 0;
353 fp[n].ft.n_str = 0;
354 fp[n].ft.flags = 0;
355 for(v = 0; v < FP_INDEX; ++v)
356 fp[n].need[v] = -1;
357 }
358
359 if(ft && ft->extf)
360 { fp[n].ft.version = ft->version;
361 fp[n].ft.extf = ft->extf;
362 fp[n].ft.eventf = ft->eventf;
363 if((v = fp[n].need[FP_WIDTH]) >= 0 && v < n)
364 fp[n].ft.width = fp[v].argv.i;
365 if((v = fp[n].need[FP_PRECIS]) >= 0 && v < n)
366 fp[n].ft.precis = fp[v].argv.i;
367 if((v = fp[n].need[FP_BASE]) >= 0 && v < n)
368 fp[n].ft.base = fp[v].argv.i;
369 if((v = fp[n].need[FP_STR]) >= 0 && v < n)
370 fp[n].ft.t_str = fp[v].argv.s;
371 if((v = fp[n].need[FP_SIZE]) >= 0 && v < n)
372 fp[n].ft.size = fp[v].argv.i;
373
374 memcpy(ft,&fp[n].ft,sizeof(Sffmt_t));
375 va_copy(ft->args,args);
376 ft->flags |= SFFMT_ARGPOS;
377 v = (*ft->extf)(f, (Void_t*)(&fp[n].argv), ft);
378 va_copy(args,ft->args);
379 memcpy(&fp[n].ft,ft,sizeof(Sffmt_t));
380 if(v < 0)
381 { memcpy(ft,&savft,sizeof(Sffmt_t));
382 ft = NIL(Sffmt_t*);
383 }
384
385 if(!(fp[n].ft.flags&SFFMT_VALUE) )
386 goto arg_list;
387 else if(_Sftype[fp[n].ft.fmt]&(SFFMT_INT|SFFMT_UINT) )
388 { if(fp[n].ft.size == sizeof(short))
389 { if(_Sftype[fp[n].ft.fmt]&SFFMT_INT)
390 fp[n].argv.i = fp[n].argv.h;
391 else fp[n].argv.i = fp[n].argv.uh;
392 }
393 else if(fp[n].ft.size == sizeof(char))
394 { if(_Sftype[fp[n].ft.fmt]&SFFMT_INT)
395 fp[n].argv.i = fp[n].argv.c;
396 else fp[n].argv.i = fp[n].argv.uc;
397 }
398 }
399 else if(_Sftype[fp[n].ft.fmt]&SFFMT_FLOAT )
400 { if(fp[n].ft.size == sizeof(float) )
401 fp[n].argv.d = fp[n].argv.f;
402 }
403 }
404 else
405 { arg_list:
406 if(fp[n].ft.fmt == LEFTP)
407 { fp[n].argv.s = va_arg(args, char*);
408 fp[n].ft.size = strlen(fp[n].argv.s);
409 }
410 else if(fp[n].ft.fmt == '.' || fp[n].ft.fmt == 'I')
411 fp[n].argv.i = va_arg(args, int);
412 else if(fp[n].ft.fmt == '!')
413 { if(ft)
414 memcpy(ft,&savft,sizeof(Sffmt_t));
415 fp[n].argv.ft = ft = va_arg(args, Sffmt_t*);
416 if(ft->form)
417 ft = NIL(Sffmt_t*);
418 if(ft)
419 memcpy(&savft,ft,sizeof(Sffmt_t));
420 }
421 else if(type > 0) /* from sfvscanf */
422 fp[n].argv.vp = va_arg(args, Void_t*);
423 else switch(_Sftype[fp[n].ft.fmt])
424 { case SFFMT_INT:
425 case SFFMT_UINT:
426 #if !_ast_intmax_long
427 if(size == sizeof(Sflong_t) )
428 fp[n].argv.ll = va_arg(args, Sflong_t);
429 else
430 #endif
431 if(size == sizeof(long) )
432 fp[n].argv.l = va_arg(args, long);
433 else fp[n].argv.i = va_arg(args, int);
434 break;
435 case SFFMT_FLOAT:
436 #if !_ast_fltmax_double
437 if(size == sizeof(Sfdouble_t) )
438 fp[n].argv.ld = va_arg(args,Sfdouble_t);
439 else
440 #endif
441 fp[n].argv.d = va_arg(args,double);
442 break;
443 case SFFMT_POINTER:
444 fp[n].argv.vp = va_arg(args,Void_t*);
445 break;
446 case SFFMT_CHAR:
447 if(fp[n].ft.base >= 0)
448 fp[n].argv.s = va_arg(args,char*);
449 #if _has_multibyte
450 else if((fp[n].ft.flags & SFFMT_LONG) ||
451 fp[n].ft.fmt == 'C' )
452 { if(sizeof(wchar_t) <= sizeof(int) )
453 fp[n].argv.wc = (wchar_t)va_arg(args,int);
454 else fp[n].argv.wc = va_arg(args,wchar_t);
455 }
456 #endif
457 /* observe promotion rule */
458 else fp[n].argv.i = va_arg(args,int);
459 break;
460 default: /* unknown pattern */
461 break;
462 }
463 }
464 }
465
466 if(ft)
467 memcpy(ft,&savft,sizeof(Sffmt_t));
468 return fp;
469 }
470
471 static const unsigned char flt_nan[] = { _ast_flt_nan_init };
472 static const unsigned char flt_inf[] = { _ast_flt_inf_init };
473 static const unsigned char dbl_nan[] = { _ast_dbl_nan_init };
474 static const unsigned char dbl_inf[] = { _ast_dbl_inf_init };
475 #ifdef _ast_ldbl_nan_init
476 static const unsigned char ldbl_nan[] = { _ast_ldbl_nan_init };
477 static const unsigned char ldbl_inf[] = { _ast_ldbl_inf_init };
478 #endif
479
480 /* function to initialize conversion tables */
481 static int sfcvinit()
482 { reg int d, l;
483
484 for(d = 0; d <= SF_MAXCHAR; ++d)
485 { _Sfcv36[d] = SF_RADIX;
486 _Sfcv64[d] = SF_RADIX;
487 }
488
489 /* [0-9] */
490 for(d = 0; d < 10; ++d)
491 { _Sfcv36[(uchar)_Sfdigits[d]] = d;
492 _Sfcv64[(uchar)_Sfdigits[d]] = d;
493 }
494
495 /* [a-z] */
496 for(; d < 36; ++d)
497 { _Sfcv36[(uchar)_Sfdigits[d]] = d;
498 _Sfcv64[(uchar)_Sfdigits[d]] = d;
499 }
500
501 /* [A-Z] */
502 for(l = 10; d < 62; ++l, ++d)
503 { _Sfcv36[(uchar)_Sfdigits[d]] = l;
504 _Sfcv64[(uchar)_Sfdigits[d]] = d;
505 }
506
507 /* remaining digits */
508 for(; d < SF_RADIX; ++d)
509 { _Sfcv36[(uchar)_Sfdigits[d]] = d;
510 _Sfcv64[(uchar)_Sfdigits[d]] = d;
511 }
512
513 _Sftype['d'] = _Sftype['i'] = SFFMT_INT;
514 _Sftype['u'] = _Sftype['o'] = _Sftype['x'] = _Sftype['X'] = SFFMT_UINT;
515 _Sftype['e'] = _Sftype['E'] = _Sftype['a'] = _Sftype['A'] =
516 _Sftype['g'] = _Sftype['G'] = _Sftype['f'] = SFFMT_FLOAT;
517 _Sftype['s'] = _Sftype['n'] = _Sftype['p'] = _Sftype['!'] = SFFMT_POINTER;
518 _Sftype['c'] = SFFMT_CHAR;
519 _Sftype['['] = SFFMT_CLASS;
520 #if _has_multibyte
521 _Sftype['S'] = SFFMT_POINTER;
522 _Sftype['C'] = SFFMT_CHAR;
523 #endif
524
525 /* IEEE floating point computed constants */
526
527 memcpy((char*)&_Sffnan, (char*)flt_nan, sizeof(_Sffnan));
528 memcpy((char*)&_Sffinf, (char*)flt_inf, sizeof(_Sffinf));
529 memcpy((char*)&_Sfdnan, (char*)dbl_nan, sizeof(_Sfdnan));
530 memcpy((char*)&_Sfdinf, (char*)dbl_inf, sizeof(_Sfdinf));
531 #ifdef _ast_ldbl_nan_init
532 memcpy((char*)&_Sflnan, (char*)ldbl_nan, sizeof(_Sflnan));
533 memcpy((char*)&_Sflinf, (char*)ldbl_inf, sizeof(_Sflinf));
534 #else
535 memcpy((char*)&_Sflnan, (char*)dbl_nan, sizeof(_Sfdnan));
536 memcpy((char*)&_Sflinf, (char*)dbl_inf, sizeof(_Sfdinf));
537 #endif
538
539 return 1;
540 }
541
542 /* table for floating point and integer conversions */
543 #include "FEATURE/sfinit"
unleashed repo fork