embedaddon/php/ext/standard/string.c - diff

Return to string.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / standard

Diff for /embedaddon/php/ext/standard/string.c between versions 1.1 and 1.1.1.2

version 1.1, 2012/02/21 23:48:02	version 1.1.1.2, 2012/05/29 12:34:43
Line 36	Line 36
#ifdef HAVE_MONETARY_H	#ifdef HAVE_MONETARY_H
# include <monetary.h>	# include <monetary.h>
#endif	#endif
/*	/*
* This define is here because some versions of libintl redefine setlocale	* This define is here because some versions of libintl redefine setlocale
* to point to libintl_setlocale. That's a ridiculous thing to do as far	* to point to libintl_setlocale. That's a ridiculous thing to do as far
* as I am concerned, but with this define and the subsequent undef we	* as I am concerned, but with this define and the subsequent undef we
Line 89 void register_string_constants(INIT_FUNC_ARGS)	Line 89 void register_string_constants(INIT_FUNC_ARGS)
REGISTER_LONG_CONSTANT("PATHINFO_FILENAME", PHP_PATHINFO_FILENAME, CONST_CS \| CONST_PERSISTENT);	REGISTER_LONG_CONSTANT("PATHINFO_FILENAME", PHP_PATHINFO_FILENAME, CONST_CS \| CONST_PERSISTENT);

#ifdef HAVE_LOCALECONV	#ifdef HAVE_LOCALECONV
/* If last members of struct lconv equal CHAR_MAX, no grouping is done */	/* If last members of struct lconv equal CHAR_MAX, no grouping is done */

/* This is bad, but since we are going to be hardcoding in the POSIX stuff anyway... */	/* This is bad, but since we are going to be hardcoding in the POSIX stuff anyway... */
# ifndef HAVE_LIMITS_H	# ifndef HAVE_LIMITS_H
Line 110 void register_string_constants(INIT_FUNC_ARGS)	Line 110 void register_string_constants(INIT_FUNC_ARGS)
REGISTER_LONG_CONSTANT("LC_MESSAGES", LC_MESSAGES, CONST_CS \| CONST_PERSISTENT);	REGISTER_LONG_CONSTANT("LC_MESSAGES", LC_MESSAGES, CONST_CS \| CONST_PERSISTENT);
# endif	# endif
#endif	#endif

}	}
/* }}} */	/* }}} */

Line 132 static char php_bin2hex(const unsigned char old, con	Line 132 static char php_bin2hex(const unsigned char old, con
size_t i, j;	size_t i, j;

result = (unsigned char ) safe_emalloc(oldlen 2, sizeof(char), 1);	result = (unsigned char ) safe_emalloc(oldlen 2, sizeof(char), 1);

for (i = j = 0; i < oldlen; i++) {	for (i = j = 0; i < oldlen; i++) {
result[j++] = hexconvtab[old[i] >> 4];	result[j++] = hexconvtab[old[i] >> 4];
result[j++] = hexconvtab[old[i] & 15];	result[j++] = hexconvtab[old[i] & 15];
}	}
result[j] = '\0';	result[j] = '\0';

if (newlen)	if (newlen)
newlen = oldlen 2 * sizeof(char);	newlen = oldlen 2 * sizeof(char);

return (char *)result;	return (char *)result;
}	}
/* }}} */	/* }}} */

	/* {{{ php_hex2bin
	*/
	static char php_hex2bin(const unsigned char old, const size_t oldlen, size_t *newlen)
	{
	size_t target_length = oldlen >> 1;
	register unsigned char str = (unsigned char )safe_emalloc(target_length, sizeof(char), 1);
	size_t i, j;
	for (i = j = 0; i < target_length; i++) {
	char c = old[j++];
	if (c >= '0' && c <= '9') {
	str[i] = (c - '0') << 4;
	} else if (c >= 'a' && c <= 'f') {
	str[i] = (c - 'a' + 10) << 4;
	} else if (c >= 'A' && c <= 'F') {
	str[i] = (c - 'A' + 10) << 4;
	} else {
	efree(str);
	return NULL;
	}
	c = old[j++];
	if (c >= '0' && c <= '9') {
	str[i] \|= c - '0';
	} else if (c >= 'a' && c <= 'f') {
	str[i] \|= c - 'a' + 10;
	} else if (c >= 'A' && c <= 'F') {
	str[i] \|= c - 'A' + 10;
	} else {
	efree(str);
	return NULL;
	}
	}
	str[target_length] = '\0';

	if (newlen)
	*newlen = target_length;

	return (char *)str;
	}
	/* }}} */

#ifdef HAVE_LOCALECONV	#ifdef HAVE_LOCALECONV
/* {{{ localeconv_r	/* {{{ localeconv_r
* glibc's localeconv is not reentrant, so lets make it so ... sorta */	* glibc's localeconv is not reentrant, so lets make it so ... sorta */
Line 205 PHP_FUNCTION(bin2hex)	Line 245 PHP_FUNCTION(bin2hex)
}	}

result = php_bin2hex((unsigned char *)data, datalen, &newlen);	result = php_bin2hex((unsigned char *)data, datalen, &newlen);

if (!result) {	if (!result) {
RETURN_FALSE;	RETURN_FALSE;
}	}
Line 214 PHP_FUNCTION(bin2hex)	Line 254 PHP_FUNCTION(bin2hex)
}	}
/* }}} */	/* }}} */

	/* {{{ proto string hex2bin(string data)
	Converts the hex representation of data to binary */
	PHP_FUNCTION(hex2bin)
	{
	char result, data;
	size_t newlen;
	int datalen;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &data, &datalen) == FAILURE) {
	return;
	}

	result = php_hex2bin((unsigned char *)data, datalen, &newlen);

	if (!result) {
	RETURN_FALSE;
	}

	RETURN_STRINGL(result, newlen, 0);
	}
	/* }}} */

static void php_spn_common_handler(INTERNAL_FUNCTION_PARAMETERS, int behavior) /* {{{ */	static void php_spn_common_handler(INTERNAL_FUNCTION_PARAMETERS, int behavior) /* {{{ */
{	{
char s11, s22;	char s11, s22;
int len1, len2;	int len1, len2;
long start = 0, len = 0;	long start = 0, len = 0;

if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss\|ll", &s11, &len1,	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss\|ll", &s11, &len1,
&s22, &len2, &start, &len) == FAILURE) {	&s22, &len2, &start, &len) == FAILURE) {
return;	return;
}	}

if (ZEND_NUM_ARGS() < 4) {	if (ZEND_NUM_ARGS() < 4) {
len = len1;	len = len1;
}	}

/* look at substr() function for more information */	/* look at substr() function for more information */

if (start < 0) {	if (start < 0) {
start += len1;	start += len1;
if (start < 0) {	if (start < 0) {
Line 239 static void php_spn_common_handler(INTERNAL_FUNCTION_P	Line 301 static void php_spn_common_handler(INTERNAL_FUNCTION_P
} else if (start > len1) {	} else if (start > len1) {
RETURN_FALSE;	RETURN_FALSE;
}	}

if (len < 0) {	if (len < 0) {
len += (len1 - start);	len += (len1 - start);
if (len < 0) {	if (len < 0) {
len = 0;	len = 0;
}	}
}	}

if (len > len1 - start) {	if (len > len1 - start) {
len = len1 - start;	len = len1 - start;
}	}
Line 266 static void php_spn_common_handler(INTERNAL_FUNCTION_P	Line 328 static void php_spn_common_handler(INTERNAL_FUNCTION_P
s11 + start + len /str1_end/,	s11 + start + len /str1_end/,
s22 + len2 /str2_end/));	s22 + len2 /str2_end/));
}	}

}	}
/* }}} */	/* }}} */

Line 462 PHP_FUNCTION(nl_langinfo)	Line 524 PHP_FUNCTION(nl_langinfo)
{	{
long item;	long item;
char *value;	char *value;

if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &item) == FAILURE) {	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &item) == FAILURE) {
return;	return;
}	}
Line 650 PHP_FUNCTION(strcoll)	Line 712 PHP_FUNCTION(strcoll)
{	{
char s1, s2;	char s1, s2;
int s1len, s2len;	int s1len, s2len;

if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &s1, &s1len, &s2, &s2len) == FAILURE) {	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &s1, &s1len, &s2, &s2len) == FAILURE) {
return;	return;
}	}

RETURN_LONG(strcoll((const char *) s1,	RETURN_LONG(strcoll((const char *) s1,
(const char *) s2));	(const char *) s2));
}	}
/* }}} */	/* }}} */
Line 663 PHP_FUNCTION(strcoll)	Line 725 PHP_FUNCTION(strcoll)

