--- /dev/null
+/*
+ +----------------------------------------------------------------------+
+ | PHP Version 5 |
+ +----------------------------------------------------------------------+
+ | Copyright (c) 1997-2014 The PHP Group |
+ +----------------------------------------------------------------------+
+ | This source file is subject to version 3.01 of the PHP license, |
+ | that is bundled with this package in the file LICENSE, and is |
+ | available through the world-wide-web at the following url: |
+ | http://www.php.net/license/3_01.txt |
+ | If you did not receive a copy of the PHP license and are unable to |
+ | obtain it through the world-wide-web, please send a note to |
+ | license@php.net so we can mail you a copy immediately. |
+ +----------------------------------------------------------------------+
+ | Author: Sascha Schumann <sascha@schumann.cx> |
+ | Xinchen Hui <laruence@php.net> |
+ +----------------------------------------------------------------------+
+ */
+
+/* $Id$ */
+
+#ifndef PHP_SMART_STRING_H
+#define PHP_SMART_STRING_H
+
+#include "php_smart_string_public.h"
+
+#include <stdlib.h>
+#ifndef SMART_STR_USE_REALLOC
+#include <zend.h>
+#endif
+
+#define smart_string_0(x) do { \
+ if ((x)->c) { \
+ (x)->c[(x)->len] = '\0'; \
+ } \
+} while (0)
+
+#ifndef SMART_STRING_PREALLOC
+#define SMART_STRING_PREALLOC 128
+#endif
+
+#ifndef SMART_STRING_START_SIZE
+#define SMART_STRING_START_SIZE 78
+#endif
+
+#ifdef SMART_STRING_USE_REALLOC
+#define SMART_STRING_REALLOC(a,b,c) realloc((a),(b))
+#else
+#define SMART_STRING_REALLOC(a,b,c) perealloc((a),(b),(c))
+#endif
+
+#define SMART_STRING_DO_REALLOC(d, what) \
+ (d)->c = SMART_STRING_REALLOC((d)->c, (d)->a + 1, (what))
+
+#define smart_string_alloc4(d, n, what, newlen) do { \
+ if (!(d)->c) { \
+ (d)->len = 0; \
+ newlen = (n); \
+ (d)->a = newlen < SMART_STRING_START_SIZE \
+ ? SMART_STRING_START_SIZE \
+ : newlen + SMART_STRING_PREALLOC; \
+ SMART_STRING_DO_REALLOC(d, what); \
+ } else { \
+ newlen = (d)->len + (n); \
+ if (newlen >= (d)->a) { \
+ (d)->a = newlen + SMART_STRING_PREALLOC; \
+ SMART_STRING_DO_REALLOC(d, what); \
+ } \
+ } \
+} while (0)
+
+#define smart_string_alloc(d, n, what) \
+ smart_string_alloc4((d), (n), (what), newlen)
+
+/* wrapper */
+
+#define smart_string_appends_ex(dest, src, what) \
+ smart_string_appendl_ex((dest), (src), strlen(src), (what))
+#define smart_string_appends(dest, src) \
+ smart_string_appendl((dest), (src), strlen(src))
+
+#define smart_string_appendc(dest, c) \
+ smart_string_appendc_ex((dest), (c), 0)
+#define smart_string_free(s) \
+ smart_string_free_ex((s), 0)
+#define smart_string_appendl(dest, src, len) \
+ smart_string_appendl_ex((dest), (src), (len), 0)
+#define smart_string_append(dest, src) \
+ smart_string_append_ex((dest), (src), 0)
+#define smart_string_append_long(dest, val) \
+ smart_string_append_long_ex((dest), (val), 0)
+#define smart_string_append_off_t(dest, val) \
+ smart_string_append_off_t_ex((dest), (val), 0)
+#define smart_string_append_unsigned(dest, val) \
+ smart_string_append_unsigned_ex((dest), (val), 0)
+
+#define smart_string_appendc_ex(dest, ch, what) do { \
+ register size_t __nl; \
+ smart_string_alloc4((dest), 1, (what), __nl); \
+ (dest)->len = __nl; \
+ ((unsigned char *) (dest)->c)[(dest)->len - 1] = (ch); \
+} while (0)
+
+#define smart_string_free_ex(s, what) do { \
+ smart_string *__s = (smart_string *) (s); \
+ if (__s->c) { \
+ pefree(__s->c, what); \
+ __s->c = NULL; \
+ } \
+ __s->a = __s->len = 0; \
+} while (0)
+
+#define smart_string_appendl_ex(dest, src, nlen, what) do { \
+ register size_t __nl; \
+ smart_string *__dest = (smart_string *) (dest); \
+ \
+ smart_string_alloc4(__dest, (nlen), (what), __nl); \
+ memcpy(__dest->c + __dest->len, (src), (nlen)); \
+ __dest->len = __nl; \
+} while (0)
+
+/* input: buf points to the END of the buffer */
+#define smart_string_print_unsigned4(buf, num, vartype, result) do { \
+ char *__p = (buf); \
+ vartype __num = (num); \
+ *__p = '\0'; \
+ do { \
+ *--__p = (char) (__num % 10) + '0'; \
+ __num /= 10; \
+ } while (__num > 0); \
+ result = __p; \
+} while (0)
+
+/* buf points to the END of the buffer */
+#define smart_string_print_long4(buf, num, vartype, result) do { \
+ if (num < 0) { \
+ /* this might cause problems when dealing with LONG_MIN \
+ and machines which don't support long long. Works \
+ flawlessly on 32bit x86 */ \
+ smart_string_print_unsigned4((buf), -(num), vartype, (result)); \
+ *--(result) = '-'; \
+ } else { \
+ smart_string_print_unsigned4((buf), (num), vartype, (result)); \
+ } \
+} while (0)
+
+/*
+ * these could be replaced using a braced-group inside an expression
+ * for GCC compatible compilers, e.g.
+ *
+ * #define f(..) ({char *r;..;__r;})
+ */
+
+static inline char *smart_string_print_long(char *buf, long num) {
+ char *r;
+ smart_string_print_long4(buf, num, unsigned long, r);
+ return r;
+}
+
+static inline char *smart_string_print_unsigned(char *buf, long num) {
+ char *r;
+ smart_string_print_unsigned4(buf, num, unsigned long, r);
+ return r;
+}
+
+#define smart_string_append_generic_ex(dest, num, type, vartype, func) do { \
+ char __b[32]; \
+ char *__t; \
+ smart_string_print##func##4 (__b + sizeof(__b) - 1, (num), vartype, __t); \
+ smart_string_appendl_ex((dest), __t, __b + sizeof(__b) - 1 - __t, (type)); \
+} while (0)
+
+#define smart_string_append_unsigned_ex(dest, num, type) \
+ smart_string_append_generic_ex((dest), (num), (type), unsigned long, _unsigned)
+
+#define smart_string_append_long_ex(dest, num, type) \
+ smart_string_append_generic_ex((dest), (num), (type), unsigned long, _long)
+
+#define smart_string_append_off_t_ex(dest, num, type) \
+ smart_string_append_generic_ex((dest), (num), (type), off_t, _long)
+
+#define smart_string_append_ex(dest, src, what) \
+ smart_string_appendl_ex((dest), ((smart_string *)(src))->c, \
+ ((smart_string *)(src))->len, (what));
+
+
+#define smart_string_setl(dest, src, nlen) do { \
+ (dest)->len = (nlen); \
+ (dest)->a = (nlen) + 1; \
+ (dest)->c = (char *) (src); \
+} while (0)
+
+#define smart_string_sets(dest, src) \
+ smart_string_setl((dest), (src), strlen(src));
+
+#endif
#define EXPONENT_LENGTH 10
#include "ext/standard/php_smart_str.h"
+#include "ext/standard/php_smart_string.h"
/* {{{ macros */
+#define INS_CHAR(xbuf, ch, is_char) do { \
+ if ((is_char)) { \
+ smart_string_appendc((smart_string *)(xbuf), (ch)); \
+ } else { \
+ smart_str_appendc((smart_str *)(xbuf), (ch)); \
+ } \
+} while (0);
+
+#define INS_STRING(xbuf, str, len, is_char) do { \
+ if ((is_char)) { \
+ smart_string_appendl((smart_string *)(xbuf), (str), (len)); \
+ } else { \
+ smart_str_appendl((smart_str *)(xbuf), (str), (len)); \
+ } \
+} while (0);
+
+#define PAD_CHAR(xbuf, ch, count, is_char) do { \
+ size_t newlen; \
+ if ((is_char)) { \
+ smart_string_alloc(((smart_string *)(xbuf)), (count), 0); \
+ memset(((smart_string *)(xbuf))->c + ((smart_string *)(xbuf))->len, (ch), (count)); \
+ ((smart_string *)(xbuf))->len += (count); \
+ } else { \
+ smart_str_alloc(((smart_str *)(xbuf)), (count), 0); \
+ memset(((smart_str *)(xbuf))->s->val + ((smart_str *)(xbuf))->s->len, (ch), (count)); \
+ ((smart_str *)(xbuf))->s->len += (count); \
+ } \
+} while (0);
+
/*
* NUM_BUF_SIZE is the size of the buffer used for arithmetic conversions
*
*/
#define NUM_BUF_SIZE 2048
-/*
- * The INS_CHAR macro inserts a character in the buffer.
- *
- * NOTE: Evaluation of the ch argument should not have any side-effects
- */
-#define INS_CHAR_NR(xbuf, ch) do { \
- smart_str_appendc(xbuf, ch); \
-} while (0)
-
-#define INS_STRING(xbuf, s, slen) do { \
- smart_str_appendl(xbuf, s, slen); \
-} while (0)
-
-#define INS_CHAR(xbuf, ch) \
- INS_CHAR_NR(xbuf, ch)
-
-/*
- * Macro that does padding. The padding is done by printing
- * the character ch.
- */
-#define PAD(xbuf, count, ch) do { \
- if ((count) > 0) { \
- size_t newlen; \
- smart_str_alloc(xbuf, (count), 0); \
- memset(xbuf->s->val + xbuf->s->len, ch, (count)); \
- xbuf->s->len += (count); \
- } \
-} while (0)
-
#define NUM(c) (c - '0')
#define STR_TO_DEC(str, num) do { \
/* }}} */
-
#if !HAVE_STRNLEN
static size_t strnlen(const char *s, size_t maxlen) {
char *r = memchr(s, '\0', maxlen);
/*
* Do format conversion placing the output in buffer
*/
-static void xbuf_format_converter(smart_str *xbuf, const char *fmt, va_list ap) /* {{{ */
+static void xbuf_format_converter(void *xbuf, zend_bool is_char, const char *fmt, va_list ap) /* {{{ */
{
char *s = NULL;
int s_len, free_zcopy;
while (*fmt) {
if (*fmt != '%') {
- INS_CHAR(xbuf, *fmt);
+ INS_CHAR(xbuf, *fmt, is_char);
} else {
/*
* Default variable settings
case 'n':
- *(va_arg(ap, int *)) = xbuf->s->len;
+ *(va_arg(ap, int *)) = is_char? ((smart_string *)xbuf)->len : ((smart_str *)xbuf)->s->len;
goto skip_output;
/*
}
if (adjust_width && adjust == RIGHT && min_width > s_len) {
if (pad_char == '0' && prefix_char != NUL) {
- INS_CHAR(xbuf, *s);
+ INS_CHAR(xbuf, *s, is_char);
s++;
s_len--;
min_width--;
}
- PAD(xbuf, min_width - s_len, pad_char);
+ PAD_CHAR(xbuf, pad_char, min_width - s_len, is_char);
}
/*
* Print the string s.
*/
- INS_STRING(xbuf, s, s_len);
+ INS_STRING(xbuf, s, s_len, is_char);
+
+ if (adjust_width && adjust == LEFT && min_width > s_len) {
+ PAD_CHAR(xbuf, pad_char, min_width - s_len, is_char);
+ }
- if (adjust_width && adjust == LEFT && min_width > s_len)
- PAD(xbuf, min_width - s_len, pad_char);
if (free_zcopy) {
zval_dtor(&zcopy);
}
*/
PHPAPI int vspprintf(char **pbuf, size_t max_len, const char *format, va_list ap) /* {{{ */
{
- smart_str xbuf = {0};
+ smart_string buf = {0};
int result;
- xbuf_format_converter(&xbuf, format, ap);
+ xbuf_format_converter(&buf, 1, format, ap);
- if (max_len && xbuf.s && xbuf.s->len > max_len) {
- xbuf.s->len = max_len;
+ if (max_len && buf.len > max_len) {
+ buf.len = max_len;
}
- smart_str_0(&xbuf);
+ smart_string_0(&buf);
- if (xbuf.s) {
- *pbuf = estrndup(xbuf.s->val, xbuf.s->len);
- result = xbuf.s->len;
- smart_str_free(&xbuf);
+ if (buf.c) {
+ *pbuf = buf.c;
+ result = buf.len;
} else {
*pbuf = NULL;
result = 0;
PHPAPI zend_string *vstrpprintf(size_t max_len, const char *format, va_list ap) /* {{{ */
{
- smart_str xbuf = {0};
+ smart_str buf = {0};
- xbuf_format_converter(&xbuf, format, ap);
+ xbuf_format_converter(&buf, 0, format, ap);
- if (max_len && xbuf.s && xbuf.s->len > max_len) {
- xbuf.s->len = max_len;
+ if (max_len && buf.s && buf.s->len > max_len) {
+ buf.s->len = max_len;
}
- smart_str_0(&xbuf);
+ smart_str_0(&buf);
- return xbuf.s;
+ return buf.s;
}
/* }}} */
projects / php / commitdiff