/*

+----------------------------------------------------------------------+

| PHP Version 7 |

+----------------------------------------------------------------------+

| Copyright (c) 1997-2016 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: Tsukada Takuya <tsukada@fminn.nagano.nagano.jp> |

| Rui Hirokawa <hirokawa@php.net> |

+----------------------------------------------------------------------+

*/

/* $Id$ */

/*

* PHP 4 Multibyte String module "mbstring"

*

* History:

* 2000.5.19 Release php-4.0RC2_jstring-1.0

* 2001.4.1 Release php4_jstring-1.0.91

* 2001.4.30 Release php4_jstring-1.1 (contribute to The PHP Group)

* 2001.5.1 Renamed from jstring to mbstring (hirokawa@php.net)

*/

/*

* PHP3 Internationalization support program.

*

* Copyright (c) 1999,2000 by the PHP3 internationalization team.

* All rights reserved.

*

* See README_PHP3-i18n-ja for more detail.

*

* Authors:

* Hironori Sato <satoh@jpnnet.com>

* Shigeru Kanemoto <sgk@happysize.co.jp>

* Tsukada Takuya <tsukada@fminn.nagano.nagano.jp>

* Rui Hirokawa <rui_hirokawa@ybb.ne.jp>

*/

/* {{{ includes */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include "php.h"

#include "php_ini.h"

#include "php_variables.h"

#include "mbstring.h"

#include "ext/standard/php_string.h"

#include "ext/standard/php_mail.h"

#include "ext/standard/exec.h"

#include "ext/standard/url.h"

#include "main/php_output.h"

#include "ext/standard/info.h"

#include "libmbfl/mbfl/mbfl_allocators.h"

#include "libmbfl/mbfl/mbfilter_pass.h"

#include "php_variables.h"

#include "php_globals.h"

#include "rfc1867.h"

#include "php_content_types.h"

#include "SAPI.h"

#include "php_unicode.h"

#include "TSRM.h"

#include "mb_gpc.h"

#if HAVE_MBREGEX

#include "php_mbregex.h"

#endif

#include "zend_multibyte.h"

#if HAVE_ONIG

#include "php_onig_compat.h"

#include <oniguruma.h>

#undef UChar

#elif HAVE_PCRE || HAVE_BUNDLED_PCRE

#include "ext/pcre/php_pcre.h"

#endif

/* }}} */

#if HAVE_MBSTRING

/* {{{ prototypes */

ZEND_DECLARE_MODULE_GLOBALS(mbstring)

static PHP_GINIT_FUNCTION(mbstring);

static PHP_GSHUTDOWN_FUNCTION(mbstring);

static void php_mb_populate_current_detect_order_list(void);

static int php_mb_encoding_translation(void);

static void php_mb_gpc_get_detect_order(const zend_encoding ***list, size_t *list_size);

static void php_mb_gpc_set_input_encoding(const zend_encoding *encoding);

/* }}} */

/* {{{ php_mb_default_identify_list */

typedef struct _php_mb_nls_ident_list {

enum mbfl_no_language lang;

const enum mbfl_no_encoding *list;

size_t list_size;

} php_mb_nls_ident_list;

static const enum mbfl_no_encoding php_mb_default_identify_list_ja[] = {

mbfl_no_encoding_ascii,

mbfl_no_encoding_jis,

mbfl_no_encoding_utf8,

mbfl_no_encoding_euc_jp,

mbfl_no_encoding_sjis

};

static const enum mbfl_no_encoding php_mb_default_identify_list_cn[] = {

mbfl_no_encoding_ascii,

mbfl_no_encoding_utf8,

mbfl_no_encoding_euc_cn,

mbfl_no_encoding_cp936

};

static const enum mbfl_no_encoding php_mb_default_identify_list_tw_hk[] = {

mbfl_no_encoding_ascii,

mbfl_no_encoding_utf8,

mbfl_no_encoding_euc_tw,

mbfl_no_encoding_big5

};

static const enum mbfl_no_encoding php_mb_default_identify_list_kr[] = {

mbfl_no_encoding_ascii,

mbfl_no_encoding_utf8,

mbfl_no_encoding_euc_kr,

mbfl_no_encoding_uhc

};

static const enum mbfl_no_encoding php_mb_default_identify_list_ru[] = {

mbfl_no_encoding_ascii,

mbfl_no_encoding_utf8,

mbfl_no_encoding_koi8r,

mbfl_no_encoding_cp1251,

mbfl_no_encoding_cp866

};

