Imported from /home/lorry/working-area/delta_php2/php-5.4.13.tar.bz2.HEADphp-5.4.13master

1 files changed, 1960 insertions, 0 deletions

diff --git a/ext/pcre/php_pcre.c b/ext/pcre/php_pcre.c
new file mode 100644
index 0000000..b74b812
--- /dev/null
+++ b/ext/pcre/php_pcre.c
@@ -0,0 +1,1960 @@
+/*
+   +----------------------------------------------------------------------+
+   | PHP Version 5                                                        |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1997-2013 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$ */
+
+#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", "1000000", 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;
+	int				count = 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;
+	char                *tmp = NULL;
+
+	/* 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_fullinfo() check to see whether cache is corrupted, and if it
+		 * is, we flush it and compile the pattern from scratch.
+		 */
+		if (pcre_fullinfo(pce->re, NULL, PCRE_INFO_CAPTURECOUNT, &count) == 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, 
+						 p < regex + regex_len ? "Null byte in regex" : "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;
+
+	pp = p;
+
+	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. */
+		while (*pp != 0) {
+			if (*pp == '\\' && pp[1] != 0) pp++;
+			else if (*pp == delimiter)
+				break;
+			pp++;
+		}
+	} 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 */
+		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) {
+		if (pp < regex + regex_len) {
+			php_error_docref(NULL TSRMLS_CC,E_WARNING, "Null byte in regex");
+		} else if (start_delimiter == end_delimiter) {
+			php_error_docref(NULL TSRMLS_CC,E_WARNING, "No ending delimiter '%c' found", delimiter);
+		} else {
+			php_error_docref(NULL TSRMLS_CC,E_WARNING, "No ending matching delimiter '%c' found", 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 < regex + regex_len) {
+		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:
+				if (pp[-1]) {
+					php_error_docref(NULL TSRMLS_CC,E_WARNING, "Unknown modifier '%c'", pp[-1]);
+				} else {
+					php_error_docref(NULL TSRMLS_CC,E_WARNING, "Null byte in regex");
+				}
+				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
+
+	/*
+	 * Interned strings are not duplicated when stored in HashTable,
+	 * but all the interned strings created during HTTP request are removed
+	 * at end of request. However PCRE_G(pcre_cache) must be consistent
+	 * on the next request as well. So we disable usage of interned strings
+	 * as hash keys especually for this table.
+	 * See bug #63180 
+	 */
+	if (IS_INTERNED(regex)) {
+		regex = tmp = estrndup(regex, regex_len);
+	}
+
+	zend_hash_update(&PCRE_G(pcre_cache), regex, regex_len+1, (void *)&new_entry,
+						sizeof(pcre_cache_entry), (void**)&pce);
+
+	if (tmp) {
+		efree(tmp);
+	}
+
+	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, "ss|zll", &regex, &regex_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 && 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);
+					if (match_sets) efree(match_sets);
+					php_error_docref(NULL TSRMLS_CC, E_WARNING, "Get subpatterns list failed");
+					RETURN_FALSE;
+				}
+
+				if (global) {	/* global pattern matching */
+					if (subpats && 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 && 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(match, match_len, &esc_match_len, 0 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 **)&regex_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", &regex, &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", &regex, &regex_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 = pcre_exec(re_bump, extra_bump, subject,
+							  subject_len, start_offset,
+							  exoptions, offsets, size_offsets);
+					if (count < 1) {
+						php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown error");
+						RETURN_FALSE;
+					}
+				} else {
+					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];
+	}
+
+
+	start_offset = last_match - subject; /* the offset might have been incremented, but without further successful matches */
+
+	if (!no_empty || start_offset < subject_len)
+	{
+		if (offset_capture) {
+			/* Add the last (match, offset) pair to the return value */
+			add_offset_pair(return_value, &subject[start_offset], subject_len - start_offset, start_offset, NULL);
+		} else {
+			/* Add the last piece to the return value */
+			add_next_index_stringl(return_value, last_match, subject + subject_len - last_match, 1);
+		}
+	}
+
+	
+	/* Clean up */
+	efree(offsets);
+}
+/* }}} */
+
+/* {{{ proto string preg_quote(string str [, string delim_char])
+   Quote regular expression characters plus an optional character */
+static PHP_FUNCTION(preg_quote)
+{
+	int		 in_str_len;
+	char	*in_str;		/* Input string argument */
+	char	*in_str_end;    /* End of the input string */
+	int		 delim_len = 0;
+	char	*delim = NULL;	/* Additional delimiter argument */
+	char	*out_str,		/* Output string with quoted characters */
+		 	*p,				/* Iterator for input string */
+			*q,				/* Iterator for output string */
+			 delim_char=0,	/* Delimiter character to be quoted */
+			 c;				/* Current character */
+	zend_bool quote_delim = 0; /* Whether to quote additional delim char */
+	
+	/* Get the arguments and check for errors */
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|s", &in_str, &in_str_len,
+							  &delim, &delim_len) == FAILURE) {
+		return;
+	}
+	
+	in_str_end = in_str + in_str_len;
+
+	/* Nothing to do if we got an empty string */
+	if (in_str == in_str_end) {
+		RETURN_EMPTY_STRING();
+	}
+
+	if (delim && *delim) {
+		delim_char = delim[0];
+		quote_delim = 1;
+	}
+	
+	/* Allocate enough memory so that even if each character
+	   is quoted, we won't run out of room */
+	out_str = safe_emalloc(4, in_str_len, 1);
+	
+	/* Go through the string and quote necessary characters */
+	for(p = in_str, q = out_str; p != in_str_end; p++) {
+		c = *p;
+		switch(c) {
+			case '.':
+			case '\\':
+			case '+':
+			case '*':
+			case '?':
+			case '[':
+			case '^':
+			case ']':
+			case '$':
+			case '(':
+			case ')':
+			case '{':
+			case '}':
+			case '=':
+			case '!':
+			case '>':
+			case '<':
+			case '|':
+			case ':':
+			case '-':
+				*q++ = '\\';
+				*q++ = c;
+				break;
+
+			case '\0':
+				*q++ = '\\';
+				*q++ = '0';
+				*q++ = '0';
+				*q++ = '0';
+				break;
+
+			default:
+				if (quote_delim && c == delim_char)
+					*q++ = '\\';
+				*q++ = c;
+				break;
+		}
+	}
+	*q = '\0';
+	
+	/* Reallocate string and return it */
+	RETVAL_STRINGL(erealloc(out_str, q - out_str + 1), q - out_str, 0);
+}
+/* }}} */
+
+/* {{{ proto array preg_grep(string regex, array input [, int flags])
+   Searches array and returns entries which match regex */
+static PHP_FUNCTION(preg_grep)
+{
+	char				*regex;			/* Regular expression */
+	int				 	 regex_len;
+	zval				*input;			/* Input array */
+	long				 flags = 0;		/* Match control flags */
+	pcre_cache_entry	*pce;			/* Compiled regular expression */
+
+	/* Get arguments and do error checking */
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sa|l", &regex, &regex_len,
+							  &input, &flags) == FAILURE) {
+		return;
+	}
+	
+	/* Compile regex or get it from cache. */
+	if ((pce = pcre_get_compiled_regex_cache(regex, regex_len TSRMLS_CC)) == NULL) {
+		RETURN_FALSE;
+	}
+	
+	php_pcre_grep_impl(pce, input, return_value, flags TSRMLS_CC);
+}
+/* }}} */
+
+PHPAPI void  php_pcre_grep_impl(pcre_cache_entry *pce, zval *input, zval *return_value, long flags TSRMLS_DC) /* {{{ */
+{
+	zval		   **entry;				/* An entry in the input array */
+	pcre_extra		*extra = pce->extra;/* Holds results of studying */
+	pcre_extra		 extra_data;		/* Used locally for exec options */
+	int				*offsets;			/* Array of subpattern offsets */
+	int				 size_offsets;		/* Size of the offsets array */
+	int				 count = 0;			/* Count of matched subpatterns */
+	char			*string_key;
+	ulong			 num_key;
+	zend_bool		 invert;			/* Whether to return non-matching
+										   entries */
+	int				 rc;
+	
+	invert = flags & PREG_GREP_INVERT ? 1 : 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, &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);
+	
+	/* Initialize return array */
+	array_init(return_value);
+
+	PCRE_G(error_code) = PHP_PCRE_NO_ERROR;
+
+	/* Go through the input array */
+	zend_hash_internal_pointer_reset(Z_ARRVAL_P(input));
+	while (zend_hash_get_current_data(Z_ARRVAL_P(input), (void **)&entry) == SUCCESS) {
+		zval subject = **entry;
+
+		if (Z_TYPE_PP(entry) != IS_STRING) {
+			zval_copy_ctor(&subject);
+			convert_to_string(&subject);
+		}
+
+		/* Perform the match */
+		count = pcre_exec(pce->re, extra, Z_STRVAL(subject),
+						  Z_STRLEN(subject), 0,
+						  0, offsets, size_offsets);
+
+		/* 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;
+		} else if (count < 0 && count != PCRE_ERROR_NOMATCH) {
+			pcre_handle_exec_error(count TSRMLS_CC);
+			break;
+		}
+
+		/* If the entry fits our requirements */
+		if ((count > 0 && !invert) || (count == PCRE_ERROR_NOMATCH && invert)) {
+
+			Z_ADDREF_PP(entry);
+
+			/* Add to return array */
+			switch (zend_hash_get_current_key(Z_ARRVAL_P(input), &string_key, &num_key, 0))
+			{
+				case HASH_KEY_IS_STRING:
+					zend_hash_update(Z_ARRVAL_P(return_value), string_key,
+									 strlen(string_key)+1, entry, sizeof(zval *), NULL);
+					break;
+
+				case HASH_KEY_IS_LONG:
+					zend_hash_index_update(Z_ARRVAL_P(return_value), num_key, entry,
+										   sizeof(zval *), NULL);
+					break;
+			}
+		}
+
+		if (Z_TYPE_PP(entry) != IS_STRING) {
+			zval_dtor(&subject);
+		}
+
+		zend_hash_move_forward(Z_ARRVAL_P(input));
+	}
+	zend_hash_internal_pointer_reset(Z_ARRVAL_P(input));
+	/* Clean up */
+	efree(offsets);
+}
+/* }}} */
+
+/* {{{ proto int preg_last_error()
+   Returns the error code of the last regexp execution. */
+static PHP_FUNCTION(preg_last_error)
+{
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "") == FAILURE) {
+		return;
+	}
+
+	RETURN_LONG(PCRE_G(error_code));
+}
+/* }}} */
+
+/* {{{ module definition structures */
+
+/* {{{ arginfo */
+ZEND_BEGIN_ARG_INFO_EX(arginfo_preg_match, 0, 0, 2)
+    ZEND_ARG_INFO(0, pattern)
+    ZEND_ARG_INFO(0, subject)
+    ZEND_ARG_INFO(1, subpatterns) /* array */
+    ZEND_ARG_INFO(0, flags)
+    ZEND_ARG_INFO(0, offset)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_preg_match_all, 0, 0, 2)
+    ZEND_ARG_INFO(0, pattern)
+    ZEND_ARG_INFO(0, subject)
+    ZEND_ARG_INFO(1, subpatterns) /* array */
+    ZEND_ARG_INFO(0, flags)
+    ZEND_ARG_INFO(0, offset)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_preg_replace, 0, 0, 3)
+    ZEND_ARG_INFO(0, regex)
+    ZEND_ARG_INFO(0, replace)
+    ZEND_ARG_INFO(0, subject)
+    ZEND_ARG_INFO(0, limit)
+    ZEND_ARG_INFO(1, count)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_preg_replace_callback, 0, 0, 3)
+    ZEND_ARG_INFO(0, regex)
+    ZEND_ARG_INFO(0, callback)
+    ZEND_ARG_INFO(0, subject)
+    ZEND_ARG_INFO(0, limit)
+    ZEND_ARG_INFO(1, count)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_preg_split, 0, 0, 2)
+    ZEND_ARG_INFO(0, pattern)
+    ZEND_ARG_INFO(0, subject)
+    ZEND_ARG_INFO(0, limit)
+    ZEND_ARG_INFO(0, flags) 
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_preg_quote, 0, 0, 1)
+    ZEND_ARG_INFO(0, str)
+    ZEND_ARG_INFO(0, delim_char)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_preg_grep, 0, 0, 2)
+    ZEND_ARG_INFO(0, regex)
+    ZEND_ARG_INFO(0, input) /* array */
+    ZEND_ARG_INFO(0, flags)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO(arginfo_preg_last_error, 0)
+ZEND_END_ARG_INFO()
+/* }}} */
+
+static const zend_function_entry pcre_functions[] = {
+	PHP_FE(preg_match,				arginfo_preg_match)
+	PHP_FE(preg_match_all,			arginfo_preg_match_all)
+	PHP_FE(preg_replace,			arginfo_preg_replace)
+	PHP_FE(preg_replace_callback,	arginfo_preg_replace_callback)
+	PHP_FE(preg_filter,				arginfo_preg_replace)
+	PHP_FE(preg_split,				arginfo_preg_split)
+	PHP_FE(preg_quote,				arginfo_preg_quote)
+	PHP_FE(preg_grep,				arginfo_preg_grep)
+	PHP_FE(preg_last_error,			arginfo_preg_last_error)
+	PHP_FE_END
+};
+
+zend_module_entry pcre_module_entry = {
+	STANDARD_MODULE_HEADER,
+   "pcre",
+	pcre_functions,
+	PHP_MINIT(pcre),
+	PHP_MSHUTDOWN(pcre),
+	NULL,
+	NULL,
+	PHP_MINFO(pcre),
+	NO_VERSION_YET,
+	PHP_MODULE_GLOBALS(pcre),
+	PHP_GINIT(pcre),
+	PHP_GSHUTDOWN(pcre),
+	NULL,
+	STANDARD_MODULE_PROPERTIES_EX
+};
+
+#ifdef COMPILE_DL_PCRE
+ZEND_GET_MODULE(pcre)
+#endif
+
+/* }}} */
+
+#endif /* HAVE_PCRE || HAVE_BUNDLED_PCRE */
+
+/*
+ * Local variables:
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ * vim600: sw=4 ts=4 fdm=marker
+ * vim<600: sw=4 ts=4
+ */