/* {{{ php_charmask	/* {{{ php_charmask
* Fills a 256-byte bytemask with input. You can specify a range like 'a..z',	* Fills a 256-byte bytemask with input. You can specify a range like 'a..z',
* it needs to be incrementing.	* it needs to be incrementing.
* Returns: FAILURE/SUCCESS whether the input was correct (i.e. no range errors)	* Returns: FAILURE/SUCCESS whether the input was correct (i.e. no range errors)
*/	*/
static inline int php_charmask(unsigned char input, int len, char mask TSRMLS_DC)	static inline int php_charmask(unsigned char input, int len, char mask TSRMLS_DC)
Line 674 static inline int php_charmask(unsigned char *input, i	Line 736 static inline int php_charmask(unsigned char *input, i

memset(mask, 0, 256);	memset(mask, 0, 256);
for (end = input+len; input < end; input++) {	for (end = input+len; input < end; input++) {
c=*input;	c=*input;
if ((input+3 < end) && input[1] == '.' && input[2] == '.'	if ((input+3 < end) && input[1] == '.' && input[2] == '.'
&& input[3] >= c) {	&& input[3] >= c) {
memset(mask+c, 1, input[3] - c + 1);	memset(mask+c, 1, input[3] - c + 1);
input+=3;	input+=3;
Line 696 static inline int php_charmask(unsigned char *input, i	Line 758 static inline int php_charmask(unsigned char *input, i
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid '..'-range, '..'-range needs to be incrementing");	php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid '..'-range, '..'-range needs to be incrementing");
result = FAILURE;	result = FAILURE;
continue;	continue;
}	}
/* FIXME: better error (a..b..c is the only left possibility?) */	/* FIXME: better error (a..b..c is the only left possibility?) */
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid '..'-range");	php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid '..'-range");
result = FAILURE;	result = FAILURE;
Line 765 static void php_do_trim(INTERNAL_FUNCTION_PARAMETERS,	Line 827 static void php_do_trim(INTERNAL_FUNCTION_PARAMETERS,
char *str;	char *str;
char *what = NULL;	char *what = NULL;
int str_len, what_len = 0;	int str_len, what_len = 0;

if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s\|s", &str, &str_len, &what, &what_len) == FAILURE) {	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s\|s", &str, &str_len, &what, &what_len) == FAILURE) {
return;	return;
}	}

php_trim(str, str_len, what, what_len, return_value, mode TSRMLS_CC);	php_trim(str, str_len, what, what_len, return_value, mode TSRMLS_CC);
}	}
/* }}} */	/* }}} */
Line 939 PHP_FUNCTION(wordwrap)	Line 1001 PHP_FUNCTION(wordwrap)

/* {{{ php_explode	/* {{{ php_explode
*/	*/
PHPAPI void php_explode(zval delim, zval str, zval *return_value, long limit)	PHPAPI void php_explode(zval delim, zval str, zval *return_value, long limit)
{	{
char p1, p2, *endp;	char p1, p2, *endp;

Line 965 PHPAPI void php_explode(zval delim, zval str, zval *	Line 1027 PHPAPI void php_explode(zval delim, zval str, zval *

/* {{{ php_explode_negative_limit	/* {{{ php_explode_negative_limit
*/	*/
PHPAPI void php_explode_negative_limit(zval delim, zval str, zval *return_value, long limit)	PHPAPI void php_explode_negative_limit(zval delim, zval str, zval *return_value, long limit)
{	{
#define EXPLODE_ALLOC_STEP 64	#define EXPLODE_ALLOC_STEP 64
char p1, p2, *endp;	char p1, p2, *endp;

endp = Z_STRVAL_P(str) + Z_STRLEN_P(str);	endp = Z_STRVAL_P(str) + Z_STRLEN_P(str);

p1 = Z_STRVAL_P(str);	p1 = Z_STRVAL_P(str);
Line 993 PHPAPI void php_explode_negative_limit(zval *delim, zv	Line 1055 PHPAPI void php_explode_negative_limit(zval *delim, zv
}	}
positions[found++] = p1 = p2 + Z_STRLEN_P(delim);	positions[found++] = p1 = p2 + Z_STRLEN_P(delim);
} while ((p2 = php_memnstr(p1, Z_STRVAL_P(delim), Z_STRLEN_P(delim), endp)) != NULL);	} while ((p2 = php_memnstr(p1, Z_STRVAL_P(delim), Z_STRLEN_P(delim), endp)) != NULL);

to_return = limit + found;	to_return = limit + found;
/* limit is at least -1 therefore no need of bounds checking : i will be always less than 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],	add_next_index_stringl(return_value, positions[i],
(positions[i+1] - Z_STRLEN_P(delim)) - positions[i],	(positions[i+1] - Z_STRLEN_P(delim)) - positions[i],
1	1
);	);
Line 1016 PHP_FUNCTION(explode)	Line 1078 PHP_FUNCTION(explode)
int str_len = 0, delim_len = 0;	int str_len = 0, delim_len = 0;
long limit = LONG_MAX; /* No limit */	long limit = LONG_MAX; /* No limit */
zval zdelim, zstr;	zval zdelim, zstr;

if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss\|l", &delim, &delim_len, &str, &str_len, &limit) == FAILURE) {	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss\|l", &delim, &delim_len, &str, &str_len, &limit) == FAILURE) {
return;	return;
}	}

if (delim_len == 0) {	if (delim_len == 0) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Empty delimiter");	php_error_docref(NULL TSRMLS_CC, E_WARNING, "Empty delimiter");
RETURN_FALSE;	RETURN_FALSE;
Line 1031 PHP_FUNCTION(explode)	Line 1093 PHP_FUNCTION(explode)
if (str_len == 0) {	if (str_len == 0) {
if (limit >= 0) {	if (limit >= 0) {
add_next_index_stringl(return_value, "", sizeof("") - 1, 1);	add_next_index_stringl(return_value, "", sizeof("") - 1, 1);
}	}
return;	return;
}	}

Line 1053 PHP_FUNCTION(explode)	Line 1115 PHP_FUNCTION(explode)

/* {{{ php_implode	/* {{{ php_implode
*/	*/
PHPAPI void php_implode(zval delim, zval arr, zval *return_value TSRMLS_DC)	PHPAPI void php_implode(zval delim, zval arr, zval *return_value TSRMLS_DC)
{	{
zval **tmp;	zval **tmp;
HashPosition pos;	HashPosition pos;
Line 1088 PHPAPI void php_implode(zval delim, zval arr, zval *	Line 1150 PHPAPI void php_implode(zval delim, zval arr, zval *
smart_str_appendl(&implstr, "1", sizeof("1")-1);	smart_str_appendl(&implstr, "1", sizeof("1")-1);
}	}
break;	break;

case IS_NULL:	case IS_NULL:
break;	break;

Line 1118 PHPAPI void php_implode(zval delim, zval arr, zval *	Line 1180 PHPAPI void php_implode(zval delim, zval arr, zval *
smart_str_appendl(&implstr, Z_STRVAL(tmp_val), Z_STRLEN(tmp_val));	smart_str_appendl(&implstr, Z_STRVAL(tmp_val), Z_STRLEN(tmp_val));
zval_dtor(&tmp_val);	zval_dtor(&tmp_val);
break;	break;

}	}

if (++i != numelems) {	if (++i != numelems) {
Line 1146 PHP_FUNCTION(implode)	Line 1208 PHP_FUNCTION(implode)
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z\|Z", &arg1, &arg2) == FAILURE) {	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z\|Z", &arg1, &arg2) == FAILURE) {
return;	return;
}	}

if (arg2 == NULL) {	if (arg2 == NULL) {
if (Z_TYPE_PP(arg1) != IS_ARRAY) {	if (Z_TYPE_PP(arg1) != IS_ARRAY) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Argument must be an array");	php_error_docref(NULL TSRMLS_CC, E_WARNING, "Argument must be an array");
Line 1173 PHP_FUNCTION(implode)	Line 1235 PHP_FUNCTION(implode)
return;	return;
}	}
}	}

php_implode(delim, arr, return_value TSRMLS_CC);	php_implode(delim, arr, return_value TSRMLS_CC);

if (arg2 == NULL) {	if (arg2 == NULL) {
Line 1182 PHP_FUNCTION(implode)	Line 1244 PHP_FUNCTION(implode)
}	}
/* }}} */	/* }}} */

#define STRTOK_TABLE(p) BG(strtok_table)[(unsigned char) *p]	#define STRTOK_TABLE(p) BG(strtok_table)[(unsigned char) *p]

/* {{{ proto string strtok([string str,] string token)	/* {{{ proto string strtok([string str,] string token)
Tokenize a string */	Tokenize a string */
PHP_FUNCTION(strtok)	PHP_FUNCTION(strtok)
{	{
char str, tok = NULL;	char str, tok = NULL;
int str_len, tok_len = 0;	int str_len, tok_len = 0;
zval *zv;	zval *zv;

char *token;	char *token;
char *token_end;	char *token_end;
char *p;	char *p;
char *pe;	char *pe;
int skipped = 0;	int skipped = 0;

if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s\|s", &str, &str_len, &tok, &tok_len) == FAILURE) {	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s\|s", &str, &str_len, &tok, &tok_len) == FAILURE) {
return;	return;
}	}
Line 1216 PHP_FUNCTION(strtok)	Line 1278 PHP_FUNCTION(strtok)
BG(strtok_last) = BG(strtok_string) = Z_STRVAL_P(zv);	BG(strtok_last) = BG(strtok_string) = Z_STRVAL_P(zv);
BG(strtok_len) = str_len;	BG(strtok_len) = str_len;
}	}

p = BG(strtok_last); /* Where we start to search */	p = BG(strtok_last); /* Where we start to search */
pe = BG(strtok_string) + BG(strtok_len);	pe = BG(strtok_string) + BG(strtok_len);

if (!p \|\| p >= pe) {	if (!p \|\| p >= pe) {
RETURN_FALSE;	RETURN_FALSE;
}	}

token = tok;	token = tok;
token_end = token + tok_len;	token_end = token + tok_len;

while (token < token_end) {	while (token < token_end) {
STRTOK_TABLE(token++) = 1;	STRTOK_TABLE(token++) = 1;
}	}

/* Skip leading delimiters */	/* Skip leading delimiters */
while (STRTOK_TABLE(p)) {	while (STRTOK_TABLE(p)) {
if (++p >= pe) {	if (++p >= pe) {
Line 1241 PHP_FUNCTION(strtok)	Line 1303 PHP_FUNCTION(strtok)
}	}
skipped++;	skipped++;
}	}

/* We know at this place that p is no delimiter, so skip it /	/* We know at this place that p is no delimiter, so skip it /
while (++p < pe) {	while (++p < pe) {
if (STRTOK_TABLE(p)) {	if (STRTOK_TABLE(p)) {
goto return_token;	goto return_token;
}	}
}	}

if (p - BG(strtok_last)) {	if (p - BG(strtok_last)) {
return_token:	return_token:
RETVAL_STRINGL(BG(strtok_last) + skipped, (p - BG(strtok_last)) - skipped, 1);	RETVAL_STRINGL(BG(strtok_last) + skipped, (p - BG(strtok_last)) - skipped, 1);
Line 1261 return_token:	Line 1323 return_token:
/* Restore table -- usually faster then memset'ing the table on every invocation */	/* Restore table -- usually faster then memset'ing the table on every invocation */
restore:	restore:
token = tok;	token = tok;

while (token < token_end) {	while (token < token_end) {
STRTOK_TABLE(token++) = 0;	STRTOK_TABLE(token++) = 0;
}	}
Line 1273 restore:	Line 1335 restore:
PHPAPI char php_strtoupper(char s, size_t len)	PHPAPI char php_strtoupper(char s, size_t len)
{	{
unsigned char c, e;	unsigned char c, e;

c = (unsigned char *)s;	c = (unsigned char *)s;
e = (unsigned char *)c+len;	e = (unsigned char *)c+len;

Line 1291 PHP_FUNCTION(strtoupper)	Line 1353 PHP_FUNCTION(strtoupper)
{	{
char *arg;	char *arg;
int arglen;	int arglen;

if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &arg, &arglen) == FAILURE) {	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &arg, &arglen) == FAILURE) {
return;	return;
}	}

arg = estrndup(arg, arglen);	arg = estrndup(arg, arglen);
php_strtoupper(arg, arglen);	php_strtoupper(arg, arglen);
RETURN_STRINGL(arg, arglen, 0);	RETURN_STRINGL(arg, arglen, 0);
}	}
/* }}} */	/* }}} */
Line 1307 PHP_FUNCTION(strtoupper)	Line 1369 PHP_FUNCTION(strtoupper)
PHPAPI char php_strtolower(char s, size_t len)	PHPAPI char php_strtolower(char s, size_t len)
{	{
unsigned char c, e;	unsigned char c, e;

c = (unsigned char *)s;	c = (unsigned char *)s;
e = c+len;	e = c+len;

Line 1325 PHP_FUNCTION(strtolower)	Line 1387 PHP_FUNCTION(strtolower)
{	{
char *str;	char *str;
int arglen;	int arglen;

if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &arglen) == FAILURE) {	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &arglen) == FAILURE) {
return;	return;
}	}
Line 1338 PHP_FUNCTION(strtolower)	Line 1400 PHP_FUNCTION(strtolower)

/* {{{ php_basename	/* {{{ php_basename
*/	*/
PHPAPI void php_basename(char s, size_t len, char suffix, size_t sufflen, char *p_ret, size_t p_len TSRMLS_DC)	PHPAPI void php_basename(const char s, size_t len, char suffix, size_t sufflen, char *p_ret, size_t p_len TSRMLS_DC)
{	{
char ret = NULL, c, comp, cend;	char ret = NULL, c, comp, cend;
size_t inc_len, cnt;	size_t inc_len, cnt;
int state;	int state;

c = comp = cend = s;	c = comp = cend = (char*)s;
cnt = len;	cnt = len;
state = 0;	state = 0;
while (cnt > 0) {	while (cnt > 0) {
Line 1354 PHPAPI void php_basename(char s, size_t len, char su	Line 1416 PHPAPI void php_basename(char s, size_t len, char su
case -2:	case -2:
case -1:	case -1:
inc_len = 1;	inc_len = 1;
php_mblen(NULL, 0);	php_ignore_value(php_mblen(NULL, 0));
break;	break;
case 0:	case 0:
goto quit_loop;	goto quit_loop;
Line 1446 PHP_FUNCTION(dirname)	Line 1508 PHP_FUNCTION(dirname)
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &str_len) == FAILURE) {	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &str_len) == FAILURE) {
return;	return;
}	}

ret = estrndup(str, str_len);	ret = estrndup(str, str_len);
ret_len = php_dirname(ret, str_len);	ret_len = php_dirname(ret, str_len);

Line 1469 PHP_FUNCTION(pathinfo)	Line 1531 PHP_FUNCTION(pathinfo)
}	}

have_basename = ((opt & PHP_PATHINFO_BASENAME) == PHP_PATHINFO_BASENAME);	have_basename = ((opt & PHP_PATHINFO_BASENAME) == PHP_PATHINFO_BASENAME);

MAKE_STD_ZVAL(tmp);	MAKE_STD_ZVAL(tmp);
array_init(tmp);	array_init(tmp);

if ((opt & PHP_PATHINFO_DIRNAME) == PHP_PATHINFO_DIRNAME) {	if ((opt & PHP_PATHINFO_DIRNAME) == PHP_PATHINFO_DIRNAME) {
ret = estrndup(path, path_len);	ret = estrndup(path, path_len);
php_dirname(ret, path_len);	php_dirname(ret, path_len);
Line 1482 PHP_FUNCTION(pathinfo)	Line 1544 PHP_FUNCTION(pathinfo)
efree(ret);	efree(ret);
ret = NULL;	ret = NULL;
}	}

if (have_basename) {	if (have_basename) {
php_basename(path, path_len, NULL, 0, &ret, &ret_len TSRMLS_CC);	php_basename(path, path_len, NULL, 0, &ret, &ret_len TSRMLS_CC);
add_assoc_stringl(tmp, "basename", ret, ret_len, 0);	add_assoc_stringl(tmp, "basename", ret, ret_len, 0);
}	}