static const enum mbfl_no_encoding php_mb_default_identify_list_hy[] = {

mbfl_no_encoding_ascii,

mbfl_no_encoding_utf8,

mbfl_no_encoding_armscii8

};

static const enum mbfl_no_encoding php_mb_default_identify_list_tr[] = {

mbfl_no_encoding_ascii,

mbfl_no_encoding_utf8,

mbfl_no_encoding_cp1254,

mbfl_no_encoding_8859_9

};

static const enum mbfl_no_encoding php_mb_default_identify_list_ua[] = {

mbfl_no_encoding_ascii,

mbfl_no_encoding_utf8,

mbfl_no_encoding_koi8u

};

static const enum mbfl_no_encoding php_mb_default_identify_list_neut[] = {

mbfl_no_encoding_ascii,

mbfl_no_encoding_utf8

};

static const php_mb_nls_ident_list php_mb_default_identify_list[] = {

{ mbfl_no_language_japanese, php_mb_default_identify_list_ja, sizeof(php_mb_default_identify_list_ja) / sizeof(php_mb_default_identify_list_ja[0]) },

{ mbfl_no_language_korean, php_mb_default_identify_list_kr, sizeof(php_mb_default_identify_list_kr) / sizeof(php_mb_default_identify_list_kr[0]) },

{ mbfl_no_language_traditional_chinese, php_mb_default_identify_list_tw_hk, sizeof(php_mb_default_identify_list_tw_hk) / sizeof(php_mb_default_identify_list_tw_hk[0]) },

{ mbfl_no_language_simplified_chinese, php_mb_default_identify_list_cn, sizeof(php_mb_default_identify_list_cn) / sizeof(php_mb_default_identify_list_cn[0]) },

{ mbfl_no_language_russian, php_mb_default_identify_list_ru, sizeof(php_mb_default_identify_list_ru) / sizeof(php_mb_default_identify_list_ru[0]) },

{ mbfl_no_language_armenian, php_mb_default_identify_list_hy, sizeof(php_mb_default_identify_list_hy) / sizeof(php_mb_default_identify_list_hy[0]) },

{ mbfl_no_language_turkish, php_mb_default_identify_list_tr, sizeof(php_mb_default_identify_list_tr) / sizeof(php_mb_default_identify_list_tr[0]) },

{ mbfl_no_language_ukrainian, php_mb_default_identify_list_ua, sizeof(php_mb_default_identify_list_ua) / sizeof(php_mb_default_identify_list_ua[0]) },

{ mbfl_no_language_neutral, php_mb_default_identify_list_neut, sizeof(php_mb_default_identify_list_neut) / sizeof(php_mb_default_identify_list_neut[0]) }

};

/* }}} */

/* {{{ mb_overload_def mb_ovld[] */

static const struct mb_overload_def mb_ovld[] = {

{MB_OVERLOAD_MAIL, "mail", "mb_send_mail", "mb_orig_mail"},

{MB_OVERLOAD_STRING, "strlen", "mb_strlen", "mb_orig_strlen"},

{MB_OVERLOAD_STRING, "strpos", "mb_strpos", "mb_orig_strpos"},

{MB_OVERLOAD_STRING, "strrpos", "mb_strrpos", "mb_orig_strrpos"},

{MB_OVERLOAD_STRING, "stripos", "mb_stripos", "mb_orig_stripos"},

{MB_OVERLOAD_STRING, "strripos", "mb_strripos", "mb_orig_strripos"},

{MB_OVERLOAD_STRING, "strstr", "mb_strstr", "mb_orig_strstr"},

{MB_OVERLOAD_STRING, "strrchr", "mb_strrchr", "mb_orig_strrchr"},

{MB_OVERLOAD_STRING, "stristr", "mb_stristr", "mb_orig_stristr"},

{MB_OVERLOAD_STRING, "substr", "mb_substr", "mb_orig_substr"},

{MB_OVERLOAD_STRING, "strtolower", "mb_strtolower", "mb_orig_strtolower"},

{MB_OVERLOAD_STRING, "strtoupper", "mb_strtoupper", "mb_orig_strtoupper"},

{MB_OVERLOAD_STRING, "substr_count", "mb_substr_count", "mb_orig_substr_count"},

{0, NULL, NULL, NULL}

};

/* }}} */

/* {{{ arginfo */

