![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to snprintf.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 snprintf.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: |
16: +----------------------------------------------------------------------+
17: */
18:
19: /* $Id: snprintf.c 321634 2012-01-01 13:15:04Z felipe $ */
20:
21:
22: #include "php.h"
23:
24: #include <zend_strtod.h>
25:
26: #include <stddef.h>
27: #include <stdio.h>
28: #include <ctype.h>
29: #include <sys/types.h>
30: #include <stdarg.h>
31: #include <string.h>
32: #include <stdlib.h>
33: #include <math.h>
34:
35: #ifdef HAVE_INTTYPES_H
36: #include <inttypes.h>
37: #endif
38:
39: #ifdef HAVE_LOCALE_H
40: #include <locale.h>
41: #define LCONV_DECIMAL_POINT (*lconv->decimal_point)
42: #else
43: #define LCONV_DECIMAL_POINT '.'
44: #endif
45:
46: /*
47: * Copyright (c) 2002, 2006 Todd C. Miller <Todd.Miller@courtesan.com>
48: *
49: * Permission to use, copy, modify, and distribute this software for any
50: * purpose with or without fee is hereby granted, provided that the above
51: * copyright notice and this permission notice appear in all copies.
52: *
53: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
54: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
55: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
56: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
57: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
58: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
59: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
60: *
61: * Sponsored in part by the Defense Advanced Research Projects
62: * Agency (DARPA) and Air Force Research Laboratory, Air Force
63: * Materiel Command, USAF, under agreement number F39502-99-1-0512.
64: */
65:
66: static char * __cvt(double value, int ndigit, int *decpt, int *sign, int fmode, int pad) /* {{{ */
67: {
68: register char *s = NULL;
69: char *p, *rve, c;
70: size_t siz;
71:
72: if (ndigit < 0) {
73: siz = -ndigit + 1;
74: } else {
75: siz = ndigit + 1;
76: }
77:
78: /* __dtoa() doesn't allocate space for 0 so we do it by hand */
79: if (value == 0.0) {
80: *decpt = 1 - fmode; /* 1 for 'e', 0 for 'f' */
81: *sign = 0;
82: if ((rve = s = (char *)malloc(ndigit?siz:2)) == NULL) {
83: return(NULL);
84: }
85: *rve++ = '0';
86: *rve = '\0';
87: if (!ndigit) {
88: return(s);
89: }
90: } else {
91: p = zend_dtoa(value, fmode + 2, ndigit, decpt, sign, &rve);
92: if (*decpt == 9999) {
93: /* Infinity or Nan, convert to inf or nan like printf */
94: *decpt = 0;
95: c = *p;
96: zend_freedtoa(p);
97: return(c == 'I' ? "INF" : "NAN");
98: }
99: /* Make a local copy and adjust rve to be in terms of s */
100: if (pad && fmode) {
101: siz += *decpt;
102: }
103: if ((s = (char *)malloc(siz+1)) == NULL) {
104: zend_freedtoa(p);
105: return(NULL);
106: }
107: (void) strlcpy(s, p, siz);
108: rve = s + (rve - p);
109: zend_freedtoa(p);
110: }
111:
112: /* Add trailing zeros */
113: if (pad) {
114: siz -= rve - s;
115: while (--siz) {
116: *rve++ = '0';
117: }
118: *rve = '\0';
119: }
120:
121: return(s);
122: }
123: /* }}} */
124:
125: static inline char *php_ecvt(double value, int ndigit, int *decpt, int *sign) /* {{{ */
126: {
127: return(__cvt(value, ndigit, decpt, sign, 0, 1));
128: }
129: /* }}} */
130:
131: static inline char *php_fcvt(double value, int ndigit, int *decpt, int *sign) /* {{{ */
132: {
133: return(__cvt(value, ndigit, decpt, sign, 1, 1));
134: }
135: /* }}} */
136:
137: PHPAPI char *php_gcvt(double value, int ndigit, char dec_point, char exponent, char *buf) /* {{{ */
138: {
139: char *digits, *dst, *src;
140: int i, decpt, sign;
141:
142: digits = zend_dtoa(value, 2, ndigit, &decpt, &sign, NULL);
143: if (decpt == 9999) {
144: /*
145: * Infinity or NaN, convert to inf or nan with sign.
146: * We assume the buffer is at least ndigit long.
147: */
148: snprintf(buf, ndigit + 1, "%s%s", (sign && *digits == 'I') ? "-" : "", *digits == 'I' ? "INF" : "NAN");
149: zend_freedtoa(digits);
150: return (buf);
151: }
152:
153: dst = buf;
154: if (sign) {
155: *dst++ = '-';
156: }
157:
158: if ((decpt >= 0 && decpt > ndigit) || decpt < -3) { /* use E-style */
159: /* exponential format (e.g. 1.2345e+13) */
160: if (--decpt < 0) {
161: sign = 1;
162: decpt = -decpt;
163: } else {
164: sign = 0;
165: }
166: src = digits;
167: *dst++ = *src++;
168: *dst++ = dec_point;
169: if (*src == '\0') {
170: *dst++ = '0';
171: } else {
172: do {
173: *dst++ = *src++;
174: } while (*src != '\0');
175: }
176: *dst++ = exponent;
177: if (sign) {
178: *dst++ = '-';
179: } else {
180: *dst++ = '+';
181: }
182: if (decpt < 10) {
183: *dst++ = '0' + decpt;
184: *dst = '\0';
185: } else {
186: /* XXX - optimize */
187: for (sign = decpt, i = 0; (sign /= 10) != 0; i++)
188: continue;
189: dst[i + 1] = '\0';
190: while (decpt != 0) {
191: dst[i--] = '0' + decpt % 10;
192: decpt /= 10;
193: }
194: }
195: } else if (decpt < 0) {
196: /* standard format 0. */
197: *dst++ = '0'; /* zero before decimal point */
198: *dst++ = dec_point;
199: do {
200: *dst++ = '0';
201: } while (++decpt < 0);
202: src = digits;
203: while (*src != '\0') {
204: *dst++ = *src++;
205: }
206: *dst = '\0';
207: } else {
208: /* standard format */
209: for (i = 0, src = digits; i < decpt; i++) {
210: if (*src != '\0') {
211: *dst++ = *src++;
212: } else {
213: *dst++ = '0';
214: }
215: }
216: if (*src != '\0') {
217: if (src == digits) {
218: *dst++ = '0'; /* zero before decimal point */
219: }
220: *dst++ = dec_point;
221: for (i = decpt; digits[i] != '\0'; i++) {
222: *dst++ = digits[i];
223: }
224: }
225: *dst = '\0';
226: }
227: zend_freedtoa(digits);
228: return (buf);
229: }
230: /* }}} */
231:
232: /* {{{ Apache license */
233: /* ====================================================================
234: * Copyright (c) 1995-1998 The Apache Group. All rights reserved.
235: *
236: * Redistribution and use in source and binary forms, with or without
237: * modification, are permitted provided that the following conditions
238: * are met:
239: *
240: * 1. Redistributions of source code must retain the above copyright
241: * notice, this list of conditions and the following disclaimer.
242: *
243: * 2. Redistributions in binary form must reproduce the above copyright
244: * notice, this list of conditions and the following disclaimer in
245: * the documentation and/or other materials provided with the
246: * distribution.
247: *
248: * 3. All advertising materials mentioning features or use of this
249: * software must display the following acknowledgment:
250: * "This product includes software developed by the Apache Group
251: * for use in the Apache HTTP server project (http://www.apache.org/)."
252: *
253: * 4. The names "Apache Server" and "Apache Group" must not be used to
254: * endorse or promote products derived from this software without
255: * prior written permission.
256: *
257: * 5. Redistributions of any form whatsoever must retain the following
258: * acknowledgment:
259: * "This product includes software developed by the Apache Group
260: * for use in the Apache HTTP server project (http://www.apache.org/)."
261: *
262: * THIS SOFTWARE IS PROVIDED BY THE APACHE GROUP ``AS IS'' AND ANY
263: * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
264: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
265: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE APACHE GROUP OR
266: * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
267: * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
268: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
269: * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
270: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
271: * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
272: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
273: * OF THE POSSIBILITY OF SUCH DAMAGE.
274: * ====================================================================
275: *
276: * This software consists of voluntary contributions made by many
277: * individuals on behalf of the Apache Group and was originally based
278: * on public domain software written at the National Center for
279: * Supercomputing Applications, University of Illinois, Urbana-Champaign.
280: * For more information on the Apache Group and the Apache HTTP server
281: * project, please see <http://www.apache.org/>.
282: *
283: * This code is based on, and used with the permission of, the
284: * SIO stdio-replacement strx_* functions by Panos Tsirigotis
285: * <panos@alumni.cs.colorado.edu> for xinetd.
286: */
287: /* }}} */
288:
289: #define FALSE 0
290: #define TRUE 1
291: #define NUL '\0'
292: #define INT_NULL ((int *)0)
293:
294: #define S_NULL "(null)"
295: #define S_NULL_LEN 6
296:
297: #define FLOAT_DIGITS 6
298: #define EXPONENT_LENGTH 10
299:
300:
301: /*
302: * Convert num to its decimal format.
303: * Return value:
304: * - a pointer to a string containing the number (no sign)
305: * - len contains the length of the string
306: * - is_negative is set to TRUE or FALSE depending on the sign
307: * of the number (always set to FALSE if is_unsigned is TRUE)
308: *
309: * The caller provides a buffer for the string: that is the buf_end argument
310: * which is a pointer to the END of the buffer + 1 (i.e. if the buffer
311: * is declared as buf[ 100 ], buf_end should be &buf[ 100 ])
312: */
313: /* char * ap_php_conv_10() {{{ */
314: char * ap_php_conv_10(register wide_int num, register bool_int is_unsigned,
315: register bool_int * is_negative, char *buf_end, register int *len)
316: {
317: register char *p = buf_end;
318: register u_wide_int magnitude;
319:
320: if (is_unsigned) {
321: magnitude = (u_wide_int) num;
322: *is_negative = FALSE;
323: } else {
324: *is_negative = (num < 0);
325:
326: /*
327: * On a 2's complement machine, negating the most negative integer
328: * results in a number that cannot be represented as a signed integer.
329: * Here is what we do to obtain the number's magnitude:
330: * a. add 1 to the number
331: * b. negate it (becomes positive)
332: * c. convert it to unsigned
333: * d. add 1
334: */
335: if (*is_negative) {
336: wide_int t = num + 1;
337: magnitude = ((u_wide_int) - t) + 1;
338: } else {
339: magnitude = (u_wide_int) num;
340: }
341: }
342:
343: /*
344: * We use a do-while loop so that we write at least 1 digit
345: */
346: do {
347: register u_wide_int new_magnitude = magnitude / 10;
348:
349: *--p = (char)(magnitude - new_magnitude * 10 + '0');
350: magnitude = new_magnitude;
351: }
352: while (magnitude);
353:
354: *len = buf_end - p;
355: return (p);
356: }
357: /* }}} */
358:
359: /* If you change this value then also change bug24640.phpt.
360: * Also NDIG must be reasonable smaller than NUM_BUF_SIZE.
361: */
362: #define NDIG 320
363:
364:
365: /*
366: * Convert a floating point number to a string formats 'f', 'e' or 'E'.
367: * The result is placed in buf, and len denotes the length of the string
368: * The sign is returned in the is_negative argument (and is not placed
369: * in buf).
370: */
371: /* PHPAPI char * php_conv_fp() {{{ */
372: PHPAPI char * php_conv_fp(register char format, register double num,
373: boolean_e add_dp, int precision, char dec_point, bool_int * is_negative, char *buf, int *len)
374: {
375: register char *s = buf;
376: register char *p, *p_orig;
377: int decimal_point;
378:
379: if (precision >= NDIG - 1) {
380: precision = NDIG - 2;
381: }
382:
383: if (format == 'F') {
384: p_orig = p = php_fcvt(num, precision, &decimal_point, is_negative);
385: } else { /* either e or E format */
386: p_orig = p = php_ecvt(num, precision + 1, &decimal_point, is_negative);
387: }
388:
389: /*
390: * Check for Infinity and NaN
391: */
392: if (isalpha((int)*p)) {
393: *len = strlen(p);
394: memcpy(buf, p, *len + 1);
395: *is_negative = FALSE;
396: free(p_orig);
397: return (buf);
398: }
399: if (format == 'F') {
400: if (decimal_point <= 0) {
401: if (num != 0 || precision > 0) {
402: *s++ = '0';
403: if (precision > 0) {
404: *s++ = dec_point;
405: while (decimal_point++ < 0) {
406: *s++ = '0';
407: }
408: } else if (add_dp) {
409: *s++ = dec_point;
410: }
411: }
412: } else {
413: int addz = decimal_point >= NDIG ? decimal_point - NDIG + 1 : 0;
414: decimal_point -= addz;
415: while (decimal_point-- > 0) {
416: *s++ = *p++;
417: }
418: while (addz-- > 0) {
419: *s++ = '0';
420: }
421: if (precision > 0 || add_dp) {
422: *s++ = dec_point;
423: }
424: }
425: } else {
426: *s++ = *p++;
427: if (precision > 0 || add_dp) {
428: *s++ = '.';
429: }
430: }
431:
432: /*
433: * copy the rest of p, the NUL is NOT copied
434: */
435: while (*p) {
436: *s++ = *p++;
437: }
438:
439: if (format != 'F') {
440: char temp[EXPONENT_LENGTH]; /* for exponent conversion */
441: int t_len;
442: bool_int exponent_is_negative;
443:
444: *s++ = format; /* either e or E */
445: decimal_point--;
446: if (decimal_point != 0) {
447: p = ap_php_conv_10((wide_int) decimal_point, FALSE, &exponent_is_negative, &temp[EXPONENT_LENGTH], &t_len);
448: *s++ = exponent_is_negative ? '-' : '+';
449:
450: /*
451: * Make sure the exponent has at least 2 digits
452: */
453: while (t_len--) {
454: *s++ = *p++;
455: }
456: } else {
457: *s++ = '+';
458: *s++ = '0';
459: }
460: }
461: *len = s - buf;
462: free(p_orig);
463: return (buf);
464: }
465: /* }}} */
466:
467: /*
468: * Convert num to a base X number where X is a power of 2. nbits determines X.
469: * For example, if nbits is 3, we do base 8 conversion
470: * Return value:
471: * a pointer to a string containing the number
472: *
473: * The caller provides a buffer for the string: that is the buf_end argument
474: * which is a pointer to the END of the buffer + 1 (i.e. if the buffer
475: * is declared as buf[ 100 ], buf_end should be &buf[ 100 ])
476: */
477: char * ap_php_conv_p2(register u_wide_int num, register int nbits, char format, char *buf_end, register int *len) /* {{{ */
478: {
479: register int mask = (1 << nbits) - 1;
480: register char *p = buf_end;
481: static char low_digits[] = "0123456789abcdef";
482: static char upper_digits[] = "0123456789ABCDEF";
483: register char *digits = (format == 'X') ? upper_digits : low_digits;
484:
485: do {
486: *--p = digits[num & mask];
487: num >>= nbits;
488: }
489: while (num);
490:
491: *len = buf_end - p;
492: return (p);
493: }
494: /* }}} */
495:
496: /*
497: * NUM_BUF_SIZE is the size of the buffer used for arithmetic conversions
498: *
499: * XXX: this is a magic number; do not decrease it
500: * Emax = 1023
501: * NDIG = 320
502: * NUM_BUF_SIZE >= strlen("-") + Emax + strlrn(".") + NDIG + strlen("E+1023") + 1;
503: */
504: #define NUM_BUF_SIZE 2048
505:
506:
507: /*
508: * Descriptor for buffer area
509: */
510: struct buf_area {
511: char *buf_end;
512: char *nextb; /* pointer to next byte to read/write */
513: };
514:
515: typedef struct buf_area buffy;
516:
517: /*
518: * The INS_CHAR macro inserts a character in the buffer and writes
519: * the buffer back to disk if necessary
520: * It uses the char pointers sp and bep:
521: * sp points to the next available character in the buffer
522: * bep points to the end-of-buffer+1
523: * While using this macro, note that the nextb pointer is NOT updated.
524: *
525: * NOTE: Evaluation of the c argument should not have any side-effects
526: */
527: #define INS_CHAR(c, sp, bep, cc) \
528: { \
529: if (sp < bep) \
530: { \
531: *sp++ = c; \
532: } \
533: cc++; \
534: }
535:
536: #define NUM( c ) ( c - '0' )
537:
538: #define STR_TO_DEC( str, num ) \
539: num = NUM( *str++ ) ; \
540: while ( isdigit((int)*str ) ) \
541: { \
542: num *= 10 ; \
543: num += NUM( *str++ ) ; \
544: }
545:
546: /*
547: * This macro does zero padding so that the precision
548: * requirement is satisfied. The padding is done by
549: * adding '0's to the left of the string that is going
550: * to be printed.
551: */
552: #define FIX_PRECISION( adjust, precision, s, s_len ) \
553: if ( adjust ) \
554: while ( s_len < precision ) \
555: { \
556: *--s = '0' ; \
557: s_len++ ; \
558: }
559:
560: /*
561: * Macro that does padding. The padding is done by printing
562: * the character ch.
563: */
564: #define PAD( width, len, ch ) do \
565: { \
566: INS_CHAR( ch, sp, bep, cc ) ; \
567: width-- ; \
568: } \
569: while ( width > len )
570:
571: /*
572: * Prefix the character ch to the string str
573: * Increase length
574: * Set the has_prefix flag
575: */
576: #define PREFIX( str, length, ch ) *--str = ch ; length++ ; has_prefix = YES
577:
578:
579: /*
580: * Do format conversion placing the output in buffer
581: */
582: static int format_converter(register buffy * odp, const char *fmt, va_list ap) /* {{{ */
583: {
584: char *sp;
585: char *bep;
586: int cc = 0;
587: int i;
588:
589: char *s = NULL;
590: int s_len, free_zcopy;
591: zval *zvp, zcopy;
592:
593: int min_width = 0;
594: int precision = 0;
595: enum {
596: LEFT, RIGHT
597: } adjust;
598: char pad_char;
599: char prefix_char;
600:
601: double fp_num;
602: wide_int i_num = (wide_int) 0;
603: u_wide_int ui_num;
604:
605: char num_buf[NUM_BUF_SIZE];
606: char char_buf[2]; /* for printing %% and %<unknown> */
607:
608: #ifdef HAVE_LOCALE_H
609: struct lconv *lconv = NULL;
610: #endif
611:
612: /*
613: * Flag variables
614: */
615: length_modifier_e modifier;
616: boolean_e alternate_form;
617: boolean_e print_sign;
618: boolean_e print_blank;
619: boolean_e adjust_precision;
620: boolean_e adjust_width;
621: bool_int is_negative;
622:
623: sp = odp->nextb;
624: bep = odp->buf_end;
625:
626: while (*fmt) {
627: if (*fmt != '%') {
628: INS_CHAR(*fmt, sp, bep, cc);
629: } else {
630: /*
631: * Default variable settings
632: */
633: adjust = RIGHT;
634: alternate_form = print_sign = print_blank = NO;
635: pad_char = ' ';
636: prefix_char = NUL;
637: free_zcopy = 0;
638:
639: fmt++;
640:
641: /*
642: * Try to avoid checking for flags, width or precision
643: */
644: if (isascii((int)*fmt) && !islower((int)*fmt)) {
645: /*
646: * Recognize flags: -, #, BLANK, +
647: */
648: for (;; fmt++) {
649: if (*fmt == '-')
650: adjust = LEFT;
651: else if (*fmt == '+')
652: print_sign = YES;
653: else if (*fmt == '#')
654: alternate_form = YES;
655: else if (*fmt == ' ')
656: print_blank = YES;
657: else if (*fmt == '0')
658: pad_char = '0';
659: else
660: break;
661: }
662:
663: /*
664: * Check if a width was specified
665: */
666: if (isdigit((int)*fmt)) {
667: STR_TO_DEC(fmt, min_width);
668: adjust_width = YES;
669: } else if (*fmt == '*') {
670: min_width = va_arg(ap, int);
671: fmt++;
672: adjust_width = YES;
673: if (min_width < 0) {
674: adjust = LEFT;
675: min_width = -min_width;
676: }
677: } else
678: adjust_width = NO;
679:
680: /*
681: * Check if a precision was specified
682: */
683: if (*fmt == '.') {
684: adjust_precision = YES;
685: fmt++;
686: if (isdigit((int)*fmt)) {
687: STR_TO_DEC(fmt, precision);
688: } else if (*fmt == '*') {
689: precision = va_arg(ap, int);
690: fmt++;
691: if (precision < 0)
692: precision = 0;
693: } else
694: precision = 0;
695:
696: if (precision > FORMAT_CONV_MAX_PRECISION) {
697: precision = FORMAT_CONV_MAX_PRECISION;
698: }
699: } else
700: adjust_precision = NO;
701: } else
702: adjust_precision = adjust_width = NO;
703:
704: /*
705: * Modifier check
706: */
707: switch (*fmt) {
708: case 'L':
709: fmt++;
710: modifier = LM_LONG_DOUBLE;
711: break;
712: case 'I':
713: fmt++;
714: #if SIZEOF_LONG_LONG
715: if (*fmt == '6' && *(fmt+1) == '4') {
716: fmt += 2;
717: modifier = LM_LONG_LONG;
718: } else
719: #endif
720: if (*fmt == '3' && *(fmt+1) == '2') {
721: fmt += 2;
722: modifier = LM_LONG;
723: } else {
724: #ifdef _WIN64
725: modifier = LM_LONG_LONG;
726: #else
727: modifier = LM_LONG;
728: #endif
729: }
730: break;
731: case 'l':
732: fmt++;
733: #if SIZEOF_LONG_LONG
734: if (*fmt == 'l') {
735: fmt++;
736: modifier = LM_LONG_LONG;
737: } else
738: #endif
739: modifier = LM_LONG;
740: break;
741: case 'z':
742: fmt++;
743: modifier = LM_SIZE_T;
744: break;
745: case 'j':
746: fmt++;
747: #if SIZEOF_INTMAX_T
748: modifier = LM_INTMAX_T;
749: #else
750: modifier = LM_SIZE_T;
751: #endif
752: break;
753: case 't':
754: fmt++;
755: #if SIZEOF_PTRDIFF_T
756: modifier = LM_PTRDIFF_T;
757: #else
758: modifier = LM_SIZE_T;
759: #endif
760: break;
761: case 'h':
762: fmt++;
763: if (*fmt == 'h') {
764: fmt++;
765: }
766: /* these are promoted to int, so no break */
767: default:
768: modifier = LM_STD;
769: break;
770: }
771:
772: /*
773: * Argument extraction and printing.
774: * First we determine the argument type.
775: * Then, we convert the argument to a string.
776: * On exit from the switch, s points to the string that
777: * must be printed, s_len has the length of the string
778: * The precision requirements, if any, are reflected in s_len.
779: *
780: * NOTE: pad_char may be set to '0' because of the 0 flag.
781: * It is reset to ' ' by non-numeric formats
782: */
783: switch (*fmt) {
784: case 'Z':
785: #if SUHOSIN_PATCH
786: zend_suhosin_log(S_MISC, "'Z' specifier within format string");
787: goto skip_output;
788: #else
789: zvp = (zval*) va_arg(ap, zval*);
790: zend_make_printable_zval(zvp, &zcopy, &free_zcopy);
791: if (free_zcopy) {
792: zvp = &zcopy;
793: }
794: s_len = Z_STRLEN_P(zvp);
795: s = Z_STRVAL_P(zvp);
796: if (adjust_precision && precision < s_len) {
797: s_len = precision;
798: }
799: #endif
800: break;
801: case 'u':
802: switch(modifier) {
803: default:
804: i_num = (wide_int) va_arg(ap, unsigned int);
805: break;
806: case LM_LONG_DOUBLE:
807: goto fmt_error;
808: case LM_LONG:
809: i_num = (wide_int) va_arg(ap, unsigned long int);
810: break;
811: case LM_SIZE_T:
812: i_num = (wide_int) va_arg(ap, size_t);
813: break;
814: #if SIZEOF_LONG_LONG
815: case LM_LONG_LONG:
816: i_num = (wide_int) va_arg(ap, u_wide_int);
817: break;
818: #endif
819: #if SIZEOF_INTMAX_T
820: case LM_INTMAX_T:
821: i_num = (wide_int) va_arg(ap, uintmax_t);
822: break;
823: #endif
824: #if SIZEOF_PTRDIFF_T
825: case LM_PTRDIFF_T:
826: i_num = (wide_int) va_arg(ap, ptrdiff_t);
827: break;
828: #endif
829: }
830: /*
831: * The rest also applies to other integer formats, so fall
832: * into that case.
833: */
834: case 'd':
835: case 'i':
836: /*
837: * Get the arg if we haven't already.
838: */
839: if ((*fmt) != 'u') {
840: switch(modifier) {
841: default:
842: i_num = (wide_int) va_arg(ap, int);
843: break;
844: case LM_LONG_DOUBLE:
845: goto fmt_error;
846: case LM_LONG:
847: i_num = (wide_int) va_arg(ap, long int);
848: break;
849: case LM_SIZE_T:
850: #if SIZEOF_SSIZE_T
851: i_num = (wide_int) va_arg(ap, ssize_t);
852: #else
853: i_num = (wide_int) va_arg(ap, size_t);
854: #endif
855: break;
856: #if SIZEOF_LONG_LONG
857: case LM_LONG_LONG:
858: i_num = (wide_int) va_arg(ap, wide_int);
859: break;
860: #endif
861: #if SIZEOF_INTMAX_T
862: case LM_INTMAX_T:
863: i_num = (wide_int) va_arg(ap, intmax_t);
864: break;
865: #endif
866: #if SIZEOF_PTRDIFF_T
867: case LM_PTRDIFF_T:
868: i_num = (wide_int) va_arg(ap, ptrdiff_t);
869: break;
870: #endif
871: }
872: }
873: s = ap_php_conv_10(i_num, (*fmt) == 'u', &is_negative,
874: &num_buf[NUM_BUF_SIZE], &s_len);
875: FIX_PRECISION(adjust_precision, precision, s, s_len);
876:
877: if (*fmt != 'u') {
878: if (is_negative) {
879: prefix_char = '-';
880: } else if (print_sign) {
881: prefix_char = '+';
882: } else if (print_blank) {
883: prefix_char = ' ';
884: }
885: }
886: break;
887:
888:
889: case 'o':
890: switch(modifier) {
891: default:
892: ui_num = (u_wide_int) va_arg(ap, unsigned int);
893: break;
894: case LM_LONG_DOUBLE:
895: goto fmt_error;
896: case LM_LONG:
897: ui_num = (u_wide_int) va_arg(ap, unsigned long int);
898: break;
899: case LM_SIZE_T:
900: ui_num = (u_wide_int) va_arg(ap, size_t);
901: break;
902: #if SIZEOF_LONG_LONG
903: case LM_LONG_LONG:
904: ui_num = (u_wide_int) va_arg(ap, u_wide_int);
905: break;
906: #endif
907: #if SIZEOF_INTMAX_T
908: case LM_INTMAX_T:
909: ui_num = (u_wide_int) va_arg(ap, uintmax_t);
910: break;
911: #endif
912: #if SIZEOF_PTRDIFF_T
913: case LM_PTRDIFF_T:
914: ui_num = (u_wide_int) va_arg(ap, ptrdiff_t);
915: break;
916: #endif
917: }
918: s = ap_php_conv_p2(ui_num, 3, *fmt, &num_buf[NUM_BUF_SIZE], &s_len);
919: FIX_PRECISION(adjust_precision, precision, s, s_len);
920: if (alternate_form && *s != '0') {
921: *--s = '0';
922: s_len++;
923: }
924: break;
925:
926:
927: case 'x':
928: case 'X':
929: switch(modifier) {
930: default:
931: ui_num = (u_wide_int) va_arg(ap, unsigned int);
932: break;
933: case LM_LONG_DOUBLE:
934: goto fmt_error;
935: case LM_LONG:
936: ui_num = (u_wide_int) va_arg(ap, unsigned long int);
937: break;
938: case LM_SIZE_T:
939: ui_num = (u_wide_int) va_arg(ap, size_t);
940: break;
941: #if SIZEOF_LONG_LONG
942: case LM_LONG_LONG:
943: ui_num = (u_wide_int) va_arg(ap, u_wide_int);
944: break;
945: #endif
946: #if SIZEOF_INTMAX_T
947: case LM_INTMAX_T:
948: ui_num = (u_wide_int) va_arg(ap, uintmax_t);
949: break;
950: #endif
951: #if SIZEOF_PTRDIFF_T
952: case LM_PTRDIFF_T:
953: ui_num = (u_wide_int) va_arg(ap, ptrdiff_t);
954: break;
955: #endif
956: }
957: s = ap_php_conv_p2(ui_num, 4, *fmt, &num_buf[NUM_BUF_SIZE], &s_len);
958: FIX_PRECISION(adjust_precision, precision, s, s_len);
959: if (alternate_form && i_num != 0) {
960: *--s = *fmt; /* 'x' or 'X' */
961: *--s = '0';
962: s_len += 2;
963: }
964: break;
965:
966:
967: case 's':
968: case 'v':
969: s = va_arg(ap, char *);
970: if (s != NULL) {
971: s_len = strlen(s);
972: if (adjust_precision && precision < s_len) {
973: s_len = precision;
974: }
975: } else {
976: s = S_NULL;
977: s_len = S_NULL_LEN;
978: }
979: pad_char = ' ';
980: break;
981:
982:
983: case 'f':
984: case 'F':
985: case 'e':
986: case 'E':
987: switch(modifier) {
988: case LM_LONG_DOUBLE:
989: fp_num = (double) va_arg(ap, long double);
990: break;
991: case LM_STD:
992: fp_num = va_arg(ap, double);
993: break;
994: default:
995: goto fmt_error;
996: }
997:
998: if (zend_isnan(fp_num)) {
999: s = "NAN";
1000: s_len = 3;
1001: } else if (zend_isinf(fp_num)) {
1002: s = "INF";
1003: s_len = 3;
1004: } else {
1005: #ifdef HAVE_LOCALE_H
1006: if (!lconv) {
1007: lconv = localeconv();
1008: }
1009: #endif
1010: s = php_conv_fp((*fmt == 'f')?'F':*fmt, fp_num, alternate_form,
1011: (adjust_precision == NO) ? FLOAT_DIGITS : precision,
1012: (*fmt == 'f')?LCONV_DECIMAL_POINT:'.',
1013: &is_negative, &num_buf[1], &s_len);
1014: if (is_negative)
1015: prefix_char = '-';
1016: else if (print_sign)
1017: prefix_char = '+';
1018: else if (print_blank)
1019: prefix_char = ' ';
1020: }
1021: break;
1022:
1023:
1024: case 'g':
1025: case 'k':
1026: case 'G':
1027: case 'H':
1028: switch(modifier) {
1029: case LM_LONG_DOUBLE:
1030: fp_num = (double) va_arg(ap, long double);
1031: break;
1032: case LM_STD:
1033: fp_num = va_arg(ap, double);
1034: break;
1035: default:
1036: goto fmt_error;
1037: }
1038:
1039: if (zend_isnan(fp_num)) {
1040: s = "NAN";
1041: s_len = 3;
1042: break;
1043: } else if (zend_isinf(fp_num)) {
1044: if (fp_num > 0) {
1045: s = "INF";
1046: s_len = 3;
1047: } else {
1048: s = "-INF";
1049: s_len = 4;
1050: }
1051: break;
1052: }
1053:
1054: if (adjust_precision == NO) {
1055: precision = FLOAT_DIGITS;
1056: } else if (precision == 0) {
1057: precision = 1;
1058: }
1059: /*
1060: * * We use &num_buf[ 1 ], so that we have room for the sign
1061: */
1062: #ifdef HAVE_LOCALE_H
1063: if (!lconv) {
1064: lconv = localeconv();
1065: }
1066: #endif
1067: s = php_gcvt(fp_num, precision, (*fmt=='H' || *fmt == 'k') ? '.' : LCONV_DECIMAL_POINT, (*fmt == 'G' || *fmt == 'H')?'E':'e', &num_buf[1]);
1068: if (*s == '-') {
1069: prefix_char = *s++;
1070: } else if (print_sign) {
1071: prefix_char = '+';
1072: } else if (print_blank) {
1073: prefix_char = ' ';
1074: }
1075:
1076: s_len = strlen(s);
1077:
1078: if (alternate_form && (strchr(s, '.')) == NULL) {
1079: s[s_len++] = '.';
1080: }
1081: break;
1082:
1083:
1084: case 'c':
1085: char_buf[0] = (char) (va_arg(ap, int));
1086: s = &char_buf[0];
1087: s_len = 1;
1088: pad_char = ' ';
1089: break;
1090:
1091:
1092: case '%':
1093: char_buf[0] = '%';
1094: s = &char_buf[0];
1095: s_len = 1;
1096: pad_char = ' ';
1097: break;
1098:
1099:
1100: case 'n':
1101: #if SUHOSIN_PATCH
1102: zend_suhosin_log(S_MISC, "'n' specifier within format string");
1103: #else
1104: *(va_arg(ap, int *)) = cc;
1105: #endif
1106: goto skip_output;
1107:
1108: /*
1109: * Always extract the argument as a "char *" pointer. We
1110: * should be using "void *" but there are still machines
1111: * that don't understand it.
1112: * If the pointer size is equal to the size of an unsigned
1113: * integer we convert the pointer to a hex number, otherwise
1114: * we print "%p" to indicate that we don't handle "%p".
1115: */
1116: case 'p':
1117: if (sizeof(char *) <= sizeof(u_wide_int)) {
1118: ui_num = (u_wide_int)((size_t) va_arg(ap, char *));
1119: s = ap_php_conv_p2(ui_num, 4, 'x',
1120: &num_buf[NUM_BUF_SIZE], &s_len);
1121: if (ui_num != 0) {
1122: *--s = 'x';
1123: *--s = '0';
1124: s_len += 2;
1125: }
1126: } else {
1127: s = "%p";
1128: s_len = 2;
1129: }
1130: pad_char = ' ';
1131: break;
1132:
1133:
1134: case NUL:
1135: /*
1136: * The last character of the format string was %.
1137: * We ignore it.
1138: */
1139: continue;
1140:
1141:
1142: fmt_error:
1143: php_error(E_ERROR, "Illegal length modifier specified '%c' in s[np]printf call", *fmt);
1144: /*
1145: * The default case is for unrecognized %'s.
1146: * We print %<char> to help the user identify what
1147: * option is not understood.
1148: * This is also useful in case the user wants to pass
1149: * the output of format_converter to another function
1150: * that understands some other %<char> (like syslog).
1151: * Note that we can't point s inside fmt because the
1152: * unknown <char> could be preceded by width etc.
1153: */
1154: default:
1155: char_buf[0] = '%';
1156: char_buf[1] = *fmt;
1157: s = char_buf;
1158: s_len = 2;
1159: pad_char = ' ';
1160: break;
1161: }
1162:
1163: if (prefix_char != NUL) {
1164: *--s = prefix_char;
1165: s_len++;
1166: }
1167: if (adjust_width && adjust == RIGHT && min_width > s_len) {
1168: if (pad_char == '0' && prefix_char != NUL) {
1169: INS_CHAR(*s, sp, bep, cc)
1170: s++;
1171: s_len--;
1172: min_width--;
1173: }
1174: PAD(min_width, s_len, pad_char);
1175: }
1176: /*
1177: * Print the string s.
1178: */
1179: for (i = s_len; i != 0; i--) {
1180: INS_CHAR(*s, sp, bep, cc);
1181: s++;
1182: }
1183:
1184: if (adjust_width && adjust == LEFT && min_width > s_len)
1185: PAD(min_width, s_len, pad_char);
1186: if (free_zcopy) {
1187: zval_dtor(&zcopy);
1188: }
1189: }
1190: skip_output:
1191: fmt++;
1192: }
1193: odp->nextb = sp;
1194: return (cc);
1195: }
1196: /* }}} */
1197:
1198: /*
1199: * This is the general purpose conversion function.
1200: */
1201: static void strx_printv(int *ccp, char *buf, size_t len, const char *format, va_list ap) /* {{{ */
1202: {
1203: buffy od;
1204: int cc;
1205:
1206: /*
1207: * First initialize the descriptor
1208: * Notice that if no length is given, we initialize buf_end to the
1209: * highest possible address.
1210: */
1211: if (len == 0) {
1212: od.buf_end = (char *) ~0;
1213: od.nextb = (char *) ~0;
1214: } else {
1215: od.buf_end = &buf[len-1];
1216: od.nextb = buf;
1217: }
1218:
1219: /*
1220: * Do the conversion
1221: */
1222: cc = format_converter(&od, format, ap);
1223: if (len != 0 && od.nextb <= od.buf_end) {
1224: *(od.nextb) = '\0';
1225: }
1226: if (ccp) {
1227: *ccp = cc;
1228: }
1229: }
1230: /* }}} */
1231:
1232: PHPAPI int ap_php_slprintf(char *buf, size_t len, const char *format,...) /* {{{ */
1233: {
1234: int cc;
1235: va_list ap;
1236:
1237: va_start(ap, format);
1238: strx_printv(&cc, buf, len, format, ap);
1239: va_end(ap);
1240: if (cc >= len) {
1241: cc = len -1;
1242: buf[cc] = '\0';
1243: }
1244: return cc;
1245: }
1246: /* }}} */
1247:
1248: PHPAPI int ap_php_vslprintf(char *buf, size_t len, const char *format, va_list ap) /* {{{ */
1249: {
1250: int cc;
1251:
1252: strx_printv(&cc, buf, len, format, ap);
1253: if (cc >= len) {
1254: cc = len -1;
1255: buf[cc] = '\0';
1256: }
1257: return cc;
1258: }
1259: /* }}} */
1260:
1261: PHPAPI int ap_php_snprintf(char *buf, size_t len, const char *format,...) /* {{{ */
1262: {
1263: int cc;
1264: va_list ap;
1265:
1266: va_start(ap, format);
1267: strx_printv(&cc, buf, len, format, ap);
1268: va_end(ap);
1269: return (cc);
1270: }
1271: /* }}} */
1272:
1273: PHPAPI int ap_php_vsnprintf(char *buf, size_t len, const char *format, va_list ap) /* {{{ */
1274: {
1275: int cc;
1276:
1277: strx_printv(&cc, buf, len, format, ap);
1278: return (cc);
1279: }
1280: /* }}} */
1281:
1282: PHPAPI int ap_php_vasprintf(char **buf, const char *format, va_list ap) /* {{{ */
1283: {
1284: va_list ap2;
1285: int cc;
1286:
1287: va_copy(ap2, ap);
1288: cc = ap_php_vsnprintf(NULL, 0, format, ap2);
1289: va_end(ap2);
1290:
1291: *buf = NULL;
1292:
1293: if (cc >= 0) {
1294: if ((*buf = malloc(++cc)) != NULL) {
1295: if ((cc = ap_php_vsnprintf(*buf, cc, format, ap)) < 0) {
1296: free(*buf);
1297: *buf = NULL;
1298: }
1299: }
1300: }
1301:
1302: return cc;
1303: }
1304: /* }}} */
1305:
1306: PHPAPI int ap_php_asprintf(char **buf, const char *format, ...) /* {{{ */
1307: {
1308: int cc;
1309: va_list ap;
1310:
1311: va_start(ap, format);
1312: cc = vasprintf(buf, format, ap);
1313: va_end(ap);
1314: return cc;
1315: }
1316: /* }}} */
1317:
1318: /*
1319: * Local variables:
1320: * tab-width: 4
1321: * c-basic-offset: 4
1322: * End:
1323: * vim600: sw=4 ts=4 fdm=marker
1324: * vim<600: sw=4 ts=4
1325: */