if ((opt & PHP_PATHINFO_EXTENSION) == PHP_PATHINFO_EXTENSION) {	if ((opt & PHP_PATHINFO_EXTENSION) == PHP_PATHINFO_EXTENSION) {
char *p;	const char *p;
int idx;	int idx;

if (!have_basename) {	if (!have_basename) {
Line 1503 PHP_FUNCTION(pathinfo)	Line 1565 PHP_FUNCTION(pathinfo)
add_assoc_stringl(tmp, "extension", ret + idx + 1, ret_len - idx - 1, 1);	add_assoc_stringl(tmp, "extension", ret + idx + 1, ret_len - idx - 1, 1);
}	}
}	}

if ((opt & PHP_PATHINFO_FILENAME) == PHP_PATHINFO_FILENAME) {	if ((opt & PHP_PATHINFO_FILENAME) == PHP_PATHINFO_FILENAME) {
char *p;	const char *p;
int idx;	int idx;

/* Have we alrady looked up the basename? */	/* Have we alrady looked up the basename? */
Line 1632 PHP_FUNCTION(stristr)	Line 1694 PHP_FUNCTION(stristr)
char *haystack_dup;	char *haystack_dup;
char needle_char[2];	char needle_char[2];
zend_bool part = 0;	zend_bool part = 0;

if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz\|b", &haystack, &haystack_len, &needle, &part) == FAILURE) {	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz\|b", &haystack, &haystack_len, &needle, &part) == FAILURE) {
return;	return;
}	}
Line 1665 PHP_FUNCTION(stristr)	Line 1727 PHP_FUNCTION(stristr)
RETVAL_STRINGL(haystack, found_offset, 1);	RETVAL_STRINGL(haystack, found_offset, 1);
} else {	} else {
RETVAL_STRINGL(haystack + found_offset, haystack_len - found_offset, 1);	RETVAL_STRINGL(haystack + found_offset, haystack_len - found_offset, 1);
}	}
} else {	} else {
RETVAL_FALSE;	RETVAL_FALSE;
}	}
Line 1685 PHP_FUNCTION(strstr)	Line 1747 PHP_FUNCTION(strstr)
char needle_char[2];	char needle_char[2];
long found_offset;	long found_offset;
zend_bool part = 0;	zend_bool part = 0;

if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz\|b", &haystack, &haystack_len, &needle, &part) == FAILURE) {	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz\|b", &haystack, &haystack_len, &needle, &part) == FAILURE) {
return;	return;
}	}
Line 1732 PHP_FUNCTION(strpos)	Line 1794 PHP_FUNCTION(strpos)
char needle_char[2];	char needle_char[2];
long offset = 0;	long offset = 0;
int haystack_len;	int haystack_len;

if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz\|l", &haystack, &haystack_len, &needle, &offset) == FAILURE) {	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz\|l", &haystack, &haystack_len, &needle, &offset) == FAILURE) {
return;	return;
}	}
Line 1816 PHP_FUNCTION(stripos)	Line 1878 PHP_FUNCTION(stripos)
}	}
needle_char[0] = tolower(needle_char[0]);	needle_char[0] = tolower(needle_char[0]);
needle_char[1] = '\0';	needle_char[1] = '\0';
found = php_memnstr(haystack_dup + offset,	found = php_memnstr(haystack_dup + offset,
needle_char,	needle_char,
sizeof(needle_char) - 1,	sizeof(needle_char) - 1,
haystack_dup + haystack_len);	haystack_dup + haystack_len);
}	}

Line 1940 PHP_FUNCTION(strripos)	Line 2002 PHP_FUNCTION(strripos)
}	}

if (needle_len == 1) {	if (needle_len == 1) {
/* Single character search can shortcut memcmps	/* Single character search can shortcut memcmps
Can also avoid tolower emallocs */	Can also avoid tolower emallocs */
if (offset >= 0) {	if (offset >= 0) {
if (offset > haystack_len) {	if (offset > haystack_len) {
Line 2018 PHP_FUNCTION(strrchr)	Line 2080 PHP_FUNCTION(strrchr)
{	{
zval *needle;	zval *needle;
char *haystack;	char *haystack;
char *found = NULL;	const char *found = NULL;
long found_offset;	long found_offset;
int haystack_len;	int haystack_len;

if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz", &haystack, &haystack_len, &needle) == FAILURE) {	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz", &haystack, &haystack_len, &needle) == FAILURE) {
return;	return;
}	}
Line 2054 static char php_chunk_split(char src, int srclen, ch	Line 2116 static char php_chunk_split(char src, int srclen, ch
char p, q;	char p, q;
int chunks; /* complete chunks! */	int chunks; /* complete chunks! */
int restlen;	int restlen;
int out_len;	int out_len;

chunks = srclen / chunklen;	chunks = srclen / chunklen;
restlen = srclen - chunks * chunklen; /* srclen % chunklen */	restlen = srclen - chunks * chunklen; /* srclen % chunklen */
Line 2100 static char php_chunk_split(char src, int srclen, ch	Line 2162 static char php_chunk_split(char src, int srclen, ch

/* {{{ proto string chunk_split(string str [, int chunklen [, string ending]])	/* {{{ proto string chunk_split(string str [, int chunklen [, string ending]])
Returns split line */	Returns split line */
PHP_FUNCTION(chunk_split)	PHP_FUNCTION(chunk_split)
{	{
char *str;	char *str;
char *result;	char *result;
Line 2109 PHP_FUNCTION(chunk_split)	Line 2171 PHP_FUNCTION(chunk_split)
long chunklen = 76;	long chunklen = 76;
int result_len;	int result_len;
int str_len;	int str_len;

if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s\|ls", &str, &str_len, &chunklen, &end, &endlen) == FAILURE) {	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s\|ls", &str, &str_len, &chunklen, &end, &endlen) == FAILURE) {
return;	return;
}	}
Line 2125 PHP_FUNCTION(chunk_split)	Line 2187 PHP_FUNCTION(chunk_split)
result = emalloc(result_len + 1);	result = emalloc(result_len + 1);
memcpy(result, str, str_len);	memcpy(result, str, str_len);
memcpy(result + str_len, end, endlen);	memcpy(result + str_len, end, endlen);
result[result_len] = '\0';	result[result_len] = '\0';
RETURN_STRINGL(result, result_len, 0);	RETURN_STRINGL(result, result_len, 0);
}	}

if (!str_len) {	if (!str_len) {
Line 2151 PHP_FUNCTION(substr)	Line 2213 PHP_FUNCTION(substr)
long l = 0, f;	long l = 0, f;
int str_len;	int str_len;
int argc = ZEND_NUM_ARGS();	int argc = ZEND_NUM_ARGS();

if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sl\|l", &str, &str_len, &f, &l) == FAILURE) {	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sl\|l", &str, &str_len, &f, &l) == FAILURE) {
return;	return;
}	}
Line 2165 PHP_FUNCTION(substr)	Line 2227 PHP_FUNCTION(substr)
} else {	} else {
l = str_len;	l = str_len;
}	}

if (f > str_len) {	if (f > str_len) {
RETURN_FALSE;	RETURN_FALSE;
} else if (f < 0 && -f > str_len) {	} else if (f < 0 && -f > str_len) {
Line 2228 PHP_FUNCTION(substr_replace)	Line 2290 PHP_FUNCTION(substr_replace)
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ZZZ\|Z", &str, &repl, &from, &len) == FAILURE) {	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ZZZ\|Z", &str, &repl, &from, &len) == FAILURE) {
return;	return;
}	}

if (Z_TYPE_PP(str) != IS_ARRAY) {	if (Z_TYPE_PP(str) != IS_ARRAY) {
if (Z_ISREF_PP(str)) {	if (Z_ISREF_PP(str)) {
SEPARATE_ZVAL(str);	SEPARATE_ZVAL(str);
Line 2262 PHP_FUNCTION(substr_replace)	Line 2324 PHP_FUNCTION(substr_replace)

if (Z_TYPE_PP(str) == IS_STRING) {	if (Z_TYPE_PP(str) == IS_STRING) {
if (	if (
(argc == 3 && Z_TYPE_PP(from) == IS_ARRAY) \|\|	(argc == 3 && Z_TYPE_PP(from) == IS_ARRAY) \|\|
(argc == 4 && Z_TYPE_PP(from) != Z_TYPE_PP(len))	(argc == 4 && Z_TYPE_PP(from) != Z_TYPE_PP(len))
) {	) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "'from' and 'len' should be of same type - numerical or array ");	php_error_docref(NULL TSRMLS_CC, E_WARNING, "'from' and 'len' should be of same type - numerical or array ");
RETURN_STRINGL(Z_STRVAL_PP(str), Z_STRLEN_PP(str), 1);	RETURN_STRINGL(Z_STRVAL_PP(str), Z_STRLEN_PP(str), 1);
}	}
if (argc == 4 && Z_TYPE_PP(from) == IS_ARRAY) {	if (argc == 4 && Z_TYPE_PP(from) == IS_ARRAY) {
if (zend_hash_num_elements(Z_ARRVAL_PP(from)) != zend_hash_num_elements(Z_ARRVAL_PP(len))) {	if (zend_hash_num_elements(Z_ARRVAL_PP(from)) != zend_hash_num_elements(Z_ARRVAL_PP(len))) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "'from' and 'len' should have the same number of elements");	php_error_docref(NULL TSRMLS_CC, E_WARNING, "'from' and 'len' should have the same number of elements");
RETURN_STRINGL(Z_STRVAL_PP(str), Z_STRLEN_PP(str), 1);	RETURN_STRINGL(Z_STRVAL_PP(str), Z_STRLEN_PP(str), 1);
}	}
}	}
}	}

if (Z_TYPE_PP(str) != IS_ARRAY) {	if (Z_TYPE_PP(str) != IS_ARRAY) {
if (Z_TYPE_PP(from) != IS_ARRAY) {	if (Z_TYPE_PP(from) != IS_ARRAY) {
int repl_len = 0;	int repl_len = 0;
Line 2333 PHP_FUNCTION(substr_replace)	Line 2395 PHP_FUNCTION(substr_replace)
RETURN_STRINGL(result, result_len, 0);	RETURN_STRINGL(result, result_len, 0);
} else {	} else {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Functionality of 'from' and 'len' as arrays is not implemented");	php_error_docref(NULL TSRMLS_CC, E_WARNING, "Functionality of 'from' and 'len' as arrays is not implemented");
RETURN_STRINGL(Z_STRVAL_PP(str), Z_STRLEN_PP(str), 1);	RETURN_STRINGL(Z_STRVAL_PP(str), Z_STRLEN_PP(str), 1);
}	}
} else { /* str is array of strings */	} else { /* str is array of strings */
char *str_index = NULL;	char *str_index = NULL;
Line 2358 PHP_FUNCTION(substr_replace)	Line 2420 PHP_FUNCTION(substr_replace)
while (zend_hash_get_current_data_ex(Z_ARRVAL_PP(str), (void **) &tmp_str, &pos_str) == SUCCESS) {	while (zend_hash_get_current_data_ex(Z_ARRVAL_PP(str), (void **) &tmp_str, &pos_str) == SUCCESS) {
zval *orig_str;	zval *orig_str;
zval dummy;	zval dummy;
	ulong refcount;
	int was_ref;

if(Z_TYPE_PP(tmp_str) != IS_STRING) {	if(Z_TYPE_PP(tmp_str) != IS_STRING) {
dummy = **tmp_str;	dummy = **tmp_str;
orig_str = &dummy;	orig_str = &dummy;
Line 2366 PHP_FUNCTION(substr_replace)	Line 2431 PHP_FUNCTION(substr_replace)
} else {	} else {
orig_str = *tmp_str;	orig_str = *tmp_str;
}	}
	was_ref = Z_ISREF_P(orig_str);
	Z_UNSET_ISREF_P(orig_str);
	refcount = Z_REFCOUNT_P(orig_str);

if (Z_TYPE_PP(from) == IS_ARRAY) {	if (Z_TYPE_PP(from) == IS_ARRAY) {
if (SUCCESS == zend_hash_get_current_data_ex(Z_ARRVAL_PP(from), (void **) &tmp_from, &pos_from)) {	if (SUCCESS == zend_hash_get_current_data_ex(Z_ARRVAL_PP(from), (void **) &tmp_from, &pos_from)) {
Line 2416 PHP_FUNCTION(substr_replace)	Line 2484 PHP_FUNCTION(substr_replace)
} else {	} else {
l = Z_STRLEN_P(orig_str);	l = Z_STRLEN_P(orig_str);
}	}
} else if (argc > 3) {	} else if (argc > 3) {
l = Z_LVAL_PP(len);	l = Z_LVAL_PP(len);
} else {	} else {
l = Z_STRLEN_P(orig_str);	l = Z_STRLEN_P(orig_str);
Line 2448 PHP_FUNCTION(substr_replace)	Line 2516 PHP_FUNCTION(substr_replace)
repl_str = *tmp_repl;	repl_str = *tmp_repl;
}	}

	if(Z_REFCOUNT_P(orig_str) != refcount) {
	php_error_docref(NULL TSRMLS_CC, E_WARNING, "Argument was modified while replacing");
	if(Z_TYPE_PP(tmp_repl) != IS_STRING) {
	zval_dtor(repl_str);
	}
	break;
	}

result_len += Z_STRLEN_P(repl_str);	result_len += Z_STRLEN_P(repl_str);
zend_hash_move_forward_ex(Z_ARRVAL_PP(repl), &pos_repl);	zend_hash_move_forward_ex(Z_ARRVAL_PP(repl), &pos_repl);
result = emalloc(result_len + 1);	result = emalloc(result_len + 1);

memcpy(result, Z_STRVAL_P(orig_str), f);	memcpy(result, Z_STRVAL_P(orig_str), f);
Line 2460 PHP_FUNCTION(substr_replace)	Line 2536 PHP_FUNCTION(substr_replace)
}	}
} else {	} else {
result = emalloc(result_len + 1);	result = emalloc(result_len + 1);

memcpy(result, Z_STRVAL_P(orig_str), f);	memcpy(result, Z_STRVAL_P(orig_str), f);
memcpy((result + f), Z_STRVAL_P(orig_str) + f + l, Z_STRLEN_P(orig_str) - f - l);	memcpy((result + f), Z_STRVAL_P(orig_str) + f + l, Z_STRLEN_P(orig_str) - f - l);
}	}
Line 2484 PHP_FUNCTION(substr_replace)	Line 2560 PHP_FUNCTION(substr_replace)

if(Z_TYPE_PP(tmp_str) != IS_STRING) {	if(Z_TYPE_PP(tmp_str) != IS_STRING) {
zval_dtor(orig_str);	zval_dtor(orig_str);
	} else {
	Z_SET_ISREF_TO_P(orig_str, was_ref);
}	}
zend_hash_move_forward_ex(Z_ARRVAL_PP(str), &pos_str);	zend_hash_move_forward_ex(Z_ARRVAL_PP(str), &pos_str);
} /while/	} /while/
Line 2504 PHP_FUNCTION(quotemeta)	Line 2582 PHP_FUNCTION(quotemeta)
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &old, &old_len) == FAILURE) {	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &old, &old_len) == FAILURE) {
return;	return;
}	}

