Annotation of embedaddon/php/ext/pcre/php_pcre.c, revision 1.1
1.1 ! misho 1: /*
! 2: +----------------------------------------------------------------------+
! 3: | PHP Version 5 |
! 4: +----------------------------------------------------------------------+
! 5: | Copyright (c) 1997-2012 The PHP Group |
! 6: +----------------------------------------------------------------------+
! 7: | This source file is subject to version 3.01 of the PHP license, |
! 8: | that is bundled with this package in the file LICENSE, and is |
! 9: | available through the world-wide-web at the following url: |
! 10: | http://www.php.net/license/3_01.txt |
! 11: | If you did not receive a copy of the PHP license and are unable to |
! 12: | obtain it through the world-wide-web, please send a note to |
! 13: | license@php.net so we can mail you a copy immediately. |
! 14: +----------------------------------------------------------------------+
! 15: | Author: Andrei Zmievski <andrei@php.net> |
! 16: +----------------------------------------------------------------------+
! 17: */
! 18:
! 19: /* $Id: php_pcre.c 321634 2012-01-01 13:15:04Z felipe $ */
! 20:
! 21: #include "php.h"
! 22: #include "php_ini.h"
! 23: #include "php_globals.h"
! 24: #include "php_pcre.h"
! 25: #include "ext/standard/info.h"
! 26: #include "ext/standard/php_smart_str.h"
! 27:
! 28: #if HAVE_PCRE || HAVE_BUNDLED_PCRE
! 29:
! 30: #include "ext/standard/php_string.h"
! 31:
! 32: #define PREG_PATTERN_ORDER 1
! 33: #define PREG_SET_ORDER 2
! 34: #define PREG_OFFSET_CAPTURE (1<<8)
! 35:
! 36: #define PREG_SPLIT_NO_EMPTY (1<<0)
! 37: #define PREG_SPLIT_DELIM_CAPTURE (1<<1)
! 38: #define PREG_SPLIT_OFFSET_CAPTURE (1<<2)
! 39:
! 40: #define PREG_REPLACE_EVAL (1<<0)
! 41:
! 42: #define PREG_GREP_INVERT (1<<0)
! 43:
! 44: #define PCRE_CACHE_SIZE 4096
! 45:
! 46: enum {
! 47: PHP_PCRE_NO_ERROR = 0,
! 48: PHP_PCRE_INTERNAL_ERROR,
! 49: PHP_PCRE_BACKTRACK_LIMIT_ERROR,
! 50: PHP_PCRE_RECURSION_LIMIT_ERROR,
! 51: PHP_PCRE_BAD_UTF8_ERROR,
! 52: PHP_PCRE_BAD_UTF8_OFFSET_ERROR
! 53: };
! 54:
! 55:
! 56: ZEND_DECLARE_MODULE_GLOBALS(pcre)
! 57:
! 58:
! 59: static void pcre_handle_exec_error(int pcre_code TSRMLS_DC) /* {{{ */
! 60: {
! 61: int preg_code = 0;
! 62:
! 63: switch (pcre_code) {
! 64: case PCRE_ERROR_MATCHLIMIT:
! 65: preg_code = PHP_PCRE_BACKTRACK_LIMIT_ERROR;
! 66: break;
! 67:
! 68: case PCRE_ERROR_RECURSIONLIMIT:
! 69: preg_code = PHP_PCRE_RECURSION_LIMIT_ERROR;
! 70: break;
! 71:
! 72: case PCRE_ERROR_BADUTF8:
! 73: preg_code = PHP_PCRE_BAD_UTF8_ERROR;
! 74: break;
! 75:
! 76: case PCRE_ERROR_BADUTF8_OFFSET:
! 77: preg_code = PHP_PCRE_BAD_UTF8_OFFSET_ERROR;
! 78: break;
! 79:
! 80: default:
! 81: preg_code = PHP_PCRE_INTERNAL_ERROR;
! 82: break;
! 83: }
! 84:
! 85: PCRE_G(error_code) = preg_code;
! 86: }
! 87: /* }}} */
! 88:
! 89: static void php_free_pcre_cache(void *data) /* {{{ */
! 90: {
! 91: pcre_cache_entry *pce = (pcre_cache_entry *) data;
! 92: if (!pce) return;
! 93: pefree(pce->re, 1);
! 94: if (pce->extra) pefree(pce->extra, 1);
! 95: #if HAVE_SETLOCALE
! 96: if ((void*)pce->tables) pefree((void*)pce->tables, 1);
! 97: pefree(pce->locale, 1);
! 98: #endif
! 99: }
! 100: /* }}} */
! 101:
! 102: static PHP_GINIT_FUNCTION(pcre) /* {{{ */
! 103: {
! 104: zend_hash_init(&pcre_globals->pcre_cache, 0, NULL, php_free_pcre_cache, 1);
! 105: pcre_globals->backtrack_limit = 0;
! 106: pcre_globals->recursion_limit = 0;
! 107: pcre_globals->error_code = PHP_PCRE_NO_ERROR;
! 108: }
! 109: /* }}} */
! 110:
! 111: static PHP_GSHUTDOWN_FUNCTION(pcre) /* {{{ */
! 112: {
! 113: zend_hash_destroy(&pcre_globals->pcre_cache);
! 114: }
! 115: /* }}} */
! 116:
! 117: PHP_INI_BEGIN()
! 118: STD_PHP_INI_ENTRY("pcre.backtrack_limit", "1000000", PHP_INI_ALL, OnUpdateLong, backtrack_limit, zend_pcre_globals, pcre_globals)
! 119: STD_PHP_INI_ENTRY("pcre.recursion_limit", "100000", PHP_INI_ALL, OnUpdateLong, recursion_limit, zend_pcre_globals, pcre_globals)
! 120: PHP_INI_END()
! 121:
! 122:
! 123: /* {{{ PHP_MINFO_FUNCTION(pcre) */
! 124: static PHP_MINFO_FUNCTION(pcre)
! 125: {
! 126: php_info_print_table_start();
! 127: php_info_print_table_row(2, "PCRE (Perl Compatible Regular Expressions) Support", "enabled" );
! 128: php_info_print_table_row(2, "PCRE Library Version", pcre_version() );
! 129: php_info_print_table_end();
! 130:
! 131: DISPLAY_INI_ENTRIES();
! 132: }
! 133: /* }}} */
! 134:
! 135: /* {{{ PHP_MINIT_FUNCTION(pcre) */
! 136: static PHP_MINIT_FUNCTION(pcre)
! 137: {
! 138: REGISTER_INI_ENTRIES();
! 139:
! 140: REGISTER_LONG_CONSTANT("PREG_PATTERN_ORDER", PREG_PATTERN_ORDER, CONST_CS | CONST_PERSISTENT);
! 141: REGISTER_LONG_CONSTANT("PREG_SET_ORDER", PREG_SET_ORDER, CONST_CS | CONST_PERSISTENT);
! 142: REGISTER_LONG_CONSTANT("PREG_OFFSET_CAPTURE", PREG_OFFSET_CAPTURE, CONST_CS | CONST_PERSISTENT);
! 143: REGISTER_LONG_CONSTANT("PREG_SPLIT_NO_EMPTY", PREG_SPLIT_NO_EMPTY, CONST_CS | CONST_PERSISTENT);
! 144: REGISTER_LONG_CONSTANT("PREG_SPLIT_DELIM_CAPTURE", PREG_SPLIT_DELIM_CAPTURE, CONST_CS | CONST_PERSISTENT);
! 145: REGISTER_LONG_CONSTANT("PREG_SPLIT_OFFSET_CAPTURE", PREG_SPLIT_OFFSET_CAPTURE, CONST_CS | CONST_PERSISTENT);
! 146: REGISTER_LONG_CONSTANT("PREG_GREP_INVERT", PREG_GREP_INVERT, CONST_CS | CONST_PERSISTENT);
! 147:
! 148: REGISTER_LONG_CONSTANT("PREG_NO_ERROR", PHP_PCRE_NO_ERROR, CONST_CS | CONST_PERSISTENT);
! 149: REGISTER_LONG_CONSTANT("PREG_INTERNAL_ERROR", PHP_PCRE_INTERNAL_ERROR, CONST_CS | CONST_PERSISTENT);
! 150: REGISTER_LONG_CONSTANT("PREG_BACKTRACK_LIMIT_ERROR", PHP_PCRE_BACKTRACK_LIMIT_ERROR, CONST_CS | CONST_PERSISTENT);
! 151: REGISTER_LONG_CONSTANT("PREG_RECURSION_LIMIT_ERROR", PHP_PCRE_RECURSION_LIMIT_ERROR, CONST_CS | CONST_PERSISTENT);
! 152: REGISTER_LONG_CONSTANT("PREG_BAD_UTF8_ERROR", PHP_PCRE_BAD_UTF8_ERROR, CONST_CS | CONST_PERSISTENT);
! 153: REGISTER_LONG_CONSTANT("PREG_BAD_UTF8_OFFSET_ERROR", PHP_PCRE_BAD_UTF8_OFFSET_ERROR, CONST_CS | CONST_PERSISTENT);
! 154: REGISTER_STRING_CONSTANT("PCRE_VERSION", (char *)pcre_version(), CONST_CS | CONST_PERSISTENT);
! 155:
! 156: return SUCCESS;
! 157: }
! 158: /* }}} */
! 159:
! 160: /* {{{ PHP_MSHUTDOWN_FUNCTION(pcre) */
! 161: static PHP_MSHUTDOWN_FUNCTION(pcre)
! 162: {
! 163: UNREGISTER_INI_ENTRIES();
! 164:
! 165: return SUCCESS;
! 166: }
! 167: /* }}} */
! 168:
! 169: /* {{{ static pcre_clean_cache */
! 170: static int pcre_clean_cache(void *data, void *arg TSRMLS_DC)
! 171: {
! 172: int *num_clean = (int *)arg;
! 173:
! 174: if (*num_clean > 0) {
! 175: (*num_clean)--;
! 176: return 1;
! 177: } else {
! 178: return 0;
! 179: }
! 180: }
! 181: /* }}} */
! 182:
! 183: /* {{{ static make_subpats_table */
! 184: static char **make_subpats_table(int num_subpats, pcre_cache_entry *pce TSRMLS_DC)
! 185: {
! 186: pcre_extra *extra = pce->extra;
! 187: int name_cnt = 0, name_size, ni = 0;
! 188: int rc;
! 189: char *name_table;
! 190: unsigned short name_idx;
! 191: char **subpat_names = (char **)ecalloc(num_subpats, sizeof(char *));
! 192:
! 193: rc = pcre_fullinfo(pce->re, extra, PCRE_INFO_NAMECOUNT, &name_cnt);
! 194: if (rc < 0) {
! 195: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Internal pcre_fullinfo() error %d", rc);
! 196: efree(subpat_names);
! 197: return NULL;
! 198: }
! 199: if (name_cnt > 0) {
! 200: int rc1, rc2;
! 201:
! 202: rc1 = pcre_fullinfo(pce->re, extra, PCRE_INFO_NAMETABLE, &name_table);
! 203: rc2 = pcre_fullinfo(pce->re, extra, PCRE_INFO_NAMEENTRYSIZE, &name_size);
! 204: rc = rc2 ? rc2 : rc1;
! 205: if (rc < 0) {
! 206: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Internal pcre_fullinfo() error %d", rc);
! 207: efree(subpat_names);
! 208: return NULL;
! 209: }
! 210:
! 211: while (ni++ < name_cnt) {
! 212: name_idx = 0xff * (unsigned char)name_table[0] + (unsigned char)name_table[1];
! 213: subpat_names[name_idx] = name_table + 2;
! 214: if (is_numeric_string(subpat_names[name_idx], strlen(subpat_names[name_idx]), NULL, NULL, 0) > 0) {
! 215: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Numeric named subpatterns are not allowed");
! 216: efree(subpat_names);
! 217: return NULL;
! 218: }
! 219: name_table += name_size;
! 220: }
! 221: }
! 222:
! 223: return subpat_names;
! 224: }
! 225: /* }}} */
! 226:
! 227: /* {{{ pcre_get_compiled_regex_cache
! 228: */
! 229: PHPAPI pcre_cache_entry* pcre_get_compiled_regex_cache(char *regex, int regex_len TSRMLS_DC)
! 230: {
! 231: pcre *re = NULL;
! 232: pcre_extra *extra;
! 233: int coptions = 0;
! 234: int soptions = 0;
! 235: const char *error;
! 236: int erroffset;
! 237: char delimiter;
! 238: char start_delimiter;
! 239: char end_delimiter;
! 240: char *p, *pp;
! 241: char *pattern;
! 242: int do_study = 0;
! 243: int poptions = 0;
! 244: int count = 0;
! 245: unsigned const char *tables = NULL;
! 246: #if HAVE_SETLOCALE
! 247: char *locale = setlocale(LC_CTYPE, NULL);
! 248: #endif
! 249: pcre_cache_entry *pce;
! 250: pcre_cache_entry new_entry;
! 251:
! 252: /* Try to lookup the cached regex entry, and if successful, just pass
! 253: back the compiled pattern, otherwise go on and compile it. */
! 254: if (zend_hash_find(&PCRE_G(pcre_cache), regex, regex_len+1, (void **)&pce) == SUCCESS) {
! 255: /*
! 256: * We use a quick pcre_fullinfo() check to see whether cache is corrupted, and if it
! 257: * is, we flush it and compile the pattern from scratch.
! 258: */
! 259: if (pcre_fullinfo(pce->re, NULL, PCRE_INFO_CAPTURECOUNT, &count) == PCRE_ERROR_BADMAGIC) {
! 260: zend_hash_clean(&PCRE_G(pcre_cache));
! 261: } else {
! 262: #if HAVE_SETLOCALE
! 263: if (!strcmp(pce->locale, locale)) {
! 264: #endif
! 265: return pce;
! 266: #if HAVE_SETLOCALE
! 267: }
! 268: #endif
! 269: }
! 270: }
! 271:
! 272: p = regex;
! 273:
! 274: /* Parse through the leading whitespace, and display a warning if we
! 275: get to the end without encountering a delimiter. */
! 276: while (isspace((int)*(unsigned char *)p)) p++;
! 277: if (*p == 0) {
! 278: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Empty regular expression");
! 279: return NULL;
! 280: }
! 281:
! 282: /* Get the delimiter and display a warning if it is alphanumeric
! 283: or a backslash. */
! 284: delimiter = *p++;
! 285: if (isalnum((int)*(unsigned char *)&delimiter) || delimiter == '\\') {
! 286: php_error_docref(NULL TSRMLS_CC,E_WARNING, "Delimiter must not be alphanumeric or backslash");
! 287: return NULL;
! 288: }
! 289:
! 290: start_delimiter = delimiter;
! 291: if ((pp = strchr("([{< )]}> )]}>", delimiter)))
! 292: delimiter = pp[5];
! 293: end_delimiter = delimiter;
! 294:
! 295: if (start_delimiter == end_delimiter) {
! 296: /* We need to iterate through the pattern, searching for the ending delimiter,
! 297: but skipping the backslashed delimiters. If the ending delimiter is not
! 298: found, display a warning. */
! 299: pp = p;
! 300: while (*pp != 0) {
! 301: if (*pp == '\\' && pp[1] != 0) pp++;
! 302: else if (*pp == delimiter)
! 303: break;
! 304: pp++;
! 305: }
! 306: if (*pp == 0) {
! 307: php_error_docref(NULL TSRMLS_CC,E_WARNING, "No ending delimiter '%c' found", delimiter);
! 308: return NULL;
! 309: }
! 310: } else {
! 311: /* We iterate through the pattern, searching for the matching ending
! 312: * delimiter. For each matching starting delimiter, we increment nesting
! 313: * level, and decrement it for each matching ending delimiter. If we
! 314: * reach the end of the pattern without matching, display a warning.
! 315: */
! 316: int brackets = 1; /* brackets nesting level */
! 317: pp = p;
! 318: while (*pp != 0) {
! 319: if (*pp == '\\' && pp[1] != 0) pp++;
! 320: else if (*pp == end_delimiter && --brackets <= 0)
! 321: break;
! 322: else if (*pp == start_delimiter)
! 323: brackets++;
! 324: pp++;
! 325: }
! 326: if (*pp == 0) {
! 327: php_error_docref(NULL TSRMLS_CC,E_WARNING, "No ending matching delimiter '%c' found", end_delimiter);
! 328: return NULL;
! 329: }
! 330: }
! 331:
! 332: /* Make a copy of the actual pattern. */
! 333: pattern = estrndup(p, pp-p);
! 334:
! 335: /* Move on to the options */
! 336: pp++;
! 337:
! 338: /* Parse through the options, setting appropriate flags. Display
! 339: a warning if we encounter an unknown modifier. */
! 340: while (*pp != 0) {
! 341: switch (*pp++) {
! 342: /* Perl compatible options */
! 343: case 'i': coptions |= PCRE_CASELESS; break;
! 344: case 'm': coptions |= PCRE_MULTILINE; break;
! 345: case 's': coptions |= PCRE_DOTALL; break;
! 346: case 'x': coptions |= PCRE_EXTENDED; break;
! 347:
! 348: /* PCRE specific options */
! 349: case 'A': coptions |= PCRE_ANCHORED; break;
! 350: case 'D': coptions |= PCRE_DOLLAR_ENDONLY;break;
! 351: case 'S': do_study = 1; break;
! 352: case 'U': coptions |= PCRE_UNGREEDY; break;
! 353: case 'X': coptions |= PCRE_EXTRA; break;
! 354: case 'u': coptions |= PCRE_UTF8;
! 355: /* In PCRE, by default, \d, \D, \s, \S, \w, and \W recognize only ASCII
! 356: characters, even in UTF-8 mode. However, this can be changed by setting
! 357: the PCRE_UCP option. */
! 358: #ifdef PCRE_UCP
! 359: coptions |= PCRE_UCP;
! 360: #endif
! 361: break;
! 362:
! 363: /* Custom preg options */
! 364: case 'e': poptions |= PREG_REPLACE_EVAL; break;
! 365:
! 366: case ' ':
! 367: case '\n':
! 368: break;
! 369:
! 370: default:
! 371: php_error_docref(NULL TSRMLS_CC,E_WARNING, "Unknown modifier '%c'", pp[-1]);
! 372: efree(pattern);
! 373: return NULL;
! 374: }
! 375: }
! 376:
! 377: #if HAVE_SETLOCALE
! 378: if (strcmp(locale, "C"))
! 379: tables = pcre_maketables();
! 380: #endif
! 381:
! 382: /* Compile pattern and display a warning if compilation failed. */
! 383: re = pcre_compile(pattern,
! 384: coptions,
! 385: &error,
! 386: &erroffset,
! 387: tables);
! 388:
! 389: if (re == NULL) {
! 390: php_error_docref(NULL TSRMLS_CC,E_WARNING, "Compilation failed: %s at offset %d", error, erroffset);
! 391: efree(pattern);
! 392: if (tables) {
! 393: pefree((void*)tables, 1);
! 394: }
! 395: return NULL;
! 396: }
! 397:
! 398: /* If study option was specified, study the pattern and
! 399: store the result in extra for passing to pcre_exec. */
! 400: if (do_study) {
! 401: extra = pcre_study(re, soptions, &error);
! 402: if (extra) {
! 403: extra->flags |= PCRE_EXTRA_MATCH_LIMIT | PCRE_EXTRA_MATCH_LIMIT_RECURSION;
! 404: }
! 405: if (error != NULL) {
! 406: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error while studying pattern");
! 407: }
! 408: } else {
! 409: extra = NULL;
! 410: }
! 411:
! 412: efree(pattern);
! 413:
! 414: /*
! 415: * If we reached cache limit, clean out the items from the head of the list;
! 416: * these are supposedly the oldest ones (but not necessarily the least used
! 417: * ones).
! 418: */
! 419: if (zend_hash_num_elements(&PCRE_G(pcre_cache)) == PCRE_CACHE_SIZE) {
! 420: int num_clean = PCRE_CACHE_SIZE / 8;
! 421: zend_hash_apply_with_argument(&PCRE_G(pcre_cache), pcre_clean_cache, &num_clean TSRMLS_CC);
! 422: }
! 423:
! 424: /* Store the compiled pattern and extra info in the cache. */
! 425: new_entry.re = re;
! 426: new_entry.extra = extra;
! 427: new_entry.preg_options = poptions;
! 428: new_entry.compile_options = coptions;
! 429: #if HAVE_SETLOCALE
! 430: new_entry.locale = pestrdup(locale, 1);
! 431: new_entry.tables = tables;
! 432: #endif
! 433: zend_hash_update(&PCRE_G(pcre_cache), regex, regex_len+1, (void *)&new_entry,
! 434: sizeof(pcre_cache_entry), (void**)&pce);
! 435:
! 436: return pce;
! 437: }
! 438: /* }}} */
! 439:
! 440: /* {{{ pcre_get_compiled_regex
! 441: */
! 442: PHPAPI pcre* pcre_get_compiled_regex(char *regex, pcre_extra **extra, int *preg_options TSRMLS_DC)
! 443: {
! 444: pcre_cache_entry * pce = pcre_get_compiled_regex_cache(regex, strlen(regex) TSRMLS_CC);
! 445:
! 446: if (extra) {
! 447: *extra = pce ? pce->extra : NULL;
! 448: }
! 449: if (preg_options) {
! 450: *preg_options = pce ? pce->preg_options : 0;
! 451: }
! 452:
! 453: return pce ? pce->re : NULL;
! 454: }
! 455: /* }}} */
! 456:
! 457: /* {{{ pcre_get_compiled_regex_ex
! 458: */
! 459: PHPAPI pcre* pcre_get_compiled_regex_ex(char *regex, pcre_extra **extra, int *preg_options, int *compile_options TSRMLS_DC)
! 460: {
! 461: pcre_cache_entry * pce = pcre_get_compiled_regex_cache(regex, strlen(regex) TSRMLS_CC);
! 462:
! 463: if (extra) {
! 464: *extra = pce ? pce->extra : NULL;
! 465: }
! 466: if (preg_options) {
! 467: *preg_options = pce ? pce->preg_options : 0;
! 468: }
! 469: if (compile_options) {
! 470: *compile_options = pce ? pce->compile_options : 0;
! 471: }
! 472:
! 473: return pce ? pce->re : NULL;
! 474: }
! 475: /* }}} */
! 476:
! 477: /* {{{ add_offset_pair */
! 478: static inline void add_offset_pair(zval *result, char *str, int len, int offset, char *name)
! 479: {
! 480: zval *match_pair;
! 481:
! 482: ALLOC_ZVAL(match_pair);
! 483: array_init(match_pair);
! 484: INIT_PZVAL(match_pair);
! 485:
! 486: /* Add (match, offset) to the return value */
! 487: add_next_index_stringl(match_pair, str, len, 1);
! 488: add_next_index_long(match_pair, offset);
! 489:
! 490: if (name) {
! 491: zval_add_ref(&match_pair);
! 492: zend_hash_update(Z_ARRVAL_P(result), name, strlen(name)+1, &match_pair, sizeof(zval *), NULL);
! 493: }
! 494: zend_hash_next_index_insert(Z_ARRVAL_P(result), &match_pair, sizeof(zval *), NULL);
! 495: }
! 496: /* }}} */
! 497:
! 498: static void php_do_pcre_match(INTERNAL_FUNCTION_PARAMETERS, int global) /* {{{ */
! 499: {
! 500: /* parameters */
! 501: char *regex; /* Regular expression */
! 502: char *subject; /* String to match against */
! 503: int regex_len;
! 504: int subject_len;
! 505: pcre_cache_entry *pce; /* Compiled regular expression */
! 506: zval *subpats = NULL; /* Array for subpatterns */
! 507: long flags = 0; /* Match control flags */
! 508: long start_offset = 0; /* Where the new search starts */
! 509:
! 510: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, ((global) ? "ssz|ll" : "ss|zll"), ®ex, ®ex_len,
! 511: &subject, &subject_len, &subpats, &flags, &start_offset) == FAILURE) {
! 512: RETURN_FALSE;
! 513: }
! 514:
! 515: /* Compile regex or get it from cache. */
! 516: if ((pce = pcre_get_compiled_regex_cache(regex, regex_len TSRMLS_CC)) == NULL) {
! 517: RETURN_FALSE;
! 518: }
! 519:
! 520: php_pcre_match_impl(pce, subject, subject_len, return_value, subpats,
! 521: global, ZEND_NUM_ARGS() >= 4, flags, start_offset TSRMLS_CC);
! 522: }
! 523: /* }}} */
! 524:
! 525: /* {{{ php_pcre_match_impl() */
! 526: PHPAPI void php_pcre_match_impl(pcre_cache_entry *pce, char *subject, int subject_len, zval *return_value,
! 527: zval *subpats, int global, int use_flags, long flags, long start_offset TSRMLS_DC)
! 528: {
! 529: zval *result_set, /* Holds a set of subpatterns after
! 530: a global match */
! 531: **match_sets = NULL; /* An array of sets of matches for each
! 532: subpattern after a global match */
! 533: pcre_extra *extra = pce->extra;/* Holds results of studying */
! 534: pcre_extra extra_data; /* Used locally for exec options */
! 535: int exoptions = 0; /* Execution options */
! 536: int count = 0; /* Count of matched subpatterns */
! 537: int *offsets; /* Array of subpattern offsets */
! 538: int num_subpats; /* Number of captured subpatterns */
! 539: int size_offsets; /* Size of the offsets array */
! 540: int matched; /* Has anything matched */
! 541: int g_notempty = 0; /* If the match should not be empty */
! 542: const char **stringlist; /* Holds list of subpatterns */
! 543: char **subpat_names; /* Array for named subpatterns */
! 544: int i, rc;
! 545: int subpats_order; /* Order of subpattern matches */
! 546: int offset_capture; /* Capture match offsets: yes/no */
! 547:
! 548: /* Overwrite the passed-in value for subpatterns with an empty array. */
! 549: if (subpats != NULL) {
! 550: zval_dtor(subpats);
! 551: array_init(subpats);
! 552: }
! 553:
! 554: subpats_order = global ? PREG_PATTERN_ORDER : 0;
! 555:
! 556: if (use_flags) {
! 557: offset_capture = flags & PREG_OFFSET_CAPTURE;
! 558:
! 559: /*
! 560: * subpats_order is pre-set to pattern mode so we change it only if
! 561: * necessary.
! 562: */
! 563: if (flags & 0xff) {
! 564: subpats_order = flags & 0xff;
! 565: }
! 566: if ((global && (subpats_order < PREG_PATTERN_ORDER || subpats_order > PREG_SET_ORDER)) ||
! 567: (!global && subpats_order != 0)) {
! 568: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid flags specified");
! 569: return;
! 570: }
! 571: } else {
! 572: offset_capture = 0;
! 573: }
! 574:
! 575: /* Negative offset counts from the end of the string. */
! 576: if (start_offset < 0) {
! 577: start_offset = subject_len + start_offset;
! 578: if (start_offset < 0) {
! 579: start_offset = 0;
! 580: }
! 581: }
! 582:
! 583: if (extra == NULL) {
! 584: extra_data.flags = PCRE_EXTRA_MATCH_LIMIT | PCRE_EXTRA_MATCH_LIMIT_RECURSION;
! 585: extra = &extra_data;
! 586: }
! 587: extra->match_limit = PCRE_G(backtrack_limit);
! 588: extra->match_limit_recursion = PCRE_G(recursion_limit);
! 589:
! 590: /* Calculate the size of the offsets array, and allocate memory for it. */
! 591: rc = pcre_fullinfo(pce->re, extra, PCRE_INFO_CAPTURECOUNT, &num_subpats);
! 592: if (rc < 0) {
! 593: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Internal pcre_fullinfo() error %d", rc);
! 594: RETURN_FALSE;
! 595: }
! 596: num_subpats++;
! 597: size_offsets = num_subpats * 3;
! 598:
! 599: /*
! 600: * Build a mapping from subpattern numbers to their names. We will always
! 601: * allocate the table, even though there may be no named subpatterns. This
! 602: * avoids somewhat more complicated logic in the inner loops.
! 603: */
! 604: subpat_names = make_subpats_table(num_subpats, pce TSRMLS_CC);
! 605: if (!subpat_names) {
! 606: RETURN_FALSE;
! 607: }
! 608:
! 609: offsets = (int *)safe_emalloc(size_offsets, sizeof(int), 0);
! 610:
! 611: /* Allocate match sets array and initialize the values. */
! 612: if (global && subpats_order == PREG_PATTERN_ORDER) {
! 613: match_sets = (zval **)safe_emalloc(num_subpats, sizeof(zval *), 0);
! 614: for (i=0; i<num_subpats; i++) {
! 615: ALLOC_ZVAL(match_sets[i]);
! 616: array_init(match_sets[i]);
! 617: INIT_PZVAL(match_sets[i]);
! 618: }
! 619: }
! 620:
! 621: matched = 0;
! 622: PCRE_G(error_code) = PHP_PCRE_NO_ERROR;
! 623:
! 624: do {
! 625: /* Execute the regular expression. */
! 626: count = pcre_exec(pce->re, extra, subject, subject_len, start_offset,
! 627: exoptions|g_notempty, offsets, size_offsets);
! 628:
! 629: /* the string was already proved to be valid UTF-8 */
! 630: exoptions |= PCRE_NO_UTF8_CHECK;
! 631:
! 632: /* Check for too many substrings condition. */
! 633: if (count == 0) {
! 634: php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Matched, but too many substrings");
! 635: count = size_offsets/3;
! 636: }
! 637:
! 638: /* If something has matched */
! 639: if (count > 0) {
! 640: matched++;
! 641:
! 642: /* If subpatterns array has been passed, fill it in with values. */
! 643: if (subpats != NULL) {
! 644: /* Try to get the list of substrings and display a warning if failed. */
! 645: if (pcre_get_substring_list(subject, offsets, count, &stringlist) < 0) {
! 646: efree(subpat_names);
! 647: efree(offsets);
! 648: if (match_sets) efree(match_sets);
! 649: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Get subpatterns list failed");
! 650: RETURN_FALSE;
! 651: }
! 652:
! 653: if (global) { /* global pattern matching */
! 654: if (subpats_order == PREG_PATTERN_ORDER) {
! 655: /* For each subpattern, insert it into the appropriate array. */
! 656: for (i = 0; i < count; i++) {
! 657: if (offset_capture) {
! 658: add_offset_pair(match_sets[i], (char *)stringlist[i],
! 659: offsets[(i<<1)+1] - offsets[i<<1], offsets[i<<1], NULL);
! 660: } else {
! 661: add_next_index_stringl(match_sets[i], (char *)stringlist[i],
! 662: offsets[(i<<1)+1] - offsets[i<<1], 1);
! 663: }
! 664: }
! 665: /*
! 666: * If the number of captured subpatterns on this run is
! 667: * less than the total possible number, pad the result
! 668: * arrays with empty strings.
! 669: */
! 670: if (count < num_subpats) {
! 671: for (; i < num_subpats; i++) {
! 672: add_next_index_string(match_sets[i], "", 1);
! 673: }
! 674: }
! 675: } else {
! 676: /* Allocate the result set array */
! 677: ALLOC_ZVAL(result_set);
! 678: array_init(result_set);
! 679: INIT_PZVAL(result_set);
! 680:
! 681: /* Add all the subpatterns to it */
! 682: for (i = 0; i < count; i++) {
! 683: if (offset_capture) {
! 684: add_offset_pair(result_set, (char *)stringlist[i],
! 685: offsets[(i<<1)+1] - offsets[i<<1], offsets[i<<1], subpat_names[i]);
! 686: } else {
! 687: if (subpat_names[i]) {
! 688: add_assoc_stringl(result_set, subpat_names[i], (char *)stringlist[i],
! 689: offsets[(i<<1)+1] - offsets[i<<1], 1);
! 690: }
! 691: add_next_index_stringl(result_set, (char *)stringlist[i],
! 692: offsets[(i<<1)+1] - offsets[i<<1], 1);
! 693: }
! 694: }
! 695: /* And add it to the output array */
! 696: zend_hash_next_index_insert(Z_ARRVAL_P(subpats), &result_set, sizeof(zval *), NULL);
! 697: }
! 698: } else { /* single pattern matching */
! 699: /* For each subpattern, insert it into the subpatterns array. */
! 700: for (i = 0; i < count; i++) {
! 701: if (offset_capture) {
! 702: add_offset_pair(subpats, (char *)stringlist[i],
! 703: offsets[(i<<1)+1] - offsets[i<<1],
! 704: offsets[i<<1], subpat_names[i]);
! 705: } else {
! 706: if (subpat_names[i]) {
! 707: add_assoc_stringl(subpats, subpat_names[i], (char *)stringlist[i],
! 708: offsets[(i<<1)+1] - offsets[i<<1], 1);
! 709: }
! 710: add_next_index_stringl(subpats, (char *)stringlist[i],
! 711: offsets[(i<<1)+1] - offsets[i<<1], 1);
! 712: }
! 713: }
! 714: }
! 715:
! 716: pcre_free((void *) stringlist);
! 717: }
! 718: } else if (count == PCRE_ERROR_NOMATCH) {
! 719: /* If we previously set PCRE_NOTEMPTY after a null match,
! 720: this is not necessarily the end. We need to advance
! 721: the start offset, and continue. Fudge the offset values
! 722: to achieve this, unless we're already at the end of the string. */
! 723: if (g_notempty != 0 && start_offset < subject_len) {
! 724: offsets[0] = start_offset;
! 725: offsets[1] = start_offset + 1;
! 726: } else
! 727: break;
! 728: } else {
! 729: pcre_handle_exec_error(count TSRMLS_CC);
! 730: break;
! 731: }
! 732:
! 733: /* If we have matched an empty string, mimic what Perl's /g options does.
! 734: This turns out to be rather cunning. First we set PCRE_NOTEMPTY and try
! 735: the match again at the same point. If this fails (picked up above) we
! 736: advance to the next character. */
! 737: g_notempty = (offsets[1] == offsets[0])? PCRE_NOTEMPTY | PCRE_ANCHORED : 0;
! 738:
! 739: /* Advance to the position right after the last full match */
! 740: start_offset = offsets[1];
! 741: } while (global);
! 742:
! 743: /* Add the match sets to the output array and clean up */
! 744: if (global && subpats_order == PREG_PATTERN_ORDER) {
! 745: for (i = 0; i < num_subpats; i++) {
! 746: if (subpat_names[i]) {
! 747: zend_hash_update(Z_ARRVAL_P(subpats), subpat_names[i],
! 748: strlen(subpat_names[i])+1, &match_sets[i], sizeof(zval *), NULL);
! 749: Z_ADDREF_P(match_sets[i]);
! 750: }
! 751: zend_hash_next_index_insert(Z_ARRVAL_P(subpats), &match_sets[i], sizeof(zval *), NULL);
! 752: }
! 753: efree(match_sets);
! 754: }
! 755:
! 756: efree(offsets);
! 757: efree(subpat_names);
! 758:
! 759: /* Did we encounter an error? */
! 760: if (PCRE_G(error_code) == PHP_PCRE_NO_ERROR) {
! 761: RETVAL_LONG(matched);
! 762: } else {
! 763: RETVAL_FALSE;
! 764: }
! 765: }
! 766: /* }}} */
! 767:
! 768: /* {{{ proto int preg_match(string pattern, string subject [, array &subpatterns [, int flags [, int offset]]])
! 769: Perform a Perl-style regular expression match */
! 770: static PHP_FUNCTION(preg_match)
! 771: {
! 772: php_do_pcre_match(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
! 773: }
! 774: /* }}} */
! 775:
! 776: /* {{{ proto int preg_match_all(string pattern, string subject, array &subpatterns [, int flags [, int offset]])
! 777: Perform a Perl-style global regular expression match */
! 778: static PHP_FUNCTION(preg_match_all)
! 779: {
! 780: php_do_pcre_match(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
! 781: }
! 782: /* }}} */
! 783:
! 784: /* {{{ preg_get_backref
! 785: */
! 786: static int preg_get_backref(char **str, int *backref)
! 787: {
! 788: register char in_brace = 0;
! 789: register char *walk = *str;
! 790:
! 791: if (walk[1] == 0)
! 792: return 0;
! 793:
! 794: if (*walk == '$' && walk[1] == '{') {
! 795: in_brace = 1;
! 796: walk++;
! 797: }
! 798: walk++;
! 799:
! 800: if (*walk >= '0' && *walk <= '9') {
! 801: *backref = *walk - '0';
! 802: walk++;
! 803: } else
! 804: return 0;
! 805:
! 806: if (*walk && *walk >= '0' && *walk <= '9') {
! 807: *backref = *backref * 10 + *walk - '0';
! 808: walk++;
! 809: }
! 810:
! 811: if (in_brace) {
! 812: if (*walk == 0 || *walk != '}')
! 813: return 0;
! 814: else
! 815: walk++;
! 816: }
! 817:
! 818: *str = walk;
! 819: return 1;
! 820: }
! 821: /* }}} */
! 822:
! 823: /* {{{ preg_do_repl_func
! 824: */
! 825: static int preg_do_repl_func(zval *function, char *subject, int *offsets, char **subpat_names, int count, char **result TSRMLS_DC)
! 826: {
! 827: zval *retval_ptr; /* Function return value */
! 828: zval **args[1]; /* Argument to pass to function */
! 829: zval *subpats; /* Captured subpatterns */
! 830: int result_len; /* Return value length */
! 831: int i;
! 832:
! 833: MAKE_STD_ZVAL(subpats);
! 834: array_init(subpats);
! 835: for (i = 0; i < count; i++) {
! 836: if (subpat_names[i]) {
! 837: add_assoc_stringl(subpats, subpat_names[i], &subject[offsets[i<<1]] , offsets[(i<<1)+1] - offsets[i<<1], 1);
! 838: }
! 839: add_next_index_stringl(subpats, &subject[offsets[i<<1]], offsets[(i<<1)+1] - offsets[i<<1], 1);
! 840: }
! 841: args[0] = &subpats;
! 842:
! 843: if (call_user_function_ex(EG(function_table), NULL, function, &retval_ptr, 1, args, 0, NULL TSRMLS_CC) == SUCCESS && retval_ptr) {
! 844: convert_to_string_ex(&retval_ptr);
! 845: *result = estrndup(Z_STRVAL_P(retval_ptr), Z_STRLEN_P(retval_ptr));
! 846: result_len = Z_STRLEN_P(retval_ptr);
! 847: zval_ptr_dtor(&retval_ptr);
! 848: } else {
! 849: if (!EG(exception)) {
! 850: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to call custom replacement function");
! 851: }
! 852: result_len = offsets[1] - offsets[0];
! 853: *result = estrndup(&subject[offsets[0]], result_len);
! 854: }
! 855:
! 856: zval_ptr_dtor(&subpats);
! 857:
! 858: return result_len;
! 859: }
! 860: /* }}} */
! 861:
! 862: /* {{{ preg_do_eval
! 863: */
! 864: static int preg_do_eval(char *eval_str, int eval_str_len, char *subject,
! 865: int *offsets, int count, char **result TSRMLS_DC)
! 866: {
! 867: zval retval; /* Return value from evaluation */
! 868: char *eval_str_end, /* End of eval string */
! 869: *match, /* Current match for a backref */
! 870: *esc_match, /* Quote-escaped match */
! 871: *walk, /* Used to walk the code string */
! 872: *segment, /* Start of segment to append while walking */
! 873: walk_last; /* Last walked character */
! 874: int match_len; /* Length of the match */
! 875: int esc_match_len; /* Length of the quote-escaped match */
! 876: int result_len; /* Length of the result of the evaluation */
! 877: int backref; /* Current backref */
! 878: char *compiled_string_description;
! 879: smart_str code = {0};
! 880:
! 881: eval_str_end = eval_str + eval_str_len;
! 882: walk = segment = eval_str;
! 883: walk_last = 0;
! 884:
! 885: while (walk < eval_str_end) {
! 886: /* If found a backreference.. */
! 887: if ('\\' == *walk || '$' == *walk) {
! 888: smart_str_appendl(&code, segment, walk - segment);
! 889: if (walk_last == '\\') {
! 890: code.c[code.len-1] = *walk++;
! 891: segment = walk;
! 892: walk_last = 0;
! 893: continue;
! 894: }
! 895: segment = walk;
! 896: if (preg_get_backref(&walk, &backref)) {
! 897: if (backref < count) {
! 898: /* Find the corresponding string match and substitute it
! 899: in instead of the backref */
! 900: match = subject + offsets[backref<<1];
! 901: match_len = offsets[(backref<<1)+1] - offsets[backref<<1];
! 902: if (match_len) {
! 903: esc_match = php_addslashes_ex(match, match_len, &esc_match_len, 0, 1 TSRMLS_CC);
! 904: } else {
! 905: esc_match = match;
! 906: esc_match_len = 0;
! 907: }
! 908: } else {
! 909: esc_match = "";
! 910: esc_match_len = 0;
! 911: }
! 912: smart_str_appendl(&code, esc_match, esc_match_len);
! 913:
! 914: segment = walk;
! 915:
! 916: /* Clean up and reassign */
! 917: if (esc_match_len)
! 918: efree(esc_match);
! 919: continue;
! 920: }
! 921: }
! 922: walk++;
! 923: walk_last = walk[-1];
! 924: }
! 925: smart_str_appendl(&code, segment, walk - segment);
! 926: smart_str_0(&code);
! 927:
! 928: compiled_string_description = zend_make_compiled_string_description("regexp code" TSRMLS_CC);
! 929: /* Run the code */
! 930: if (zend_eval_stringl(code.c, code.len, &retval, compiled_string_description TSRMLS_CC) == FAILURE) {
! 931: efree(compiled_string_description);
! 932: php_error_docref(NULL TSRMLS_CC,E_ERROR, "Failed evaluating code: %s%s", PHP_EOL, code.c);
! 933: /* zend_error() does not return in this case */
! 934: }
! 935: efree(compiled_string_description);
! 936: convert_to_string(&retval);
! 937:
! 938: /* Save the return value and its length */
! 939: *result = estrndup(Z_STRVAL(retval), Z_STRLEN(retval));
! 940: result_len = Z_STRLEN(retval);
! 941:
! 942: /* Clean up */
! 943: zval_dtor(&retval);
! 944: smart_str_free(&code);
! 945:
! 946: return result_len;
! 947: }
! 948: /* }}} */
! 949:
! 950: /* {{{ php_pcre_replace
! 951: */
! 952: PHPAPI char *php_pcre_replace(char *regex, int regex_len,
! 953: char *subject, int subject_len,
! 954: zval *replace_val, int is_callable_replace,
! 955: int *result_len, int limit, int *replace_count TSRMLS_DC)
! 956: {
! 957: pcre_cache_entry *pce; /* Compiled regular expression */
! 958:
! 959: /* Compile regex or get it from cache. */
! 960: if ((pce = pcre_get_compiled_regex_cache(regex, regex_len TSRMLS_CC)) == NULL) {
! 961: return NULL;
! 962: }
! 963:
! 964: return php_pcre_replace_impl(pce, subject, subject_len, replace_val,
! 965: is_callable_replace, result_len, limit, replace_count TSRMLS_CC);
! 966: }
! 967: /* }}} */
! 968:
! 969: /* {{{ php_pcre_replace_impl() */
! 970: PHPAPI char *php_pcre_replace_impl(pcre_cache_entry *pce, char *subject, int subject_len, zval *replace_val,
! 971: int is_callable_replace, int *result_len, int limit, int *replace_count TSRMLS_DC)
! 972: {
! 973: pcre_extra *extra = pce->extra;/* Holds results of studying */
! 974: pcre_extra extra_data; /* Used locally for exec options */
! 975: int exoptions = 0; /* Execution options */
! 976: int count = 0; /* Count of matched subpatterns */
! 977: int *offsets; /* Array of subpattern offsets */
! 978: char **subpat_names; /* Array for named subpatterns */
! 979: int num_subpats; /* Number of captured subpatterns */
! 980: int size_offsets; /* Size of the offsets array */
! 981: int new_len; /* Length of needed storage */
! 982: int alloc_len; /* Actual allocated length */
! 983: int eval_result_len=0; /* Length of the eval'ed or
! 984: function-returned string */
! 985: int match_len; /* Length of the current match */
! 986: int backref; /* Backreference number */
! 987: int eval; /* If the replacement string should be eval'ed */
! 988: int start_offset; /* Where the new search starts */
! 989: int g_notempty=0; /* If the match should not be empty */
! 990: int replace_len=0; /* Length of replacement string */
! 991: char *result, /* Result of replacement */
! 992: *replace=NULL, /* Replacement string */
! 993: *new_buf, /* Temporary buffer for re-allocation */
! 994: *walkbuf, /* Location of current replacement in the result */
! 995: *walk, /* Used to walk the replacement string */
! 996: *match, /* The current match */
! 997: *piece, /* The current piece of subject */
! 998: *replace_end=NULL, /* End of replacement string */
! 999: *eval_result, /* Result of eval or custom function */
! 1000: walk_last; /* Last walked character */
! 1001: int rc;
! 1002:
! 1003: if (extra == NULL) {
! 1004: extra_data.flags = PCRE_EXTRA_MATCH_LIMIT | PCRE_EXTRA_MATCH_LIMIT_RECURSION;
! 1005: extra = &extra_data;
! 1006: }
! 1007: extra->match_limit = PCRE_G(backtrack_limit);
! 1008: extra->match_limit_recursion = PCRE_G(recursion_limit);
! 1009:
! 1010: eval = pce->preg_options & PREG_REPLACE_EVAL;
! 1011: if (is_callable_replace) {
! 1012: if (eval) {
! 1013: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Modifier /e cannot be used with replacement callback");
! 1014: return NULL;
! 1015: }
! 1016: } else {
! 1017: replace = Z_STRVAL_P(replace_val);
! 1018: replace_len = Z_STRLEN_P(replace_val);
! 1019: replace_end = replace + replace_len;
! 1020: }
! 1021:
! 1022: /* Calculate the size of the offsets array, and allocate memory for it. */
! 1023: rc = pcre_fullinfo(pce->re, extra, PCRE_INFO_CAPTURECOUNT, &num_subpats);
! 1024: if (rc < 0) {
! 1025: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Internal pcre_fullinfo() error %d", rc);
! 1026: return NULL;
! 1027: }
! 1028: num_subpats++;
! 1029: size_offsets = num_subpats * 3;
! 1030:
! 1031: /*
! 1032: * Build a mapping from subpattern numbers to their names. We will always
! 1033: * allocate the table, even though there may be no named subpatterns. This
! 1034: * avoids somewhat more complicated logic in the inner loops.
! 1035: */
! 1036: subpat_names = make_subpats_table(num_subpats, pce TSRMLS_CC);
! 1037: if (!subpat_names) {
! 1038: return NULL;
! 1039: }
! 1040:
! 1041: offsets = (int *)safe_emalloc(size_offsets, sizeof(int), 0);
! 1042:
! 1043: alloc_len = 2 * subject_len + 1;
! 1044: result = safe_emalloc(alloc_len, sizeof(char), 0);
! 1045:
! 1046: /* Initialize */
! 1047: match = NULL;
! 1048: *result_len = 0;
! 1049: start_offset = 0;
! 1050: PCRE_G(error_code) = PHP_PCRE_NO_ERROR;
! 1051:
! 1052: while (1) {
! 1053: /* Execute the regular expression. */
! 1054: count = pcre_exec(pce->re, extra, subject, subject_len, start_offset,
! 1055: exoptions|g_notempty, offsets, size_offsets);
! 1056:
! 1057: /* the string was already proved to be valid UTF-8 */
! 1058: exoptions |= PCRE_NO_UTF8_CHECK;
! 1059:
! 1060: /* Check for too many substrings condition. */
! 1061: if (count == 0) {
! 1062: php_error_docref(NULL TSRMLS_CC,E_NOTICE, "Matched, but too many substrings");
! 1063: count = size_offsets/3;
! 1064: }
! 1065:
! 1066: piece = subject + start_offset;
! 1067:
! 1068: if (count > 0 && (limit == -1 || limit > 0)) {
! 1069: if (replace_count) {
! 1070: ++*replace_count;
! 1071: }
! 1072: /* Set the match location in subject */
! 1073: match = subject + offsets[0];
! 1074:
! 1075: new_len = *result_len + offsets[0] - start_offset; /* part before the match */
! 1076:
! 1077: /* If evaluating, do it and add the return string's length */
! 1078: if (eval) {
! 1079: eval_result_len = preg_do_eval(replace, replace_len, subject,
! 1080: offsets, count, &eval_result TSRMLS_CC);
! 1081: new_len += eval_result_len;
! 1082: } else if (is_callable_replace) {
! 1083: /* Use custom function to get replacement string and its length. */
! 1084: eval_result_len = preg_do_repl_func(replace_val, subject, offsets, subpat_names, count, &eval_result TSRMLS_CC);
! 1085: new_len += eval_result_len;
! 1086: } else { /* do regular substitution */
! 1087: walk = replace;
! 1088: walk_last = 0;
! 1089: while (walk < replace_end) {
! 1090: if ('\\' == *walk || '$' == *walk) {
! 1091: if (walk_last == '\\') {
! 1092: walk++;
! 1093: walk_last = 0;
! 1094: continue;
! 1095: }
! 1096: if (preg_get_backref(&walk, &backref)) {
! 1097: if (backref < count)
! 1098: new_len += offsets[(backref<<1)+1] - offsets[backref<<1];
! 1099: continue;
! 1100: }
! 1101: }
! 1102: new_len++;
! 1103: walk++;
! 1104: walk_last = walk[-1];
! 1105: }
! 1106: }
! 1107:
! 1108: if (new_len + 1 > alloc_len) {
! 1109: alloc_len = 1 + alloc_len + 2 * new_len;
! 1110: new_buf = emalloc(alloc_len);
! 1111: memcpy(new_buf, result, *result_len);
! 1112: efree(result);
! 1113: result = new_buf;
! 1114: }
! 1115: /* copy the part of the string before the match */
! 1116: memcpy(&result[*result_len], piece, match-piece);
! 1117: *result_len += match-piece;
! 1118:
! 1119: /* copy replacement and backrefs */
! 1120: walkbuf = result + *result_len;
! 1121:
! 1122: /* If evaluating or using custom function, copy result to the buffer
! 1123: * and clean up. */
! 1124: if (eval || is_callable_replace) {
! 1125: memcpy(walkbuf, eval_result, eval_result_len);
! 1126: *result_len += eval_result_len;
! 1127: STR_FREE(eval_result);
! 1128: } else { /* do regular backreference copying */
! 1129: walk = replace;
! 1130: walk_last = 0;
! 1131: while (walk < replace_end) {
! 1132: if ('\\' == *walk || '$' == *walk) {
! 1133: if (walk_last == '\\') {
! 1134: *(walkbuf-1) = *walk++;
! 1135: walk_last = 0;
! 1136: continue;
! 1137: }
! 1138: if (preg_get_backref(&walk, &backref)) {
! 1139: if (backref < count) {
! 1140: match_len = offsets[(backref<<1)+1] - offsets[backref<<1];
! 1141: memcpy(walkbuf, subject + offsets[backref<<1], match_len);
! 1142: walkbuf += match_len;
! 1143: }
! 1144: continue;
! 1145: }
! 1146: }
! 1147: *walkbuf++ = *walk++;
! 1148: walk_last = walk[-1];
! 1149: }
! 1150: *walkbuf = '\0';
! 1151: /* increment the result length by how much we've added to the string */
! 1152: *result_len += walkbuf - (result + *result_len);
! 1153: }
! 1154:
! 1155: if (limit != -1)
! 1156: limit--;
! 1157:
! 1158: } else if (count == PCRE_ERROR_NOMATCH || limit == 0) {
! 1159: /* If we previously set PCRE_NOTEMPTY after a null match,
! 1160: this is not necessarily the end. We need to advance
! 1161: the start offset, and continue. Fudge the offset values
! 1162: to achieve this, unless we're already at the end of the string. */
! 1163: if (g_notempty != 0 && start_offset < subject_len) {
! 1164: offsets[0] = start_offset;
! 1165: offsets[1] = start_offset + 1;
! 1166: memcpy(&result[*result_len], piece, 1);
! 1167: (*result_len)++;
! 1168: } else {
! 1169: new_len = *result_len + subject_len - start_offset;
! 1170: if (new_len + 1 > alloc_len) {
! 1171: alloc_len = new_len + 1; /* now we know exactly how long it is */
! 1172: new_buf = safe_emalloc(alloc_len, sizeof(char), 0);
! 1173: memcpy(new_buf, result, *result_len);
! 1174: efree(result);
! 1175: result = new_buf;
! 1176: }
! 1177: /* stick that last bit of string on our output */
! 1178: memcpy(&result[*result_len], piece, subject_len - start_offset);
! 1179: *result_len += subject_len - start_offset;
! 1180: result[*result_len] = '\0';
! 1181: break;
! 1182: }
! 1183: } else {
! 1184: pcre_handle_exec_error(count TSRMLS_CC);
! 1185: efree(result);
! 1186: result = NULL;
! 1187: break;
! 1188: }
! 1189:
! 1190: /* If we have matched an empty string, mimic what Perl's /g options does.
! 1191: This turns out to be rather cunning. First we set PCRE_NOTEMPTY and try
! 1192: the match again at the same point. If this fails (picked up above) we
! 1193: advance to the next character. */
! 1194: g_notempty = (offsets[1] == offsets[0])? PCRE_NOTEMPTY | PCRE_ANCHORED : 0;
! 1195:
! 1196: /* Advance to the next piece. */
! 1197: start_offset = offsets[1];
! 1198: }
! 1199:
! 1200: efree(offsets);
! 1201: efree(subpat_names);
! 1202:
! 1203: return result;
! 1204: }
! 1205: /* }}} */
! 1206:
! 1207: /* {{{ php_replace_in_subject
! 1208: */
! 1209: 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)
! 1210: {
! 1211: zval **regex_entry,
! 1212: **replace_entry = NULL,
! 1213: *replace_value,
! 1214: empty_replace;
! 1215: char *subject_value,
! 1216: *result;
! 1217: int subject_len;
! 1218:
! 1219: /* Make sure we're dealing with strings. */
! 1220: convert_to_string_ex(subject);
! 1221: /* FIXME: This might need to be changed to STR_EMPTY_ALLOC(). Check if this zval could be dtor()'ed somehow */
! 1222: ZVAL_STRINGL(&empty_replace, "", 0, 0);
! 1223:
! 1224: /* If regex is an array */
! 1225: if (Z_TYPE_P(regex) == IS_ARRAY) {
! 1226: /* Duplicate subject string for repeated replacement */
! 1227: subject_value = estrndup(Z_STRVAL_PP(subject), Z_STRLEN_PP(subject));
! 1228: subject_len = Z_STRLEN_PP(subject);
! 1229: *result_len = subject_len;
! 1230:
! 1231: zend_hash_internal_pointer_reset(Z_ARRVAL_P(regex));
! 1232:
! 1233: replace_value = replace;
! 1234: if (Z_TYPE_P(replace) == IS_ARRAY && !is_callable_replace)
! 1235: zend_hash_internal_pointer_reset(Z_ARRVAL_P(replace));
! 1236:
! 1237: /* For each entry in the regex array, get the entry */
! 1238: while (zend_hash_get_current_data(Z_ARRVAL_P(regex), (void **)®ex_entry) == SUCCESS) {
! 1239: /* Make sure we're dealing with strings. */
! 1240: convert_to_string_ex(regex_entry);
! 1241:
! 1242: /* If replace is an array and not a callable construct */
! 1243: if (Z_TYPE_P(replace) == IS_ARRAY && !is_callable_replace) {
! 1244: /* Get current entry */
! 1245: if (zend_hash_get_current_data(Z_ARRVAL_P(replace), (void **)&replace_entry) == SUCCESS) {
! 1246: if (!is_callable_replace) {
! 1247: convert_to_string_ex(replace_entry);
! 1248: }
! 1249: replace_value = *replace_entry;
! 1250: zend_hash_move_forward(Z_ARRVAL_P(replace));
! 1251: } else {
! 1252: /* We've run out of replacement strings, so use an empty one */
! 1253: replace_value = &empty_replace;
! 1254: }
! 1255: }
! 1256:
! 1257: /* Do the actual replacement and put the result back into subject_value
! 1258: for further replacements. */
! 1259: if ((result = php_pcre_replace(Z_STRVAL_PP(regex_entry),
! 1260: Z_STRLEN_PP(regex_entry),
! 1261: subject_value,
! 1262: subject_len,
! 1263: replace_value,
! 1264: is_callable_replace,
! 1265: result_len,
! 1266: limit,
! 1267: replace_count TSRMLS_CC)) != NULL) {
! 1268: efree(subject_value);
! 1269: subject_value = result;
! 1270: subject_len = *result_len;
! 1271: } else {
! 1272: efree(subject_value);
! 1273: return NULL;
! 1274: }
! 1275:
! 1276: zend_hash_move_forward(Z_ARRVAL_P(regex));
! 1277: }
! 1278:
! 1279: return subject_value;
! 1280: } else {
! 1281: result = php_pcre_replace(Z_STRVAL_P(regex),
! 1282: Z_STRLEN_P(regex),
! 1283: Z_STRVAL_PP(subject),
! 1284: Z_STRLEN_PP(subject),
! 1285: replace,
! 1286: is_callable_replace,
! 1287: result_len,
! 1288: limit,
! 1289: replace_count TSRMLS_CC);
! 1290: return result;
! 1291: }
! 1292: }
! 1293: /* }}} */
! 1294:
! 1295: /* {{{ preg_replace_impl
! 1296: */
! 1297: static void preg_replace_impl(INTERNAL_FUNCTION_PARAMETERS, int is_callable_replace, int is_filter)
! 1298: {
! 1299: zval **regex,
! 1300: **replace,
! 1301: **subject,
! 1302: **subject_entry,
! 1303: **zcount = NULL;
! 1304: char *result;
! 1305: int result_len;
! 1306: int limit_val = -1;
! 1307: long limit = -1;
! 1308: char *string_key;
! 1309: ulong num_key;
! 1310: char *callback_name;
! 1311: int replace_count=0, old_replace_count;
! 1312:
! 1313: /* Get function parameters and do error-checking. */
! 1314: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ZZZ|lZ", ®ex, &replace, &subject, &limit, &zcount) == FAILURE) {
! 1315: return;
! 1316: }
! 1317:
! 1318: if (!is_callable_replace && Z_TYPE_PP(replace) == IS_ARRAY && Z_TYPE_PP(regex) != IS_ARRAY) {
! 1319: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Parameter mismatch, pattern is a string while replacement is an array");
! 1320: RETURN_FALSE;
! 1321: }
! 1322:
! 1323: SEPARATE_ZVAL(replace);
! 1324: if (Z_TYPE_PP(replace) != IS_ARRAY && (Z_TYPE_PP(replace) != IS_OBJECT || !is_callable_replace)) {
! 1325: convert_to_string_ex(replace);
! 1326: }
! 1327: if (is_callable_replace) {
! 1328: if (!zend_is_callable(*replace, 0, &callback_name TSRMLS_CC)) {
! 1329: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Requires argument 2, '%s', to be a valid callback", callback_name);
! 1330: efree(callback_name);
! 1331: MAKE_COPY_ZVAL(subject, return_value);
! 1332: return;
! 1333: }
! 1334: efree(callback_name);
! 1335: }
! 1336:
! 1337: SEPARATE_ZVAL(regex);
! 1338: SEPARATE_ZVAL(subject);
! 1339:
! 1340: if (ZEND_NUM_ARGS() > 3) {
! 1341: limit_val = limit;
! 1342: }
! 1343:
! 1344: if (Z_TYPE_PP(regex) != IS_ARRAY)
! 1345: convert_to_string_ex(regex);
! 1346:
! 1347: /* if subject is an array */
! 1348: if (Z_TYPE_PP(subject) == IS_ARRAY) {
! 1349: array_init(return_value);
! 1350: zend_hash_internal_pointer_reset(Z_ARRVAL_PP(subject));
! 1351:
! 1352: /* For each subject entry, convert it to string, then perform replacement
! 1353: and add the result to the return_value array. */
! 1354: while (zend_hash_get_current_data(Z_ARRVAL_PP(subject), (void **)&subject_entry) == SUCCESS) {
! 1355: SEPARATE_ZVAL(subject_entry);
! 1356: old_replace_count = replace_count;
! 1357: if ((result = php_replace_in_subject(*regex, *replace, subject_entry, &result_len, limit_val, is_callable_replace, &replace_count TSRMLS_CC)) != NULL) {
! 1358: if (!is_filter || replace_count > old_replace_count) {
! 1359: /* Add to return array */
! 1360: switch(zend_hash_get_current_key(Z_ARRVAL_PP(subject), &string_key, &num_key, 0))
! 1361: {
! 1362: case HASH_KEY_IS_STRING:
! 1363: add_assoc_stringl(return_value, string_key, result, result_len, 0);
! 1364: break;
! 1365:
! 1366: case HASH_KEY_IS_LONG:
! 1367: add_index_stringl(return_value, num_key, result, result_len, 0);
! 1368: break;
! 1369: }
! 1370: } else {
! 1371: efree(result);
! 1372: }
! 1373: }
! 1374:
! 1375: zend_hash_move_forward(Z_ARRVAL_PP(subject));
! 1376: }
! 1377: } else { /* if subject is not an array */
! 1378: old_replace_count = replace_count;
! 1379: if ((result = php_replace_in_subject(*regex, *replace, subject, &result_len, limit_val, is_callable_replace, &replace_count TSRMLS_CC)) != NULL) {
! 1380: if (!is_filter || replace_count > old_replace_count) {
! 1381: RETVAL_STRINGL(result, result_len, 0);
! 1382: } else {
! 1383: efree(result);
! 1384: }
! 1385: }
! 1386: }
! 1387: if (ZEND_NUM_ARGS() > 4) {
! 1388: zval_dtor(*zcount);
! 1389: ZVAL_LONG(*zcount, replace_count);
! 1390: }
! 1391:
! 1392: }
! 1393: /* }}} */
! 1394:
! 1395: /* {{{ proto mixed preg_replace(mixed regex, mixed replace, mixed subject [, int limit [, int &count]])
! 1396: Perform Perl-style regular expression replacement. */
! 1397: static PHP_FUNCTION(preg_replace)
! 1398: {
! 1399: preg_replace_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0, 0);
! 1400: }
! 1401: /* }}} */
! 1402:
! 1403: /* {{{ proto mixed preg_replace_callback(mixed regex, mixed callback, mixed subject [, int limit [, int &count]])
! 1404: Perform Perl-style regular expression replacement using replacement callback. */
! 1405: static PHP_FUNCTION(preg_replace_callback)
! 1406: {
! 1407: preg_replace_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1, 0);
! 1408: }
! 1409: /* }}} */
! 1410:
! 1411: /* {{{ proto mixed preg_filter(mixed regex, mixed replace, mixed subject [, int limit [, int &count]])
! 1412: Perform Perl-style regular expression replacement and only return matches. */
! 1413: static PHP_FUNCTION(preg_filter)
! 1414: {
! 1415: preg_replace_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0, 1);
! 1416: }
! 1417: /* }}} */
! 1418:
! 1419: /* {{{ proto array preg_split(string pattern, string subject [, int limit [, int flags]])
! 1420: Split string into an array using a perl-style regular expression as a delimiter */
! 1421: static PHP_FUNCTION(preg_split)
! 1422: {
! 1423: char *regex; /* Regular expression */
! 1424: char *subject; /* String to match against */
! 1425: int regex_len;
! 1426: int subject_len;
! 1427: long limit_val = -1;/* Integer value of limit */
! 1428: long flags = 0; /* Match control flags */
! 1429: pcre_cache_entry *pce; /* Compiled regular expression */
! 1430:
! 1431: /* Get function parameters and do error checking */
! 1432: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|ll", ®ex, ®ex_len,
! 1433: &subject, &subject_len, &limit_val, &flags) == FAILURE) {
! 1434: RETURN_FALSE;
! 1435: }
! 1436:
! 1437: /* Compile regex or get it from cache. */
! 1438: if ((pce = pcre_get_compiled_regex_cache(regex, regex_len TSRMLS_CC)) == NULL) {
! 1439: RETURN_FALSE;
! 1440: }
! 1441:
! 1442: php_pcre_split_impl(pce, subject, subject_len, return_value, limit_val, flags TSRMLS_CC);
! 1443: }
! 1444: /* }}} */
! 1445:
! 1446: /* {{{ php_pcre_split
! 1447: */
! 1448: PHPAPI void php_pcre_split_impl(pcre_cache_entry *pce, char *subject, int subject_len, zval *return_value,
! 1449: long limit_val, long flags TSRMLS_DC)
! 1450: {
! 1451: pcre_extra *extra = NULL; /* Holds results of studying */
! 1452: pcre *re_bump = NULL; /* Regex instance for empty matches */
! 1453: pcre_extra *extra_bump = NULL; /* Almost dummy */
! 1454: pcre_extra extra_data; /* Used locally for exec options */
! 1455: int *offsets; /* Array of subpattern offsets */
! 1456: int size_offsets; /* Size of the offsets array */
! 1457: int exoptions = 0; /* Execution options */
! 1458: int count = 0; /* Count of matched subpatterns */
! 1459: int start_offset; /* Where the new search starts */
! 1460: int next_offset; /* End of the last delimiter match + 1 */
! 1461: int g_notempty = 0; /* If the match should not be empty */
! 1462: char *last_match; /* Location of last match */
! 1463: int rc;
! 1464: int no_empty; /* If NO_EMPTY flag is set */
! 1465: int delim_capture; /* If delimiters should be captured */
! 1466: int offset_capture; /* If offsets should be captured */
! 1467:
! 1468: no_empty = flags & PREG_SPLIT_NO_EMPTY;
! 1469: delim_capture = flags & PREG_SPLIT_DELIM_CAPTURE;
! 1470: offset_capture = flags & PREG_SPLIT_OFFSET_CAPTURE;
! 1471:
! 1472: if (limit_val == 0) {
! 1473: limit_val = -1;
! 1474: }
! 1475:
! 1476: if (extra == NULL) {
! 1477: extra_data.flags = PCRE_EXTRA_MATCH_LIMIT | PCRE_EXTRA_MATCH_LIMIT_RECURSION;
! 1478: extra = &extra_data;
! 1479: }
! 1480: extra->match_limit = PCRE_G(backtrack_limit);
! 1481: extra->match_limit_recursion = PCRE_G(recursion_limit);
! 1482:
! 1483: /* Initialize return value */
! 1484: array_init(return_value);
! 1485:
! 1486: /* Calculate the size of the offsets array, and allocate memory for it. */
! 1487: rc = pcre_fullinfo(pce->re, extra, PCRE_INFO_CAPTURECOUNT, &size_offsets);
! 1488: if (rc < 0) {
! 1489: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Internal pcre_fullinfo() error %d", rc);
! 1490: RETURN_FALSE;
! 1491: }
! 1492: size_offsets = (size_offsets + 1) * 3;
! 1493: offsets = (int *)safe_emalloc(size_offsets, sizeof(int), 0);
! 1494:
! 1495: /* Start at the beginning of the string */
! 1496: start_offset = 0;
! 1497: next_offset = 0;
! 1498: last_match = subject;
! 1499: PCRE_G(error_code) = PHP_PCRE_NO_ERROR;
! 1500:
! 1501: /* Get next piece if no limit or limit not yet reached and something matched*/
! 1502: while ((limit_val == -1 || limit_val > 1)) {
! 1503: count = pcre_exec(pce->re, extra, subject,
! 1504: subject_len, start_offset,
! 1505: exoptions|g_notempty, offsets, size_offsets);
! 1506:
! 1507: /* the string was already proved to be valid UTF-8 */
! 1508: exoptions |= PCRE_NO_UTF8_CHECK;
! 1509:
! 1510: /* Check for too many substrings condition. */
! 1511: if (count == 0) {
! 1512: php_error_docref(NULL TSRMLS_CC,E_NOTICE, "Matched, but too many substrings");
! 1513: count = size_offsets/3;
! 1514: }
! 1515:
! 1516: /* If something matched */
! 1517: if (count > 0) {
! 1518: if (!no_empty || &subject[offsets[0]] != last_match) {
! 1519:
! 1520: if (offset_capture) {
! 1521: /* Add (match, offset) pair to the return value */
! 1522: add_offset_pair(return_value, last_match, &subject[offsets[0]]-last_match, next_offset, NULL);
! 1523: } else {
! 1524: /* Add the piece to the return value */
! 1525: add_next_index_stringl(return_value, last_match,
! 1526: &subject[offsets[0]]-last_match, 1);
! 1527: }
! 1528:
! 1529: /* One less left to do */
! 1530: if (limit_val != -1)
! 1531: limit_val--;
! 1532: }
! 1533:
! 1534: last_match = &subject[offsets[1]];
! 1535: next_offset = offsets[1];
! 1536:
! 1537: if (delim_capture) {
! 1538: int i, match_len;
! 1539: for (i = 1; i < count; i++) {
! 1540: match_len = offsets[(i<<1)+1] - offsets[i<<1];
! 1541: /* If we have matched a delimiter */
! 1542: if (!no_empty || match_len > 0) {
! 1543: if (offset_capture) {
! 1544: add_offset_pair(return_value, &subject[offsets[i<<1]], match_len, offsets[i<<1], NULL);
! 1545: } else {
! 1546: add_next_index_stringl(return_value,
! 1547: &subject[offsets[i<<1]],
! 1548: match_len, 1);
! 1549: }
! 1550: }
! 1551: }
! 1552: }
! 1553: } else if (count == PCRE_ERROR_NOMATCH) {
! 1554: /* If we previously set PCRE_NOTEMPTY after a null match,
! 1555: this is not necessarily the end. We need to advance
! 1556: the start offset, and continue. Fudge the offset values
! 1557: to achieve this, unless we're already at the end of the string. */
! 1558: if (g_notempty != 0 && start_offset < subject_len) {
! 1559: if (pce->compile_options & PCRE_UTF8) {
! 1560: if (re_bump == NULL) {
! 1561: int dummy;
! 1562:
! 1563: if ((re_bump = pcre_get_compiled_regex("/./us", &extra_bump, &dummy TSRMLS_CC)) == NULL) {
! 1564: RETURN_FALSE;
! 1565: }
! 1566: }
! 1567: count = pcre_exec(re_bump, extra_bump, subject,
! 1568: subject_len, start_offset,
! 1569: exoptions, offsets, size_offsets);
! 1570: if (count < 1) {
! 1571: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown error");
! 1572: RETURN_FALSE;
! 1573: }
! 1574: } else {
! 1575: offsets[0] = start_offset;
! 1576: offsets[1] = start_offset + 1;
! 1577: }
! 1578: } else
! 1579: break;
! 1580: } else {
! 1581: pcre_handle_exec_error(count TSRMLS_CC);
! 1582: break;
! 1583: }
! 1584:
! 1585: /* If we have matched an empty string, mimic what Perl's /g options does.
! 1586: This turns out to be rather cunning. First we set PCRE_NOTEMPTY and try
! 1587: the match again at the same point. If this fails (picked up above) we
! 1588: advance to the next character. */
! 1589: g_notempty = (offsets[1] == offsets[0])? PCRE_NOTEMPTY | PCRE_ANCHORED : 0;
! 1590:
! 1591: /* Advance to the position right after the last full match */
! 1592: start_offset = offsets[1];
! 1593: }
! 1594:
! 1595:
! 1596: start_offset = last_match - subject; /* the offset might have been incremented, but without further successful matches */
! 1597:
! 1598: if (!no_empty || start_offset < subject_len)
! 1599: {
! 1600: if (offset_capture) {
! 1601: /* Add the last (match, offset) pair to the return value */
! 1602: add_offset_pair(return_value, &subject[start_offset], subject_len - start_offset, start_offset, NULL);
! 1603: } else {
! 1604: /* Add the last piece to the return value */
! 1605: add_next_index_stringl(return_value, last_match, subject + subject_len - last_match, 1);
! 1606: }
! 1607: }
! 1608:
! 1609:
! 1610: /* Clean up */
! 1611: efree(offsets);
! 1612: }
! 1613: /* }}} */
! 1614:
! 1615: /* {{{ proto string preg_quote(string str [, string delim_char])
! 1616: Quote regular expression characters plus an optional character */
! 1617: static PHP_FUNCTION(preg_quote)
! 1618: {
! 1619: int in_str_len;
! 1620: char *in_str; /* Input string argument */
! 1621: char *in_str_end; /* End of the input string */
! 1622: int delim_len = 0;
! 1623: char *delim = NULL; /* Additional delimiter argument */
! 1624: char *out_str, /* Output string with quoted characters */
! 1625: *p, /* Iterator for input string */
! 1626: *q, /* Iterator for output string */
! 1627: delim_char=0, /* Delimiter character to be quoted */
! 1628: c; /* Current character */
! 1629: zend_bool quote_delim = 0; /* Whether to quote additional delim char */
! 1630:
! 1631: /* Get the arguments and check for errors */
! 1632: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|s", &in_str, &in_str_len,
! 1633: &delim, &delim_len) == FAILURE) {
! 1634: return;
! 1635: }
! 1636:
! 1637: in_str_end = in_str + in_str_len;
! 1638:
! 1639: /* Nothing to do if we got an empty string */
! 1640: if (in_str == in_str_end) {
! 1641: RETURN_EMPTY_STRING();
! 1642: }
! 1643:
! 1644: if (delim && *delim) {
! 1645: delim_char = delim[0];
! 1646: quote_delim = 1;
! 1647: }
! 1648:
! 1649: /* Allocate enough memory so that even if each character
! 1650: is quoted, we won't run out of room */
! 1651: out_str = safe_emalloc(4, in_str_len, 1);
! 1652:
! 1653: /* Go through the string and quote necessary characters */
! 1654: for(p = in_str, q = out_str; p != in_str_end; p++) {
! 1655: c = *p;
! 1656: switch(c) {
! 1657: case '.':
! 1658: case '\\':
! 1659: case '+':
! 1660: case '*':
! 1661: case '?':
! 1662: case '[':
! 1663: case '^':
! 1664: case ']':
! 1665: case '$':
! 1666: case '(':
! 1667: case ')':
! 1668: case '{':
! 1669: case '}':
! 1670: case '=':
! 1671: case '!':
! 1672: case '>':
! 1673: case '<':
! 1674: case '|':
! 1675: case ':':
! 1676: case '-':
! 1677: *q++ = '\\';
! 1678: *q++ = c;
! 1679: break;
! 1680:
! 1681: case '\0':
! 1682: *q++ = '\\';
! 1683: *q++ = '0';
! 1684: *q++ = '0';
! 1685: *q++ = '0';
! 1686: break;
! 1687:
! 1688: default:
! 1689: if (quote_delim && c == delim_char)
! 1690: *q++ = '\\';
! 1691: *q++ = c;
! 1692: break;
! 1693: }
! 1694: }
! 1695: *q = '\0';
! 1696:
! 1697: /* Reallocate string and return it */
! 1698: RETVAL_STRINGL(erealloc(out_str, q - out_str + 1), q - out_str, 0);
! 1699: }
! 1700: /* }}} */
! 1701:
! 1702: /* {{{ proto array preg_grep(string regex, array input [, int flags])
! 1703: Searches array and returns entries which match regex */
! 1704: static PHP_FUNCTION(preg_grep)
! 1705: {
! 1706: char *regex; /* Regular expression */
! 1707: int regex_len;
! 1708: zval *input; /* Input array */
! 1709: long flags = 0; /* Match control flags */
! 1710: pcre_cache_entry *pce; /* Compiled regular expression */
! 1711:
! 1712: /* Get arguments and do error checking */
! 1713: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sa|l", ®ex, ®ex_len,
! 1714: &input, &flags) == FAILURE) {
! 1715: return;
! 1716: }
! 1717:
! 1718: /* Compile regex or get it from cache. */
! 1719: if ((pce = pcre_get_compiled_regex_cache(regex, regex_len TSRMLS_CC)) == NULL) {
! 1720: RETURN_FALSE;
! 1721: }
! 1722:
! 1723: php_pcre_grep_impl(pce, input, return_value, flags TSRMLS_CC);
! 1724: }
! 1725: /* }}} */
! 1726:
! 1727: PHPAPI void php_pcre_grep_impl(pcre_cache_entry *pce, zval *input, zval *return_value, long flags TSRMLS_DC) /* {{{ */
! 1728: {
! 1729: zval **entry; /* An entry in the input array */
! 1730: pcre_extra *extra = pce->extra;/* Holds results of studying */
! 1731: pcre_extra extra_data; /* Used locally for exec options */
! 1732: int *offsets; /* Array of subpattern offsets */
! 1733: int size_offsets; /* Size of the offsets array */
! 1734: int count = 0; /* Count of matched subpatterns */
! 1735: char *string_key;
! 1736: ulong num_key;
! 1737: zend_bool invert; /* Whether to return non-matching
! 1738: entries */
! 1739: int rc;
! 1740:
! 1741: invert = flags & PREG_GREP_INVERT ? 1 : 0;
! 1742:
! 1743: if (extra == NULL) {
! 1744: extra_data.flags = PCRE_EXTRA_MATCH_LIMIT | PCRE_EXTRA_MATCH_LIMIT_RECURSION;
! 1745: extra = &extra_data;
! 1746: }
! 1747: extra->match_limit = PCRE_G(backtrack_limit);
! 1748: extra->match_limit_recursion = PCRE_G(recursion_limit);
! 1749:
! 1750: /* Calculate the size of the offsets array, and allocate memory for it. */
! 1751: rc = pcre_fullinfo(pce->re, extra, PCRE_INFO_CAPTURECOUNT, &size_offsets);
! 1752: if (rc < 0) {
! 1753: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Internal pcre_fullinfo() error %d", rc);
! 1754: RETURN_FALSE;
! 1755: }
! 1756: size_offsets = (size_offsets + 1) * 3;
! 1757: offsets = (int *)safe_emalloc(size_offsets, sizeof(int), 0);
! 1758:
! 1759: /* Initialize return array */
! 1760: array_init(return_value);
! 1761:
! 1762: PCRE_G(error_code) = PHP_PCRE_NO_ERROR;
! 1763:
! 1764: /* Go through the input array */
! 1765: zend_hash_internal_pointer_reset(Z_ARRVAL_P(input));
! 1766: while (zend_hash_get_current_data(Z_ARRVAL_P(input), (void **)&entry) == SUCCESS) {
! 1767: zval subject = **entry;
! 1768:
! 1769: if (Z_TYPE_PP(entry) != IS_STRING) {
! 1770: zval_copy_ctor(&subject);
! 1771: convert_to_string(&subject);
! 1772: }
! 1773:
! 1774: /* Perform the match */
! 1775: count = pcre_exec(pce->re, extra, Z_STRVAL(subject),
! 1776: Z_STRLEN(subject), 0,
! 1777: 0, offsets, size_offsets);
! 1778:
! 1779: /* Check for too many substrings condition. */
! 1780: if (count == 0) {
! 1781: php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Matched, but too many substrings");
! 1782: count = size_offsets/3;
! 1783: } else if (count < 0 && count != PCRE_ERROR_NOMATCH) {
! 1784: pcre_handle_exec_error(count TSRMLS_CC);
! 1785: break;
! 1786: }
! 1787:
! 1788: /* If the entry fits our requirements */
! 1789: if ((count > 0 && !invert) || (count == PCRE_ERROR_NOMATCH && invert)) {
! 1790:
! 1791: Z_ADDREF_PP(entry);
! 1792:
! 1793: /* Add to return array */
! 1794: switch (zend_hash_get_current_key(Z_ARRVAL_P(input), &string_key, &num_key, 0))
! 1795: {
! 1796: case HASH_KEY_IS_STRING:
! 1797: zend_hash_update(Z_ARRVAL_P(return_value), string_key,
! 1798: strlen(string_key)+1, entry, sizeof(zval *), NULL);
! 1799: break;
! 1800:
! 1801: case HASH_KEY_IS_LONG:
! 1802: zend_hash_index_update(Z_ARRVAL_P(return_value), num_key, entry,
! 1803: sizeof(zval *), NULL);
! 1804: break;
! 1805: }
! 1806: }
! 1807:
! 1808: if (Z_TYPE_PP(entry) != IS_STRING) {
! 1809: zval_dtor(&subject);
! 1810: }
! 1811:
! 1812: zend_hash_move_forward(Z_ARRVAL_P(input));
! 1813: }
! 1814: zend_hash_internal_pointer_reset(Z_ARRVAL_P(input));
! 1815: /* Clean up */
! 1816: efree(offsets);
! 1817: }
! 1818: /* }}} */
! 1819:
! 1820: /* {{{ proto int preg_last_error()
! 1821: Returns the error code of the last regexp execution. */
! 1822: static PHP_FUNCTION(preg_last_error)
! 1823: {
! 1824: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "") == FAILURE) {
! 1825: return;
! 1826: }
! 1827:
! 1828: RETURN_LONG(PCRE_G(error_code));
! 1829: }
! 1830: /* }}} */
! 1831:
! 1832: /* {{{ module definition structures */
! 1833:
! 1834: /* {{{ arginfo */
! 1835: ZEND_BEGIN_ARG_INFO_EX(arginfo_preg_match, 0, 0, 2)
! 1836: ZEND_ARG_INFO(0, pattern)
! 1837: ZEND_ARG_INFO(0, subject)
! 1838: ZEND_ARG_INFO(1, subpatterns) /* array */
! 1839: ZEND_ARG_INFO(0, flags)
! 1840: ZEND_ARG_INFO(0, offset)
! 1841: ZEND_END_ARG_INFO()
! 1842:
! 1843: ZEND_BEGIN_ARG_INFO_EX(arginfo_preg_match_all, 0, 0, 3)
! 1844: ZEND_ARG_INFO(0, pattern)
! 1845: ZEND_ARG_INFO(0, subject)
! 1846: ZEND_ARG_INFO(1, subpatterns) /* array */
! 1847: ZEND_ARG_INFO(0, flags)
! 1848: ZEND_ARG_INFO(0, offset)
! 1849: ZEND_END_ARG_INFO()
! 1850:
! 1851: ZEND_BEGIN_ARG_INFO_EX(arginfo_preg_replace, 0, 0, 3)
! 1852: ZEND_ARG_INFO(0, regex)
! 1853: ZEND_ARG_INFO(0, replace)
! 1854: ZEND_ARG_INFO(0, subject)
! 1855: ZEND_ARG_INFO(0, limit)
! 1856: ZEND_ARG_INFO(1, count)
! 1857: ZEND_END_ARG_INFO()
! 1858:
! 1859: ZEND_BEGIN_ARG_INFO_EX(arginfo_preg_replace_callback, 0, 0, 3)
! 1860: ZEND_ARG_INFO(0, regex)
! 1861: ZEND_ARG_INFO(0, callback)
! 1862: ZEND_ARG_INFO(0, subject)
! 1863: ZEND_ARG_INFO(0, limit)
! 1864: ZEND_ARG_INFO(1, count)
! 1865: ZEND_END_ARG_INFO()
! 1866:
! 1867: ZEND_BEGIN_ARG_INFO_EX(arginfo_preg_split, 0, 0, 2)
! 1868: ZEND_ARG_INFO(0, pattern)
! 1869: ZEND_ARG_INFO(0, subject)
! 1870: ZEND_ARG_INFO(0, limit)
! 1871: ZEND_ARG_INFO(0, flags)
! 1872: ZEND_END_ARG_INFO()
! 1873:
! 1874: ZEND_BEGIN_ARG_INFO_EX(arginfo_preg_quote, 0, 0, 1)
! 1875: ZEND_ARG_INFO(0, str)
! 1876: ZEND_ARG_INFO(0, delim_char)
! 1877: ZEND_END_ARG_INFO()
! 1878:
! 1879: ZEND_BEGIN_ARG_INFO_EX(arginfo_preg_grep, 0, 0, 2)
! 1880: ZEND_ARG_INFO(0, regex)
! 1881: ZEND_ARG_INFO(0, input) /* array */
! 1882: ZEND_ARG_INFO(0, flags)
! 1883: ZEND_END_ARG_INFO()
! 1884:
! 1885: ZEND_BEGIN_ARG_INFO(arginfo_preg_last_error, 0)
! 1886: ZEND_END_ARG_INFO()
! 1887: /* }}} */
! 1888:
! 1889: static const zend_function_entry pcre_functions[] = {
! 1890: PHP_FE(preg_match, arginfo_preg_match)
! 1891: PHP_FE(preg_match_all, arginfo_preg_match_all)
! 1892: PHP_FE(preg_replace, arginfo_preg_replace)
! 1893: PHP_FE(preg_replace_callback, arginfo_preg_replace_callback)
! 1894: PHP_FE(preg_filter, arginfo_preg_replace)
! 1895: PHP_FE(preg_split, arginfo_preg_split)
! 1896: PHP_FE(preg_quote, arginfo_preg_quote)
! 1897: PHP_FE(preg_grep, arginfo_preg_grep)
! 1898: PHP_FE(preg_last_error, arginfo_preg_last_error)
! 1899: PHP_FE_END
! 1900: };
! 1901:
! 1902: zend_module_entry pcre_module_entry = {
! 1903: STANDARD_MODULE_HEADER,
! 1904: "pcre",
! 1905: pcre_functions,
! 1906: PHP_MINIT(pcre),
! 1907: PHP_MSHUTDOWN(pcre),
! 1908: NULL,
! 1909: NULL,
! 1910: PHP_MINFO(pcre),
! 1911: NO_VERSION_YET,
! 1912: PHP_MODULE_GLOBALS(pcre),
! 1913: PHP_GINIT(pcre),
! 1914: PHP_GSHUTDOWN(pcre),
! 1915: NULL,
! 1916: STANDARD_MODULE_PROPERTIES_EX
! 1917: };
! 1918:
! 1919: #ifdef COMPILE_DL_PCRE
! 1920: ZEND_GET_MODULE(pcre)
! 1921: #endif
! 1922:
! 1923: /* }}} */
! 1924:
! 1925: #endif /* HAVE_PCRE || HAVE_BUNDLED_PCRE */
! 1926:
! 1927: /*
! 1928: * Local variables:
! 1929: * tab-width: 4
! 1930: * c-basic-offset: 4
! 1931: * End:
! 1932: * vim600: sw=4 ts=4 fdm=marker
! 1933: * vim<600: sw=4 ts=4
! 1934: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to php_pcre.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / pcre