Sync smart_string implementation with smart_str

Switch to using inline functions instead of macros, etc.

2 files changed, 85 insertions, 96 deletions

diff --git a/Zend/zend_smart_string.h b/Zend/zend_smart_string.h
index e04f256e0f..7325c80796 100644
--- a/Zend/zend_smart_string.h
+++ b/Zend/zend_smart_string.h
@@ -22,19 +22,13 @@
 #ifndef PHP_SMART_STRING_H
 #define PHP_SMART_STRING_H
 
-#include "zend_smart_string.h"
+#include "zend_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
@@ -52,98 +46,94 @@
 #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 {														\
-		if(UNEXPECTED((size_t)n > SIZE_MAX - (d)->len)) {					\
-			zend_error(E_ERROR, "String size overflow");			\
-		}															\
-		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_appends_ex(str, src, what) \
+	smart_string_appendl_ex((str), (src), strlen(src), (what))
+#define smart_string_appends(str, src) \
+	smart_string_appendl((str), (src), strlen(src))
+#define smart_string_append_ex(str, src, what) \
+	smart_string_appendl_ex((str), ((smart_string *)(src))->c, \
+		((smart_string *)(src))->len, (what));
+#define smart_string_sets(str, src) \
+	smart_string_setl((str), (src), strlen(src));
 
-#define smart_string_appendc(dest, c) \
-	smart_string_appendc_ex((dest), (c), 0)
+#define smart_string_appendc(str, c) \
+	smart_string_appendc_ex((str), (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_unsigned(dest, val) \
-	smart_string_append_unsigned_ex((dest), (val), 0)
-
-#define smart_string_appendc_ex(dest, ch, what) do {					\
-	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 {			\
-	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)
-
-#define smart_string_append_generic_ex(dest, num, type, vartype, func) do {	\
-	char __b[32];															\
-	char *__t = zend_print##func##_to_buf(__b + sizeof(__b) - 1, (num));	\
-	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), zend_ulong, _ulong)
-
-#define smart_string_append_long_ex(dest, num, type) \
-	smart_string_append_generic_ex((dest), (num), (type), zend_ulong, _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));
+#define smart_string_appendl(str, src, len) \
+	smart_string_appendl_ex((str), (src), (len), 0)
+#define smart_string_append(str, src) \
+	smart_string_append_ex((str), (src), 0)
+#define smart_string_append_long(str, val) \
+	smart_string_append_long_ex((str), (val), 0)
+#define smart_string_append_unsigned(str, val) \
+	smart_string_append_unsigned_ex((str), (val), 0)
+
+static zend_always_inline size_t smart_string_alloc(smart_string *str, size_t len, zend_bool persistent) {
+	if (!str->c) {
+		str->len = 0;
+		str->a = len < SMART_STRING_START_SIZE
+				? SMART_STRING_START_SIZE
+				: len + SMART_STRING_PREALLOC;
+		SMART_STRING_DO_REALLOC(str, persistent);
+		return len;
+	} else {
+		if (UNEXPECTED((size_t) len > SIZE_MAX - str->len)) {
+			zend_error(E_ERROR, "String size overflow");
+		}
+		len += str->len;
+		if (UNEXPECTED(len >= str->a)) {
+			str->a = len + SMART_STRING_PREALLOC;
+			SMART_STRING_DO_REALLOC(str, persistent);
+		}
+	}
+	return len;
+}
+
+static zend_always_inline void smart_string_free_ex(smart_string *str, zend_bool persistent) {
+	if (str->c) {
+		pefree(str->c, persistent);
+		str->c = NULL;
+	}
+	str->a = str->len = 0;
+}
+
+static zend_always_inline void smart_string_0(smart_string *str) {
+	if (str->c) {
+		str->c[str->len] = '\0';
+	}
+}
+
+static zend_always_inline void smart_string_appendc_ex(smart_string *dest, char ch, zend_bool persistent) {
+	dest->len = smart_string_alloc(dest, 1, persistent);
+	dest->c[dest->len - 1] = ch;
+}
+
+static zend_always_inline void smart_string_appendl_ex(smart_string *dest, const char *str, size_t len, zend_bool persistent) {
+	size_t new_len = smart_string_alloc(dest, len, persistent);
+	memcpy(dest->c + dest->len, str, len);
+	dest->len = new_len;
+
+}
+
+static zend_always_inline void smart_string_append_long_ex(smart_string *dest, zend_long num, zend_bool persistent) {
+	char buf[32];
+	char *result = zend_print_long_to_buf(buf + sizeof(buf) - 1, num);
+	smart_string_appendl_ex(dest, result, buf + sizeof(buf) - 1 - result, persistent);
+}
+
+static zend_always_inline void smart_string_append_unsigned_ex(smart_string *dest, zend_ulong num, zend_bool persistent) {
+	char buf[32];
+	char *result = zend_print_ulong_to_buf(buf + sizeof(buf) - 1, num);
+	smart_string_appendl_ex(dest, result, buf + sizeof(buf) - 1 - result, persistent);
+}
+
+static zend_always_inline void smart_string_setl(smart_string *dest, char *src, size_t len) {
+	dest->len = len;
+	dest->a = len + 1;
+	dest->c = src;
+}
 
 #endif
diff --git a/main/spprintf.c b/main/spprintf.c
index 2d24dbddeb..5a8ce07720 100644
--- a/main/spprintf.c
+++ b/main/spprintf.c
@@ -138,7 +138,6 @@
 } 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)); \