![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to spprintf.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / main|
Return to spprintf.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / main |
1.1 misho 1: /*
2: +----------------------------------------------------------------------+
3: | PHP Version 5 |
4: +----------------------------------------------------------------------+
5: | Copyright (c) 1997-2012 The PHP Group |
6: +----------------------------------------------------------------------+
7: | This source file is subject to version 3.01 of the PHP license, |
8: | that is bundled with this package in the file LICENSE, and is |
9: | available through the world-wide-web at the following url: |
10: | http://www.php.net/license/3_01.txt |
11: | If you did not receive a copy of the PHP license and are unable to |
12: | obtain it through the world-wide-web, please send a note to |
13: | license@php.net so we can mail you a copy immediately. |
14: +----------------------------------------------------------------------+
15: | Author: Marcus Boerger <helly@php.net> |
16: +----------------------------------------------------------------------+
17: */
18:
1.1.1.2 ! misho 19: /* $Id$ */
1.1 misho 20:
21: /* This is the spprintf implementation.
22: * It has emerged from apache snprintf. See original header:
23: */
24:
25: /* ====================================================================
26: * Copyright (c) 1995-1998 The Apache Group. All rights reserved.
27: *
28: * Redistribution and use in source and binary forms, with or without
29: * modification, are permitted provided that the following conditions
30: * are met:
31: *
32: * 1. Redistributions of source code must retain the above copyright
33: * notice, this list of conditions and the following disclaimer.
34: *
35: * 2. Redistributions in binary form must reproduce the above copyright
36: * notice, this list of conditions and the following disclaimer in
37: * the documentation and/or other materials provided with the
38: * distribution.
39: *
40: * 3. All advertising materials mentioning features or use of this
41: * software must display the following acknowledgment:
42: * "This product includes software developed by the Apache Group
43: * for use in the Apache HTTP server project (http://www.apache.org/)."
44: *
45: * 4. The names "Apache Server" and "Apache Group" must not be used to
46: * endorse or promote products derived from this software without
47: * prior written permission.
48: *
49: * 5. Redistributions of any form whatsoever must retain the following
50: * acknowledgment:
51: * "This product includes software developed by the Apache Group
52: * for use in the Apache HTTP server project (http://www.apache.org/)."
53: *
54: * THIS SOFTWARE IS PROVIDED BY THE APACHE GROUP ``AS IS'' AND ANY
55: * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
56: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
57: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE APACHE GROUP OR
58: * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
59: * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
60: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
61: * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
62: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
63: * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
64: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
65: * OF THE POSSIBILITY OF SUCH DAMAGE.
66: * ====================================================================
67: *
68: * This software consists of voluntary contributions made by many
69: * individuals on behalf of the Apache Group and was originally based
70: * on public domain software written at the National Center for
71: * Supercomputing Applications, University of Illinois, Urbana-Champaign.
72: * For more information on the Apache Group and the Apache HTTP server
73: * project, please see <http://www.apache.org/>.
74: *
75: * This code is based on, and used with the permission of, the
76: * SIO stdio-replacement strx_* functions by Panos Tsirigotis
77: * <panos@alumni.cs.colorado.edu> for xinetd.
78: */
79: #define _GNU_SOURCE
80: #include "php.h"
81:
82: #include <stddef.h>
83: #include <stdio.h>
84: #include <ctype.h>
85: #include <sys/types.h>
86: #include <stdarg.h>
87: #include <string.h>
88: #include <stdlib.h>
89: #include <math.h>
90: #ifdef HAVE_INTTYPES_H
91: #include <inttypes.h>
92: #endif
93:
94: #ifdef HAVE_LOCALE_H
95: #include <locale.h>
96: #define LCONV_DECIMAL_POINT (*lconv->decimal_point)
97: #else
98: #define LCONV_DECIMAL_POINT '.'
99: #endif
100:
101: #include "snprintf.h"
102:
103: #define FALSE 0
104: #define TRUE 1
105: #define NUL '\0'
106: #define INT_NULL ((int *)0)
107:
108: #define S_NULL "(null)"
109: #define S_NULL_LEN 6
110:
111: #define FLOAT_DIGITS 6
112: #define EXPONENT_LENGTH 10
113:
114: #include "ext/standard/php_smart_str.h"
115:
116: /* {{{ macros */
117:
118: /*
119: * NUM_BUF_SIZE is the size of the buffer used for arithmetic conversions
120: *
121: * XXX: this is a magic number; do not decrease it
122: * Emax = 1023
123: * NDIG = 320
124: * NUM_BUF_SIZE >= strlen("-") + Emax + strlrn(".") + NDIG + strlen("E+1023") + 1;
125: */
1.1.1.2 ! misho 126: #define NUM_BUF_SIZE 2048
1.1 misho 127:
128: /*
129: * The INS_CHAR macro inserts a character in the buffer.
130: *
131: * NOTE: Evaluation of the ch argument should not have any side-effects
132: */
133: #define INS_CHAR_NR(xbuf, ch) do { \
134: smart_str_appendc(xbuf, ch); \
135: } while (0)
136:
137: #define INS_STRING(xbuf, s, slen) do { \
138: smart_str_appendl(xbuf, s, slen); \
139: } while (0)
140:
141: #define INS_CHAR(xbuf, ch) \
142: INS_CHAR_NR(xbuf, ch)
143:
144: /*
145: * Macro that does padding. The padding is done by printing
146: * the character ch.
147: */
148: #define PAD(xbuf, count, ch) do { \
149: if ((count) > 0) { \
150: size_t newlen; \
151: smart_str_alloc(xbuf, (count), 0); \
152: memset(xbuf->c + xbuf->len, ch, (count)); \
153: xbuf->len += (count); \
154: } \
155: } while (0)
156:
157: #define NUM(c) (c - '0')
158:
159: #define STR_TO_DEC(str, num) do { \
160: num = NUM(*str++); \
161: while (isdigit((int)*str)) { \
162: num *= 10; \
163: num += NUM(*str++); \
164: if (num >= INT_MAX / 10) { \
165: while (isdigit((int)*str++)); \
166: break; \
167: } \
168: } \
169: } while (0)
170:
171: /*
172: * This macro does zero padding so that the precision
173: * requirement is satisfied. The padding is done by
174: * adding '0's to the left of the string that is going
175: * to be printed.
176: */
177: #define FIX_PRECISION(adjust, precision, s, s_len) do { \
178: if (adjust) \
179: while (s_len < precision) { \
180: *--s = '0'; \
181: s_len++; \
182: } \
183: } while (0)
184:
185: /* }}} */
186:
187:
188: #if !HAVE_STRNLEN
189: static size_t strnlen(const char *s, size_t maxlen) {
190: char *r = memchr(s, '\0', maxlen);
191: return r ? r-s : maxlen;
192: }
193: #endif
194:
195: /*
196: * Do format conversion placing the output in buffer
197: */
198: static void xbuf_format_converter(smart_str *xbuf, const char *fmt, va_list ap) /* {{{ */
199: {
200: char *s = NULL;
201: int s_len, free_zcopy;
202: zval *zvp, zcopy;
203:
204: int min_width = 0;
205: int precision = 0;
206: enum {
207: LEFT, RIGHT
208: } adjust;
209: char pad_char;
210: char prefix_char;
211:
212: double fp_num;
213: wide_int i_num = (wide_int) 0;
214: u_wide_int ui_num;
215:
216: char num_buf[NUM_BUF_SIZE];
217: char char_buf[2]; /* for printing %% and %<unknown> */
218:
219: #ifdef HAVE_LOCALE_H
220: struct lconv *lconv = NULL;
221: #endif
222:
223: /*
224: * Flag variables
225: */
226: length_modifier_e modifier;
227: boolean_e alternate_form;
228: boolean_e print_sign;
229: boolean_e print_blank;
230: boolean_e adjust_precision;
231: boolean_e adjust_width;
232: bool_int is_negative;
233:
234: while (*fmt) {
235: if (*fmt != '%') {
236: INS_CHAR(xbuf, *fmt);
237: } else {
238: /*
239: * Default variable settings
240: */
241: adjust = RIGHT;
242: alternate_form = print_sign = print_blank = NO;
243: pad_char = ' ';
244: prefix_char = NUL;
245: free_zcopy = 0;
246:
247: fmt++;
248:
249: /*
250: * Try to avoid checking for flags, width or precision
251: */
252: if (isascii((int)*fmt) && !islower((int)*fmt)) {
253: /*
254: * Recognize flags: -, #, BLANK, +
255: */
256: for (;; fmt++) {
257: if (*fmt == '-')
258: adjust = LEFT;
259: else if (*fmt == '+')
260: print_sign = YES;
261: else if (*fmt == '#')
262: alternate_form = YES;
263: else if (*fmt == ' ')
264: print_blank = YES;
265: else if (*fmt == '0')
266: pad_char = '0';
267: else
268: break;
269: }
270:
271: /*
272: * Check if a width was specified
273: */
274: if (isdigit((int)*fmt)) {
275: STR_TO_DEC(fmt, min_width);
276: adjust_width = YES;
277: } else if (*fmt == '*') {
278: min_width = va_arg(ap, int);
279: fmt++;
280: adjust_width = YES;
281: if (min_width < 0) {
282: adjust = LEFT;
283: min_width = -min_width;
284: }
285: } else
286: adjust_width = NO;
287:
288: /*
289: * Check if a precision was specified
290: */
291: if (*fmt == '.') {
292: adjust_precision = YES;
293: fmt++;
294: if (isdigit((int)*fmt)) {
295: STR_TO_DEC(fmt, precision);
296: } else if (*fmt == '*') {
297: precision = va_arg(ap, int);
298: fmt++;
299: if (precision < 0)
300: precision = 0;
301: } else
302: precision = 0;
303:
304: if (precision > FORMAT_CONV_MAX_PRECISION) {
305: precision = FORMAT_CONV_MAX_PRECISION;
306: }
307: } else
308: adjust_precision = NO;
309: } else
310: adjust_precision = adjust_width = NO;
311:
312: /*
313: * Modifier check
314: */
315: switch (*fmt) {
316: case 'L':
317: fmt++;
318: modifier = LM_LONG_DOUBLE;
319: break;
320: case 'I':
321: fmt++;
322: #if SIZEOF_LONG_LONG
323: if (*fmt == '6' && *(fmt+1) == '4') {
324: fmt += 2;
325: modifier = LM_LONG_LONG;
326: } else
327: #endif
328: if (*fmt == '3' && *(fmt+1) == '2') {
329: fmt += 2;
330: modifier = LM_LONG;
331: } else {
332: #ifdef _WIN64
333: modifier = LM_LONG_LONG;
334: #else
335: modifier = LM_LONG;
336: #endif
337: }
338: break;
339: case 'l':
340: fmt++;
341: #if SIZEOF_LONG_LONG
342: if (*fmt == 'l') {
343: fmt++;
344: modifier = LM_LONG_LONG;
345: } else
346: #endif
347: modifier = LM_LONG;
348: break;
349: case 'z':
350: fmt++;
351: modifier = LM_SIZE_T;
352: break;
353: case 'j':
354: fmt++;
355: #if SIZEOF_INTMAX_T
356: modifier = LM_INTMAX_T;
357: #else
358: modifier = LM_SIZE_T;
359: #endif
360: break;
361: case 't':
362: fmt++;
363: #if SIZEOF_PTRDIFF_T
364: modifier = LM_PTRDIFF_T;
365: #else
366: modifier = LM_SIZE_T;
367: #endif
368: break;
369: case 'h':
370: fmt++;
371: if (*fmt == 'h') {
372: fmt++;
373: }
374: /* these are promoted to int, so no break */
375: default:
376: modifier = LM_STD;
377: break;
378: }
379:
380: /*
381: * Argument extraction and printing.
382: * First we determine the argument type.
383: * Then, we convert the argument to a string.
384: * On exit from the switch, s points to the string that
385: * must be printed, s_len has the length of the string
386: * The precision requirements, if any, are reflected in s_len.
387: *
388: * NOTE: pad_char may be set to '0' because of the 0 flag.
389: * It is reset to ' ' by non-numeric formats
390: */
391: switch (*fmt) {
392: case 'Z':
393: zvp = (zval*) va_arg(ap, zval*);
394: zend_make_printable_zval(zvp, &zcopy, &free_zcopy);
395: if (free_zcopy) {
396: zvp = &zcopy;
397: }
398: s_len = Z_STRLEN_P(zvp);
399: s = Z_STRVAL_P(zvp);
400: if (adjust_precision && precision < s_len) {
401: s_len = precision;
402: }
403: break;
404: case 'u':
405: switch(modifier) {
406: default:
407: i_num = (wide_int) va_arg(ap, unsigned int);
408: break;
409: case LM_LONG_DOUBLE:
410: goto fmt_error;
411: case LM_LONG:
412: i_num = (wide_int) va_arg(ap, unsigned long int);
413: break;
414: case LM_SIZE_T:
415: i_num = (wide_int) va_arg(ap, size_t);
416: break;
417: #if SIZEOF_LONG_LONG
418: case LM_LONG_LONG:
419: i_num = (wide_int) va_arg(ap, u_wide_int);
420: break;
421: #endif
422: #if SIZEOF_INTMAX_T
423: case LM_INTMAX_T:
424: i_num = (wide_int) va_arg(ap, uintmax_t);
425: break;
426: #endif
427: #if SIZEOF_PTRDIFF_T
428: case LM_PTRDIFF_T:
429: i_num = (wide_int) va_arg(ap, ptrdiff_t);
430: break;
431: #endif
432: }
433: /*
434: * The rest also applies to other integer formats, so fall
435: * into that case.
436: */
437: case 'd':
438: case 'i':
439: /*
440: * Get the arg if we haven't already.
441: */
442: if ((*fmt) != 'u') {
443: switch(modifier) {
444: default:
445: i_num = (wide_int) va_arg(ap, int);
446: break;
447: case LM_LONG_DOUBLE:
448: goto fmt_error;
449: case LM_LONG:
450: i_num = (wide_int) va_arg(ap, long int);
451: break;
452: case LM_SIZE_T:
453: #if SIZEOF_SSIZE_T
454: i_num = (wide_int) va_arg(ap, ssize_t);
455: #else
456: i_num = (wide_int) va_arg(ap, size_t);
457: #endif
458: break;
459: #if SIZEOF_LONG_LONG
460: case LM_LONG_LONG:
461: i_num = (wide_int) va_arg(ap, wide_int);
462: break;
463: #endif
464: #if SIZEOF_INTMAX_T
465: case LM_INTMAX_T:
466: i_num = (wide_int) va_arg(ap, intmax_t);
467: break;
468: #endif
469: #if SIZEOF_PTRDIFF_T
470: case LM_PTRDIFF_T:
471: i_num = (wide_int) va_arg(ap, ptrdiff_t);
472: break;
473: #endif
474: }
475: }
476: s = ap_php_conv_10(i_num, (*fmt) == 'u', &is_negative,
477: &num_buf[NUM_BUF_SIZE], &s_len);
478: FIX_PRECISION(adjust_precision, precision, s, s_len);
479:
480: if (*fmt != 'u') {
481: if (is_negative)
482: prefix_char = '-';
483: else if (print_sign)
484: prefix_char = '+';
485: else if (print_blank)
486: prefix_char = ' ';
487: }
488: break;
489:
490:
491: case 'o':
492: switch(modifier) {
493: default:
494: ui_num = (u_wide_int) va_arg(ap, unsigned int);
495: break;
496: case LM_LONG_DOUBLE:
497: goto fmt_error;
498: case LM_LONG:
499: ui_num = (u_wide_int) va_arg(ap, unsigned long int);
500: break;
501: case LM_SIZE_T:
502: ui_num = (u_wide_int) va_arg(ap, size_t);
503: break;
504: #if SIZEOF_LONG_LONG
505: case LM_LONG_LONG:
506: ui_num = (u_wide_int) va_arg(ap, u_wide_int);
507: break;
508: #endif
509: #if SIZEOF_INTMAX_T
510: case LM_INTMAX_T:
511: ui_num = (u_wide_int) va_arg(ap, uintmax_t);
512: break;
513: #endif
514: #if SIZEOF_PTRDIFF_T
515: case LM_PTRDIFF_T:
516: ui_num = (u_wide_int) va_arg(ap, ptrdiff_t);
517: break;
518: #endif
519: }
520: s = ap_php_conv_p2(ui_num, 3, *fmt,
521: &num_buf[NUM_BUF_SIZE], &s_len);
522: FIX_PRECISION(adjust_precision, precision, s, s_len);
523: if (alternate_form && *s != '0') {
524: *--s = '0';
525: s_len++;
526: }
527: break;
528:
529:
530: case 'x':
531: case 'X':
532: switch(modifier) {
533: default:
534: ui_num = (u_wide_int) va_arg(ap, unsigned int);
535: break;
536: case LM_LONG_DOUBLE:
537: goto fmt_error;
538: case LM_LONG:
539: ui_num = (u_wide_int) va_arg(ap, unsigned long int);
540: break;
541: case LM_SIZE_T:
542: ui_num = (u_wide_int) va_arg(ap, size_t);
543: break;
544: #if SIZEOF_LONG_LONG
545: case LM_LONG_LONG:
546: ui_num = (u_wide_int) va_arg(ap, u_wide_int);
547: break;
548: #endif
549: #if SIZEOF_INTMAX_T
550: case LM_INTMAX_T:
551: ui_num = (u_wide_int) va_arg(ap, uintmax_t);
552: break;
553: #endif
554: #if SIZEOF_PTRDIFF_T
555: case LM_PTRDIFF_T:
556: ui_num = (u_wide_int) va_arg(ap, ptrdiff_t);
557: break;
558: #endif
559: }
560: s = ap_php_conv_p2(ui_num, 4, *fmt,
561: &num_buf[NUM_BUF_SIZE], &s_len);
562: FIX_PRECISION(adjust_precision, precision, s, s_len);
563: if (alternate_form && i_num != 0) {
564: *--s = *fmt; /* 'x' or 'X' */
565: *--s = '0';
566: s_len += 2;
567: }
568: break;
569:
570:
571: case 's':
572: case 'v':
573: s = va_arg(ap, char *);
574: if (s != NULL) {
575: if (!adjust_precision) {
576: s_len = strlen(s);
577: } else {
578: s_len = strnlen(s, precision);
579: }
580: } else {
581: s = S_NULL;
582: s_len = S_NULL_LEN;
583: }
584: pad_char = ' ';
585: break;
586:
587:
588: case 'f':
589: case 'F':
590: case 'e':
591: case 'E':
592: switch(modifier) {
593: case LM_LONG_DOUBLE:
594: fp_num = (double) va_arg(ap, long double);
595: break;
596: case LM_STD:
597: fp_num = va_arg(ap, double);
598: break;
599: default:
600: goto fmt_error;
601: }
602:
603: if (zend_isnan(fp_num)) {
604: s = "nan";
605: s_len = 3;
606: } else if (zend_isinf(fp_num)) {
607: s = "inf";
608: s_len = 3;
609: } else {
610: #ifdef HAVE_LOCALE_H
611: if (!lconv) {
612: lconv = localeconv();
613: }
614: #endif
615: s = php_conv_fp((*fmt == 'f')?'F':*fmt, fp_num, alternate_form,
616: (adjust_precision == NO) ? FLOAT_DIGITS : precision,
617: (*fmt == 'f')?LCONV_DECIMAL_POINT:'.',
618: &is_negative, &num_buf[1], &s_len);
619: if (is_negative)
620: prefix_char = '-';
621: else if (print_sign)
622: prefix_char = '+';
623: else if (print_blank)
624: prefix_char = ' ';
625: }
626: break;
627:
628:
629: case 'g':
630: case 'k':
631: case 'G':
632: case 'H':
633: switch(modifier) {
634: case LM_LONG_DOUBLE:
635: fp_num = (double) va_arg(ap, long double);
636: break;
637: case LM_STD:
638: fp_num = va_arg(ap, double);
639: break;
640: default:
641: goto fmt_error;
642: }
643:
644: if (zend_isnan(fp_num)) {
645: s = "NAN";
646: s_len = 3;
647: break;
648: } else if (zend_isinf(fp_num)) {
649: if (fp_num > 0) {
650: s = "INF";
651: s_len = 3;
652: } else {
653: s = "-INF";
654: s_len = 4;
655: }
656: break;
657: }
658:
659: if (adjust_precision == NO)
660: precision = FLOAT_DIGITS;
661: else if (precision == 0)
662: precision = 1;
663: /*
664: * * We use &num_buf[ 1 ], so that we have room for the sign
665: */
666: #ifdef HAVE_LOCALE_H
667: if (!lconv) {
668: lconv = localeconv();
669: }
670: #endif
671: s = php_gcvt(fp_num, precision, (*fmt=='H' || *fmt == 'k') ? '.' : LCONV_DECIMAL_POINT, (*fmt == 'G' || *fmt == 'H')?'E':'e', &num_buf[1]);
672: if (*s == '-')
673: prefix_char = *s++;
674: else if (print_sign)
675: prefix_char = '+';
676: else if (print_blank)
677: prefix_char = ' ';
678:
679: s_len = strlen(s);
680:
681: if (alternate_form && (strchr(s, '.')) == NULL)
682: s[s_len++] = '.';
683: break;
684:
685:
686: case 'c':
687: char_buf[0] = (char) (va_arg(ap, int));
688: s = &char_buf[0];
689: s_len = 1;
690: pad_char = ' ';
691: break;
692:
693:
694: case '%':
695: char_buf[0] = '%';
696: s = &char_buf[0];
697: s_len = 1;
698: pad_char = ' ';
699: break;
700:
701:
702: case 'n':
703: *(va_arg(ap, int *)) = xbuf->len;
704: goto skip_output;
705:
706: /*
707: * Always extract the argument as a "char *" pointer. We
708: * should be using "void *" but there are still machines
709: * that don't understand it.
710: * If the pointer size is equal to the size of an unsigned
711: * integer we convert the pointer to a hex number, otherwise
712: * we print "%p" to indicate that we don't handle "%p".
713: */
714: case 'p':
715: if (sizeof(char *) <= sizeof(u_wide_int)) {
716: ui_num = (u_wide_int)((size_t) va_arg(ap, char *));
717: s = ap_php_conv_p2(ui_num, 4, 'x',
718: &num_buf[NUM_BUF_SIZE], &s_len);
719: if (ui_num != 0) {
720: *--s = 'x';
721: *--s = '0';
722: s_len += 2;
723: }
724: } else {
725: s = "%p";
726: s_len = 2;
727: }
728: pad_char = ' ';
729: break;
730:
731:
732: case NUL:
733: /*
734: * The last character of the format string was %.
735: * We ignore it.
736: */
737: continue;
738:
739:
740: fmt_error:
741: php_error(E_ERROR, "Illegal length modifier specified '%c' in s[np]printf call", *fmt);
742: /*
743: * The default case is for unrecognized %'s.
744: * We print %<char> to help the user identify what
745: * option is not understood.
746: * This is also useful in case the user wants to pass
747: * the output of format_converter to another function
748: * that understands some other %<char> (like syslog).
749: * Note that we can't point s inside fmt because the
750: * unknown <char> could be preceded by width etc.
751: */
752: default:
753: char_buf[0] = '%';
754: char_buf[1] = *fmt;
755: s = char_buf;
756: s_len = 2;
757: pad_char = ' ';
758: break;
759: }
760:
761: if (prefix_char != NUL) {
762: *--s = prefix_char;
763: s_len++;
764: }
765: if (adjust_width && adjust == RIGHT && min_width > s_len) {
766: if (pad_char == '0' && prefix_char != NUL) {
767: INS_CHAR(xbuf, *s);
768: s++;
769: s_len--;
770: min_width--;
771: }
772: PAD(xbuf, min_width - s_len, pad_char);
773: }
774: /*
775: * Print the string s.
776: */
777: INS_STRING(xbuf, s, s_len);
778:
779: if (adjust_width && adjust == LEFT && min_width > s_len)
780: PAD(xbuf, min_width - s_len, pad_char);
781: if (free_zcopy) {
782: zval_dtor(&zcopy);
783: }
784: }
785: skip_output:
786: fmt++;
787: }
788: return;
789: }
790: /* }}} */
791:
792: /*
793: * This is the general purpose conversion function.
794: */
795: PHPAPI int vspprintf(char **pbuf, size_t max_len, const char *format, va_list ap) /* {{{ */
796: {
797: smart_str xbuf = {0};
798:
799: xbuf_format_converter(&xbuf, format, ap);
800:
801: if (max_len && xbuf.len > max_len) {
802: xbuf.len = max_len;
803: }
804: smart_str_0(&xbuf);
805:
806: *pbuf = xbuf.c;
807:
808: return xbuf.len;
809: }
810: /* }}} */
811:
812: PHPAPI int spprintf(char **pbuf, size_t max_len, const char *format, ...) /* {{{ */
813: {
814: int cc;
815: va_list ap;
816:
817: va_start(ap, format);
818: cc = vspprintf(pbuf, max_len, format, ap);
819: va_end(ap);
820: return (cc);
821: }
822: /* }}} */
823:
824: /*
825: * Local variables:
826: * tab-width: 4
827: * c-basic-offset: 4
828: * End:
829: * vim600: sw=4 ts=4 fdm=marker
830: * vim<600: sw=4 ts=4
831: */