/ext/pcre/php_pcre.c
C | 1932 lines | 1395 code | 250 blank | 287 comment | 370 complexity | aaa2d91781bfab0110c1497869565e07 MD5 | raw file
Possible License(s): MPL-2.0-no-copyleft-exception, LGPL-2.1, BSD-3-Clause
Large files files are truncated, but you can click here to view the full file
- /*
- +----------------------------------------------------------------------+
- | PHP Version 5 |
- +----------------------------------------------------------------------+
- | Copyright (c) 1997-2011 The PHP Group |
- +----------------------------------------------------------------------+
- | 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 |
- | available through the world-wide-web at the following url: |
- | http://www.php.net/license/3_01.txt |
- | If you did not receive a copy of the PHP license and are unable to |
- | obtain it through the world-wide-web, please send a note to |
- | license@php.net so we can mail you a copy immediately. |
- +----------------------------------------------------------------------+
- | Author: Andrei Zmievski <andrei@php.net> |
- +----------------------------------------------------------------------+
- */
- /* $Id: php_pcre.c 306939 2011-01-01 02:19:59Z felipe $ */
- #include "php.h"
- #include "php_ini.h"
- #include "php_globals.h"
- #include "php_pcre.h"
- #include "ext/standard/info.h"
- #include "ext/standard/php_smart_str.h"
- #if HAVE_PCRE || HAVE_BUNDLED_PCRE
- #include "ext/standard/php_string.h"
- #define PREG_PATTERN_ORDER 1
- #define PREG_SET_ORDER 2
- #define PREG_OFFSET_CAPTURE (1<<8)
- #define PREG_SPLIT_NO_EMPTY (1<<0)
- #define PREG_SPLIT_DELIM_CAPTURE (1<<1)
- #define PREG_SPLIT_OFFSET_CAPTURE (1<<2)
- #define PREG_REPLACE_EVAL (1<<0)
- #define PREG_GREP_INVERT (1<<0)
- #define PCRE_CACHE_SIZE 4096
- enum {
- PHP_PCRE_NO_ERROR = 0,
- PHP_PCRE_INTERNAL_ERROR,
- PHP_PCRE_BACKTRACK_LIMIT_ERROR,
- PHP_PCRE_RECURSION_LIMIT_ERROR,
- PHP_PCRE_BAD_UTF8_ERROR,
- PHP_PCRE_BAD_UTF8_OFFSET_ERROR
- };
- ZEND_DECLARE_MODULE_GLOBALS(pcre)
- static void pcre_handle_exec_error(int pcre_code TSRMLS_DC) /* {{{ */
- {
- int preg_code = 0;
- switch (pcre_code) {
- case PCRE_ERROR_MATCHLIMIT:
- preg_code = PHP_PCRE_BACKTRACK_LIMIT_ERROR;
- break;
- case PCRE_ERROR_RECURSIONLIMIT:
- preg_code = PHP_PCRE_RECURSION_LIMIT_ERROR;
- break;
- case PCRE_ERROR_BADUTF8:
- preg_code = PHP_PCRE_BAD_UTF8_ERROR;
- break;
- case PCRE_ERROR_BADUTF8_OFFSET:
- preg_code = PHP_PCRE_BAD_UTF8_OFFSET_ERROR;
- break;
- default:
- preg_code = PHP_PCRE_INTERNAL_ERROR;
- break;
- }
- PCRE_G(error_code) = preg_code;
- }
- /* }}} */
- static void php_free_pcre_cache(void *data) /* {{{ */
- {
- pcre_cache_entry *pce = (pcre_cache_entry *) data;
- if (!pce) return;
- pefree(pce->re, 1);
- if (pce->extra) pefree(pce->extra, 1);
- #if HAVE_SETLOCALE
- if ((void*)pce->tables) pefree((void*)pce->tables, 1);
- pefree(pce->locale, 1);
- #endif
- }
- /* }}} */
- static PHP_GINIT_FUNCTION(pcre) /* {{{ */
- {
- zend_hash_init(&pcre_globals->pcre_cache, 0, NULL, php_free_pcre_cache, 1);
- pcre_globals->backtrack_limit = 0;
- pcre_globals->recursion_limit = 0;
- pcre_globals->error_code = PHP_PCRE_NO_ERROR;
- }
- /* }}} */
- static PHP_GSHUTDOWN_FUNCTION(pcre) /* {{{ */
- {
- zend_hash_destroy(&pcre_globals->pcre_cache);
- }
- /* }}} */
- PHP_INI_BEGIN()
- STD_PHP_INI_ENTRY("pcre.backtrack_limit", "100000", PHP_INI_ALL, OnUpdateLong, backtrack_limit, zend_pcre_globals, pcre_globals)
- STD_PHP_INI_ENTRY("pcre.recursion_limit", "100000", PHP_INI_ALL, OnUpdateLong, recursion_limit, zend_pcre_globals, pcre_globals)
- PHP_INI_END()
- /* {{{ PHP_MINFO_FUNCTION(pcre) */
- static PHP_MINFO_FUNCTION(pcre)
- {
- php_info_print_table_start();
- php_info_print_table_row(2, "PCRE (Perl Compatible Regular Expressions) Support", "enabled" );
- php_info_print_table_row(2, "PCRE Library Version", pcre_version() );
- php_info_print_table_end();
- DISPLAY_INI_ENTRIES();
- }
- /* }}} */
- /* {{{ PHP_MINIT_FUNCTION(pcre) */
- static PHP_MINIT_FUNCTION(pcre)
- {
- REGISTER_INI_ENTRIES();
-
- REGISTER_LONG_CONSTANT("PREG_PATTERN_ORDER", PREG_PATTERN_ORDER, CONST_CS | CONST_PERSISTENT);
- REGISTER_LONG_CONSTANT("PREG_SET_ORDER", PREG_SET_ORDER, CONST_CS | CONST_PERSISTENT);
- REGISTER_LONG_CONSTANT("PREG_OFFSET_CAPTURE", PREG_OFFSET_CAPTURE, CONST_CS | CONST_PERSISTENT);
- REGISTER_LONG_CONSTANT("PREG_SPLIT_NO_EMPTY", PREG_SPLIT_NO_EMPTY, CONST_CS | CONST_PERSISTENT);
- REGISTER_LONG_CONSTANT("PREG_SPLIT_DELIM_CAPTURE", PREG_SPLIT_DELIM_CAPTURE, CONST_CS | CONST_PERSISTENT);
- REGISTER_LONG_CONSTANT("PREG_SPLIT_OFFSET_CAPTURE", PREG_SPLIT_OFFSET_CAPTURE, CONST_CS | CONST_PERSISTENT);
- REGISTER_LONG_CONSTANT("PREG_GREP_INVERT", PREG_GREP_INVERT, CONST_CS | CONST_PERSISTENT);
- REGISTER_LONG_CONSTANT("PREG_NO_ERROR", PHP_PCRE_NO_ERROR, CONST_CS | CONST_PERSISTENT);
- REGISTER_LONG_CONSTANT("PREG_INTERNAL_ERROR", PHP_PCRE_INTERNAL_ERROR, CONST_CS | CONST_PERSISTENT);
- REGISTER_LONG_CONSTANT("PREG_BACKTRACK_LIMIT_ERROR", PHP_PCRE_BACKTRACK_LIMIT_ERROR, CONST_CS | CONST_PERSISTENT);
- REGISTER_LONG_CONSTANT("PREG_RECURSION_LIMIT_ERROR", PHP_PCRE_RECURSION_LIMIT_ERROR, CONST_CS | CONST_PERSISTENT);
- REGISTER_LONG_CONSTANT("PREG_BAD_UTF8_ERROR", PHP_PCRE_BAD_UTF8_ERROR, CONST_CS | CONST_PERSISTENT);
- REGISTER_LONG_CONSTANT("PREG_BAD_UTF8_OFFSET_ERROR", PHP_PCRE_BAD_UTF8_OFFSET_ERROR, CONST_CS | CONST_PERSISTENT);
- REGISTER_STRING_CONSTANT("PCRE_VERSION", (char *)pcre_version(), CONST_CS | CONST_PERSISTENT);
- return SUCCESS;
- }
- /* }}} */
- /* {{{ PHP_MSHUTDOWN_FUNCTION(pcre) */
- static PHP_MSHUTDOWN_FUNCTION(pcre)
- {
- UNREGISTER_INI_ENTRIES();
- return SUCCESS;
- }
- /* }}} */
- /* {{{ static pcre_clean_cache */
- static int pcre_clean_cache(void *data, void *arg TSRMLS_DC)
- {
- int *num_clean = (int *)arg;
- if (*num_clean > 0) {
- (*num_clean)--;
- return 1;
- } else {
- return 0;
- }
- }
- /* }}} */
- /* {{{ static make_subpats_table */
- static char **make_subpats_table(int num_subpats, pcre_cache_entry *pce TSRMLS_DC)
- {
- pcre_extra *extra = pce->extra;
- int name_cnt = 0, name_size, ni = 0;
- int rc;
- char *name_table;
- unsigned short name_idx;
- char **subpat_names = (char **)ecalloc(num_subpats, sizeof(char *));
- rc = pcre_fullinfo(pce->re, extra, PCRE_INFO_NAMECOUNT, &name_cnt);
- if (rc < 0) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Internal pcre_fullinfo() error %d", rc);
- efree(subpat_names);
- return NULL;
- }
- if (name_cnt > 0) {
- int rc1, rc2;
- rc1 = pcre_fullinfo(pce->re, extra, PCRE_INFO_NAMETABLE, &name_table);
- rc2 = pcre_fullinfo(pce->re, extra, PCRE_INFO_NAMEENTRYSIZE, &name_size);
- rc = rc2 ? rc2 : rc1;
- if (rc < 0) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Internal pcre_fullinfo() error %d", rc);
- efree(subpat_names);
- return NULL;
- }
- while (ni++ < name_cnt) {
- name_idx = 0xff * (unsigned char)name_table[0] + (unsigned char)name_table[1];
- subpat_names[name_idx] = name_table + 2;
- if (is_numeric_string(subpat_names[name_idx], strlen(subpat_names[name_idx]), NULL, NULL, 0) > 0) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Numeric named subpatterns are not allowed");
- efree(subpat_names);
- return NULL;
- }
- name_table += name_size;
- }
- }
- return subpat_names;
- }
- /* }}} */
- /* {{{ pcre_get_compiled_regex_cache
- */
- PHPAPI pcre_cache_entry* pcre_get_compiled_regex_cache(char *regex, int regex_len TSRMLS_DC)
- {
- pcre *re = NULL;
- pcre_extra *extra;
- int coptions = 0;
- int soptions = 0;
- const char *error;
- int erroffset;
- char delimiter;
- char start_delimiter;
- char end_delimiter;
- char *p, *pp;
- char *pattern;
- int do_study = 0;
- int poptions = 0;
- unsigned const char *tables = NULL;
- #if HAVE_SETLOCALE
- char *locale = setlocale(LC_CTYPE, NULL);
- #endif
- pcre_cache_entry *pce;
- pcre_cache_entry new_entry;
- /* Try to lookup the cached regex entry, and if successful, just pass
- back the compiled pattern, otherwise go on and compile it. */
- if (zend_hash_find(&PCRE_G(pcre_cache), regex, regex_len+1, (void **)&pce) == SUCCESS) {
- /*
- * We use a quick pcre_info() check to see whether cache is corrupted, and if it
- * is, we flush it and compile the pattern from scratch.
- */
- if (pcre_info(pce->re, NULL, NULL) == PCRE_ERROR_BADMAGIC) {
- zend_hash_clean(&PCRE_G(pcre_cache));
- } else {
- #if HAVE_SETLOCALE
- if (!strcmp(pce->locale, locale)) {
- #endif
- return pce;
- #if HAVE_SETLOCALE
- }
- #endif
- }
- }
-
- p = regex;
-
- /* Parse through the leading whitespace, and display a warning if we
- get to the end without encountering a delimiter. */
- while (isspace((int)*(unsigned char *)p)) p++;
- if (*p == 0) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Empty regular expression");
- return NULL;
- }
-
- /* Get the delimiter and display a warning if it is alphanumeric
- or a backslash. */
- delimiter = *p++;
- if (isalnum((int)*(unsigned char *)&delimiter) || delimiter == '\\') {
- php_error_docref(NULL TSRMLS_CC,E_WARNING, "Delimiter must not be alphanumeric or backslash");
- return NULL;
- }
- start_delimiter = delimiter;
- if ((pp = strchr("([{< )]}> )]}>", delimiter)))
- delimiter = pp[5];
- end_delimiter = delimiter;
- if (start_delimiter == end_delimiter) {
- /* We need to iterate through the pattern, searching for the ending delimiter,
- but skipping the backslashed delimiters. If the ending delimiter is not
- found, display a warning. */
- pp = p;
- while (*pp != 0) {
- if (*pp == '\\' && pp[1] != 0) pp++;
- else if (*pp == delimiter)
- break;
- pp++;
- }
- if (*pp == 0) {
- php_error_docref(NULL TSRMLS_CC,E_WARNING, "No ending delimiter '%c' found", delimiter);
- return NULL;
- }
- } else {
- /* We iterate through the pattern, searching for the matching ending
- * delimiter. For each matching starting delimiter, we increment nesting
- * level, and decrement it for each matching ending delimiter. If we
- * reach the end of the pattern without matching, display a warning.
- */
- int brackets = 1; /* brackets nesting level */
- pp = p;
- while (*pp != 0) {
- if (*pp == '\\' && pp[1] != 0) pp++;
- else if (*pp == end_delimiter && --brackets <= 0)
- break;
- else if (*pp == start_delimiter)
- brackets++;
- pp++;
- }
- if (*pp == 0) {
- php_error_docref(NULL TSRMLS_CC,E_WARNING, "No ending matching delimiter '%c' found", end_delimiter);
- return NULL;
- }
- }
-
- /* Make a copy of the actual pattern. */
- pattern = estrndup(p, pp-p);
- /* Move on to the options */
- pp++;
- /* Parse through the options, setting appropriate flags. Display
- a warning if we encounter an unknown modifier. */
- while (*pp != 0) {
- switch (*pp++) {
- /* Perl compatible options */
- case 'i': coptions |= PCRE_CASELESS; break;
- case 'm': coptions |= PCRE_MULTILINE; break;
- case 's': coptions |= PCRE_DOTALL; break;
- case 'x': coptions |= PCRE_EXTENDED; break;
-
- /* PCRE specific options */
- case 'A': coptions |= PCRE_ANCHORED; break;
- case 'D': coptions |= PCRE_DOLLAR_ENDONLY;break;
- case 'S': do_study = 1; break;
- case 'U': coptions |= PCRE_UNGREEDY; break;
- case 'X': coptions |= PCRE_EXTRA; break;
- case 'u': coptions |= PCRE_UTF8;
- /* In PCRE, by default, \d, \D, \s, \S, \w, and \W recognize only ASCII
- characters, even in UTF-8 mode. However, this can be changed by setting
- the PCRE_UCP option. */
- #ifdef PCRE_UCP
- coptions |= PCRE_UCP;
- #endif
- break;
- /* Custom preg options */
- case 'e': poptions |= PREG_REPLACE_EVAL; break;
-
- case ' ':
- case '\n':
- break;
- default:
- php_error_docref(NULL TSRMLS_CC,E_WARNING, "Unknown modifier '%c'", pp[-1]);
- efree(pattern);
- return NULL;
- }
- }
- #if HAVE_SETLOCALE
- if (strcmp(locale, "C"))
- tables = pcre_maketables();
- #endif
- /* Compile pattern and display a warning if compilation failed. */
- re = pcre_compile(pattern,
- coptions,
- &error,
- &erroffset,
- tables);
- if (re == NULL) {
- php_error_docref(NULL TSRMLS_CC,E_WARNING, "Compilation failed: %s at offset %d", error, erroffset);
- efree(pattern);
- if (tables) {
- pefree((void*)tables, 1);
- }
- return NULL;
- }
- /* If study option was specified, study the pattern and
- store the result in extra for passing to pcre_exec. */
- if (do_study) {
- extra = pcre_study(re, soptions, &error);
- if (extra) {
- extra->flags |= PCRE_EXTRA_MATCH_LIMIT | PCRE_EXTRA_MATCH_LIMIT_RECURSION;
- }
- if (error != NULL) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error while studying pattern");
- }
- } else {
- extra = NULL;
- }
- efree(pattern);
- /*
- * If we reached cache limit, clean out the items from the head of the list;
- * these are supposedly the oldest ones (but not necessarily the least used
- * ones).
- */
- if (zend_hash_num_elements(&PCRE_G(pcre_cache)) == PCRE_CACHE_SIZE) {
- int num_clean = PCRE_CACHE_SIZE / 8;
- zend_hash_apply_with_argument(&PCRE_G(pcre_cache), pcre_clean_cache, &num_clean TSRMLS_CC);
- }
- /* Store the compiled pattern and extra info in the cache. */
- new_entry.re = re;
- new_entry.extra = extra;
- new_entry.preg_options = poptions;
- new_entry.compile_options = coptions;
- #if HAVE_SETLOCALE
- new_entry.locale = pestrdup(locale, 1);
- new_entry.tables = tables;
- #endif
- zend_hash_update(&PCRE_G(pcre_cache), regex, regex_len+1, (void *)&new_entry,
- sizeof(pcre_cache_entry), (void**)&pce);
- return pce;
- }
- /* }}} */
- /* {{{ pcre_get_compiled_regex
- */
- PHPAPI pcre* pcre_get_compiled_regex(char *regex, pcre_extra **extra, int *preg_options TSRMLS_DC)
- {
- pcre_cache_entry * pce = pcre_get_compiled_regex_cache(regex, strlen(regex) TSRMLS_CC);
- if (extra) {
- *extra = pce ? pce->extra : NULL;
- }
- if (preg_options) {
- *preg_options = pce ? pce->preg_options : 0;
- }
-
- return pce ? pce->re : NULL;
- }
- /* }}} */
- /* {{{ pcre_get_compiled_regex_ex
- */
- PHPAPI pcre* pcre_get_compiled_regex_ex(char *regex, pcre_extra **extra, int *preg_options, int *compile_options TSRMLS_DC)
- {
- pcre_cache_entry * pce = pcre_get_compiled_regex_cache(regex, strlen(regex) TSRMLS_CC);
-
- if (extra) {
- *extra = pce ? pce->extra : NULL;
- }
- if (preg_options) {
- *preg_options = pce ? pce->preg_options : 0;
- }
- if (compile_options) {
- *compile_options = pce ? pce->compile_options : 0;
- }
-
- return pce ? pce->re : NULL;
- }
- /* }}} */
- /* {{{ add_offset_pair */
- static inline void add_offset_pair(zval *result, char *str, int len, int offset, char *name)
- {
- zval *match_pair;
- ALLOC_ZVAL(match_pair);
- array_init(match_pair);
- INIT_PZVAL(match_pair);
- /* Add (match, offset) to the return value */
- add_next_index_stringl(match_pair, str, len, 1);
- add_next_index_long(match_pair, offset);
-
- if (name) {
- zval_add_ref(&match_pair);
- zend_hash_update(Z_ARRVAL_P(result), name, strlen(name)+1, &match_pair, sizeof(zval *), NULL);
- }
- zend_hash_next_index_insert(Z_ARRVAL_P(result), &match_pair, sizeof(zval *), NULL);
- }
- /* }}} */
- static void php_do_pcre_match(INTERNAL_FUNCTION_PARAMETERS, int global) /* {{{ */
- {
- /* parameters */
- char *regex; /* Regular expression */
- char *subject; /* String to match against */
- int regex_len;
- int subject_len;
- pcre_cache_entry *pce; /* Compiled regular expression */
- zval *subpats = NULL; /* Array for subpatterns */
- long flags = 0; /* Match control flags */
- long start_offset = 0; /* Where the new search starts */
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, ((global) ? "ssz|ll" : "ss|zll"), ®ex, ®ex_len,
- &subject, &subject_len, &subpats, &flags, &start_offset) == FAILURE) {
- RETURN_FALSE;
- }
-
- /* Compile regex or get it from cache. */
- if ((pce = pcre_get_compiled_regex_cache(regex, regex_len TSRMLS_CC)) == NULL) {
- RETURN_FALSE;
- }
- php_pcre_match_impl(pce, subject, subject_len, return_value, subpats,
- global, ZEND_NUM_ARGS() >= 4, flags, start_offset TSRMLS_CC);
- }
- /* }}} */
- /* {{{ php_pcre_match_impl() */
- PHPAPI void php_pcre_match_impl(pcre_cache_entry *pce, char *subject, int subject_len, zval *return_value,
- zval *subpats, int global, int use_flags, long flags, long start_offset TSRMLS_DC)
- {
- zval *result_set, /* Holds a set of subpatterns after
- a global match */
- **match_sets = NULL; /* An array of sets of matches for each
- subpattern after a global match */
- pcre_extra *extra = pce->extra;/* Holds results of studying */
- pcre_extra extra_data; /* Used locally for exec options */
- int exoptions = 0; /* Execution options */
- int count = 0; /* Count of matched subpatterns */
- int *offsets; /* Array of subpattern offsets */
- int num_subpats; /* Number of captured subpatterns */
- int size_offsets; /* Size of the offsets array */
- int matched; /* Has anything matched */
- int g_notempty = 0; /* If the match should not be empty */
- const char **stringlist; /* Holds list of subpatterns */
- char **subpat_names; /* Array for named subpatterns */
- int i, rc;
- int subpats_order; /* Order of subpattern matches */
- int offset_capture; /* Capture match offsets: yes/no */
- /* Overwrite the passed-in value for subpatterns with an empty array. */
- if (subpats != NULL) {
- zval_dtor(subpats);
- array_init(subpats);
- }
- subpats_order = global ? PREG_PATTERN_ORDER : 0;
- if (use_flags) {
- offset_capture = flags & PREG_OFFSET_CAPTURE;
- /*
- * subpats_order is pre-set to pattern mode so we change it only if
- * necessary.
- */
- if (flags & 0xff) {
- subpats_order = flags & 0xff;
- }
- if ((global && (subpats_order < PREG_PATTERN_ORDER || subpats_order > PREG_SET_ORDER)) ||
- (!global && subpats_order != 0)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid flags specified");
- return;
- }
- } else {
- offset_capture = 0;
- }
- /* Negative offset counts from the end of the string. */
- if (start_offset < 0) {
- start_offset = subject_len + start_offset;
- if (start_offset < 0) {
- start_offset = 0;
- }
- }
- if (extra == NULL) {
- extra_data.flags = PCRE_EXTRA_MATCH_LIMIT | PCRE_EXTRA_MATCH_LIMIT_RECURSION;
- extra = &extra_data;
- }
- extra->match_limit = PCRE_G(backtrack_limit);
- extra->match_limit_recursion = PCRE_G(recursion_limit);
- /* Calculate the size of the offsets array, and allocate memory for it. */
- rc = pcre_fullinfo(pce->re, extra, PCRE_INFO_CAPTURECOUNT, &num_subpats);
- if (rc < 0) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Internal pcre_fullinfo() error %d", rc);
- RETURN_FALSE;
- }
- num_subpats++;
- size_offsets = num_subpats * 3;
- /*
- * Build a mapping from subpattern numbers to their names. We will always
- * allocate the table, even though there may be no named subpatterns. This
- * avoids somewhat more complicated logic in the inner loops.
- */
- subpat_names = make_subpats_table(num_subpats, pce TSRMLS_CC);
- if (!subpat_names) {
- RETURN_FALSE;
- }
- offsets = (int *)safe_emalloc(size_offsets, sizeof(int), 0);
- /* Allocate match sets array and initialize the values. */
- if (global && subpats_order == PREG_PATTERN_ORDER) {
- match_sets = (zval **)safe_emalloc(num_subpats, sizeof(zval *), 0);
- for (i=0; i<num_subpats; i++) {
- ALLOC_ZVAL(match_sets[i]);
- array_init(match_sets[i]);
- INIT_PZVAL(match_sets[i]);
- }
- }
- matched = 0;
- PCRE_G(error_code) = PHP_PCRE_NO_ERROR;
-
- do {
- /* Execute the regular expression. */
- count = pcre_exec(pce->re, extra, subject, subject_len, start_offset,
- exoptions|g_notempty, offsets, size_offsets);
- /* the string was already proved to be valid UTF-8 */
- exoptions |= PCRE_NO_UTF8_CHECK;
- /* Check for too many substrings condition. */
- if (count == 0) {
- php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Matched, but too many substrings");
- count = size_offsets/3;
- }
- /* If something has matched */
- if (count > 0) {
- matched++;
- /* If subpatterns array has been passed, fill it in with values. */
- if (subpats != NULL) {
- /* Try to get the list of substrings and display a warning if failed. */
- if (pcre_get_substring_list(subject, offsets, count, &stringlist) < 0) {
- efree(subpat_names);
- efree(offsets);
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Get subpatterns list failed");
- RETURN_FALSE;
- }
- if (global) { /* global pattern matching */
- if (subpats_order == PREG_PATTERN_ORDER) {
- /* For each subpattern, insert it into the appropriate array. */
- for (i = 0; i < count; i++) {
- if (offset_capture) {
- add_offset_pair(match_sets[i], (char *)stringlist[i],
- offsets[(i<<1)+1] - offsets[i<<1], offsets[i<<1], NULL);
- } else {
- add_next_index_stringl(match_sets[i], (char *)stringlist[i],
- offsets[(i<<1)+1] - offsets[i<<1], 1);
- }
- }
- /*
- * If the number of captured subpatterns on this run is
- * less than the total possible number, pad the result
- * arrays with empty strings.
- */
- if (count < num_subpats) {
- for (; i < num_subpats; i++) {
- add_next_index_string(match_sets[i], "", 1);
- }
- }
- } else {
- /* Allocate the result set array */
- ALLOC_ZVAL(result_set);
- array_init(result_set);
- INIT_PZVAL(result_set);
-
- /* Add all the subpatterns to it */
- for (i = 0; i < count; i++) {
- if (offset_capture) {
- add_offset_pair(result_set, (char *)stringlist[i],
- offsets[(i<<1)+1] - offsets[i<<1], offsets[i<<1], subpat_names[i]);
- } else {
- if (subpat_names[i]) {
- add_assoc_stringl(result_set, subpat_names[i], (char *)stringlist[i],
- offsets[(i<<1)+1] - offsets[i<<1], 1);
- }
- add_next_index_stringl(result_set, (char *)stringlist[i],
- offsets[(i<<1)+1] - offsets[i<<1], 1);
- }
- }
- /* And add it to the output array */
- zend_hash_next_index_insert(Z_ARRVAL_P(subpats), &result_set, sizeof(zval *), NULL);
- }
- } else { /* single pattern matching */
- /* For each subpattern, insert it into the subpatterns array. */
- for (i = 0; i < count; i++) {
- if (offset_capture) {
- add_offset_pair(subpats, (char *)stringlist[i],
- offsets[(i<<1)+1] - offsets[i<<1],
- offsets[i<<1], subpat_names[i]);
- } else {
- if (subpat_names[i]) {
- add_assoc_stringl(subpats, subpat_names[i], (char *)stringlist[i],
- offsets[(i<<1)+1] - offsets[i<<1], 1);
- }
- add_next_index_stringl(subpats, (char *)stringlist[i],
- offsets[(i<<1)+1] - offsets[i<<1], 1);
- }
- }
- }
- pcre_free((void *) stringlist);
- }
- } else if (count == PCRE_ERROR_NOMATCH) {
- /* If we previously set PCRE_NOTEMPTY after a null match,
- this is not necessarily the end. We need to advance
- the start offset, and continue. Fudge the offset values
- to achieve this, unless we're already at the end of the string. */
- if (g_notempty != 0 && start_offset < subject_len) {
- offsets[0] = start_offset;
- offsets[1] = start_offset + 1;
- } else
- break;
- } else {
- pcre_handle_exec_error(count TSRMLS_CC);
- break;
- }
-
- /* If we have matched an empty string, mimic what Perl's /g options does.
- This turns out to be rather cunning. First we set PCRE_NOTEMPTY and try
- the match again at the same point. If this fails (picked up above) we
- advance to the next character. */
- g_notempty = (offsets[1] == offsets[0])? PCRE_NOTEMPTY | PCRE_ANCHORED : 0;
-
- /* Advance to the position right after the last full match */
- start_offset = offsets[1];
- } while (global);
- /* Add the match sets to the output array and clean up */
- if (global && subpats_order == PREG_PATTERN_ORDER) {
- for (i = 0; i < num_subpats; i++) {
- if (subpat_names[i]) {
- zend_hash_update(Z_ARRVAL_P(subpats), subpat_names[i],
- strlen(subpat_names[i])+1, &match_sets[i], sizeof(zval *), NULL);
- Z_ADDREF_P(match_sets[i]);
- }
- zend_hash_next_index_insert(Z_ARRVAL_P(subpats), &match_sets[i], sizeof(zval *), NULL);
- }
- efree(match_sets);
- }
-
- efree(offsets);
- efree(subpat_names);
- /* Did we encounter an error? */
- if (PCRE_G(error_code) == PHP_PCRE_NO_ERROR) {
- RETVAL_LONG(matched);
- } else {
- RETVAL_FALSE;
- }
- }
- /* }}} */
- /* {{{ proto int preg_match(string pattern, string subject [, array &subpatterns [, int flags [, int offset]]])
- Perform a Perl-style regular expression match */
- static PHP_FUNCTION(preg_match)
- {
- php_do_pcre_match(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
- }
- /* }}} */
- /* {{{ proto int preg_match_all(string pattern, string subject, array &subpatterns [, int flags [, int offset]])
- Perform a Perl-style global regular expression match */
- static PHP_FUNCTION(preg_match_all)
- {
- php_do_pcre_match(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
- }
- /* }}} */
- /* {{{ preg_get_backref
- */
- static int preg_get_backref(char **str, int *backref)
- {
- register char in_brace = 0;
- register char *walk = *str;
- if (walk[1] == 0)
- return 0;
- if (*walk == '$' && walk[1] == '{') {
- in_brace = 1;
- walk++;
- }
- walk++;
- if (*walk >= '0' && *walk <= '9') {
- *backref = *walk - '0';
- walk++;
- } else
- return 0;
-
- if (*walk && *walk >= '0' && *walk <= '9') {
- *backref = *backref * 10 + *walk - '0';
- walk++;
- }
- if (in_brace) {
- if (*walk == 0 || *walk != '}')
- return 0;
- else
- walk++;
- }
-
- *str = walk;
- return 1;
- }
- /* }}} */
- /* {{{ preg_do_repl_func
- */
- static int preg_do_repl_func(zval *function, char *subject, int *offsets, char **subpat_names, int count, char **result TSRMLS_DC)
- {
- zval *retval_ptr; /* Function return value */
- zval **args[1]; /* Argument to pass to function */
- zval *subpats; /* Captured subpatterns */
- int result_len; /* Return value length */
- int i;
- MAKE_STD_ZVAL(subpats);
- array_init(subpats);
- for (i = 0; i < count; i++) {
- if (subpat_names[i]) {
- add_assoc_stringl(subpats, subpat_names[i], &subject[offsets[i<<1]] , offsets[(i<<1)+1] - offsets[i<<1], 1);
- }
- add_next_index_stringl(subpats, &subject[offsets[i<<1]], offsets[(i<<1)+1] - offsets[i<<1], 1);
- }
- args[0] = &subpats;
- if (call_user_function_ex(EG(function_table), NULL, function, &retval_ptr, 1, args, 0, NULL TSRMLS_CC) == SUCCESS && retval_ptr) {
- convert_to_string_ex(&retval_ptr);
- *result = estrndup(Z_STRVAL_P(retval_ptr), Z_STRLEN_P(retval_ptr));
- result_len = Z_STRLEN_P(retval_ptr);
- zval_ptr_dtor(&retval_ptr);
- } else {
- if (!EG(exception)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to call custom replacement function");
- }
- result_len = offsets[1] - offsets[0];
- *result = estrndup(&subject[offsets[0]], result_len);
- }
- zval_ptr_dtor(&subpats);
- return result_len;
- }
- /* }}} */
- /* {{{ preg_do_eval
- */
- static int preg_do_eval(char *eval_str, int eval_str_len, char *subject,
- int *offsets, int count, char **result TSRMLS_DC)
- {
- zval retval; /* Return value from evaluation */
- char *eval_str_end, /* End of eval string */
- *match, /* Current match for a backref */
- *esc_match, /* Quote-escaped match */
- *walk, /* Used to walk the code string */
- *segment, /* Start of segment to append while walking */
- walk_last; /* Last walked character */
- int match_len; /* Length of the match */
- int esc_match_len; /* Length of the quote-escaped match */
- int result_len; /* Length of the result of the evaluation */
- int backref; /* Current backref */
- char *compiled_string_description;
- smart_str code = {0};
-
- eval_str_end = eval_str + eval_str_len;
- walk = segment = eval_str;
- walk_last = 0;
-
- while (walk < eval_str_end) {
- /* If found a backreference.. */
- if ('\\' == *walk || '$' == *walk) {
- smart_str_appendl(&code, segment, walk - segment);
- if (walk_last == '\\') {
- code.c[code.len-1] = *walk++;
- segment = walk;
- walk_last = 0;
- continue;
- }
- segment = walk;
- if (preg_get_backref(&walk, &backref)) {
- if (backref < count) {
- /* Find the corresponding string match and substitute it
- in instead of the backref */
- match = subject + offsets[backref<<1];
- match_len = offsets[(backref<<1)+1] - offsets[backref<<1];
- if (match_len) {
- esc_match = php_addslashes_ex(match, match_len, &esc_match_len, 0, 1 TSRMLS_CC);
- } else {
- esc_match = match;
- esc_match_len = 0;
- }
- } else {
- esc_match = "";
- esc_match_len = 0;
- }
- smart_str_appendl(&code, esc_match, esc_match_len);
- segment = walk;
- /* Clean up and reassign */
- if (esc_match_len)
- efree(esc_match);
- continue;
- }
- }
- walk++;
- walk_last = walk[-1];
- }
- smart_str_appendl(&code, segment, walk - segment);
- smart_str_0(&code);
- compiled_string_description = zend_make_compiled_string_description("regexp code" TSRMLS_CC);
- /* Run the code */
- if (zend_eval_stringl(code.c, code.len, &retval, compiled_string_description TSRMLS_CC) == FAILURE) {
- efree(compiled_string_description);
- php_error_docref(NULL TSRMLS_CC,E_ERROR, "Failed evaluating code: %s%s", PHP_EOL, code.c);
- /* zend_error() does not return in this case */
- }
- efree(compiled_string_description);
- convert_to_string(&retval);
-
- /* Save the return value and its length */
- *result = estrndup(Z_STRVAL(retval), Z_STRLEN(retval));
- result_len = Z_STRLEN(retval);
-
- /* Clean up */
- zval_dtor(&retval);
- smart_str_free(&code);
-
- return result_len;
- }
- /* }}} */
- /* {{{ php_pcre_replace
- */
- PHPAPI char *php_pcre_replace(char *regex, int regex_len,
- char *subject, int subject_len,
- zval *replace_val, int is_callable_replace,
- int *result_len, int limit, int *replace_count TSRMLS_DC)
- {
- pcre_cache_entry *pce; /* Compiled regular expression */
- /* Compile regex or get it from cache. */
- if ((pce = pcre_get_compiled_regex_cache(regex, regex_len TSRMLS_CC)) == NULL) {
- return NULL;
- }
- return php_pcre_replace_impl(pce, subject, subject_len, replace_val,
- is_callable_replace, result_len, limit, replace_count TSRMLS_CC);
- }
- /* }}} */
- /* {{{ php_pcre_replace_impl() */
- PHPAPI char *php_pcre_replace_impl(pcre_cache_entry *pce, char *subject, int subject_len, zval *replace_val,
- int is_callable_replace, int *result_len, int limit, int *replace_count TSRMLS_DC)
- {
- pcre_extra *extra = pce->extra;/* Holds results of studying */
- pcre_extra extra_data; /* Used locally for exec options */
- int exoptions = 0; /* Execution options */
- int count = 0; /* Count of matched subpatterns */
- int *offsets; /* Array of subpattern offsets */
- char **subpat_names; /* Array for named subpatterns */
- int num_subpats; /* Number of captured subpatterns */
- int size_offsets; /* Size of the offsets array */
- int new_len; /* Length of needed storage */
- int alloc_len; /* Actual allocated length */
- int eval_result_len=0; /* Length of the eval'ed or
- function-returned string */
- int match_len; /* Length of the current match */
- int backref; /* Backreference number */
- int eval; /* If the replacement string should be eval'ed */
- int start_offset; /* Where the new search starts */
- int g_notempty=0; /* If the match should not be empty */
- int replace_len=0; /* Length of replacement string */
- char *result, /* Result of replacement */
- *replace=NULL, /* Replacement string */
- *new_buf, /* Temporary buffer for re-allocation */
- *walkbuf, /* Location of current replacement in the result */
- *walk, /* Used to walk the replacement string */
- *match, /* The current match */
- *piece, /* The current piece of subject */
- *replace_end=NULL, /* End of replacement string */
- *eval_result, /* Result of eval or custom function */
- walk_last; /* Last walked character */
- int rc;
- if (extra == NULL) {
- extra_data.flags = PCRE_EXTRA_MATCH_LIMIT | PCRE_EXTRA_MATCH_LIMIT_RECURSION;
- extra = &extra_data;
- }
- extra->match_limit = PCRE_G(backtrack_limit);
- extra->match_limit_recursion = PCRE_G(recursion_limit);
- eval = pce->preg_options & PREG_REPLACE_EVAL;
- if (is_callable_replace) {
- if (eval) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Modifier /e cannot be used with replacement callback");
- return NULL;
- }
- } else {
- replace = Z_STRVAL_P(replace_val);
- replace_len = Z_STRLEN_P(replace_val);
- replace_end = replace + replace_len;
- }
- /* Calculate the size of the offsets array, and allocate memory for it. */
- rc = pcre_fullinfo(pce->re, extra, PCRE_INFO_CAPTURECOUNT, &num_subpats);
- if (rc < 0) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Internal pcre_fullinfo() error %d", rc);
- return NULL;
- }
- num_subpats++;
- size_offsets = num_subpats * 3;
- /*
- * Build a mapping from subpattern numbers to their names. We will always
- * allocate the table, even though there may be no named subpatterns. This
- * avoids somewhat more complicated logic in the inner loops.
- */
- subpat_names = make_subpats_table(num_subpats, pce TSRMLS_CC);
- if (!subpat_names) {
- return NULL;
- }
- offsets = (int *)safe_emalloc(size_offsets, sizeof(int), 0);
-
- alloc_len = 2 * subject_len + 1;
- result = safe_emalloc(alloc_len, sizeof(char), 0);
- /* Initialize */
- match = NULL;
- *result_len = 0;
- start_offset = 0;
- PCRE_G(error_code) = PHP_PCRE_NO_ERROR;
-
- while (1) {
- /* Execute the regular expression. */
- count = pcre_exec(pce->re, extra, subject, subject_len, start_offset,
- exoptions|g_notempty, offsets, size_offsets);
- /* the string was already proved to be valid UTF-8 */
- exoptions |= PCRE_NO_UTF8_CHECK;
- /* Check for too many substrings condition. */
- if (count == 0) {
- php_error_docref(NULL TSRMLS_CC,E_NOTICE, "Matched, but too many substrings");
- count = size_offsets/3;
- }
- piece = subject + start_offset;
- if (count > 0 && (limit == -1 || limit > 0)) {
- if (replace_count) {
- ++*replace_count;
- }
- /* Set the match location in subject */
- match = subject + offsets[0];
- new_len = *result_len + offsets[0] - start_offset; /* part before the match */
-
- /* If evaluating, do it and add the return string's length */
- if (eval) {
- eval_result_len = preg_do_eval(replace, replace_len, subject,
- offsets, count, &eval_result TSRMLS_CC);
- new_len += eval_result_len;
- } else if (is_callable_replace) {
- /* Use custom function to get replacement string and its length. */
- eval_result_len = preg_do_repl_func(replace_val, subject, offsets, subpat_names, count, &eval_result TSRMLS_CC);
- new_len += eval_result_len;
- } else { /* do regular substitution */
- walk = replace;
- walk_last = 0;
- while (walk < replace_end) {
- if ('\\' == *walk || '$' == *walk) {
- if (walk_last == '\\') {
- walk++;
- walk_last = 0;
- continue;
- }
- if (preg_get_backref(&walk, &backref)) {
- if (backref < count)
- new_len += offsets[(backref<<1)+1] - offsets[backref<<1];
- continue;
- }
- }
- new_len++;
- walk++;
- walk_last = walk[-1];
- }
- }
- if (new_len + 1 > alloc_len) {
- alloc_len = 1 + alloc_len + 2 * new_len;
- new_buf = emalloc(alloc_len);
- memcpy(new_buf, result, *result_len);
- efree(result);
- result = new_buf;
- }
- /* copy the part of the string before the match */
- memcpy(&result[*result_len], piece, match-piece);
- *result_len += match-piece;
- /* copy replacement and backrefs */
- walkbuf = result + *result_len;
-
- /* If evaluating or using custom function, copy result to the buffer
- * and clean up. */
- if (eval || is_callable_replace) {
- memcpy(walkbuf, eval_result, eval_result_len);
- *result_len += eval_result_len;
- STR_FREE(eval_result);
- } else { /* do regular backreference copying */
- walk = replace;
- walk_last = 0;
- while (walk < replace_end) {
- if ('\\' == *walk || '$' == *walk) {
- if (walk_last == '\\') {
- *(walkbuf-1) = *walk++;
- walk_last = 0;
- continue;
- }
- if (preg_get_backref(&walk, &backref)) {
- if (backref < count) {
- match_len = offsets[(backref<<1)+1] - offsets[backref<<1];
- memcpy(walkbuf, subject + offsets[backref<<1], match_len);
- walkbuf += match_len;
- }
- continue;
- }
- }
- *walkbuf++ = *walk++;
- walk_last = walk[-1];
- }
- *walkbuf = '\0';
- /* increment the result length by how much we've added to the string */
- *result_len += walkbuf - (result + *result_len);
- }
- if (limit != -1)
- limit--;
- } else if (count == PCRE_ERROR_NOMATCH || limit == 0) {
- /* If we previously set PCRE_NOTEMPTY after a null match,
- this is not necessarily the end. We need to advance
- the start offset, and continue. Fudge the offset values
- to achieve this, unless we're already at the end of the string. */
- if (g_notempty != 0 && start_offset < subject_len) {
- offsets[0] = start_offset;
- offsets[1] = start_offset + 1;
- memcpy(&result[*result_len], piece, 1);
- (*result_len)++;
- } else {
- new_len = *result_len + subject_len - start_offset;
- if (new_len + 1 > alloc_len) {
- alloc_len = new_len + 1; /* now we know exactly how long it is */
- new_buf = safe_emalloc(alloc_len, sizeof(char), 0);
- memcpy(new_buf, result, *result_len);
- efree(result);
- result = new_buf;
- }
- /* stick that last bit of string on our output */
- memcpy(&result[*result_len], piece, subject_len - start_offset);
- *result_len += subject_len - start_offset;
- result[*result_len] = '\0';
- break;
- }
- } else {
- pcre_handle_exec_error(count TSRMLS_CC);
- efree(result);
- result = NULL;
- break;
- }
-
- /* If we have matched an empty string, mimic what Perl's /g options does.
- This turns out to be rather cunning. First we set PCRE_NOTEMPTY and try
- the match again at the same point. If this fails (picked up above) we
- advance to the next character. */
- g_notempty = (offsets[1] == offsets[0])? PCRE_NOTEMPTY | PCRE_ANCHORED : 0;
-
- /* Advance to the next piece. */
- start_offset = offsets[1];
- }
- efree(offsets);
- efree(subpat_names);
- return result;
- }
- /* }}} */
- /* {{{ php_replace_in_subject
- */
- static char *php_replace_in_subject(zval *regex, zval *replace, zval **subject, int *result_len, int limit, int is_callable_replace, int *replace_count TSRMLS_DC)
- {
- zval **regex_entry,
- **replace_entry = NULL,
- *replace_value,
- empty_replace;
- char *subject_value,
- *result;
- int subject_len;
- /* Make sure we're dealing with strings. */
- convert_to_string_ex(subject);
- /* FIXME: This might need to be changed to STR_EMPTY_ALLOC(). Check if this zval could be dtor()'ed somehow */
- ZVAL_STRINGL(&empty_replace, "", 0, 0);
-
- /* If regex is an array */
- if (Z_TYPE_P(regex) == IS_ARRAY) {
- /* Duplicate subject string for repeated replacement */
- subject_value = estrndup(Z_STRVAL_PP(subject), Z_STRLEN_PP(subject));
- subject_len = Z_STRLEN_PP(subject);
- *result_len = subject_len;
-
- zend_hash_internal_pointer_reset(Z_ARRVAL_P(regex));
- replace_value = replace;
- if (Z_TYPE_P(replace) == IS_ARRAY && !is_callable_replace)
- zend_hash_internal_pointer_reset(Z_ARRVAL_P(replace));
- /* For each entry in the regex array, get the entry */
- while (zend_hash_get_current_data(Z_ARRVAL_P(regex), (void **)®ex_entry) == SUCCESS) {
- /* Make sure we're dealing with strings. */
- convert_to_string_ex(regex_entry);
-
- /* If replace is an array and not a callable construct */
- if (Z_TYPE_P(replace) == IS_ARRAY && !is_callable_replace) {
- /* Get current entry */
- if (zend_hash_get_current_data(Z_ARRVAL_P(replace), (void **)&replace_entry) == SUCCESS) {
- if (!is_callable_replace) {
- convert_to_string_ex(replace_entry);
- }
- replace_value = *replace_entry;
- zend_hash_move_forward(Z_ARRVAL_P(replace));
- } else {
- /* We've run out of replacement strings, so use an empty one */
- replace_value = &empty_replace;
- }
- }
-
- /* Do the actual replacement and put the result back into subject_value
- for further replacements. */
- if ((result = php_pcre_replace(Z_STRVAL_PP(regex_entry),
- Z_STRLEN_PP(regex_entry),
- subject_value,
- subject_len,
- replace_value,
- is_callable_replace,
- result_len,
- limit,
- replace_count TSRMLS_CC)) != NULL) {
- efree(subject_value);
- subject_value = result;
- subject_len = *result_len;
- } else {
- efree(subject_value);
- return NULL;
- }
- zend_hash_move_forward(Z_ARRVAL_P(regex));
- }
- return subject_value;
- } else {
- result = php_pcre_replace(Z_STRVAL_P(regex),
- Z_STRLEN_P(regex),
- Z_STRVAL_PP(subject),
- Z_STRLEN_PP(subject),
- replace,
- is_callable_replace,
- result_len,
- limit,
- replace_count TSRMLS_CC);
- return result;
- }
- }
- /* }}} */
- /* {{{ preg_replace_impl
- */
- static void preg_replace_impl(INTERNAL_FUNCTION_PARAMETERS, int is_callable_replace, int is_filter)
- {
- zval **regex,
- **replace,
- **subject,
- **subject_entry,
- **zcount = NULL;
- char *result;
- int result_len;
- int limit_val = -1;
- long limit = -1;
- char *string_key;
- ulong num_key;
- char *callback_name;
- int replace_count=0, old_replace_count;
-
- /* Get function parameters and do error-checking. */
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ZZZ|lZ", ®ex, &replace, &subject, &limit, &zcount) == FAILURE) {
- return;
- }
-
- if (!is_callable_replace && Z_TYPE_PP(replace) == IS_ARRAY && Z_TYPE_PP(regex) != IS_ARRAY) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Parameter mismatch, pattern is a string while replacement is an array");
- RETURN_FALSE;
- }
- SEPARATE_ZVAL(replace);
- if (Z_TYPE_PP(replace) != IS_ARRAY && (Z_TYPE_PP(replace) != IS_OBJECT || !is_callable_replace)) {
- convert_to_string_ex(replace);
- }
- if (is_callable_replace) {
- if (!zend_is_callable(*replace, 0, &callback_name TSRMLS_CC)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Requires argument 2, '%s', to be a valid callback", callback_name);
- efree(callback_name);
- MAKE_COPY_ZVAL(subject, return_value);
- return;
- }
- efree(callback_name);
- }
- SEPARATE_ZVAL(regex);
- SEPARATE_ZVAL(subject);
- if (ZEND_NUM_ARGS() > 3) {
- limit_val = limit;
- }
-
- if (Z_TYPE_PP(regex) != IS_ARRAY)
- convert_to_string_ex(regex);
-
- /* if subject is an array */
- if (Z_TYPE_PP(subject) == IS_ARRAY) {
- array_init(return_value);
- zend_hash_internal_pointer_reset(Z_ARRVAL_PP(subject));
- /* For each subject entry, convert it to string, then perform replacement
- and add the result to the return_value array. */
- while (zend_hash_get_current_data(Z_ARRVAL_PP(subject), (void **)&subject_entry) == SUCCESS) {
- SEPARATE_ZVAL(subject_entry);
- old_replace_count = replace_count;
- if ((result = php_replace_in_subject(*regex, *replace, subject_entry, &result_len, limit_val, is_callable_replace, &replace_count TSRMLS_CC)) != NULL) {
- if (!is_filter || replace_count > old_replace_count) {
- /* Add to return array */
- switch(zend_hash_get_current_key(Z_ARRVAL_PP(subject), &string_key, &num_key, 0))
- {
- case HASH_KEY_IS_STRING:
- add_assoc_stringl(return_value, string_key, result, result_len, 0);
- break;
- case HASH_KEY_IS_LONG:
- add_index_stringl(return_value, num_key, result, result_len, 0);
- break;
- }
- } else {
- efree(result);
- }
- }
-
- zend_hash_move_forward(Z_ARRVAL_PP(subject));
- }
- } else { /* if subject is not an array */
- old_replace_count = replace_count;
- if ((result = php_replace_in_subject(*regex, *replace, subject, &result_len, limit_val, is_callable_replace, &replace_count TSRMLS_CC)) != NULL) {
- if (!is_filter || replace_count > old_replace_count) {
- RETVAL_STRINGL(result, result_len, 0);
- } else {
- efree(result);
- }
- }
- }
- if (ZEND_NUM_ARGS() > 4) {
- zval_dtor(*zcount);
- ZVAL_LONG(*zcount, replace_count);
- }
-
- }
- /* }}} */
- /* {{{ proto mixed preg_replace(mixed regex, mixed replace, mixed subject [, int limit [, int &count]])
- Perform Perl-style regular expression replacement. */
- static PHP_FUNCTION(preg_replace)
- {
- preg_replace_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0, 0);
- }
- /* }}} */
- /* {{{ proto mixed preg_replace_callback(mixed regex, mixed callback, mixed subject [, int limit [, int &count]])
- Perform Perl-style regular expression replacement using replacement callback. */
- static PHP_FUNCTION(preg_replace_callback)
- {
- preg_replace_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1, 0);
- }
- /* }}} */
- /* {{{ proto mixed preg_filter(mixed regex, mixed replace, mixed subject [, int limit [, int &count]])
- Perform Perl-style regular expression replacement and only return matches. */
- static PHP_FUNCTION(preg_filter)
- {
- preg_replace_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0, 1);
- }
- /* }}} */
- /* {{{ proto array preg_split(string pattern, string subject [, int limit [, int flags]])
- Split string into an array using a perl-style regular expression as a delimiter */
- static PHP_FUNCTION(preg_split)
- {
- char *regex; /* Regular expression */
- char *subject; /* String to match against */
- int regex_len;
- int subject_len;
- long limit_val = -1;/* Integer value of limit */
- long flags = 0; /* Match control flags */
- pcre_cache_entry *pce; /* Compiled regular expression */
- /* Get function parameters and do error checking */
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|ll", ®ex, ®ex_len,
- &subject, &subject_len, &limit_val, &flags) == FAILURE) {
- RETURN_FALSE;
- }
-
- /* Compile regex or get it from cache. */
- if ((pce = pcre_get_compiled_regex_cache(regex, regex_len TSRMLS_CC)) == NULL) {
- RETURN_FALSE;
- }
- php_pcre_split_impl(pce, subject, subject_len, return_value, limit_val, flags TSRMLS_CC);
- }
- /* }}} */
- /* {{{ php_pcre_split
- */
- PHPAPI void php_pcre_split_impl(pcre_cache_entry *pce, char *subject, int subject_len, zval *return_value,
- long limit_val, long flags TSRMLS_DC)
- {
- pcre_extra *extra = NULL; /* Holds results of studying */
- pcre *re_bump = NULL; /* Regex instance for empty matches */
- pcre_extra *extra_bump = NULL; /* Almost dummy */
- pcre_extra extra_data; /* Used locally for exec options */
- int *offsets; /* Array of subpattern offsets */
- int size_offsets; /* Size of the offsets array */
- int exoptions = 0; /* Execution options */
- int count = 0; /* Count of matched subpatterns */
- int start_offset; /* Where the new search starts */
- int next_offset; /* End of the last delimiter match + 1 */
- int g_notempty = 0; /* If the match should not be empty */
- char *last_match; /* Location of last match */
- int rc;
- int no_empty; /* If NO_EMPTY flag is set */
- int delim_capture; /* If delimiters should be captured */
- int offset_capture; /* If offsets should be captured */
- no_empty = flags & PREG_SPLIT_NO_EMPTY;
- delim_capture = flags & PREG_SPLIT_DELIM_CAPTURE;
- offset_capture = flags & PREG_SPLIT_OFFSET_CAPTURE;
-
- if (limit_val == 0) {
- limit_val = -1;
- }
- if (extra == NULL) {
- extra_data.flags = PCRE_EXTRA_MATCH_LIMIT | PCRE_EXTRA_MATCH_LIMIT_RECURSION;
- extra = &extra_data;
- }
- extra->match_limit = PCRE_G(backtrack_limit);
- extra->match_limit_recursion = PCRE_G(recursion_limit);
-
- /* Initialize return value */
- array_init(return_value);
- /* Calculate the size of the offsets array, and allocate memory for it. */
- rc = pcre_fullinfo(pce->re, extra, PCRE_INFO_CAPTURECOUNT, &size_offsets);
- if (rc < 0) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Internal pcre_fullinfo() error %d", rc);
- RETURN_FALSE;
- }
- size_offsets = (size_offsets + 1) * 3;
- offsets = (int *)safe_emalloc(size_offsets, sizeof(int), 0);
-
- /* Start at the beginning of the string */
- start_offset = 0;
- next_offset = 0;
- last_match = subject;
- PCRE_G(error_code) = PHP_PCRE_NO_ERROR;
-
- /* Get next piece if no limit or limit not yet reached and something matched*/
- while ((limit_val == -1 || limit_val > 1)) {
- count = pcre_exec(pce->re, extra, subject,
- subject_len, start_offset,
- exoptions|g_notempty, offsets, size_offsets);
- /* the string was already proved to be valid UTF-8 */
- exoptions |= PCRE_NO_UTF8_CHECK;
- /* Check for too many substrings condition. */
- if (count == 0) {
- php_error_docref(NULL TSRMLS_CC,E_NOTICE, "Matched, but too many substrings");
- count = size_offsets/3;
- }
-
- /* If something matched */
- if (count > 0) {
- if (!no_empty || &subject[offsets[0]] != last_match) {
- if (offset_capture) {
- /* Add (match, offset) pair to the return value */
- add_offset_pair(return_value, last_match, &subject[offsets[0]]-last_match, next_offset, NULL);
- } else {
- /* Add the piece to the return value */
- add_next_index_stringl(return_value, last_match,
- &subject[offsets[0]]-last_match, 1);
- }
- /* One less left to do */
- if (limit_val != -1)
- limit_val--;
- }
-
- last_match = &subject[offsets[1]];
- next_offset = offsets[1];
- if (delim_capture) {
- int i, match_len;
- for (i = 1; i < count; i++) {
- match_len = offsets[(i<<1)+1] - offsets[i<<1];
- /* If we have matched a delimiter */
- if (!no_empty || match_len > 0) {
- if (offset_capture) {
- add_offset_pair(return_value, &subject[offsets[i<<1]], match_len, offsets[i<<1], NULL);
- } else {
- add_next_index_stringl(return_value,
- &subject[offsets[i<<1]],
- match_len, 1);
- }
- }
- }
- }
- } else if (count == PCRE_ERROR_NOMATCH) {
- /* If we previously set PCRE_NOTEMPTY after a null match,
- this is not necessarily the end. We need to advance
- the start offset, and continue. Fudge the offset values
- to achieve this, unless we're already at the end of the string. */
- if (g_notempty != 0 && start_offset < subject_len) {
- if (pce->compile_options & PCRE_UTF8) {
- if (re_bump == NULL) {
- int dummy;
- if ((re_bump = pcre_get_compiled_regex("/./us", &extra_bump, &dummy TSRMLS_CC)) == NULL) {
- RETURN_FALSE;
- }
- }
- count = p…
Large files files are truncated, but you can click here to view the full file