ZEND_BEGIN_ARG_INFO_EX(arginfo_mb_language, 0, 0, 0)

ZEND_ARG_INFO(0, language)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_mb_internal_encoding, 0, 0, 0)

ZEND_ARG_INFO(0, encoding)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_mb_http_input, 0, 0, 0)

ZEND_ARG_INFO(0, type)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_mb_http_output, 0, 0, 0)

ZEND_ARG_INFO(0, encoding)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_mb_detect_order, 0, 0, 0)

ZEND_ARG_INFO(0, encoding)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_mb_substitute_character, 0, 0, 0)

ZEND_ARG_INFO(0, substchar)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_mb_preferred_mime_name, 0, 0, 1)

ZEND_ARG_INFO(0, encoding)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_mb_parse_str, 0, 0, 1)

ZEND_ARG_INFO(0, encoded_string)

ZEND_ARG_INFO(1, result)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_mb_output_handler, 0, 0, 2)

ZEND_ARG_INFO(0, contents)

ZEND_ARG_INFO(0, status)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_mb_strlen, 0, 0, 1)

ZEND_ARG_INFO(0, str)

ZEND_ARG_INFO(0, encoding)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_mb_strpos, 0, 0, 2)

ZEND_ARG_INFO(0, haystack)

ZEND_ARG_INFO(0, needle)

ZEND_ARG_INFO(0, offset)

ZEND_ARG_INFO(0, encoding)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_mb_strrpos, 0, 0, 2)

ZEND_ARG_INFO(0, haystack)

ZEND_ARG_INFO(0, needle)

ZEND_ARG_INFO(0, offset)

ZEND_ARG_INFO(0, encoding)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_mb_stripos, 0, 0, 2)

ZEND_ARG_INFO(0, haystack)

ZEND_ARG_INFO(0, needle)

ZEND_ARG_INFO(0, offset)

ZEND_ARG_INFO(0, encoding)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_mb_strripos, 0, 0, 2)

ZEND_ARG_INFO(0, haystack)

ZEND_ARG_INFO(0, needle)

ZEND_ARG_INFO(0, offset)

ZEND_ARG_INFO(0, encoding)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_mb_strstr, 0, 0, 2)

ZEND_ARG_INFO(0, haystack)

ZEND_ARG_INFO(0, needle)

ZEND_ARG_INFO(0, part)

ZEND_ARG_INFO(0, encoding)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_mb_strrchr, 0, 0, 2)

ZEND_ARG_INFO(0, haystack)

ZEND_ARG_INFO(0, needle)

ZEND_ARG_INFO(0, part)

ZEND_ARG_INFO(0, encoding)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_mb_stristr, 0, 0, 2)

ZEND_ARG_INFO(0, haystack)

ZEND_ARG_INFO(0, needle)

ZEND_ARG_INFO(0, part)

ZEND_ARG_INFO(0, encoding)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_mb_strrichr, 0, 0, 2)

ZEND_ARG_INFO(0, haystack)

ZEND_ARG_INFO(0, needle)

ZEND_ARG_INFO(0, part)

ZEND_ARG_INFO(0, encoding)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_mb_substr_count, 0, 0, 2)

ZEND_ARG_INFO(0, haystack)

ZEND_ARG_INFO(0, needle)

ZEND_ARG_INFO(0, encoding)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_mb_substr, 0, 0, 2)

ZEND_ARG_INFO(0, str)

ZEND_ARG_INFO(0, start)

ZEND_ARG_INFO(0, length)

ZEND_ARG_INFO(0, encoding)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_mb_strcut, 0, 0, 2)

ZEND_ARG_INFO(0, str)

ZEND_ARG_INFO(0, start)

ZEND_ARG_INFO(0, length)

ZEND_ARG_INFO(0, encoding)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_mb_strwidth, 0, 0, 1)

ZEND_ARG_INFO(0, str)

ZEND_ARG_INFO(0, encoding)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_mb_strimwidth, 0, 0, 3)

ZEND_ARG_INFO(0, str)

ZEND_ARG_INFO(0, start)

ZEND_ARG_INFO(0, width)

ZEND_ARG_INFO(0, trimmarker)

ZEND_ARG_INFO(0, encoding)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_mb_convert_encoding, 0, 0, 2)

ZEND_ARG_INFO(0, str)

ZEND_ARG_INFO(0, to)