old_end = old + old_len;	old_end = old + old_len;

if (old == old_end) {	if (old == old_end) {
RETURN_FALSE;	RETURN_FALSE;
}	}

str = safe_emalloc(2, old_len, 1);	str = safe_emalloc(2, old_len, 1);

for (p = old, q = str; p != old_end; p++) {	for (p = old, q = str; p != old_end; p++) {
c = *p;	c = *p;
switch (c) {	switch (c) {
Line 2545 PHP_FUNCTION(ord)	Line 2623 PHP_FUNCTION(ord)
{	{
char *str;	char *str;
int str_len;	int str_len;

if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &str_len) == FAILURE) {	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &str_len) == FAILURE) {
return;	return;
}	}

RETURN_LONG((unsigned char) str[0]);	RETURN_LONG((unsigned char) str[0]);
}	}
/* }}} */	/* }}} */
Line 2578 PHP_FUNCTION(chr)	Line 2656 PHP_FUNCTION(chr)

/* {{{ php_ucfirst	/* {{{ php_ucfirst
Uppercase the first character of the word in a native string */	Uppercase the first character of the word in a native string */
static void php_ucfirst(char *str)	static void php_ucfirst(char *str)
{	{
register char *r;	register char *r;
r = str;	r = str;
Line 2592 PHP_FUNCTION(ucfirst)	Line 2670 PHP_FUNCTION(ucfirst)
{	{
char *str;	char *str;
int str_len;	int str_len;

if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &str_len) == FAILURE) {	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &str_len) == FAILURE) {
return;	return;
}	}
Line 2643 PHP_FUNCTION(ucwords)	Line 2721 PHP_FUNCTION(ucwords)
char *str;	char *str;
register char r, r_end;	register char r, r_end;
int str_len;	int str_len;

