- Removed dependencies from php_mbregex to oniguruma types

diff --git a/ext/mbstring/mbstring.c b/ext/mbstring/mbstring.c
index 24da6439e0602d170d9167256e29373ba3940987..1a38cfb070539a8900d77af4152f49bff9a89a83 100644 (file)
--- a/ext/mbstring/mbstring.c
+++ b/ext/mbstring/mbstring.c
@@ -73,6 +73,10 @@
 
 #include "mb_gpc.h"
 
+#if HAVE_MBREGEX
+#include "php_mbregex.h"
+#endif
+
 #ifdef ZEND_MULTIBYTE
 #include "zend_multibyte.h"
 #endif /* ZEND_MULTIBYTE */
@@ -89,7 +93,7 @@ static PHP_GSHUTDOWN_FUNCTION(mbstring);
 /* {{{ php_mb_default_identify_list */
 typedef struct _php_mb_nls_ident_list {
        enum mbfl_no_language lang;
-       enum mbfl_no_encoding* list;
+       const enum mbfl_no_encoding* list;
        int list_size;
 } php_mb_nls_ident_list;
 
@@ -911,7 +915,7 @@ static int php_mb_nls_get_default_detect_order_list(enum mbfl_no_language lang,
 
        for (i = 0; i < sizeof(php_mb_default_identify_list) / sizeof(php_mb_default_identify_list[0]); i++) {
                if (php_mb_default_identify_list[i].lang == lang) {
-                       *plist = php_mb_default_identify_list[i].list;
+                       *plist = (enum mbfl_no_encoding *)php_mb_default_identify_list[i].list;
                        *plist_size = php_mb_default_identify_list[i].list_size;
                        return 1;
                }
@@ -1008,12 +1012,13 @@ static PHP_INI_MH(OnUpdate_mbstring_internal_encoding)
                MBSTRG(current_internal_encoding) = no_encoding;
 #if HAVE_MBREGEX
                {
-                       OnigEncoding mbctype;
-                       mbctype = php_mb_regex_name2mbctype(new_value);
-                       if (mbctype == ONIG_ENCODING_UNDEF) {
-                               mbctype = ONIG_ENCODING_EUC_JP;
-                       }
-                       MBSTRG(current_mbctype) = MBSTRG(default_mbctype) = mbctype;
+                       const char *enc_name = new_value;
+                       if (FAILURE == php_mb_regex_set_default_mbctype(enc_name)) {
+                               /* falls back to EUC-JP if an unknown encoding name is given */
+                               enc_name = "EUC-JP";
+                               php_mb_regex_set_default_mbctype(enc_name);
+                       }
+                       php_mb_regex_set_mbctype(new_value);
                }
 #endif
 #ifdef ZEND_MULTIBYTE
@@ -1164,7 +1169,7 @@ static PHP_GINIT_FUNCTION(mbstring)
        mbstring_globals->strict_detection = 0;
        mbstring_globals->outconv = NULL;
 #if HAVE_MBREGEX
-       _php_mb_regex_globals_ctor(mbstring_globals TSRMLS_CC);
+       mbstring_globals->mb_regex_globals = php_mb_regex_globals_alloc(TSRMLS_C);
 #endif
 }
 /* }}} */
@@ -1173,7 +1178,7 @@ static PHP_GINIT_FUNCTION(mbstring)
 static PHP_GSHUTDOWN_FUNCTION(mbstring)
 {
 #if HAVE_MBREGEX
-       _php_mb_regex_globals_dtor(mbstring_globals TSRMLS_CC);
+       php_mb_regex_globals_free(mbstring_globals->mb_regex_globals TSRMLS_CC);
 #endif
 }
 /* }}} */

diff --git a/ext/mbstring/mbstring.h b/ext/mbstring/mbstring.h
index 1393559f8e9b4a8e414154130aa275b5475f8b3f..7f94db15ad349af702ba1dfca831a4b7523403d5 100644 (file)
--- a/ext/mbstring/mbstring.h
+++ b/ext/mbstring/mbstring.h
@@ -76,10 +76,6 @@
 
 #define PHP_MBSTRING_API 20021024
 
-#if HAVE_MBREGEX
-#include "php_mbregex.h"
-#endif
-
 extern zend_module_entry mbstring_module_entry;
 #define mbstring_module_ptr &mbstring_module_entry
 
@@ -197,8 +193,8 @@ ZEND_BEGIN_MODULE_GLOBALS(mbstring)
        long strict_detection;
        long illegalchars;
        mbfl_buffer_converter *outconv;
-#if HAVE_MBREGEX && defined(PHP_MBREGEX_GLOBALS)
-       PHP_MBREGEX_GLOBALS     
+#if HAVE_MBREGEX
+    struct _zend_mb_regex_globals *mb_regex_globals;
 #endif
 ZEND_END_MODULE_GLOBALS(mbstring)
 

diff --git a/ext/mbstring/php_mbregex.c b/ext/mbstring/php_mbregex.c
index f28477e497dc12e31c7f5b9f43c6a9a9fdc7e035..c15330346f3eb15acd89463b6b6a21328936b332 100644 (file)
--- a/ext/mbstring/php_mbregex.c
+++ b/ext/mbstring/php_mbregex.c
@@ -29,11 +29,31 @@
 #if HAVE_MBREGEX
 
 #include "ext/standard/php_smart_str.h"
+#include "ext/standard/info.h"
 #include "php_mbregex.h"
 #include "mbstring.h"
 
+#include "php_onig_compat.h" /* must come prior to the oniguruma header */
+#include <oniguruma.h>
+#undef UChar
+
 ZEND_EXTERN_MODULE_GLOBALS(mbstring)
 
+struct _zend_mb_regex_globals {
+       OnigEncoding default_mbctype;
+       OnigEncoding current_mbctype;
+       HashTable ht_rc;
+       zval *search_str;
+       zval *search_str_val;
+       unsigned int search_pos;
+       php_mb_regex_t *search_re;
+       OnigRegion *search_regs;
+       OnigOptionType regex_default_options;
+       OnigSyntaxType *regex_default_syntax;
+};
+
+#define MBREX(g) (MBSTRG(mb_regex_globals)->g)
+
 /* {{{ static void php_mb_regex_free_cache() */
 static void php_mb_regex_free_cache(php_mb_regex_t **pre) 
 {
@@ -42,24 +62,52 @@ static void php_mb_regex_free_cache(php_mb_regex_t **pre)
 /* }}} */
 
 /* {{{ _php_mb_regex_globals_ctor */
-void _php_mb_regex_globals_ctor(zend_mbstring_globals *pglobals TSRMLS_DC)
+static int _php_mb_regex_globals_ctor(zend_mb_regex_globals *pglobals TSRMLS_DC)
 {
-       MBSTRG(default_mbctype) = ONIG_ENCODING_EUC_JP;
-       MBSTRG(current_mbctype) = ONIG_ENCODING_EUC_JP;
-       zend_hash_init(&(MBSTRG(ht_rc)), 0, NULL, (void (*)(void *)) php_mb_regex_free_cache, 1);
-       MBSTRG(search_str) = (zval*) NULL;
-       MBSTRG(search_re) = (php_mb_regex_t*)NULL;
-       MBSTRG(search_pos) = 0;
-       MBSTRG(search_regs) = (OnigRegion*)NULL;
-       MBSTRG(regex_default_options) = ONIG_OPTION_MULTILINE | ONIG_OPTION_SINGLELINE;
-       MBSTRG(regex_default_syntax) = ONIG_SYNTAX_RUBY;
+       pglobals->default_mbctype = ONIG_ENCODING_EUC_JP;
+       pglobals->current_mbctype = ONIG_ENCODING_EUC_JP;
+       zend_hash_init(&(pglobals->ht_rc), 0, NULL, (void (*)(void *)) php_mb_regex_free_cache, 1);
+       pglobals->search_str = (zval*) NULL;
+       pglobals->search_re = (php_mb_regex_t*)NULL;
+       pglobals->search_pos = 0;
+       pglobals->search_regs = (OnigRegion*)NULL;
+       pglobals->regex_default_options = ONIG_OPTION_MULTILINE | ONIG_OPTION_SINGLELINE;
+       pglobals->regex_default_syntax = ONIG_SYNTAX_RUBY;
+       return SUCCESS;
 }
 /* }}} */
 
 /* {{{ _php_mb_regex_globals_dtor */
-void _php_mb_regex_globals_dtor(zend_mbstring_globals *pglobals TSRMLS_DC) 
+static void _php_mb_regex_globals_dtor(zend_mb_regex_globals *pglobals TSRMLS_DC) 
 {
-       zend_hash_destroy(&MBSTRG(ht_rc));
+       zend_hash_destroy(&pglobals->ht_rc);
+}
+/* }}} */
+
+/* {{{ php_mb_regex_globals_alloc */
+zend_mb_regex_globals *php_mb_regex_globals_alloc(TSRMLS_D)
+{
+       zend_mb_regex_globals *pglobals = pemalloc(
+                       sizeof(zend_mb_regex_globals), 1);
+       if (!pglobals) {
+               return NULL;
+       }
+       if (SUCCESS != _php_mb_regex_globals_ctor(pglobals TSRMLS_CC)) {
+               pefree(pglobals, 1);
+               return NULL;
+       }
+       return pglobals;
+}
+/* }}} */
+
+/* {{{ php_mb_regex_globals_free */
+void php_mb_regex_globals_free(zend_mb_regex_globals *pglobals TSRMLS_DC)
+{
+       if (!pglobals) {
+               return;
+       }
+       _php_mb_regex_globals_dtor(pglobals TSRMLS_CC);
+       pefree(pglobals, 1);
 }
 /* }}} */
 
@@ -80,26 +128,26 @@ PHP_MSHUTDOWN_FUNCTION(mb_regex)
 /* {{{ PHP_RINIT_FUNCTION(mb_regex) */
 PHP_RINIT_FUNCTION(mb_regex)
 {
-       return SUCCESS;
+       return MBSTRG(mb_regex_globals) ? SUCCESS: FAILURE;
 }
 /* }}} */
 
 /* {{{ PHP_RSHUTDOWN_FUNCTION(mb_regex) */
 PHP_RSHUTDOWN_FUNCTION(mb_regex)
 {
-       MBSTRG(current_mbctype) = MBSTRG(default_mbctype);
+       MBREX(current_mbctype) = MBREX(default_mbctype);
 
-       if (MBSTRG(search_str) != NULL) {
-               zval_ptr_dtor(&MBSTRG(search_str));
-               MBSTRG(search_str) = (zval *)NULL;
+       if (MBREX(search_str) != NULL) {
+               zval_ptr_dtor(&MBREX(search_str));
+               MBREX(search_str) = (zval *)NULL;
        }
-       MBSTRG(search_pos) = 0;
+       MBREX(search_pos) = 0;
 
-       if (MBSTRG(search_regs) != NULL) {
-               onig_region_free(MBSTRG(search_regs), 1);
-               MBSTRG(search_regs) = (OnigRegion *)NULL;
+       if (MBREX(search_regs) != NULL) {
+               onig_region_free(MBREX(search_regs), 1);
+               MBREX(search_regs) = (OnigRegion *)NULL;
        }
-       zend_hash_clean(&MBSTRG(ht_rc));
+       zend_hash_clean(&MBREX(ht_rc));
 
        return SUCCESS;
 }
@@ -317,7 +365,7 @@ php_mb_regex_enc_name_map_t enc_name_map[] = {
 /* }}} */
 
 /* {{{ php_mb_regex_name2mbctype */
-OnigEncoding php_mb_regex_name2mbctype(const char *pname)
+static OnigEncoding _php_mb_regex_name2mbctype(const char *pname)
 {
        const char *p;
        php_mb_regex_enc_name_map_t *mapping;
@@ -338,8 +386,8 @@ OnigEncoding php_mb_regex_name2mbctype(const char *pname)
 }
 /* }}} */
 
-/* {{{ php_mbregex_mbctype2name */
-const char *php_mb_regex_mbctype2name(OnigEncoding mbctype)
+/* {{{ php_mb_regex_mbctype2name */
+static const char *_php_mb_regex_mbctype2name(OnigEncoding mbctype)
 {
        php_mb_regex_enc_name_map_t *mapping;
 
@@ -353,6 +401,44 @@ const char *php_mb_regex_mbctype2name(OnigEncoding mbctype)
 }
 /* }}} */
 
+/* {{{ php_mb_regex_set_mbctype */
+int php_mb_regex_set_mbctype(const char *encname TSRMLS_DC)
+{
+       OnigEncoding mbctype = _php_mb_regex_name2mbctype(encname);
+       if (mbctype == ONIG_ENCODING_UNDEF) {
+               return FAILURE;
+       }
+       MBREX(current_mbctype) = mbctype;
+       return SUCCESS;
+}
+/* }}} */
+
+/* {{{ php_mb_regex_set_default_mbctype */
+int php_mb_regex_set_default_mbctype(const char *encname TSRMLS_DC)
+{
+       OnigEncoding mbctype = _php_mb_regex_name2mbctype(encname);
+       if (mbctype == ONIG_ENCODING_UNDEF) {
+               return FAILURE;
+       }
+       MBREX(default_mbctype) = mbctype;
+       return SUCCESS;
+}
+/* }}} */
+
+/* {{{ php_mb_regex_get_mbctype */
+const char *php_mb_regex_get_mbctype(TSRMLS_D)
+{
+       return _php_mb_regex_mbctype2name(MBREX(current_mbctype));
+}
+/* }}} */
+
+/* {{{ php_mb_regex_get_default_mbctype */
+const char *php_mb_regex_get_default_mbctype(TSRMLS_D)
+{
+       return _php_mb_regex_mbctype2name(MBREX(default_mbctype));
+}
+/* }}} */
+
 /*
  * regex cache
  */
@@ -365,7 +451,7 @@ static php_mb_regex_t *php_mbregex_compile_pattern(const char *pattern, int patl
        OnigErrorInfo err_info;
        OnigUChar err_str[ONIG_MAX_ERROR_MESSAGE_LEN];
 
-       found = zend_hash_find(&MBSTRG(ht_rc), (char *)pattern, patlen+1, (void **) &rc);
+       found = zend_hash_find(&MBREX(ht_rc), (char *)pattern, patlen+1, (void **) &rc);
        if (found == FAILURE || (*rc)->options != options || (*rc)->enc != enc || (*rc)->syntax != syntax) {
                if ((err_code = onig_new(&retval, (OnigUChar *)pattern, (OnigUChar *)(pattern + patlen), options, enc, syntax, &err_info)) != ONIG_NORMAL) {
                        onig_error_code_to_str(err_str, err_code, err_info);
@@ -373,7 +459,7 @@ static php_mb_regex_t *php_mbregex_compile_pattern(const char *pattern, int patl
                        retval = NULL;
                        goto out;
                }
-               zend_hash_update(&MBSTRG(ht_rc), (char *) pattern, patlen + 1, (void *) &retval, sizeof(retval), NULL);
+               zend_hash_update(&MBREX(ht_rc), (char *) pattern, patlen + 1, (void *) &retval, sizeof(retval), NULL);
        } else if (found == SUCCESS) {
                retval = *rc;
        }
@@ -571,7 +657,7 @@ PHP_FUNCTION(mb_regex_encoding)
        OnigEncoding mbctype;
 
        if (ZEND_NUM_ARGS() == 0) {
-               const char *retval = php_mb_regex_mbctype2name(MBSTRG(current_mbctype));
+               const char *retval = _php_mb_regex_mbctype2name(MBREX(current_mbctype));
                if ( retval != NULL ) {
                        RETVAL_STRING((char *)retval, 1);
                } else {
@@ -580,12 +666,12 @@ PHP_FUNCTION(mb_regex_encoding)
        } else if (ZEND_NUM_ARGS() == 1 &&
                   zend_get_parameters_ex(1, &arg1) != FAILURE) {
                convert_to_string_ex(arg1);
-               mbctype = php_mb_regex_name2mbctype(Z_STRVAL_PP(arg1));
+               mbctype = _php_mb_regex_name2mbctype(Z_STRVAL_PP(arg1));
                if (mbctype == ONIG_ENCODING_UNDEF) {
                        php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown encoding \"%s\"", Z_STRVAL_PP(arg1));
                        RETVAL_FALSE;
                } else {
-                       MBSTRG(current_mbctype) = mbctype;
+                       MBREX(current_mbctype) = mbctype;
                        RETVAL_TRUE;
                }
        } else {
@@ -612,7 +698,7 @@ static void _php_mb_regex_ereg_exec(INTERNAL_FUNCTION_PARAMETERS, int icase)
                RETURN_FALSE;
        }
 
-       options = MBSTRG(regex_default_options);
+       options = MBREX(regex_default_options);
        if (icase) {
                options |= ONIG_OPTION_IGNORECASE;
        }
@@ -626,7 +712,7 @@ static void _php_mb_regex_ereg_exec(INTERNAL_FUNCTION_PARAMETERS, int icase)
                convert_to_string_ex(arg_pattern);
                /* don't bother doing an extended regex with just a number */
        }
-       re = php_mbregex_compile_pattern(Z_STRVAL_PP(arg_pattern), Z_STRLEN_PP(arg_pattern), options, MBSTRG(current_mbctype), MBSTRG(regex_default_syntax) TSRMLS_CC);
+       re = php_mbregex_compile_pattern(Z_STRVAL_PP(arg_pattern), Z_STRLEN_PP(arg_pattern), options, MBREX(current_mbctype), MBREX(regex_default_syntax) TSRMLS_CC);
        if (re == NULL) {
                RETVAL_FALSE;
                goto out;
@@ -635,7 +721,7 @@ static void _php_mb_regex_ereg_exec(INTERNAL_FUNCTION_PARAMETERS, int icase)
        regs = onig_region_new();
 
        /* actually execute the regular expression */
-       if (onig_search(re, (OnigUChar *)string, (OnigUChar *)(string + string_len), string, (OnigUChar *)(string + string_len), regs, 0) < 0) {
+       if (onig_search(re, (OnigUChar *)string, (OnigUChar *)(string + string_len), (OnigUChar *)string, (OnigUChar *)(string + string_len), regs, 0) < 0) {
                RETVAL_FALSE;
                goto out;
        }
@@ -715,7 +801,7 @@ static void _php_mb_regex_ereg_replace_exec(INTERNAL_FUNCTION_PARAMETERS, OnigOp
 
        {
                const char *current_enc_name;
-               current_enc_name = php_mb_regex_mbctype2name(MBSTRG(current_mbctype));
+               current_enc_name = _php_mb_regex_mbctype2name(MBREX(current_mbctype));
                if (current_enc_name == NULL ||
                        (enc = mbfl_name2encoding(current_enc_name)) == NULL) {
                        php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown error");
@@ -738,8 +824,8 @@ static void _php_mb_regex_ereg_replace_exec(INTERNAL_FUNCTION_PARAMETERS, OnigOp
                if (option_str != NULL) {
                        _php_mb_regex_init_options(option_str, option_str_len, &options, &syntax, &eval);
                } else {
-                       options |= MBSTRG(regex_default_options);
-                       syntax = MBSTRG(regex_default_syntax);
+                       options |= MBREX(regex_default_options);
+                       syntax = MBREX(regex_default_syntax);
                }
        }
        if (Z_TYPE_PP(arg_pattern_zval) == IS_STRING) {
@@ -759,7 +845,7 @@ static void _php_mb_regex_ereg_replace_exec(INTERNAL_FUNCTION_PARAMETERS, OnigOp
                arg_pattern_len = 1;    
        }
        /* create regex pattern buffer */
-       re = php_mbregex_compile_pattern(arg_pattern, arg_pattern_len, options, MBSTRG(current_mbctype), syntax TSRMLS_CC);
+       re = php_mbregex_compile_pattern(arg_pattern, arg_pattern_len, options, MBREX(current_mbctype), syntax TSRMLS_CC);
        if (re == NULL) {
                RETURN_FALSE;
        }
@@ -774,7 +860,7 @@ static void _php_mb_regex_ereg_replace_exec(INTERNAL_FUNCTION_PARAMETERS, OnigOp
 
        /* do the actual work */
        err = 0;
-       pos = string;
+       pos = (OnigUChar *)string;
        string_lim = (OnigUChar*)(string + string_len);
        regs = onig_region_new();
        while (err >= 0) {
@@ -836,7 +922,7 @@ static void _php_mb_regex_ereg_replace_exec(INTERNAL_FUNCTION_PARAMETERS, OnigOp
                        }
                        n = regs->end[0];
                        if ((size_t)(pos - (OnigUChar *)string) < n) {
-                               pos = string + n;
+                               pos = (OnigUChar *)string + n;
                        } else {
                                if (pos < string_lim) {
                                        smart_str_appendl(&out_buf, pos, 1); 
@@ -910,7 +996,7 @@ PHP_FUNCTION(mb_split)
        }
 
        /* create regex pattern buffer */
-       if ((re = php_mbregex_compile_pattern(arg_pattern, arg_pattern_len, MBSTRG(regex_default_options), MBSTRG(current_mbctype), MBSTRG(regex_default_syntax) TSRMLS_CC)) == NULL) {
+       if ((re = php_mbregex_compile_pattern(arg_pattern, arg_pattern_len, MBREX(regex_default_options), MBREX(current_mbctype), MBREX(regex_default_syntax) TSRMLS_CC)) == NULL) {
                RETURN_FALSE;
        }
 
@@ -929,7 +1015,7 @@ PHP_FUNCTION(mb_split)
 
                /* add it to the array */
                if (regs->beg[0] < string_len && regs->beg[0] >= (size_t)(pos - (OnigUChar *)string)) {
-                       add_next_index_stringl(return_value, pos, ((OnigUChar *)(string + regs->beg[0]) - pos), 1);
+                       add_next_index_stringl(return_value, (char *)pos, ((OnigUChar *)(string + regs->beg[0]) - pos), 1);
                } else {
                        err = -2;
                        break;
@@ -959,7 +1045,7 @@ PHP_FUNCTION(mb_split)
        /* otherwise we just have one last element to add to the array */
        n = ((OnigUChar *)(string + string_len) - pos);
        if (n > 0) {
-               add_next_index_stringl(return_value, pos, n, 1);
+               add_next_index_stringl(return_value, (char *)pos, n, 1);
        } else {
                add_next_index_stringl(return_value, "", 0, 1);
        }
@@ -978,7 +1064,8 @@ PHP_FUNCTION(mb_ereg_match)
 
        php_mb_regex_t *re;
        OnigSyntaxType *syntax;
-       int option = 0, err;
+       OnigOptionType option = 0;
+       int err;
 
        {
                char *option_str = NULL;
@@ -993,12 +1080,12 @@ PHP_FUNCTION(mb_ereg_match)
                if (option_str != NULL) {
                        _php_mb_regex_init_options(option_str, option_str_len, &option, &syntax, NULL);
                } else {
-                       option |= MBSTRG(regex_default_options);
-                       syntax = MBSTRG(regex_default_syntax);
+                       option |= MBREX(regex_default_options);
+                       syntax = MBREX(regex_default_syntax);
                }
        }
 
-       if ((re = php_mbregex_compile_pattern(arg_pattern, arg_pattern_len, option, MBSTRG(current_mbctype), syntax TSRMLS_CC)) == NULL) {
+       if ((re = php_mbregex_compile_pattern(arg_pattern, arg_pattern_len, option, MBREX(current_mbctype), syntax TSRMLS_CC)) == NULL) {
                RETURN_FALSE;
        }
 
@@ -1018,11 +1105,12 @@ static void
 _php_mb_regex_ereg_search_exec(INTERNAL_FUNCTION_PARAMETERS, int mode)
 {
        zval **arg_pattern, **arg_options;
-       int n, i, err, pos, len, beg, end, option;
+       int n, i, err, pos, len, beg, end;
+       OnigOptionType option;
        OnigUChar *str;
        OnigSyntaxType *syntax;
 
-       option = MBSTRG(regex_default_options);
+       option = MBREX(regex_default_options);
        switch (ZEND_NUM_ARGS()) {
        case 0:
                break;
@@ -1047,20 +1135,20 @@ _php_mb_regex_ereg_search_exec(INTERNAL_FUNCTION_PARAMETERS, int mode)
                /* create regex pattern buffer */
                convert_to_string_ex(arg_pattern);
 
-               if ((MBSTRG(search_re) = php_mbregex_compile_pattern(Z_STRVAL_PP(arg_pattern), Z_STRLEN_PP(arg_pattern), option, MBSTRG(current_mbctype), MBSTRG(regex_default_syntax) TSRMLS_CC)) == NULL) {
+               if ((MBREX(search_re) = php_mbregex_compile_pattern(Z_STRVAL_PP(arg_pattern), Z_STRLEN_PP(arg_pattern), option, MBREX(current_mbctype), MBREX(regex_default_syntax) TSRMLS_CC)) == NULL) {
                        RETURN_FALSE;
                }
        }
 
-       pos = MBSTRG(search_pos);
+       pos = MBREX(search_pos);
        str = NULL;
        len = 0;
-       if (MBSTRG(search_str) != NULL && Z_TYPE_P(MBSTRG(search_str)) == IS_STRING){
-               str = (OnigUChar *)Z_STRVAL_P(MBSTRG(search_str));
-               len = Z_STRLEN_P(MBSTRG(search_str));
+       if (MBREX(search_str) != NULL && Z_TYPE_P(MBREX(search_str)) == IS_STRING){
+               str = (OnigUChar *)Z_STRVAL_P(MBREX(search_str));
+               len = Z_STRLEN_P(MBREX(search_str));
        }
 
-       if (MBSTRG(search_re) == NULL) {
+       if (MBREX(search_re) == NULL) {
                php_error_docref(NULL TSRMLS_CC, E_WARNING, "No regex given");
                RETURN_FALSE;
        }
@@ -1070,14 +1158,14 @@ _php_mb_regex_ereg_search_exec(INTERNAL_FUNCTION_PARAMETERS, int mode)
                RETURN_FALSE;
        }
 
-       if (MBSTRG(search_regs)) {
-               onig_region_free(MBSTRG(search_regs), 1);
+       if (MBREX(search_regs)) {
+               onig_region_free(MBREX(search_regs), 1);
        }
-       MBSTRG(search_regs) = onig_region_new();
+       MBREX(search_regs) = onig_region_new();
 
-       err = onig_search(MBSTRG(search_re), str, str + len, str + pos, str  + len, MBSTRG(search_regs), 0);
+       err = onig_search(MBREX(search_re), str, str + len, str + pos, str  + len, MBREX(search_regs), 0);
        if (err == ONIG_MISMATCH) {
-               MBSTRG(search_pos) = len;
+               MBREX(search_pos) = len;
                RETVAL_FALSE;
        } else if (err <= -2) {
                OnigUChar err_str[ONIG_MAX_ERROR_MESSAGE_LEN];
@@ -1085,23 +1173,23 @@ _php_mb_regex_ereg_search_exec(INTERNAL_FUNCTION_PARAMETERS, int mode)
                php_error_docref(NULL TSRMLS_CC, E_WARNING, "mbregex search failure in mbregex_search(): %s", err_str);
                RETVAL_FALSE;
        } else {
-               if (MBSTRG(search_regs)->beg[0] == MBSTRG(search_regs)->end[0]) {
+               if (MBREX(search_regs)->beg[0] == MBREX(search_regs)->end[0]) {
                        php_error_docref(NULL TSRMLS_CC, E_WARNING, "Empty regular expression");
                }
                switch (mode) {
                case 1:
                        array_init(return_value);
-                       beg = MBSTRG(search_regs)->beg[0];
-                       end = MBSTRG(search_regs)->end[0];
+                       beg = MBREX(search_regs)->beg[0];
+                       end = MBREX(search_regs)->end[0];
                        add_next_index_long(return_value, beg);
                        add_next_index_long(return_value, end - beg);
                        break;
                case 2:
                        array_init(return_value);
-                       n = MBSTRG(search_regs)->num_regs;
+                       n = MBREX(search_regs)->num_regs;
                        for (i = 0; i < n; i++) {
-                               beg = MBSTRG(search_regs)->beg[i];
-                               end = MBSTRG(search_regs)->end[i];
+                               beg = MBREX(search_regs)->beg[i];
+                               end = MBREX(search_regs)->end[i];
                                if (beg >= 0 && beg <= end && end <= len) {
                                        add_index_stringl(return_value, i, (char *)&str[beg], end - beg, 1);
                                } else {
@@ -1113,17 +1201,17 @@ _php_mb_regex_ereg_search_exec(INTERNAL_FUNCTION_PARAMETERS, int mode)
                        RETVAL_TRUE;
                        break;
                }
-               end = MBSTRG(search_regs)->end[0];
+               end = MBREX(search_regs)->end[0];
                if (pos < end) {
-                       MBSTRG(search_pos) = end;
+                       MBREX(search_pos) = end;
                } else {
-                       MBSTRG(search_pos) = pos + 1;
+                       MBREX(search_pos) = pos + 1;
                }
        }
 
        if (err < 0) {
-               onig_region_free(MBSTRG(search_regs), 1);
-               MBSTRG(search_regs) = (OnigRegion *)NULL;
+               onig_region_free(MBREX(search_regs), 1);
+               MBREX(search_regs) = (OnigRegion *)NULL;
        }
 }
 /* }}} */
@@ -1160,8 +1248,8 @@ PHP_FUNCTION(mb_ereg_search_init)
        OnigSyntaxType *syntax = NULL;
        int option;
 
-       option = MBSTRG(regex_default_options);
-       syntax = MBSTRG(regex_default_syntax);
+       option = MBREX(regex_default_options);
+       syntax = MBREX(regex_default_syntax);
        switch (ZEND_NUM_ARGS()) {
        case 1:
                if (zend_get_parameters_ex(1, &arg_str) == FAILURE) {
@@ -1190,25 +1278,25 @@ PHP_FUNCTION(mb_ereg_search_init)
                /* create regex pattern buffer */
                convert_to_string_ex(arg_pattern);
 
-               if ((MBSTRG(search_re) = php_mbregex_compile_pattern(Z_STRVAL_PP(arg_pattern), Z_STRLEN_PP(arg_pattern), option, MBSTRG(current_mbctype), syntax TSRMLS_CC)) == NULL) {
+               if ((MBREX(search_re) = php_mbregex_compile_pattern(Z_STRVAL_PP(arg_pattern), Z_STRLEN_PP(arg_pattern), option, MBREX(current_mbctype), syntax TSRMLS_CC)) == NULL) {
                        RETURN_FALSE;
                }
        }
 
-       if (MBSTRG(search_str) != NULL) {
-               zval_ptr_dtor(&MBSTRG(search_str));
-               MBSTRG(search_str) = (zval *)NULL;
+       if (MBREX(search_str) != NULL) {
+               zval_ptr_dtor(&MBREX(search_str));
+               MBREX(search_str) = (zval *)NULL;
        }
 
-       MBSTRG(search_str) = *arg_str;
-       Z_ADDREF_P(MBSTRG(search_str));
-       SEPARATE_ZVAL_IF_NOT_REF(&MBSTRG(search_str));
+       MBREX(search_str) = *arg_str;
+       Z_ADDREF_P(MBREX(search_str));
+       SEPARATE_ZVAL_IF_NOT_REF(&MBREX(search_str));
 
-       MBSTRG(search_pos) = 0;
+       MBREX(search_pos) = 0;
 
-       if (MBSTRG(search_regs) != NULL) {
-               onig_region_free(MBSTRG(search_regs), 1);
-               MBSTRG(search_regs) = (OnigRegion *) NULL;
+       if (MBREX(search_regs) != NULL) {
+               onig_region_free(MBREX(search_regs), 1);
+               MBREX(search_regs) = (OnigRegion *) NULL;
        }
 
        RETURN_TRUE;
@@ -1222,15 +1310,15 @@ PHP_FUNCTION(mb_ereg_search_getregs)
        int n, i, len, beg, end;
        OnigUChar *str;
 
-       if (MBSTRG(search_regs) != NULL && Z_TYPE_P(MBSTRG(search_str)) == IS_STRING && Z_STRVAL_P(MBSTRG(search_str)) != NULL) {
+       if (MBREX(search_regs) != NULL && Z_TYPE_P(MBREX(search_str)) == IS_STRING && Z_STRVAL_P(MBREX(search_str)) != NULL) {
                array_init(return_value);
 
-               str = (OnigUChar *)Z_STRVAL_P(MBSTRG(search_str));
-               len = Z_STRLEN_P(MBSTRG(search_str));
-               n = MBSTRG(search_regs)->num_regs;
+               str = (OnigUChar *)Z_STRVAL_P(MBREX(search_str));
+               len = Z_STRLEN_P(MBREX(search_str));
+               n = MBREX(search_regs)->num_regs;
                for (i = 0; i < n; i++) {
-                       beg = MBSTRG(search_regs)->beg[i];
-                       end = MBSTRG(search_regs)->end[i];
+                       beg = MBREX(search_regs)->beg[i];
+                       end = MBREX(search_regs)->end[i];
                        if (beg >= 0 && beg <= end && end <= len) {
                                add_index_stringl(return_value, i, (char *)&str[beg], end - beg, 1);
                        } else {
@@ -1247,7 +1335,7 @@ PHP_FUNCTION(mb_ereg_search_getregs)
    Get search start position */
 PHP_FUNCTION(mb_ereg_search_getpos)
 {
-       RETVAL_LONG(MBSTRG(search_pos));
+       RETVAL_LONG(MBREX(search_pos));
 }
 /* }}} */
 
@@ -1263,28 +1351,28 @@ PHP_FUNCTION(mb_ereg_search_setpos)
        }
        convert_to_long_ex(arg_pos);
        n = Z_LVAL_PP(arg_pos);
-       if (n < 0 || (MBSTRG(search_str) != NULL && Z_TYPE_P(MBSTRG(search_str)) == IS_STRING && n >= Z_STRLEN_P(MBSTRG(search_str)))) {
+       if (n < 0 || (MBREX(search_str) != NULL && Z_TYPE_P(MBREX(search_str)) == IS_STRING && n >= Z_STRLEN_P(MBREX(search_str)))) {
                php_error_docref(NULL TSRMLS_CC, E_WARNING, "Position is out of range");
-               MBSTRG(search_pos) = 0;
+               MBREX(search_pos) = 0;
                RETVAL_FALSE;
        } else {
-               MBSTRG(search_pos) = n;
+               MBREX(search_pos) = n;
                RETVAL_TRUE;
        }
 }
 /* }}} */
 
 /* {{{ php_mb_regex_set_options */
-void php_mb_regex_set_options(OnigOptionType options, OnigSyntaxType *syntax, OnigOptionType *prev_options, OnigSyntaxType **prev_syntax TSRMLS_DC) 
+static void _php_mb_regex_set_options(OnigOptionType options, OnigSyntaxType *syntax, OnigOptionType *prev_options, OnigSyntaxType **prev_syntax TSRMLS_DC) 
 {
        if (prev_options != NULL) {
-               *prev_options = MBSTRG(regex_default_options);
+               *prev_options = MBREX(regex_default_options);
        }
        if (prev_syntax != NULL) {
-               *prev_syntax = MBSTRG(regex_default_syntax);
+               *prev_syntax = MBREX(regex_default_syntax);
        }
-       MBSTRG(regex_default_options) = options;
-       MBSTRG(regex_default_syntax) = syntax;
+       MBREX(regex_default_options) = options;
+       MBREX(regex_default_syntax) = syntax;
 }
 /* }}} */
 
@@ -1306,10 +1394,10 @@ PHP_FUNCTION(mb_regex_set_options)
                opt = 0;
                syntax = NULL;
                _php_mb_regex_init_options(string, string_len, &opt, &syntax, NULL);
-               php_mb_regex_set_options(opt, syntax, NULL, NULL TSRMLS_CC);
+               _php_mb_regex_set_options(opt, syntax, NULL, NULL TSRMLS_CC);
        } else {
-               opt = MBSTRG(regex_default_options);
-               syntax = MBSTRG(regex_default_syntax);
+               opt = MBREX(regex_default_options);
+               syntax = MBREX(regex_default_syntax);
        }
        _php_mb_regex_get_option_string(buf, sizeof(buf), opt, syntax);
 

diff --git a/ext/mbstring/php_mbregex.h b/ext/mbstring/php_mbregex.h
index 8326fed316121f35b4d232c2300be1196c3e00c1..04f408cdd564e06523cabb2bea1b42a428e9a1b5 100644 (file)
--- a/ext/mbstring/php_mbregex.h
+++ b/ext/mbstring/php_mbregex.h
@@ -25,23 +25,6 @@
 
 #include "php.h"
 #include "zend.h"
-#include "php_onig_compat.h" /* must come prior to the oniguruma header */
-#include "oniguruma.h"
-#undef UChar
-
-/* {{{ PHP_MBREGEX_GLOBALS */
-#define PHP_MBREGEX_GLOBALS \
-       OnigEncoding default_mbctype; \
-       OnigEncoding current_mbctype; \
-       HashTable ht_rc; \
-       zval *search_str; \
-       zval *search_str_val; \
-       unsigned int search_pos; \
-       php_mb_regex_t *search_re; \
-       OnigRegion *search_regs; \
-       OnigOptionType regex_default_options; \
-       OnigSyntaxType *regex_default_syntax;
-/* }}} */
 
 /* {{{ PHP_MBREGEX_FUNCTION_ENTRIES */
 #define PHP_MBREGEX_FUNCTION_ENTRIES \
@@ -76,8 +59,6 @@
        PHP_FALIAS(mbereg_search_setpos,        mb_ereg_search_setpos,  arginfo_mb_ereg_search_setpos)
 /* }}} */
 
-typedef struct _zend_mbstring_globals * zend_mbstring_globals_ptr;
-
 #define PHP_MBREGEX_MAXCACHE 50
 
 PHP_MINIT_FUNCTION(mb_regex);
@@ -85,11 +66,15 @@ PHP_MSHUTDOWN_FUNCTION(mb_regex);
 PHP_RINIT_FUNCTION(mb_regex);
 PHP_RSHUTDOWN_FUNCTION(mb_regex);
 PHP_MINFO_FUNCTION(mb_regex);
-void _php_mb_regex_globals_ctor(zend_mbstring_globals_ptr pglobals TSRMLS_DC);
-void php_mb_regex_set_options(OnigOptionType options, OnigSyntaxType *syntax, OnigOptionType *prev_options, OnigSyntaxType **prev_syntax TSRMLS_DC);
-void _php_mb_regex_globals_dtor(zend_mbstring_globals_ptr pglobals TSRMLS_DC);
-OnigEncoding php_mb_regex_name2mbctype(const char *pname);
-const char *php_mb_regex_mbctype2name(OnigEncoding mbctype);
+
+typedef struct _zend_mb_regex_globals zend_mb_regex_globals;
+
+zend_mb_regex_globals *php_mb_regex_globals_new(TSRMLS_D);
+void php_mb_regex_globals_free(zend_mb_regex_globals *pglobals TSRMLS_DC);
+int php_mb_regex_set_mbctype(const char *enc TSRMLS_DC);
+int php_mb_regex_set_default_mbctype(const char *encname TSRMLS_DC);
+const char *php_mb_regex_get_mbctype(TSRMLS_D);
+const char *php_mb_regex_get_default_mbctype(TSRMLS_D);
 
 PHP_FUNCTION(mb_regex_encoding);
 PHP_FUNCTION(mb_ereg);