ZEND_ARG_INFO(0, from)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_mb_convert_case, 0, 0, 2)

ZEND_ARG_INFO(0, sourcestring)

ZEND_ARG_INFO(0, mode)

ZEND_ARG_INFO(0, encoding)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_mb_strtoupper, 0, 0, 1)

ZEND_ARG_INFO(0, sourcestring)

ZEND_ARG_INFO(0, encoding)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_mb_strtolower, 0, 0, 1)

ZEND_ARG_INFO(0, sourcestring)

ZEND_ARG_INFO(0, encoding)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_mb_detect_encoding, 0, 0, 1)

ZEND_ARG_INFO(0, str)

ZEND_ARG_INFO(0, encoding_list)

ZEND_ARG_INFO(0, strict)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_mb_list_encodings, 0)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_mb_encoding_aliases, 0, 0, 1)

ZEND_ARG_INFO(0, encoding)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_mb_encode_mimeheader, 0, 0, 1)

ZEND_ARG_INFO(0, str)

ZEND_ARG_INFO(0, charset)

ZEND_ARG_INFO(0, transfer)

ZEND_ARG_INFO(0, linefeed)

ZEND_ARG_INFO(0, indent)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_mb_decode_mimeheader, 0, 0, 1)

ZEND_ARG_INFO(0, string)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_mb_convert_kana, 0, 0, 1)

ZEND_ARG_INFO(0, str)

ZEND_ARG_INFO(0, option)

ZEND_ARG_INFO(0, encoding)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_mb_convert_variables, 0, 0, 3)

ZEND_ARG_INFO(0, to)

ZEND_ARG_INFO(0, from)

ZEND_ARG_VARIADIC_INFO(1, vars)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_mb_encode_numericentity, 0, 0, 2)

ZEND_ARG_INFO(0, string)

ZEND_ARG_INFO(0, convmap)

ZEND_ARG_INFO(0, encoding)

ZEND_ARG_INFO(0, is_hex)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_mb_decode_numericentity, 0, 0, 2)

ZEND_ARG_INFO(0, string)

ZEND_ARG_INFO(0, convmap)

ZEND_ARG_INFO(0, encoding)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_mb_send_mail, 0, 0, 3)

ZEND_ARG_INFO(0, to)

ZEND_ARG_INFO(0, subject)

ZEND_ARG_INFO(0, message)

ZEND_ARG_INFO(0, additional_headers)

ZEND_ARG_INFO(0, additional_parameters)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_mb_get_info, 0, 0, 0)

ZEND_ARG_INFO(0, type)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_mb_check_encoding, 0, 0, 0)

ZEND_ARG_INFO(0, var)

ZEND_ARG_INFO(0, encoding)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_mb_regex_encoding, 0, 0, 0)

ZEND_ARG_INFO(0, encoding)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_mb_ereg, 0, 0, 2)

ZEND_ARG_INFO(0, pattern)

ZEND_ARG_INFO(0, string)

ZEND_ARG_INFO(1, registers)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_mb_eregi, 0, 0, 2)

ZEND_ARG_INFO(0, pattern)

ZEND_ARG_INFO(0, string)

ZEND_ARG_INFO(1, registers)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_mb_ereg_replace, 0, 0, 3)

ZEND_ARG_INFO(0, pattern)

ZEND_ARG_INFO(0, replacement)

ZEND_ARG_INFO(0, string)

ZEND_ARG_INFO(0, option)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_mb_eregi_replace, 0, 0, 3)

ZEND_ARG_INFO(0, pattern)

ZEND_ARG_INFO(0, replacement)

ZEND_ARG_INFO(0, string)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_mb_ereg_replace_callback, 0, 0, 3)

ZEND_ARG_INFO(0, pattern)

ZEND_ARG_INFO(0, callback)

ZEND_ARG_INFO(0, string)

ZEND_ARG_INFO(0, option)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_mb_split, 0, 0, 2)

ZEND_ARG_INFO(0, pattern)

ZEND_ARG_INFO(0, string)

ZEND_ARG_INFO(0, limit)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_mb_ereg_match, 0, 0, 2)

ZEND_ARG_INFO(0, pattern)

ZEND_ARG_INFO(0, string)

ZEND_ARG_INFO(0, option)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_mb_ereg_search, 0, 0, 0)

ZEND_ARG_INFO(0, pattern)

ZEND_ARG_INFO(0, option)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_mb_ereg_search_pos, 0, 0, 0)

