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 engine for formatting data. 25 ** 1. Argument positioning is done in sftable.c so any changes 26 ** made here should be reflected in sftable.c as well. 27 ** 2. For internationalization, Sfio only supports I/O of multibyte strings. 28 ** However, this code does provide minimal support so that Stdio functions 29 ** such as fwprintf/swprintf can be emulated (see stdvwprintf()). 30 ** 31 ** Written by Kiem-Phong Vo. 32 */ 33 #define HIGHBITI (~((~((uint)0)) >> 1)) 34 #define HIGHBITL (~((~((Sfulong_t)0)) >> 1)) 35 36 #define SFFMT_PREFIX (SFFMT_MINUS|SFFMT_SIGN|SFFMT_BLANK) 37 38 #define FPRECIS 6 /* default precision for floats */ 39 40 #if _PACKAGE_ast 41 #include <ccode.h> 42 #else 43 /* characters when using ebcdic or ascii */ 44 #if _chr_ebcdic 45 #define CC_vt 013 /* vertical tab */ 46 #define CC_esc 047 /* escape */ 47 #define CC_bel 057 /* bell */ 48 #else 49 #define CC_vt 013 /* vertical tab */ 50 #define CC_esc 033 /* escape */ 51 #define CC_bel 007 /* bell */ 52 #endif /* _chr_ebcdic */ 53 #endif /* _PACKAGE_ast */ 54 55 #if __STD_C 56 static int chr2str(char* buf, int v) 57 #else 58 static int chr2str(buf, v) 59 char* buf; 60 int v; 61 #endif 62 { 63 if(isprint(v) && v != '\\') 64 { *buf++ = v; 65 return 1; 66 } 67 else 68 { *buf++ = '\\'; 69 switch(v) 70 { case CC_bel: *buf++ = 'a'; return 2; 71 case CC_vt: *buf++ = 'v'; return 2; 72 case CC_esc: *buf++ = 'E'; return 2; 73 case '\b': *buf++ = 'b'; return 2; 74 case '\f': *buf++ = 'f'; return 2; 75 case '\n': *buf++ = 'n'; return 2; 76 case '\r': *buf++ = 'r'; return 2; 77 case '\t': *buf++ = 't'; return 2; 78 case '\\': *buf++ = '\\'; return 2; 79 default: *buf++ = '0' + ((v >> 6) & 03); 80 *buf++ = '0' + ((v >> 3) & 07); 81 *buf++ = '0' + ((v >> 0) & 07); 82 return 4; 83 } 84 } 85 } 86 87 /* On some platform(s), large functions are not compilable. 88 ** In such a case, the below macro should be defined non-zero so that 89 ** some in-lined macros will be made smaller, trading time for space. 90 */ 91 #if !defined(_sffmt_small) && defined(_UTS) 92 #define _sffmt_small 1 93 #endif 94 95 #if __STD_C 96 int sfvprintf(Sfio_t* f, const char* form, va_list args) 97 #else 98 int sfvprintf(f,form,args) 99 Sfio_t* f; /* file to print to */ 100 char* form; /* format to use */ 101 va_list args; /* arg list if !argf */ 102 #endif 103 { 104 int n, v, w, k, n_s, base, fmt, flags; 105 Sflong_t lv; 106 char *sp, *ssp, *endsp, *ep, *endep; 107 int dot, width, precis, sign, decpt; 108 #if _PACKAGE_ast 109 int scale; 110 #endif 111 ssize_t size; 112 Sfdouble_t dval; 113 Void_t* valp; 114 char *tls[2], **ls; /* for %..[separ]s */ 115 char* t_str; /* stuff between () */ 116 ssize_t n_str; /* its length */ 117 118 Argv_t argv; /* for extf to return value */ 119 Sffmt_t *ft; /* format environment */ 120 Fmt_t *fm, *fmstk; /* stack contexts */ 121 122 char* oform; /* original format string */ 123 va_list oargs; /* original arg list */ 124 Fmtpos_t* fp; /* arg position list */ 125 int argp, argn; /* arg position and number */ 126 127 #define SLACK 1024 128 char buf[SF_MAXDIGITS+SLACK], tmp[SF_MAXDIGITS+1], data[SF_GRAIN]; 129 int decimal = 0, thousand = 0; 130 131 #if _has_multibyte 132 wchar_t* wsp; 133 SFMBDCL(fmbs) /* state of format string */ 134 SFMBDCL(mbs) /* state of some string */ 135 #ifdef mbwidth 136 char* osp; 137 int n_w, wc; 138 #endif 139 #endif 140 141 /* local io system */ 142 int o, n_output; 143 #define SMputc(f,c) { if((o = SFFLSBUF(f,c)) >= 0 ) n_output += 1; \ 144 else { SFBUF(f); goto done; } \ 145 } 146 #define SMnputc(f,c,n) { if((o = SFNPUTC(f,c,n)) > 0 ) n_output += 1; \ 147 if(o != n) { SFBUF(f); goto done; } \ 148 } 149 #define SMwrite(f,s,n) { if((o = SFWRITE(f,(Void_t*)s,n)) > 0 ) n_output += o; \ 150 if(o != n) { SFBUF(f); goto done; } \ 151 } 152 #if _sffmt_small /* these macros are made smaller at some performance cost */ 153 #define SFBUF(f) 154 #define SFINIT(f) (n_output = 0) 155 #define SFEND(f) 156 #define SFputc(f,c) SMputc(f,c) 157 #define SFnputc(f,c,n) SMnputc(f,c,n) 158 #define SFwrite(f,s,n) SMwrite(f,s,n) 159 #else 160 uchar *d, *endd; 161 #define SFBUF(f) (d = f->next, endd = f->endb) 162 #define SFINIT(f) (SFBUF(f), n_output = 0) 163 #define SFEND(f) ((n_output += d - f->next), (f->next = d)) 164 #define SFputc(f,c) { if(d < endd) { *d++ = (uchar)c; } \ 165 else { SFEND(f); SMputc(f,c); SFBUF(f); } \ 166 } 167 #define SFnputc(f,c,n) { if(d+n <= endd) { while(n--) *d++ = (uchar)(c); } \ 168 else { SFEND(f); SMnputc(f,c,n); SFBUF(f); } \ 169 } 170 #define SFwrite(f,s,n) { if(d+n <= endd) { while(n--) *d++ = (uchar)(*s++); } \ 171 else { SFEND(f); SMwrite(f,s,n); SFBUF(f); } \ 172 } 173 #endif /* _sffmt_small */ 174 175 SFMTXDECL(f); 176 177 SFCVINIT(); /* initialize conversion tables */ 178 179 SFMTXENTER(f,-1); 180 181 if(!form) 182 SFMTXRETURN(f, -1); 183 184 /* make sure stream is in write mode and buffer is not NULL */ 185 if(f->mode != SF_WRITE && _sfmode(f,SF_WRITE,0) < 0) 186 SFMTXRETURN(f, -1); 187 188 SFLOCK(f,0); 189 190 if(!f->data && !(f->flags&SF_STRING)) 191 { f->data = f->next = (uchar*)data; 192 f->endb = f->data+sizeof(data); 193 } 194 SFINIT(f); 195 196 tls[1] = NIL(char*); 197 198 fmstk = NIL(Fmt_t*); 199 ft = NIL(Sffmt_t*); 200 201 oform = (char*)form; 202 va_copy(oargs,args); 203 argn = -1; 204 fp = NIL(Fmtpos_t*); 205 206 loop_fmt : 207 SFMBCLR(&fmbs); /* clear multibyte states to parse the format string */ 208 while((n = *form) ) 209 { if(n != '%') /* collect the non-pattern chars */ 210 { sp = (char*)form; 211 do 212 { if((n = SFMBLEN(form, &fmbs)) <= 0) 213 { n = 1; 214 SFMBCLR(&fmbs); 215 } 216 } while(*(form += n) && *form != '%'); 217 218 n = form-sp; 219 SFwrite(f,sp,n); 220 continue; 221 } 222 else form += 1; 223 224 flags = 0; 225 #if _PACKAGE_ast 226 scale = 0; 227 #endif 228 size = width = precis = base = n_s = argp = -1; 229 ssp = _Sfdigits; 230 endep = ep = NIL(char*); 231 endsp = sp = buf+(sizeof(buf)-1); 232 t_str = NIL(char*); 233 n_str = dot = 0; 234 235 loop_flags: /* LOOP FOR \0, %, FLAGS, WIDTH, PRECISION, BASE, TYPE */ 236 switch((fmt = *form++) ) 237 { 238 case '\0': 239 SFputc(f,'%'); 240 goto pop_fmt; 241 case '%' : 242 SFputc(f,'%'); 243 continue; 244 245 case LEFTP : /* get the type enclosed in balanced parens */ 246 t_str = (char*)form; 247 for(v = 1;;) 248 { switch(*form++) 249 { 250 case 0 : /* not balancable, retract */ 251 form = t_str; 252 t_str = NIL(char*); 253 n_str = 0; 254 goto loop_flags; 255 case LEFTP : /* increasing nested level */ 256 v += 1; 257 continue; 258 case RIGHTP : /* decreasing nested level */ 259 if((v -= 1) != 0) 260 continue; 261 if(*t_str != '*' ) 262 n_str = (form-1)-t_str; 263 else 264 { t_str = (*_Sffmtintf)(t_str+1,&n); 265 if(*t_str == '$') 266 { if(!fp && 267 !(fp = (*_Sffmtposf)(f,oform,oargs,ft,0)) ) 268 goto pop_fmt; 269 n = FP_SET(n,argn); 270 } 271 else n = FP_SET(-1,argn); 272 273 if(fp) 274 { t_str = fp[n].argv.s; 275 n_str = fp[n].ft.size; 276 } 277 else if(ft && ft->extf ) 278 { FMTSET(ft, form,args, 279 LEFTP, 0, 0, 0,0,0, 280 NIL(char*),0); 281 n = (*ft->extf) 282 (f,(Void_t*)&argv,ft); 283 if(n < 0) 284 goto pop_fmt; 285 if(!(ft->flags&SFFMT_VALUE) ) 286 goto t_arg; 287 if((t_str = argv.s) && 288 (n_str = (int)ft->size) < 0) 289 n_str = strlen(t_str); 290 } 291 else 292 { t_arg: 293 if((t_str = va_arg(args,char*)) ) 294 n_str = strlen(t_str); 295 } 296 } 297 goto loop_flags; 298 } 299 } 300 301 case '-' : 302 if(dot == 1) 303 { dot = 0; 304 precis = -1; 305 flags |= SFFMT_CHOP; 306 } 307 else 308 flags = (flags & ~(SFFMT_CENTER|SFFMT_ZERO)) | SFFMT_LEFT; 309 goto loop_flags; 310 case '0' : 311 if(!(flags&(SFFMT_LEFT|SFFMT_CENTER)) ) 312 flags |= SFFMT_ZERO; 313 goto loop_flags; 314 case ' ' : 315 if(!(flags&SFFMT_SIGN) ) 316 flags |= SFFMT_BLANK; 317 goto loop_flags; 318 case '+' : 319 flags = (flags & ~SFFMT_BLANK) | SFFMT_SIGN; 320 goto loop_flags; 321 case '=' : 322 flags = (flags & ~(SFFMT_LEFT|SFFMT_ZERO)) | SFFMT_CENTER; 323 goto loop_flags; 324 case '#' : 325 flags |= SFFMT_ALTER; 326 goto loop_flags; 327 case QUOTE: 328 SFSETLOCALE(&decimal,&thousand); 329 if(thousand > 0) 330 flags |= SFFMT_THOUSAND; 331 goto loop_flags; 332 case ',': 333 SFSETLOCALE(&decimal,&thousand); 334 if(thousand < 0) 335 thousand = fmt; 336 flags |= SFFMT_THOUSAND; 337 goto loop_flags; 338 339 case '.': 340 dot += 1; 341 if(dot == 1) 342 { /* so base can be defined without setting precis */ 343 if(*form != '.' && !(flags & SFFMT_CHOP)) 344 precis = 0; 345 } 346 else if(dot == 2) 347 { base = 0; /* for %s,%c */ 348 v = form[0] == 'l' ? form[1] : form[0]; 349 if(v == 'c' || v == 'C' || v == 's' || v == 'S') 350 goto loop_flags; 351 if(*form && !isalnum(*form)) 352 { v = form[1] == 'l' ? form[2] : form[1]; 353 if(v == 'c' || v == 'C' || v == 's' || v == 'S') 354 { if(*form == '*') 355 goto do_star; 356 else 357 { base = *form++; 358 goto loop_flags; 359 } 360 } 361 } 362 } 363 364 if(isdigit(*form) ) 365 { fmt = *form++; 366 goto dot_size; 367 } 368 else if(*form != '*') 369 goto loop_flags; 370 do_star: 371 form += 1; /* fall thru for '*' */ 372 /* FALLTHROUGH */ 373 case '*' : 374 form = (*_Sffmtintf)(form,&n); 375 if(*form == '$') 376 { form += 1; 377 if(!fp && !(fp = (*_Sffmtposf)(f,oform,oargs,ft,0)) ) 378 goto pop_fmt; 379 n = FP_SET(n,argn); 380 } 381 else n = FP_SET(-1,argn); 382 383 if(fp) 384 v = fp[n].argv.i; 385 else if(ft && ft->extf) 386 { FMTSET(ft, form,args, '.',dot, 0, 0,0,0, NIL(char*), 0); 387 if((*ft->extf)(f, (Void_t*)(&argv), ft) < 0) 388 goto pop_fmt; 389 fmt = ft->fmt; 390 flags = (flags&~SFFMT_TYPES) | (ft->flags&SFFMT_TYPES); 391 if(ft->flags&SFFMT_VALUE) 392 v = argv.i; 393 else v = (dot <= 2) ? va_arg(args,int) : 0; 394 } 395 else v = dot <= 2 ? va_arg(args,int) : 0; 396 goto dot_set; 397 398 case '1' : case '2' : case '3' : 399 case '4' : case '5' : case '6' : 400 case '7' : case '8' : case '9' : 401 dot_size : 402 for(v = fmt - '0'; isdigit(*form); ++form) 403 v = v*10 + (*form - '0'); 404 if(*form == '$') 405 { form += 1; 406 if(!fp && !(fp = (*_Sffmtposf)(f,oform,oargs,ft,0)) ) 407 goto pop_fmt; 408 argp = v-1; 409 goto loop_flags; 410 } 411 dot_set : 412 if(dot == 0) 413 { if((width = v) < 0) 414 { width = -width; 415 flags = (flags & ~(SFFMT_CENTER|SFFMT_ZERO)) | SFFMT_LEFT; 416 } 417 } 418 else if(dot == 1) 419 precis = v; 420 else if(dot == 2) 421 base = v; 422 goto loop_flags; 423 424 /* 2012-06-27 I* will be deprecated and POSIX will probably settle on one of L* or z* */ 425 case 'L' : /* long double or L* sizeof object length */ 426 case 'z' : /* ssize_t or z* sizeof object length */ 427 case 'I' : /* object length */ 428 size = -1; flags = (flags & ~SFFMT_TYPES) | SFFMT_IFLAG; 429 if(*form == '*') 430 { form = (*_Sffmtintf)(form+1,&n); 431 if(*form == '$') 432 { form += 1; 433 if(!fp && 434 !(fp = (*_Sffmtposf)(f,oform,oargs,ft,0))) 435 goto pop_fmt; 436 n = FP_SET(n,argn); 437 } 438 else n = FP_SET(-1,argn); 439 440 if(fp) /* use position list */ 441 size = fp[n].argv.i; 442 else if(ft && ft->extf) 443 { FMTSET(ft, form,args, 'I',sizeof(int), 0, 0,0,0, 444 NIL(char*), 0); 445 if((*ft->extf)(f, (Void_t*)(&argv), ft) < 0) 446 goto pop_fmt; 447 if(ft->flags&SFFMT_VALUE) 448 size = argv.i; 449 else size = va_arg(args,int); 450 } 451 else size = va_arg(args,int); 452 } 453 else if (fmt == 'L') 454 flags = (flags & ~SFFMT_TYPES) | SFFMT_LDOUBLE; 455 else if (fmt == 'z') 456 flags = (flags&~SFFMT_TYPES) | SFFMT_ZFLAG; 457 else if(isdigit(*form) ) 458 { for(size = 0, n = *form; isdigit(n); n = *++form) 459 size = size*10 + (n - '0'); 460 } 461 goto loop_flags; 462 463 case 'l' : 464 size = -1; flags &= ~SFFMT_TYPES; 465 if(*form == 'l') 466 { form += 1; 467 flags |= SFFMT_LLONG; 468 } 469 else flags |= SFFMT_LONG; 470 goto loop_flags; 471 case 'h' : 472 size = -1; flags &= ~SFFMT_TYPES; 473 if(*form == 'h') 474 { form += 1; 475 flags |= SFFMT_SSHORT; 476 } 477 else flags |= SFFMT_SHORT; 478 goto loop_flags; 479 case 'j' : 480 size = -1; flags = (flags&~SFFMT_TYPES) | SFFMT_JFLAG; 481 goto loop_flags; 482 case 't' : 483 size = -1; flags = (flags&~SFFMT_TYPES) | SFFMT_TFLAG; 484 goto loop_flags; 485 default: 486 break; 487 } 488 489 /* set object size for scalars */ 490 if(flags & SFFMT_TYPES) 491 { if((_Sftype[fmt]&(SFFMT_INT|SFFMT_UINT)) || fmt == 'n') 492 { if(flags&SFFMT_LONG) 493 size = sizeof(long); 494 else if(flags&SFFMT_SHORT) 495 size = sizeof(short); 496 else if(flags&SFFMT_SSHORT) 497 size = sizeof(char); 498 else if(flags&SFFMT_TFLAG) 499 size = sizeof(ptrdiff_t); 500 else if(flags&SFFMT_ZFLAG) 501 size = sizeof(size_t); 502 else if(flags&(SFFMT_LLONG|SFFMT_JFLAG) ) 503 size = sizeof(Sflong_t); 504 else if(flags&SFFMT_IFLAG) 505 { if(size <= 0 || 506 size == sizeof(Sflong_t)*CHAR_BIT ) 507 size = sizeof(Sflong_t); 508 } 509 else if(size < 0) 510 size = sizeof(int); 511 } 512 else if(_Sftype[fmt]&SFFMT_FLOAT) 513 { if(flags&SFFMT_LDOUBLE) 514 size = sizeof(Sfdouble_t); 515 else if(flags&(SFFMT_LONG|SFFMT_LLONG)) 516 size = sizeof(double); 517 else if(flags&SFFMT_IFLAG) 518 { if(size <= 0) 519 size = sizeof(Sfdouble_t); 520 } 521 else if(size < 0) 522 size = sizeof(float); 523 } 524 else if(_Sftype[fmt]&SFFMT_CHAR) 525 { 526 #if _has_multibyte 527 if((flags&SFFMT_LONG) || fmt == 'C') 528 { size = sizeof(wchar_t) > sizeof(int) ? 529 sizeof(wchar_t) : sizeof(int); 530 } else 531 #endif 532 if(size < 0) 533 size = sizeof(int); 534 } 535 } 536 537 argp = FP_SET(argp,argn); 538 if(fp) 539 { if(ft && ft->extf && fp[argp].ft.fmt != fp[argp].fmt) 540 fmt = fp[argp].ft.fmt; 541 argv = fp[argp].argv; 542 size = fp[argp].ft.size; 543 } 544 else if(ft && ft->extf ) /* extended processing */ 545 { FMTSET(ft, form,args, fmt, size,flags, width,precis,base, 546 t_str,n_str); 547 SFEND(f); SFOPEN(f,0); 548 v = (*ft->extf)(f, (Void_t*)(&argv), ft); 549 SFLOCK(f,0); SFBUF(f); 550 551 if(v < 0) /* no further processing */ 552 goto pop_fmt; 553 else if(v > 0) /* extf output v bytes */ 554 { n_output += v; 555 continue; 556 } 557 else /* extf did not output */ 558 { FMTGET(ft, form,args, fmt, size,flags, width,precis,base); 559 560 if(!(ft->flags&SFFMT_VALUE)) 561 goto arg_list; 562 else if(_Sftype[fmt]&(SFFMT_INT|SFFMT_UINT) ) 563 { if(size == sizeof(short)) 564 { if(_Sftype[fmt]&SFFMT_INT) 565 argv.i = argv.h; 566 else argv.i = argv.uh; 567 } 568 else if(size == sizeof(char)) 569 { if(_Sftype[fmt]&SFFMT_INT) 570 argv.i = argv.c; 571 else argv.i = argv.uc; 572 } 573 } 574 else if(_Sftype[fmt]&SFFMT_FLOAT ) 575 { if(size == sizeof(float) ) 576 argv.d = argv.f; 577 } 578 else if(_Sftype[fmt]&SFFMT_CHAR) 579 { if(base < 0) 580 argv.i = (int)argv.c; 581 } 582 } 583 } 584 else 585 { arg_list: 586 switch(_Sftype[fmt]) 587 { case SFFMT_INT: 588 case SFFMT_UINT: 589 #if !_ast_intmax_long 590 if(size == sizeof(Sflong_t)) 591 argv.ll = va_arg(args, Sflong_t); 592 else 593 #endif 594 if(size == sizeof(long) ) 595 argv.l = va_arg(args, long); 596 else argv.i = va_arg(args, int); 597 break; 598 case SFFMT_FLOAT: 599 #if !_ast_fltmax_double 600 if(size == sizeof(Sfdouble_t)) 601 argv.ld = va_arg(args,Sfdouble_t); 602 else 603 #endif 604 argv.d = va_arg(args,double); 605 break; 606 case SFFMT_POINTER: 607 argv.vp = va_arg(args,Void_t*); 608 break; 609 case SFFMT_CHAR: 610 if(base >= 0) 611 argv.s = va_arg(args,char*); 612 #if _has_multibyte 613 else if((flags & SFFMT_LONG) || fmt == 'C') 614 { if(sizeof(wchar_t) <= sizeof(uint) ) 615 argv.wc = (wchar_t)va_arg(args,uint); 616 else argv.wc = va_arg(args,wchar_t); 617 } 618 #endif 619 else argv.i = va_arg(args,int); 620 break; 621 default: /* unknown pattern */ 622 break; 623 } 624 } 625 626 switch(fmt) /* PRINTF DIRECTIVES */ 627 { 628 default : /* unknown directive */ 629 form -= 1; 630 argn -= 1; 631 continue; 632 633 case '!' : /* stacking a new environment */ 634 if(!fp) 635 fp = (*_Sffmtposf)(f,oform,oargs,ft,0); 636 else goto pop_fmt; 637 638 if(!argv.ft) 639 goto pop_fmt; 640 if(!argv.ft->form && ft ) /* change extension functions */ 641 { if(ft->eventf && 642 (*ft->eventf)(f,SF_DPOP,(Void_t*)form,ft) < 0) 643 continue; 644 fmstk->ft = ft = argv.ft; 645 } 646 else /* stack a new environment */ 647 { if(!(fm = (Fmt_t*)malloc(sizeof(Fmt_t))) ) 648 goto done; 649 650 ft = fm->ft = argv.ft; 651 SFMBSET(ft->mbs, &fmbs); 652 if(ft->form) 653 { fm->form = (char*)form; SFMBCPY(&fm->mbs,&fmbs); 654 va_copy(fm->args,args); 655 656 fm->oform = oform; 657 va_copy(fm->oargs,oargs); 658 fm->argn = argn; 659 fm->fp = fp; 660 661 form = ft->form; SFMBCLR(ft->mbs); 662 va_copy(args,ft->args); 663 argn = -1; 664 fp = NIL(Fmtpos_t*); 665 oform = (char*)form; 666 va_copy(oargs,args); 667 } 668 else fm->form = NIL(char*); 669 670 fm->eventf = ft->eventf; 671 fm->next = fmstk; 672 fmstk = fm; 673 } 674 continue; 675 676 case 'S': 677 flags = (flags & ~(SFFMT_TYPES|SFFMT_LDOUBLE)) | SFFMT_LONG; 678 /* FALLTHROUGH */ 679 case 's': 680 #if _has_multibyte && defined(mbwidth) 681 wc = (flags & SFFMT_LDOUBLE) && mbwide(); 682 #endif 683 if(base >= 0) /* list of strings */ 684 { if(!(ls = argv.sp) || !ls[0]) 685 continue; 686 } 687 else 688 { if(!(sp = argv.s)) 689 { sp = "(null)"; 690 flags &= ~SFFMT_LONG; 691 } 692 #if _PACKAGE_ast 693 str_cvt: 694 if(scale) 695 { size = base = -1; 696 flags &= ~SFFMT_LONG; 697 } 698 #endif 699 ls = tls; tls[0] = sp; 700 } 701 for(sp = *ls;;) 702 { /* v: number of bytes w: print width of those v bytes */ 703 #if _has_multibyte 704 if(flags & SFFMT_LONG) 705 { v = 0; 706 #ifdef mbwidth 707 w = 0; 708 #endif 709 SFMBCLR(&mbs); 710 for(n = 0, wsp = (wchar_t*)sp;; ++wsp, ++n) 711 { if((size >= 0 && n >= size) || 712 (size < 0 && *wsp == 0) ) 713 break; 714 if((n_s = wcrtomb(buf, *wsp, &mbs)) <= 0) 715 break; 716 #ifdef mbwidth 717 if(wc) 718 { n_w = mbwidth(*wsp); 719 if(precis >= 0 && (w+n_w) > precis ) 720 break; 721 w += n_w; 722 } 723 else 724 #endif 725 if(precis >= 0 && (v+n_s) > precis ) 726 break; 727 v += n_s; 728 } 729 #ifdef mbwidth 730 if(!wc) 731 w = v; 732 #endif 733 } 734 #ifdef mbwidth 735 else if (wc) 736 { w = 0; 737 SFMBCLR(&mbs); 738 ssp = sp; 739 for(;;) 740 { if((size >= 0 && w >= size) || 741 (size < 0 && *ssp == 0) ) 742 break; 743 osp = ssp; 744 n = mbchar(osp); 745 n_w = mbwidth(n); 746 if(precis >= 0 && (w+n_w) > precis ) 747 break; 748 w += n_w; 749 ssp = osp; 750 } 751 v = ssp - sp; 752 } 753 #endif 754 else 755 #endif 756 { if((v = size) < 0) 757 for(v = 0; v != precis && sp[v]; ++v); 758 if(precis >= 0 && v > precis) 759 v = precis; 760 w = v; 761 } 762 763 if((n = width - w) > 0 && !(flags&SFFMT_LEFT) ) 764 { if(flags&SFFMT_CENTER) 765 { n -= (k = n/2); 766 SFnputc(f, ' ', k); 767 } 768 else 769 { SFnputc(f, ' ', n); 770 n = 0; 771 } 772 } 773 if(n < 0 && (flags & SFFMT_CHOP) && width > 0 && precis < 0) 774 { 775 #if _has_multibyte 776 if(flags & SFFMT_LONG) 777 { SFMBCLR(&mbs); 778 wsp = (wchar_t*)sp; 779 while(n < 0) 780 { 781 #ifdef mbwidth 782 n += mbwidth(*wsp); 783 #else 784 n++; 785 #endif 786 wsp++; 787 w--; 788 } 789 sp = (char*)wsp; 790 } 791 else if (wc) 792 { SFMBCLR(&mbs); 793 osp = sp; 794 while(n < 0) 795 { ssp = sp; 796 if ((k = mbchar(sp)) <= 0) 797 { sp = ssp; 798 break; 799 } 800 #ifdef mbwidth 801 n += mbwidth(k); 802 #else 803 n++; 804 #endif 805 } 806 v -= (sp - osp); 807 } 808 else 809 #endif 810 { sp += -n; 811 v += n; 812 } 813 n = 0; 814 } 815 #if _has_multibyte 816 if(flags & SFFMT_LONG) 817 { SFMBCLR(&mbs); 818 for(wsp = (wchar_t*)sp; w > 0; ++wsp, --w) 819 { if((n_s = wcrtomb(buf, *wsp, &mbs)) <= 0) 820 break; 821 sp = buf; SFwrite(f, sp, n_s); 822 } 823 } 824 else 825 #endif 826 { SFwrite(f,sp,v); } 827 if(n > 0) 828 { SFnputc(f,' ',n); } 829 if(!(sp = *++ls)) 830 break; 831 else if(base > 0) 832 { SFputc(f,base); } 833 } 834 continue; 835 836 case 'C': 837 flags = (flags & ~(SFFMT_TYPES|SFFMT_LDOUBLE)) | SFFMT_LONG; 838 /* FALLTHROUGH */ 839 case 'c': 840 #if _has_multibyte && defined(mbwidth) 841 wc = (flags & SFFMT_LDOUBLE) && mbwide(); 842 #endif 843 if(precis <= 0) /* # of times to repeat a character */ 844 precis = 1; 845 #if _has_multibyte 846 if(flags & SFFMT_LONG) 847 { if(base >= 0) 848 { if(!(wsp = (wchar_t*)argv.s) ) 849 continue; 850 for(size = 0; wsp[size]; ++size) 851 ; 852 } 853 else 854 { wsp = &argv.wc; 855 size = 1; 856 } 857 } 858 else 859 #endif 860 { if(base >= 0) 861 { if(!(sp = argv.s) ) 862 continue; 863 size = strlen(sp); 864 } 865 else 866 { argv.c = (char)(argv.i); 867 sp = &argv.c; 868 size = 1; 869 } 870 } 871 872 while(size > 0) 873 { 874 #if _has_multibyte 875 if(flags&SFFMT_LONG) 876 { SFMBCLR(&mbs); 877 if((n_s = wcrtomb(buf, *wsp++, &mbs)) <= 0) 878 break; 879 #ifdef mbwidth 880 if(wc) 881 n_s = mbwidth(*(wsp - 1)); 882 #endif 883 n = width - precis*n_s; /* padding amount */ 884 } 885 else 886 #endif 887 if(flags&SFFMT_ALTER) 888 { n_s = chr2str(buf, *sp++); 889 n = width - precis*n_s; 890 } 891 else 892 { fmt = *sp++; 893 n = width - precis; 894 } 895 896 if(n > 0 && !(flags&SFFMT_LEFT) ) 897 { if(flags&SFFMT_CENTER) 898 { n -= (k = n/2); 899 SFnputc(f, ' ', k); 900 } 901 else 902 { SFnputc(f, ' ', n); 903 n = 0; 904 } 905 } 906 907 v = precis; /* need this because SFnputc may clear it */ 908 #if _has_multibyte 909 if(flags&SFFMT_LONG) 910 { for(; v > 0; --v) 911 { ssp = buf; k = n_s; SFwrite(f,ssp,k); } 912 } 913 else 914 #endif 915 if(flags&SFFMT_ALTER) 916 { for(; v > 0; --v) 917 { ssp = buf; k = n_s; SFwrite(f,ssp,k); } 918 } 919 else 920 { SFnputc(f, fmt, v); 921 } 922 923 if(n > 0) 924 { SFnputc(f,' ',n); }; 925 926 if((size -= 1) > 0 && base > 0) 927 { SFputc(f,base); } 928 } 929 continue; 930 931 case 'n': /* return current output length */ 932 SFEND(f); 933 #if !_ast_intmax_long 934 if(size == sizeof(Sflong_t) ) 935 *((Sflong_t*)argv.vp) = (Sflong_t)n_output; 936 else 937 #endif 938 if(size == sizeof(long)) 939 *((long*)argv.vp) = (long)n_output; 940 else if(size == sizeof(short) ) 941 *((short*)argv.vp) = (short)n_output; 942 else if(size == sizeof(uchar) ) 943 *((uchar*)argv.vp) = (uchar)n_output; 944 else *((int*)argv.vp) = (int)n_output; 945 946 continue; 947 948 case 'p': /* pointer value */ 949 fmt = 'x'; 950 base = 16; n_s = 15; n = 4; 951 flags = (flags&~(SFFMT_SIGN|SFFMT_BLANK|SFFMT_ZERO))|SFFMT_ALTER; 952 #if _more_void_int 953 lv = (Sflong_t)((Sfulong_t)argv.vp); 954 goto long_cvt; 955 #else 956 v = (int)((uint)argv.vp); 957 goto int_cvt; 958 #endif 959 case 'o': 960 base = 8; n_s = 7; n = 3; 961 flags &= ~(SFFMT_SIGN|SFFMT_BLANK); 962 goto int_arg; 963 case 'X': 964 ssp = "0123456789ABCDEF"; 965 /* FALLTHROUGH */ 966 case 'x': 967 base = 16; n_s = 15; n = 4; 968 flags &= ~(SFFMT_SIGN|SFFMT_BLANK); 969 goto int_arg; 970 case 'i': 971 #if _PACKAGE_ast 972 if((flags&SFFMT_ALTER) && base < 0) 973 { flags &= ~SFFMT_ALTER; 974 scale = 1024; 975 } 976 #endif 977 fmt = 'd'; 978 goto d_format; 979 case 'u': 980 flags &= ~(SFFMT_SIGN|SFFMT_BLANK); 981 /* FALLTHROUGH */ 982 case 'd': 983 d_format: 984 #if _PACKAGE_ast 985 if((flags&SFFMT_ALTER) && base < 0) 986 { flags &= ~SFFMT_ALTER; 987 scale = 1000; 988 } 989 #endif 990 if(base < 2 || base > SF_RADIX) 991 base = 10; 992 if((base&(n_s = base-1)) == 0) 993 { if(base < 8) 994 n = base < 4 ? 1 : 2; 995 else if(base < 32) 996 n = base < 16 ? 3 : 4; 997 else n = base < 64 ? 5 : 6; 998 } 999 else n_s = base == 10 ? -1 : 0; 1000 1001 int_arg: 1002 #if !_ast_intmax_long || _more_long_int || _more_void_int 1003 if(size == sizeof(Sflong_t)) 1004 { lv = argv.ll; 1005 goto long_cvt; 1006 } 1007 else if(sizeof(long) < sizeof(Sflong_t) && size == sizeof(long)) 1008 { if(fmt == 'd') 1009 lv = (Sflong_t)argv.l; 1010 else lv = (Sflong_t)argv.ul; 1011 long_cvt: 1012 #if _PACKAGE_ast 1013 if(scale) 1014 { sp = fmtscale(lv, scale); 1015 #if _has_multibyte && defined(mbwidth) 1016 wc = 0; 1017 #endif 1018 goto str_cvt; 1019 } 1020 #endif 1021 if(lv == 0 && precis == 0) 1022 break; 1023 if(lv < 0 && fmt == 'd' ) 1024 { flags |= SFFMT_MINUS; 1025 if(lv == HIGHBITL) /* avoid overflow */ 1026 { lv = (Sflong_t)(HIGHBITL/base); 1027 *--sp = _Sfdigits[HIGHBITL - 1028 ((Sfulong_t)lv)*base]; 1029 } 1030 else lv = -lv; 1031 } 1032 if(n_s < 0) /* base 10 */ 1033 { Sflong_t nv; 1034 sfucvt(lv,sp,nv,ssp,Sflong_t,Sfulong_t); 1035 } 1036 else if(n_s > 0) /* base power-of-2 */ 1037 { do 1038 { *--sp = ssp[lv&n_s]; 1039 } while((lv = ((Sfulong_t)lv) >> n) ); 1040 } 1041 else /* general base */ 1042 { do 1043 { *--sp = ssp[((Sfulong_t)lv)%base]; 1044 } while((lv = ((Sfulong_t)lv)/base) ); 1045 } 1046 } else 1047 #endif 1048 if(sizeof(short) < sizeof(int) && size == sizeof(short) ) 1049 { if(fmt == 'd') 1050 v = (int)((short)argv.i); 1051 else v = (int)((ushort)argv.i); 1052 goto int_cvt; 1053 } 1054 else if(size == sizeof(char)) 1055 { if(fmt != 'd') 1056 v = (int)((uchar)argv.i); 1057 else 1058 { 1059 #if _key_signed 1060 v = (int)((signed char)argv.i); 1061 #else 1062 if(argv.i < 0) 1063 v = -((int)((char)(-argv.i))); 1064 else v = ((int)((char)( argv.i))); 1065 #endif 1066 } 1067 goto int_cvt; 1068 } 1069 else 1070 { v = argv.i; 1071 int_cvt: 1072 #if _PACKAGE_ast 1073 if(scale) 1074 { sp = fmtscale(v, scale); 1075 #if _has_multibyte && defined(mbwidth) 1076 wc = 0; 1077 #endif 1078 goto str_cvt; 1079 } 1080 #endif 1081 if(v == 0 && precis == 0) 1082 break; 1083 if(v < 0 && fmt == 'd' ) 1084 { flags |= SFFMT_MINUS; 1085 if(v == HIGHBITI) /* avoid overflow */ 1086 { v = (int)(HIGHBITI/base); 1087 *--sp = _Sfdigits[HIGHBITI - 1088 ((uint)v)*base]; 1089 } 1090 else v = -v; 1091 } 1092 if(n_s < 0) /* base 10 */ 1093 { sfucvt(v,sp,n,ssp,int,uint); 1094 } 1095 else if(n_s > 0) /* base power-of-2 */ 1096 { do 1097 { *--sp = ssp[v&n_s]; 1098 } while((v = ((uint)v) >> n) ); 1099 } 1100 else /* n_s == 0, general base */ 1101 { do 1102 { *--sp = ssp[((uint)v)%base]; 1103 } while((v = ((uint)v)/base) ); 1104 } 1105 } 1106 1107 if(n_s < 0 && (flags&SFFMT_THOUSAND) && (n = endsp-sp) > 3) 1108 { if((n %= 3) == 0) 1109 n = 3; 1110 for(ep = buf+SLACK, endep = ep + n; ; ) 1111 { while(ep < endep) 1112 *ep++ = *sp++; 1113 if(sp == endsp) 1114 break; 1115 if(sp <= endsp-3) 1116 *ep++ = thousand; 1117 endep = ep+3; 1118 } 1119 sp = buf+SLACK; 1120 endsp = ep; 1121 } 1122 1123 /* zero padding for precision if have room in buffer */ 1124 if(precis > 0 && (precis -= (endsp-sp)) < (sp-buf)-64) 1125 while(precis-- > 0) 1126 *--sp = '0'; 1127 1128 if(flags&SFFMT_ALTER) /* prefix */ 1129 { if(fmt == 'o') 1130 { if(*sp != '0') 1131 *--sp = '0'; 1132 } 1133 else 1134 { if(width > 0 && (flags&SFFMT_ZERO)) 1135 { /* do 0 padding first */ 1136 if(fmt == 'x' || fmt == 'X') 1137 n = 0; 1138 else if(dot < 2) 1139 n = width; 1140 else n = base < 10 ? 2 : 3; 1141 n += (flags&(SFFMT_MINUS|SFFMT_SIGN)) ? 1142 1 : 0; 1143 n = width - (n + (endsp-sp)); 1144 while(n-- > 0) 1145 *--sp = '0'; 1146 } 1147 if(fmt == 'x' || fmt == 'X') 1148 { *--sp = (char)fmt; 1149 *--sp = '0'; 1150 } 1151 else if(dot >= 2) 1152 { /* base#value notation */ 1153 *--sp = '#'; 1154 if(base < 10) 1155 *--sp = (char)('0'+base); 1156 else 1157 { *--sp = _Sfdec[(base <<= 1)+1]; 1158 *--sp = _Sfdec[base]; 1159 } 1160 } 1161 } 1162 } 1163 1164 break; 1165 1166 case 'g': case 'G': /* these ultimately become %e or %f */ 1167 case 'a': case 'A': 1168 case 'e': case 'E': 1169 case 'f': case 'F': 1170 #if !_ast_fltmax_double 1171 if(size == sizeof(Sfdouble_t) ) 1172 { v = SFFMT_LDOUBLE; 1173 valp = &argv.ld; 1174 dval = argv.ld; 1175 } 1176 else 1177 #endif 1178 { v = 0; 1179 valp = &argv.d; 1180 dval = argv.d; 1181 } 1182 1183 if(fmt == 'e' || fmt == 'E' && (v |= SFFMT_UPPER)) 1184 { v |= SFFMT_EFORMAT; 1185 n = (precis = precis < 0 ? FPRECIS : precis)+1; 1186 ep = _sfcvt(valp,tmp+1,sizeof(tmp)-1, min(n,SF_FDIGITS), 1187 &decpt, &sign, &n_s, v); 1188 goto e_format; 1189 } 1190 else if(fmt == 'f' || fmt == 'F' && (v |= SFFMT_UPPER)) 1191 { precis = precis < 0 ? FPRECIS : precis; 1192 ep = _sfcvt(valp,tmp+1,sizeof(tmp)-1, min(precis,SF_FDIGITS), 1193 &decpt, &sign, &n_s, v); 1194 goto f_format; 1195 } 1196 else if(fmt == 'a' || fmt == 'A' && (v |= SFFMT_UPPER)) 1197 { v |= SFFMT_AFORMAT; 1198 if(precis < 0) 1199 { if(v & SFFMT_LDOUBLE) 1200 precis = 2*(sizeof(Sfdouble_t) - 2); 1201 else precis = 2*(sizeof(double) - 2); 1202 } 1203 n = precis + 1; 1204 ep = _sfcvt(valp,tmp+1,sizeof(tmp)-1, min(n,SF_FDIGITS), 1205 &decpt, &sign, &n_s, v); 1206 1207 sp = endsp = buf+1; /* reserve space for sign */ 1208 *endsp++ = '0'; 1209 *endsp++ = fmt == 'a' ? 'x' : 'X'; 1210 if (!isxdigit(*ep)) 1211 goto infinite; 1212 if (base < 0) 1213 base = 0; 1214 goto a_format; 1215 } 1216 else /* 'g' or 'G' format */ 1217 { precis = precis < 0 ? FPRECIS : precis == 0 ? 1 : precis; 1218 if(fmt == 'G') 1219 v |= SFFMT_UPPER; 1220 v |= SFFMT_EFORMAT; 1221 ep = _sfcvt(valp,tmp+1,sizeof(tmp)-1, min(precis,SF_FDIGITS), 1222 &decpt, &sign, &n_s, v); 1223 if(dval == 0.) 1224 decpt = 1; 1225 else if(*ep == 'I') 1226 goto infinite; 1227 1228 if(!(flags&SFFMT_ALTER)) 1229 { /* zap trailing 0s */ 1230 if((n = n_s) > precis) 1231 n = precis; 1232 while((n -= 1) >= 1 && ep[n] == '0') 1233 ; 1234 n += 1; 1235 } 1236 else n = precis; 1237 1238 if(decpt < -3 || decpt > precis) 1239 { precis = n-1; 1240 goto e_format; 1241 } 1242 else 1243 { precis = n - decpt; 1244 goto f_format; 1245 } 1246 } 1247 1248 e_format: /* build the x.yyyy string */ 1249 if(isalpha(*ep)) 1250 goto infinite; 1251 sp = endsp = buf+1; /* reserve space for sign */ 1252 if (base <= 0) 1253 base = 2; 1254 a_format: 1255 *endsp++ = *ep ? *ep++ : '0'; 1256 1257 SFSETLOCALE(&decimal,&thousand); 1258 if(precis > 0 || (flags&SFFMT_ALTER)) 1259 *endsp++ = decimal; 1260 ssp = endsp; 1261 endep = ep+precis; 1262 while((*endsp++ = *ep++) && ep <= endep) 1263 ; 1264 precis -= (endsp -= 1) - ssp; 1265 1266 /* build the exponent */ 1267 ep = endep = buf+(sizeof(buf)-1); 1268 if(dval != 0.) 1269 { if((n = decpt - 1) < 0) 1270 n = -n; 1271 while(n > 9) 1272 { v = n; n /= 10; 1273 *--ep = (char)('0' + (v - n*10)); 1274 } 1275 } 1276 else n = 0; 1277 *--ep = (char)('0' + n); 1278 while((endep-ep) < base && ep > (buf+2)) /* at least base digits in exponent */ 1279 *--ep = '0'; 1280 1281 /* the e/Exponent separator and sign */ 1282 *--ep = (decpt > 0 || dval == 0.) ? '+' : '-'; 1283 *--ep = fmt == 'a' ? 'p' : fmt == 'A' ? 'P' : 1284 isupper(fmt) ? 'E' : 'e'; 1285 1286 goto end_aefg; 1287 1288 f_format: /* data before the decimal point */ 1289 if(isalpha(*ep)) 1290 { 1291 infinite: 1292 flags &= ~SFFMT_ZERO; 1293 endsp = (sp = ep)+sfslen(); 1294 ep = endep; 1295 precis = 0; 1296 goto end_aefg; 1297 } 1298 1299 SFSETLOCALE(&decimal,&thousand); 1300 endsp = sp = buf+1; /* save a space for sign */ 1301 endep = ep+decpt; 1302 if(decpt > 3 && (flags&SFFMT_THOUSAND) ) 1303 { if((n = decpt%3) == 0) 1304 n = 3; 1305 while(ep < endep && (*endsp++ = *ep++) ) 1306 { if(--n == 0 && (ep <= endep-3) ) 1307 { *endsp++ = thousand; 1308 n = 3; 1309 } 1310 } 1311 } 1312 else 1313 { while(ep < endep && (*endsp++ = *ep++)) 1314 ; 1315 } 1316 if(endsp == sp) 1317 *endsp++ = '0'; 1318 1319 if(precis > 0 || (flags&SFFMT_ALTER)) 1320 *endsp++ = decimal; 1321 1322 if((n = -decpt) > 0) 1323 { /* output zeros for negative exponent */ 1324 ssp = endsp + min(n,precis); 1325 precis -= n; 1326 while(endsp < ssp) 1327 *endsp++ = '0'; 1328 } 1329 1330 ssp = endsp; 1331 endep = ep+precis; 1332 while((*endsp++ = *ep++) && ep <= endep) 1333 ; 1334 precis -= (endsp -= 1) - ssp; 1335 ep = endep; 1336 end_aefg: 1337 flags |= SFFMT_FLOAT; 1338 if(sign) 1339 flags |= SFFMT_MINUS; 1340 break; 1341 } 1342 1343 if(flags == 0 && width <= 0) 1344 goto do_output; 1345 1346 if(flags&SFFMT_PREFIX) 1347 fmt = (flags&SFFMT_MINUS) ? '-' : (flags&SFFMT_SIGN) ? '+' : ' '; 1348 1349 n = (endsp-sp) + (endep-ep) + (precis <= 0 ? 0 : precis) + 1350 ((flags&SFFMT_PREFIX) ? 1 : 0); 1351 if((v = width-n) <= 0) 1352 v = 0; 1353 else if(!(flags&SFFMT_ZERO)) /* right padding */ 1354 { if(flags&SFFMT_LEFT) 1355 v = -v; 1356 else if(flags&SFFMT_PREFIX) /* blank padding, output prefix now */ 1357 { *--sp = fmt; 1358 flags &= ~SFFMT_PREFIX; 1359 } 1360 } 1361 1362 if(flags&SFFMT_PREFIX) /* put out the prefix */ 1363 { SFputc(f,fmt); 1364 if(fmt != ' ') 1365 flags |= SFFMT_ZERO; 1366 } 1367 1368 if((n = v) > 0) /* left padding */ 1369 { v = (flags&SFFMT_ZERO) ? '0' : ' '; 1370 SFnputc(f,v,n); 1371 } 1372 1373 if((n = precis) > 0 && !(flags&SFFMT_FLOAT)) 1374 { /* padding for integer precision */ 1375 SFnputc(f,'0',n); 1376 precis = 0; 1377 } 1378 1379 do_output: 1380 if((n = endsp-sp) > 0) 1381 SFwrite(f,sp,n); 1382 1383 if(flags&(SFFMT_FLOAT|SFFMT_LEFT)) 1384 { /* SFFMT_FLOAT: right padding for float precision */ 1385 if((n = precis) > 0) 1386 SFnputc(f,'0',n); 1387 1388 /* SFFMT_FLOAT: the exponent of %eE */ 1389 if((n = endep - (sp = ep)) > 0) 1390 SFwrite(f,sp,n); 1391 1392 /* SFFMT_LEFT: right padding */ 1393 if((n = -v) > 0) 1394 { SFnputc(f,' ',n); } 1395 } 1396 } 1397 1398 pop_fmt: 1399 if(fp) 1400 { free(fp); 1401 fp = NIL(Fmtpos_t*); 1402 } 1403 while((fm = fmstk) ) /* pop the format stack and continue */ 1404 { if(fm->eventf) 1405 { if(!form || !form[0]) 1406 (*fm->eventf)(f,SF_FINAL,NIL(Void_t*),ft); 1407 else if((*fm->eventf)(f,SF_DPOP,(Void_t*)form,ft) < 0) 1408 goto loop_fmt; 1409 } 1410 1411 fmstk = fm->next; 1412 if((form = fm->form) ) 1413 { SFMBCPY(&fmbs,&fm->mbs); 1414 va_copy(args, fm->args); 1415 oform = fm->oform; 1416 va_copy(oargs,fm->oargs); 1417 argn = fm->argn; 1418 fp = fm->fp; 1419 } 1420 ft = fm->ft; 1421 free(fm); 1422 if(form && form[0]) 1423 goto loop_fmt; 1424 } 1425 1426 done: 1427 if(fp) 1428 free(fp); 1429 while((fm = fmstk) ) 1430 { if(fm->eventf) 1431 (*fm->eventf)(f,SF_FINAL,NIL(Void_t*),fm->ft); 1432 fmstk = fm->next; 1433 free(fm); 1434 } 1435 1436 SFEND(f); 1437 1438 n = f->next - f->data; 1439 if((sp = (char*)f->data) == data) 1440 f->endw = f->endr = f->endb = f->data = NIL(uchar*); 1441 f->next = f->data; 1442 1443 if((((flags = f->flags)&SF_SHARE) && !(flags&SF_PUBLIC) ) || 1444 (n > 0 && (sp == data || (flags&SF_LINE) ) ) ) 1445 (void)SFWRITE(f,(Void_t*)sp,n); 1446 else f->next += n; 1447 1448 SFOPEN(f,0); 1449 SFMTXRETURN(f, n_output); 1450 } 1451