if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &str_len) == FAILURE) {	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &str_len) == FAILURE) {
return;	return;
}	}
Line 2705 static void php_strtr_array(zval return_value, char	Line 2783 static void php_strtr_array(zval return_value, char
HashPosition hpos;	HashPosition hpos;
smart_str result = {0};	smart_str result = {0};
HashTable tmp_hash;	HashTable tmp_hash;

zend_hash_init(&tmp_hash, zend_hash_num_elements(hash), NULL, NULL, 0);	zend_hash_init(&tmp_hash, zend_hash_num_elements(hash), NULL, NULL, 0);
zend_hash_internal_pointer_reset_ex(hash, &hpos);	zend_hash_internal_pointer_reset_ex(hash, &hpos);
while (zend_hash_get_current_data_ex(hash, (void **)&entry, &hpos) == SUCCESS) {	while (zend_hash_get_current_data_ex(hash, (void **)&entry, &hpos) == SUCCESS) {
Line 2723 static void php_strtr_array(zval return_value, char	Line 2801 static void php_strtr_array(zval return_value, char
if (len < minlen) {	if (len < minlen) {
minlen = len;	minlen = len;
}	}
break;	break;

case HASH_KEY_IS_LONG:	case HASH_KEY_IS_LONG:
Z_TYPE(ctmp) = IS_LONG;	Z_TYPE(ctmp) = IS_LONG;
Z_LVAL(ctmp) = num_key;	Z_LVAL(ctmp) = num_key;

convert_to_string(&ctmp);	convert_to_string(&ctmp);
len = Z_STRLEN(ctmp);	len = Z_STRLEN(ctmp);
zend_hash_add(&tmp_hash, Z_STRVAL(ctmp), len+1, entry, sizeof(zval*), NULL);	zend_hash_add(&tmp_hash, Z_STRVAL(ctmp), len+1, entry, sizeof(zval*), NULL);
Line 2758 static void php_strtr_array(zval return_value, char	Line 2836 static void php_strtr_array(zval return_value, char

for (len = maxlen; len >= minlen; len--) {	for (len = maxlen; len >= minlen; len--) {
key[len] = 0;	key[len] = 0;

if (zend_hash_find(&tmp_hash, key, len+1, (void**)&trans) == SUCCESS) {	if (zend_hash_find(&tmp_hash, key, len+1, (void**)&trans) == SUCCESS) {
char *tval;	char *tval;
int tlen;	int tlen;
Line 2783 static void php_strtr_array(zval return_value, char	Line 2861 static void php_strtr_array(zval return_value, char
zval_dtor(&tmp);	zval_dtor(&tmp);
}	}
break;	break;
}	}
}	}

if (! found) {	if (! found) {
Line 2801 static void php_strtr_array(zval return_value, char	Line 2879 static void php_strtr_array(zval return_value, char
/* {{{ proto string strtr(string str, string from[, string to])	/* {{{ proto string strtr(string str, string from[, string to])
Translates characters in str using given translation tables */	Translates characters in str using given translation tables */
PHP_FUNCTION(strtr)	PHP_FUNCTION(strtr)
{	{
zval **from;	zval **from;
char str, to = NULL;	char str, to = NULL;
int str_len, to_len = 0;	int str_len, to_len = 0;
int ac = ZEND_NUM_ARGS();	int ac = ZEND_NUM_ARGS();

if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sZ\|s", &str, &str_len, &from, &to, &to_len) == FAILURE) {	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sZ\|s", &str, &str_len, &from, &to, &to_len) == FAILURE) {
return;	return;
}	}

if (ac == 2 && Z_TYPE_PP(from) != IS_ARRAY) {	if (ac == 2 && Z_TYPE_PP(from) != IS_ARRAY) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "The second argument is not an array");	php_error_docref(NULL TSRMLS_CC, E_WARNING, "The second argument is not an array");
RETURN_FALSE;	RETURN_FALSE;
Line 2827 PHP_FUNCTION(strtr)	Line 2905 PHP_FUNCTION(strtr)
convert_to_string_ex(from);	convert_to_string_ex(from);

ZVAL_STRINGL(return_value, str, str_len, 1);	ZVAL_STRINGL(return_value, str, str_len, 1);

php_strtr(Z_STRVAL_P(return_value),	php_strtr(Z_STRVAL_P(return_value),
Z_STRLEN_P(return_value),	Z_STRLEN_P(return_value),
Z_STRVAL_PP(from),	Z_STRVAL_PP(from),
to,	to,
MIN(Z_STRLEN_PP(from),	MIN(Z_STRLEN_PP(from),
to_len));	to_len));
}	}
}	}
Line 2845 PHP_FUNCTION(strrev)	Line 2923 PHP_FUNCTION(strrev)
char *str;	char *str;
char e, n, *p;	char e, n, *p;
int str_len;	int str_len;

if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &str_len) == FAILURE) {	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &str_len) == FAILURE) {
return;	return;
}	}

n = emalloc(str_len+1);	n = emalloc(str_len+1);
p = n;	p = n;

e = str + str_len;	e = str + str_len;

while (--e>=str) {	while (--e>=str) {
p++ = e;	p++ = e;
}	}

*p = '\0';	*p = '\0';

RETVAL_STRINGL(n, str_len, 0);	RETVAL_STRINGL(n, str_len, 0);
}	}
/* }}} */	/* }}} */
Line 2873 static void php_similar_str(const char *txt1, int len1	Line 2951 static void php_similar_str(const char *txt1, int len1
char end1 = (char ) txt1 + len1;	char end1 = (char ) txt1 + len1;
char end2 = (char ) txt2 + len2;	char end2 = (char ) txt2 + len2;
int l;	int l;

*max = 0;	*max = 0;
for (p = (char *) txt1; p < end1; p++) {	for (p = (char *) txt1; p < end1; p++) {
for (q = (char *) txt2; q < end2; q++) {	for (q = (char *) txt2; q < end2; q++) {
Line 2898 static int php_similar_char(const char *txt1, int len1	Line 2976 static int php_similar_char(const char *txt1, int len1
php_similar_str(txt1, len1, txt2, len2, &pos1, &pos2, &max);	php_similar_str(txt1, len1, txt2, len2, &pos1, &pos2, &max);
if ((sum = max)) {	if ((sum = max)) {
if (pos1 && pos2) {	if (pos1 && pos2) {
sum += php_similar_char(txt1, pos1,	sum += php_similar_char(txt1, pos1,
txt2, pos2);	txt2, pos2);
}	}
if ((pos1 + max < len1) && (pos2 + max < len2)) {	if ((pos1 + max < len1) && (pos2 + max < len2)) {
sum += php_similar_char(txt1 + pos1 + max, len1 - pos1 - max,	sum += php_similar_char(txt1 + pos1 + max, len1 - pos1 - max,
txt2 + pos2 + max, len2 - pos2 - max);	txt2 + pos2 + max, len2 - pos2 - max);
}	}
}	}
Line 2920 PHP_FUNCTION(similar_text)	Line 2998 PHP_FUNCTION(similar_text)
int ac = ZEND_NUM_ARGS();	int ac = ZEND_NUM_ARGS();
int sim;	int sim;
int t1_len, t2_len;	int t1_len, t2_len;

if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss\|Z", &t1, &t1_len, &t2, &t2_len, &percent) == FAILURE) {	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss\|Z", &t1, &t1_len, &t2, &t2_len, &percent) == FAILURE) {
return;	return;
}	}

if (ac > 2) {	if (ac > 2) {
convert_to_double_ex(percent);	convert_to_double_ex(percent);
}	}

if (t1_len + t2_len == 0) {	if (t1_len + t2_len == 0) {
if (ac > 2) {	if (ac > 2) {
Z_DVAL_PP(percent) = 0;	Z_DVAL_PP(percent) = 0;
Line 2936 PHP_FUNCTION(similar_text)	Line 3014 PHP_FUNCTION(similar_text)

RETURN_LONG(0);	RETURN_LONG(0);
}	}

sim = php_similar_char(t1, t1_len, t2, t2_len);

	sim = php_similar_char(t1, t1_len, t2, t2_len);

if (ac > 2) {	if (ac > 2) {
Z_DVAL_PP(percent) = sim * 200.0 / (t1_len + t2_len);	Z_DVAL_PP(percent) = sim * 200.0 / (t1_len + t2_len);
}	}
Line 2963 PHPAPI void php_stripslashes(char str, int len TSRML	Line 3041 PHPAPI void php_stripslashes(char str, int len TSRML
s = str;	s = str;
t = str;	t = str;

if (PG(magic_quotes_sybase)) {
while (l > 0) {
if (*t == '\'') {
if ((l > 0) && (t[1] == '\'')) {
t++;
if (len != NULL) {
(*len)--;
}
l--;
}
s++ = t++;
} else if (*t == '\\' && t[1] == '0' && l > 0) {
*s++='\0';
t+=2;
if (len != NULL) {
(*len)--;
}
l--;
} else {
s++ = t++;
}
l--;
}
*s = '\0';

return;
}

while (l > 0) {	while (l > 0) {
if (*t == '\\') {	if (*t == '\\') {
t++; /* skip the slash */	t++; /* skip the slash */
Line 3048 PHP_FUNCTION(addslashes)	Line 3098 PHP_FUNCTION(addslashes)
{	{
char *str;	char *str;
int str_len;	int str_len;

if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &str_len) == FAILURE) {	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &str_len) == FAILURE) {
return;	return;
}	}
Line 3058 PHP_FUNCTION(addslashes)	Line 3108 PHP_FUNCTION(addslashes)
}	}

RETURN_STRING(php_addslashes(str,	RETURN_STRING(php_addslashes(str,
str_len,	str_len,
&Z_STRLEN_P(return_value), 0	&Z_STRLEN_P(return_value), 0
TSRMLS_CC), 0);	TSRMLS_CC), 0);
}	}
/* }}} */	/* }}} */
Line 3070 PHP_FUNCTION(stripcslashes)	Line 3120 PHP_FUNCTION(stripcslashes)
{	{
char *str;	char *str;
int str_len;	int str_len;

if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &str_len) == FAILURE) {	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &str_len) == FAILURE) {
return;	return;
}	}
Line 3086 PHP_FUNCTION(stripslashes)	Line 3136 PHP_FUNCTION(stripslashes)
{	{
char *str;	char *str;
int str_len;	int str_len;

if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &str_len) == FAILURE) {	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &str_len) == FAILURE) {
return;	return;
}	}
Line 3099 PHP_FUNCTION(stripslashes)	Line 3149 PHP_FUNCTION(stripslashes)
#ifndef HAVE_STRERROR	#ifndef HAVE_STRERROR
/* {{{ php_strerror	/* {{{ php_strerror
*/	*/
char *php_strerror(int errnum)	char *php_strerror(int errnum)
{	{
extern int sys_nerr;	extern int sys_nerr;
extern char *sys_errlist[];	extern char *sys_errlist[];
Line 3150 PHPAPI void php_stripcslashes(char str, int len)	Line 3200 PHPAPI void php_stripcslashes(char str, int len)
break;	break;
}	}
/* break is left intentionally */	/* break is left intentionally */
default:	default:
i=0;	i=0;
while (source < end && source >= '0' && source <= '7' && i<3) {	while (source < end && source >= '0' && source <= '7' && i<3) {
numtmp[i++] = *source++;	numtmp[i++] = *source++;
}	}
Line 3177 PHPAPI void php_stripcslashes(char str, int len)	Line 3227 PHPAPI void php_stripcslashes(char str, int len)
*len = nlen;	*len = nlen;
}	}
/* }}} */	/* }}} */

/* {{{ php_addcslashes	/* {{{ php_addcslashes
*/	*/
PHPAPI char php_addcslashes(char str, int length, int new_length, int should_free, char what, int wlength TSRMLS_DC)	PHPAPI char php_addcslashes(const char str, int length, int new_length, int should_free, char what, int wlength TSRMLS_DC)
{	{
char flags[256];	char flags[256];
char *new_str = safe_emalloc(4, (length?length:(length=strlen(str))), 1);	char *new_str = safe_emalloc(4, (length?length:(length=strlen(str))), 1);
Line 3195 PHPAPI char php_addcslashes(char str, int length, in	Line 3245 PHPAPI char php_addcslashes(char str, int length, in

php_charmask((unsigned char *)what, wlength, flags TSRMLS_CC);	php_charmask((unsigned char *)what, wlength, flags TSRMLS_CC);

for (source = str, end = source + length, target = new_str; source < end; source++) {	for (source = (char*)str, end = source + length, target = new_str; source < end; source++) {
c = *source;	c = *source;
if (flags[(unsigned char)c]) {	if (flags[(unsigned char)c]) {
if ((unsigned char) c < 32 \|\| (unsigned char) c > 126) {	if ((unsigned char) c < 32 \|\| (unsigned char) c > 126) {
*target++ = '\\';	*target++ = '\\';
Line 3211 PHPAPI char php_addcslashes(char str, int length, in	Line 3261 PHPAPI char php_addcslashes(char str, int length, in
default: target += sprintf(target, "%03o", (unsigned char) c);	default: target += sprintf(target, "%03o", (unsigned char) c);
}	}
continue;	continue;
}	}
*target++ = '\\';	*target++ = '\\';
}	}
*target++ = c;	*target++ = c;
Line 3225 PHPAPI char php_addcslashes(char str, int length, in	Line 3275 PHPAPI char php_addcslashes(char str, int length, in
*new_length = newlen;	*new_length = newlen;
}	}
if (should_free) {	if (should_free) {
STR_FREE(str);	STR_FREE((char*)str);
}	}
return new_str;	return new_str;
}	}
Line 3235 PHPAPI char php_addcslashes(char str, int length, in	Line 3285 PHPAPI char php_addcslashes(char str, int length, in
*/	*/
PHPAPI char php_addslashes(char str, int length, int *new_length, int should_free TSRMLS_DC)	PHPAPI char php_addslashes(char str, int length, int *new_length, int should_free TSRMLS_DC)
{	{
return php_addslashes_ex(str, length, new_length, should_free, 0 TSRMLS_CC);
}
/* }}} */

/* {{{ php_addslashes_ex
*/
PHPAPI char php_addslashes_ex(char str, int length, int *new_length, int should_free, int ignore_sybase TSRMLS_DC)
{
/* maximum string length, worst case situation */	/* maximum string length, worst case situation */
char *new_str;	char *new_str;
char source, target;	char source, target;
char *end;	char *end;
int local_new_length;	int local_new_length;

if (!new_length) {	if (!new_length) {
new_length = &local_new_length;	new_length = &local_new_length;
}	}
Line 3260 PHPAPI char php_addslashes_ex(char str, int length,	Line 3302 PHPAPI char php_addslashes_ex(char str, int length,
source = str;	source = str;
end = source + length;	end = source + length;
target = new_str;	target = new_str;

if (!ignore_sybase && PG(magic_quotes_sybase)) {	while (source < end) {
while (source < end) {	switch (*source) {
switch (*source) {	case '\0':
case '\0':	*target++ = '\\';
*target++ = '\\';	*target++ = '0';
*target++ = '0';	break;
break;	case '\'':
case '\'':	case '\"':
*target++ = '\'';	case '\\':
*target++ = '\'';	*target++ = '\\';
break;	/* break is missing intentionally */
default:	default:
target++ = source;	target++ = source;
break;	break;
}
source++;
}	}
} else {
while (source < end) {	source++;
switch (*source) {
case '\0':
*target++ = '\\';
*target++ = '0';
break;
case '\'':
case '\"':
case '\\':
*target++ = '\\';
/* break is missing intentionally */
default:
target++ = source;
break;
}

source++;
}
}	}

*target = 0;	*target = 0;
*new_length = target - new_str;	*new_length = target - new_str;
if (should_free) {	if (should_free) {
Line 3322 PHPAPI int php_char_to_str_ex(char *str, uint len, cha	Line 3345 PHPAPI int php_char_to_str_ex(char *str, uint len, cha
int char_count = 0;	int char_count = 0;
int replaced = 0;	int replaced = 0;
char source, target, tmp, source_end=str+len, *tmp_end = NULL;	char source, target, tmp, source_end=str+len, *tmp_end = NULL;

if (case_sensitivity) {	if (case_sensitivity) {
char p = str, e = p + len;	char p = str, e = p + len;
while ((p = memchr(p, from, (e - p)))) {	while ((p = memchr(p, from, (e - p)))) {
Line 3341 PHPAPI int php_char_to_str_ex(char *str, uint len, cha	Line 3364 PHPAPI int php_char_to_str_ex(char *str, uint len, cha
ZVAL_STRINGL(result, str, len, 1);	ZVAL_STRINGL(result, str, len, 1);
return 0;	return 0;
}	}

Z_STRLEN_P(result) = len + (char_count * (to_len - 1));	Z_STRLEN_P(result) = len + (char_count * (to_len - 1));
Z_STRVAL_P(result) = target = safe_emalloc(char_count, to_len, len + 1);	Z_STRVAL_P(result) = target = safe_emalloc(char_count, to_len, len + 1);
Z_TYPE_P(result) = IS_STRING;	Z_TYPE_P(result) = IS_STRING;
Line 3395 PHPAPI int php_char_to_str(char *str, uint len, char f	Line 3418 PHPAPI int php_char_to_str(char *str, uint len, char f

/* {{{ php_str_to_str_ex	/* {{{ php_str_to_str_ex
*/	*/
PHPAPI char php_str_to_str_ex(char haystack, int length,	PHPAPI char php_str_to_str_ex(char haystack, int length,
char needle, int needle_len, char str, int str_len, int _new_length, int case_sensitivity, int replace_count)	char needle, int needle_len, char str, int str_len, int _new_length, int case_sensitivity, int replace_count)
{	{
char *new_str;	char *new_str;
Line 3567 nothing_todo:	Line 3590 nothing_todo:

/* {{{ php_str_to_str	/* {{{ php_str_to_str
*/	*/
PHPAPI char php_str_to_str(char haystack, int length,	PHPAPI char php_str_to_str(char haystack, int length,
char needle, int needle_len, char str, int str_len, int *_new_length)	char needle, int needle_len, char str, int str_len, int *_new_length)
{	{
return php_str_to_str_ex(haystack, length, needle, needle_len, str, str_len, _new_length, 1, NULL);	return php_str_to_str_ex(haystack, length, needle, needle_len, str, str_len, _new_length, 1, NULL);
}	}
/* }}} */	/* }}} */

/* {{{ php_str_replace_in_subject	/* {{{ php_str_replace_in_subject
Line 3584 static void php_str_replace_in_subject(zval *search, z	Line 3607 static void php_str_replace_in_subject(zval *search, z
char *replace_value = NULL;	char *replace_value = NULL;
int replace_len = 0;	int replace_len = 0;

/* Make sure we're dealing with strings. */	/* Make sure we're dealing with strings. */
convert_to_string_ex(subject);	convert_to_string_ex(subject);
Z_TYPE_P(result) = IS_STRING;	Z_TYPE_P(result) = IS_STRING;
if (Z_STRLEN_PP(subject) == 0) {	if (Z_STRLEN_PP(subject) == 0) {
ZVAL_STRINGL(result, "", 0, 1);	ZVAL_STRINGL(result, "", 0, 1);
return;	return;
}	}

/* If search is an array */	/* If search is an array */
if (Z_TYPE_P(search) == IS_ARRAY) {	if (Z_TYPE_P(search) == IS_ARRAY) {
/* Duplicate subject string for repeated replacement */	/* Duplicate subject string for repeated replacement */
MAKE_COPY_ZVAL(subject, result);	MAKE_COPY_ZVAL(subject, result);

zend_hash_internal_pointer_reset(Z_ARRVAL_P(search));	zend_hash_internal_pointer_reset(Z_ARRVAL_P(search));

if (Z_TYPE_P(replace) == IS_ARRAY) {	if (Z_TYPE_P(replace) == IS_ARRAY) {
Line 3609 static void php_str_replace_in_subject(zval *search, z	Line 3632 static void php_str_replace_in_subject(zval *search, z

/* For each entry in the search array, get the entry */	/* For each entry in the search array, get the entry */
while (zend_hash_get_current_data(Z_ARRVAL_P(search), (void **) &search_entry) == SUCCESS) {	while (zend_hash_get_current_data(Z_ARRVAL_P(search), (void **) &search_entry) == SUCCESS) {
/* Make sure we're dealing with strings. */	/* Make sure we're dealing with strings. */
SEPARATE_ZVAL(search_entry);	SEPARATE_ZVAL(search_entry);
convert_to_string(*search_entry);	convert_to_string(*search_entry);
if (Z_STRLEN_PP(search_entry) == 0) {	if (Z_STRLEN_PP(search_entry) == 0) {
Line 3624 static void php_str_replace_in_subject(zval *search, z	Line 3647 static void php_str_replace_in_subject(zval *search, z
if (Z_TYPE_P(replace) == IS_ARRAY) {	if (Z_TYPE_P(replace) == IS_ARRAY) {
/* Get current entry */	/* Get current entry */
if (zend_hash_get_current_data(Z_ARRVAL_P(replace), (void **)&replace_entry) == SUCCESS) {	if (zend_hash_get_current_data(Z_ARRVAL_P(replace), (void **)&replace_entry) == SUCCESS) {
/* Make sure we're dealing with strings. */	/* Make sure we're dealing with strings. */
convert_to_string_ex(replace_entry);	convert_to_string_ex(replace_entry);

/* Set replacement value to the one we got from array */	/* Set replacement value to the one we got from array */
replace_value = Z_STRVAL_PP(replace_entry);	replace_value = Z_STRVAL_PP(replace_entry);
replace_len = Z_STRLEN_PP(replace_entry);	replace_len = Z_STRLEN_PP(replace_entry);
Line 3638 static void php_str_replace_in_subject(zval *search, z	Line 3661 static void php_str_replace_in_subject(zval *search, z
replace_len = 0;	replace_len = 0;
}	}
}	}

if (Z_STRLEN_PP(search_entry) == 1) {	if (Z_STRLEN_PP(search_entry) == 1) {
php_char_to_str_ex(Z_STRVAL_P(result),	php_char_to_str_ex(Z_STRVAL_P(result),
Z_STRLEN_P(result),	Z_STRLEN_P(result),
Line 3654 static void php_str_replace_in_subject(zval *search, z	Line 3677 static void php_str_replace_in_subject(zval *search, z
replace_value, replace_len, &Z_STRLEN(temp_result), case_sensitivity, replace_count);	replace_value, replace_len, &Z_STRLEN(temp_result), case_sensitivity, replace_count);
}	}

efree(Z_STRVAL_P(result));	str_efree(Z_STRVAL_P(result));
Z_STRVAL_P(result) = Z_STRVAL(temp_result);	Z_STRVAL_P(result) = Z_STRVAL(temp_result);
Z_STRLEN_P(result) = Z_STRLEN(temp_result);	Z_STRLEN_P(result) = Z_STRLEN(temp_result);

Line 3741 static void php_str_replace_common(INTERNAL_FUNCTION_P	Line 3764 static void php_str_replace_common(INTERNAL_FUNCTION_P
add_index_zval(return_value, num_key, result);	add_index_zval(return_value, num_key, result);
break;	break;
}	}

zend_hash_move_forward(Z_ARRVAL_PP(subject));	zend_hash_move_forward(Z_ARRVAL_PP(subject));
}	}
} else { /* if subject is not an array */	} else { /* if subject is not an array */
php_str_replace_in_subject(search, replace, subject, return_value, case_sensitivity, (argc > 3) ? &count : NULL);	php_str_replace_in_subject(search, replace, subject, return_value, case_sensitivity, (argc > 3) ? &count : NULL);
}	}
if (argc > 3) {	if (argc > 3) {
zval_dtor(*zcount);	zval_dtor(*zcount);
ZVAL_LONG(*zcount, count);	ZVAL_LONG(*zcount, count);
Line 3783 static void php_hebrev(INTERNAL_FUNCTION_PARAMETERS, i	Line 3806 static void php_hebrev(INTERNAL_FUNCTION_PARAMETERS, i
long max_chars=0;	long max_chars=0;
int begin, end, char_count, orig_begin;	int begin, end, char_count, orig_begin;
int str_len;	int str_len;

if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s\|l", &str, &str_len, &max_chars) == FAILURE) {	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s\|l", &str, &str_len, &max_chars) == FAILURE) {
return;	return;
}	}

if (str_len == 0) {	if (str_len == 0) {
RETURN_FALSE;	RETURN_FALSE;
}	}
Line 3807 static void php_hebrev(INTERNAL_FUNCTION_PARAMETERS, i	Line 3830 static void php_hebrev(INTERNAL_FUNCTION_PARAMETERS, i
} else {	} else {
block_type = _HEB_BLOCK_TYPE_ENG;	block_type = _HEB_BLOCK_TYPE_ENG;
}	}

do {	do {
if (block_type == _HEB_BLOCK_TYPE_HEB) {	if (block_type == _HEB_BLOCK_TYPE_HEB) {
while ((isheb((int)(tmp+1)) \|\| _isblank((int)(tmp+1)) \|\| ispunct((int)(tmp+1)) \|\| (int)(tmp+1)=='\n' ) && block_end<str_len-1) {	while ((isheb((int)(tmp+1)) \|\| _isblank((int)(tmp+1)) \|\| ispunct((int)(tmp+1)) \|\| (int)(tmp+1)=='\n' ) && block_end<str_len-1) {
Line 3877 static void php_hebrev(INTERNAL_FUNCTION_PARAMETERS, i	Line 3900 static void php_hebrev(INTERNAL_FUNCTION_PARAMETERS, i
broken_str = (char *) emalloc(str_len+1);	broken_str = (char *) emalloc(str_len+1);
begin=end=str_len-1;	begin=end=str_len-1;
target = broken_str;	target = broken_str;

while (1) {	while (1) {
char_count=0;	char_count=0;
while ((!max_chars \|\| char_count < max_chars) && begin > 0) {	while ((!max_chars \|\| char_count < max_chars) && begin > 0) {
Line 3893 static void php_hebrev(INTERNAL_FUNCTION_PARAMETERS, i	Line 3916 static void php_hebrev(INTERNAL_FUNCTION_PARAMETERS, i
}	}
if (char_count == max_chars) { /* try to avoid breaking words */	if (char_count == max_chars) { /* try to avoid breaking words */
int new_char_count=char_count, new_begin=begin;	int new_char_count=char_count, new_begin=begin;

while (new_char_count > 0) {	while (new_char_count > 0) {
if (_isblank(heb_str[new_begin]) \|\| _isnewline(heb_str[new_begin])) {	if (_isblank(heb_str[new_begin]) \|\| _isnewline(heb_str[new_begin])) {
break;	break;
Line 3907 static void php_hebrev(INTERNAL_FUNCTION_PARAMETERS, i	Line 3930 static void php_hebrev(INTERNAL_FUNCTION_PARAMETERS, i
}	}
}	}
orig_begin=begin;	orig_begin=begin;

if (_isblank(heb_str[begin])) {	if (_isblank(heb_str[begin])) {
heb_str[begin]='\n';	heb_str[begin]='\n';
}	}
Line 3971 PHP_FUNCTION(nl2br)	Line 3994 PHP_FUNCTION(nl2br)
int repl_cnt = 0;	int repl_cnt = 0;
int str_len;	int str_len;
zend_bool is_xhtml = 1;	zend_bool is_xhtml = 1;

if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s\|b", &str, &str_len, &is_xhtml) == FAILURE) {	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s\|b", &str, &str_len, &is_xhtml) == FAILURE) {
return;	return;
}	}

tmp = str;	tmp = str;
end = str + str_len;	end = str + str_len;

/* it is really faster to scan twice and allocate mem once instead of scanning once	/* it is really faster to scan twice and allocate mem once instead of scanning once
and constantly reallocing */	and constantly reallocing */
while (tmp < end) {	while (tmp < end) {
Line 3993 PHP_FUNCTION(nl2br)	Line 4016 PHP_FUNCTION(nl2br)
}	}
repl_cnt++;	repl_cnt++;
}	}

tmp++;	tmp++;
}	}

if (repl_cnt == 0) {	if (repl_cnt == 0) {
RETURN_STRINGL(str, str_len, 1);	RETURN_STRINGL(str, str_len, 1);
}	}
Line 4023 PHP_FUNCTION(nl2br)	Line 4046 PHP_FUNCTION(nl2br)
}	}

*target++ = '>';	*target++ = '>';

if ((str == '\r' && (str+1) == '\n') \|\| (str == '\n' && (str+1) == '\r')) {	if ((str == '\r' && (str+1) == '\n') \|\| (str == '\n' && (str+1) == '\r')) {
target++ = str++;	target++ = str++;
}	}
Line 4031 PHP_FUNCTION(nl2br)	Line 4054 PHP_FUNCTION(nl2br)
default:	default:
target++ = str;	target++ = str;
}	}

str++;	str++;
}	}

*target = '\0';	*target = '\0';

RETURN_STRINGL(tmp, new_length, 0);	RETURN_STRINGL(tmp, new_length, 0);
Line 4056 PHP_FUNCTION(strip_tags)	Line 4079 PHP_FUNCTION(strip_tags)
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s\|Z", &str, &str_len, &allow) == FAILURE) {	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s\|Z", &str, &str_len, &allow) == FAILURE) {
return;	return;
}	}

/* To maintain a certain BC, we allow anything for the second parameter and return original string */	/* To maintain a certain BC, we allow anything for the second parameter and return original string */
if (allow != NULL) {	if (allow != NULL) {
convert_to_string_ex(allow);	convert_to_string_ex(allow);
Line 4085 PHP_FUNCTION(setlocale)	Line 4108 PHP_FUNCTION(setlocale)

#ifdef HAVE_SETLOCALE	#ifdef HAVE_SETLOCALE
if (Z_TYPE_PP(pcategory) == IS_LONG) {	if (Z_TYPE_PP(pcategory) == IS_LONG) {
convert_to_long_ex(pcategory);	convert_to_long_ex(pcategory);
cat = Z_LVAL_PP(pcategory);	cat = Z_LVAL_PP(pcategory);
} else {	} else {
/* FIXME: The following behaviour should be removed. */	/* FIXME: The following behaviour should be removed. */
char *category;	char *category;

php_error_docref(NULL TSRMLS_CC, E_DEPRECATED, "Passing locale category name as string is deprecated. Use the LC_* -constants instead");	php_error_docref(NULL TSRMLS_CC, E_DEPRECATED, "Passing locale category name as string is deprecated. Use the LC_* -constants instead");

convert_to_string_ex(pcategory);	convert_to_string_ex(pcategory);
category = Z_STRVAL_PP(pcategory);	category = Z_STRVAL_PP(pcategory);

Line 4114 PHP_FUNCTION(setlocale)	Line 4137 PHP_FUNCTION(setlocale)
cat = LC_TIME;	cat = LC_TIME;
} else {	} else {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid locale category name %s, must be one of LC_ALL, LC_COLLATE, LC_CTYPE, LC_MONETARY, LC_NUMERIC, or LC_TIME", category);	php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid locale category name %s, must be one of LC_ALL, LC_COLLATE, LC_CTYPE, LC_MONETARY, LC_NUMERIC, or LC_TIME", category);

if (args) {	if (args) {
efree(args);	efree(args);
}	}
RETURN_FALSE;	RETURN_FALSE;
}	}
}	}
Line 4125 PHP_FUNCTION(setlocale)	Line 4148 PHP_FUNCTION(setlocale)
if (Z_TYPE_PP(args[0]) == IS_ARRAY) {	if (Z_TYPE_PP(args[0]) == IS_ARRAY) {
zend_hash_internal_pointer_reset(Z_ARRVAL_PP(args[0]));	zend_hash_internal_pointer_reset(Z_ARRVAL_PP(args[0]));
}	}

while (1) {	while (1) {
if (Z_TYPE_PP(args[0]) == IS_ARRAY) {	if (Z_TYPE_PP(args[0]) == IS_ARRAY) {
if (!zend_hash_num_elements(Z_ARRVAL_PP(args[0]))) {	if (!zend_hash_num_elements(Z_ARRVAL_PP(args[0]))) {
Line 4137 PHP_FUNCTION(setlocale)	Line 4160 PHP_FUNCTION(setlocale)
}	}

convert_to_string_ex(plocale);	convert_to_string_ex(plocale);

if (!strcmp ("0", Z_STRVAL_PP(plocale))) {	if (!strcmp ("0", Z_STRVAL_PP(plocale))) {
loc = NULL;	loc = NULL;
} else {	} else {
Line 4162 PHP_FUNCTION(setlocale)	Line 4185 PHP_FUNCTION(setlocale)
}	}
RETURN_STRING(retval, 1);	RETURN_STRING(retval, 1);
}	}

if (Z_TYPE_PP(args[0]) == IS_ARRAY) {	if (Z_TYPE_PP(args[0]) == IS_ARRAY) {
if (zend_hash_move_forward(Z_ARRVAL_PP(args[0])) == FAILURE) break;	if (zend_hash_move_forward(Z_ARRVAL_PP(args[0])) == FAILURE) break;
} else {	} else {
Line 4203 PHP_FUNCTION(parse_str)	Line 4226 PHP_FUNCTION(parse_str)
sapi_module.treat_data(PARSE_STRING, res, &tmp TSRMLS_CC);	sapi_module.treat_data(PARSE_STRING, res, &tmp TSRMLS_CC);
} else {	} else {
zval ret;	zval ret;

array_init(&ret);	array_init(&ret);
sapi_module.treat_data(PARSE_STRING, res, &ret TSRMLS_CC);	sapi_module.treat_data(PARSE_STRING, res, &ret TSRMLS_CC);
/* Clear out the array that was passed in. */	/* Clear out the array that was passed in. */
zval_dtor(arrayArg);	zval_dtor(arrayArg);
arrayArg->type = ret.type;	ZVAL_COPY_VALUE(arrayArg, &ret);
arrayArg->value = ret.value;
}	}
}	}
/* }}} */	/* }}} */
Line 4218 PHP_FUNCTION(parse_str)	Line 4240 PHP_FUNCTION(parse_str)

/* {{{ php_tag_find	/* {{{ php_tag_find
*	*
* Check if tag is in a set of tags	* Check if tag is in a set of tags
*	*
* states:	* states:
*	*
* 0 start tag	* 0 start tag
* 1 first non-whitespace char seen	* 1 first non-whitespace char seen
*/	*/
Line 4233 int php_tag_find(char tag, int len, char set) {	Line 4255 int php_tag_find(char tag, int len, char set) {
if (len <= 0) {	if (len <= 0) {
return 0;	return 0;
}	}

norm = emalloc(len+1);	norm = emalloc(len+1);

n = norm;	n = norm;
t = tag;	t = tag;
c = tolower(*t);	c = tolower(*t);
/*	/*
normalize the tag removing leading and trailing whitespace	normalize the tag removing leading and trailing whitespace
and turn any <a whatever...> into just <a> and any </tag>	and turn any <a whatever...> into just <a> and any </tag>
into <tag>	into <tag>
Line 4267 int php_tag_find(char tag, int len, char set) {	Line 4289 int php_tag_find(char tag, int len, char set) {
break;	break;
}	}
c = tolower(*(++t));	c = tolower(*(++t));
}	}
*(n++) = '>';	*(n++) = '>';
*n = '\0';	*n = '\0';
if (strstr(set, norm)) {	if (strstr(set, norm)) {
done=1;	done=1;
} else {	} else {
Line 4287 PHPAPI size_t php_strip_tags(char *rbuf, int len, int	Line 4309 PHPAPI size_t php_strip_tags(char *rbuf, int len, int
/* }}} */	/* }}} */

/* {{{ php_strip_tags	/* {{{ php_strip_tags

A simple little state-machine to strip out html and php tags	A simple little state-machine to strip out html and php tags

State 0 is the output state, State 1 means we are inside a	State 0 is the output state, State 1 means we are inside a
normal html tag and state 2 means we are inside a php tag.	normal html tag and state 2 means we are inside a php tag.

Line 4311 PHPAPI size_t php_strip_tags_ex(char *rbuf, int len, i	Line 4333 PHPAPI size_t php_strip_tags_ex(char *rbuf, int len, i
char tbuf, buf, p, tp, *rp, c, lc;	char tbuf, buf, p, tp, *rp, c, lc;
int br, i=0, depth=0, in_q = 0;	int br, i=0, depth=0, in_q = 0;
int state = 0, pos;	int state = 0, pos;
	char *allow_free;

if (stateptr)	if (stateptr)
state = *stateptr;	state = *stateptr;
Line 4322 PHPAPI size_t php_strip_tags_ex(char *rbuf, int len, i	Line 4345 PHPAPI size_t php_strip_tags_ex(char *rbuf, int len, i
rp = rbuf;	rp = rbuf;
br = 0;	br = 0;
if (allow) {	if (allow) {
php_strtolower(allow, allow_len);	if (IS_INTERNED(allow)) {
	allow_free = allow = zend_str_tolower_dup(allow, allow_len);
	} else {
	allow_free = NULL;
	php_strtolower(allow, allow_len);
	}
tbuf = emalloc(PHP_TAG_BUF_SIZE + 1);	tbuf = emalloc(PHP_TAG_BUF_SIZE + 1);
tp = tbuf;	tp = tbuf;
} else {	} else {
Line 4372 PHPAPI size_t php_strip_tags_ex(char *rbuf, int len, i	Line 4400 PHPAPI size_t php_strip_tags_ex(char *rbuf, int len, i
} else if (state == 0) {	} else if (state == 0) {
*(rp++) = c;	*(rp++) = c;
}	}
break;	break;

case ')':	case ')':
if (state == 2) {	if (state == 2) {
Line 4390 PHPAPI size_t php_strip_tags_ex(char *rbuf, int len, i	Line 4418 PHPAPI size_t php_strip_tags_ex(char *rbuf, int len, i
} else if (state == 0) {	} else if (state == 0) {
*(rp++) = c;	*(rp++) = c;
}	}
break;	break;

case '>':	case '>':
if (depth) {	if (depth) {
Line 4421 PHPAPI size_t php_strip_tags_ex(char *rbuf, int len, i	Line 4449 PHPAPI size_t php_strip_tags_ex(char *rbuf, int len, i
tp = tbuf;	tp = tbuf;
}	}
break;	break;

case 2: /* PHP */	case 2: /* PHP */
if (!br && lc != '\"' && *(p-1) == '?') {	if (!br && lc != '\"' && *(p-1) == '?') {
in_q = state = 0;	in_q = state = 0;
tp = tbuf;	tp = tbuf;
}	}
break;	break;

case 3:	case 3:
in_q = state = 0;	in_q = state = 0;
tp = tbuf;	tp = tbuf;
Line 4476 PHPAPI size_t php_strip_tags_ex(char *rbuf, int len, i	Line 4504 PHPAPI size_t php_strip_tags_ex(char *rbuf, int len, i
}	}
}	}
break;	break;

case '!':	case '!':
/* JavaScript & Other HTML scripting languages */	/* JavaScript & Other HTML scripting languages */
if (state == 1 && *(p-1) == '<') {	if (state == 1 && *(p-1) == '<') {
state = 3;	state = 3;
lc = c;	lc = c;
} else {	} else {
Line 4506 PHPAPI size_t php_strip_tags_ex(char *rbuf, int len, i	Line 4534 PHPAPI size_t php_strip_tags_ex(char *rbuf, int len, i

case '?':	case '?':

if (state == 1 && *(p-1) == '<') {	if (state == 1 && *(p-1) == '<') {
br=0;	br=0;
state=2;	state=2;
break;	break;
Line 4551 reg_char:	Line 4579 reg_char:
tp = tbuf + pos;	tp = tbuf + pos;
}	}
*(tp++) = c;	*(tp++) = c;
}	}
break;	break;
}	}
c = *(++p);	c = *(++p);
i++;	i++;
}	}
if (rp < rbuf + len) {	if (rp < rbuf + len) {
*rp = '\0';	*rp = '\0';
}	}
efree(buf);	efree(buf);
if (allow)	if (allow) {
efree(tbuf);	efree(tbuf);
	if (allow_free) {
	efree(allow_free);
	}
	}
if (stateptr)	if (stateptr)
*stateptr = state;	*stateptr = state;

Line 4578 PHP_FUNCTION(str_getcsv)	Line 4610 PHP_FUNCTION(str_getcsv)
char delim_str = NULL, enc_str = NULL, *esc_str = NULL;	char delim_str = NULL, enc_str = NULL, *esc_str = NULL;
int str_len = 0, delim_len = 0, enc_len = 0, esc_len = 0;	int str_len = 0, delim_len = 0, enc_len = 0, esc_len = 0;

if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s\|sss", &str, &str_len, &delim_str, &delim_len,	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s\|sss", &str, &str_len, &delim_str, &delim_len,
&enc_str, &enc_len, &esc_str, &esc_len) == FAILURE) {	&enc_str, &enc_len, &esc_str, &esc_len) == FAILURE) {
return;	return;
}	}

delim = delim_len ? delim_str[0] : delim;	delim = delim_len ? delim_str[0] : delim;
enc = enc_len ? enc_str[0] : enc;	enc = enc_len ? enc_str[0] : enc;
esc = esc_len ? esc_str[0] : esc;	esc = esc_len ? esc_str[0] : esc;
Line 4600 PHP_FUNCTION(str_repeat)	Line 4632 PHP_FUNCTION(str_repeat)
long mult; /* Multiplier */	long mult; /* Multiplier */
char result; / Resulting string */	char result; / Resulting string */
size_t result_len; /* Length of the resulting string */	size_t result_len; /* Length of the resulting string */

if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sl", &input_str, &input_len, &mult) == FAILURE) {	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sl", &input_str, &input_len, &mult) == FAILURE) {
return;	return;
}	}
Line 4615 PHP_FUNCTION(str_repeat)	Line 4647 PHP_FUNCTION(str_repeat)
if (input_len == 0 \|\| mult == 0)	if (input_len == 0 \|\| mult == 0)
RETURN_EMPTY_STRING();	RETURN_EMPTY_STRING();

/* Initialize the result string */	/* Initialize the result string */
result_len = input_len * mult;	result_len = input_len * mult;
result = (char *)safe_emalloc(input_len, mult, 1);	result = (char *)safe_emalloc(input_len, mult, 1);

/* Heavy optimization for situations where input string is 1 byte long */	/* Heavy optimization for situations where input string is 1 byte long */
if (input_len == 1) {	if (input_len == 1) {
memset(result, *(input_str), mult);	memset(result, *(input_str), mult);
} else {	} else {
char s, e, *ee;	char s, e, *ee;
int l=0;	int l=0;
Line 4629 PHP_FUNCTION(str_repeat)	Line 4661 PHP_FUNCTION(str_repeat)
s = result;	s = result;
e = result + input_len;	e = result + input_len;
ee = result + result_len;	ee = result + result_len;

while (e<ee) {	while (e<ee) {
l = (e-s) < (ee-e) ? (e-s) : (ee-e);	l = (e-s) < (ee-e) ? (e-s) : (ee-e);
memmove(e, s, l);	memmove(e, s, l);
Line 4638 PHP_FUNCTION(str_repeat)	Line 4670 PHP_FUNCTION(str_repeat)
}	}

result[result_len] = '\0';	result[result_len] = '\0';

RETURN_STRINGL(result, result_len, 0);	RETURN_STRINGL(result, result_len, 0);
}	}
/* }}} */	/* }}} */
Line 4704 PHP_FUNCTION(count_chars)	Line 4736 PHP_FUNCTION(count_chars)
break;	break;
}	}
}	}

if (mymode >= 3 && mymode <= 4) {	if (mymode >= 3 && mymode <= 4) {
RETURN_STRINGL(retstr, retlen, 1);	RETURN_STRINGL(retstr, retlen, 1);
}	}
Line 4728 static void php_strnatcmp(INTERNAL_FUNCTION_PARAMETERS	Line 4760 static void php_strnatcmp(INTERNAL_FUNCTION_PARAMETERS
}	}
/* }}} */	/* }}} */

	PHPAPI int string_natural_compare_function_ex(zval result, zval op1, zval op2, zend_bool case_insensitive TSRMLS_DC) / {{{ */
	{
	zval op1_copy, op2_copy;
	int use_copy1 = 0, use_copy2 = 0;

	if (Z_TYPE_P(op1) != IS_STRING) {
	zend_make_printable_zval(op1, &op1_copy, &use_copy1);
	}
	if (Z_TYPE_P(op2) != IS_STRING) {
	zend_make_printable_zval(op2, &op2_copy, &use_copy2);
	}

	if (use_copy1) {
	op1 = &op1_copy;
	}
	if (use_copy2) {
	op2 = &op2_copy;
	}

	ZVAL_LONG(result, strnatcmp_ex(Z_STRVAL_P(op1), Z_STRLEN_P(op1), Z_STRVAL_P(op2), Z_STRLEN_P(op2), case_insensitive));

	if (use_copy1) {
	zval_dtor(op1);
	}
	if (use_copy2) {
	zval_dtor(op2);
	}
	return SUCCESS;
	}
	/* }}} */

	PHPAPI int string_natural_case_compare_function(zval result, zval op1, zval op2 TSRMLS_DC) / {{{ */
	{
	return string_natural_compare_function_ex(result, op1, op2, 1 TSRMLS_CC);
	}
	/* }}} */

	PHPAPI int string_natural_compare_function(zval result, zval op1, zval op2 TSRMLS_DC) / {{{ */
	{
	return string_natural_compare_function_ex(result, op1, op2, 0 TSRMLS_CC);
	}
	/* }}} */

/* {{{ proto int strnatcmp(string s1, string s2)	/* {{{ proto int strnatcmp(string s1, string s2)
Returns the result of string comparison using 'natural' algorithm */	Returns the result of string comparison using 'natural' algorithm */
PHP_FUNCTION(strnatcmp)	PHP_FUNCTION(strnatcmp)
Line 4760 PHP_FUNCTION(localeconv)	Line 4835 PHP_FUNCTION(localeconv)
struct lconv currlocdata;	struct lconv currlocdata;

localeconv_r( &currlocdata );	localeconv_r( &currlocdata );

/* Grab the grouping data out of the array */	/* Grab the grouping data out of the array */
len = strlen(currlocdata.grouping);	len = strlen(currlocdata.grouping);

Line 4849 PHP_FUNCTION(substr_count)	Line 4924 PHP_FUNCTION(substr_count)
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Empty substring");	php_error_docref(NULL TSRMLS_CC, E_WARNING, "Empty substring");
RETURN_FALSE;	RETURN_FALSE;
}	}

p = haystack;	p = haystack;
endp = p + haystack_len;	endp = p + haystack_len;

if (offset < 0) {	if (offset < 0) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Offset should be greater than or equal to 0");	php_error_docref(NULL TSRMLS_CC, E_WARNING, "Offset should be greater than or equal to 0");
RETURN_FALSE;	RETURN_FALSE;
}	}

if (offset > haystack_len) {	if (offset > haystack_len) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Offset value %ld exceeds string length", offset);	php_error_docref(NULL TSRMLS_CC, E_WARNING, "Offset value %ld exceeds string length", offset);
RETURN_FALSE;	RETURN_FALSE;
}	}
p += offset;	p += offset;

Line 4868 PHP_FUNCTION(substr_count)	Line 4943 PHP_FUNCTION(substr_count)

if (length <= 0) {	if (length <= 0) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Length should be greater than 0");	php_error_docref(NULL TSRMLS_CC, E_WARNING, "Length should be greater than 0");
RETURN_FALSE;	RETURN_FALSE;
}	}
if (length > (haystack_len - offset)) {	if (length > (haystack_len - offset)) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Length value %ld exceeds string length", length);	php_error_docref(NULL TSRMLS_CC, E_WARNING, "Length value %ld exceeds string length", length);
Line 4876 PHP_FUNCTION(substr_count)	Line 4951 PHP_FUNCTION(substr_count)
}	}
endp = p + length;	endp = p + length;
}	}

if (needle_len == 1) {	if (needle_len == 1) {
cmp = needle[0];	cmp = needle[0];

Line 4893 PHP_FUNCTION(substr_count)	Line 4968 PHP_FUNCTION(substr_count)

RETURN_LONG(count);	RETURN_LONG(count);
}	}
/* }}} */	/* }}} */

/* {{{ proto string str_pad(string input, int pad_length [, string pad_string [, int pad_type]])	/* {{{ proto string str_pad(string input, int pad_length [, string pad_string [, int pad_type]])
Returns input string padded on the left or right to specified length with pad_string */	Returns input string padded on the left or right to specified length with pad_string */
Line 4903 PHP_FUNCTION(str_pad)	Line 4978 PHP_FUNCTION(str_pad)
char input; / Input string */	char input; / Input string */
int input_len;	int input_len;
long pad_length; /* Length to pad to */	long pad_length; /* Length to pad to */

/* Helper variables */	/* Helper variables */
size_t num_pad_chars; /* Number of padding characters (total - input size) */	size_t num_pad_chars; /* Number of padding characters (total - input size) */
char result = NULL; / Resulting string */	char result = NULL; / Resulting string */
Line 4928 PHP_FUNCTION(str_pad)	Line 5003 PHP_FUNCTION(str_pad)
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Padding string cannot be empty");	php_error_docref(NULL TSRMLS_CC, E_WARNING, "Padding string cannot be empty");
return;	return;
}	}

if (pad_type_val < STR_PAD_LEFT \|\| pad_type_val > STR_PAD_BOTH) {	if (pad_type_val < STR_PAD_LEFT \|\| pad_type_val > STR_PAD_BOTH) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Padding type has to be STR_PAD_LEFT, STR_PAD_RIGHT, or STR_PAD_BOTH");	php_error_docref(NULL TSRMLS_CC, E_WARNING, "Padding type has to be STR_PAD_LEFT, STR_PAD_RIGHT, or STR_PAD_BOTH");
return;	return;
Line 4937 PHP_FUNCTION(str_pad)	Line 5012 PHP_FUNCTION(str_pad)
num_pad_chars = pad_length - input_len;	num_pad_chars = pad_length - input_len;
if (num_pad_chars >= INT_MAX) {	if (num_pad_chars >= INT_MAX) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Padding length is too long");	php_error_docref(NULL TSRMLS_CC, E_WARNING, "Padding length is too long");
return;	return;
}	}
result = (char *)emalloc(input_len + num_pad_chars + 1);	result = (char *)emalloc(input_len + num_pad_chars + 1);

Line 4976 PHP_FUNCTION(str_pad)	Line 5051 PHP_FUNCTION(str_pad)
RETURN_STRINGL(result, result_len, 0);	RETURN_STRINGL(result, result_len, 0);
}	}
/* }}} */	/* }}} */

/* {{{ proto mixed sscanf(string str, string format [, string ...])	/* {{{ proto mixed sscanf(string str, string format [, string ...])
Implements an ANSI C compatible sscanf */	Implements an ANSI C compatible sscanf */
PHP_FUNCTION(sscanf)	PHP_FUNCTION(sscanf)
Line 4985 PHP_FUNCTION(sscanf)	Line 5060 PHP_FUNCTION(sscanf)
char str, format;	char str, format;
int str_len, format_len, result, num_args = 0;	int str_len, format_len, result, num_args = 0;

if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss*", &str, &str_len, &format, &format_len,	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss*", &str, &str_len, &format, &format_len,
&args, &num_args) == FAILURE) {	&args, &num_args) == FAILURE) {
return;	return;
}	}

result = php_sscanf_internal(str, format, num_args, args, 0, &return_value TSRMLS_CC);	result = php_sscanf_internal(str, format, num_args, args, 0, &return_value TSRMLS_CC);

if (args) {	if (args) {
efree(args);	efree(args);
}	}
Line 5029 static void php_string_shuffle(char *str, long len TSR	Line 5104 static void php_string_shuffle(char *str, long len TSR
/* The implementation is stolen from array_data_shuffle */	/* The implementation is stolen from array_data_shuffle */
/* Thus the characteristics of the randomization are the same */	/* Thus the characteristics of the randomization are the same */
n_elems = len;	n_elems = len;

if (n_elems <= 1) {	if (n_elems <= 1) {
return;	return;
}	}

n_left = n_elems;	n_left = n_elems;

while (--n_left) {	while (--n_left) {
rnd_idx = php_rand(TSRMLS_C);	rnd_idx = php_rand(TSRMLS_C);
RAND_RANGE(rnd_idx, 0, n_left, PHP_RAND_MAX);	RAND_RANGE(rnd_idx, 0, n_left, PHP_RAND_MAX);
Line 5060 PHP_FUNCTION(str_shuffle)	Line 5135 PHP_FUNCTION(str_shuffle)
}	}

RETVAL_STRINGL(arg, arglen, 1);	RETVAL_STRINGL(arg, arglen, 1);
if (Z_STRLEN_P(return_value) > 1) {	if (Z_STRLEN_P(return_value) > 1) {
php_string_shuffle(Z_STRVAL_P(return_value), (long) Z_STRLEN_P(return_value) TSRMLS_CC);	php_string_shuffle(Z_STRVAL_P(return_value), (long) Z_STRLEN_P(return_value) TSRMLS_CC);
}	}
}	}
Line 5072 PHP_FUNCTION(str_shuffle)	Line 5147 PHP_FUNCTION(str_shuffle)
found inside the string. If format of 2 is specified, then the function	found inside the string. If format of 2 is specified, then the function
will return an associated array where the position of the word is the key	will return an associated array where the position of the word is the key
and the word itself is the value.	and the word itself is the value.

For the purpose of this function, 'word' is defined as a locale dependent	For the purpose of this function, 'word' is defined as a locale dependent
string containing alphabetic characters, which also may contain, but not start	string containing alphabetic characters, which also may contain, but not start
with "'" and "-" characters.	with "'" and "-" characters.
Line 5109 PHP_FUNCTION(str_word_count)	Line 5184 PHP_FUNCTION(str_word_count)
if (char_list) {	if (char_list) {
php_charmask((unsigned char *)char_list, char_list_len, ch TSRMLS_CC);	php_charmask((unsigned char *)char_list, char_list_len, ch TSRMLS_CC);
}	}

p = str;	p = str;
e = str + str_len;	e = str + str_len;

Line 5140 PHP_FUNCTION(str_word_count)	Line 5215 PHP_FUNCTION(str_word_count)
break;	break;
default:	default:
word_count++;	word_count++;
break;	break;
}	}
}	}
p++;	p++;
}	}

if (!type) {	if (!type) {
RETURN_LONG(word_count);	RETURN_LONG(word_count);
}	}
}	}

Line 5171 PHP_FUNCTION(money_format)	Line 5246 PHP_FUNCTION(money_format)
e = p + format_len;	e = p + format_len;
while ((p = memchr(p, '%', (e - p)))) {	while ((p = memchr(p, '%', (e - p)))) {
if (*(p + 1) == '%') {	if (*(p + 1) == '%') {
p += 2;	p += 2;
} else if (!check) {	} else if (!check) {
check = 1;	check = 1;
p++;	p++;
Line 5203 PHP_FUNCTION(str_split)	Line 5278 PHP_FUNCTION(str_split)
long split_length = 1;	long split_length = 1;
char *p;	char *p;
int n_reg_segments;	int n_reg_segments;

if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s\|l", &str, &str_len, &split_length) == FAILURE) {	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s\|l", &str, &str_len, &split_length) == FAILURE) {
return;	return;
}	}
Line 5240 PHP_FUNCTION(strpbrk)	Line 5315 PHP_FUNCTION(strpbrk)
{	{
char haystack, char_list;	char haystack, char_list;
int haystack_len, char_list_len;	int haystack_len, char_list_len;
char *p;	char haystack_ptr, cl_ptr;

if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &haystack, &haystack_len, &char_list, &char_list_len) == FAILURE) {	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &haystack, &haystack_len, &char_list, &char_list_len) == FAILURE) {
RETURN_FALSE;	RETURN_FALSE;
}	}

if (!char_list_len) {	if (!char_list_len) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "The character list cannot be empty");	php_error_docref(NULL TSRMLS_CC, E_WARNING, "The character list cannot be empty");
RETURN_FALSE;	RETURN_FALSE;
}	}

if ((p = strpbrk(haystack, char_list))) {	for (haystack_ptr = haystack; haystack_ptr < (haystack + haystack_len); ++haystack_ptr) {
RETURN_STRINGL(p, (haystack + haystack_len - p), 1);	for (cl_ptr = char_list; cl_ptr < (char_list + char_list_len); ++cl_ptr) {
} else {	if (cl_ptr == haystack_ptr) {
RETURN_FALSE;	RETURN_STRINGL(haystack_ptr, (haystack + haystack_len - haystack_ptr), 1);
	}
	}
}	}

	RETURN_FALSE;
}	}
/* }}} */	/* }}} */

Line 5286 PHP_FUNCTION(substr_compare)	Line 5365 PHP_FUNCTION(substr_compare)
if (offset >= s1_len) {	if (offset >= s1_len) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "The start position cannot exceed initial string length");	php_error_docref(NULL TSRMLS_CC, E_WARNING, "The start position cannot exceed initial string length");
RETURN_FALSE;	RETURN_FALSE;
}

if (len > s1_len - offset) {
len = s1_len - offset;
}	}

cmp_len = (uint) (len ? len : MAX(s2_len, (s1_len - offset)));	cmp_len = (uint) (len ? len : MAX(s2_len, (s1_len - offset)));

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>

Removed from v.1.1
changed lines
	Added in v.1.1.1.2