ZEND_ARG_INFO(0, pattern)

ZEND_ARG_INFO(0, option)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_mb_ereg_search_regs, 0, 0, 0)

ZEND_ARG_INFO(0, pattern)

ZEND_ARG_INFO(0, option)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_mb_ereg_search_init, 0, 0, 1)

ZEND_ARG_INFO(0, string)

ZEND_ARG_INFO(0, pattern)

ZEND_ARG_INFO(0, option)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_mb_ereg_search_getregs, 0)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_mb_ereg_search_getpos, 0)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_mb_ereg_search_setpos, 0, 0, 1)

ZEND_ARG_INFO(0, position)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_mb_regex_set_options, 0, 0, 0)

ZEND_ARG_INFO(0, options)

ZEND_END_ARG_INFO()

/* }}} */

/* {{{ zend_function_entry mbstring_functions[] */

const zend_function_entry mbstring_functions[] = {

PHP_FE(mb_convert_case, arginfo_mb_convert_case)

PHP_FE(mb_strtoupper, arginfo_mb_strtoupper)

PHP_FE(mb_strtolower, arginfo_mb_strtolower)

PHP_FE(mb_language, arginfo_mb_language)

PHP_FE(mb_internal_encoding, arginfo_mb_internal_encoding)

PHP_FE(mb_http_input, arginfo_mb_http_input)

PHP_FE(mb_http_output, arginfo_mb_http_output)

PHP_FE(mb_detect_order, arginfo_mb_detect_order)

PHP_FE(mb_substitute_character, arginfo_mb_substitute_character)

PHP_FE(mb_parse_str, arginfo_mb_parse_str)

PHP_FE(mb_output_handler, arginfo_mb_output_handler)

PHP_FE(mb_preferred_mime_name, arginfo_mb_preferred_mime_name)

PHP_FE(mb_strlen, arginfo_mb_strlen)

PHP_FE(mb_strpos, arginfo_mb_strpos)

PHP_FE(mb_strrpos, arginfo_mb_strrpos)

PHP_FE(mb_stripos, arginfo_mb_stripos)

PHP_FE(mb_strripos, arginfo_mb_strripos)

PHP_FE(mb_strstr, arginfo_mb_strstr)

PHP_FE(mb_strrchr, arginfo_mb_strrchr)

PHP_FE(mb_stristr, arginfo_mb_stristr)

PHP_FE(mb_strrichr, arginfo_mb_strrichr)

PHP_FE(mb_substr_count, arginfo_mb_substr_count)

PHP_FE(mb_substr, arginfo_mb_substr)

PHP_FE(mb_strcut, arginfo_mb_strcut)

PHP_FE(mb_strwidth, arginfo_mb_strwidth)

PHP_FE(mb_strimwidth, arginfo_mb_strimwidth)

PHP_FE(mb_convert_encoding, arginfo_mb_convert_encoding)

PHP_FE(mb_detect_encoding, arginfo_mb_detect_encoding)

PHP_FE(mb_list_encodings, arginfo_mb_list_encodings)

PHP_FE(mb_encoding_aliases, arginfo_mb_encoding_aliases)

PHP_FE(mb_convert_kana, arginfo_mb_convert_kana)

PHP_FE(mb_encode_mimeheader, arginfo_mb_encode_mimeheader)

PHP_FE(mb_decode_mimeheader, arginfo_mb_decode_mimeheader)

PHP_FE(mb_convert_variables, arginfo_mb_convert_variables)

PHP_FE(mb_encode_numericentity, arginfo_mb_encode_numericentity)

PHP_FE(mb_decode_numericentity, arginfo_mb_decode_numericentity)

PHP_FE(mb_send_mail, arginfo_mb_send_mail)

PHP_FE(mb_get_info, arginfo_mb_get_info)

PHP_FE(mb_check_encoding, arginfo_mb_check_encoding)

#if HAVE_MBREGEX

PHP_MBREGEX_FUNCTION_ENTRIES

#endif

PHP_FE_END

};

/* }}} */

/* {{{ zend_module_entry mbstring_module_entry */

zend_module_entry mbstring_module_entry = {

STANDARD_MODULE_HEADER,

"mbstring",

mbstring_functions,

PHP_MINIT(mbstring),

PHP_MSHUTDOWN(mbstring),

PHP_RINIT(mbstring),

PHP_RSHUTDOWN(mbstring),

PHP_MINFO(mbstring),

PHP_MBSTRING_VERSION,

PHP_MODULE_GLOBALS(mbstring),

PHP_GINIT(mbstring),

PHP_GSHUTDOWN(mbstring),

NULL,

STANDARD_MODULE_PROPERTIES_EX

};

