diff options
Diffstat (limited to 'ext/standard/string.c')
| -rw-r--r-- | ext/standard/string.c | 960 |
1 files changed, 469 insertions, 491 deletions
diff --git a/ext/standard/string.c b/ext/standard/string.c index 4ead166495..706a3eb075 100644 --- a/ext/standard/string.c +++ b/ext/standard/string.c @@ -1,6 +1,6 @@ /* +----------------------------------------------------------------------+ - | PHP Version 5 | + | PHP Version 7 | +----------------------------------------------------------------------+ | Copyright (c) 1997-2014 The PHP Group | +----------------------------------------------------------------------+ @@ -56,7 +56,7 @@ #include "zend_execute.h" #include "php_globals.h" #include "basic_functions.h" -#include "php_smart_str.h" +#include "zend_smart_str.h" #include <Zend/zend_exceptions.h> #ifdef ZTS #include "TSRM.h" @@ -81,13 +81,13 @@ */ void register_string_constants(INIT_FUNC_ARGS) { - REGISTER_INT_CONSTANT("STR_PAD_LEFT", STR_PAD_LEFT, CONST_CS | CONST_PERSISTENT); - REGISTER_INT_CONSTANT("STR_PAD_RIGHT", STR_PAD_RIGHT, CONST_CS | CONST_PERSISTENT); - REGISTER_INT_CONSTANT("STR_PAD_BOTH", STR_PAD_BOTH, CONST_CS | CONST_PERSISTENT); - REGISTER_INT_CONSTANT("PATHINFO_DIRNAME", PHP_PATHINFO_DIRNAME, CONST_CS | CONST_PERSISTENT); - REGISTER_INT_CONSTANT("PATHINFO_BASENAME", PHP_PATHINFO_BASENAME, CONST_CS | CONST_PERSISTENT); - REGISTER_INT_CONSTANT("PATHINFO_EXTENSION", PHP_PATHINFO_EXTENSION, CONST_CS | CONST_PERSISTENT); - REGISTER_INT_CONSTANT("PATHINFO_FILENAME", PHP_PATHINFO_FILENAME, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("STR_PAD_LEFT", STR_PAD_LEFT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("STR_PAD_RIGHT", STR_PAD_RIGHT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("STR_PAD_BOTH", STR_PAD_BOTH, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("PATHINFO_DIRNAME", PHP_PATHINFO_DIRNAME, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("PATHINFO_BASENAME", PHP_PATHINFO_BASENAME, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("PATHINFO_EXTENSION", PHP_PATHINFO_EXTENSION, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("PATHINFO_FILENAME", PHP_PATHINFO_FILENAME, CONST_CS | CONST_PERSISTENT); #ifdef HAVE_LOCALECONV /* If last members of struct lconv equal CHAR_MAX, no grouping is done */ @@ -97,25 +97,25 @@ void register_string_constants(INIT_FUNC_ARGS) # define CHAR_MAX 127 # endif - REGISTER_INT_CONSTANT("CHAR_MAX", CHAR_MAX, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("CHAR_MAX", CHAR_MAX, CONST_CS | CONST_PERSISTENT); #endif #ifdef HAVE_LOCALE_H - REGISTER_INT_CONSTANT("LC_CTYPE", LC_CTYPE, CONST_CS | CONST_PERSISTENT); - REGISTER_INT_CONSTANT("LC_NUMERIC", LC_NUMERIC, CONST_CS | CONST_PERSISTENT); - REGISTER_INT_CONSTANT("LC_TIME", LC_TIME, CONST_CS | CONST_PERSISTENT); - REGISTER_INT_CONSTANT("LC_COLLATE", LC_COLLATE, CONST_CS | CONST_PERSISTENT); - REGISTER_INT_CONSTANT("LC_MONETARY", LC_MONETARY, CONST_CS | CONST_PERSISTENT); - REGISTER_INT_CONSTANT("LC_ALL", LC_ALL, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("LC_CTYPE", LC_CTYPE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("LC_NUMERIC", LC_NUMERIC, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("LC_TIME", LC_TIME, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("LC_COLLATE", LC_COLLATE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("LC_MONETARY", LC_MONETARY, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("LC_ALL", LC_ALL, CONST_CS | CONST_PERSISTENT); # ifdef LC_MESSAGES - REGISTER_INT_CONSTANT("LC_MESSAGES", LC_MESSAGES, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("LC_MESSAGES", LC_MESSAGES, CONST_CS | CONST_PERSISTENT); # endif #endif } /* }}} */ -int php_tag_find(char *tag, php_size_t len, char *set); +int php_tag_find(char *tag, size_t len, char *set); /* this is read-only, so it's ok */ static char hexconvtab[] = "0123456789abcdef"; @@ -132,7 +132,7 @@ static zend_string *php_bin2hex(const unsigned char *old, const size_t oldlen) zend_string *result; size_t i, j; - result = STR_SAFE_ALLOC(oldlen, 2 * sizeof(char), 0, 0); + result = zend_string_safe_alloc(oldlen, 2 * sizeof(char), 0, 0); for (i = j = 0; i < oldlen; i++) { result->val[j++] = hexconvtab[old[i] >> 4]; @@ -149,7 +149,7 @@ static zend_string *php_bin2hex(const unsigned char *old, const size_t oldlen) static zend_string *php_hex2bin(const unsigned char *old, const size_t oldlen) { size_t target_length = oldlen >> 1; - zend_string *str = STR_ALLOC(target_length, 0); + zend_string *str = zend_string_alloc(target_length, 0); unsigned char *ret = (unsigned char *)str->val; size_t i, j; @@ -164,7 +164,7 @@ static zend_string *php_hex2bin(const unsigned char *old, const size_t oldlen) } else if (c >= 'A' && c <= 'F') { d = (c - 'A' + 10) << 4; } else { - STR_FREE(str); + zend_string_free(str); return NULL; } c = old[j++]; @@ -175,7 +175,7 @@ static zend_string *php_hex2bin(const unsigned char *old, const size_t oldlen) } else if (c >= 'A' && c <= 'F') { d |= c - 'A' + 10; } else { - STR_FREE(str); + zend_string_free(str); return NULL; } ret[i] = d; @@ -282,9 +282,9 @@ PHP_FUNCTION(hex2bin) static void php_spn_common_handler(INTERNAL_FUNCTION_PARAMETERS, int behavior) /* {{{ */ { zend_string *s11, *s22; - php_int_t start = 0, len = 0; + zend_long start = 0, len = 0; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "SS|ii", &s11, + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "SS|ll", &s11, &s22, &start, &len) == FAILURE) { return; } @@ -296,11 +296,11 @@ static void php_spn_common_handler(INTERNAL_FUNCTION_PARAMETERS, int behavior) / /* look at substr() function for more information */ if (start < 0) { - start += (php_int_t)s11->len; + start += (zend_long)s11->len; if (start < 0) { start = 0; } - } else if ((php_size_t)start > s11->len) { + } else if ((size_t)start > s11->len) { RETURN_FALSE; } @@ -311,21 +311,21 @@ static void php_spn_common_handler(INTERNAL_FUNCTION_PARAMETERS, int behavior) / } } - if (len > (php_int_t)s11->len - start) { + if (len > (zend_long)s11->len - start) { len = s11->len - start; } if(len == 0) { - RETURN_INT(0); + RETURN_LONG(0); } if (behavior == STR_STRSPN) { - RETURN_INT(php_strspn(s11->val + start /*str1_start*/, + RETURN_LONG(php_strspn(s11->val + start /*str1_start*/, s22->val /*str2_start*/, s11->val + start + len /*str1_end*/, s22->val + s22->len /*str2_end*/)); } else if (behavior == STR_STRCSPN) { - RETURN_INT(php_strcspn(s11->val + start /*str1_start*/, + RETURN_LONG(php_strcspn(s11->val + start /*str1_start*/, s22->val /*str2_start*/, s11->val + start + len /*str1_end*/, s22->val + s22->len /*str2_end*/)); @@ -354,7 +354,7 @@ PHP_FUNCTION(strcspn) #if HAVE_NL_LANGINFO PHP_MINIT_FUNCTION(nl_langinfo) { -#define REGISTER_NL_LANGINFO_CONSTANT(x) REGISTER_INT_CONSTANT(#x, x, CONST_CS | CONST_PERSISTENT) +#define REGISTER_NL_LANGINFO_CONSTANT(x) REGISTER_LONG_CONSTANT(#x, x, CONST_CS | CONST_PERSISTENT) #ifdef ABDAY_1 REGISTER_NL_LANGINFO_CONSTANT(ABDAY_1); REGISTER_NL_LANGINFO_CONSTANT(ABDAY_2); @@ -524,10 +524,10 @@ PHP_MINIT_FUNCTION(nl_langinfo) Query language and locale information */ PHP_FUNCTION(nl_langinfo) { - php_int_t item; + zend_long item; char *value; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "i", &item) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &item) == FAILURE) { return; } @@ -692,7 +692,7 @@ PHP_FUNCTION(nl_langinfo) #endif break; default: - php_error_docref(NULL TSRMLS_CC, E_WARNING, "Item '" ZEND_INT_FMT "' is not valid", item); + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Item '" ZEND_LONG_FMT "' is not valid", item); RETURN_FALSE; } /* }}} */ @@ -718,7 +718,7 @@ PHP_FUNCTION(strcoll) return; } - RETURN_INT(strcoll((const char *) s1->val, + RETURN_LONG(strcoll((const char *) s1->val, (const char *) s2->val)); } /* }}} */ @@ -729,7 +729,7 @@ PHP_FUNCTION(strcoll) * it needs to be incrementing. * Returns: FAILURE/SUCCESS whether the input was correct (i.e. no range errors) */ -static inline int php_charmask(unsigned char *input, php_size_t len, char *mask TSRMLS_DC) +static inline int php_charmask(unsigned char *input, size_t len, char *mask TSRMLS_DC) { unsigned char *end; unsigned char c; @@ -778,10 +778,10 @@ static inline int php_charmask(unsigned char *input, php_size_t len, char *mask * mode 3 : trim left and right * what indicates which chars are to be trimmed. NULL->default (' \t\n\r\v\0') */ -PHPAPI char *php_trim(char *c, php_size_t len, char *what, php_size_t what_len, zval *return_value, int mode TSRMLS_DC) +PHPAPI char *php_trim(char *c, size_t len, char *what, size_t what_len, zval *return_value, int mode TSRMLS_DC) { - register php_int_t i; - int trimmed = 0; + register size_t i; + size_t trimmed = 0; char mask[256]; if (what) { @@ -802,12 +802,15 @@ PHPAPI char *php_trim(char *c, php_size_t len, char *what, php_size_t what_len, c += trimmed; } if (mode & 2) { - for (i = len - 1; i >= 0; i--) { - if (mask[(unsigned char)c[i]]) { - len--; - } else { - break; - } + if (len > 0) { + i = len - 1; + do { + if (mask[(unsigned char)c[i]]) { + len--; + } else { + break; + } + } while (i-- != 0); } } @@ -872,33 +875,24 @@ PHP_FUNCTION(ltrim) Wraps buffer to selected number of characters using string break char */ PHP_FUNCTION(wordwrap) { - zend_string *text, *breakchar = NULL, *breakchar_save = NULL; - php_size_t newtextlen, chk; + zend_string *text; + char *breakchar = "\n"; + size_t newtextlen, chk, breakchar_len = 1; size_t alloced; - php_int_t current = 0, laststart = 0, lastspace = 0; - php_int_t linelength = 75; + zend_long current = 0, laststart = 0, lastspace = 0; + zend_long linelength = 75; zend_bool docut = 0; zend_string *newtext; - breakchar = breakchar_save = STR_INIT("\n", 1, 1); - if (!breakchar) { - return; - } - - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S|iSb", &text, &linelength, &breakchar, &docut) == FAILURE) { - STR_FREE(breakchar); + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S|lsb", &text, &linelength, &breakchar, &breakchar_len, &docut) == FAILURE) { return; } - if (breakchar != breakchar_save) { - STR_FREE(breakchar_save); - } - if (text->len == 0) { RETURN_EMPTY_STRING(); } - if (breakchar->len == 0) { + if (breakchar_len == 0) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Break string cannot be empty"); RETURN_FALSE; } @@ -910,21 +904,21 @@ PHP_FUNCTION(wordwrap) /* Special case for a single-character break as it needs no additional storage space */ - if (breakchar->len == 1 && !docut) { - newtext = STR_INIT(text->val, text->len, 0); + if (breakchar_len == 1 && !docut) { + newtext = zend_string_init(text->val, text->len, 0); laststart = lastspace = 0; for (current = 0; current < text->len; current++) { - if (text->val[current] == breakchar->val[0]) { + if (text->val[current] == breakchar[0]) { laststart = lastspace = current + 1; } else if (text->val[current] == ' ') { if (current - laststart >= linelength) { - newtext->val[current] = breakchar->val[0]; + newtext->val[current] = breakchar[0]; laststart = current + 1; } lastspace = current; } else if (current - laststart >= linelength && laststart != lastspace) { - newtext->val[lastspace] = breakchar->val[0]; + newtext->val[lastspace] = breakchar[0]; laststart = lastspace + 1; } } @@ -933,13 +927,13 @@ PHP_FUNCTION(wordwrap) } else { /* Multiple character line break or forced cut */ if (linelength > 0) { - chk = (php_size_t)(text->len/linelength + 1); - newtext = STR_ALLOC(chk * breakchar->len + text->len, 0); - alloced = text->len + chk * breakchar->len + 1; + chk = (size_t)(text->len/linelength + 1); + newtext = zend_string_alloc(chk * breakchar_len + text->len, 0); + alloced = text->len + chk * breakchar_len + 1; } else { chk = text->len; - alloced = text->len * (breakchar->len + 1) + 1; - newtext = STR_ALLOC(text->len * (breakchar->len + 1), 0); + alloced = text->len * (breakchar_len + 1) + 1; + newtext = zend_string_alloc(text->len * (breakchar_len + 1), 0); } /* now keep track of the actual new text length */ @@ -948,18 +942,18 @@ PHP_FUNCTION(wordwrap) laststart = lastspace = 0; for (current = 0; current < text->len; current++) { if (chk <= 0) { - alloced += (php_size_t) (((text->len - current + 1)/linelength + 1) * breakchar->len) + 1; - newtext = STR_REALLOC(newtext, alloced, 0); - chk = (php_size_t) ((text->len - current)/linelength) + 1; + alloced += (size_t) (((text->len - current + 1)/linelength + 1) * breakchar_len) + 1; + newtext = zend_string_realloc(newtext, alloced, 0); + chk = (size_t) ((text->len - current)/linelength) + 1; } /* when we hit an existing break, copy to new buffer, and * fix up laststart and lastspace */ - if (text->val[current] == breakchar->val[0] - && current + breakchar->len < text->len - && !strncmp(text->val+current, breakchar->val, breakchar->len)) { - memcpy(newtext->val + newtextlen, text->val + laststart, current - laststart + breakchar->len); - newtextlen += current - laststart + breakchar->len; - current += breakchar->len - 1; + if (text->val[current] == breakchar[0] + && current + breakchar_len < text->len + && !strncmp(text->val+current, breakchar, breakchar_len)) { + memcpy(newtext->val + newtextlen, text->val + laststart, current - laststart + breakchar_len); + newtextlen += current - laststart + breakchar_len; + current += breakchar_len - 1; laststart = lastspace = current + 1; chk--; } @@ -969,8 +963,8 @@ PHP_FUNCTION(wordwrap) if (current - laststart >= linelength) { memcpy(newtext->val + newtextlen, text->val + laststart, current - laststart); newtextlen += current - laststart; - memcpy(newtext->val + newtextlen, breakchar->val, breakchar->len); - newtextlen += breakchar->len; + memcpy(newtext->val + newtextlen, breakchar, breakchar_len); + newtextlen += breakchar_len; laststart = current + 1; chk--; } @@ -983,8 +977,8 @@ PHP_FUNCTION(wordwrap) && docut && laststart >= lastspace) { memcpy(newtext->val + newtextlen, text->val + laststart, current - laststart); newtextlen += current - laststart; - memcpy(newtext->val + newtextlen, breakchar->val, breakchar->len); - newtextlen += breakchar->len; + memcpy(newtext->val + newtextlen, breakchar, breakchar_len); + newtextlen += breakchar_len; laststart = lastspace = current; chk--; } @@ -995,8 +989,8 @@ PHP_FUNCTION(wordwrap) && laststart < lastspace) { memcpy(newtext->val + newtextlen, text->val + laststart, lastspace - laststart); newtextlen += lastspace - laststart; - memcpy(newtext->val + newtextlen, breakchar->val, breakchar->len); - newtextlen += breakchar->len; + memcpy(newtext->val + newtextlen, breakchar, breakchar_len); + newtextlen += breakchar_len; laststart = lastspace = lastspace + 1; chk--; } @@ -1010,7 +1004,7 @@ PHP_FUNCTION(wordwrap) newtext->val[newtextlen] = '\0'; /* free unused memory */ - newtext = STR_REALLOC(newtext, newtextlen, 0); + newtext = zend_string_realloc(newtext, newtextlen, 0); RETURN_NEW_STR(newtext); } @@ -1019,41 +1013,36 @@ PHP_FUNCTION(wordwrap) /* {{{ php_explode */ -PHPAPI void php_explode(zval *delim, zval *str, zval *return_value, php_int_t limit) +PHPAPI void php_explode(const zend_string *delim, zend_string *str, zval *return_value, zend_long limit) { - char *p1, *p2, *endp; - - endp = Z_STRVAL_P(str) + Z_STRSIZE_P(str); - - p1 = Z_STRVAL_P(str); - p2 = (char*)php_memnstr(Z_STRVAL_P(str), Z_STRVAL_P(delim), Z_STRSIZE_P(delim), endp); + char *p1 = str->val; + char *endp = str->val + str->len; + char *p2 = (char *) php_memnstr(str->val, delim->val, delim->len, endp); if (p2 == NULL) { - add_next_index_stringl(return_value, p1, Z_STRSIZE_P(str)); + add_next_index_str(return_value, zend_string_copy(str)); } else { do { add_next_index_stringl(return_value, p1, p2 - p1); - p1 = p2 + Z_STRSIZE_P(delim); - } while ((p2 = (char*)php_memnstr(p1, Z_STRVAL_P(delim), Z_STRSIZE_P(delim), endp)) != NULL && - --limit > 1); + p1 = p2 + delim->len; + p2 = (char *) php_memnstr(p1, delim->val, delim->len, endp); + } while (p2 != NULL && --limit > 1); - if (p1 <= endp) - add_next_index_stringl(return_value, p1, endp-p1); + if (p1 <= endp) { + add_next_index_stringl(return_value, p1, endp - p1); + } } } /* }}} */ /* {{{ php_explode_negative_limit */ -PHPAPI void php_explode_negative_limit(zval *delim, zval *str, zval *return_value, php_int_t limit) +PHPAPI void php_explode_negative_limit(const zend_string *delim, zend_string *str, zval *return_value, zend_long limit) { #define EXPLODE_ALLOC_STEP 64 - char *p1, *p2, *endp; - - endp = Z_STRVAL_P(str) + Z_STRSIZE_P(str); - - p1 = Z_STRVAL_P(str); - p2 = (char*)php_memnstr(Z_STRVAL_P(str), Z_STRVAL_P(delim), Z_STRSIZE_P(delim), endp); + char *p1 = str->val; + char *endp = str->val + str->len; + char *p2 = (char *) php_memnstr(str->val, delim->val, delim->len, endp); if (p2 == NULL) { /* @@ -1061,8 +1050,8 @@ PHPAPI void php_explode_negative_limit(zval *delim, zval *str, zval *return_valu by doing nothing we return empty array */ } else { - php_size_t allocated = EXPLODE_ALLOC_STEP, found = 0; - php_int_t i, to_return; + size_t allocated = EXPLODE_ALLOC_STEP, found = 0; + zend_long i, to_return; char **positions = emalloc(allocated * sizeof(char *)); positions[found++] = p1; @@ -1071,14 +1060,15 @@ PHPAPI void php_explode_negative_limit(zval *delim, zval *str, zval *return_valu allocated = found + EXPLODE_ALLOC_STEP;/* make sure we have enough memory */ positions = erealloc(positions, allocated*sizeof(char *)); } - positions[found++] = p1 = p2 + Z_STRSIZE_P(delim); - } while ((p2 = (char*)php_memnstr(p1, Z_STRVAL_P(delim), Z_STRSIZE_P(delim), endp)) != NULL); + positions[found++] = p1 = p2 + delim->len; + p2 = (char *) php_memnstr(p1, delim->val, delim->len, endp); + } while (p2 != NULL); to_return = limit + found; /* limit is at least -1 therefore no need of bounds checking : i will be always less than found */ - for (i = 0;i < to_return;i++) { /* this checks also for to_return > 0 */ + for (i = 0; i < to_return; i++) { /* this checks also for to_return > 0 */ add_next_index_stringl(return_value, positions[i], - (positions[i+1] - Z_STRSIZE_P(delim)) - positions[i]); + (positions[i+1] - delim->len) - positions[i]); } efree(positions); } @@ -1091,11 +1081,10 @@ PHPAPI void php_explode_negative_limit(zval *delim, zval *str, zval *return_valu PHP_FUNCTION(explode) { zend_string *str, *delim; - php_int_t limit = PHP_INT_MAX; /* No limit */ - zval zdelim, zstr; + zend_long limit = ZEND_LONG_MAX; /* No limit */ #ifndef FAST_ZPP - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "SS|i", &delim, &str, &limit) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "SS|l", &delim, &str, &limit) == FAILURE) { return; } #else @@ -1103,7 +1092,7 @@ PHP_FUNCTION(explode) Z_PARAM_STR(delim) Z_PARAM_STR(str) Z_PARAM_OPTIONAL - Z_PARAM_INT(limit) + Z_PARAM_LONG(limit) ZEND_PARSE_PARAMETERS_END(); #endif @@ -1116,17 +1105,15 @@ PHP_FUNCTION(explode) if (str->len == 0) { if (limit >= 0) { - add_next_index_stringl(return_value, "", sizeof("") - 1); + add_next_index_str(return_value, STR_EMPTY_ALLOC()); } return; } - ZVAL_STR(&zstr, str); - ZVAL_STR(&zdelim, delim); if (limit > 1) { - php_explode(&zdelim, &zstr, return_value, limit); + php_explode(delim, str, return_value, limit); } else if (limit < 0) { - php_explode_negative_limit(&zdelim, &zstr, return_value, limit); + php_explode_negative_limit(delim, str, return_value, limit); } else { add_index_stringl(return_value, 0, str->val, str->len); } @@ -1139,7 +1126,7 @@ PHP_FUNCTION(explode) /* {{{ php_implode */ -PHPAPI void php_implode(zval *delim, zval *arr, zval *return_value TSRMLS_DC) +PHPAPI void php_implode(const zend_string *delim, zval *arr, zval *return_value TSRMLS_DC) { zval *tmp; smart_str implstr = {0}; @@ -1156,11 +1143,11 @@ PHPAPI void php_implode(zval *delim, zval *arr, zval *return_value TSRMLS_DC) again: switch (Z_TYPE_P(tmp)) { case IS_STRING: - smart_str_appendl(&implstr, Z_STRVAL_P(tmp), Z_STRSIZE_P(tmp)); + smart_str_append(&implstr, Z_STR_P(tmp)); break; - case IS_INT: - smart_str_append_int(&implstr, Z_IVAL_P(tmp)); + case IS_LONG: + smart_str_append_long(&implstr, Z_LVAL_P(tmp)); break; case IS_TRUE: @@ -1173,11 +1160,11 @@ again: case IS_DOUBLE: { char *stmp; - php_size_t str_len = spprintf(&stmp, 0, "%.*G", (int) EG(precision), Z_DVAL_P(tmp)); + size_t str_len = spprintf(&stmp, 0, "%.*G", (int) EG(precision), Z_DVAL_P(tmp)); smart_str_appendl(&implstr, stmp, str_len); efree(stmp); - } break; + } case IS_REFERENCE: tmp = Z_REFVAL_P(tmp); @@ -1185,14 +1172,14 @@ again: default: str = zval_get_string(tmp); - smart_str_appendl(&implstr, str->val, str->len); - STR_RELEASE(str); + smart_str_append(&implstr, str); + zend_string_release(str); break; } if (++i != numelems) { - smart_str_appendl(&implstr, Z_STRVAL_P(delim), Z_STRSIZE_P(delim)); + smart_str_append(&implstr, delim); } } ZEND_HASH_FOREACH_END(); @@ -1211,7 +1198,8 @@ again: Joins array elements placing glue string between items and return one string */ PHP_FUNCTION(implode) { - zval *arg1 = NULL, *arg2 = NULL, *delim, *arr, tmp; + zval *arg1, *arg2 = NULL, *arr; + zend_string *delim; #ifndef FAST_ZPP if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &arg1, &arg2) == FAILURE) { @@ -1231,20 +1219,15 @@ PHP_FUNCTION(implode) return; } - ZVAL_EMPTY_STRING(&tmp); - delim = &tmp; - - SEPARATE_ZVAL(arg1); + delim = STR_EMPTY_ALLOC(); arr = arg1; } else { if (Z_TYPE_P(arg1) == IS_ARRAY) { + delim = zval_get_string(arg2); arr = arg1; - convert_to_string_ex(arg2); - delim = arg2; } else if (Z_TYPE_P(arg2) == IS_ARRAY) { + delim = zval_get_string(arg1); arr = arg2; - convert_to_string_ex(arg1); - delim = arg1; } else { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid arguments passed"); return; @@ -1252,6 +1235,7 @@ PHP_FUNCTION(implode) } php_implode(delim, arr, return_value TSRMLS_CC); + zend_string_release(delim); } /* }}} */ @@ -1266,7 +1250,7 @@ PHP_FUNCTION(strtok) char *token_end; char *p; char *pe; - int skipped = 0; + size_t skipped = 0; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S|S", &str, &tok) == FAILURE) { return; @@ -1360,7 +1344,7 @@ PHP_FUNCTION(strtoupper) return; } - result = STR_INIT(arg->val, arg->len, 0); + result = zend_string_init(arg->val, arg->len, 0); php_strtoupper(result->val, result->len); RETURN_NEW_STR(result); } @@ -1400,7 +1384,7 @@ PHP_FUNCTION(strtolower) ZEND_PARSE_PARAMETERS_END(); #endif - result = STR_INIT(str->val, str->len, 0); + result = zend_string_init(str->val, str->len, 0); php_strtolower(result->val, result->len); RETURN_NEW_STR(result); } @@ -1419,13 +1403,13 @@ PHPAPI zend_string *php_basename(const char *s, size_t len, char *suffix, size_t cnt = len; state = 0; while (cnt > 0) { - inc_len = (*c == '\0' ? 1: php_mblen(c, cnt)); + inc_len = (*c == '\0' ? 1 : php_mblen(c, cnt)); switch (inc_len) { case -2: case -1: inc_len = 1; - php_ignore_value(php_mblen(NULL, 0)); + php_mb_reset(); break; case 0: goto quit_loop; @@ -1474,14 +1458,14 @@ quit_loop: if (state == 1) { cend = c; } - if (suffix != NULL && sufflen < (uint)(cend - comp) && + if (suffix != NULL && sufflen < (size_t)(cend - comp) && memcmp(cend - sufflen, suffix, sufflen) == 0) { cend -= sufflen; } len = cend - comp; - ret = STR_INIT(comp, len, 0); + ret = zend_string_init(comp, len, 0); return ret; } /* }}} */ @@ -1491,7 +1475,7 @@ quit_loop: PHP_FUNCTION(basename) { char *string, *suffix = NULL; - int string_len, suffix_len = 0; + size_t string_len, suffix_len = 0; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|s", &string, &string_len, &suffix, &suffix_len) == FAILURE) { return; @@ -1515,13 +1499,13 @@ PHP_FUNCTION(dirname) { char *str; zend_string *ret; - int str_len; + size_t str_len; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &str_len) == FAILURE) { return; } - ret = STR_INIT(str, str_len, 0); + ret = zend_string_init(str, str_len, 0); ret->len = zend_dirname(ret->val, str_len); RETURN_NEW_STR(ret); @@ -1534,11 +1518,12 @@ PHP_FUNCTION(pathinfo) { zval tmp; char *path, *dirname; - int path_len, have_basename; - php_int_t opt = PHP_PATHINFO_ALL; + size_t path_len; + int have_basename; + zend_long opt = PHP_PATHINFO_ALL; zend_string *ret = NULL; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|i", &path, &path_len, &opt) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &path, &path_len, &opt) == FAILURE) { return; } @@ -1557,12 +1542,12 @@ PHP_FUNCTION(pathinfo) if (have_basename) { ret = php_basename(path, path_len, NULL, 0 TSRMLS_CC); - add_assoc_str(&tmp, "basename", STR_COPY(ret)); + add_assoc_str(&tmp, "basename", zend_string_copy(ret)); } if ((opt & PHP_PATHINFO_EXTENSION) == PHP_PATHINFO_EXTENSION) { const char *p; - int idx; + ptrdiff_t idx; if (!have_basename) { ret = php_basename(path, path_len, NULL, 0 TSRMLS_CC); @@ -1578,7 +1563,7 @@ PHP_FUNCTION(pathinfo) if ((opt & PHP_PATHINFO_FILENAME) == PHP_PATHINFO_FILENAME) { const char *p; - int idx; + ptrdiff_t idx; /* Have we already looked up the basename? */ if (!have_basename && !ret) { @@ -1592,7 +1577,7 @@ PHP_FUNCTION(pathinfo) } if (ret) { - STR_RELEASE(ret); + zend_string_release(ret); } if (opt == PHP_PATHINFO_ALL) { @@ -1663,8 +1648,8 @@ PHPAPI size_t php_strcspn(char *s1, char *s2, char *s1_end, char *s2_end) static int php_needle_char(zval *needle, char *target TSRMLS_DC) { switch (Z_TYPE_P(needle)) { - case IS_INT: - *target = (char)Z_IVAL_P(needle); + case IS_LONG: + *target = (char)Z_LVAL_P(needle); return SUCCESS; case IS_NULL: case IS_FALSE: @@ -1680,11 +1665,11 @@ static int php_needle_char(zval *needle, char *target TSRMLS_DC) { zval holder = *needle; zval_copy_ctor(&(holder)); - convert_to_int(&(holder)); - if(Z_TYPE(holder) != IS_INT) { + convert_to_long(&(holder)); + if(Z_TYPE(holder) != IS_LONG) { return FAILURE; } - *target = (char)Z_IVAL(holder); + *target = (char)Z_LVAL(holder); return SUCCESS; } default: { @@ -1702,7 +1687,7 @@ PHP_FUNCTION(stristr) zval *needle; zend_string *haystack; char *found = NULL; - php_size_t found_offset; + size_t found_offset; char *haystack_dup; char needle_char[2]; zend_bool part = 0; @@ -1715,13 +1700,13 @@ PHP_FUNCTION(stristr) if (Z_TYPE_P(needle) == IS_STRING) { char *orig_needle; - if (!Z_STRSIZE_P(needle)) { + if (!Z_STRLEN_P(needle)) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Empty needle"); efree(haystack_dup); RETURN_FALSE; } - orig_needle = estrndup(Z_STRVAL_P(needle), Z_STRSIZE_P(needle)); - found = php_stristr(haystack_dup, orig_needle, haystack->len, Z_STRSIZE_P(needle)); + orig_needle = estrndup(Z_STRVAL_P(needle), Z_STRLEN_P(needle)); + found = php_stristr(haystack_dup, orig_needle, haystack->len, Z_STRLEN_P(needle)); efree(orig_needle); } else { if (php_needle_char(needle, needle_char TSRMLS_CC) != SUCCESS) { @@ -1756,7 +1741,7 @@ PHP_FUNCTION(strstr) zend_string *haystack; char *found = NULL; char needle_char[2]; - php_int_t found_offset; + zend_long found_offset; zend_bool part = 0; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Sz|b", &haystack, &needle, &part) == FAILURE) { @@ -1764,12 +1749,12 @@ PHP_FUNCTION(strstr) } if (Z_TYPE_P(needle) == IS_STRING) { - if (!Z_STRSIZE_P(needle)) { + if (!Z_STRLEN_P(needle)) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Empty needle"); RETURN_FALSE; } - found = (char*)php_memnstr(haystack->val, Z_STRVAL_P(needle), Z_STRSIZE_P(needle), haystack->val + haystack->len); + found = (char*)php_memnstr(haystack->val, Z_STRVAL_P(needle), Z_STRLEN_P(needle), haystack->val + haystack->len); } else { if (php_needle_char(needle, needle_char TSRMLS_CC) != SUCCESS) { RETURN_FALSE; @@ -1803,10 +1788,10 @@ PHP_FUNCTION(strpos) zend_string *haystack; char *found = NULL; char needle_char[2]; - php_int_t offset = 0; + zend_long offset = 0; #ifndef FAST_ZPP - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Sz|i", &haystack, &needle, &offset) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Sz|l", &haystack, &needle, &offset) == FAILURE) { return; } #else @@ -1814,24 +1799,24 @@ PHP_FUNCTION(strpos) Z_PARAM_STR(haystack) Z_PARAM_ZVAL(needle) Z_PARAM_OPTIONAL - Z_PARAM_INT(offset) + Z_PARAM_LONG(offset) ZEND_PARSE_PARAMETERS_END(); #endif - if (offset < 0 || offset > haystack->len) { + if (offset < 0 || (size_t)offset > haystack->len) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Offset not contained in string"); RETURN_FALSE; } if (Z_TYPE_P(needle) == IS_STRING) { - if (!Z_STRSIZE_P(needle)) { + if (!Z_STRLEN_P(needle)) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Empty needle"); RETURN_FALSE; } found = (char*)php_memnstr(haystack->val + offset, Z_STRVAL_P(needle), - Z_STRSIZE_P(needle), + Z_STRLEN_P(needle), haystack->val + haystack->len); } else { if (php_needle_char(needle, needle_char TSRMLS_CC) != SUCCESS) { @@ -1846,7 +1831,7 @@ PHP_FUNCTION(strpos) } if (found) { - RETURN_INT(found - haystack->val); + RETURN_LONG(found - haystack->val); } else { RETURN_FALSE; } @@ -1859,16 +1844,16 @@ PHP_FUNCTION(stripos) { char *found = NULL; zend_string *haystack; - php_int_t offset = 0; + zend_long offset = 0; char *needle_dup = NULL, *haystack_dup; char needle_char[2]; zval *needle; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Sz|i", &haystack, &needle, &offset) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Sz|l", &haystack, &needle, &offset) == FAILURE) { return; } - if (offset < 0 || offset > haystack->len) { + if (offset < 0 || (size_t)offset > haystack->len) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Offset not contained in string"); RETURN_FALSE; } @@ -1881,14 +1866,14 @@ PHP_FUNCTION(stripos) php_strtolower(haystack_dup, haystack->len); if (Z_TYPE_P(needle) == IS_STRING) { - if (Z_STRSIZE_P(needle) == 0 || Z_STRSIZE_P(needle) > haystack->len) { + if (Z_STRLEN_P(needle) == 0 || Z_STRLEN_P(needle) > haystack->len) { efree(haystack_dup); RETURN_FALSE; } - needle_dup = estrndup(Z_STRVAL_P(needle), Z_STRSIZE_P(needle)); - php_strtolower(needle_dup, Z_STRSIZE_P(needle)); - found = (char*)php_memnstr(haystack_dup + offset, needle_dup, Z_STRSIZE_P(needle), haystack_dup + haystack->len); + needle_dup = estrndup(Z_STRVAL_P(needle), Z_STRLEN_P(needle)); + php_strtolower(needle_dup, Z_STRLEN_P(needle)); + found = (char*)php_memnstr(haystack_dup + offset, needle_dup, Z_STRLEN_P(needle), haystack_dup + haystack->len); } else { if (php_needle_char(needle, needle_char TSRMLS_CC) != SUCCESS) { efree(haystack_dup); @@ -1908,7 +1893,7 @@ PHP_FUNCTION(stripos) } if (found) { - RETURN_INT(found - haystack_dup); + RETURN_LONG(found - haystack_dup); } else { RETURN_FALSE; } @@ -1922,12 +1907,12 @@ PHP_FUNCTION(strrpos) zval *zneedle; char *needle; zend_string *haystack; - php_size_t needle_len; - php_int_t offset = 0; + size_t needle_len; + zend_long offset = 0; char *p, *e, ord_needle[2]; #ifndef FAST_ZPP - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Sz|i", &haystack, &zneedle, &offset) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Sz|l", &haystack, &zneedle, &offset) == FAILURE) { RETURN_FALSE; } #else @@ -1935,13 +1920,13 @@ PHP_FUNCTION(strrpos) Z_PARAM_STR(haystack) Z_PARAM_ZVAL(zneedle) Z_PARAM_OPTIONAL - Z_PARAM_INT(offset) + Z_PARAM_LONG(offset) ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE); #endif if (Z_TYPE_P(zneedle) == IS_STRING) { needle = Z_STRVAL_P(zneedle); - needle_len = Z_STRSIZE_P(zneedle); + needle_len = Z_STRLEN_P(zneedle); } else { if (php_needle_char(zneedle, ord_needle TSRMLS_CC) != SUCCESS) { RETURN_FALSE; @@ -1956,20 +1941,20 @@ PHP_FUNCTION(strrpos) } if (offset >= 0) { - if (offset > haystack->len) { + if ((size_t)offset > haystack->len) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Offset is greater than the length of haystack string"); RETURN_FALSE; } - p = haystack->val + offset; + p = haystack->val + (size_t)offset; e = haystack->val + haystack->len - needle_len; } else { - if (offset < -INT_MAX || -offset > haystack->len) { + if (offset < -INT_MAX || (size_t)(-offset) > haystack->len) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Offset is greater than the length of haystack string"); RETURN_FALSE; } p = haystack->val; - if (needle_len > -offset) { + if (needle_len > (size_t)(-offset)) { e = haystack->val + haystack->len - needle_len; } else { e = haystack->val + haystack->len + offset; @@ -1980,7 +1965,7 @@ PHP_FUNCTION(strrpos) /* Single character search can shortcut memcmps */ while (e >= p) { if (*e == *needle) { - RETURN_INT(e - p + (offset > 0 ? offset : 0)); + RETURN_LONG(e - p + (offset > 0 ? offset : 0)); } e--; } @@ -1989,7 +1974,7 @@ PHP_FUNCTION(strrpos) while (e >= p) { if (memcmp(e, needle, needle_len) == 0) { - RETURN_INT(e - p + (offset > 0 ? offset : 0)); + RETURN_LONG(e - p + (offset > 0 ? offset : 0)); } e--; } @@ -2005,18 +1990,18 @@ PHP_FUNCTION(strripos) zval *zneedle; char *needle; zend_string *haystack; - php_size_t needle_len; - php_int_t offset = 0; + size_t needle_len; + zend_long offset = 0; char *p, *e, ord_needle[2]; char *needle_dup, *haystack_dup; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Sz|i", &haystack, &zneedle, &offset) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Sz|l", &haystack, &zneedle, &offset) == FAILURE) { RETURN_FALSE; } if (Z_TYPE_P(zneedle) == IS_STRING) { needle = Z_STRVAL_P(zneedle); - needle_len = Z_STRSIZE_P(zneedle); + needle_len = Z_STRLEN_P(zneedle); } else { if (php_needle_char(zneedle, ord_needle TSRMLS_CC) != SUCCESS) { RETURN_FALSE; @@ -2034,7 +2019,7 @@ PHP_FUNCTION(strripos) /* Single character search can shortcut memcmps Can also avoid tolower emallocs */ if (offset >= 0) { - if (offset > haystack->len) { + if ((size_t)offset > haystack->len) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Offset is greater than the length of haystack string"); RETURN_FALSE; } @@ -2042,7 +2027,7 @@ PHP_FUNCTION(strripos) e = haystack->val + haystack->len - 1; } else { p = haystack->val; - if (offset < -INT_MAX || -offset > haystack->len) { + if (offset < -INT_MAX || (size_t)(-offset) > haystack->len) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Offset is greater than the length of haystack string"); RETURN_FALSE; } @@ -2052,7 +2037,7 @@ PHP_FUNCTION(strripos) *ord_needle = tolower(*needle); while (e >= p) { if (tolower(*e) == *ord_needle) { - RETURN_INT(e - p + (offset > 0 ? offset : 0)); + RETURN_LONG(e - p + (offset > 0 ? offset : 0)); } e--; } @@ -2065,7 +2050,7 @@ PHP_FUNCTION(strripos) php_strtolower(haystack_dup, haystack->len); if (offset >= 0) { - if (offset > haystack->len) { + if ((size_t)offset > haystack->len) { efree(needle_dup); efree(haystack_dup); php_error_docref(NULL TSRMLS_CC, E_WARNING, "Offset is greater than the length of haystack string"); @@ -2074,14 +2059,14 @@ PHP_FUNCTION(strripos) p = haystack_dup + offset; e = haystack_dup + haystack->len - needle_len; } else { - if (offset < -INT_MAX || -offset > haystack->len) { + if (offset < -INT_MAX || (size_t)(-offset) > haystack->len) { efree(needle_dup); efree(haystack_dup); php_error_docref(NULL TSRMLS_CC, E_WARNING, "Offset is greater than the length of haystack string"); RETURN_FALSE; } p = haystack_dup; - if (needle_len > -offset) { + if (needle_len > (size_t)(-offset)) { e = haystack_dup + haystack->len - needle_len; } else { e = haystack_dup + haystack->len + offset; @@ -2092,7 +2077,7 @@ PHP_FUNCTION(strripos) if (memcmp(e, needle_dup, needle_len) == 0) { efree(haystack_dup); efree(needle_dup); - RETURN_INT(e - p + (offset > 0 ? offset : 0)); + RETURN_LONG(e - p + (offset > 0 ? offset : 0)); } e--; } @@ -2110,7 +2095,7 @@ PHP_FUNCTION(strrchr) zval *needle; zend_string *haystack; const char *found = NULL; - php_int_t found_offset; + zend_long found_offset; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Sz", &haystack, &needle) == FAILURE) { return; @@ -2138,12 +2123,12 @@ PHP_FUNCTION(strrchr) /* {{{ php_chunk_split */ -static zend_string *php_chunk_split(char *src, php_size_t srclen, char *end, php_size_t endlen, php_size_t chunklen) +static zend_string *php_chunk_split(char *src, size_t srclen, char *end, size_t endlen, size_t chunklen) { char *p, *q; - php_size_t chunks; /* complete chunks! */ - php_size_t restlen; - php_size_t out_len; + size_t chunks; /* complete chunks! */ + size_t restlen; + size_t out_len; zend_string *dest; chunks = srclen / chunklen; @@ -2162,7 +2147,7 @@ static zend_string *php_chunk_split(char *src, php_size_t srclen, char *end, php } out_len += srclen + 1; - dest = STR_ALLOC(out_len * sizeof(char), 0); + dest = zend_string_alloc(out_len * sizeof(char), 0); for (p = src, q = dest->val; p < (src + srclen - chunklen + 1); ) { memcpy(q, p, chunklen); @@ -2192,11 +2177,11 @@ PHP_FUNCTION(chunk_split) { zend_string *str; char *end = "\r\n"; - int endlen = 2; - php_int_t chunklen = 76; + size_t endlen = 2; + zend_long chunklen = 76; zend_string *result; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S|is", &str, &chunklen, &end, &endlen) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S|ls", &str, &chunklen, &end, &endlen) == FAILURE) { return; } @@ -2205,9 +2190,9 @@ PHP_FUNCTION(chunk_split) RETURN_FALSE; } - if (chunklen > str->len) { + if ((size_t)chunklen > str->len) { /* to maintain BC, we must return original string + ending */ - result = STR_ALLOC(endlen + str->len, 0); + result = zend_string_alloc(endlen + str->len, 0); memcpy(result->val, str->val, str->len); memcpy(result->val + str->len, end, endlen); result->val[result->len] = '\0'; @@ -2218,7 +2203,7 @@ PHP_FUNCTION(chunk_split) RETURN_EMPTY_STRING(); } - result = php_chunk_split(str->val, str->len, end, endlen, chunklen); + result = php_chunk_split(str->val, str->len, end, endlen, (size_t)chunklen); if (result) { RETURN_STR(result); @@ -2233,39 +2218,39 @@ PHP_FUNCTION(chunk_split) PHP_FUNCTION(substr) { zend_string *str; - php_int_t l = 0, f; + zend_long l = 0, f; int argc = ZEND_NUM_ARGS(); #ifndef FAST_ZPP - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Si|i", &str, &f, &l) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Sl|l", &str, &f, &l) == FAILURE) { return; } #else ZEND_PARSE_PARAMETERS_START(2, 3) Z_PARAM_STR(str) - Z_PARAM_INT(f) + Z_PARAM_LONG(f) Z_PARAM_OPTIONAL - Z_PARAM_INT(l) + Z_PARAM_LONG(l) ZEND_PARSE_PARAMETERS_END(); #endif if (argc > 2) { - if ((l < 0 && -l > str->len)) { + if ((l < 0 && (size_t)(-l) > str->len)) { RETURN_FALSE; - } else if (l > (php_int_t)str->len) { + } else if (l > (zend_long)str->len) { l = str->len; } } else { l = str->len; } - if (f > (php_int_t)str->len) { + if (f > (zend_long)str->len) { RETURN_FALSE; } else if (f < 0 && -f > str->len) { f = 0; } - if (l < 0 && (l + (php_int_t)str->len - f) < 0) { + if (l < 0 && (l + (zend_long)str->len - f) < 0) { RETURN_FALSE; } @@ -2273,7 +2258,7 @@ PHP_FUNCTION(substr) * of the string */ if (f < 0) { - f = (php_int_t)str->len + f; + f = (zend_long)str->len + f; if (f < 0) { f = 0; } @@ -2283,17 +2268,17 @@ PHP_FUNCTION(substr) * needed to stop that many chars from the end of the string */ if (l < 0) { - l = ((php_int_t)str->len - f) + l; + l = ((zend_long)str->len - f) + l; if (l < 0) { l = 0; } } - if (f >= (php_int_t)str->len) { + if (f >= (zend_long)str->len) { RETURN_FALSE; } - if ((f + l) > (php_int_t)str->len) { + if ((f + l) > (zend_long)str->len) { l = str->len - f; } @@ -2309,8 +2294,8 @@ PHP_FUNCTION(substr_replace) zval *from; zval *len = NULL; zval *repl; - php_int_t l = 0; /* l and f should be size_t, however this needs much closer below logic investigation.*/ - php_int_t f; + zend_long l = 0; /* l and f should be size_t, however this needs much closer below logic investigation.*/ + zend_long f; int argc = ZEND_NUM_ARGS(); zend_string *result; @@ -2328,16 +2313,16 @@ PHP_FUNCTION(substr_replace) convert_to_string_ex(repl); } if (Z_TYPE_P(from) != IS_ARRAY) { - convert_to_int_ex(from); + convert_to_long_ex(from); } if (argc > 3) { if (Z_TYPE_P(len) != IS_ARRAY) { - l = zval_get_int(len); + l = zval_get_long(len); } } else { if (Z_TYPE_P(str) != IS_ARRAY) { - l = Z_STRSIZE_P(str); + l = Z_STRLEN_P(str); } } @@ -2347,79 +2332,79 @@ PHP_FUNCTION(substr_replace) (argc == 4 && Z_TYPE_P(from) != Z_TYPE_P(len)) ) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "'from' and 'len' should be of same type - numerical or array "); - RETURN_STR(STR_COPY(Z_STR_P(str))); + RETURN_STR(zend_string_copy(Z_STR_P(str))); } if (argc == 4 && Z_TYPE_P(from) == IS_ARRAY) { if (zend_hash_num_elements(Z_ARRVAL_P(from)) != zend_hash_num_elements(Z_ARRVAL_P(len))) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "'from' and 'len' should have the same number of elements"); - RETURN_STR(STR_COPY(Z_STR_P(str))); + RETURN_STR(zend_string_copy(Z_STR_P(str))); } } } if (Z_TYPE_P(str) != IS_ARRAY) { if (Z_TYPE_P(from) != IS_ARRAY) { - php_size_t repl_len = 0; + size_t repl_len = 0; - f = Z_IVAL_P(from); + f = Z_LVAL_P(from); /* if "from" position is negative, count start position from the end * of the string */ if (f < 0) { - f = Z_STRSIZE_P(str) + f; + f = Z_STRLEN_P(str) + f; if (f < 0) { f = 0; } - } else if (f > Z_STRSIZE_P(str)) { - f = Z_STRSIZE_P(str); + } else if (f > Z_STRLEN_P(str)) { + f = Z_STRLEN_P(str); } /* if "length" position is negative, set it to the length * needed to stop that many chars from the end of the string */ if (l < 0) { - l = (Z_STRSIZE_P(str) - f) + l; + l = (Z_STRLEN_P(str) - f) + l; if (l < 0) { l = 0; } } - if (f > Z_STRSIZE_P(str) || (f < 0 && -f > Z_STRSIZE_P(str))) { + if (f > Z_STRLEN_P(str) || (f < 0 && -f > Z_STRLEN_P(str))) { RETURN_FALSE; - } else if (l > Z_STRSIZE_P(str) || (l < 0 && -l > Z_STRSIZE_P(str))) { - l = Z_STRSIZE_P(str); + } else if (l > Z_STRLEN_P(str) || (l < 0 && -l > Z_STRLEN_P(str))) { + l = Z_STRLEN_P(str); } - if ((f + l) > Z_STRSIZE_P(str)) { - l = Z_STRSIZE_P(str) - f; + if ((f + l) > Z_STRLEN_P(str)) { + l = Z_STRLEN_P(str) - f; } if (Z_TYPE_P(repl) == IS_ARRAY) { zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(repl), &pos_repl); if (NULL != (tmp_repl = zend_hash_get_current_data_ex(Z_ARRVAL_P(repl), &pos_repl))) { convert_to_string_ex(tmp_repl); - repl_len = Z_STRSIZE_P(tmp_repl); + repl_len = Z_STRLEN_P(tmp_repl); } } else { - repl_len = Z_STRSIZE_P(repl); + repl_len = Z_STRLEN_P(repl); } - result = STR_ALLOC(Z_STRSIZE_P(str) - l + repl_len, 0); + result = zend_string_alloc(Z_STRLEN_P(str) - l + repl_len, 0); memcpy(result->val, Z_STRVAL_P(str), f); if (repl_len) { memcpy((result->val + f), (Z_TYPE_P(repl) == IS_ARRAY ? Z_STRVAL_P(tmp_repl) : Z_STRVAL_P(repl)), repl_len); } - memcpy((result->val + f + repl_len), Z_STRVAL_P(str) + f + l, Z_STRSIZE_P(str) - f - l); + memcpy((result->val + f + repl_len), Z_STRVAL_P(str) + f + l, Z_STRLEN_P(str) - f - l); result->val[result->len] = '\0'; RETURN_NEW_STR(result); } else { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Functionality of 'from' and 'len' as arrays is not implemented"); - RETURN_STR(STR_COPY(Z_STR_P(str))); + RETURN_STR(zend_string_copy(Z_STR_P(str))); } } else { /* str is array of strings */ zend_string *str_index = NULL; - php_size_t result_len; - php_uint_t num_index; + size_t result_len; + zend_ulong num_index; array_init(return_value); @@ -2458,57 +2443,57 @@ PHP_FUNCTION(substr_replace) if (Z_TYPE_P(from) == IS_ARRAY) { if (NULL != (tmp_from = zend_hash_get_current_data_ex(Z_ARRVAL_P(from), &pos_from))) { - f = zval_get_int(tmp_from); + f = zval_get_long(tmp_from); if (f < 0) { - f = Z_STRSIZE_P(orig_str) + f; + f = Z_STRLEN_P(orig_str) + f; if (f < 0) { f = 0; } - } else if (f > Z_STRSIZE_P(orig_str)) { - f = Z_STRSIZE_P(orig_str); + } else if (f > Z_STRLEN_P(orig_str)) { + f = Z_STRLEN_P(orig_str); } zend_hash_move_forward_ex(Z_ARRVAL_P(from), &pos_from); } else { f = 0; } } else { - f = Z_IVAL_P(from); + f = Z_LVAL_P(from); if (f < 0) { - f = Z_STRSIZE_P(orig_str) + f; + f = Z_STRLEN_P(orig_str) + f; if (f < 0) { f = 0; } - } else if (f > Z_STRSIZE_P(orig_str)) { - f = Z_STRSIZE_P(orig_str); + } else if (f > Z_STRLEN_P(orig_str)) { + f = Z_STRLEN_P(orig_str); } } if (argc > 3 && Z_TYPE_P(len) == IS_ARRAY) { if (NULL != (tmp_len = zend_hash_get_current_data_ex(Z_ARRVAL_P(len), &pos_len))) { - l = zval_get_int(tmp_len); + l = zval_get_long(tmp_len); zend_hash_move_forward_ex(Z_ARRVAL_P(len), &pos_len); } else { - l = Z_STRSIZE_P(orig_str); + l = Z_STRLEN_P(orig_str); } } else if (argc > 3) { - l = Z_IVAL_P(len); + l = Z_LVAL_P(len); } else { - l = Z_STRSIZE_P(orig_str); + l = Z_STRLEN_P(orig_str); } if (l < 0) { - l = (Z_STRSIZE_P(orig_str) - f) + l; + l = (Z_STRLEN_P(orig_str) - f) + l; if (l < 0) { l = 0; } } - if ((f + l) > Z_STRSIZE_P(orig_str)) { - l = Z_STRSIZE_P(orig_str) - f; + if ((f + l) > Z_STRLEN_P(orig_str)) { + l = Z_STRLEN_P(orig_str) - f; } - result_len = Z_STRSIZE_P(orig_str) - l; + result_len = Z_STRLEN_P(orig_str) - l; if (Z_TYPE_P(repl) == IS_ARRAY) { if (NULL != (tmp_repl = zend_hash_get_current_data_ex(Z_ARRVAL_P(repl), &pos_repl))) { @@ -2533,30 +2518,30 @@ PHP_FUNCTION(substr_replace) } */ - result_len += Z_STRSIZE_P(repl_str); + result_len += Z_STRLEN_P(repl_str); zend_hash_move_forward_ex(Z_ARRVAL_P(repl), &pos_repl); - result = STR_ALLOC(result_len, 0); + result = zend_string_alloc(result_len, 0); memcpy(result->val, Z_STRVAL_P(orig_str), f); - memcpy((result->val + f), Z_STRVAL_P(repl_str), Z_STRSIZE_P(repl_str)); - memcpy((result->val + f + Z_STRSIZE_P(repl_str)), Z_STRVAL_P(orig_str) + f + l, Z_STRSIZE_P(orig_str) - f - l); + memcpy((result->val + f), Z_STRVAL_P(repl_str), Z_STRLEN_P(repl_str)); + memcpy((result->val + f + Z_STRLEN_P(repl_str)), Z_STRVAL_P(orig_str) + f + l, Z_STRLEN_P(orig_str) - f - l); if(Z_TYPE_P(tmp_repl) != IS_STRING) { zval_dtor(repl_str); } } else { - result = STR_ALLOC(result_len, 0); + result = zend_string_alloc(result_len, 0); memcpy(result->val, Z_STRVAL_P(orig_str), f); - memcpy((result->val + f), Z_STRVAL_P(orig_str) + f + l, Z_STRSIZE_P(orig_str) - f - l); + memcpy((result->val + f), Z_STRVAL_P(orig_str) + f + l, Z_STRLEN_P(orig_str) - f - l); } } else { - result_len += Z_STRSIZE_P(repl); + result_len += Z_STRLEN_P(repl); - result = STR_ALLOC(result_len, 0); + result = zend_string_alloc(result_len, 0); memcpy(result->val, Z_STRVAL_P(orig_str), f); - memcpy((result->val + f), Z_STRVAL_P(repl), Z_STRSIZE_P(repl)); - memcpy((result->val + f + Z_STRSIZE_P(repl)), Z_STRVAL_P(orig_str) + f + l, Z_STRSIZE_P(orig_str) - f - l); + memcpy((result->val + f), Z_STRVAL_P(repl), Z_STRLEN_P(repl)); + memcpy((result->val + f + Z_STRLEN_P(repl)), Z_STRVAL_P(orig_str) + f + l, Z_STRLEN_P(orig_str) - f - l); } result->val[result->len] = '\0'; @@ -2564,7 +2549,7 @@ PHP_FUNCTION(substr_replace) if (str_index) { zval tmp; - ZVAL_STR(&tmp, result); + ZVAL_NEW_STR(&tmp, result); zend_symtable_update(Z_ARRVAL_P(return_value), str_index, &tmp); } else { add_index_str(return_value, num_index, result); @@ -2600,7 +2585,7 @@ PHP_FUNCTION(quotemeta) RETURN_FALSE; } - str = STR_ALLOC(2 * old->len, 0); + str = zend_string_alloc(2 * old->len, 0); for (p = old->val, q = str->val; p != old_end; p++) { c = *p; @@ -2625,7 +2610,7 @@ PHP_FUNCTION(quotemeta) *q = '\0'; - RETURN_NEW_STR(STR_REALLOC(str, q - str->val, 0)); + RETURN_NEW_STR(zend_string_realloc(str, q - str->val, 0)); } /* }}} */ @@ -2633,8 +2618,8 @@ PHP_FUNCTION(quotemeta) Returns ASCII value of character */ PHP_FUNCTION(ord) { - char *str; - int str_len; + char *str; + size_t str_len; #ifndef FAST_ZPP if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &str_len) == FAILURE) { @@ -2646,7 +2631,7 @@ PHP_FUNCTION(ord) ZEND_PARSE_PARAMETERS_END(); #endif - RETURN_INT((unsigned char) str[0]); + RETURN_LONG((unsigned char) str[0]); } /* }}} */ @@ -2654,14 +2639,14 @@ PHP_FUNCTION(ord) Converts ASCII code to a character */ PHP_FUNCTION(chr) { - php_int_t c; + zend_long c; char temp[2]; if (ZEND_NUM_ARGS() != 1) { WRONG_PARAM_COUNT; } - if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "i", &c) == FAILURE) { + if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "l", &c) == FAILURE) { c = 0; } @@ -2743,7 +2728,7 @@ PHP_FUNCTION(ucwords) zend_string *str; char *delims = " \t\r\n\f\v"; register char *r, *r_end; - int delims_len = 6; + size_t delims_len = 6; char mask[256]; #ifndef FAST_ZPP @@ -2768,7 +2753,7 @@ PHP_FUNCTION(ucwords) r = Z_STRVAL_P(return_value); *r = toupper((unsigned char) *r); - for (r_end = r + Z_STRSIZE_P(return_value) - 1; r < r_end; ) { + for (r_end = r + Z_STRLEN_P(return_value) - 1; r < r_end; ) { if (mask[(unsigned char)*r++]) { *r = toupper((unsigned char) *r); } @@ -2778,9 +2763,9 @@ PHP_FUNCTION(ucwords) /* {{{ php_strtr */ -PHPAPI char *php_strtr(char *str, php_size_t len, char *str_from, char *str_to, php_size_t trlen) +PHPAPI char *php_strtr(char *str, size_t len, char *str_from, char *str_to, size_t trlen) { - php_size_t i; + size_t i; unsigned char xlat[256]; if ((trlen < 1) || (len < 1)) { @@ -2811,14 +2796,14 @@ static int php_strtr_key_compare(const void *a, const void *b TSRMLS_DC) /* {{{ /* }}} */ /* {{{ php_strtr_array */ -static void php_strtr_array(zval *return_value, char *str, php_size_t slen, HashTable *pats TSRMLS_DC) +static void php_strtr_array(zval *return_value, char *str, size_t slen, HashTable *pats TSRMLS_DC) { - php_uint_t num_key; + zend_ulong num_key; zend_string *str_key; - php_size_t len, pos, found; + size_t len, pos, found; int num_keys = 0; - php_size_t minlen = 128*1024; - php_size_t maxlen = 0; + size_t minlen = 128*1024; + size_t maxlen = 0; HashTable str_hash, num_hash; zval *entry, tmp, dummy; char *key; @@ -2856,7 +2841,7 @@ static void php_strtr_array(zval *return_value, char *str, php_size_t slen, Hash zend_hash_init(&str_hash, zend_hash_num_elements(pats), NULL, NULL, 0); ZEND_HASH_FOREACH_KEY_VAL(pats, num_key, str_key, entry) { if (UNEXPECTED(!str_key)) { - ZVAL_INT(&tmp, num_key); + ZVAL_LONG(&tmp, num_key); convert_to_string(&tmp); str_key = Z_STR(tmp); len = str_key->len; @@ -2912,10 +2897,10 @@ static void php_strtr_array(zval *return_value, char *str, php_size_t slen, Hash entry = zend_hash_str_find(pats, key, len); if (entry != NULL) { zend_string *str = zval_get_string(entry); - smart_str_appendl(&result, str->val, str->len); + smart_str_append(&result, str); pos += len; found = 1; - STR_RELEASE(str); + zend_string_release(str); break; } } ZEND_HASH_FOREACH_END(); @@ -2937,10 +2922,10 @@ static void php_strtr_array(zval *return_value, char *str, php_size_t slen, Hash entry = zend_hash_str_find(pats, key, len); if (entry != NULL) { zend_string *str = zval_get_string(entry); - smart_str_appendl(&result, str->val, str->len); + smart_str_append(&result, str); pos += len; found = 1; - STR_RELEASE(str); + zend_string_release(str); break; } } @@ -2966,7 +2951,7 @@ PHP_FUNCTION(strtr) { zval *from; char *str, *to = NULL; - int str_len, to_len = 0; + size_t str_len, to_len = 0; int ac = ZEND_NUM_ARGS(); #ifndef FAST_ZPP @@ -3000,10 +2985,10 @@ PHP_FUNCTION(strtr) ZVAL_STRINGL(return_value, str, str_len); php_strtr(Z_STRVAL_P(return_value), - Z_STRSIZE_P(return_value), + Z_STRLEN_P(return_value), Z_STRVAL_P(from), to, - MIN(Z_STRSIZE_P(from), + MIN(Z_STRLEN_P(from), to_len)); } } @@ -3021,7 +3006,7 @@ PHP_FUNCTION(strrev) return; } - n = STR_ALLOC(str->len, 0); + n = zend_string_alloc(str->len, 0); p = n->val; e = str->val + str->len; @@ -3038,12 +3023,12 @@ PHP_FUNCTION(strrev) /* {{{ php_similar_str */ -static void php_similar_str(const char *txt1, php_size_t len1, const char *txt2, php_size_t len2, php_size_t *pos1, php_size_t *pos2, php_size_t *max) +static void php_similar_str(const char *txt1, size_t len1, const char *txt2, size_t len2, size_t *pos1, size_t *pos2, size_t *max) { char *p, *q; char *end1 = (char *) txt1 + len1; char *end2 = (char *) txt2 + len2; - php_size_t l; + size_t l; *max = 0; for (p = (char *) txt1; p < end1; p++) { @@ -3061,10 +3046,10 @@ static void php_similar_str(const char *txt1, php_size_t len1, const char *txt2, /* {{{ php_similar_char */ -static php_size_t php_similar_char(const char *txt1, php_size_t len1, const char *txt2, php_size_t len2) +static size_t php_similar_char(const char *txt1, size_t len1, const char *txt2, size_t len2) { - php_size_t sum; - php_size_t pos1 = 0, pos2 = 0, max; + size_t sum; + size_t pos1 = 0, pos2 = 0, max; php_similar_str(txt1, len1, txt2, len2, &pos1, &pos2, &max); if ((sum = max)) { @@ -3089,7 +3074,7 @@ PHP_FUNCTION(similar_text) zend_string *t1, *t2; zval *percent = NULL; int ac = ZEND_NUM_ARGS(); - php_size_t sim; + size_t sim; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "SS|z/", &t1, &t2, &percent) == FAILURE) { return; @@ -3104,7 +3089,7 @@ PHP_FUNCTION(similar_text) Z_DVAL_P(percent) = 0; } - RETURN_INT(0); + RETURN_LONG(0); } sim = php_similar_char(t1->val, t1->len, t2->val, t2->len); @@ -3113,17 +3098,17 @@ PHP_FUNCTION(similar_text) Z_DVAL_P(percent) = sim * 200.0 / (t1->len + t2->len); } - RETURN_INT(sim); + RETURN_LONG(sim); } /* }}} */ /* {{{ php_stripslashes * * be careful, this edits the string in-place */ -PHPAPI void php_stripslashes(char *str, php_size_t *len TSRMLS_DC) +PHPAPI void php_stripslashes(char *str, size_t *len TSRMLS_DC) { char *s, *t; - php_size_t l; + size_t l; if (len != NULL) { l = *len; @@ -3217,7 +3202,7 @@ PHP_FUNCTION(stripcslashes) } ZVAL_STRINGL(return_value, str->val, str->len); - php_stripcslashes(Z_STRVAL_P(return_value), &Z_STRSIZE_P(return_value)); + php_stripcslashes(Z_STRVAL_P(return_value), &Z_STRLEN_P(return_value)); } /* }}} */ @@ -3232,7 +3217,7 @@ PHP_FUNCTION(stripslashes) } ZVAL_STRINGL(return_value, str->val, str->len); - php_stripslashes(Z_STRVAL_P(return_value), &Z_STRSIZE_P(return_value) TSRMLS_CC); + php_stripslashes(Z_STRVAL_P(return_value), &Z_STRLEN_P(return_value) TSRMLS_CC); } /* }}} */ @@ -3257,10 +3242,10 @@ char *php_strerror(int errnum) /* {{{ php_stripcslashes */ -PHPAPI void php_stripcslashes(char *str, php_size_t *len) +PHPAPI void php_stripcslashes(char *str, size_t *len) { char *source, *target, *end; - php_size_t nlen = *len, i; + size_t nlen = *len, i; char numtmp[4]; for (source=str, end=str+nlen, target=str; source < end; source++) { @@ -3320,14 +3305,14 @@ PHPAPI void php_stripcslashes(char *str, php_size_t *len) /* {{{ php_addcslashes */ -PHPAPI zend_string *php_addcslashes(const char *str, php_size_t length, int should_free, char *what, php_size_t wlength TSRMLS_DC) +PHPAPI zend_string *php_addcslashes(const char *str, size_t length, int should_free, char *what, size_t wlength TSRMLS_DC) { char flags[256]; char *source, *target; char *end; char c; - php_size_t newlen; - zend_string *new_str = STR_ALLOC(4 * (length? length : (length = strlen(str))), 0); + size_t newlen; + zend_string *new_str = zend_string_alloc(4 * (length? length : (length = strlen(str))), 0); if (!wlength) { wlength = strlen(what); @@ -3359,7 +3344,7 @@ PHPAPI zend_string *php_addcslashes(const char *str, php_size_t length, int shou *target = 0; newlen = target - new_str->val; if (newlen < length * 4) { - new_str = STR_REALLOC(new_str, newlen, 0); + new_str = zend_string_realloc(new_str, newlen, 0); } if (should_free) { efree((char*)str); @@ -3370,7 +3355,7 @@ PHPAPI zend_string *php_addcslashes(const char *str, php_size_t length, int shou /* {{{ php_addslashes */ -PHPAPI zend_string *php_addslashes(char *str, php_size_t length, int should_free TSRMLS_DC) +PHPAPI zend_string *php_addslashes(char *str, size_t length, int should_free TSRMLS_DC) { /* maximum string length, worst case situation */ char *source, *target; @@ -3381,7 +3366,7 @@ PHPAPI zend_string *php_addslashes(char *str, php_size_t length, int should_free return STR_EMPTY_ALLOC(); } - new_str = STR_ALLOC(2 * (length ? length : (length = strlen(str))), 0); + new_str = zend_string_alloc(2 * (length ? length : (length = strlen(str))), 0); source = str; end = source + length; target = new_str->val; @@ -3409,7 +3394,7 @@ PHPAPI zend_string *php_addslashes(char *str, php_size_t length, int should_free if (should_free) { efree(str); } - new_str = STR_REALLOC(new_str, target - new_str->val, 0); + new_str = zend_string_realloc(new_str, target - new_str->val, 0); return new_str; } @@ -3423,10 +3408,10 @@ PHPAPI zend_string *php_addslashes(char *str, php_size_t length, int should_free /* {{{ php_char_to_str_ex */ -PHPAPI php_size_t php_char_to_str_ex(char *str, php_size_t len, char from, char *to, php_size_t to_len, zval *result, int case_sensitivity, php_size_t *replace_count) +PHPAPI size_t php_char_to_str_ex(char *str, size_t len, char from, char *to, size_t to_len, zval *result, int case_sensitivity, size_t *replace_count) { - php_size_t char_count = 0; - php_size_t replaced = 0; + size_t char_count = 0; + size_t replaced = 0; char *source, *target, *tmp, *source_end=str+len, *tmp_end = NULL; if (case_sensitivity) { @@ -3449,9 +3434,9 @@ PHPAPI php_size_t php_char_to_str_ex(char *str, php_size_t len, char from, char } if (to_len > 0) { - ZVAL_NEW_STR(result, STR_SAFE_ALLOC(char_count, to_len - 1, len, 0)); + ZVAL_NEW_STR(result, zend_string_safe_alloc(char_count, to_len - 1, len, 0)); } else { - ZVAL_NEW_STR(result, STR_ALLOC(len - char_count, 0)); + ZVAL_NEW_STR(result, zend_string_alloc(len - char_count, 0)); } target = Z_STRVAL_P(result); @@ -3496,7 +3481,7 @@ PHPAPI php_size_t php_char_to_str_ex(char *str, php_size_t len, char from, char /* {{{ php_char_to_str */ -PHPAPI php_size_t php_char_to_str(char *str, php_size_t len, char from, char *to, php_size_t to_len, zval *result) +PHPAPI size_t php_char_to_str(char *str, size_t len, char from, char *to, size_t to_len, zval *result) { return php_char_to_str_ex(str, len, from, to, to_len, result, 1, NULL); } @@ -3504,8 +3489,8 @@ PHPAPI php_size_t php_char_to_str(char *str, php_size_t len, char from, char *to /* {{{ php_str_to_str_ex */ -PHPAPI zend_string *php_str_to_str_ex(char *haystack, php_size_t length, - char *needle, php_size_t needle_len, char *str, php_size_t str_len, int case_sensitivity, php_size_t *replace_count) +PHPAPI zend_string *php_str_to_str_ex(char *haystack, size_t length, + char *needle, size_t needle_len, char *str, size_t str_len, int case_sensitivity, size_t *replace_count) { zend_string *new_str; @@ -3514,7 +3499,7 @@ PHPAPI zend_string *php_str_to_str_ex(char *haystack, php_size_t length, char *e, *s, *p, *r; if (needle_len == str_len) { - new_str = STR_INIT(haystack, length, 0); + new_str = zend_string_init(haystack, length, 0); if (case_sensitivity) { end = new_str->val + length; @@ -3549,9 +3534,9 @@ PHPAPI zend_string *php_str_to_str_ex(char *haystack, php_size_t length, } if (str_len < needle_len) { - new_str = STR_ALLOC(length, 0); + new_str = zend_string_alloc(length, 0); } else { - php_size_t count = 0; + size_t count = 0; char *o, *n, *endp; if (case_sensitivity) { @@ -3575,10 +3560,10 @@ PHPAPI zend_string *php_str_to_str_ex(char *haystack, php_size_t length, if (needle_dup) { efree(needle_dup); } - new_str = STR_INIT(haystack, length, 0); + new_str = zend_string_init(haystack, length, 0); return new_str; } else { - new_str = STR_ALLOC(count * (str_len - needle_len) + length, 0); + new_str = zend_string_alloc(count * (str_len - needle_len) + length, 0); } } @@ -3628,12 +3613,12 @@ PHPAPI zend_string *php_str_to_str_ex(char *haystack, php_size_t length, *e = '\0'; - new_str = STR_REALLOC(new_str, e - s, 0); + new_str = zend_string_realloc(new_str, e - s, 0); return new_str; } } else if (needle_len > length) { nothing_todo: - new_str = STR_INIT(haystack, length, 0); + new_str = zend_string_init(haystack, length, 0); return new_str; } else { if (case_sensitivity && memcmp(haystack, needle, length)) { @@ -3656,7 +3641,7 @@ nothing_todo: efree(l_needle); } - new_str = STR_INIT(str, str_len, 0); + new_str = zend_string_init(str, str_len, 0); if (replace_count) { (*replace_count)++; @@ -3669,7 +3654,7 @@ nothing_todo: /* {{{ php_str_to_str */ -PHPAPI zend_string *php_str_to_str(char *haystack, php_size_t length, char *needle, php_size_t needle_len, char *str, php_size_t str_len) +PHPAPI zend_string *php_str_to_str(char *haystack, size_t length, char *needle, size_t needle_len, char *str, size_t str_len) { return php_str_to_str_ex(haystack, length, needle, needle_len, str, str_len, 1, NULL); } @@ -3677,14 +3662,14 @@ PHPAPI zend_string *php_str_to_str(char *haystack, php_size_t length, char *need /* {{{ php_str_replace_in_subject */ -static void php_str_replace_in_subject(zval *search, zval *replace, zval *subject, zval *result, int case_sensitivity, php_size_t *replace_count TSRMLS_DC) +static void php_str_replace_in_subject(zval *search, zval *replace, zval *subject, zval *result, int case_sensitivity, size_t *replace_count TSRMLS_DC) { zval *search_entry, *replace_entry = NULL, temp_result, tmp_subject; char *replace_value = NULL; - php_size_t replace_len = 0; + size_t replace_len = 0; HashPosition pos; /* Make sure we're dealing with strings. */ @@ -3697,7 +3682,7 @@ static void php_str_replace_in_subject(zval *search, zval *replace, zval *subjec convert_to_string_ex(&tmp_subject); subject = &tmp_subject; } - if (Z_STRSIZE_P(subject) == 0) { + if (Z_STRLEN_P(subject) == 0) { zval_ptr_dtor(&tmp_subject); ZVAL_EMPTY_STRING(result); return; @@ -3714,7 +3699,7 @@ static void php_str_replace_in_subject(zval *search, zval *replace, zval *subjec } else { /* Set replacement value to the passed one */ replace_value = Z_STRVAL_P(replace); - replace_len = Z_STRSIZE_P(replace); + replace_len = Z_STRLEN_P(replace); } /* For each entry in the search array, get the entry */ @@ -3722,7 +3707,7 @@ static void php_str_replace_in_subject(zval *search, zval *replace, zval *subjec /* Make sure we're dealing with strings. */ SEPARATE_ZVAL(search_entry); convert_to_string(search_entry); - if (Z_STRSIZE_P(search_entry) == 0) { + if (Z_STRLEN_P(search_entry) == 0) { if (Z_TYPE_P(replace) == IS_ARRAY) { zend_hash_move_forward_ex(Z_ARRVAL_P(replace), &pos); } @@ -3738,7 +3723,7 @@ static void php_str_replace_in_subject(zval *search, zval *replace, zval *subjec /* Set replacement value to the one we got from array */ replace_value = Z_STRVAL_P(replace_entry); - replace_len = Z_STRSIZE_P(replace_entry); + replace_len = Z_STRLEN_P(replace_entry); zend_hash_move_forward_ex(Z_ARRVAL_P(replace), &pos); } else { @@ -3748,44 +3733,44 @@ static void php_str_replace_in_subject(zval *search, zval *replace, zval *subjec } } - if (Z_STRSIZE_P(search_entry) == 1) { + if (Z_STRLEN_P(search_entry) == 1) { php_char_to_str_ex(Z_STRVAL_P(result), - Z_STRSIZE_P(result), + Z_STRLEN_P(result), Z_STRVAL_P(search_entry)[0], replace_value, replace_len, &temp_result, case_sensitivity, replace_count); - } else if (Z_STRSIZE_P(search_entry) > 1) { - ZVAL_STR(&temp_result, php_str_to_str_ex(Z_STRVAL_P(result), Z_STRSIZE_P(result), - Z_STRVAL_P(search_entry), Z_STRSIZE_P(search_entry), + } else if (Z_STRLEN_P(search_entry) > 1) { + ZVAL_STR(&temp_result, php_str_to_str_ex(Z_STRVAL_P(result), Z_STRLEN_P(result), + Z_STRVAL_P(search_entry), Z_STRLEN_P(search_entry), replace_value, replace_len, case_sensitivity, replace_count)); } - STR_FREE(Z_STR_P(result)); + zend_string_free(Z_STR_P(result)); Z_STR_P(result) = Z_STR(temp_result); Z_TYPE_INFO_P(result) = Z_TYPE_INFO(temp_result); - if (Z_STRSIZE_P(result) == 0) { + if (Z_STRLEN_P(result) == 0) { zval_ptr_dtor(&tmp_subject); return; } } ZEND_HASH_FOREACH_END(); } else { - if (Z_STRSIZE_P(search) == 1) { + if (Z_STRLEN_P(search) == 1) { php_char_to_str_ex(Z_STRVAL_P(subject), - Z_STRSIZE_P(subject), + Z_STRLEN_P(subject), Z_STRVAL_P(search)[0], Z_STRVAL_P(replace), - Z_STRSIZE_P(replace), + Z_STRLEN_P(replace), result, case_sensitivity, replace_count); - } else if (Z_STRSIZE_P(search) > 1) { - ZVAL_STR(result, php_str_to_str_ex(Z_STRVAL_P(subject), Z_STRSIZE_P(subject), - Z_STRVAL_P(search), Z_STRSIZE_P(search), - Z_STRVAL_P(replace), Z_STRSIZE_P(replace), case_sensitivity, replace_count)); + } else if (Z_STRLEN_P(search) > 1) { + ZVAL_STR(result, php_str_to_str_ex(Z_STRVAL_P(subject), Z_STRLEN_P(subject), + Z_STRVAL_P(search), Z_STRLEN_P(search), + Z_STRVAL_P(replace), Z_STRLEN_P(replace), case_sensitivity, replace_count)); } else { ZVAL_DUP(result, subject); } @@ -3801,8 +3786,8 @@ static void php_str_replace_common(INTERNAL_FUNCTION_PARAMETERS, int case_sensit zval *subject, *search, *replace, *subject_entry, *zcount = NULL; zval result; zend_string *string_key; - php_uint_t num_key; - php_int_t count = 0; + zend_ulong num_key; + size_t count = 0; int argc = ZEND_NUM_ARGS(); #ifndef FAST_ZPP @@ -3856,7 +3841,7 @@ static void php_str_replace_common(INTERNAL_FUNCTION_PARAMETERS, int case_sensit } if (argc > 3) { zval_dtor(zcount); - ZVAL_INT(zcount, count); + ZVAL_LONG(zcount, count); } } /* }}} */ @@ -3886,13 +3871,13 @@ static void php_hebrev(INTERNAL_FUNCTION_PARAMETERS, int convert_newlines) { char *str; char *heb_str, *tmp, *target; - int block_start, block_end, block_type, block_length, i; - php_int_t max_chars=0; - int begin, end, char_count, orig_begin; - int str_len; + size_t block_start, block_end, block_type, block_length, i; + zend_long max_chars=0; + size_t begin, end, char_count, orig_begin; + size_t str_len; zend_string *broken_str; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|i", &str, &str_len, &max_chars) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &str, &str_len, &max_chars) == FAILURE) { return; } @@ -3923,8 +3908,8 @@ static void php_hebrev(INTERNAL_FUNCTION_PARAMETERS, int convert_newlines) block_end++; block_length++; } - for (i = block_start; i<= block_end; i++) { - *target = str[i]; + for (i = block_start+1; i<= block_end+1; i++) { + *target = str[i-1]; switch (*target) { case '(': *target = ')'; @@ -3972,8 +3957,8 @@ static void php_hebrev(INTERNAL_FUNCTION_PARAMETERS, int convert_newlines) tmp--; block_end--; } - for (i = block_end; i >= block_start; i--) { - *target = str[i]; + for (i = block_end+1; i >= block_start+1; i--) { + *target = str[i-1]; target--; } block_type = _HEB_BLOCK_TYPE_HEB; @@ -3982,13 +3967,13 @@ static void php_hebrev(INTERNAL_FUNCTION_PARAMETERS, int convert_newlines) } while (block_end < str_len-1); - broken_str = STR_ALLOC(str_len, 0); + broken_str = zend_string_alloc(str_len, 0); begin = end = str_len-1; target = broken_str->val; while (1) { char_count=0; - while ((!max_chars || char_count < max_chars) && begin > 0) { + while ((!max_chars || (max_chars > 0 && char_count < max_chars)) && begin > 0) { char_count++; begin--; if (begin <= 0 || _isnewline(heb_str[begin])) { @@ -3999,8 +3984,8 @@ static void php_hebrev(INTERNAL_FUNCTION_PARAMETERS, int convert_newlines) break; } } - if (char_count == max_chars) { /* try to avoid breaking words */ - int new_char_count=char_count, new_begin=begin; + if (max_chars >= 0 && char_count == max_chars) { /* try to avoid breaking words */ + size_t new_char_count=char_count, new_begin=begin; while (new_char_count > 0) { if (_isblank(heb_str[new_begin]) || _isnewline(heb_str[new_begin])) { @@ -4042,7 +4027,7 @@ static void php_hebrev(INTERNAL_FUNCTION_PARAMETERS, int convert_newlines) if (convert_newlines) { php_char_to_str(broken_str->val, broken_str->len,'\n', "<br />\n", 7, return_value); - STR_FREE(broken_str); + zend_string_free(broken_str); } else { RETURN_NEW_STR(broken_str); } @@ -4073,7 +4058,7 @@ PHP_FUNCTION(nl2br) char *tmp; zend_string *str; char *end, *target; - php_size_t repl_cnt = 0; + size_t repl_cnt = 0; zend_bool is_xhtml = 1; zend_string *result; @@ -4109,7 +4094,7 @@ PHP_FUNCTION(nl2br) { size_t repl_len = is_xhtml ? (sizeof("<br />") - 1) : (sizeof("<br>") - 1); - result = STR_ALLOC(repl_cnt * repl_len + str->len, 0); + result = zend_string_alloc(repl_cnt * repl_len + str->len, 0); target = result->val; } @@ -4154,7 +4139,7 @@ PHP_FUNCTION(strip_tags) zend_string *str; zval *allow=NULL; char *allowed_tags=NULL; - int allowed_tags_len=0; + size_t allowed_tags_len=0; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S|z", &str, &allow) == FAILURE) { return; @@ -4164,20 +4149,20 @@ PHP_FUNCTION(strip_tags) if (allow != NULL) { convert_to_string_ex(allow); // TODO: reimplement to avoid reallocation ??? - if (IS_INTERNED(Z_STR_P(allow))) { - allowed_tags = estrndup(Z_STRVAL_P(allow), Z_STRSIZE_P(allow)); - allowed_tags_len = Z_STRSIZE_P(allow); + if (!Z_REFCOUNTED_P(allow)) { + allowed_tags = estrndup(Z_STRVAL_P(allow), Z_STRLEN_P(allow)); + allowed_tags_len = Z_STRLEN_P(allow); } else { allowed_tags = Z_STRVAL_P(allow); - allowed_tags_len = Z_STRSIZE_P(allow); + allowed_tags_len = Z_STRLEN_P(allow); } } - buf = STR_INIT(str->val, str->len, 0); + buf = zend_string_init(str->val, str->len, 0); buf->len = php_strip_tags_ex(buf->val, str->len, NULL, allowed_tags, allowed_tags_len, 0); // TODO: reimplement to avoid reallocation ??? - if (allow && IS_INTERNED(Z_STR_P(allow))) { + if (allow && !Z_REFCOUNTED_P(allow)) { efree(allowed_tags); } RETURN_STR(buf); @@ -4199,8 +4184,8 @@ PHP_FUNCTION(setlocale) } #ifdef HAVE_SETLOCALE - if (Z_TYPE_P(pcategory) == IS_INT) { - cat = Z_IVAL_P(pcategory); + if (Z_TYPE_P(pcategory) == IS_LONG) { + cat = Z_LVAL_P(pcategory); } else { /* FIXME: The following behaviour should be removed. */ char *category; @@ -4261,7 +4246,7 @@ PHP_FUNCTION(setlocale) loc = NULL; } else { loc = Z_STRVAL(tmp); - if (Z_STRSIZE(tmp) >= 255) { + if (Z_STRLEN(tmp) >= 255) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Specified locale name is too long"); zval_dtor(&tmp); break; @@ -4273,7 +4258,7 @@ PHP_FUNCTION(setlocale) if (retval) { /* Remember if locale was changed */ if (loc) { -//??? STR_FREE(BG(locale_string)); +//??? zend_string_free(BG(locale_string)); if (BG(locale_string)) { efree(BG(locale_string)); } @@ -4304,7 +4289,7 @@ PHP_FUNCTION(parse_str) char *arg; zval *arrayArg = NULL; char *res = NULL; - int arglen; + size_t arglen; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|z/", &arg, &arglen, &arrayArg) == FAILURE) { return; @@ -4341,7 +4326,7 @@ PHP_FUNCTION(parse_str) * 0 start tag * 1 first non-whitespace char seen */ -int php_tag_find(char *tag, php_size_t len, char *set) { +int php_tag_find(char *tag, size_t len, char *set) { char c, *n, *t; int state=0, done=0; char *norm; @@ -4396,7 +4381,7 @@ int php_tag_find(char *tag, php_size_t len, char *set) { } /* }}} */ -PHPAPI php_size_t php_strip_tags(char *rbuf, php_size_t len, int *stateptr, char *allow, php_size_t allow_len) /* {{{ */ +PHPAPI size_t php_strip_tags(char *rbuf, size_t len, int *stateptr, char *allow, size_t allow_len) /* {{{ */ { return php_strip_tags_ex(rbuf, len, stateptr, allow, allow_len, 0); } @@ -4422,11 +4407,12 @@ PHPAPI php_size_t php_strip_tags(char *rbuf, php_size_t len, int *stateptr, char swm: Added ability to strip <?xml tags without assuming it PHP code. */ -PHPAPI size_t php_strip_tags_ex(char *rbuf, php_size_t len, int *stateptr, char *allow, php_size_t allow_len, zend_bool allow_tag_spaces) +PHPAPI size_t php_strip_tags_ex(char *rbuf, size_t len, int *stateptr, char *allow, size_t allow_len, zend_bool allow_tag_spaces) { char *tbuf, *buf, *p, *tp, *rp, c, lc; - int br, i=0, depth=0, in_q = 0; - int state = 0, pos; + int br, depth=0, in_q = 0; + int state = 0; + size_t pos, i = 0; char *allow_free = NULL; if (stateptr) @@ -4703,7 +4689,7 @@ PHP_FUNCTION(str_getcsv) zend_string *str; char delim = ',', enc = '"', esc = '\\'; char *delim_str = NULL, *enc_str = NULL, *esc_str = NULL; - int delim_len = 0, enc_len = 0, esc_len = 0; + size_t delim_len = 0, enc_len = 0, esc_len = 0; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S|sss", &str, &delim_str, &delim_len, &enc_str, &enc_len, &esc_str, &esc_len) == FAILURE) { @@ -4723,11 +4709,11 @@ PHP_FUNCTION(str_getcsv) PHP_FUNCTION(str_repeat) { zend_string *input_str; /* Input string */ - php_int_t mult; /* Multiplier */ + zend_long mult; /* Multiplier */ zend_string *result; /* Resulting string */ size_t result_len; /* Length of the resulting string */ - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Si", &input_str, &mult) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Sl", &input_str, &mult) == FAILURE) { return; } @@ -4742,7 +4728,7 @@ PHP_FUNCTION(str_repeat) RETURN_EMPTY_STRING(); /* Initialize the result string */ - result = STR_SAFE_ALLOC(input_str->len, mult, 0, 0); + result = zend_string_safe_alloc(input_str->len, mult, 0, 0); result_len = input_str->len * mult; /* Heavy optimization for situations where input string is 1 byte long */ @@ -4775,14 +4761,14 @@ PHP_FUNCTION(count_chars) { zend_string *input; int chars[256]; - php_int_t mymode=0; + zend_long mymode=0; unsigned char *buf; int inx; char retstr[256]; - php_size_t retlen=0; - php_size_t tmp = 0; + size_t retlen=0; + size_t tmp = 0; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S|i", &input, &mymode) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S|l", &input, &mymode) == FAILURE) { return; } @@ -4807,16 +4793,16 @@ PHP_FUNCTION(count_chars) for (inx = 0; inx < 256; inx++) { switch (mymode) { case 0: - add_index_int(return_value, inx, chars[inx]); + add_index_long(return_value, inx, chars[inx]); break; case 1: if (chars[inx] != 0) { - add_index_int(return_value, inx, chars[inx]); + add_index_long(return_value, inx, chars[inx]); } break; case 2: if (chars[inx] == 0) { - add_index_int(return_value, inx, chars[inx]); + add_index_long(return_value, inx, chars[inx]); } break; case 3: @@ -4848,7 +4834,7 @@ static void php_strnatcmp(INTERNAL_FUNCTION_PARAMETERS, int fold_case) return; } - RETURN_INT(strnatcmp_ex(s1->val, s1->len, + RETURN_LONG(strnatcmp_ex(s1->val, s1->len, s2->val, s2->len, fold_case)); } @@ -4859,10 +4845,10 @@ PHPAPI int string_natural_compare_function_ex(zval *result, zval *op1, zval *op2 zend_string *str1 = zval_get_string(op1); zend_string *str2 = zval_get_string(op2); - ZVAL_INT(result, strnatcmp_ex(str1->val, str1->len, str2->val, str2->len, case_insensitive)); + ZVAL_LONG(result, strnatcmp_ex(str1->val, str1->len, str2->val, str2->len, case_insensitive)); - STR_RELEASE(str1); - STR_RELEASE(str2); + zend_string_release(str1); + zend_string_release(str2); return SUCCESS; } /* }}} */ @@ -4913,14 +4899,14 @@ PHP_FUNCTION(localeconv) len = strlen(currlocdata.grouping); for (i = 0; i < len; i++) { - add_index_int(&grouping, i, currlocdata.grouping[i]); + add_index_long(&grouping, i, currlocdata.grouping[i]); } /* Grab the monetary grouping data out of the array */ len = strlen(currlocdata.mon_grouping); for (i = 0; i < len; i++) { - add_index_int(&mon_grouping, i, currlocdata.mon_grouping[i]); + add_index_long(&mon_grouping, i, currlocdata.mon_grouping[i]); } add_assoc_string(return_value, "decimal_point", currlocdata.decimal_point); @@ -4931,21 +4917,21 @@ PHP_FUNCTION(localeconv) add_assoc_string(return_value, "mon_thousands_sep", currlocdata.mon_thousands_sep); add_assoc_string(return_value, "positive_sign", currlocdata.positive_sign); add_assoc_string(return_value, "negative_sign", currlocdata.negative_sign); - add_assoc_int( return_value, "int_frac_digits", currlocdata.int_frac_digits); - add_assoc_int( return_value, "frac_digits", currlocdata.frac_digits); - add_assoc_int( return_value, "p_cs_precedes", currlocdata.p_cs_precedes); - add_assoc_int( return_value, "p_sep_by_space", currlocdata.p_sep_by_space); - add_assoc_int( return_value, "n_cs_precedes", currlocdata.n_cs_precedes); - add_assoc_int( return_value, "n_sep_by_space", currlocdata.n_sep_by_space); - add_assoc_int( return_value, "p_sign_posn", currlocdata.p_sign_posn); - add_assoc_int( return_value, "n_sign_posn", currlocdata.n_sign_posn); + add_assoc_long( return_value, "int_frac_digits", currlocdata.int_frac_digits); + add_assoc_long( return_value, "frac_digits", currlocdata.frac_digits); + add_assoc_long( return_value, "p_cs_precedes", currlocdata.p_cs_precedes); + add_assoc_long( return_value, "p_sep_by_space", currlocdata.p_sep_by_space); + add_assoc_long( return_value, "n_cs_precedes", currlocdata.n_cs_precedes); + add_assoc_long( return_value, "n_sep_by_space", currlocdata.n_sep_by_space); + add_assoc_long( return_value, "p_sign_posn", currlocdata.p_sign_posn); + add_assoc_long( return_value, "n_sign_posn", currlocdata.n_sign_posn); } #else /* Ok, it doesn't look like we have locale info floating around, so I guess it wouldn't hurt to just go ahead and return the POSIX locale information? */ - add_index_int(&grouping, 0, -1); - add_index_int(&mon_grouping, 0, -1); + add_index_long(&grouping, 0, -1); + add_index_long(&mon_grouping, 0, -1); add_assoc_string(return_value, "decimal_point", "\x2E"); add_assoc_string(return_value, "thousands_sep", ""); @@ -4955,14 +4941,14 @@ PHP_FUNCTION(localeconv) add_assoc_string(return_value, "mon_thousands_sep", ""); add_assoc_string(return_value, "positive_sign", ""); add_assoc_string(return_value, "negative_sign", ""); - add_assoc_int( return_value, "int_frac_digits", CHAR_MAX); - add_assoc_int( return_value, "frac_digits", CHAR_MAX); - add_assoc_int( return_value, "p_cs_precedes", CHAR_MAX); - add_assoc_int( return_value, "p_sep_by_space", CHAR_MAX); - add_assoc_int( return_value, "n_cs_precedes", CHAR_MAX); - add_assoc_int( return_value, "n_sep_by_space", CHAR_MAX); - add_assoc_int( return_value, "p_sign_posn", CHAR_MAX); - add_assoc_int( return_value, "n_sign_posn", CHAR_MAX); + add_assoc_long( return_value, "int_frac_digits", CHAR_MAX); + add_assoc_long( return_value, "frac_digits", CHAR_MAX); + add_assoc_long( return_value, "p_cs_precedes", CHAR_MAX); + add_assoc_long( return_value, "p_sep_by_space", CHAR_MAX); + add_assoc_long( return_value, "n_cs_precedes", CHAR_MAX); + add_assoc_long( return_value, "n_sep_by_space", CHAR_MAX); + add_assoc_long( return_value, "p_sign_posn", CHAR_MAX); + add_assoc_long( return_value, "n_sign_posn", CHAR_MAX); #endif zend_hash_str_update(Z_ARRVAL_P(return_value), "grouping", sizeof("grouping")-1, &grouping); @@ -4983,13 +4969,13 @@ PHP_FUNCTION(strnatcasecmp) PHP_FUNCTION(substr_count) { char *haystack, *needle; - php_int_t offset = 0, length = 0; + zend_long offset = 0, length = 0; int ac = ZEND_NUM_ARGS(); int count = 0; - int haystack_len, needle_len; + size_t haystack_len, needle_len; char *p, *endp, cmp; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|ii", &haystack, &haystack_len, &needle, &needle_len, &offset, &length) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|ll", &haystack, &haystack_len, &needle, &needle_len, &offset, &length) == FAILURE) { return; } @@ -5006,8 +4992,8 @@ PHP_FUNCTION(substr_count) RETURN_FALSE; } - if (offset > haystack_len) { - php_error_docref(NULL TSRMLS_CC, E_WARNING, "Offset value " ZEND_INT_FMT " exceeds string length", offset); + if ((size_t)offset > haystack_len) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Offset value " ZEND_LONG_FMT " exceeds string length", offset); RETURN_FALSE; } p += offset; @@ -5019,7 +5005,7 @@ PHP_FUNCTION(substr_count) RETURN_FALSE; } if (length > (haystack_len - offset)) { - php_error_docref(NULL TSRMLS_CC, E_WARNING, "Length value " ZEND_INT_FMT " exceeds string length", length); + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Length value " ZEND_LONG_FMT " exceeds string length", length); RETURN_FALSE; } endp = p + length; @@ -5039,7 +5025,7 @@ PHP_FUNCTION(substr_count) } } - RETURN_INT(count); + RETURN_LONG(count); } /* }}} */ @@ -5049,36 +5035,27 @@ PHP_FUNCTION(str_pad) { /* Input arguments */ zend_string *input; /* Input string */ - php_int_t pad_length; /* Length to pad to */ + zend_long pad_length; /* Length to pad to */ /* Helper variables */ size_t num_pad_chars; /* Number of padding characters (total - input size) */ - zend_string *pad_str, *pad_str_save; /* Pointer to padding string */ - php_int_t pad_type_val = STR_PAD_RIGHT; /* The padding type value */ - int i, left_pad=0, right_pad=0; + char *pad_str = " "; /* Pointer to padding string */ + size_t pad_str_len = 1; + zend_long pad_type_val = STR_PAD_RIGHT; /* The padding type value */ + size_t i, left_pad=0, right_pad=0; zend_string *result = NULL; /* Resulting string */ - pad_str = pad_str_save = STR_INIT(" ", 1, 1); - if (!pad_str) { - return; - } - - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Si|Si", &input, &pad_length, &pad_str, &pad_type_val) == FAILURE) { - STR_FREE(pad_str); + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Sl|sl", &input, &pad_length, &pad_str, &pad_str_len, &pad_type_val) == FAILURE) { return; } - if (pad_str != pad_str_save) { - STR_FREE(pad_str_save); - } - /* If resulting string turns out to be shorter than input string, we simply copy the input and return. */ - if (pad_length < 0 || pad_length <= input->len) { + if (pad_length < 0 || (size_t)pad_length <= input->len) { RETURN_STRINGL(input->val, input->len); } - if (pad_str->len == 0) { + if (pad_str_len == 0) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Padding string cannot be empty"); return; } @@ -5094,7 +5071,7 @@ PHP_FUNCTION(str_pad) return; } - result = STR_ALLOC(input->len + num_pad_chars, 0); + result = zend_string_alloc(input->len + num_pad_chars, 0); result->len = 0; /* We need to figure out the left/right padding lengths. */ @@ -5117,7 +5094,7 @@ PHP_FUNCTION(str_pad) /* First we pad on the left. */ for (i = 0; i < left_pad; i++) - result->val[result->len++] = pad_str->val[i % pad_str->len]; + result->val[result->len++] = pad_str[i % pad_str_len]; /* Then we copy the input string. */ memcpy(result->val + result->len, input->val, input->len); @@ -5125,7 +5102,7 @@ PHP_FUNCTION(str_pad) /* Finally, we pad on the right. */ for (i = 0; i < right_pad; i++) - result->val[result->len++] = pad_str->val[i % pad_str->len]; + result->val[result->len++] = pad_str[i % pad_str_len]; result->val[result->len] = '\0'; @@ -5139,7 +5116,8 @@ PHP_FUNCTION(sscanf) { zval *args = NULL; char *str, *format; - int str_len, format_len, result, num_args = 0; + size_t str_len, format_len; + int result, num_args = 0; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss*", &str, &str_len, &format, &format_len, &args, &num_args) == FAILURE) { @@ -5169,13 +5147,13 @@ PHP_FUNCTION(str_rot13) RETVAL_STRINGL(arg->val, arg->len); - php_strtr(Z_STRVAL_P(return_value), Z_STRSIZE_P(return_value), rot13_from, rot13_to, 52); + php_strtr(Z_STRVAL_P(return_value), Z_STRLEN_P(return_value), rot13_from, rot13_to, 52); } /* }}} */ -static void php_string_shuffle(char *str, php_int_t len TSRMLS_DC) /* {{{ */ +static void php_string_shuffle(char *str, zend_long len TSRMLS_DC) /* {{{ */ { - php_int_t n_elems, rnd_idx, n_left; + zend_long n_elems, rnd_idx, n_left; char temp; /* The implementation is stolen from array_data_shuffle */ /* Thus the characteristics of the randomization are the same */ @@ -5210,8 +5188,8 @@ PHP_FUNCTION(str_shuffle) } RETVAL_STRINGL(arg->val, arg->len); - if (Z_STRSIZE_P(return_value) > 1) { - php_string_shuffle(Z_STRVAL_P(return_value), (php_int_t) Z_STRSIZE_P(return_value) TSRMLS_CC); + if (Z_STRLEN_P(return_value) > 1) { + php_string_shuffle(Z_STRVAL_P(return_value), (zend_long) Z_STRLEN_P(return_value) TSRMLS_CC); } } /* }}} */ @@ -5231,10 +5209,10 @@ PHP_FUNCTION(str_word_count) { zend_string *str; char *char_list = NULL, *p, *e, *s, ch[256]; - int char_list_len = 0, word_count = 0; - php_int_t type = 0; + size_t char_list_len = 0, word_count = 0; + zend_long type = 0; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S|is", &str, &type, &char_list, &char_list_len) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S|ls", &str, &type, &char_list, &char_list_len) == FAILURE) { return; } @@ -5248,12 +5226,12 @@ PHP_FUNCTION(str_word_count) break; case 0: if (!str->len) { - RETURN_INT(0); + RETURN_LONG(0); } /* nothing to be done */ break; default: - php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid format value " ZEND_INT_FMT, type); + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid format value " ZEND_LONG_FMT, type); RETURN_FALSE; } @@ -5296,7 +5274,7 @@ PHP_FUNCTION(str_word_count) } if (!type) { - RETURN_INT(word_count); + RETURN_LONG(word_count); } } @@ -5307,7 +5285,7 @@ PHP_FUNCTION(str_word_count) Convert monetary value(s) to string */ PHP_FUNCTION(money_format) { - int format_len = 0; + size_t format_len = 0; char *format, *p, *e; double value; zend_bool check = 0; @@ -5331,14 +5309,14 @@ PHP_FUNCTION(money_format) } } - str = STR_ALLOC(format_len + 1024, 0); + str = zend_string_alloc(format_len + 1024, 0); if ((str->len = strfmon(str->val, str->len, format, value)) < 0) { - STR_FREE(str); + zend_string_free(str); RETURN_FALSE; } str->val[str->len] = '\0'; - RETURN_NEW_STR(STR_REALLOC(str, str->len, 0)); + RETURN_NEW_STR(zend_string_realloc(str, str->len, 0)); } /* }}} */ #endif @@ -5348,11 +5326,11 @@ PHP_FUNCTION(money_format) PHP_FUNCTION(str_split) { zend_string *str; - php_int_t split_length = 1; + zend_long split_length = 1; char *p; - php_size_t n_reg_segments; + size_t n_reg_segments; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S|i", &str, &split_length) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S|l", &str, &split_length) == FAILURE) { return; } @@ -5362,7 +5340,7 @@ PHP_FUNCTION(str_split) } - if (0 == str->len || split_length >= str->len) { + if (0 == str->len || (size_t)split_length >= str->len) { array_init_size(return_value, 1); add_next_index_stringl(return_value, str->val, str->len); return; @@ -5417,17 +5395,17 @@ PHP_FUNCTION(strpbrk) PHP_FUNCTION(substr_compare) { zend_string *s1, *s2; - php_int_t offset, len=0; + zend_long offset, len=0; zend_bool cs=0; - php_size_t cmp_len; + size_t cmp_len; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "SSi|ib", &s1, &s2, &offset, &len, &cs) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "SSl|lb", &s1, &s2, &offset, &len, &cs) == FAILURE) { RETURN_FALSE; } if (ZEND_NUM_ARGS() >= 4 && len <= 0) { if (len == 0) { - RETURN_INT(0L); + RETURN_LONG(0L); } else { php_error_docref(NULL TSRMLS_CC, E_WARNING, "The length must be greater than or equal to zero"); RETURN_FALSE; @@ -5439,17 +5417,17 @@ PHP_FUNCTION(substr_compare) offset = (offset < 0) ? 0 : offset; } - if (offset >= s1->len) { + if ((size_t)offset >= s1->len) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "The start position cannot exceed initial string length"); RETURN_FALSE; } - cmp_len = (php_size_t) (len ? len : MAX(s2->len, (s1->len - offset))); + cmp_len = (size_t) (len ? len : MAX(s2->len, (s1->len - offset))); if (!cs) { - RETURN_INT(zend_binary_strncmp(s1->val + offset, (s1->len - offset), s2->val, s2->len, cmp_len)); + RETURN_LONG(zend_binary_strncmp(s1->val + offset, (s1->len - offset), s2->val, s2->len, cmp_len)); } else { - RETURN_INT(zend_binary_strncasecmp_l(s1->val + offset, (s1->len - offset), s2->val, s2->len, cmp_len)); + RETURN_LONG(zend_binary_strncasecmp_l(s1->val + offset, (s1->len - offset), s2->val, s2->len, cmp_len)); } } /* }}} */ |