Returns part of a string */
PHP_FUNCTION(substr)
{
- zval **str, **from, **len;
+ char *str;
int l;
int f;
+ int str_len;
int argc = ZEND_NUM_ARGS();
-
- if (argc < 2 || argc > 3 || zend_get_parameters_ex(argc, &str, &from, &len) == FAILURE) {
- WRONG_PARAM_COUNT;
+
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sl|l", &str, &str_len, &f, &l) == FAILURE) {
+ return;
}
- convert_to_string_ex(str);
- convert_to_long_ex(from);
-
if (argc > 2) {
- convert_to_long_ex(len);
- l = Z_LVAL_PP(len);
- if ((l < 0 && -l > Z_STRLEN_PP(str))) {
+ if ((l < 0 && -l > str_len)) {
RETURN_FALSE;
- } else if (l > Z_STRLEN_PP(str)) {
- l = Z_STRLEN_PP(str);
+ } else if (l > str_len) {
+ l = str_len;
}
} else {
- l = Z_STRLEN_PP(str);
+ l = str_len;
}
- f = Z_LVAL_PP(from);
- if (f > Z_STRLEN_PP(str)) {
+ if (f > str_len) {
RETURN_FALSE;
- } else if (f < 0 && -f > Z_STRLEN_PP(str)) {
+ } else if (f < 0 && -f > str_len) {
f = 0;
}
- if (l < 0 && (l + Z_STRLEN_PP(str) - f) < 0) {
+ if (l < 0 && (l + str_len - f) < 0) {
RETURN_FALSE;
}
* of the string
*/
if (f < 0) {
- f = Z_STRLEN_PP(str) + f;
+ f = str_len + f;
if (f < 0) {
f = 0;
}
* needed to stop that many chars from the end of the string
*/
if (l < 0) {
- l = (Z_STRLEN_PP(str) - f) + l;
+ l = (str_len - f) + l;
if (l < 0) {
l = 0;
}
}
- if (f >= Z_STRLEN_PP(str)) {
+ if (f >= str_len) {
RETURN_FALSE;
}
- if ((f + l) > Z_STRLEN_PP(str)) {
- l = Z_STRLEN_PP(str) - f;
+ if ((f + l) > str_len) {
+ l = str_len - f;
}
- RETURN_STRINGL(Z_STRVAL_PP(str) + f, l, 1);
+ RETURN_STRINGL(str + f, l, 1);
}
/* }}} */
HashPosition pos_str, pos_from, pos_repl, pos_len;
zval **tmp_str = NULL, **tmp_from = NULL, **tmp_repl = NULL, **tmp_len= NULL;
-
- if (argc < 3 || argc > 4 || zend_get_parameters_ex(argc, &str, &repl, &from, &len) == FAILURE) {
- WRONG_PARAM_COUNT;
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ZZZ|Z", &str, &repl, &from, &len) == FAILURE) {
+ return;
}
if (Z_TYPE_PP(str) != IS_ARRAY) {
Quotes meta characters */
PHP_FUNCTION(quotemeta)
{
- zval **arg;
char *str, *old;
char *old_end;
char *p, *q;
char c;
-
- if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &arg) == FAILURE) {
- WRONG_PARAM_COUNT;
- }
-
- convert_to_string_ex(arg);
-
- old = Z_STRVAL_PP(arg);
- old_end = Z_STRVAL_PP(arg) + Z_STRLEN_PP(arg);
+ int old_len;
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &old, &old_len) == FAILURE) {
+ return;
+ }
+
+ old_end = old + old_len;
+
if (old == old_end) {
RETURN_FALSE;
}
- str = safe_emalloc(2, Z_STRLEN_PP(arg), 1);
+ str = safe_emalloc(2, old_len, 1);
for (p = old, q = str; p != old_end; p++) {
c = *p;
Returns ASCII value of character */
PHP_FUNCTION(ord)
{
- zval **str;
+ char *str;
+ int str_len;
- if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &str) == FAILURE) {
- WRONG_PARAM_COUNT;
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &str_len) == FAILURE) {
+ return;
}
- convert_to_string_ex(str);
-
- RETURN_LONG((unsigned char) Z_STRVAL_PP(str)[0]);
+
+ RETURN_LONG((unsigned char) str[0]);
}
/* }}} */
Uppercase the first character of every word in a string */
PHP_FUNCTION(ucwords)
{
- zval **str;
+ char *str;
register char *r, *r_end;
+ int str_len;
- if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &str) == FAILURE) {
- WRONG_PARAM_COUNT;
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &str_len) == FAILURE) {
+ return;
}
- convert_to_string_ex(str);
- if (!Z_STRLEN_PP(str)) {
+ if (!str_len) {
RETURN_EMPTY_STRING();
}
- ZVAL_STRINGL(return_value, Z_STRVAL_PP(str), Z_STRLEN_PP(str), 1);
+ ZVAL_STRINGL(return_value, str, str_len, 1);
r = Z_STRVAL_P(return_value);
*r = toupper((unsigned char) *r);
Translates characters in str using given translation tables */
PHP_FUNCTION(strtr)
{
- zval **str, **from, **to;
+ zval **from;
+ char *str, *to;
+ int str_len, to_len;
int ac = ZEND_NUM_ARGS();
-
- if (ac < 2 || ac > 3 || zend_get_parameters_ex(ac, &str, &from, &to) == FAILURE) {
- WRONG_PARAM_COUNT;
+
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sZ|s", &str, &str_len, &from, &to, &to_len) == FAILURE) {
+ return;
}
if (ac == 2 && Z_TYPE_PP(from) != IS_ARRAY) {
RETURN_FALSE;
}
- convert_to_string_ex(str);
-
/* shortcut for empty string */
- if (Z_STRLEN_PP(str) == 0) {
+ if (str_len == 0) {
RETURN_EMPTY_STRING();
}
if (ac == 2) {
- php_strtr_array(return_value, Z_STRVAL_PP(str), Z_STRLEN_PP(str), HASH_OF(*from));
+ php_strtr_array(return_value, str, str_len, HASH_OF(*from));
} else {
convert_to_string_ex(from);
- convert_to_string_ex(to);
- ZVAL_STRINGL(return_value, Z_STRVAL_PP(str), Z_STRLEN_PP(str), 1);
+ ZVAL_STRINGL(return_value, str, str_len, 1);
php_strtr(Z_STRVAL_P(return_value),
Z_STRLEN_P(return_value),
Z_STRVAL_PP(from),
- Z_STRVAL_PP(to),
+ to,
MIN(Z_STRLEN_PP(from),
- Z_STRLEN_PP(to)));
+ to_len));
}
}
/* }}} */
Reverse a string */
PHP_FUNCTION(strrev)
{
- zval **str;
- char *s, *e, *n, *p;
+ char *str;
+ char *e, *n, *p;
+ int str_len;
- if (ZEND_NUM_ARGS()!=1 || zend_get_parameters_ex(1, &str) == FAILURE) {
- WRONG_PARAM_COUNT;
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &str_len) == FAILURE) {
+ return;
}
- convert_to_string_ex(str);
- n = emalloc(Z_STRLEN_PP(str)+1);
+ n = emalloc(str_len+1);
p = n;
- s = Z_STRVAL_PP(str);
- e = s + Z_STRLEN_PP(str);
+ e = str + str_len;
- while (--e>=s) {
+ while (--e>=str) {
*p++ = *e;
}
*p = '\0';
- RETVAL_STRINGL(n, Z_STRLEN_PP(str), 0);
+ RETVAL_STRINGL(n, str_len, 0);
}
/* }}} */
Calculates the similarity between two strings */
PHP_FUNCTION(similar_text)
{
- zval **t1, **t2, **percent;
+ char *t1, *t2;
+ zval **percent;
int ac = ZEND_NUM_ARGS();
int sim;
+ int t1_len, t2_len;
+
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|Z", &t1, &t1_len, &t2, &t2_len, &percent) == FAILURE) {
+ return;
+ }
- if (ac < 2 || ac > 3 || zend_get_parameters_ex(ac, &t1, &t2, &percent) == FAILURE) {
- WRONG_PARAM_COUNT;
- }
-
- convert_to_string_ex(t1);
- convert_to_string_ex(t2);
-
if (ac > 2) {
convert_to_double_ex(percent);
}
- if (Z_STRLEN_PP(t1) + Z_STRLEN_PP(t2) == 0) {
+ if (t1_len + t2_len == 0) {
if (ac > 2) {
Z_DVAL_PP(percent) = 0;
}
RETURN_LONG(0);
}
- sim = php_similar_char(Z_STRVAL_PP(t1), Z_STRLEN_PP(t1), Z_STRVAL_PP(t2), Z_STRLEN_PP(t2));
+ sim = php_similar_char(t1, t1_len, t2, t2_len);
if (ac > 2) {
- Z_DVAL_PP(percent) = sim * 200.0 / (Z_STRLEN_PP(t1) + Z_STRLEN_PP(t2));
+ Z_DVAL_PP(percent) = sim * 200.0 / (t1_len + t2_len);
}
RETURN_LONG(sim);
Escapes all chars mentioned in charlist with backslash. It creates octal representations if asked to backslash characters with 8th bit set or with ASCII<32 (except '\n', '\r', '\t' etc...) */
PHP_FUNCTION(addcslashes)
{
- zval **str, **what;
+ char *str, *what;
+ int str_len, what_len;
- if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &str, &what) == FAILURE) {
- WRONG_PARAM_COUNT;
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &str, &str_len, &what, &what_len) == FAILURE) {
+ return;
}
- convert_to_string_ex(str);
- convert_to_string_ex(what);
- if (Z_STRLEN_PP(str) == 0) {
+ if (str_len == 0) {
RETURN_EMPTY_STRING();
}
- if (Z_STRLEN_PP(what) == 0) {
- RETURN_STRINGL(Z_STRVAL_PP(str), Z_STRLEN_PP(str), 1);
+ if (what_len == 0) {
+ RETURN_STRINGL(str, str_len, 1);
}
- Z_STRVAL_P(return_value) = php_addcslashes(Z_STRVAL_PP(str), Z_STRLEN_PP(str), &Z_STRLEN_P(return_value), 0, Z_STRVAL_PP(what), Z_STRLEN_PP(what) TSRMLS_CC);
+ Z_STRVAL_P(return_value) = php_addcslashes(str, str_len, &Z_STRLEN_P(return_value), 0, what, what_len TSRMLS_CC);
RETURN_STRINGL(Z_STRVAL_P(return_value), Z_STRLEN_P(return_value), 0);
}
/* }}} */
Escapes single quote, double quotes and backslash characters in a string with backslashes */
PHP_FUNCTION(addslashes)
{
- zval **str;
-
- if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &str) == FAILURE) {
- WRONG_PARAM_COUNT;
+ char *str;
+ int str_len;
+
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &str_len) == FAILURE) {
+ return;
}
- convert_to_string_ex(str);
- if (Z_STRLEN_PP(str) == 0) {
+ if (str_len == 0) {
RETURN_EMPTY_STRING();
}
- RETURN_STRING(php_addslashes(Z_STRVAL_PP(str),
- Z_STRLEN_PP(str),
+ RETURN_STRING(php_addslashes(str,
+ str_len,
&Z_STRLEN_P(return_value), 0
TSRMLS_CC), 0);
}
Strips backslashes from a string. Uses C-style conventions */
PHP_FUNCTION(stripcslashes)
{
- zval **str;
+ char *str;
+ int str_len;
- if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &str) == FAILURE) {
- WRONG_PARAM_COUNT;
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &str_len) == FAILURE) {
+ return;
}
- convert_to_string_ex(str);
- ZVAL_STRINGL(return_value, Z_STRVAL_PP(str), Z_STRLEN_PP(str), 1);
+ ZVAL_STRINGL(return_value, str, str_len, 1);
php_stripcslashes(Z_STRVAL_P(return_value), &Z_STRLEN_P(return_value));
}
/* }}} */
Strips backslashes from a string */
PHP_FUNCTION(stripslashes)
{
- zval **str;
+ char *str;
+ int str_len;
- if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &str) == FAILURE) {
- WRONG_PARAM_COUNT;
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &str_len) == FAILURE) {
+ return;
}
- convert_to_string_ex(str);
- ZVAL_STRINGL(return_value, Z_STRVAL_PP(str), Z_STRLEN_PP(str), 1);
+ ZVAL_STRINGL(return_value, str, str_len, 1);
php_stripslashes(Z_STRVAL_P(return_value), &Z_STRLEN_P(return_value) TSRMLS_CC);
}
/* }}} */
int count = 0;
int argc = ZEND_NUM_ARGS();
- if (argc < 3 || argc > 4 ||
- zend_get_parameters_ex(argc, &search, &replace, &subject, &zcount) == FAILURE) {
- WRONG_PARAM_COUNT;
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ZZZ|Z", &search, &replace, &subject, &zcount) == FAILURE) {
+ return;
}
SEPARATE_ZVAL(search);
*/
static void php_hebrev(INTERNAL_FUNCTION_PARAMETERS, int convert_newlines)
{
- zval **str, **max_chars_per_line;
+ char *str;
char *heb_str, *tmp, *target, *broken_str;
int block_start, block_end, block_type, block_length, i;
long max_chars=0;
int begin, end, char_count, orig_begin;
-
+ int str_len;
- switch (ZEND_NUM_ARGS()) {
- case 1:
- if (zend_get_parameters_ex(1, &str) == FAILURE) {
- RETURN_FALSE;
- }
- break;
- case 2:
- if (zend_get_parameters_ex(2, &str, &max_chars_per_line) == FAILURE) {
- RETURN_FALSE;
- }
- convert_to_long_ex(max_chars_per_line);
- max_chars = Z_LVAL_PP(max_chars_per_line);
- break;
- default:
- WRONG_PARAM_COUNT;
- break;
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &str, &str_len, &max_chars) == FAILURE) {
+ return;
}
- convert_to_string_ex(str);
-
- if (Z_STRLEN_PP(str) == 0) {
+ if (str_len == 0) {
RETURN_FALSE;
}
- tmp = Z_STRVAL_PP(str);
+ tmp = str;
block_start=block_end=0;
- heb_str = (char *) emalloc(Z_STRLEN_PP(str)+1);
- target = heb_str+Z_STRLEN_PP(str);
+ heb_str = (char *) emalloc(str_len+1);
+ target = heb_str+str_len;
*target = 0;
target--;
do {
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<Z_STRLEN_PP(str)-1) {
+ while ((isheb((int)*(tmp+1)) || _isblank((int)*(tmp+1)) || ispunct((int)*(tmp+1)) || (int)*(tmp+1)=='\n' ) && block_end<str_len-1) {
tmp++;
block_end++;
block_length++;
}
for (i = block_start; i<= block_end; i++) {
- *target = Z_STRVAL_PP(str)[i];
+ *target = str[i];
switch (*target) {
case '(':
*target = ')';
}
block_type = _HEB_BLOCK_TYPE_ENG;
} else {
- while (!isheb(*(tmp+1)) && (int)*(tmp+1)!='\n' && block_end < Z_STRLEN_PP(str)-1) {
+ while (!isheb(*(tmp+1)) && (int)*(tmp+1)!='\n' && block_end < str_len-1) {
tmp++;
block_end++;
block_length++;
block_end--;
}
for (i = block_end; i >= block_start; i--) {
- *target = Z_STRVAL_PP(str)[i];
+ *target = str[i];
target--;
}
block_type = _HEB_BLOCK_TYPE_HEB;
}
block_start=block_end+1;
- } while (block_end < Z_STRLEN_PP(str)-1);
+ } while (block_end < str_len-1);
- broken_str = (char *) emalloc(Z_STRLEN_PP(str)+1);
- begin=end=Z_STRLEN_PP(str)-1;
+ broken_str = (char *) emalloc(str_len+1);
+ begin=end=str_len-1;
target = broken_str;
while (1) {
efree(heb_str);
if (convert_newlines) {
- php_char_to_str(broken_str, Z_STRLEN_PP(str),'\n', "<br />\n", 7, return_value);
+ php_char_to_str(broken_str, str_len,'\n', "<br />\n", 7, return_value);
efree(broken_str);
} else {
Z_STRVAL_P(return_value) = broken_str;
- Z_STRLEN_P(return_value) = Z_STRLEN_PP(str);
+ Z_STRLEN_P(return_value) = str_len;
Z_TYPE_P(return_value) = IS_STRING;
}
}
PHP_FUNCTION(nl2br)
{
/* in brief this inserts <br /> before matched regexp \n\r?|\r\n? */
- zval **zstr;
char *tmp, *str;
int new_length;
char *end, *target;
int repl_cnt = 0;
-
- if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &zstr) == FAILURE) {
- WRONG_PARAM_COUNT;
+ int str_len;
+
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &str_len) == FAILURE) {
+ return;
}
- convert_to_string_ex(zstr);
-
- str = Z_STRVAL_PP(zstr);
- end = str + Z_STRLEN_PP(zstr);
+ tmp = str;
+ end = str + str_len;
/* it is really faster to scan twice and allocate mem once insted scanning once
and constantly reallocing */
- while (str < end) {
- if (*str == '\r') {
- if (*(str+1) == '\n') {
- str++;
+ while (tmp < end) {
+ if (*tmp == '\r') {
+ if (*(tmp+1) == '\n') {
+ tmp++;
}
repl_cnt++;
- } else if (*str == '\n') {
- if (*(str+1) == '\r') {
- str++;
+ } else if (*tmp == '\n') {
+ if (*(tmp+1) == '\r') {
+ tmp++;
}
repl_cnt++;
}
- str++;
+ tmp++;
}
if (repl_cnt == 0) {
- RETURN_STRINGL(Z_STRVAL_PP(zstr), Z_STRLEN_PP(zstr), 1);
+ RETURN_STRINGL(str, str_len, 1);
}
- new_length = Z_STRLEN_PP(zstr) + repl_cnt * (sizeof("<br />") - 1);
+ new_length = str_len + repl_cnt * (sizeof("<br />") - 1);
tmp = target = emalloc(new_length + 1);
- str = Z_STRVAL_PP(zstr);
-
while (str < end) {
switch (*str) {
case '\r':
PHP_FUNCTION(strip_tags)
{
char *buf;
- zval **str, **allow=NULL;
+ char *str;
+ zval **allow=NULL;
char *allowed_tags=NULL;
int allowed_tags_len=0;
+ int str_len;
size_t retval_len;
- switch (ZEND_NUM_ARGS()) {
- case 1:
- if (zend_get_parameters_ex(1, &str) == FAILURE) {
- RETURN_FALSE;
- }
- break;
- case 2:
- if (zend_get_parameters_ex(2, &str, &allow) == FAILURE) {
- RETURN_FALSE;
- }
- convert_to_string_ex(allow);
- allowed_tags = Z_STRVAL_PP(allow);
- allowed_tags_len = Z_STRLEN_PP(allow);
- break;
- default:
- WRONG_PARAM_COUNT;
- break;
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|Z", &str, &str_len, &allow) == FAILURE) {
+ return;
}
- convert_to_string_ex(str);
- buf = estrndup(Z_STRVAL_PP(str), Z_STRLEN_PP(str));
- retval_len = php_strip_tags_ex(buf, Z_STRLEN_PP(str), NULL, allowed_tags, allowed_tags_len, 0);
+
+ /* To maintain a certain BC, we allow anything for the second parameter and return original string */
+ if (allow != NULL) {
+ convert_to_string_ex(allow);
+ allowed_tags = Z_STRVAL_PP(allow);
+ allowed_tags_len = Z_STRLEN_PP(allow);
+ }
+
+ buf = estrndup(str, str_len);
+ retval_len = php_strip_tags_ex(buf, str_len, NULL, allowed_tags, allowed_tags_len, 0);
RETURN_STRINGL(buf, retval_len, 0);
}
/* }}} */
Parses GET/POST/COOKIE data and sets global variables */
PHP_FUNCTION(parse_str)
{
- zval **arg;
- zval **arrayArg;
+ char *arg;
+ zval **arrayArg = NULL;
zval *sarg;
char *res = NULL;
- int argCount;
+ int arglen;
- argCount = ZEND_NUM_ARGS();
- if (argCount < 1 || argCount > 2 || zend_get_parameters_ex(argCount, &arg, &arrayArg) == FAILURE) {
- WRONG_PARAM_COUNT;
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|Z", &arg, &arglen, &arrayArg) == FAILURE) {
+ return;
}
- convert_to_string_ex(arg);
- sarg = *arg;
- if (Z_STRVAL_P(sarg) && *Z_STRVAL_P(sarg)) {
- res = estrndup(Z_STRVAL_P(sarg), Z_STRLEN_P(sarg));
+ if (!arglen) {
+ return;
}
- if (argCount == 1) {
+ res = estrndup(arg, arglen);
+
+ if (arrayArg == NULL) {
zval tmp;
if (!EG(active_symbol_table)) {
Returns the input string repeat mult times */
PHP_FUNCTION(str_repeat)
{
- zval **input_str; /* Input string */
- zval **mult; /* Multiplier */
+ char *input_str; /* Input string */
+ int input_len;
+ int mult; /* Multiplier */
char *result; /* Resulting string */
size_t result_len; /* Length of the resulting string */
- if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &input_str, &mult) == FAILURE) {
- WRONG_PARAM_COUNT;
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sl", &input_str, &input_len, &mult) == FAILURE) {
+ return;
}
-
- /* Make sure we're dealing with proper types */
- convert_to_string_ex(input_str);
- convert_to_long_ex(mult);
-
- if (Z_LVAL_PP(mult) < 0) {
+
+ if (mult < 0) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Second argument has to be greater than or equal to 0");
return;
}
/* Don't waste our time if it's empty */
- if (Z_STRLEN_PP(input_str) == 0)
- RETURN_STRINGL("", 0, 1);
-
/* ... or if the multiplier is zero */
- if (Z_LVAL_PP(mult) == 0)
- RETURN_STRINGL("", 0, 1);
-
+ if (input_len == 0 || mult == 0)
+ RETURN_EMPTY_STRING();
+
/* Initialize the result string */
- result_len = Z_STRLEN_PP(input_str) * Z_LVAL_PP(mult);
- result = (char *)safe_emalloc(Z_STRLEN_PP(input_str), Z_LVAL_PP(mult), 1);
+ result_len = input_len * mult;
+ result = (char *)safe_emalloc(input_len, mult, 1);
/* Heavy optimization for situations where input string is 1 byte long */
- if (Z_STRLEN_PP(input_str) == 1) {
- memset(result, *(Z_STRVAL_PP(input_str)), Z_LVAL_PP(mult));
+ if (input_len == 1) {
+ memset(result, *(input_str), mult);
} else {
char *s, *e, *ee;
int l=0;
- memcpy(result, Z_STRVAL_PP(input_str), Z_STRLEN_PP(input_str));
+ memcpy(result, input_str, input_len);
s = result;
- e = result + Z_STRLEN_PP(input_str);
+ e = result + input_len;
ee = result + result_len;
while (e<ee) {
Returns info about what characters are used in input */
PHP_FUNCTION(count_chars)
{
- zval **input, **mode;
+ char *input;
int chars[256];
- int ac=ZEND_NUM_ARGS();
int mymode=0;
unsigned char *buf;
int len, inx;
char retstr[256];
int retlen=0;
- if (ac < 1 || ac > 2 || zend_get_parameters_ex(ac, &input, &mode) == FAILURE) {
- WRONG_PARAM_COUNT;
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &input, &len, &mymode) == FAILURE) {
+ return;
}
-
- convert_to_string_ex(input);
- if (ac == 2) {
- convert_to_long_ex(mode);
- mymode = Z_LVAL_PP(mode);
-
- if (mymode < 0 || mymode > 4) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown mode");
- RETURN_FALSE;
- }
+ if (mymode < 0 || mymode > 4) {
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown mode");
+ RETURN_FALSE;
}
-
- len = Z_STRLEN_PP(input);
- buf = (unsigned char *) Z_STRVAL_PP(input);
+
+ buf = (unsigned char *) input;
memset((void*) chars, 0, sizeof(chars));
while (len > 0) {
*/
static void php_strnatcmp(INTERNAL_FUNCTION_PARAMETERS, int fold_case)
{
- zval **s1, **s2;
+ char *s1, *s2;
+ int s1_len, s2_len;
- if (ZEND_NUM_ARGS()!=2 || zend_get_parameters_ex(2, &s1, &s2) == FAILURE) {
- WRONG_PARAM_COUNT;
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &s1, &s1_len, &s2, &s2_len) == FAILURE) {
+ return;
}
- convert_to_string_ex(s1);
- convert_to_string_ex(s2);
-
- RETURN_LONG(strnatcmp_ex(Z_STRVAL_PP(s1), Z_STRLEN_PP(s1),
- Z_STRVAL_PP(s2), Z_STRLEN_PP(s2),
+ RETURN_LONG(strnatcmp_ex(s1, s1_len,
+ s2, s2_len,
fold_case));
}
/* }}} */
Returns the number of times a substring occurs in the string */
PHP_FUNCTION(substr_count)
{
- zval **haystack, **needle, **offset, **length;
+ char *haystack, *needle;
+ int offset = 0;
+ int length;
int ac = ZEND_NUM_ARGS();
int count = 0;
+ int haystack_len, needle_len;
char *p, *endp, cmp;
- if (ac < 2 || ac > 4 || zend_get_parameters_ex(ac, &haystack, &needle, &offset, &length) == FAILURE) {
- WRONG_PARAM_COUNT;
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|ll", &haystack, &haystack_len, &needle, &needle_len, &offset, &length) == FAILURE) {
+ return;
}
- convert_to_string_ex(haystack);
- convert_to_string_ex(needle);
-
- if (Z_STRLEN_PP(needle) == 0) {
+ if (needle_len == 0) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Empty substring");
RETURN_FALSE;
}
- p = Z_STRVAL_PP(haystack);
- endp = p + Z_STRLEN_PP(haystack);
-
- if (ac > 2) {
- convert_to_long_ex(offset);
- if (Z_LVAL_PP(offset) < 0) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Offset should be greater than or equal to 0");
- RETURN_FALSE;
- }
+ p = haystack;
+ endp = p + haystack_len;
- if (Z_LVAL_PP(offset) > Z_STRLEN_PP(haystack)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Offset value %ld exceeds string length", Z_LVAL_PP(offset));
+ if (offset < 0) {
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Offset should be greater than or equal to 0");
+ RETURN_FALSE;
+ }
+
+ if (offset > haystack_len) {
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Offset value %ld exceeds string length", offset);
+ RETURN_FALSE;
+ }
+ p += offset;
+
+ if (ac == 4) {
+
+ if (length <= 0) {
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Length should be greater than 0");
RETURN_FALSE;
}
- p += Z_LVAL_PP(offset);
-
- if (ac == 4) {
- convert_to_long_ex(length);
- if (Z_LVAL_PP(length) <= 0) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Length should be greater than 0");
- RETURN_FALSE;
- }
- if (Z_LVAL_PP(length) > (Z_STRLEN_PP(haystack) - Z_LVAL_PP(offset))) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Length value %ld exceeds string length", Z_LVAL_PP(length));
- RETURN_FALSE;
- }
- endp = p + Z_LVAL_PP(length);
+ if (length > (haystack_len - offset)) {
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Length value %ld exceeds string length", length);
+ RETURN_FALSE;
}
+ endp = p + length;
}
- if (Z_STRLEN_PP(needle) == 1) {
- cmp = Z_STRVAL_PP(needle)[0];
+ if (needle_len == 1) {
+ cmp = needle[0];
while ((p = memchr(p, cmp, endp - p))) {
count++;
p++;
}
} else {
- while ((p = php_memnstr(p, Z_STRVAL_PP(needle), Z_STRLEN_PP(needle), endp))) {
- p += Z_STRLEN_PP(needle);
+ while ((p = php_memnstr(p, needle, needle_len, endp))) {
+ p += needle_len;
count++;
}
}
PHP_FUNCTION(str_pad)
{
/* Input arguments */
- zval **input, /* Input string */
- **pad_length, /* Length to pad to */
- **pad_string, /* Padding string */
- **pad_type; /* Padding type (left/right/both) */
+ char *input; /* Input string */
+ int input_len;
+ int pad_length; /* Length to pad to */
/* Helper variables */
int num_pad_chars; /* Number of padding characters (total - input size) */
int pad_type_val = STR_PAD_RIGHT; /* The padding type value */
int i, left_pad=0, right_pad=0;
-
- if (ZEND_NUM_ARGS() < 2 || ZEND_NUM_ARGS() > 4 ||
- zend_get_parameters_ex(ZEND_NUM_ARGS(), &input, &pad_length, &pad_string, &pad_type) == FAILURE) {
- WRONG_PARAM_COUNT;
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sl|sl", &input, &input_len, &pad_length,
+ &pad_str_val, &pad_str_len, &pad_type_val) == FAILURE) {
+ return;
}
- /* Perform initial conversion to expected data types. */
- convert_to_string_ex(input);
- convert_to_long_ex(pad_length);
-
- num_pad_chars = Z_LVAL_PP(pad_length) - Z_STRLEN_PP(input);
+ num_pad_chars = pad_length - input_len;
/* If resulting string turns out to be shorter than input string,
we simply copy the input and return. */
- if (Z_LVAL_PP(pad_length) < 0 || num_pad_chars < 0) {
- RETURN_ZVAL(*input, 1, 0);
+ if (pad_length < 0 || num_pad_chars < 0) {
+ RETURN_STRINGL(input, input_len, 1);
}
- /* Setup the padding string values if specified. */
- if (ZEND_NUM_ARGS() > 2) {
- convert_to_string_ex(pad_string);
- if (Z_STRLEN_PP(pad_string) == 0) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Padding string cannot be empty");
- return;
- }
- pad_str_val = Z_STRVAL_PP(pad_string);
- pad_str_len = Z_STRLEN_PP(pad_string);
-
- if (ZEND_NUM_ARGS() > 3) {
- convert_to_long_ex(pad_type);
- pad_type_val = Z_LVAL_PP(pad_type);
- 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");
- return;
- }
- }
+ if (pad_str_len == 0) {
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Padding string cannot be empty");
+ return;
+ }
+
+ 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");
+ return;
}
- result = (char *)emalloc(Z_STRLEN_PP(input) + num_pad_chars + 1);
+ result = (char *)emalloc(input_len + num_pad_chars + 1);
/* We need to figure out the left/right padding lengths. */
switch (pad_type_val) {
result[result_len++] = pad_str_val[i % pad_str_len];
/* Then we copy the input string. */
- memcpy(result + result_len, Z_STRVAL_PP(input), Z_STRLEN_PP(input));
- result_len += Z_STRLEN_PP(input);
+ memcpy(result + result_len, input, input_len);
+ result_len += input_len;
/* Finally, we pad on the right. */
for (i = 0; i < right_pad; i++)
Perform the rot13 transform on a string */
PHP_FUNCTION(str_rot13)
{
- zval **arg;
+ char *arg;
+ int arglen;
- if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &arg)) {
- WRONG_PARAM_COUNT;
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &arg, &arglen) == FAILURE) {
+ return;
}
- convert_to_string_ex(arg);
- RETVAL_ZVAL(*arg, 1, 0);
+ RETVAL_STRINGL(arg, arglen, 1);
php_strtr(Z_STRVAL_P(return_value), Z_STRLEN_P(return_value), rot13_from, rot13_to, 52);
}
Shuffles string. One permutation of all possible is created */
PHP_FUNCTION(str_shuffle)
{
- zval **arg;
-
- if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &arg)) {
- WRONG_PARAM_COUNT;
+ char *arg;
+ int arglen;
+
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &arg, &arglen) == FAILURE) {
+ return;
}
-
- convert_to_string_ex(arg);
- RETVAL_ZVAL(*arg, 1, 0);
+
+ RETVAL_STRINGL(arg, arglen, 1);
if (Z_STRLEN_P(return_value) > 1) {
php_string_shuffle(Z_STRVAL_P(return_value), (long) Z_STRLEN_P(return_value) TSRMLS_CC);
}
projects / php / commitdiff