/* }}} */

/* {{{ static sapi_post_entry php_post_entries[] */

static sapi_post_entry php_post_entries[] = {

{ DEFAULT_POST_CONTENT_TYPE, sizeof(DEFAULT_POST_CONTENT_TYPE)-1, sapi_read_standard_form_data, php_std_post_handler },

{ MULTIPART_CONTENT_TYPE, sizeof(MULTIPART_CONTENT_TYPE)-1, NULL, rfc1867_post_handler },

{ NULL, 0, NULL, NULL }

};

/* }}} */

#ifdef COMPILE_DL_MBSTRING

#ifdef ZTS

ZEND_TSRMLS_CACHE_DEFINE()

#endif

ZEND_GET_MODULE(mbstring)

#endif

static char *get_internal_encoding(void) {

if (PG(internal_encoding) && PG(internal_encoding)[0]) {

return PG(internal_encoding);

} else if (SG(default_charset)) {

return SG(default_charset);

}

return "";

}

static char *get_input_encoding(void) {

if (PG(input_encoding) && PG(input_encoding)[0]) {

return PG(input_encoding);

} else if (SG(default_charset)) {

return SG(default_charset);

}

return "";

}

static char *get_output_encoding(void) {

if (PG(output_encoding) && PG(output_encoding)[0]) {

return PG(output_encoding);

} else if (SG(default_charset)) {

return SG(default_charset);

}

return "";

}

/* {{{ allocators */

static void *_php_mb_allocators_malloc(unsigned int sz)

{

return emalloc(sz);

}

static void *_php_mb_allocators_realloc(void *ptr, unsigned int sz)

{

return erealloc(ptr, sz);

}

static void *_php_mb_allocators_calloc(unsigned int nelems, unsigned int szelem)

{

return ecalloc(nelems, szelem);

}

static void _php_mb_allocators_free(void *ptr)

{

efree(ptr);

}

static void *_php_mb_allocators_pmalloc(unsigned int sz)

{

return pemalloc(sz, 1);

}

static void *_php_mb_allocators_prealloc(void *ptr, unsigned int sz)

{

return perealloc(ptr, sz, 1);

}

static void _php_mb_allocators_pfree(void *ptr)

{

pefree(ptr, 1);

}

static mbfl_allocators _php_mb_allocators = {

_php_mb_allocators_malloc,

_php_mb_allocators_realloc,

_php_mb_allocators_calloc,

_php_mb_allocators_free,

_php_mb_allocators_pmalloc,

_php_mb_allocators_prealloc,

_php_mb_allocators_pfree

};

/* }}} */

/* {{{ static sapi_post_entry mbstr_post_entries[] */

static sapi_post_entry mbstr_post_entries[] = {

{ DEFAULT_POST_CONTENT_TYPE, sizeof(DEFAULT_POST_CONTENT_TYPE)-1, sapi_read_standard_form_data, php_mb_post_handler },

{ MULTIPART_CONTENT_TYPE, sizeof(MULTIPART_CONTENT_TYPE)-1, NULL, rfc1867_post_handler },

{ NULL, 0, NULL, NULL }

};

/* }}} */

/* {{{ static int php_mb_parse_encoding_list()

* Return 0 if input contains any illegal encoding, otherwise 1.

* Even if any illegal encoding is detected the result may contain a list

* of parsed encodings.

*/

static int

php_mb_parse_encoding_list(const char *value, size_t value_length, const mbfl_encoding ***return_list, size_t *return_size, int persistent)

