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