version 1.1.1.2, 2012/05/29 12:34:43
|
version 1.1.1.4, 2013/10/14 08:02:35
|
Line 2
|
Line 2
|
+----------------------------------------------------------------------+ |
+----------------------------------------------------------------------+ |
| PHP Version 5 | |
| PHP Version 5 | |
+----------------------------------------------------------------------+ |
+----------------------------------------------------------------------+ |
| Copyright (c) 1997-2012 The PHP Group | | | Copyright (c) 1997-2013 The PHP Group | |
+----------------------------------------------------------------------+ |
+----------------------------------------------------------------------+ |
| This source file is subject to version 3.01 of the PHP license, | |
| This source file is subject to version 3.01 of the PHP license, | |
| that is bundled with this package in the file LICENSE, and is | |
| that is bundled with this package in the file LICENSE, and is | |
Line 23
|
Line 23
|
/* Synced with php 3.0 revision 1.193 1999-06-16 [ssb] */ |
/* Synced with php 3.0 revision 1.193 1999-06-16 [ssb] */ |
|
|
#include <stdio.h> |
#include <stdio.h> |
|
#ifdef PHP_WIN32 |
|
# include "win32/php_stdint.h" |
|
#else |
|
# include <stdint.h> |
|
#endif |
#include "php.h" |
#include "php.h" |
#include "php_rand.h" |
#include "php_rand.h" |
#include "php_string.h" |
#include "php_string.h" |
Line 57
|
Line 62
|
#include "php_globals.h" |
#include "php_globals.h" |
#include "basic_functions.h" |
#include "basic_functions.h" |
#include "php_smart_str.h" |
#include "php_smart_str.h" |
|
#include <Zend/zend_exceptions.h> |
#ifdef ZTS |
#ifdef ZTS |
#include "TSRM.h" |
#include "TSRM.h" |
#endif |
#endif |
Line 131 static char *php_bin2hex(const unsigned char *old, con
|
Line 137 static char *php_bin2hex(const unsigned char *old, con
|
register unsigned char *result = NULL; |
register unsigned char *result = NULL; |
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]; |
Line 266 PHP_FUNCTION(hex2bin)
|
Line 272 PHP_FUNCTION(hex2bin)
|
return; |
return; |
} |
} |
|
|
|
if (datalen % 2 != 0) { |
|
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Hexadecimal input string must have an even length"); |
|
RETURN_FALSE; |
|
} |
|
|
result = php_hex2bin((unsigned char *)data, datalen, &newlen); |
result = php_hex2bin((unsigned char *)data, datalen, &newlen); |
|
|
if (!result) { |
if (!result) { |
Line 1570 PHP_FUNCTION(pathinfo)
|
Line 1581 PHP_FUNCTION(pathinfo)
|
const char *p; |
const char *p; |
int idx; |
int idx; |
|
|
/* Have we alrady looked up the basename? */ | /* Have we already looked up the basename? */ |
if (!have_basename && !ret) { |
if (!have_basename && !ret) { |
php_basename(path, path_len, NULL, 0, &ret, &ret_len TSRMLS_CC); |
php_basename(path, path_len, NULL, 0, &ret, &ret_len TSRMLS_CC); |
} |
} |
Line 1704 PHP_FUNCTION(stristr)
|
Line 1715 PHP_FUNCTION(stristr)
|
if (Z_TYPE_P(needle) == IS_STRING) { |
if (Z_TYPE_P(needle) == IS_STRING) { |
char *orig_needle; |
char *orig_needle; |
if (!Z_STRLEN_P(needle)) { |
if (!Z_STRLEN_P(needle)) { |
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Empty delimiter"); | php_error_docref(NULL TSRMLS_CC, E_WARNING, "Empty needle"); |
efree(haystack_dup); |
efree(haystack_dup); |
RETURN_FALSE; |
RETURN_FALSE; |
} |
} |
Line 1754 PHP_FUNCTION(strstr)
|
Line 1765 PHP_FUNCTION(strstr)
|
|
|
if (Z_TYPE_P(needle) == IS_STRING) { |
if (Z_TYPE_P(needle) == IS_STRING) { |
if (!Z_STRLEN_P(needle)) { |
if (!Z_STRLEN_P(needle)) { |
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Empty delimiter"); | php_error_docref(NULL TSRMLS_CC, E_WARNING, "Empty needle"); |
RETURN_FALSE; |
RETURN_FALSE; |
} |
} |
|
|
Line 1806 PHP_FUNCTION(strpos)
|
Line 1817 PHP_FUNCTION(strpos)
|
|
|
if (Z_TYPE_P(needle) == IS_STRING) { |
if (Z_TYPE_P(needle) == IS_STRING) { |
if (!Z_STRLEN_P(needle)) { |
if (!Z_STRLEN_P(needle)) { |
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Empty delimiter"); | php_error_docref(NULL TSRMLS_CC, E_WARNING, "Empty needle"); |
RETURN_FALSE; |
RETURN_FALSE; |
} |
} |
|
|
Line 2767 PHPAPI char *php_strtr(char *str, int len, char *str_f
|
Line 2778 PHPAPI char *php_strtr(char *str, int len, char *str_f
|
} |
} |
/* }}} */ |
/* }}} */ |
|
|
/* {{{ php_strtr_array | /* {{{ Definitions for php_strtr_array */ |
*/ | typedef size_t STRLEN; /* STRLEN should be unsigned */ |
static void php_strtr_array(zval *return_value, char *str, int slen, HashTable *hash) | typedef uint16_t HASH; |
{ | typedef struct { |
zval **entry; | HASH table_mask; |
char *string_key; | STRLEN entries[1]; |
uint string_key_len; | } SHIFT_TAB; |
zval **trans; | typedef struct { |
zval ctmp; | HASH table_mask; |
ulong num_key; | int entries[1]; |
int minlen = 128*1024; | } HASH_TAB; |
int maxlen = 0, pos, len, found; | typedef struct { |
char *key; | const char *s; |
HashPosition hpos; | STRLEN l; |
smart_str result = {0}; | } STR; |
HashTable tmp_hash; | typedef struct _pat_and_repl { |
| STR pat; |
| STR repl; |
| } PATNREPL; |
|
|
zend_hash_init(&tmp_hash, zend_hash_num_elements(hash), NULL, NULL, 0); | #define S(a) ((a)->s) |
zend_hash_internal_pointer_reset_ex(hash, &hpos); | #define L(a) ((a)->l) |
while (zend_hash_get_current_data_ex(hash, (void **)&entry, &hpos) == SUCCESS) { | |
switch (zend_hash_get_current_key_ex(hash, &string_key, &string_key_len, &num_key, 0, &hpos)) { | |
case HASH_KEY_IS_STRING: | |
len = string_key_len-1; | |
if (len < 1) { | |
zend_hash_destroy(&tmp_hash); | |
RETURN_FALSE; | |
} | |
zend_hash_add(&tmp_hash, string_key, string_key_len, entry, sizeof(zval*), NULL); | |
if (len > maxlen) { | |
maxlen = len; | |
} | |
if (len < minlen) { | |
minlen = len; | |
} | |
break; | |
|
|
case HASH_KEY_IS_LONG: | #define SHIFT_TAB_BITS 13 |
Z_TYPE(ctmp) = IS_LONG; | #define HASH_TAB_BITS 10 /* should be less than sizeof(HASH) * 8 */ |
Z_LVAL(ctmp) = num_key; | #define SHIFT_TAB_SIZE (1U << SHIFT_TAB_BITS) |
| #define HASH_TAB_SIZE (1U << HASH_TAB_BITS) |
|
|
convert_to_string(&ctmp); | typedef struct { |
len = Z_STRLEN(ctmp); | int B; /* size of suffixes */ |
zend_hash_add(&tmp_hash, Z_STRVAL(ctmp), len+1, entry, sizeof(zval*), NULL); | int Bp; /* size of prefixes */ |
zval_dtor(&ctmp); | STRLEN m; /* minimum pattern length */ |
| int patnum; /* number of patterns */ |
| SHIFT_TAB *shift; /* table mapping hash to allowed shift */ |
| HASH_TAB *hash; /* table mapping hash to int (pair of pointers) */ |
| HASH *prefix; /* array of hashes of prefixes by pattern suffix hash order */ |
| PATNREPL *patterns; /* array of prefixes by pattern suffix hash order */ |
| } PPRES; |
| /* }}} */ |
|
|
if (len > maxlen) { | /* {{{ php_strtr_hash */ |
maxlen = len; | static inline HASH php_strtr_hash(const char *str, int len) |
} | { |
if (len < minlen) { | HASH res = 0; |
minlen = len; | int i; |
} | for (i = 0; i < len; i++) { |
break; | res = res * 33 + (unsigned char)str[i]; |
| } |
| |
| return res; |
| } |
| /* }}} */ |
| /* {{{ php_strtr_populate_shift */ |
| static inline void php_strtr_populate_shift(PATNREPL *patterns, int patnum, int B, STRLEN m, SHIFT_TAB *shift) |
| { |
| int i; |
| STRLEN j, |
| max_shift; |
| |
| max_shift = m - B + 1; |
| for (i = 0; i < SHIFT_TAB_SIZE; i++) { |
| shift->entries[i] = max_shift; |
| } |
| for (i = 0; i < patnum; i++) { |
| for (j = 0; j < m - B + 1; j++) { |
| HASH h = php_strtr_hash(&S(&patterns[i].pat)[j], B) & shift->table_mask; |
| assert((long long) m - (long long) j - B >= 0); |
| shift->entries[h] = MIN(shift->entries[h], m - j - B); |
} |
} |
zend_hash_move_forward_ex(hash, &hpos); |
|
} |
} |
|
} |
|
/* }}} */ |
|
/* {{{ php_strtr_compare_hash_suffix */ |
|
static int php_strtr_compare_hash_suffix(const void *a, const void *b, void *ctx_g) |
|
{ |
|
const PPRES *res = ctx_g; |
|
const PATNREPL *pnr_a = a, |
|
*pnr_b = b; |
|
HASH hash_a = php_strtr_hash(&S(&pnr_a->pat)[res->m - res->B], res->B) |
|
& res->hash->table_mask, |
|
hash_b = php_strtr_hash(&S(&pnr_b->pat)[res->m - res->B], res->B) |
|
& res->hash->table_mask; |
|
/* TODO: don't recalculate the hashes all the time */ |
|
if (hash_a > hash_b) { |
|
return 1; |
|
} else if (hash_a < hash_b) { |
|
return -1; |
|
} else { |
|
/* longer patterns must be sorted first */ |
|
if (L(&pnr_a->pat) > L(&pnr_b->pat)) { |
|
return -1; |
|
} else if (L(&pnr_a->pat) < L(&pnr_b->pat)) { |
|
return 1; |
|
} else { |
|
return 0; |
|
} |
|
} |
|
} |
|
/* }}} */ |
|
/* {{{ Sorting (no zend_qsort_r in this PHP version) */ |
|
#define HS_LEFT(i) ((i) * 2 + 1) |
|
#define HS_RIGHT(i) ((i) * 2 + 2) |
|
#define HS_PARENT(i) (((i) - 1) / 2); |
|
#define HS_OFF(data, i) ((void *)(&((data)->arr)[i])) |
|
#define HS_CMP_CALL(data, i1, i2) \ |
|
(php_strtr_compare_hash_suffix(HS_OFF((data), (i1)), HS_OFF((data), (i2)), (data)->res)) |
|
struct hs_data { |
|
PATNREPL *arr; |
|
size_t nel; |
|
size_t heapel; |
|
PPRES *res; |
|
}; |
|
static inline void php_strtr_swap(PATNREPL *a, PATNREPL *b) |
|
{ |
|
PATNREPL tmp = *a; |
|
*a = *b; |
|
*b = tmp; |
|
} |
|
static inline void php_strtr_fix_heap(struct hs_data *data, size_t i) |
|
{ |
|
size_t li = HS_LEFT(i), |
|
ri = HS_RIGHT(i), |
|
largei; |
|
if (li < data->heapel && HS_CMP_CALL(data, li, i) > 0) { |
|
largei = li; |
|
} else { |
|
largei = i; |
|
} |
|
if (ri < data->heapel && HS_CMP_CALL(data, ri, largei) > 0) { |
|
largei = ri; |
|
} |
|
if (largei != i) { |
|
php_strtr_swap(HS_OFF(data, i), HS_OFF(data, largei)); |
|
php_strtr_fix_heap(data, largei); |
|
} |
|
} |
|
static inline void php_strtr_build_heap(struct hs_data *data) |
|
{ |
|
size_t i; |
|
for (i = data->nel / 2; i > 0; i--) { |
|
php_strtr_fix_heap(data, i - 1); |
|
} |
|
} |
|
static inline void php_strtr_heapsort(PATNREPL *arr, size_t nel, PPRES *res) |
|
{ |
|
struct hs_data data = { arr, nel, nel, res }; |
|
size_t i; |
|
php_strtr_build_heap(&data); |
|
for (i = nel; i > 1; i--) { |
|
php_strtr_swap(arr, HS_OFF(&data, i - 1)); |
|
data.heapel--; |
|
php_strtr_fix_heap(&data, 0); |
|
} |
|
} |
|
/* }}} */ |
|
/* {{{ php_strtr_free_strp */ |
|
static void php_strtr_free_strp(void *strp) |
|
{ |
|
STR_FREE(*(char**)strp); |
|
} |
|
/* }}} */ |
|
/* {{{ php_strtr_array_prepare_repls */ |
|
static PATNREPL *php_strtr_array_prepare_repls(int slen, HashTable *pats, zend_llist **allocs, int *outsize) |
|
{ |
|
PATNREPL *patterns; |
|
HashPosition hpos; |
|
zval **entry; |
|
int num_pats = zend_hash_num_elements(pats), |
|
i; |
|
|
key = emalloc(maxlen+1); | patterns = safe_emalloc(num_pats, sizeof(*patterns), 0); |
pos = 0; | *allocs = emalloc(sizeof **allocs); |
| zend_llist_init(*allocs, sizeof(void*), &php_strtr_free_strp, 0); |
|
|
while (pos < slen) { | for (i = 0, zend_hash_internal_pointer_reset_ex(pats, &hpos); |
if ((pos + maxlen) > slen) { | zend_hash_get_current_data_ex(pats, (void **)&entry, &hpos) == SUCCESS; |
maxlen = slen - pos; | zend_hash_move_forward_ex(pats, &hpos)) { |
| char *string_key; |
| uint string_key_len; |
| ulong num_key; |
| zval *tzv = NULL; |
| |
| switch (zend_hash_get_current_key_ex(pats, &string_key, &string_key_len, &num_key, 0, &hpos)) { |
| case HASH_KEY_IS_LONG: |
| string_key_len = 1 + zend_spprintf(&string_key, 0, "%ld", (long)num_key); |
| zend_llist_add_element(*allocs, &string_key); |
| /* break missing intentionally */ |
| |
| case HASH_KEY_IS_STRING: |
| string_key_len--; /* exclude final '\0' */ |
| if (string_key_len == 0) { /* empty string given as pattern */ |
| efree(patterns); |
| zend_llist_destroy(*allocs); |
| efree(*allocs); |
| *allocs = NULL; |
| return NULL; |
| } |
| if (string_key_len > slen) { /* this pattern can never match */ |
| continue; |
| } |
| |
| if (Z_TYPE_PP(entry) != IS_STRING) { |
| tzv = *entry; |
| zval_addref_p(tzv); |
| SEPARATE_ZVAL(&tzv); |
| convert_to_string(tzv); |
| entry = &tzv; |
| zend_llist_add_element(*allocs, &Z_STRVAL_PP(entry)); |
| } |
| |
| S(&patterns[i].pat) = string_key; |
| L(&patterns[i].pat) = string_key_len; |
| S(&patterns[i].repl) = Z_STRVAL_PP(entry); |
| L(&patterns[i].repl) = Z_STRLEN_PP(entry); |
| i++; |
| |
| if (tzv) { |
| efree(tzv); |
| } |
} |
} |
|
} |
|
|
found = 0; | *outsize = i; |
memcpy(key, str+pos, maxlen); | return patterns; |
| } |
| /* }}} */ |
|
|
for (len = maxlen; len >= minlen; len--) { | /* {{{ PPRES *php_strtr_array_prepare(STR *text, PATNREPL *patterns, int patnum, int B, int Bp) */ |
key[len] = 0; | static PPRES *php_strtr_array_prepare(STR *text, PATNREPL *patterns, int patnum, int B, int Bp) |
| { |
| int i; |
| PPRES *res = emalloc(sizeof *res); |
|
|
if (zend_hash_find(&tmp_hash, key, len+1, (void**)&trans) == SUCCESS) { | res->m = (STRLEN)-1; |
char *tval; | for (i = 0; i < patnum; i++) { |
int tlen; | if (L(&patterns[i].pat) < res->m) { |
zval tmp; | res->m = L(&patterns[i].pat); |
| } |
| } |
| assert(res->m > 0); |
| res->B = B = MIN(B, res->m); |
| res->Bp = Bp = MIN(Bp, res->m); |
|
|
if (Z_TYPE_PP(trans) != IS_STRING) { | res->shift = safe_emalloc(SHIFT_TAB_SIZE, sizeof(*res->shift->entries), sizeof(*res->shift)); |
tmp = **trans; | res->shift->table_mask = SHIFT_TAB_SIZE - 1; |
zval_copy_ctor(&tmp); | php_strtr_populate_shift(patterns, patnum, B, res->m, res->shift); |
convert_to_string(&tmp); | |
tval = Z_STRVAL(tmp); | |
tlen = Z_STRLEN(tmp); | |
} else { | |
tval = Z_STRVAL_PP(trans); | |
tlen = Z_STRLEN_PP(trans); | |
} | |
|
|
smart_str_appendl(&result, tval, tlen); | res->hash = safe_emalloc(HASH_TAB_SIZE, sizeof(*res->hash->entries), sizeof(*res->hash)); |
pos += len; | res->hash->table_mask = HASH_TAB_SIZE - 1; |
found = 1; | |
|
|
if (Z_TYPE_PP(trans) != IS_STRING) { | res->patterns = safe_emalloc(patnum, sizeof(*res->patterns), 0); |
zval_dtor(&tmp); | memcpy(res->patterns, patterns, sizeof(*patterns) * patnum); |
} | php_strtr_heapsort(res->patterns, patnum, res); |
break; | |
| res->prefix = safe_emalloc(patnum, sizeof(*res->prefix), 0); |
| for (i = 0; i < patnum; i++) { |
| res->prefix[i] = php_strtr_hash(S(&res->patterns[i].pat), Bp); |
| } |
| |
| /* Initialize the rest of ->hash */ |
| for (i = 0; i < HASH_TAB_SIZE; i++) { |
| res->hash->entries[i] = -1; |
| } |
| { |
| HASH last_h = -1; /* assumes not all bits are used in res->hash */ |
| /* res->patterns is already ordered by hash. |
| * Make res->hash->entries[h] de index of the first pattern in |
| * res->patterns that has hash h */ |
| for (i = 0; i < patnum; i++) { |
| HASH h = php_strtr_hash(&S(&res->patterns[i].pat)[res->m - res->B], res->B) |
| & res->hash->table_mask; |
| if (h != last_h) { |
| res->hash->entries[h] = i; |
| last_h = h; |
} |
} |
} |
} |
|
} |
|
res->hash->entries[HASH_TAB_SIZE] = patnum; /* OK, we effectively allocated SIZE+1 */ |
|
for (i = HASH_TAB_SIZE - 1; i >= 0; i--) { |
|
if (res->hash->entries[i] == -1) { |
|
res->hash->entries[i] = res->hash->entries[i + 1]; |
|
} |
|
} |
|
|
if (! found) { | res->patnum = patnum; |
smart_str_appendc(&result, str[pos++]); | |
| return res; |
| } |
| /* }}} */ |
| /* {{{ php_strtr_array_destroy_ppres(PPRES *d) */ |
| static void php_strtr_array_destroy_ppres(PPRES *d) |
| { |
| efree(d->shift); |
| efree(d->hash); |
| efree(d->prefix); |
| efree(d->patterns); |
| efree(d); |
| } |
| /* }}} */ |
| |
| /* {{{ php_strtr_array_do_repl(STR *text, PPRES *d, zval *return_value) */ |
| static void php_strtr_array_do_repl(STR *text, PPRES *d, zval *return_value) |
| { |
| STRLEN pos = 0, |
| nextwpos = 0, |
| lastpos = L(text) - d->m; |
| smart_str result = {0}; |
| |
| while (pos <= lastpos) { |
| HASH h = php_strtr_hash(&S(text)[pos + d->m - d->B], d->B) & d->shift->table_mask; |
| STRLEN shift = d->shift->entries[h]; |
| |
| if (shift > 0) { |
| pos += shift; |
| } else { |
| HASH h2 = h & d->hash->table_mask, |
| prefix_h = php_strtr_hash(&S(text)[pos], d->Bp); |
| |
| int offset_start = d->hash->entries[h2], |
| offset_end = d->hash->entries[h2 + 1], /* exclusive */ |
| i = 0; |
| |
| for (i = offset_start; i < offset_end; i++) { |
| PATNREPL *pnr; |
| if (d->prefix[i] != prefix_h) |
| continue; |
| |
| pnr = &d->patterns[i]; |
| if (L(&pnr->pat) > L(text) - pos || |
| memcmp(S(&pnr->pat), &S(text)[pos], L(&pnr->pat)) != 0) |
| continue; |
| |
| smart_str_appendl(&result, &S(text)[nextwpos], pos - nextwpos); |
| smart_str_appendl(&result, S(&pnr->repl), L(&pnr->repl)); |
| pos += L(&pnr->pat); |
| nextwpos = pos; |
| goto end_outer_loop; |
| } |
| |
| pos++; |
| end_outer_loop: ; |
} |
} |
} |
} |
|
|
efree(key); | smart_str_appendl(&result, &S(text)[nextwpos], L(text) - nextwpos); |
zend_hash_destroy(&tmp_hash); | |
smart_str_0(&result); | if (result.c != NULL) { |
RETVAL_STRINGL(result.c, result.len, 0); | smart_str_0(&result); |
| RETVAL_STRINGL(result.c, result.len, 0); |
| } else { |
| RETURN_EMPTY_STRING(); |
| } |
} |
} |
/* }}} */ |
/* }}} */ |
|
|
|
/* {{{ php_strtr_array */ |
|
static void php_strtr_array(zval *return_value, char *str, int slen, HashTable *pats) |
|
{ |
|
PPRES *data; |
|
STR text; |
|
PATNREPL *patterns; |
|
int patterns_len; |
|
zend_llist *allocs; |
|
|
|
S(&text) = str; |
|
L(&text) = slen; |
|
|
|
patterns = php_strtr_array_prepare_repls(slen, pats, &allocs, &patterns_len); |
|
if (patterns == NULL) { |
|
RETURN_FALSE; |
|
} |
|
data = php_strtr_array_prepare(&text, patterns, patterns_len, 2, 2); |
|
efree(patterns); |
|
php_strtr_array_do_repl(&text, data, return_value); |
|
php_strtr_array_destroy_ppres(data); |
|
zend_llist_destroy(allocs); |
|
efree(allocs); |
|
} |
|
/* }}} */ |
|
|
/* {{{ 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) |
Line 2971 static void php_similar_str(const char *txt1, int len1
|
Line 3253 static void php_similar_str(const char *txt1, int len1
|
static int php_similar_char(const char *txt1, int len1, const char *txt2, int len2) |
static int php_similar_char(const char *txt1, int len1, const char *txt2, int len2) |
{ |
{ |
int sum; |
int sum; |
int pos1, pos2, max; | int pos1 = 0, pos2 = 0, max; |
|
|
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)) { |
Line 3925 static void php_hebrev(INTERNAL_FUNCTION_PARAMETERS, i
|
Line 4207 static void php_hebrev(INTERNAL_FUNCTION_PARAMETERS, i
|
new_char_count--; |
new_char_count--; |
} |
} |
if (new_char_count > 0) { |
if (new_char_count > 0) { |
char_count=new_char_count; |
|
begin=new_begin; |
begin=new_begin; |
} |
} |
} |
} |
Line 4024 PHP_FUNCTION(nl2br)
|
Line 4305 PHP_FUNCTION(nl2br)
|
RETURN_STRINGL(str, str_len, 1); |
RETURN_STRINGL(str, str_len, 1); |
} |
} |
|
|
if (is_xhtml) { | { |
new_length = str_len + repl_cnt * (sizeof("<br />") - 1); | size_t repl_len = is_xhtml ? (sizeof("<br />") - 1) : (sizeof("<br>") - 1); |
} else { | |
new_length = str_len + repl_cnt * (sizeof("<br>") - 1); | new_length = str_len + repl_cnt * repl_len; |
| tmp = target = safe_emalloc(repl_cnt, repl_len, str_len + 1); |
} |
} |
|
|
tmp = target = emalloc(new_length + 1); |
|
|
|
while (str < end) { |
while (str < end) { |
switch (*str) { |
switch (*str) { |
case '\r': |
case '\r': |
Line 4333 PHPAPI size_t php_strip_tags_ex(char *rbuf, int len, i
|
Line 4613 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; | char *allow_free = NULL; |
|
|
if (stateptr) |
if (stateptr) |
state = *stateptr; |
state = *stateptr; |