{

int bauto, ret = SUCCESS;

size_t n, size;

char *p, *p1, *p2, *endp, *tmpstr;

const mbfl_encoding **entry, **list;

list = NULL;

if (value == NULL || value_length <= 0) {

if (return_list) {

*return_list = NULL;

}

if (return_size) {

*return_size = 0;

}

return FAILURE;

} else {

/* copy the value string for work */

if (value[0]=='"' && value[value_length-1]=='"' && value_length>2) {

tmpstr = (char *)estrndup(value+1, value_length-2);

value_length -= 2;

}

else

tmpstr = (char *)estrndup(value, value_length);

if (tmpstr == NULL) {

return FAILURE;

}

/* count the number of listed encoding names */

endp = tmpstr + value_length;

n = 1;

p1 = tmpstr;

while ((p2 = (char*)php_memnstr(p1, ",", 1, endp)) != NULL) {

p1 = p2 + 1;

n++;

}

size = n + MBSTRG(default_detect_order_list_size);

/* make list */

list = (const mbfl_encoding **)pecalloc(size, sizeof(mbfl_encoding*), persistent);

if (list != NULL) {

entry = list;

n = 0;

bauto = 0;

p1 = tmpstr;

do {

p2 = p = (char*)php_memnstr(p1, ",", 1, endp);

if (p == NULL) {

p = endp;

}

*p = '\0';

/* trim spaces */

while (p1 < p && (*p1 == ' ' || *p1 == '\t')) {

p1++;

}

p--;

while (p > p1 && (*p == ' ' || *p == '\t')) {

*p = '\0';

p--;

}

/* convert to the encoding number and check encoding */

if (strcasecmp(p1, "auto") == 0) {

if (!bauto) {

const enum mbfl_no_encoding *src = MBSTRG(default_detect_order_list);

const size_t identify_list_size = MBSTRG(default_detect_order_list_size);

size_t i;

bauto = 1;

for (i = 0; i < identify_list_size; i++) {

*entry++ = mbfl_no2encoding(*src++);

n++;

}

}

} else {

const mbfl_encoding *encoding = mbfl_name2encoding(p1);

if (encoding) {

*entry++ = encoding;

n++;

} else {

ret = 0;

}

}

p1 = p2 + 1;

} while (n < size && p2 != NULL);

if (n > 0) {

if (return_list) {

*return_list = list;

} else {

pefree(list, persistent);

}

} else {

pefree(list, persistent);

if (return_list) {

*return_list = NULL;

}

ret = 0;

}

if (return_size) {

*return_size = n;

}

} else {

if (return_list) {

*return_list = NULL;

}

if (return_size) {

*return_size = 0;

}

ret = 0;

}

efree(tmpstr);

}

return ret;

}

/* }}} */

/* {{{ static int php_mb_parse_encoding_array()

* Return 0 if input contains any illegal encoding, otherwise 1.

* Even if any illegal encoding is detected the result may contain a list

* of parsed encodings.

*/

static int

php_mb_parse_encoding_array(zval *array, const mbfl_encoding ***return_list, size_t *return_size, int persistent)

{

zval *hash_entry;

HashTable *target_hash;

int i, n, size, bauto, ret = SUCCESS;

const mbfl_encoding **list, **entry;

list = NULL;

if (Z_TYPE_P(array) == IS_ARRAY) {

target_hash = Z_ARRVAL_P(array);

i = zend_hash_num_elements(target_hash);

size = i + MBSTRG(default_detect_order_list_size);

list = (const mbfl_encoding **)pecalloc(size, sizeof(mbfl_encoding*), persistent);

if (list != NULL) {

entry = list;

bauto = 0;

n = 0;

ZEND_HASH_FOREACH_VAL(target_hash, hash_entry) {

convert_to_string_ex(hash_entry);

if (strcasecmp(Z_STRVAL_P(hash_entry), "auto") == 0) {

if (!bauto) {

const enum mbfl_no_encoding *src = MBSTRG(default_detect_order_list);

const size_t identify_list_size = MBSTRG(default_detect_order_list_size);

size_t j;

bauto = 1;

for (j = 0; j < identify_list_size; j++) {

*entry++ = mbfl_no2encoding(*src++);

n++;

}

}

} else {

const mbfl_encoding *encoding = mbfl_name2encoding(Z_STRVAL_P(hash_entry));

if (encoding) {

*entry++ = encoding;

n++;

} else {

ret = FAILURE;

}

}

i--;

} ZEND_HASH_FOREACH_END();

if (n > 0) {

if (return_list) {

*return_list = list;

} else {

pefree(list, persistent);

}

} else {

pefree(list, persistent);

if (return_list) {

*return_list = NULL;

}

ret = FAILURE;

}

if (return_size) {

*return_size = n;

}

} else {

if (return_list) {

*return_list = NULL;

}

if (return_size) {

*return_size = 0;

}

ret = FAILURE;

}

}

return ret;

}

/* }}} */

/* {{{ zend_multibyte interface */

static const zend_encoding* php_mb_zend_encoding_fetcher(const char *encoding_name)

{

return (const zend_encoding*)mbfl_name2encoding(encoding_name);

}

static const char *php_mb_zend_encoding_name_getter(const zend_encoding *encoding)

{

return ((const mbfl_encoding *)encoding)->name;

}

static int php_mb_zend_encoding_lexer_compatibility_checker(const zend_encoding *_encoding)

{

const mbfl_encoding *encoding = (const mbfl_encoding*)_encoding;

if (encoding->flag & MBFL_ENCTYPE_SBCS) {

return 1;

}

if ((encoding->flag & (MBFL_ENCTYPE_MBCS | MBFL_ENCTYPE_GL_UNSAFE)) == MBFL_ENCTYPE_MBCS) {

return 1;

}

return 0;

}

static const zend_encoding *php_mb_zend_encoding_detector(const unsigned char *arg_string, size_t arg_length, const zend_encoding **list, size_t list_size)

{

mbfl_string string;

if (!list) {

list = (const zend_encoding **)MBSTRG(current_detect_order_list);

list_size = MBSTRG(current_detect_order_list_size);

}

mbfl_string_init(&string);

string.no_language = MBSTRG(language);

string.val = (unsigned char *)arg_string;

string.len = arg_length;

return (const zend_encoding *) mbfl_identify_encoding2(&string, (const mbfl_encoding **)list, list_size, 0);

}

static size_t php_mb_zend_encoding_converter(unsigned char **to, size_t *to_length, const unsigned char *from, size_t from_length, const zend_encoding *encoding_to, const zend_encoding *encoding_from)

{

mbfl_string string, result;

mbfl_buffer_converter *convd;

int status, loc;

/* new encoding */

/* initialize string */

mbfl_string_init(&string);

mbfl_string_init(&result);

string.no_encoding = ((const mbfl_encoding*)encoding_from)->no_encoding;

string.no_language = MBSTRG(language);

string.val = (unsigned char*)from;

string.len = from_length;

/* initialize converter */

convd = mbfl_buffer_converter_new2((const mbfl_encoding *)encoding_from, (const mbfl_encoding *)encoding_to, string.len);

if (convd == NULL) {

return -1;

}

mbfl_buffer_converter_illegal_mode(convd, MBSTRG(current_filter_illegal_mode));

mbfl_buffer_converter_illegal_substchar(convd, MBSTRG(current_filter_illegal_substchar));

/* do it */

status = mbfl_buffer_converter_feed2(convd, &string, &loc);

if (status) {

mbfl_buffer_converter_delete(convd);

return (size_t)-1;

}

mbfl_buffer_converter_flush(convd);

if (!mbfl_buffer_converter_result(convd, &result)) {

mbfl_buffer_converter_delete(convd);

return (size_t)-1;

}

*to = result.val;

*to_length = result.len;

mbfl_buffer_converter_delete(convd);

return loc;

}

static int php_mb_zend_encoding_list_parser(const char *encoding_list, size_t encoding_list_len, const zend_encoding ***return_list, size_t *return_size, int persistent)

{

return php_mb_parse_encoding_list(encoding_list, encoding_list_len, (const mbfl_encoding ***)return_list, return_size, persistent);

}

static const zend_encoding *php_mb_zend_internal_encoding_getter(void)

{

return (const zend_encoding *)MBSTRG(internal_encoding);

}

static int php_mb_zend_internal_encoding_setter(const zend_encoding *encoding)

{

MBSTRG(internal_encoding) = (const mbfl_encoding *)encoding;

return SUCCESS;

}

static zend_multibyte_functions php_mb_zend_multibyte_functions = {

"mbstring",

php_mb_zend_encoding_fetcher,

php_mb_zend_encoding_name_getter,

php_mb_zend_encoding_lexer_compatibility_checker,

php_mb_zend_encoding_detector,

php_mb_zend_encoding_converter,

php_mb_zend_encoding_list_parser,

php_mb_zend_internal_encoding_getter,

php_mb_zend_internal_encoding_setter

};

/* }}} */

static void *_php_mb_compile_regex(const char *pattern);

static int _php_mb_match_regex(void *opaque, const char *str, size_t str_len);

static void _php_mb_free_regex(void *opaque);

#if HAVE_ONIG

/* {{{ _php_mb_compile_regex */

static void *_php_mb_compile_regex(const char *pattern)

{

php_mb_regex_t *retval;