From: Rui Hirokawa Date: Wed, 10 Apr 2002 12:47:41 +0000 (+0000) Subject: changed mbstring to make thread safe. X-Git-Tag: php-4.3.0dev-ZendEngine2-Preview1~742 X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=1f847267e729d6496fa1b491c6299afd45225c5c;p=php changed mbstring to make thread safe. --- diff --git a/ext/mbstring/CREDITS b/ext/mbstring/CREDITS index 14b6215f1d..e4af536087 100644 --- a/ext/mbstring/CREDITS +++ b/ext/mbstring/CREDITS @@ -1,2 +1,2 @@ Multibyte (Japanese) String Functions -Tsukada Takuya +Tsukada Takuya, Rui Hirokawa diff --git a/ext/mbstring/mbfilter.c b/ext/mbstring/mbfilter.c index 4bfb58f78d..0325aff170 100644 --- a/ext/mbstring/mbfilter.c +++ b/ext/mbstring/mbfilter.c @@ -82,6 +82,7 @@ /* $Id$ */ #include "php.h" +#include "php_globals.h" #include #include "mbfilter.h" @@ -743,95 +744,95 @@ static mbfl_encoding *mbfl_encoding_ptr_list[] = { }; /* forward */ -static void mbfl_filt_conv_common_ctor(mbfl_convert_filter *filter); -static int mbfl_filt_conv_common_flush(mbfl_convert_filter *filter); -static void mbfl_filt_conv_common_dtor(mbfl_convert_filter *filter); - -static int mbfl_filt_conv_pass(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_wchar_byte2be(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_byte2be_wchar(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_wchar_byte2le(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_byte2le_wchar(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_wchar_byte4be(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_byte4be_wchar(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_wchar_byte4le(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_byte4le_wchar(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_any_7bit(int c, mbfl_convert_filter *filter); - -static int mbfl_filt_conv_base64enc(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_base64enc_flush(mbfl_convert_filter *filter); -static int mbfl_filt_conv_base64dec(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_base64dec_flush(mbfl_convert_filter *filter); -static int mbfl_filt_conv_uudec(int c, mbfl_convert_filter *filter); - -static int mbfl_filt_conv_qprintenc(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_qprintenc_flush(mbfl_convert_filter *filter); -static int mbfl_filt_conv_qprintdec(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_qprintdec_flush(mbfl_convert_filter *filter); - -static int mbfl_filt_conv_ucs4_wchar(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_wchar_ucs4be(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_wchar_ucs4le(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_ucs2_wchar(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_wchar_ucs2be(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_wchar_ucs2le(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_utf16_wchar(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_utf16be_wchar(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_wchar_utf16be(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_utf16le_wchar(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_wchar_utf16le(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_utf8_wchar(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_wchar_utf8(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_utf7_wchar(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_wchar_utf7(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_wchar_utf7_flush(mbfl_convert_filter *filter); -static int mbfl_filt_conv_utf7imap_wchar(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_wchar_utf7imap(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_wchar_utf7imap_flush(mbfl_convert_filter *filter); -static int mbfl_filt_conv_wchar_ascii(int c, mbfl_convert_filter *filter); - -static int mbfl_filt_conv_wchar_cp1252(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_cp1252_wchar(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_wchar_8859_1(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_8859_2_wchar(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_wchar_8859_2(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_8859_3_wchar(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_wchar_8859_3(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_8859_4_wchar(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_wchar_8859_4(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_8859_5_wchar(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_wchar_8859_5(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_8859_6_wchar(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_wchar_8859_6(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_8859_7_wchar(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_wchar_8859_7(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_8859_8_wchar(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_wchar_8859_8(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_8859_9_wchar(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_wchar_8859_9(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_8859_10_wchar(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_wchar_8859_10(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_8859_13_wchar(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_wchar_8859_13(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_8859_14_wchar(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_wchar_8859_14(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_8859_15_wchar(int c, mbfl_convert_filter *filter); -static int mbfl_filt_conv_wchar_8859_15(int c, mbfl_convert_filter *filter); - -static void mbfl_filt_ident_common_ctor(mbfl_identify_filter *filter); -static void mbfl_filt_ident_common_dtor(mbfl_identify_filter *filter); -static void mbfl_filt_ident_false_ctor(mbfl_identify_filter *filter); -static int mbfl_filt_ident_utf8(int c, mbfl_identify_filter *filter); -static int mbfl_filt_ident_utf7(int c, mbfl_identify_filter *filter); -static int mbfl_filt_ident_ascii(int c, mbfl_identify_filter *filter); -static int mbfl_filt_ident_eucjp(int c, mbfl_identify_filter *filter); -static int mbfl_filt_ident_sjis(int c, mbfl_identify_filter *filter); -static int mbfl_filt_ident_sjiswin(int c, mbfl_identify_filter *filter); -static int mbfl_filt_ident_jis(int c, mbfl_identify_filter *filter); -static int mbfl_filt_ident_cp1252(int c, mbfl_identify_filter *filter); -static int mbfl_filt_ident_2022jp(int c, mbfl_identify_filter *filter); -static int mbfl_filt_ident_false(int c, mbfl_identify_filter *filter); -static int mbfl_filt_ident_true(int c, mbfl_identify_filter *filter); +static void mbfl_filt_conv_common_ctor(mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_common_flush(mbfl_convert_filter *filter TSRMLS_DC); +static void mbfl_filt_conv_common_dtor(mbfl_convert_filter *filter TSRMLS_DC); + +static int mbfl_filt_conv_pass(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_wchar_byte2be(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_byte2be_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_wchar_byte2le(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_byte2le_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_wchar_byte4be(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_byte4be_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_wchar_byte4le(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_byte4le_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_any_7bit(int c, mbfl_convert_filter *filter TSRMLS_DC); + +static int mbfl_filt_conv_base64enc(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_base64enc_flush(mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_base64dec(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_base64dec_flush(mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_uudec(int c, mbfl_convert_filter *filter TSRMLS_DC); + +static int mbfl_filt_conv_qprintenc(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_qprintenc_flush(mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_qprintdec(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_qprintdec_flush(mbfl_convert_filter *filter TSRMLS_DC); + +static int mbfl_filt_conv_ucs4_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_wchar_ucs4be(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_wchar_ucs4le(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_ucs2_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_wchar_ucs2be(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_wchar_ucs2le(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_utf16_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_utf16be_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_wchar_utf16be(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_utf16le_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_wchar_utf16le(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_utf8_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_wchar_utf8(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_utf7_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_wchar_utf7(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_wchar_utf7_flush(mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_utf7imap_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_wchar_utf7imap(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_wchar_utf7imap_flush(mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_wchar_ascii(int c, mbfl_convert_filter *filter TSRMLS_DC); + +static int mbfl_filt_conv_wchar_cp1252(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_cp1252_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_wchar_8859_1(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_8859_2_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_wchar_8859_2(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_8859_3_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_wchar_8859_3(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_8859_4_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_wchar_8859_4(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_8859_5_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_wchar_8859_5(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_8859_6_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_wchar_8859_6(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_8859_7_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_wchar_8859_7(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_8859_8_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_wchar_8859_8(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_8859_9_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_wchar_8859_9(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_8859_10_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_wchar_8859_10(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_8859_13_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_wchar_8859_13(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_8859_14_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_wchar_8859_14(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_8859_15_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC); +static int mbfl_filt_conv_wchar_8859_15(int c, mbfl_convert_filter *filter TSRMLS_DC); + +static void mbfl_filt_ident_common_ctor(mbfl_identify_filter *filter TSRMLS_DC); +static void mbfl_filt_ident_common_dtor(mbfl_identify_filter *filter TSRMLS_DC); +static void mbfl_filt_ident_false_ctor(mbfl_identify_filter *filter TSRMLS_DC); +static int mbfl_filt_ident_utf8(int c, mbfl_identify_filter *filter TSRMLS_DC); +static int mbfl_filt_ident_utf7(int c, mbfl_identify_filter *filter TSRMLS_DC); +static int mbfl_filt_ident_ascii(int c, mbfl_identify_filter *filter TSRMLS_DC); +static int mbfl_filt_ident_eucjp(int c, mbfl_identify_filter *filter TSRMLS_DC); +static int mbfl_filt_ident_sjis(int c, mbfl_identify_filter *filter TSRMLS_DC); +static int mbfl_filt_ident_sjiswin(int c, mbfl_identify_filter *filter TSRMLS_DC); +static int mbfl_filt_ident_jis(int c, mbfl_identify_filter *filter TSRMLS_DC); +static int mbfl_filt_ident_cp1252(int c, mbfl_identify_filter *filter TSRMLS_DC); +static int mbfl_filt_ident_2022jp(int c, mbfl_identify_filter *filter TSRMLS_DC); +static int mbfl_filt_ident_false(int c, mbfl_identify_filter *filter TSRMLS_DC); +static int mbfl_filt_ident_true(int c, mbfl_identify_filter *filter TSRMLS_DC); /* convert filter function table */ static struct mbfl_convert_vtbl vtbl_pass = { @@ -2014,7 +2015,7 @@ mbfl_is_support_encoding(const char *name) * memory device output functions */ void -mbfl_memory_device_init(mbfl_memory_device *device, int initsz, int allocsz) +mbfl_memory_device_init(mbfl_memory_device *device, int initsz, int allocsz TSRMLS_DC) { if (device) { device->length = 0; @@ -2035,7 +2036,7 @@ mbfl_memory_device_init(mbfl_memory_device *device, int initsz, int allocsz) } void -mbfl_memory_device_realloc(mbfl_memory_device *device, int initsz, int allocsz) +mbfl_memory_device_realloc(mbfl_memory_device *device, int initsz, int allocsz TSRMLS_DC) { unsigned char *tmp; @@ -2056,7 +2057,7 @@ mbfl_memory_device_realloc(mbfl_memory_device *device, int initsz, int allocsz) } void -mbfl_memory_device_clear(mbfl_memory_device *device) +mbfl_memory_device_clear(mbfl_memory_device *device TSRMLS_DC) { if (device) { if (device->buffer) { @@ -2069,7 +2070,7 @@ mbfl_memory_device_clear(mbfl_memory_device *device) } void -mbfl_memory_device_reset(mbfl_memory_device *device) +mbfl_memory_device_reset(mbfl_memory_device *device TSRMLS_DC) { if (device) { device->pos = 0; @@ -2077,7 +2078,7 @@ mbfl_memory_device_reset(mbfl_memory_device *device) } void -mbfl_memory_device_unput(mbfl_memory_device *device) +mbfl_memory_device_unput(mbfl_memory_device *device TSRMLS_DC) { if (device->pos > 0) { device->pos--; @@ -2085,11 +2086,11 @@ mbfl_memory_device_unput(mbfl_memory_device *device) } mbfl_string * -mbfl_memory_device_result(mbfl_memory_device *device, mbfl_string *result) +mbfl_memory_device_result(mbfl_memory_device *device, mbfl_string *result TSRMLS_DC) { if (device && result) { result->len = device->pos; - mbfl_memory_device_output4('\0', device); + mbfl_memory_device_output4('\0', device TSRMLS_CC); result->val = device->buffer; device->buffer = (unsigned char *)0; device->length = 0; @@ -2106,7 +2107,7 @@ mbfl_memory_device_result(mbfl_memory_device *device, mbfl_string *result) } int -mbfl_memory_device_output(int c, void *data) +mbfl_memory_device_output(int c, void *data TSRMLS_DC) { mbfl_memory_device *device = (mbfl_memory_device *)data; @@ -2129,7 +2130,7 @@ mbfl_memory_device_output(int c, void *data) } int -mbfl_memory_device_output2(int c, void *data) +mbfl_memory_device_output2(int c, void *data TSRMLS_DC) { mbfl_memory_device *device = (mbfl_memory_device *)data; @@ -2154,7 +2155,7 @@ mbfl_memory_device_output2(int c, void *data) } int -mbfl_memory_device_output4(int c, void* data) +mbfl_memory_device_output4(int c, void* data TSRMLS_DC) { mbfl_memory_device *device = (mbfl_memory_device *)data; @@ -2181,7 +2182,7 @@ mbfl_memory_device_output4(int c, void* data) } int -mbfl_memory_device_strcat(mbfl_memory_device *device, const char *psrc) +mbfl_memory_device_strcat(mbfl_memory_device *device, const char *psrc TSRMLS_DC) { int len; unsigned char *w; @@ -2217,7 +2218,7 @@ mbfl_memory_device_strcat(mbfl_memory_device *device, const char *psrc) } int -mbfl_memory_device_strncat(mbfl_memory_device *device, const char *psrc, int len) +mbfl_memory_device_strncat(mbfl_memory_device *device, const char *psrc, int len TSRMLS_DC) { unsigned char *w; @@ -2243,7 +2244,7 @@ mbfl_memory_device_strncat(mbfl_memory_device *device, const char *psrc, int len } int -mbfl_memory_device_devcat(mbfl_memory_device *dest, mbfl_memory_device *src) +mbfl_memory_device_devcat(mbfl_memory_device *dest, mbfl_memory_device *src TSRMLS_DC) { int n; unsigned char *p, *w; @@ -2272,7 +2273,7 @@ mbfl_memory_device_devcat(mbfl_memory_device *dest, mbfl_memory_device *src) } void -mbfl_wchar_device_init(mbfl_wchar_device *device) +mbfl_wchar_device_init(mbfl_wchar_device *device TSRMLS_DC) { if (device) { device->buffer = (unsigned int *)0; @@ -2283,7 +2284,7 @@ mbfl_wchar_device_init(mbfl_wchar_device *device) } void -mbfl_wchar_device_clear(mbfl_wchar_device *device) +mbfl_wchar_device_clear(mbfl_wchar_device *device TSRMLS_DC) { if (device) { if (device->buffer) { @@ -2296,7 +2297,7 @@ mbfl_wchar_device_clear(mbfl_wchar_device *device) } int -mbfl_wchar_device_output(int c, void *data) +mbfl_wchar_device_output(int c, void *data TSRMLS_DC) { mbfl_wchar_device *device = (mbfl_wchar_device *)data; @@ -2368,14 +2369,14 @@ mbfl_string_clear(mbfl_string *string) * commonly used constructor and destructor */ static void -mbfl_filt_conv_common_ctor(mbfl_convert_filter *filter) +mbfl_filt_conv_common_ctor(mbfl_convert_filter *filter TSRMLS_DC) { filter->status = 0; filter->cache = 0; } static int -mbfl_filt_conv_common_flush(mbfl_convert_filter *filter) +mbfl_filt_conv_common_flush(mbfl_convert_filter *filter TSRMLS_DC) { filter->status = 0; filter->cache = 0; @@ -2383,29 +2384,29 @@ mbfl_filt_conv_common_flush(mbfl_convert_filter *filter) } static void -mbfl_filt_conv_common_dtor(mbfl_convert_filter *filter) +mbfl_filt_conv_common_dtor(mbfl_convert_filter *filter TSRMLS_DC) { filter->status = 0; filter->cache = 0; } static int -mbfl_filt_conv_pass(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_pass(int c, mbfl_convert_filter *filter TSRMLS_DC) { - return (*filter->output_function)(c, filter->data); + return (*filter->output_function)(c, filter->data TSRMLS_CC); } static int -mbfl_filt_conv_any_7bit(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_any_7bit(int c, mbfl_convert_filter *filter TSRMLS_DC) { if (c >= 0 && c < 0x80) { - CK((*filter->output_function)(c, filter->data)); + CK((*filter->output_function)(c, filter->data TSRMLS_CC)); } return c; } static int -mbfl_filt_conv_byte2be_wchar(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_byte2be_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC) { int n; @@ -2416,21 +2417,21 @@ mbfl_filt_conv_byte2be_wchar(int c, mbfl_convert_filter *filter) } else { filter->status = 0; n = (c & 0xff) | filter->cache; - CK((*filter->output_function)(n, filter->data)); + CK((*filter->output_function)(n, filter->data TSRMLS_CC)); } return c; } static int -mbfl_filt_conv_wchar_byte2be(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_wchar_byte2be(int c, mbfl_convert_filter *filter TSRMLS_DC) { - CK((*filter->output_function)((c >> 8) & 0xff, filter->data)); - CK((*filter->output_function)(c & 0xff, filter->data)); + CK((*filter->output_function)((c >> 8) & 0xff, filter->data TSRMLS_CC)); + CK((*filter->output_function)(c & 0xff, filter->data TSRMLS_CC)); return c; } static int -mbfl_filt_conv_byte2le_wchar(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_byte2le_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC) { int n; @@ -2441,21 +2442,21 @@ mbfl_filt_conv_byte2le_wchar(int c, mbfl_convert_filter *filter) } else { filter->status = 0; n = ((c & 0xff) << 8) | filter->cache; - CK((*filter->output_function)(n, filter->data)); + CK((*filter->output_function)(n, filter->data TSRMLS_CC)); } return c; } static int -mbfl_filt_conv_wchar_byte2le(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_wchar_byte2le(int c, mbfl_convert_filter *filter TSRMLS_DC) { - CK((*filter->output_function)(c & 0xff, filter->data)); - CK((*filter->output_function)((c >> 8) & 0xff, filter->data)); + CK((*filter->output_function)(c & 0xff, filter->data TSRMLS_CC)); + CK((*filter->output_function)((c >> 8) & 0xff, filter->data TSRMLS_CC)); return c; } static int -mbfl_filt_conv_byte4be_wchar(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_byte4be_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC) { int n; @@ -2474,23 +2475,23 @@ mbfl_filt_conv_byte4be_wchar(int c, mbfl_convert_filter *filter) } else { filter->status = 0; n = (c & 0xff) | filter->cache; - CK((*filter->output_function)(n, filter->data)); + CK((*filter->output_function)(n, filter->data TSRMLS_CC)); } return c; } static int -mbfl_filt_conv_wchar_byte4be(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_wchar_byte4be(int c, mbfl_convert_filter *filter TSRMLS_DC) { - CK((*filter->output_function)((c >> 24) & 0xff, filter->data)); - CK((*filter->output_function)((c >> 16) & 0xff, filter->data)); - CK((*filter->output_function)((c >> 8) & 0xff, filter->data)); - CK((*filter->output_function)(c & 0xff, filter->data)); + CK((*filter->output_function)((c >> 24) & 0xff, filter->data TSRMLS_CC)); + CK((*filter->output_function)((c >> 16) & 0xff, filter->data TSRMLS_CC)); + CK((*filter->output_function)((c >> 8) & 0xff, filter->data TSRMLS_CC)); + CK((*filter->output_function)(c & 0xff, filter->data TSRMLS_CC)); return c; } static int -mbfl_filt_conv_byte4le_wchar(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_byte4le_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC) { int n; @@ -2509,18 +2510,18 @@ mbfl_filt_conv_byte4le_wchar(int c, mbfl_convert_filter *filter) } else { filter->status = 0; n = ((c & 0xff) << 24) | filter->cache; - CK((*filter->output_function)(n, filter->data)); + CK((*filter->output_function)(n, filter->data TSRMLS_CC)); } return c; } static int -mbfl_filt_conv_wchar_byte4le(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_wchar_byte4le(int c, mbfl_convert_filter *filter TSRMLS_DC) { - CK((*filter->output_function)(c & 0xff, filter->data)); - CK((*filter->output_function)((c >> 8) & 0xff, filter->data)); - CK((*filter->output_function)((c >> 16) & 0xff, filter->data)); - CK((*filter->output_function)((c >> 24) & 0xff, filter->data)); + CK((*filter->output_function)(c & 0xff, filter->data TSRMLS_CC)); + CK((*filter->output_function)((c >> 8) & 0xff, filter->data TSRMLS_CC)); + CK((*filter->output_function)((c >> 16) & 0xff, filter->data TSRMLS_CC)); + CK((*filter->output_function)((c >> 24) & 0xff, filter->data TSRMLS_CC)); return c; } @@ -2533,7 +2534,7 @@ enum { uudec_state_ground=0, uudec_state_inbegin, uudec_state_size, uudec_state_a, uudec_state_b, uudec_state_c, uudec_state_d, uudec_state_skip_newline}; static int -mbfl_filt_conv_uudec(int c, mbfl_convert_filter * filter) +mbfl_filt_conv_uudec(int c, mbfl_convert_filter * filter TSRMLS_DC) { int n; @@ -2600,11 +2601,11 @@ mbfl_filt_conv_uudec(int c, mbfl_convert_filter * filter) C = (filter->cache) & 0xff; n = (filter->cache >> 24) & 0xff; if (n-- > 0) - CK((*filter->output_function)( (A << 2) | (B >> 4), filter->data)); + CK((*filter->output_function)( (A << 2) | (B >> 4), filter->data TSRMLS_CC)); if (n-- > 0) - CK((*filter->output_function)( (B << 4) | (C >> 2), filter->data)); + CK((*filter->output_function)( (B << 4) | (C >> 2), filter->data TSRMLS_CC)); if (n-- > 0) - CK((*filter->output_function)( (C << 6) | D, filter->data)); + CK((*filter->output_function)( (C << 6) | D, filter->data TSRMLS_CC)); filter->cache = n << 24; if (n == 0) @@ -2640,7 +2641,7 @@ static const unsigned char mbfl_base64_table[] = #define MBFL_BASE64_STS_MIME_HEADER 0x1000000 static int -mbfl_filt_conv_base64enc(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_base64enc(int c, mbfl_convert_filter *filter TSRMLS_DC) { int n; @@ -2656,24 +2657,24 @@ mbfl_filt_conv_base64enc(int c, mbfl_convert_filter *filter) if ((filter->status & MBFL_BASE64_STS_MIME_HEADER) == 0) { n = (filter->status & 0xff00) >> 8; if (n > 72) { - CK((*filter->output_function)(0x0d, filter->data)); /* CR */ - CK((*filter->output_function)(0x0a, filter->data)); /* LF */ + CK((*filter->output_function)(0x0d, filter->data TSRMLS_CC)); /* CR */ + CK((*filter->output_function)(0x0a, filter->data TSRMLS_CC)); /* LF */ filter->status &= ~0xff00; } filter->status += 0x400; } n = filter->cache | (c & 0xff); - CK((*filter->output_function)(mbfl_base64_table[(n >> 18) & 0x3f], filter->data)); - CK((*filter->output_function)(mbfl_base64_table[(n >> 12) & 0x3f], filter->data)); - CK((*filter->output_function)(mbfl_base64_table[(n >> 6) & 0x3f], filter->data)); - CK((*filter->output_function)(mbfl_base64_table[n & 0x3f], filter->data)); + CK((*filter->output_function)(mbfl_base64_table[(n >> 18) & 0x3f], filter->data TSRMLS_CC)); + CK((*filter->output_function)(mbfl_base64_table[(n >> 12) & 0x3f], filter->data TSRMLS_CC)); + CK((*filter->output_function)(mbfl_base64_table[(n >> 6) & 0x3f], filter->data TSRMLS_CC)); + CK((*filter->output_function)(mbfl_base64_table[n & 0x3f], filter->data TSRMLS_CC)); } return c; } static int -mbfl_filt_conv_base64enc_flush(mbfl_convert_filter *filter) +mbfl_filt_conv_base64enc_flush(mbfl_convert_filter *filter TSRMLS_DC) { int status, cache, len; @@ -2686,18 +2687,18 @@ mbfl_filt_conv_base64enc_flush(mbfl_convert_filter *filter) if (status >= 1) { if ((filter->status & MBFL_BASE64_STS_MIME_HEADER) == 0) { if (len > 72){ - CK((*filter->output_function)(0x0d, filter->data)); /* CR */ - CK((*filter->output_function)(0x0a, filter->data)); /* LF */ + CK((*filter->output_function)(0x0d, filter->data TSRMLS_CC)); /* CR */ + CK((*filter->output_function)(0x0a, filter->data TSRMLS_CC)); /* LF */ } } - CK((*filter->output_function)(mbfl_base64_table[(cache >> 18) & 0x3f], filter->data)); - CK((*filter->output_function)(mbfl_base64_table[(cache >> 12) & 0x3f], filter->data)); + CK((*filter->output_function)(mbfl_base64_table[(cache >> 18) & 0x3f], filter->data TSRMLS_CC)); + CK((*filter->output_function)(mbfl_base64_table[(cache >> 12) & 0x3f], filter->data TSRMLS_CC)); if (status == 1) { - CK((*filter->output_function)(0x3d, filter->data)); /* '=' */ - CK((*filter->output_function)(0x3d, filter->data)); /* '=' */ + CK((*filter->output_function)(0x3d, filter->data TSRMLS_CC)); /* '=' */ + CK((*filter->output_function)(0x3d, filter->data TSRMLS_CC)); /* '=' */ } else { - CK((*filter->output_function)(mbfl_base64_table[(cache >> 6) & 0x3f], filter->data)); - CK((*filter->output_function)(0x3d, filter->data)); /* '=' */ + CK((*filter->output_function)(mbfl_base64_table[(cache >> 6) & 0x3f], filter->data TSRMLS_CC)); + CK((*filter->output_function)(0x3d, filter->data TSRMLS_CC)); /* '=' */ } } return 0; @@ -2707,7 +2708,7 @@ mbfl_filt_conv_base64enc_flush(mbfl_convert_filter *filter) * BASE64 => any */ static int -mbfl_filt_conv_base64dec(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_base64dec(int c, mbfl_convert_filter *filter TSRMLS_DC) { int n; @@ -2745,9 +2746,9 @@ mbfl_filt_conv_base64dec(int c, mbfl_convert_filter *filter) default: filter->status = 0; n |= filter->cache; - CK((*filter->output_function)((n >> 16) & 0xff, filter->data)); - CK((*filter->output_function)((n >> 8) & 0xff, filter->data)); - CK((*filter->output_function)(n & 0xff, filter->data)); + CK((*filter->output_function)((n >> 16) & 0xff, filter->data TSRMLS_CC)); + CK((*filter->output_function)((n >> 8) & 0xff, filter->data TSRMLS_CC)); + CK((*filter->output_function)(n & 0xff, filter->data TSRMLS_CC)); break; } @@ -2755,7 +2756,7 @@ mbfl_filt_conv_base64dec(int c, mbfl_convert_filter *filter) } static int -mbfl_filt_conv_base64dec_flush(mbfl_convert_filter *filter) +mbfl_filt_conv_base64dec_flush(mbfl_convert_filter *filter TSRMLS_DC) { int status, cache; @@ -2765,9 +2766,9 @@ mbfl_filt_conv_base64dec_flush(mbfl_convert_filter *filter) filter->cache = 0; /* flush fragments */ if (status >= 2) { - CK((*filter->output_function)((cache >> 16) & 0xff, filter->data)); + CK((*filter->output_function)((cache >> 16) & 0xff, filter->data TSRMLS_CC)); if (status >= 3) { - CK((*filter->output_function)((cache >> 8) & 0xff, filter->data)); + CK((*filter->output_function)((cache >> 8) & 0xff, filter->data TSRMLS_CC)); } } return 0; @@ -2779,7 +2780,7 @@ mbfl_filt_conv_base64dec_flush(mbfl_convert_filter *filter) #define MBFL_QPRINT_STS_MIME_HEADER 0x1000000 static int -mbfl_filt_conv_qprintenc(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_qprintenc(int c, mbfl_convert_filter *filter TSRMLS_DC) { int s, n; @@ -2794,15 +2795,15 @@ mbfl_filt_conv_qprintenc(int c, mbfl_convert_filter *filter) n = (filter->status & 0xff00) >> 8; if (s == 0) { /* null */ - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); filter->status &= ~0xff00; break; } if ((filter->status & MBFL_QPRINT_STS_MIME_HEADER) == 0) { if (s == 0x0a || (s == 0x0d && c != 0x0a)) { /* line feed */ - CK((*filter->output_function)(0x0d, filter->data)); /* CR */ - CK((*filter->output_function)(0x0a, filter->data)); /* LF */ + CK((*filter->output_function)(0x0d, filter->data TSRMLS_CC)); /* CR */ + CK((*filter->output_function)(0x0a, filter->data TSRMLS_CC)); /* LF */ filter->status &= ~0xff00; break; } else if (s == 0x0d) { @@ -2811,9 +2812,9 @@ mbfl_filt_conv_qprintenc(int c, mbfl_convert_filter *filter) } if ((filter->status & MBFL_QPRINT_STS_MIME_HEADER) == 0 && n >= 72) { /* soft line feed */ - CK((*filter->output_function)(0x3d, filter->data)); /* '=' */ - CK((*filter->output_function)(0x0d, filter->data)); /* CR */ - CK((*filter->output_function)(0x0a, filter->data)); /* LF */ + CK((*filter->output_function)(0x3d, filter->data TSRMLS_CC)); /* '=' */ + CK((*filter->output_function)(0x0d, filter->data TSRMLS_CC)); /* CR */ + CK((*filter->output_function)(0x0a, filter->data TSRMLS_CC)); /* LF */ filter->status &= ~0xff00; } @@ -2821,26 +2822,26 @@ mbfl_filt_conv_qprintenc(int c, mbfl_convert_filter *filter) || ((filter->status & MBFL_QPRINT_STS_MIME_HEADER) != 0 && (mbfl_charprop_table[s] & MBFL_CHP_MMHQENC) != 0)) { /* hex-octet */ - CK((*filter->output_function)(0x3d, filter->data)); /* '=' */ + CK((*filter->output_function)(0x3d, filter->data TSRMLS_CC)); /* '=' */ n = (s >> 4) & 0xf; if (n < 10) { n += 48; /* '0' */ } else { n += 55; /* 'A' - 10 */ } - CK((*filter->output_function)(n, filter->data)); + CK((*filter->output_function)(n, filter->data TSRMLS_CC)); n = s & 0xf; if (n < 10) { n += 48; } else { n += 55; } - CK((*filter->output_function)(n, filter->data)); + CK((*filter->output_function)(n, filter->data TSRMLS_CC)); if ((filter->status & MBFL_QPRINT_STS_MIME_HEADER) == 0) { filter->status += 0x300; } } else { - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); if ((filter->status & MBFL_QPRINT_STS_MIME_HEADER) == 0) { filter->status += 0x100; } @@ -2852,10 +2853,10 @@ mbfl_filt_conv_qprintenc(int c, mbfl_convert_filter *filter) } static int -mbfl_filt_conv_qprintenc_flush(mbfl_convert_filter *filter) +mbfl_filt_conv_qprintenc_flush(mbfl_convert_filter *filter TSRMLS_DC) { /* flush filter cache */ - (*filter->filter_function)('\0', filter); + (*filter->filter_function)('\0', filter TSRMLS_CC); filter->status &= ~0xffff; filter->cache = 0; return 0; @@ -2865,7 +2866,7 @@ mbfl_filt_conv_qprintenc_flush(mbfl_convert_filter *filter) * Quoted-Printable => any */ static int -mbfl_filt_conv_qprintdec(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_qprintdec(int c, mbfl_convert_filter *filter TSRMLS_DC) { int n; @@ -2879,8 +2880,8 @@ mbfl_filt_conv_qprintdec(int c, mbfl_convert_filter *filter) } else if (c == 0x0a) { /* soft line feed */ filter->status = 0; } else { - CK((*filter->output_function)(0x3d, filter->data)); /* '=' */ - CK((*filter->output_function)(c, filter->data)); + CK((*filter->output_function)(0x3d, filter->data TSRMLS_CC)); /* '=' */ + CK((*filter->output_function)(c, filter->data TSRMLS_CC)); filter->status = 0; } break; @@ -2897,16 +2898,16 @@ mbfl_filt_conv_qprintdec(int c, mbfl_convert_filter *filter) } else if (c >= 0x41 && c <= 0x46) { /* 'A' - 'F' */ n += (c - 55); } else { - CK((*filter->output_function)(0x3d, filter->data)); /* '=' */ - CK((*filter->output_function)(filter->cache, filter->data)); + CK((*filter->output_function)(0x3d, filter->data TSRMLS_CC)); /* '=' */ + CK((*filter->output_function)(filter->cache, filter->data TSRMLS_CC)); n = c; } - CK((*filter->output_function)(n, filter->data)); + CK((*filter->output_function)(n, filter->data TSRMLS_CC)); filter->status = 0; break; case 3: if (c != 0x0a) { /* LF */ - CK((*filter->output_function)(c, filter->data)); + CK((*filter->output_function)(c, filter->data TSRMLS_CC)); } filter->status = 0; break; @@ -2914,7 +2915,7 @@ mbfl_filt_conv_qprintdec(int c, mbfl_convert_filter *filter) if (c == 0x3d) { /* '=' */ filter->status = 1; } else { - CK((*filter->output_function)(c, filter->data)); + CK((*filter->output_function)(c, filter->data TSRMLS_CC)); } break; } @@ -2923,7 +2924,7 @@ mbfl_filt_conv_qprintdec(int c, mbfl_convert_filter *filter) } static int -mbfl_filt_conv_qprintdec_flush(mbfl_convert_filter *filter) +mbfl_filt_conv_qprintdec_flush(mbfl_convert_filter *filter TSRMLS_DC) { int status, cache; @@ -2933,10 +2934,10 @@ mbfl_filt_conv_qprintdec_flush(mbfl_convert_filter *filter) filter->cache = 0; /* flush fragments */ if (status == 1) { - CK((*filter->output_function)(0x3d, filter->data)); /* '=' */ + CK((*filter->output_function)(0x3d, filter->data TSRMLS_CC)); /* '=' */ } else if (status == 2) { - CK((*filter->output_function)(0x3d, filter->data)); /* '=' */ - CK((*filter->output_function)(cache, filter->data)); + CK((*filter->output_function)(0x3d, filter->data TSRMLS_CC)); /* '=' */ + CK((*filter->output_function)(cache, filter->data TSRMLS_CC)); } return 0; @@ -2947,7 +2948,7 @@ mbfl_filt_conv_qprintdec_flush(mbfl_convert_filter *filter) * UCS-4 => wchar */ static int -mbfl_filt_conv_ucs4_wchar(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_ucs4_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC) { int n, endian; @@ -2993,10 +2994,10 @@ mbfl_filt_conv_ucs4_wchar(int c, mbfl_convert_filter *filter) } else { filter->status = 0x100; /* little-endian */ } - CK((*filter->output_function)(0xfeff, filter->data)); + CK((*filter->output_function)(0xfeff, filter->data TSRMLS_CC)); } else { filter->status &= ~0xff; - CK((*filter->output_function)(n, filter->data)); + CK((*filter->output_function)(n, filter->data TSRMLS_CC)); } break; } @@ -3008,16 +3009,16 @@ mbfl_filt_conv_ucs4_wchar(int c, mbfl_convert_filter *filter) * wchar => UCS-4BE */ static int -mbfl_filt_conv_wchar_ucs4be(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_wchar_ucs4be(int c, mbfl_convert_filter *filter TSRMLS_DC) { if (c >= 0 && c < MBFL_WCSGROUP_UCS4MAX) { - CK((*filter->output_function)((c >> 24) & 0xff, filter->data)); - CK((*filter->output_function)((c >> 16) & 0xff, filter->data)); - CK((*filter->output_function)((c >> 8) & 0xff, filter->data)); - CK((*filter->output_function)(c & 0xff, filter->data)); + CK((*filter->output_function)((c >> 24) & 0xff, filter->data TSRMLS_CC)); + CK((*filter->output_function)((c >> 16) & 0xff, filter->data TSRMLS_CC)); + CK((*filter->output_function)((c >> 8) & 0xff, filter->data TSRMLS_CC)); + CK((*filter->output_function)(c & 0xff, filter->data TSRMLS_CC)); } else { if (filter->illegal_mode != MBFL_OUTPUTFILTER_ILLEGAL_MODE_NONE) { - CK(mbfl_filt_conv_illegal_output(c, filter)); + CK(mbfl_filt_conv_illegal_output(c, filter TSRMLS_CC)); } } @@ -3028,16 +3029,16 @@ mbfl_filt_conv_wchar_ucs4be(int c, mbfl_convert_filter *filter) * wchar => UCS-4LE */ static int -mbfl_filt_conv_wchar_ucs4le(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_wchar_ucs4le(int c, mbfl_convert_filter *filter TSRMLS_DC) { if (c >= 0 && c < MBFL_WCSGROUP_UCS4MAX) { - CK((*filter->output_function)(c & 0xff, filter->data)); - CK((*filter->output_function)((c >> 8) & 0xff, filter->data)); - CK((*filter->output_function)((c >> 16) & 0xff, filter->data)); - CK((*filter->output_function)((c >> 24) & 0xff, filter->data)); + CK((*filter->output_function)(c & 0xff, filter->data TSRMLS_CC)); + CK((*filter->output_function)((c >> 8) & 0xff, filter->data TSRMLS_CC)); + CK((*filter->output_function)((c >> 16) & 0xff, filter->data TSRMLS_CC)); + CK((*filter->output_function)((c >> 24) & 0xff, filter->data TSRMLS_CC)); } else { if (filter->illegal_mode != MBFL_OUTPUTFILTER_ILLEGAL_MODE_NONE) { - CK(mbfl_filt_conv_illegal_output(c, filter)); + CK(mbfl_filt_conv_illegal_output(c, filter TSRMLS_CC)); } } @@ -3048,7 +3049,7 @@ mbfl_filt_conv_wchar_ucs4le(int c, mbfl_convert_filter *filter) * UCS-2 => wchar */ static int -mbfl_filt_conv_ucs2_wchar(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_ucs2_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC) { int n, endian; @@ -3076,10 +3077,10 @@ mbfl_filt_conv_ucs2_wchar(int c, mbfl_convert_filter *filter) } else { filter->status = 0x100; /* little-endian */ } - CK((*filter->output_function)(0xfeff, filter->data)); + CK((*filter->output_function)(0xfeff, filter->data TSRMLS_CC)); } else { filter->status &= ~0xff; - CK((*filter->output_function)(n, filter->data)); + CK((*filter->output_function)(n, filter->data TSRMLS_CC)); } break; } @@ -3091,14 +3092,14 @@ mbfl_filt_conv_ucs2_wchar(int c, mbfl_convert_filter *filter) * wchar => UCS-2BE */ static int -mbfl_filt_conv_wchar_ucs2be(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_wchar_ucs2be(int c, mbfl_convert_filter *filter TSRMLS_DC) { if (c >= 0 && c < MBFL_WCSPLANE_UCS2MAX) { - CK((*filter->output_function)((c >> 8) & 0xff, filter->data)); - CK((*filter->output_function)(c & 0xff, filter->data)); + CK((*filter->output_function)((c >> 8) & 0xff, filter->data TSRMLS_CC)); + CK((*filter->output_function)(c & 0xff, filter->data TSRMLS_CC)); } else { if (filter->illegal_mode != MBFL_OUTPUTFILTER_ILLEGAL_MODE_NONE) { - CK(mbfl_filt_conv_illegal_output(c, filter)); + CK(mbfl_filt_conv_illegal_output(c, filter TSRMLS_CC)); } } @@ -3109,14 +3110,14 @@ mbfl_filt_conv_wchar_ucs2be(int c, mbfl_convert_filter *filter) * wchar => UCS-2LE */ static int -mbfl_filt_conv_wchar_ucs2le(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_wchar_ucs2le(int c, mbfl_convert_filter *filter TSRMLS_DC) { if (c >= 0 && c < MBFL_WCSPLANE_UCS2MAX) { - CK((*filter->output_function)(c & 0xff, filter->data)); - CK((*filter->output_function)((c >> 8) & 0xff, filter->data)); + CK((*filter->output_function)(c & 0xff, filter->data TSRMLS_CC)); + CK((*filter->output_function)((c >> 8) & 0xff, filter->data TSRMLS_CC)); } else { if (filter->illegal_mode != MBFL_OUTPUTFILTER_ILLEGAL_MODE_NONE) { - CK(mbfl_filt_conv_illegal_output(c, filter)); + CK(mbfl_filt_conv_illegal_output(c, filter TSRMLS_CC)); } } @@ -3128,7 +3129,7 @@ mbfl_filt_conv_wchar_ucs2le(int c, mbfl_convert_filter *filter) * UTF-16 => wchar */ static int -mbfl_filt_conv_utf16_wchar(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_utf16_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC) { int n, endian; @@ -3157,7 +3158,7 @@ mbfl_filt_conv_utf16_wchar(int c, mbfl_convert_filter *filter) } else { filter->status = 0x100; /* little-endian */ } - CK((*filter->output_function)(0xfeff, filter->data)); + CK((*filter->output_function)(0xfeff, filter->data TSRMLS_CC)); } else if (n >= 0xd800 && n < 0xdc00) { filter->cache = ((n & 0x3ff) << 16) + 0x400000; } else if (n >= 0xdc00 && n < 0xe000) { @@ -3165,15 +3166,15 @@ mbfl_filt_conv_utf16_wchar(int c, mbfl_convert_filter *filter) n |= (filter->cache & 0xfff0000) >> 6; filter->cache = 0; if (n >= MBFL_WCSPLANE_SUPMIN && n < MBFL_WCSPLANE_SUPMAX) { - CK((*filter->output_function)(n, filter->data)); + CK((*filter->output_function)(n, filter->data TSRMLS_CC)); } else { /* illegal character */ n &= MBFL_WCSGROUP_MASK; n |= MBFL_WCSGROUP_THROUGH; - CK((*filter->output_function)(n, filter->data)); + CK((*filter->output_function)(n, filter->data TSRMLS_CC)); } } else { filter->cache = 0; - CK((*filter->output_function)(n, filter->data)); + CK((*filter->output_function)(n, filter->data TSRMLS_CC)); } break; } @@ -3185,7 +3186,7 @@ mbfl_filt_conv_utf16_wchar(int c, mbfl_convert_filter *filter) * UTF-16BE => wchar */ static int -mbfl_filt_conv_utf16be_wchar(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_utf16be_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC) { int n; @@ -3205,15 +3206,15 @@ mbfl_filt_conv_utf16be_wchar(int c, mbfl_convert_filter *filter) n |= (filter->cache & 0xfff0000) >> 6; filter->cache = 0; if (n >= MBFL_WCSPLANE_SUPMIN && n < MBFL_WCSPLANE_SUPMAX) { - CK((*filter->output_function)(n, filter->data)); + CK((*filter->output_function)(n, filter->data TSRMLS_CC)); } else { /* illegal character */ n &= MBFL_WCSGROUP_MASK; n |= MBFL_WCSGROUP_THROUGH; - CK((*filter->output_function)(n, filter->data)); + CK((*filter->output_function)(n, filter->data TSRMLS_CC)); } } else { filter->cache = 0; - CK((*filter->output_function)(n, filter->data)); + CK((*filter->output_function)(n, filter->data TSRMLS_CC)); } break; } @@ -3225,23 +3226,23 @@ mbfl_filt_conv_utf16be_wchar(int c, mbfl_convert_filter *filter) * wchar => UTF-16BE */ static int -mbfl_filt_conv_wchar_utf16be(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_wchar_utf16be(int c, mbfl_convert_filter *filter TSRMLS_DC) { int n; if (c >= 0 && c < MBFL_WCSPLANE_UCS2MAX) { - CK((*filter->output_function)((c >> 8) & 0xff, filter->data)); - CK((*filter->output_function)(c & 0xff, filter->data)); + CK((*filter->output_function)((c >> 8) & 0xff, filter->data TSRMLS_CC)); + CK((*filter->output_function)(c & 0xff, filter->data TSRMLS_CC)); } else if (c >= MBFL_WCSPLANE_SUPMIN && c < MBFL_WCSPLANE_SUPMAX) { n = ((c >> 10) - 0x40) | 0xd800; - CK((*filter->output_function)((n >> 8) & 0xff, filter->data)); - CK((*filter->output_function)(n & 0xff, filter->data)); + CK((*filter->output_function)((n >> 8) & 0xff, filter->data TSRMLS_CC)); + CK((*filter->output_function)(n & 0xff, filter->data TSRMLS_CC)); n = (c & 0x3ff) | 0xdc00; - CK((*filter->output_function)((n >> 8) & 0xff, filter->data)); - CK((*filter->output_function)(n & 0xff, filter->data)); + CK((*filter->output_function)((n >> 8) & 0xff, filter->data TSRMLS_CC)); + CK((*filter->output_function)(n & 0xff, filter->data TSRMLS_CC)); } else { if (filter->illegal_mode != MBFL_OUTPUTFILTER_ILLEGAL_MODE_NONE) { - CK(mbfl_filt_conv_illegal_output(c, filter)); + CK(mbfl_filt_conv_illegal_output(c, filter TSRMLS_CC)); } } @@ -3252,7 +3253,7 @@ mbfl_filt_conv_wchar_utf16be(int c, mbfl_convert_filter *filter) * UTF-16LE => wchar */ static int -mbfl_filt_conv_utf16le_wchar(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_utf16le_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC) { int n; @@ -3272,15 +3273,15 @@ mbfl_filt_conv_utf16le_wchar(int c, mbfl_convert_filter *filter) n |= (filter->cache & 0xfff0000) >> 6; filter->cache = 0; if (n >= MBFL_WCSPLANE_SUPMIN && n < MBFL_WCSPLANE_SUPMAX) { - CK((*filter->output_function)(n, filter->data)); + CK((*filter->output_function)(n, filter->data TSRMLS_CC)); } else { /* illegal character */ n &= MBFL_WCSGROUP_MASK; n |= MBFL_WCSGROUP_THROUGH; - CK((*filter->output_function)(n, filter->data)); + CK((*filter->output_function)(n, filter->data TSRMLS_CC)); } } else { filter->cache = 0; - CK((*filter->output_function)(n, filter->data)); + CK((*filter->output_function)(n, filter->data TSRMLS_CC)); } break; } @@ -3292,23 +3293,23 @@ mbfl_filt_conv_utf16le_wchar(int c, mbfl_convert_filter *filter) * wchar => UTF-16LE */ static int -mbfl_filt_conv_wchar_utf16le(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_wchar_utf16le(int c, mbfl_convert_filter *filter TSRMLS_DC) { int n; if (c >= 0 && c < MBFL_WCSPLANE_UCS2MAX) { - CK((*filter->output_function)(c & 0xff, filter->data)); - CK((*filter->output_function)((c >> 8) & 0xff, filter->data)); + CK((*filter->output_function)(c & 0xff, filter->data TSRMLS_CC)); + CK((*filter->output_function)((c >> 8) & 0xff, filter->data TSRMLS_CC)); } else if (c >= MBFL_WCSPLANE_SUPMIN && c < MBFL_WCSPLANE_SUPMAX) { n = ((c >> 10) - 0x40) | 0xd800; - CK((*filter->output_function)(n & 0xff, filter->data)); - CK((*filter->output_function)((n >> 8) & 0xff, filter->data)); + CK((*filter->output_function)(n & 0xff, filter->data TSRMLS_CC)); + CK((*filter->output_function)((n >> 8) & 0xff, filter->data TSRMLS_CC)); n = (c & 0x3ff) | 0xdc00; - CK((*filter->output_function)(n & 0xff, filter->data)); - CK((*filter->output_function)((n >> 8) & 0xff, filter->data)); + CK((*filter->output_function)(n & 0xff, filter->data TSRMLS_CC)); + CK((*filter->output_function)((n >> 8) & 0xff, filter->data TSRMLS_CC)); } else { if (filter->illegal_mode != MBFL_OUTPUTFILTER_ILLEGAL_MODE_NONE) { - CK(mbfl_filt_conv_illegal_output(c, filter)); + CK(mbfl_filt_conv_illegal_output(c, filter TSRMLS_CC)); } } @@ -3320,13 +3321,13 @@ mbfl_filt_conv_wchar_utf16le(int c, mbfl_convert_filter *filter) * UTF-8 => wchar */ static int -mbfl_filt_conv_utf8_wchar(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_utf8_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC) { int s; if (c < 0x80) { if (c >= 0) { - CK((*filter->output_function)(c, filter->data)); + CK((*filter->output_function)(c, filter->data TSRMLS_CC)); } filter->status = 0; } else if (c < 0xc0) { @@ -3339,7 +3340,7 @@ mbfl_filt_conv_utf8_wchar(int c, mbfl_convert_filter *filter) filter->status = 0; s = filter->cache | (c & 0x3f); if (s >= 0x80) { - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); } break; case 0x20: /* 3byte code 2nd char */ @@ -3395,40 +3396,40 @@ mbfl_filt_conv_utf8_wchar(int c, mbfl_convert_filter *filter) * wchar => UTF-8 */ static int -mbfl_filt_conv_wchar_utf8(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_wchar_utf8(int c, mbfl_convert_filter *filter TSRMLS_DC) { if (c >= 0 && c < MBFL_WCSGROUP_UCS4MAX) { if (c < 0x80) { - CK((*filter->output_function)(c, filter->data)); + CK((*filter->output_function)(c, filter->data TSRMLS_CC)); } else if (c < 0x800) { - CK((*filter->output_function)(((c >> 6) & 0x1f) | 0xc0, filter->data)); - CK((*filter->output_function)((c & 0x3f) | 0x80, filter->data)); + CK((*filter->output_function)(((c >> 6) & 0x1f) | 0xc0, filter->data TSRMLS_CC)); + CK((*filter->output_function)((c & 0x3f) | 0x80, filter->data TSRMLS_CC)); } else if (c < 0x10000) { - CK((*filter->output_function)(((c >> 12) & 0x0f) | 0xe0, filter->data)); - CK((*filter->output_function)(((c >> 6) & 0x3f) | 0x80, filter->data)); - CK((*filter->output_function)((c & 0x3f) | 0x80, filter->data)); + CK((*filter->output_function)(((c >> 12) & 0x0f) | 0xe0, filter->data TSRMLS_CC)); + CK((*filter->output_function)(((c >> 6) & 0x3f) | 0x80, filter->data TSRMLS_CC)); + CK((*filter->output_function)((c & 0x3f) | 0x80, filter->data TSRMLS_CC)); } else if (c < 0x200000) { - CK((*filter->output_function)(((c >> 18) & 0x07) | 0xf0, filter->data)); - CK((*filter->output_function)(((c >> 12) & 0x3f) | 0x80, filter->data)); - CK((*filter->output_function)(((c >> 6) & 0x3f) | 0x80, filter->data)); - CK((*filter->output_function)((c & 0x3f) | 0x80, filter->data)); + CK((*filter->output_function)(((c >> 18) & 0x07) | 0xf0, filter->data TSRMLS_CC)); + CK((*filter->output_function)(((c >> 12) & 0x3f) | 0x80, filter->data TSRMLS_CC)); + CK((*filter->output_function)(((c >> 6) & 0x3f) | 0x80, filter->data TSRMLS_CC)); + CK((*filter->output_function)((c & 0x3f) | 0x80, filter->data TSRMLS_CC)); } else if (c < 0x4000000) { - CK((*filter->output_function)(((c >> 24) & 0x03) | 0xf8, filter->data)); - CK((*filter->output_function)(((c >> 18) & 0x3f) | 0x80, filter->data)); - CK((*filter->output_function)(((c >> 12) & 0x3f) | 0x80, filter->data)); - CK((*filter->output_function)(((c >> 6) & 0x3f) | 0x80, filter->data)); - CK((*filter->output_function)((c & 0x3f) | 0x80, filter->data)); + CK((*filter->output_function)(((c >> 24) & 0x03) | 0xf8, filter->data TSRMLS_CC)); + CK((*filter->output_function)(((c >> 18) & 0x3f) | 0x80, filter->data TSRMLS_CC)); + CK((*filter->output_function)(((c >> 12) & 0x3f) | 0x80, filter->data TSRMLS_CC)); + CK((*filter->output_function)(((c >> 6) & 0x3f) | 0x80, filter->data TSRMLS_CC)); + CK((*filter->output_function)((c & 0x3f) | 0x80, filter->data TSRMLS_CC)); } else { - CK((*filter->output_function)(((c >> 30) & 0x01) | 0xfc, filter->data)); - CK((*filter->output_function)(((c >> 24) & 0x3f) | 0x80, filter->data)); - CK((*filter->output_function)(((c >> 18) & 0x3f) | 0x80, filter->data)); - CK((*filter->output_function)(((c >> 12) & 0x3f) | 0x80, filter->data)); - CK((*filter->output_function)(((c >> 6) & 0x3f) | 0x80, filter->data)); - CK((*filter->output_function)((c & 0x3f) | 0x80, filter->data)); + CK((*filter->output_function)(((c >> 30) & 0x01) | 0xfc, filter->data TSRMLS_CC)); + CK((*filter->output_function)(((c >> 24) & 0x3f) | 0x80, filter->data TSRMLS_CC)); + CK((*filter->output_function)(((c >> 18) & 0x3f) | 0x80, filter->data TSRMLS_CC)); + CK((*filter->output_function)(((c >> 12) & 0x3f) | 0x80, filter->data TSRMLS_CC)); + CK((*filter->output_function)(((c >> 6) & 0x3f) | 0x80, filter->data TSRMLS_CC)); + CK((*filter->output_function)((c & 0x3f) | 0x80, filter->data TSRMLS_CC)); } } else { if (filter->illegal_mode != MBFL_OUTPUTFILTER_ILLEGAL_MODE_NONE) { - CK(mbfl_filt_conv_illegal_output(c, filter)); + CK(mbfl_filt_conv_illegal_output(c, filter TSRMLS_CC)); } } @@ -3440,7 +3441,7 @@ mbfl_filt_conv_wchar_utf8(int c, mbfl_convert_filter *filter) * UTF-7 => wchar */ static int -mbfl_filt_conv_utf7_wchar(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_utf7_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC) { int s, n; @@ -3460,14 +3461,14 @@ mbfl_filt_conv_utf7_wchar(int c, mbfl_convert_filter *filter) if (n < 0 || n > 63) { if (c == 0x2d) { if (filter->status == 1) { /* "+-" -> "+" */ - CK((*filter->output_function)(0x2b, filter->data)); + CK((*filter->output_function)(0x2b, filter->data TSRMLS_CC)); } } else if (c >= 0 && c < 0x80) { /* ASCII exclude '-' */ - CK((*filter->output_function)(c, filter->data)); + CK((*filter->output_function)(c, filter->data TSRMLS_CC)); } else { /* illegal character */ s = c & MBFL_WCSGROUP_MASK; s |= MBFL_WCSGROUP_THROUGH; - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); } filter->cache = 0; filter->status = 0; @@ -3481,11 +3482,11 @@ mbfl_filt_conv_utf7_wchar(int c, mbfl_convert_filter *filter) if (c == 0x2b) { /* '+' shift character */ filter->status = 1; } else if (c >= 0 && c < 0x80) { /* ASCII */ - CK((*filter->output_function)(c, filter->data)); + CK((*filter->output_function)(c, filter->data TSRMLS_CC)); } else { /* illegal character */ s = c & MBFL_WCSGROUP_MASK; s |= MBFL_WCSGROUP_THROUGH; - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); } break; @@ -3511,15 +3512,15 @@ mbfl_filt_conv_utf7_wchar(int c, mbfl_convert_filter *filter) s |= (filter->cache & 0xfff0000) >> 6; filter->cache = n; if (s >= MBFL_WCSPLANE_SUPMIN && s < MBFL_WCSPLANE_SUPMAX) { - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); } else { /* illegal character */ s &= MBFL_WCSGROUP_MASK; s |= MBFL_WCSGROUP_THROUGH; - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); } } else { filter->cache = n; - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); } break; @@ -3543,15 +3544,15 @@ mbfl_filt_conv_utf7_wchar(int c, mbfl_convert_filter *filter) s |= (filter->cache & 0xfff0000) >> 6; filter->cache = n; if (s >= MBFL_WCSPLANE_SUPMIN && s < MBFL_WCSPLANE_SUPMAX) { - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); } else { /* illegal character */ s &= MBFL_WCSGROUP_MASK; s |= MBFL_WCSGROUP_THROUGH; - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); } } else { filter->cache = n; - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); } break; @@ -3570,15 +3571,15 @@ mbfl_filt_conv_utf7_wchar(int c, mbfl_convert_filter *filter) s |= (filter->cache & 0xfff0000) >> 6; filter->cache = 0; if (s >= MBFL_WCSPLANE_SUPMIN && s < MBFL_WCSPLANE_SUPMAX) { - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); } else { /* illegal character */ s &= MBFL_WCSGROUP_MASK; s |= MBFL_WCSGROUP_THROUGH; - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); } } else { filter->cache = 0; - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); } break; @@ -3594,7 +3595,7 @@ mbfl_filt_conv_utf7_wchar(int c, mbfl_convert_filter *filter) * wchar => UTF-7 */ static int -mbfl_filt_conv_wchar_utf7(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_wchar_utf7(int c, mbfl_convert_filter *filter TSRMLS_DC) { int s, n; @@ -3639,13 +3640,13 @@ mbfl_filt_conv_wchar_utf7(int c, mbfl_convert_filter *filter) ; } else if (c >= MBFL_WCSPLANE_SUPMIN && c < MBFL_WCSPLANE_SUPMAX) { s = ((c >> 10) - 0x40) | 0xd800; - CK((*filter->filter_function)(s, filter)); + CK((*filter->filter_function)(s, filter TSRMLS_CC)); s = (c & 0x3ff) | 0xdc00; - CK((*filter->filter_function)(s, filter)); + CK((*filter->filter_function)(s, filter TSRMLS_CC)); return c; } else { if (filter->illegal_mode != MBFL_OUTPUTFILTER_ILLEGAL_MODE_NONE) { - CK(mbfl_filt_conv_illegal_output(c, filter)); + CK(mbfl_filt_conv_illegal_output(c, filter TSRMLS_CC)); } return c; } @@ -3653,9 +3654,9 @@ mbfl_filt_conv_wchar_utf7(int c, mbfl_convert_filter *filter) switch (filter->status) { case 0: if (n != 0) { /* directly encode characters */ - CK((*filter->output_function)(c, filter->data)); + CK((*filter->output_function)(c, filter->data TSRMLS_CC)); } else { /* Modified Base64 */ - CK((*filter->output_function)(0x2b, filter->data)); /* '+' */ + CK((*filter->output_function)(0x2b, filter->data TSRMLS_CC)); /* '+' */ filter->status++; filter->cache = c; } @@ -3664,14 +3665,14 @@ mbfl_filt_conv_wchar_utf7(int c, mbfl_convert_filter *filter) /* encode Modified Base64 */ case 1: s = filter->cache; - CK((*filter->output_function)(mbfl_base64_table[(s >> 10) & 0x3f], filter->data)); - CK((*filter->output_function)(mbfl_base64_table[(s >> 4) & 0x3f], filter->data)); + CK((*filter->output_function)(mbfl_base64_table[(s >> 10) & 0x3f], filter->data TSRMLS_CC)); + CK((*filter->output_function)(mbfl_base64_table[(s >> 4) & 0x3f], filter->data TSRMLS_CC)); if (n != 0) { - CK((*filter->output_function)(mbfl_base64_table[(s << 2) & 0x3c], filter->data)); + CK((*filter->output_function)(mbfl_base64_table[(s << 2) & 0x3c], filter->data TSRMLS_CC)); if (n == 1) { - CK((*filter->output_function)(0x2d, filter->data)); /* '-' */ + CK((*filter->output_function)(0x2d, filter->data TSRMLS_CC)); /* '-' */ } - CK((*filter->output_function)(c, filter->data)); + CK((*filter->output_function)(c, filter->data TSRMLS_CC)); filter->status = 0; } else { filter->status++; @@ -3681,15 +3682,15 @@ mbfl_filt_conv_wchar_utf7(int c, mbfl_convert_filter *filter) case 2: s = filter->cache; - CK((*filter->output_function)(mbfl_base64_table[(s >> 14) & 0x3f], filter->data)); - CK((*filter->output_function)(mbfl_base64_table[(s >> 8) & 0x3f], filter->data)); - CK((*filter->output_function)(mbfl_base64_table[(s >> 2) & 0x3f], filter->data)); + CK((*filter->output_function)(mbfl_base64_table[(s >> 14) & 0x3f], filter->data TSRMLS_CC)); + CK((*filter->output_function)(mbfl_base64_table[(s >> 8) & 0x3f], filter->data TSRMLS_CC)); + CK((*filter->output_function)(mbfl_base64_table[(s >> 2) & 0x3f], filter->data TSRMLS_CC)); if (n != 0) { - CK((*filter->output_function)(mbfl_base64_table[(s << 4) & 0x30], filter->data)); + CK((*filter->output_function)(mbfl_base64_table[(s << 4) & 0x30], filter->data TSRMLS_CC)); if (n == 1) { - CK((*filter->output_function)(0x2d, filter->data)); /* '-' */ + CK((*filter->output_function)(0x2d, filter->data TSRMLS_CC)); /* '-' */ } - CK((*filter->output_function)(c, filter->data)); + CK((*filter->output_function)(c, filter->data TSRMLS_CC)); filter->status = 0; } else { filter->status++; @@ -3699,14 +3700,14 @@ mbfl_filt_conv_wchar_utf7(int c, mbfl_convert_filter *filter) case 3: s = filter->cache; - CK((*filter->output_function)(mbfl_base64_table[(s >> 12) & 0x3f], filter->data)); - CK((*filter->output_function)(mbfl_base64_table[(s >> 6) & 0x3f], filter->data)); - CK((*filter->output_function)(mbfl_base64_table[s & 0x3f], filter->data)); + CK((*filter->output_function)(mbfl_base64_table[(s >> 12) & 0x3f], filter->data TSRMLS_CC)); + CK((*filter->output_function)(mbfl_base64_table[(s >> 6) & 0x3f], filter->data TSRMLS_CC)); + CK((*filter->output_function)(mbfl_base64_table[s & 0x3f], filter->data TSRMLS_CC)); if (n != 0) { if (n == 1) { - CK((*filter->output_function)(0x2d, filter->data)); /* '-' */ + CK((*filter->output_function)(0x2d, filter->data TSRMLS_CC)); /* '-' */ } - CK((*filter->output_function)(c, filter->data)); + CK((*filter->output_function)(c, filter->data TSRMLS_CC)); filter->status = 0; } else { filter->status = 1; @@ -3724,7 +3725,7 @@ mbfl_filt_conv_wchar_utf7(int c, mbfl_convert_filter *filter) } static int -mbfl_filt_conv_wchar_utf7_flush(mbfl_convert_filter *filter) +mbfl_filt_conv_wchar_utf7_flush(mbfl_convert_filter *filter TSRMLS_DC) { int status, cache; @@ -3735,25 +3736,25 @@ mbfl_filt_conv_wchar_utf7_flush(mbfl_convert_filter *filter) /* flush fragments */ switch (status) { case 1: - CK((*filter->output_function)(mbfl_base64_table[(cache >> 10) & 0x3f], filter->data)); - CK((*filter->output_function)(mbfl_base64_table[(cache >> 4) & 0x3f], filter->data)); - CK((*filter->output_function)(mbfl_base64_table[(cache << 2) & 0x3c], filter->data)); - CK((*filter->output_function)(0x2d, filter->data)); /* '-' */ + CK((*filter->output_function)(mbfl_base64_table[(cache >> 10) & 0x3f], filter->data TSRMLS_CC)); + CK((*filter->output_function)(mbfl_base64_table[(cache >> 4) & 0x3f], filter->data TSRMLS_CC)); + CK((*filter->output_function)(mbfl_base64_table[(cache << 2) & 0x3c], filter->data TSRMLS_CC)); + CK((*filter->output_function)(0x2d, filter->data TSRMLS_CC)); /* '-' */ break; case 2: - CK((*filter->output_function)(mbfl_base64_table[(cache >> 14) & 0x3f], filter->data)); - CK((*filter->output_function)(mbfl_base64_table[(cache >> 8) & 0x3f], filter->data)); - CK((*filter->output_function)(mbfl_base64_table[(cache >> 2) & 0x3f], filter->data)); - CK((*filter->output_function)(mbfl_base64_table[(cache << 4) & 0x30], filter->data)); - CK((*filter->output_function)(0x2d, filter->data)); /* '-' */ + CK((*filter->output_function)(mbfl_base64_table[(cache >> 14) & 0x3f], filter->data TSRMLS_CC)); + CK((*filter->output_function)(mbfl_base64_table[(cache >> 8) & 0x3f], filter->data TSRMLS_CC)); + CK((*filter->output_function)(mbfl_base64_table[(cache >> 2) & 0x3f], filter->data TSRMLS_CC)); + CK((*filter->output_function)(mbfl_base64_table[(cache << 4) & 0x30], filter->data TSRMLS_CC)); + CK((*filter->output_function)(0x2d, filter->data TSRMLS_CC)); /* '-' */ break; case 3: - CK((*filter->output_function)(mbfl_base64_table[(cache >> 12) & 0x3f], filter->data)); - CK((*filter->output_function)(mbfl_base64_table[(cache >> 6) & 0x3f], filter->data)); - CK((*filter->output_function)(mbfl_base64_table[cache & 0x3f], filter->data)); - CK((*filter->output_function)(0x2d, filter->data)); /* '-' */ + CK((*filter->output_function)(mbfl_base64_table[(cache >> 12) & 0x3f], filter->data TSRMLS_CC)); + CK((*filter->output_function)(mbfl_base64_table[(cache >> 6) & 0x3f], filter->data TSRMLS_CC)); + CK((*filter->output_function)(mbfl_base64_table[cache & 0x3f], filter->data TSRMLS_CC)); + CK((*filter->output_function)(0x2d, filter->data TSRMLS_CC)); /* '-' */ break; } return 0; @@ -3764,7 +3765,7 @@ mbfl_filt_conv_wchar_utf7_flush(mbfl_convert_filter *filter) * UTF7-IMAP => wchar */ static int -mbfl_filt_conv_utf7imap_wchar(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_utf7imap_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC) { int s, n; @@ -3784,14 +3785,14 @@ mbfl_filt_conv_utf7imap_wchar(int c, mbfl_convert_filter *filter) if (n < 0 || n > 63) { if (c == 0x2d) { if (filter->status == 1) { /* "&-" -> "&" */ - CK((*filter->output_function)(0x26, filter->data)); + CK((*filter->output_function)(0x26, filter->data TSRMLS_CC)); } } else if (c >= 0 && c < 0x80) { /* ASCII exclude '-' */ - CK((*filter->output_function)(c, filter->data)); + CK((*filter->output_function)(c, filter->data TSRMLS_CC)); } else { /* illegal character */ s = c & MBFL_WCSGROUP_MASK; s |= MBFL_WCSGROUP_THROUGH; - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); } filter->cache = 0; filter->status = 0; @@ -3805,11 +3806,11 @@ mbfl_filt_conv_utf7imap_wchar(int c, mbfl_convert_filter *filter) if (c == 0x26) { /* '&' shift character */ filter->status++; } else if (c >= 0 && c < 0x80) { /* ASCII */ - CK((*filter->output_function)(c, filter->data)); + CK((*filter->output_function)(c, filter->data TSRMLS_CC)); } else { /* illegal character */ s = c & MBFL_WCSGROUP_MASK; s |= MBFL_WCSGROUP_THROUGH; - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); } break; @@ -3835,15 +3836,15 @@ mbfl_filt_conv_utf7imap_wchar(int c, mbfl_convert_filter *filter) s |= (filter->cache & 0xfff0000) >> 6; filter->cache = n; if (s >= MBFL_WCSPLANE_SUPMIN && s < MBFL_WCSPLANE_SUPMAX) { - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); } else { /* illegal character */ s &= MBFL_WCSGROUP_MASK; s |= MBFL_WCSGROUP_THROUGH; - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); } } else { filter->cache = n; - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); } break; @@ -3867,15 +3868,15 @@ mbfl_filt_conv_utf7imap_wchar(int c, mbfl_convert_filter *filter) s |= (filter->cache & 0xfff0000) >> 6; filter->cache = n; if (s >= MBFL_WCSPLANE_SUPMIN && s < MBFL_WCSPLANE_SUPMAX) { - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); } else { /* illegal character */ s &= MBFL_WCSGROUP_MASK; s |= MBFL_WCSGROUP_THROUGH; - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); } } else { filter->cache = n; - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); } break; @@ -3894,15 +3895,15 @@ mbfl_filt_conv_utf7imap_wchar(int c, mbfl_convert_filter *filter) s |= (filter->cache & 0xfff0000) >> 6; filter->cache = 0; if (s >= MBFL_WCSPLANE_SUPMIN && s < MBFL_WCSPLANE_SUPMAX) { - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); } else { /* illegal character */ s &= MBFL_WCSGROUP_MASK; s |= MBFL_WCSGROUP_THROUGH; - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); } } else { filter->cache = 0; - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); } break; @@ -3932,7 +3933,7 @@ static const unsigned char mbfl_utf7imap_base64_table[] = * wchar => UTF7-IMAP */ static int -mbfl_filt_conv_wchar_utf7imap(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_wchar_utf7imap(int c, mbfl_convert_filter *filter TSRMLS_DC) { int n, s; @@ -3945,13 +3946,13 @@ mbfl_filt_conv_wchar_utf7imap(int c, mbfl_convert_filter *filter) ; } else if (c >= MBFL_WCSPLANE_SUPMIN && c < MBFL_WCSPLANE_SUPMAX) { s = ((c >> 10) - 0x40) | 0xd800; - CK((*filter->filter_function)(s, filter)); + CK((*filter->filter_function)(s, filter TSRMLS_CC)); s = (c & 0x3ff) | 0xdc00; - CK((*filter->filter_function)(s, filter)); + CK((*filter->filter_function)(s, filter TSRMLS_CC)); return c; } else { if (filter->illegal_mode != MBFL_OUTPUTFILTER_ILLEGAL_MODE_NONE) { - CK(mbfl_filt_conv_illegal_output(c, filter)); + CK(mbfl_filt_conv_illegal_output(c, filter TSRMLS_CC)); } return c; } @@ -3959,12 +3960,12 @@ mbfl_filt_conv_wchar_utf7imap(int c, mbfl_convert_filter *filter) switch (filter->status) { case 0: if (n != 0) { /* directly encode characters */ - CK((*filter->output_function)(c, filter->data)); + CK((*filter->output_function)(c, filter->data TSRMLS_CC)); if (n == 1) { - CK((*filter->output_function)(0x2d, filter->data)); /* '-' */ + CK((*filter->output_function)(0x2d, filter->data TSRMLS_CC)); /* '-' */ } } else { /* Modified Base64 */ - CK((*filter->output_function)(0x26, filter->data)); /* '&' */ + CK((*filter->output_function)(0x26, filter->data TSRMLS_CC)); /* '&' */ filter->status = 1; filter->cache = c; } @@ -3973,14 +3974,14 @@ mbfl_filt_conv_wchar_utf7imap(int c, mbfl_convert_filter *filter) /* encode Modified Base64 */ case 1: s = filter->cache; - CK((*filter->output_function)(mbfl_utf7imap_base64_table[(s >> 10) & 0x3f], filter->data)); - CK((*filter->output_function)(mbfl_utf7imap_base64_table[(s >> 4) & 0x3f], filter->data)); + CK((*filter->output_function)(mbfl_utf7imap_base64_table[(s >> 10) & 0x3f], filter->data TSRMLS_CC)); + CK((*filter->output_function)(mbfl_utf7imap_base64_table[(s >> 4) & 0x3f], filter->data TSRMLS_CC)); if (n != 0) { - CK((*filter->output_function)(mbfl_utf7imap_base64_table[(s << 2) & 0x3c], filter->data)); - CK((*filter->output_function)(0x2d, filter->data)); /* '-' */ - CK((*filter->output_function)(c, filter->data)); + CK((*filter->output_function)(mbfl_utf7imap_base64_table[(s << 2) & 0x3c], filter->data TSRMLS_CC)); + CK((*filter->output_function)(0x2d, filter->data TSRMLS_CC)); /* '-' */ + CK((*filter->output_function)(c, filter->data TSRMLS_CC)); if (n == 1) { - CK((*filter->output_function)(0x2d, filter->data)); /* '-' */ + CK((*filter->output_function)(0x2d, filter->data TSRMLS_CC)); /* '-' */ } filter->status = 0; } else { @@ -3991,15 +3992,15 @@ mbfl_filt_conv_wchar_utf7imap(int c, mbfl_convert_filter *filter) case 2: s = filter->cache; - CK((*filter->output_function)(mbfl_utf7imap_base64_table[(s >> 14) & 0x3f], filter->data)); - CK((*filter->output_function)(mbfl_utf7imap_base64_table[(s >> 8) & 0x3f], filter->data)); - CK((*filter->output_function)(mbfl_utf7imap_base64_table[(s >> 2) & 0x3f], filter->data)); + CK((*filter->output_function)(mbfl_utf7imap_base64_table[(s >> 14) & 0x3f], filter->data TSRMLS_CC)); + CK((*filter->output_function)(mbfl_utf7imap_base64_table[(s >> 8) & 0x3f], filter->data TSRMLS_CC)); + CK((*filter->output_function)(mbfl_utf7imap_base64_table[(s >> 2) & 0x3f], filter->data TSRMLS_CC)); if (n != 0) { - CK((*filter->output_function)(mbfl_utf7imap_base64_table[(s << 4) & 0x30], filter->data)); - CK((*filter->output_function)(0x2d, filter->data)); /* '-' */ - CK((*filter->output_function)(c, filter->data)); + CK((*filter->output_function)(mbfl_utf7imap_base64_table[(s << 4) & 0x30], filter->data TSRMLS_CC)); + CK((*filter->output_function)(0x2d, filter->data TSRMLS_CC)); /* '-' */ + CK((*filter->output_function)(c, filter->data TSRMLS_CC)); if (n == 1) { - CK((*filter->output_function)(0x2d, filter->data)); /* '-' */ + CK((*filter->output_function)(0x2d, filter->data TSRMLS_CC)); /* '-' */ } filter->status = 0; } else { @@ -4010,14 +4011,14 @@ mbfl_filt_conv_wchar_utf7imap(int c, mbfl_convert_filter *filter) case 3: s = filter->cache; - CK((*filter->output_function)(mbfl_utf7imap_base64_table[(s >> 12) & 0x3f], filter->data)); - CK((*filter->output_function)(mbfl_utf7imap_base64_table[(s >> 6) & 0x3f], filter->data)); - CK((*filter->output_function)(mbfl_utf7imap_base64_table[s & 0x3f], filter->data)); + CK((*filter->output_function)(mbfl_utf7imap_base64_table[(s >> 12) & 0x3f], filter->data TSRMLS_CC)); + CK((*filter->output_function)(mbfl_utf7imap_base64_table[(s >> 6) & 0x3f], filter->data TSRMLS_CC)); + CK((*filter->output_function)(mbfl_utf7imap_base64_table[s & 0x3f], filter->data TSRMLS_CC)); if (n != 0) { - CK((*filter->output_function)(0x2d, filter->data)); /* '-' */ - CK((*filter->output_function)(c, filter->data)); + CK((*filter->output_function)(0x2d, filter->data TSRMLS_CC)); /* '-' */ + CK((*filter->output_function)(c, filter->data TSRMLS_CC)); if (n == 1) { - CK((*filter->output_function)(0x2d, filter->data)); /* '-' */ + CK((*filter->output_function)(0x2d, filter->data TSRMLS_CC)); /* '-' */ } filter->status = 0; } else { @@ -4036,7 +4037,7 @@ mbfl_filt_conv_wchar_utf7imap(int c, mbfl_convert_filter *filter) } static int -mbfl_filt_conv_wchar_utf7imap_flush(mbfl_convert_filter *filter) +mbfl_filt_conv_wchar_utf7imap_flush(mbfl_convert_filter *filter TSRMLS_DC) { int status, cache; @@ -4047,25 +4048,25 @@ mbfl_filt_conv_wchar_utf7imap_flush(mbfl_convert_filter *filter) /* flush fragments */ switch (status) { case 1: - CK((*filter->output_function)(mbfl_utf7imap_base64_table[(cache >> 10) & 0x3f], filter->data)); - CK((*filter->output_function)(mbfl_utf7imap_base64_table[(cache >> 4) & 0x3f], filter->data)); - CK((*filter->output_function)(mbfl_utf7imap_base64_table[(cache << 2) & 0x3c], filter->data)); - CK((*filter->output_function)(0x2d, filter->data)); /* '-' */ + CK((*filter->output_function)(mbfl_utf7imap_base64_table[(cache >> 10) & 0x3f], filter->data TSRMLS_CC)); + CK((*filter->output_function)(mbfl_utf7imap_base64_table[(cache >> 4) & 0x3f], filter->data TSRMLS_CC)); + CK((*filter->output_function)(mbfl_utf7imap_base64_table[(cache << 2) & 0x3c], filter->data TSRMLS_CC)); + CK((*filter->output_function)(0x2d, filter->data TSRMLS_CC)); /* '-' */ break; case 2: - CK((*filter->output_function)(mbfl_utf7imap_base64_table[(cache >> 14) & 0x3f], filter->data)); - CK((*filter->output_function)(mbfl_utf7imap_base64_table[(cache >> 8) & 0x3f], filter->data)); - CK((*filter->output_function)(mbfl_utf7imap_base64_table[(cache >> 2) & 0x3f], filter->data)); - CK((*filter->output_function)(mbfl_utf7imap_base64_table[(cache << 4) & 0x30], filter->data)); - CK((*filter->output_function)(0x2d, filter->data)); /* '-' */ + CK((*filter->output_function)(mbfl_utf7imap_base64_table[(cache >> 14) & 0x3f], filter->data TSRMLS_CC)); + CK((*filter->output_function)(mbfl_utf7imap_base64_table[(cache >> 8) & 0x3f], filter->data TSRMLS_CC)); + CK((*filter->output_function)(mbfl_utf7imap_base64_table[(cache >> 2) & 0x3f], filter->data TSRMLS_CC)); + CK((*filter->output_function)(mbfl_utf7imap_base64_table[(cache << 4) & 0x30], filter->data TSRMLS_CC)); + CK((*filter->output_function)(0x2d, filter->data TSRMLS_CC)); /* '-' */ break; case 3: - CK((*filter->output_function)(mbfl_utf7imap_base64_table[(cache >> 12) & 0x3f], filter->data)); - CK((*filter->output_function)(mbfl_utf7imap_base64_table[(cache >> 6) & 0x3f], filter->data)); - CK((*filter->output_function)(mbfl_utf7imap_base64_table[cache & 0x3f], filter->data)); - CK((*filter->output_function)(0x2d, filter->data)); /* '-' */ + CK((*filter->output_function)(mbfl_utf7imap_base64_table[(cache >> 12) & 0x3f], filter->data TSRMLS_CC)); + CK((*filter->output_function)(mbfl_utf7imap_base64_table[(cache >> 6) & 0x3f], filter->data TSRMLS_CC)); + CK((*filter->output_function)(mbfl_utf7imap_base64_table[cache & 0x3f], filter->data TSRMLS_CC)); + CK((*filter->output_function)(0x2d, filter->data TSRMLS_CC)); /* '-' */ break; } return 0; @@ -4076,13 +4077,13 @@ mbfl_filt_conv_wchar_utf7imap_flush(mbfl_convert_filter *filter) * wchar => ASCII */ static int -mbfl_filt_conv_wchar_ascii(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_wchar_ascii(int c, mbfl_convert_filter *filter TSRMLS_DC) { if (c >= 0 && c < 0x80) { - CK((*filter->output_function)(c, filter->data)); + CK((*filter->output_function)(c, filter->data TSRMLS_CC)); } else { if (filter->illegal_mode != MBFL_OUTPUTFILTER_ILLEGAL_MODE_NONE) { - CK(mbfl_filt_conv_illegal_output(c, filter)); + CK(mbfl_filt_conv_illegal_output(c, filter TSRMLS_CC)); } } @@ -4093,7 +4094,7 @@ mbfl_filt_conv_wchar_ascii(int c, mbfl_convert_filter *filter) * wchar => cp1252 */ static int -mbfl_filt_conv_wchar_cp1252(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_wchar_cp1252(int c, mbfl_convert_filter *filter TSRMLS_DC) { int s=-1, n; @@ -4117,10 +4118,10 @@ mbfl_filt_conv_wchar_cp1252(int c, mbfl_convert_filter *filter) s = c; } if (s >= 0) { - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); } else { if (filter->illegal_mode != MBFL_OUTPUTFILTER_ILLEGAL_MODE_NONE) { - CK(mbfl_filt_conv_illegal_output(c, filter)); + CK(mbfl_filt_conv_illegal_output(c, filter TSRMLS_CC)); } } return c; @@ -4130,7 +4131,7 @@ mbfl_filt_conv_wchar_cp1252(int c, mbfl_convert_filter *filter) * cp1252 => wchar */ static int -mbfl_filt_conv_cp1252_wchar(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_cp1252_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC) { int s; @@ -4140,7 +4141,7 @@ mbfl_filt_conv_cp1252_wchar(int c, mbfl_convert_filter *filter) s = c; } - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); return c; } @@ -4149,13 +4150,13 @@ mbfl_filt_conv_cp1252_wchar(int c, mbfl_convert_filter *filter) * wchar => ISO-8859-1 */ static int -mbfl_filt_conv_wchar_8859_1(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_wchar_8859_1(int c, mbfl_convert_filter *filter TSRMLS_DC) { if (c >= 0 && c < 0x100) { - CK((*filter->output_function)(c, filter->data)); + CK((*filter->output_function)(c, filter->data TSRMLS_CC)); } else { if (filter->illegal_mode != MBFL_OUTPUTFILTER_ILLEGAL_MODE_NONE) { - CK(mbfl_filt_conv_illegal_output(c, filter)); + CK(mbfl_filt_conv_illegal_output(c, filter TSRMLS_CC)); } } @@ -4166,7 +4167,7 @@ mbfl_filt_conv_wchar_8859_1(int c, mbfl_convert_filter *filter) * ISO-8859-2 => wchar */ static int -mbfl_filt_conv_8859_2_wchar(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_8859_2_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC) { int s; @@ -4185,7 +4186,7 @@ mbfl_filt_conv_8859_2_wchar(int c, mbfl_convert_filter *filter) s |= MBFL_WCSGROUP_THROUGH; } - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); return c; } @@ -4194,7 +4195,7 @@ mbfl_filt_conv_8859_2_wchar(int c, mbfl_convert_filter *filter) * wchar => ISO-8859-2 */ static int -mbfl_filt_conv_wchar_8859_2(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_wchar_8859_2(int c, mbfl_convert_filter *filter TSRMLS_DC) { int s, n; @@ -4216,10 +4217,10 @@ mbfl_filt_conv_wchar_8859_2(int c, mbfl_convert_filter *filter) } if (s >= 0) { - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); } else { if (filter->illegal_mode != MBFL_OUTPUTFILTER_ILLEGAL_MODE_NONE) { - CK(mbfl_filt_conv_illegal_output(c, filter)); + CK(mbfl_filt_conv_illegal_output(c, filter TSRMLS_CC)); } } @@ -4230,7 +4231,7 @@ mbfl_filt_conv_wchar_8859_2(int c, mbfl_convert_filter *filter) * ISO-8859-3 => wchar */ static int -mbfl_filt_conv_8859_3_wchar(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_8859_3_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC) { int s; @@ -4249,7 +4250,7 @@ mbfl_filt_conv_8859_3_wchar(int c, mbfl_convert_filter *filter) s |= MBFL_WCSGROUP_THROUGH; } - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); return c; } @@ -4258,7 +4259,7 @@ mbfl_filt_conv_8859_3_wchar(int c, mbfl_convert_filter *filter) * wchar => ISO-8859-3 */ static int -mbfl_filt_conv_wchar_8859_3(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_wchar_8859_3(int c, mbfl_convert_filter *filter TSRMLS_DC) { int s, n; @@ -4280,10 +4281,10 @@ mbfl_filt_conv_wchar_8859_3(int c, mbfl_convert_filter *filter) } if (s >= 0) { - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); } else { if (filter->illegal_mode != MBFL_OUTPUTFILTER_ILLEGAL_MODE_NONE) { - CK(mbfl_filt_conv_illegal_output(c, filter)); + CK(mbfl_filt_conv_illegal_output(c, filter TSRMLS_CC)); } } @@ -4294,7 +4295,7 @@ mbfl_filt_conv_wchar_8859_3(int c, mbfl_convert_filter *filter) * ISO-8859-4 => wchar */ static int -mbfl_filt_conv_8859_4_wchar(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_8859_4_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC) { int s; @@ -4313,7 +4314,7 @@ mbfl_filt_conv_8859_4_wchar(int c, mbfl_convert_filter *filter) s |= MBFL_WCSGROUP_THROUGH; } - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); return c; } @@ -4322,7 +4323,7 @@ mbfl_filt_conv_8859_4_wchar(int c, mbfl_convert_filter *filter) * wchar => ISO-8859-4 */ static int -mbfl_filt_conv_wchar_8859_4(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_wchar_8859_4(int c, mbfl_convert_filter *filter TSRMLS_DC) { int s, n; @@ -4344,10 +4345,10 @@ mbfl_filt_conv_wchar_8859_4(int c, mbfl_convert_filter *filter) } if (s >= 0) { - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); } else { if (filter->illegal_mode != MBFL_OUTPUTFILTER_ILLEGAL_MODE_NONE) { - CK(mbfl_filt_conv_illegal_output(c, filter)); + CK(mbfl_filt_conv_illegal_output(c, filter TSRMLS_CC)); } } @@ -4358,7 +4359,7 @@ mbfl_filt_conv_wchar_8859_4(int c, mbfl_convert_filter *filter) * ISO-8859-5 => wchar */ static int -mbfl_filt_conv_8859_5_wchar(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_8859_5_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC) { int s; @@ -4377,7 +4378,7 @@ mbfl_filt_conv_8859_5_wchar(int c, mbfl_convert_filter *filter) s |= MBFL_WCSGROUP_THROUGH; } - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); return c; } @@ -4386,7 +4387,7 @@ mbfl_filt_conv_8859_5_wchar(int c, mbfl_convert_filter *filter) * wchar => ISO-8859-5 */ static int -mbfl_filt_conv_wchar_8859_5(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_wchar_8859_5(int c, mbfl_convert_filter *filter TSRMLS_DC) { int s, n; @@ -4408,10 +4409,10 @@ mbfl_filt_conv_wchar_8859_5(int c, mbfl_convert_filter *filter) } if (s >= 0) { - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); } else { if (filter->illegal_mode != MBFL_OUTPUTFILTER_ILLEGAL_MODE_NONE) { - CK(mbfl_filt_conv_illegal_output(c, filter)); + CK(mbfl_filt_conv_illegal_output(c, filter TSRMLS_CC)); } } @@ -4422,7 +4423,7 @@ mbfl_filt_conv_wchar_8859_5(int c, mbfl_convert_filter *filter) * ISO-8859-6 => wchar */ static int -mbfl_filt_conv_8859_6_wchar(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_8859_6_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC) { int s; @@ -4441,7 +4442,7 @@ mbfl_filt_conv_8859_6_wchar(int c, mbfl_convert_filter *filter) s |= MBFL_WCSGROUP_THROUGH; } - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); return c; } @@ -4450,7 +4451,7 @@ mbfl_filt_conv_8859_6_wchar(int c, mbfl_convert_filter *filter) * wchar => ISO-8859-6 */ static int -mbfl_filt_conv_wchar_8859_6(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_wchar_8859_6(int c, mbfl_convert_filter *filter TSRMLS_DC) { int s, n; @@ -4472,10 +4473,10 @@ mbfl_filt_conv_wchar_8859_6(int c, mbfl_convert_filter *filter) } if (s >= 0) { - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); } else { if (filter->illegal_mode != MBFL_OUTPUTFILTER_ILLEGAL_MODE_NONE) { - CK(mbfl_filt_conv_illegal_output(c, filter)); + CK(mbfl_filt_conv_illegal_output(c, filter TSRMLS_CC)); } } @@ -4486,7 +4487,7 @@ mbfl_filt_conv_wchar_8859_6(int c, mbfl_convert_filter *filter) * ISO-8859-7 => wchar */ static int -mbfl_filt_conv_8859_7_wchar(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_8859_7_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC) { int s; @@ -4505,7 +4506,7 @@ mbfl_filt_conv_8859_7_wchar(int c, mbfl_convert_filter *filter) s |= MBFL_WCSGROUP_THROUGH; } - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); return c; } @@ -4514,7 +4515,7 @@ mbfl_filt_conv_8859_7_wchar(int c, mbfl_convert_filter *filter) * wchar => ISO-8859-7 */ static int -mbfl_filt_conv_wchar_8859_7(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_wchar_8859_7(int c, mbfl_convert_filter *filter TSRMLS_DC) { int s, n; @@ -4536,10 +4537,10 @@ mbfl_filt_conv_wchar_8859_7(int c, mbfl_convert_filter *filter) } if (s >= 0) { - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); } else { if (filter->illegal_mode != MBFL_OUTPUTFILTER_ILLEGAL_MODE_NONE) { - CK(mbfl_filt_conv_illegal_output(c, filter)); + CK(mbfl_filt_conv_illegal_output(c, filter TSRMLS_CC)); } } @@ -4550,7 +4551,7 @@ mbfl_filt_conv_wchar_8859_7(int c, mbfl_convert_filter *filter) * ISO-8859-8 => wchar */ static int -mbfl_filt_conv_8859_8_wchar(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_8859_8_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC) { int s; @@ -4569,7 +4570,7 @@ mbfl_filt_conv_8859_8_wchar(int c, mbfl_convert_filter *filter) s |= MBFL_WCSGROUP_THROUGH; } - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); return c; } @@ -4578,7 +4579,7 @@ mbfl_filt_conv_8859_8_wchar(int c, mbfl_convert_filter *filter) * wchar => ISO-8859-8 */ static int -mbfl_filt_conv_wchar_8859_8(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_wchar_8859_8(int c, mbfl_convert_filter *filter TSRMLS_DC) { int s, n; @@ -4600,10 +4601,10 @@ mbfl_filt_conv_wchar_8859_8(int c, mbfl_convert_filter *filter) } if (s >= 0) { - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); } else { if (filter->illegal_mode != MBFL_OUTPUTFILTER_ILLEGAL_MODE_NONE) { - CK(mbfl_filt_conv_illegal_output(c, filter)); + CK(mbfl_filt_conv_illegal_output(c, filter TSRMLS_CC)); } } @@ -4614,7 +4615,7 @@ mbfl_filt_conv_wchar_8859_8(int c, mbfl_convert_filter *filter) * ISO-8859-9 => wchar */ static int -mbfl_filt_conv_8859_9_wchar(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_8859_9_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC) { int s; @@ -4633,7 +4634,7 @@ mbfl_filt_conv_8859_9_wchar(int c, mbfl_convert_filter *filter) s |= MBFL_WCSGROUP_THROUGH; } - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); return c; } @@ -4642,7 +4643,7 @@ mbfl_filt_conv_8859_9_wchar(int c, mbfl_convert_filter *filter) * wchar => ISO-8859-9 */ static int -mbfl_filt_conv_wchar_8859_9(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_wchar_8859_9(int c, mbfl_convert_filter *filter TSRMLS_DC) { int s, n; @@ -4664,10 +4665,10 @@ mbfl_filt_conv_wchar_8859_9(int c, mbfl_convert_filter *filter) } if (s >= 0) { - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); } else { if (filter->illegal_mode != MBFL_OUTPUTFILTER_ILLEGAL_MODE_NONE) { - CK(mbfl_filt_conv_illegal_output(c, filter)); + CK(mbfl_filt_conv_illegal_output(c, filter TSRMLS_CC)); } } @@ -4678,7 +4679,7 @@ mbfl_filt_conv_wchar_8859_9(int c, mbfl_convert_filter *filter) * ISO-8859-10 => wchar */ static int -mbfl_filt_conv_8859_10_wchar(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_8859_10_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC) { int s; @@ -4697,7 +4698,7 @@ mbfl_filt_conv_8859_10_wchar(int c, mbfl_convert_filter *filter) s |= MBFL_WCSGROUP_THROUGH; } - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); return c; } @@ -4706,7 +4707,7 @@ mbfl_filt_conv_8859_10_wchar(int c, mbfl_convert_filter *filter) * wchar => ISO-8859-10 */ static int -mbfl_filt_conv_wchar_8859_10(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_wchar_8859_10(int c, mbfl_convert_filter *filter TSRMLS_DC) { int s, n; @@ -4728,10 +4729,10 @@ mbfl_filt_conv_wchar_8859_10(int c, mbfl_convert_filter *filter) } if (s >= 0) { - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); } else { if (filter->illegal_mode != MBFL_OUTPUTFILTER_ILLEGAL_MODE_NONE) { - CK(mbfl_filt_conv_illegal_output(c, filter)); + CK(mbfl_filt_conv_illegal_output(c, filter TSRMLS_CC)); } } @@ -4742,7 +4743,7 @@ mbfl_filt_conv_wchar_8859_10(int c, mbfl_convert_filter *filter) * ISO-8859-13 => wchar */ static int -mbfl_filt_conv_8859_13_wchar(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_8859_13_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC) { int s; @@ -4761,7 +4762,7 @@ mbfl_filt_conv_8859_13_wchar(int c, mbfl_convert_filter *filter) s |= MBFL_WCSGROUP_THROUGH; } - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); return c; } @@ -4770,7 +4771,7 @@ mbfl_filt_conv_8859_13_wchar(int c, mbfl_convert_filter *filter) * wchar => ISO-8859-13 */ static int -mbfl_filt_conv_wchar_8859_13(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_wchar_8859_13(int c, mbfl_convert_filter *filter TSRMLS_DC) { int s, n; @@ -4792,10 +4793,10 @@ mbfl_filt_conv_wchar_8859_13(int c, mbfl_convert_filter *filter) } if (s >= 0) { - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); } else { if (filter->illegal_mode != MBFL_OUTPUTFILTER_ILLEGAL_MODE_NONE) { - CK(mbfl_filt_conv_illegal_output(c, filter)); + CK(mbfl_filt_conv_illegal_output(c, filter TSRMLS_CC)); } } @@ -4806,7 +4807,7 @@ mbfl_filt_conv_wchar_8859_13(int c, mbfl_convert_filter *filter) * ISO-8859-14 => wchar */ static int -mbfl_filt_conv_8859_14_wchar(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_8859_14_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC) { int s; @@ -4825,7 +4826,7 @@ mbfl_filt_conv_8859_14_wchar(int c, mbfl_convert_filter *filter) s |= MBFL_WCSGROUP_THROUGH; } - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); return c; } @@ -4834,7 +4835,7 @@ mbfl_filt_conv_8859_14_wchar(int c, mbfl_convert_filter *filter) * wchar => ISO-8859-14 */ static int -mbfl_filt_conv_wchar_8859_14(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_wchar_8859_14(int c, mbfl_convert_filter *filter TSRMLS_DC) { int s, n; @@ -4856,10 +4857,10 @@ mbfl_filt_conv_wchar_8859_14(int c, mbfl_convert_filter *filter) } if (s >= 0) { - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); } else { if (filter->illegal_mode != MBFL_OUTPUTFILTER_ILLEGAL_MODE_NONE) { - CK(mbfl_filt_conv_illegal_output(c, filter)); + CK(mbfl_filt_conv_illegal_output(c, filter TSRMLS_CC)); } } @@ -4870,7 +4871,7 @@ mbfl_filt_conv_wchar_8859_14(int c, mbfl_convert_filter *filter) * ISO-8859-15 => wchar */ static int -mbfl_filt_conv_8859_15_wchar(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_8859_15_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC) { int s; @@ -4889,7 +4890,7 @@ mbfl_filt_conv_8859_15_wchar(int c, mbfl_convert_filter *filter) s |= MBFL_WCSGROUP_THROUGH; } - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); return c; } @@ -4898,7 +4899,7 @@ mbfl_filt_conv_8859_15_wchar(int c, mbfl_convert_filter *filter) * wchar => ISO-8859-15 */ static int -mbfl_filt_conv_wchar_8859_15(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_wchar_8859_15(int c, mbfl_convert_filter *filter TSRMLS_DC) { int s, n; @@ -4920,10 +4921,10 @@ mbfl_filt_conv_wchar_8859_15(int c, mbfl_convert_filter *filter) } if (s >= 0) { - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); } else { if (filter->illegal_mode != MBFL_OUTPUTFILTER_ILLEGAL_MODE_NONE) { - CK(mbfl_filt_conv_illegal_output(c, filter)); + CK(mbfl_filt_conv_illegal_output(c, filter TSRMLS_CC)); } } @@ -4939,20 +4940,20 @@ mbfl_filt_conv_wchar_8859_15(int c, mbfl_convert_filter *filter) */ static void -mbfl_filt_ident_common_ctor(mbfl_identify_filter *filter) +mbfl_filt_ident_common_ctor(mbfl_identify_filter *filter TSRMLS_DC) { filter->status = 0; filter->flag = 0; } static void -mbfl_filt_ident_common_dtor(mbfl_identify_filter *filter) +mbfl_filt_ident_common_dtor(mbfl_identify_filter *filter TSRMLS_DC) { filter->status = 0; } static int -mbfl_filt_ident_ascii(int c, mbfl_identify_filter *filter) +mbfl_filt_ident_ascii(int c, mbfl_identify_filter *filter TSRMLS_DC) { if (c >= 0x20 && c < 0x80) { ; @@ -4966,7 +4967,7 @@ mbfl_filt_ident_ascii(int c, mbfl_identify_filter *filter) } static int -mbfl_filt_ident_utf8(int c, mbfl_identify_filter *filter) +mbfl_filt_ident_utf8(int c, mbfl_identify_filter *filter TSRMLS_DC) { if (c < 0x80) { if (c < 0) { @@ -5025,7 +5026,7 @@ mbfl_filt_ident_utf8(int c, mbfl_identify_filter *filter) } static int -mbfl_filt_ident_utf7(int c, mbfl_identify_filter *filter) +mbfl_filt_ident_utf7(int c, mbfl_identify_filter *filter TSRMLS_DC) { int n; @@ -5075,7 +5076,7 @@ mbfl_filt_ident_utf7(int c, mbfl_identify_filter *filter) } static int -mbfl_filt_ident_eucjp(int c, mbfl_identify_filter *filter) +mbfl_filt_ident_eucjp(int c, mbfl_identify_filter *filter TSRMLS_DC) { switch (filter->status) { case 0: /* latin */ @@ -5128,7 +5129,7 @@ mbfl_filt_ident_eucjp(int c, mbfl_identify_filter *filter) } static int -mbfl_filt_ident_sjis(int c, mbfl_identify_filter *filter) +mbfl_filt_ident_sjis(int c, mbfl_identify_filter *filter TSRMLS_DC) { if (filter->status) { /* kanji second char */ if (c < 0x40 || c > 0xfc || c == 0x7f) { /* bad */ @@ -5149,7 +5150,7 @@ mbfl_filt_ident_sjis(int c, mbfl_identify_filter *filter) } static int -mbfl_filt_ident_sjiswin(int c, mbfl_identify_filter *filter) +mbfl_filt_ident_sjiswin(int c, mbfl_identify_filter *filter TSRMLS_DC) { if (filter->status) { /* kanji second char */ if (c < 0x40 || c > 0xfc || c == 0x7f) { /* bad */ @@ -5170,7 +5171,7 @@ mbfl_filt_ident_sjiswin(int c, mbfl_identify_filter *filter) } static int -mbfl_filt_ident_jis(int c, mbfl_identify_filter *filter) +mbfl_filt_ident_jis(int c, mbfl_identify_filter *filter TSRMLS_DC) { retry: switch (filter->status & 0xf) { @@ -5275,7 +5276,7 @@ retry: * The problem here is that cp1252 looks like SJIS for certain chars. * */ static int -mbfl_filt_ident_cp1252(int c, mbfl_identify_filter *filter) +mbfl_filt_ident_cp1252(int c, mbfl_identify_filter *filter TSRMLS_DC) { if (c >= 0x80 && c < 0xa0) filter->flag = 0; @@ -5285,7 +5286,7 @@ mbfl_filt_ident_cp1252(int c, mbfl_identify_filter *filter) } static int -mbfl_filt_ident_2022jp(int c, mbfl_identify_filter *filter) +mbfl_filt_ident_2022jp(int c, mbfl_identify_filter *filter TSRMLS_DC) { retry: switch (filter->status & 0xf) { @@ -5362,21 +5363,21 @@ retry: } static void -mbfl_filt_ident_false_ctor(mbfl_identify_filter *filter) +mbfl_filt_ident_false_ctor(mbfl_identify_filter *filter TSRMLS_DC) { filter->status = 0; filter->flag = 1; } static int -mbfl_filt_ident_false(int c, mbfl_identify_filter *filter) +mbfl_filt_ident_false(int c, mbfl_identify_filter *filter TSRMLS_DC) { filter->flag = 1; /* bad */ return c; } static int -mbfl_filt_ident_true(int c, mbfl_identify_filter *filter) +mbfl_filt_ident_true(int c, mbfl_identify_filter *filter TSRMLS_DC) { return c; } @@ -5442,16 +5443,16 @@ mbfl_convert_filter_select_vtbl(mbfl_convert_filter *filter) /* filter pipe */ static int -mbfl_filter_output_pipe(int c, void* data) +mbfl_filter_output_pipe(int c, void* data TSRMLS_DC) { mbfl_convert_filter *filter = (mbfl_convert_filter*)data; - return (*filter->filter_function)(c, filter); + return (*filter->filter_function)(c, filter TSRMLS_CC); } /* null output */ static int -mbfl_filter_output_null(int c, void* data) +mbfl_filter_output_null(int c, void* data TSRMLS_DC) { return c; } @@ -5461,9 +5462,9 @@ mbfl_convert_filter * mbfl_convert_filter_new( enum mbfl_no_encoding from, enum mbfl_no_encoding to, - int (*output_function)(int, void*), - int (*flush_function)(void*), - void* data) + int (*output_function)(int, void* TSRMLS_DC), + int (*flush_function)(void* TSRMLS_DC), + void* data TSRMLS_DC) { mbfl_convert_filter * filter; @@ -5497,41 +5498,41 @@ mbfl_convert_filter_new( mbfl_convert_filter_select_vtbl(filter); /* constructor */ - (*filter->filter_ctor)(filter); + (*filter->filter_ctor)(filter TSRMLS_CC); return filter; } void -mbfl_convert_filter_delete(mbfl_convert_filter *filter) +mbfl_convert_filter_delete(mbfl_convert_filter *filter TSRMLS_DC) { if (filter) { - (*filter->filter_dtor)(filter); + (*filter->filter_dtor)(filter TSRMLS_CC); mbfl_free((void*)filter); } } int -mbfl_convert_filter_feed(int c, mbfl_convert_filter *filter) +mbfl_convert_filter_feed(int c, mbfl_convert_filter *filter TSRMLS_DC) { - return (*filter->filter_function)(c, filter); + return (*filter->filter_function)(c, filter TSRMLS_CC); } int -mbfl_convert_filter_flush(mbfl_convert_filter *filter) +mbfl_convert_filter_flush(mbfl_convert_filter *filter TSRMLS_DC) { - (*filter->filter_flush)(filter); - return (filter->flush_function ? (*filter->flush_function)(filter->data) : 0); + (*filter->filter_flush)(filter TSRMLS_CC); + return (filter->flush_function ? (*filter->flush_function)(filter->data TSRMLS_CC) : 0); } void mbfl_convert_filter_reset( mbfl_convert_filter *filter, enum mbfl_no_encoding from, - enum mbfl_no_encoding to) + enum mbfl_no_encoding to TSRMLS_DC) { /* destruct old filter */ - (*filter->filter_dtor)(filter); + (*filter->filter_dtor)(filter TSRMLS_CC); /* resset filter member */ filter->from = mbfl_no2encoding(from); @@ -5541,13 +5542,13 @@ mbfl_convert_filter_reset( mbfl_convert_filter_select_vtbl(filter); /* construct new filter */ - (*filter->filter_ctor)(filter); + (*filter->filter_ctor)(filter TSRMLS_CC); } void mbfl_convert_filter_copy( mbfl_convert_filter *src, - mbfl_convert_filter *dist) + mbfl_convert_filter *dist TSRMLS_DC) { dist->filter_ctor = src->filter_ctor; dist->filter_dtor = src->filter_dtor; @@ -5565,7 +5566,8 @@ mbfl_convert_filter_copy( } static int -mbfl_convert_filter_devcat(mbfl_convert_filter *filter, mbfl_memory_device *src) +mbfl_convert_filter_devcat(mbfl_convert_filter *filter, mbfl_memory_device *src + TSRMLS_DC) { int n; unsigned char *p; @@ -5573,7 +5575,7 @@ mbfl_convert_filter_devcat(mbfl_convert_filter *filter, mbfl_memory_device *src) p = src->buffer; n = src->pos; while (n > 0) { - if ((*filter->filter_function)(*p++, filter) < 0) { + if ((*filter->filter_function)(*p++, filter TSRMLS_CC) < 0) { return -1; } n--; @@ -5583,12 +5585,12 @@ mbfl_convert_filter_devcat(mbfl_convert_filter *filter, mbfl_memory_device *src) } static int -mbfl_convert_filter_strcat(mbfl_convert_filter *filter, const unsigned char *p) +mbfl_convert_filter_strcat(mbfl_convert_filter *filter, const unsigned char *p TSRMLS_DC) { int c; while ((c = *p++) != '\0') { - if ((*filter->filter_function)(c, filter) < 0) { + if ((*filter->filter_function)(c, filter TSRMLS_CC) < 0) { return -1; } } @@ -5598,10 +5600,11 @@ mbfl_convert_filter_strcat(mbfl_convert_filter *filter, const unsigned char *p) #if 0 static int -mbfl_convert_filter_strncat(mbfl_convert_filter *filter, const unsigned char *p, int n) +mbfl_convert_filter_strncat(mbfl_convert_filter *filter, const unsigned char *p, + int n TSRMLS_DC) { while (n > 0) { - if ((*filter->filter_function)(*p++, filter) < 0) { + if ((*filter->filter_function)(*p++, filter TSRMLS_CC) < 0) { return -1; } n--; @@ -5618,7 +5621,7 @@ static char mbfl_hexchar_table[] = { /* illegal character output function for conv-filter */ int -mbfl_filt_conv_illegal_output(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_illegal_output(int c, mbfl_convert_filter *filter TSRMLS_DC) { int mode_backup, ret, n, m, r; @@ -5627,35 +5630,35 @@ mbfl_filt_conv_illegal_output(int c, mbfl_convert_filter *filter) filter->illegal_mode = MBFL_OUTPUTFILTER_ILLEGAL_MODE_NONE; switch (mode_backup) { case MBFL_OUTPUTFILTER_ILLEGAL_MODE_CHAR: - ret = (*filter->filter_function)(filter->illegal_substchar, filter); + ret = (*filter->filter_function)(filter->illegal_substchar, filter TSRMLS_CC); break; case MBFL_OUTPUTFILTER_ILLEGAL_MODE_LONG: if (c >= 0) { if (c < MBFL_WCSGROUP_UCS4MAX) { /* unicode */ - ret = mbfl_convert_filter_strcat(filter, "U+"); + ret = mbfl_convert_filter_strcat(filter, "U+" TSRMLS_CC); } else { if (c < MBFL_WCSGROUP_WCHARMAX) { m = c & ~MBFL_WCSPLANE_MASK; switch (m) { case MBFL_WCSPLANE_JIS0208: - ret = mbfl_convert_filter_strcat(filter, "JIS+"); + ret = mbfl_convert_filter_strcat(filter, "JIS+" TSRMLS_CC); break; case MBFL_WCSPLANE_JIS0212: - ret = mbfl_convert_filter_strcat(filter, "JIS2+"); + ret = mbfl_convert_filter_strcat(filter, "JIS2+" TSRMLS_CC); break; case MBFL_WCSPLANE_WINCP932: - ret = mbfl_convert_filter_strcat(filter, "W932+"); + ret = mbfl_convert_filter_strcat(filter, "W932+" TSRMLS_CC); break; case MBFL_WCSPLANE_8859_1: - ret = mbfl_convert_filter_strcat(filter, "I8859_1+"); + ret = mbfl_convert_filter_strcat(filter, "I8859_1+" TSRMLS_CC); break; default: - ret = mbfl_convert_filter_strcat(filter, "?+"); + ret = mbfl_convert_filter_strcat(filter, "?+" TSRMLS_CC); break; } c &= MBFL_WCSPLANE_MASK; } else { - ret = mbfl_convert_filter_strcat(filter, "BAD+"); + ret = mbfl_convert_filter_strcat(filter, "BAD+" TSRMLS_CC); c &= MBFL_WCSGROUP_MASK; } } @@ -5666,7 +5669,7 @@ mbfl_filt_conv_illegal_output(int c, mbfl_convert_filter *filter) n = (c >> r) & 0xf; if (n || m) { m = 1; - ret = (*filter->filter_function)(mbfl_hexchar_table[n], filter); + ret = (*filter->filter_function)(mbfl_hexchar_table[n], filter TSRMLS_CC); if (ret < 0) { break; } @@ -5674,7 +5677,7 @@ mbfl_filt_conv_illegal_output(int c, mbfl_convert_filter *filter) r -= 4; } if (m == 0 && ret >= 0) { - ret = (*filter->filter_function)(mbfl_hexchar_table[0], filter); + ret = (*filter->filter_function)(mbfl_hexchar_table[0], filter TSRMLS_CC); } } } @@ -5731,7 +5734,7 @@ mbfl_identify_filter_select_vtbl(mbfl_identify_filter *filter) } mbfl_identify_filter * -mbfl_identify_filter_new(enum mbfl_no_encoding encoding) +mbfl_identify_filter_new(enum mbfl_no_encoding encoding TSRMLS_DC) { mbfl_identify_filter * filter; @@ -5755,16 +5758,16 @@ mbfl_identify_filter_new(enum mbfl_no_encoding encoding) mbfl_identify_filter_select_vtbl(filter); /* constructor */ - (*filter->filter_ctor)(filter); + (*filter->filter_ctor)(filter TSRMLS_CC); return filter; } void -mbfl_identify_filter_delete(mbfl_identify_filter *filter) +mbfl_identify_filter_delete(mbfl_identify_filter *filter TSRMLS_DC) { if (filter) { - (*filter->filter_dtor)(filter); + (*filter->filter_dtor)(filter TSRMLS_CC); mbfl_free((void*)filter); } } @@ -5778,7 +5781,7 @@ mbfl_buffer_converter * mbfl_buffer_converter_new( enum mbfl_no_encoding from, enum mbfl_no_encoding to, - int buf_initsz) + int buf_initsz TSRMLS_DC) { mbfl_buffer_converter *convd; @@ -5802,13 +5805,13 @@ mbfl_buffer_converter_new( convd->filter1 = NULL; convd->filter2 = NULL; if (mbfl_convert_filter_get_vtbl(convd->from->no_encoding, convd->to->no_encoding) != NULL) { - convd->filter1 = mbfl_convert_filter_new(convd->from->no_encoding, convd->to->no_encoding, mbfl_memory_device_output, 0, &convd->device); + convd->filter1 = mbfl_convert_filter_new(convd->from->no_encoding, convd->to->no_encoding, mbfl_memory_device_output, 0, &convd->device TSRMLS_CC); } else { - convd->filter2 = mbfl_convert_filter_new(mbfl_no_encoding_wchar, convd->to->no_encoding, mbfl_memory_device_output, 0, &convd->device); + convd->filter2 = mbfl_convert_filter_new(mbfl_no_encoding_wchar, convd->to->no_encoding, mbfl_memory_device_output, 0, &convd->device TSRMLS_CC); if (convd->filter2 != NULL) { - convd->filter1 = mbfl_convert_filter_new(convd->from->no_encoding, mbfl_no_encoding_wchar, (int (*)(int, void*))convd->filter2->filter_function, NULL, convd->filter2); + convd->filter1 = mbfl_convert_filter_new(convd->from->no_encoding, mbfl_no_encoding_wchar, (int (*)(int, void* TSRMLS_DC))convd->filter2->filter_function, NULL, convd->filter2 TSRMLS_CC); if (convd->filter1 == NULL) { - mbfl_convert_filter_delete(convd->filter2); + mbfl_convert_filter_delete(convd->filter2 TSRMLS_CC); } } } @@ -5816,34 +5819,34 @@ mbfl_buffer_converter_new( return NULL; } - mbfl_memory_device_init(&convd->device, buf_initsz, buf_initsz/4); + mbfl_memory_device_init(&convd->device, buf_initsz, buf_initsz/4 TSRMLS_CC); return convd; } void -mbfl_buffer_converter_delete(mbfl_buffer_converter *convd) +mbfl_buffer_converter_delete(mbfl_buffer_converter *convd TSRMLS_DC) { if (convd != NULL) { if (convd->filter1) { - mbfl_convert_filter_delete(convd->filter1); + mbfl_convert_filter_delete(convd->filter1 TSRMLS_CC); } if (convd->filter2) { - mbfl_convert_filter_delete(convd->filter2); + mbfl_convert_filter_delete(convd->filter2 TSRMLS_CC); } - mbfl_memory_device_clear(&convd->device); + mbfl_memory_device_clear(&convd->device TSRMLS_CC); mbfl_free((void*)convd); } } void -mbfl_buffer_converter_reset(mbfl_buffer_converter *convd) +mbfl_buffer_converter_reset(mbfl_buffer_converter *convd TSRMLS_DC) { - mbfl_memory_device_reset(&convd->device); + mbfl_memory_device_reset(&convd->device TSRMLS_CC); } int -mbfl_buffer_converter_illegal_mode(mbfl_buffer_converter *convd, int mode) +mbfl_buffer_converter_illegal_mode(mbfl_buffer_converter *convd, int mode TSRMLS_DC) { if (convd != NULL) { if (convd->filter2 != NULL) { @@ -5859,7 +5862,7 @@ mbfl_buffer_converter_illegal_mode(mbfl_buffer_converter *convd, int mode) } int -mbfl_buffer_converter_illegal_substchar(mbfl_buffer_converter *convd, int substchar) +mbfl_buffer_converter_illegal_substchar(mbfl_buffer_converter *convd, int substchar TSRMLS_DC) { if (convd != NULL) { if (convd->filter2 != NULL) { @@ -5875,17 +5878,17 @@ mbfl_buffer_converter_illegal_substchar(mbfl_buffer_converter *convd, int substc } int -mbfl_buffer_converter_strncat(mbfl_buffer_converter *convd, const unsigned char *p, int n) +mbfl_buffer_converter_strncat(mbfl_buffer_converter *convd, const unsigned char *p, int n TSRMLS_DC) { mbfl_convert_filter *filter; - int (*filter_function)(int c, mbfl_convert_filter *filter); + int (*filter_function)(int c, mbfl_convert_filter *filter TSRMLS_DC); if (convd != NULL && p != NULL) { filter = convd->filter1; if (filter != NULL) { filter_function = filter->filter_function; while (n > 0) { - if ((*filter_function)(*p++, filter) < 0) { + if ((*filter_function)(*p++, filter TSRMLS_CC) < 0) { break; } n--; @@ -5897,17 +5900,17 @@ mbfl_buffer_converter_strncat(mbfl_buffer_converter *convd, const unsigned char } int -mbfl_buffer_converter_feed(mbfl_buffer_converter *convd, mbfl_string *string) +mbfl_buffer_converter_feed(mbfl_buffer_converter *convd, mbfl_string *string TSRMLS_DC) { int n; unsigned char *p; mbfl_convert_filter *filter; - int (*filter_function)(int c, mbfl_convert_filter *filter); + int (*filter_function)(int c, mbfl_convert_filter *filter TSRMLS_DC); if (convd == NULL || string == NULL) { return -1; } - mbfl_memory_device_realloc(&convd->device, convd->device.pos + string->len, string->len/4); + mbfl_memory_device_realloc(&convd->device, convd->device.pos + string->len, string->len/4 TSRMLS_CC); /* feed data */ n = string->len; p = string->val; @@ -5915,7 +5918,7 @@ mbfl_buffer_converter_feed(mbfl_buffer_converter *convd, mbfl_string *string) if (filter != NULL) { filter_function = filter->filter_function; while (n > 0) { - if ((*filter_function)(*p++, filter) < 0) { + if ((*filter_function)(*p++, filter TSRMLS_CC) < 0) { return -1; } n--; @@ -5926,24 +5929,24 @@ mbfl_buffer_converter_feed(mbfl_buffer_converter *convd, mbfl_string *string) } int -mbfl_buffer_converter_flush(mbfl_buffer_converter *convd) +mbfl_buffer_converter_flush(mbfl_buffer_converter *convd TSRMLS_DC) { if (convd == NULL) { return -1; } if (convd->filter1 != NULL) { - mbfl_convert_filter_flush(convd->filter1); + mbfl_convert_filter_flush(convd->filter1 TSRMLS_CC); } if (convd->filter2 != NULL) { - mbfl_convert_filter_flush(convd->filter2); + mbfl_convert_filter_flush(convd->filter2 TSRMLS_CC); } return 0; } mbfl_string * -mbfl_buffer_converter_getbuffer(mbfl_buffer_converter *convd, mbfl_string *result) +mbfl_buffer_converter_getbuffer(mbfl_buffer_converter *convd, mbfl_string *result TSRMLS_DC) { if (convd != NULL && result != NULL && convd->device.buffer != NULL) { result->no_encoding = convd->to->no_encoding; @@ -5957,30 +5960,31 @@ mbfl_buffer_converter_getbuffer(mbfl_buffer_converter *convd, mbfl_string *resul } mbfl_string * -mbfl_buffer_converter_result(mbfl_buffer_converter *convd, mbfl_string *result) +mbfl_buffer_converter_result(mbfl_buffer_converter *convd, mbfl_string *result TSRMLS_DC) { if (convd == NULL || result == NULL) { return NULL; } result->no_encoding = convd->to->no_encoding; - return mbfl_memory_device_result(&convd->device, result); + return mbfl_memory_device_result(&convd->device, result TSRMLS_CC); } mbfl_string * -mbfl_buffer_converter_feed_result(mbfl_buffer_converter *convd, mbfl_string *string, mbfl_string *result) +mbfl_buffer_converter_feed_result(mbfl_buffer_converter *convd, mbfl_string *string, + mbfl_string *result TSRMLS_DC) { if (convd == NULL || string == NULL || result == NULL) { return NULL; } - mbfl_buffer_converter_feed(convd, string); + mbfl_buffer_converter_feed(convd, string TSRMLS_CC); if (convd->filter1 != NULL) { - mbfl_convert_filter_flush(convd->filter1); + mbfl_convert_filter_flush(convd->filter1 TSRMLS_CC); } if (convd->filter2 != NULL) { - mbfl_convert_filter_flush(convd->filter2); + mbfl_convert_filter_flush(convd->filter2 TSRMLS_CC); } result->no_encoding = convd->to->no_encoding; - return mbfl_memory_device_result(&convd->device, result); + return mbfl_memory_device_result(&convd->device, result TSRMLS_CC); } @@ -5988,7 +5992,7 @@ mbfl_buffer_converter_feed_result(mbfl_buffer_converter *convd, mbfl_string *str * encoding detector */ mbfl_encoding_detector * -mbfl_encoding_detector_new(enum mbfl_no_encoding *elist, int eliztsz) +mbfl_encoding_detector_new(enum mbfl_no_encoding *elist, int eliztsz TSRMLS_DC) { mbfl_encoding_detector *identd; @@ -6014,7 +6018,7 @@ mbfl_encoding_detector_new(enum mbfl_no_encoding *elist, int eliztsz) i = 0; num = 0; while (i < eliztsz) { - filter = mbfl_identify_filter_new(elist[i]); + filter = mbfl_identify_filter_new(elist[i] TSRMLS_CC); if (filter != NULL) { identd->filter_list[num] = filter; num++; @@ -6027,7 +6031,7 @@ mbfl_encoding_detector_new(enum mbfl_no_encoding *elist, int eliztsz) } void -mbfl_encoding_detector_delete(mbfl_encoding_detector *identd) +mbfl_encoding_detector_delete(mbfl_encoding_detector *identd TSRMLS_DC) { int i; @@ -6036,7 +6040,7 @@ mbfl_encoding_detector_delete(mbfl_encoding_detector *identd) i = identd->filter_list_size; while (i > 0) { i--; - mbfl_identify_filter_delete(identd->filter_list[i]); + mbfl_identify_filter_delete(identd->filter_list[i] TSRMLS_CC); } mbfl_free((void *)identd->filter_list); } @@ -6045,7 +6049,7 @@ mbfl_encoding_detector_delete(mbfl_encoding_detector *identd) } int -mbfl_encoding_detector_feed(mbfl_encoding_detector *identd, mbfl_string *string) +mbfl_encoding_detector_feed(mbfl_encoding_detector *identd, mbfl_string *string TSRMLS_DC) { int i, n, num, bad, res; unsigned char *p; @@ -6062,7 +6066,7 @@ mbfl_encoding_detector_feed(mbfl_encoding_detector *identd, mbfl_string *string) bad = 0; while (i < num) { filter = identd->filter_list[i]; - (*filter->filter_function)(*p, filter); + (*filter->filter_function)(*p, filter TSRMLS_CC); if (filter->flag) { bad++; } @@ -6080,7 +6084,7 @@ mbfl_encoding_detector_feed(mbfl_encoding_detector *identd, mbfl_string *string) return res; } -enum mbfl_no_encoding mbfl_encoding_detector_judge(mbfl_encoding_detector *identd) +enum mbfl_no_encoding mbfl_encoding_detector_judge(mbfl_encoding_detector *identd TSRMLS_DC) { mbfl_identify_filter *filter; enum mbfl_no_encoding encoding; @@ -6110,7 +6114,7 @@ mbfl_string * mbfl_convert_encoding( mbfl_string *string, mbfl_string *result, - enum mbfl_no_encoding toenc) + enum mbfl_no_encoding toenc TSRMLS_DC) { int n; unsigned char *p; @@ -6128,13 +6132,13 @@ mbfl_convert_encoding( filter1 = NULL; filter2 = NULL; if (mbfl_convert_filter_get_vtbl(string->no_encoding, toenc) != NULL) { - filter1 = mbfl_convert_filter_new(string->no_encoding, toenc, mbfl_memory_device_output, 0, &device); + filter1 = mbfl_convert_filter_new(string->no_encoding, toenc, mbfl_memory_device_output, 0, &device TSRMLS_CC); } else { - filter2 = mbfl_convert_filter_new(mbfl_no_encoding_wchar, toenc, mbfl_memory_device_output, 0, &device); + filter2 = mbfl_convert_filter_new(mbfl_no_encoding_wchar, toenc, mbfl_memory_device_output, 0, &device TSRMLS_CC); if (filter2 != NULL) { - filter1 = mbfl_convert_filter_new(string->no_encoding, mbfl_no_encoding_wchar, (int (*)(int, void*))filter2->filter_function, NULL, filter2); + filter1 = mbfl_convert_filter_new(string->no_encoding, mbfl_no_encoding_wchar, (int (*)(int, void* TSRMLS_DC))filter2->filter_function, NULL, filter2 TSRMLS_CC); if (filter1 == NULL) { - mbfl_convert_filter_delete(filter2); + mbfl_convert_filter_delete(filter2 TSRMLS_CC); } } } @@ -6143,28 +6147,28 @@ mbfl_convert_encoding( } filter2->illegal_mode = MBFL_OUTPUTFILTER_ILLEGAL_MODE_CHAR; filter2->illegal_substchar = 0x3f; /* '?' */ - mbfl_memory_device_init(&device, string->len, (string->len >> 2) + 8); + mbfl_memory_device_init(&device, string->len, (string->len >> 2) + 8 TSRMLS_CC); /* feed data */ n = string->len; p = string->val; if (p != NULL) { while (n > 0) { - if ((*filter1->filter_function)(*p++, filter1) < 0) { + if ((*filter1->filter_function)(*p++, filter1 TSRMLS_CC) < 0) { break; } n--; } } - mbfl_convert_filter_flush(filter1); - mbfl_convert_filter_delete(filter1); + mbfl_convert_filter_flush(filter1 TSRMLS_CC); + mbfl_convert_filter_delete(filter1 TSRMLS_CC); if (filter2 != NULL) { - mbfl_convert_filter_flush(filter2); - mbfl_convert_filter_delete(filter2); + mbfl_convert_filter_flush(filter2 TSRMLS_CC); + mbfl_convert_filter_delete(filter2 TSRMLS_CC); } - return mbfl_memory_device_result(&device, result); + return mbfl_memory_device_result(&device, result TSRMLS_CC); } @@ -6172,7 +6176,7 @@ mbfl_convert_encoding( * identify encoding */ mbfl_encoding * -mbfl_identify_encoding(mbfl_string *string, enum mbfl_no_encoding *elist, int eliztsz) +mbfl_identify_encoding(mbfl_string *string, enum mbfl_no_encoding *elist, int eliztsz TSRMLS_DC) { int i, n, num, bad; unsigned char *p; @@ -6194,7 +6198,7 @@ mbfl_identify_encoding(mbfl_string *string, enum mbfl_no_encoding *elist, int el filter = &flist[num]; mbfl_identify_filter_set_vtbl(filter, vtbl); filter->encoding = mbfl_no2encoding(vtbl->encoding); - (*filter->filter_ctor)(filter); + (*filter->filter_ctor)(filter TSRMLS_CC); num++; } i++; @@ -6210,7 +6214,7 @@ mbfl_identify_encoding(mbfl_string *string, enum mbfl_no_encoding *elist, int el bad = 0; while (i < num) { filter = &flist[i]; - (*filter->filter_function)(*p, filter); + (*filter->filter_function)(*p, filter TSRMLS_CC); if (filter->flag) { bad++; } @@ -6246,7 +6250,7 @@ mbfl_identify_encoding(mbfl_string *string, enum mbfl_no_encoding *elist, int el i = 0; while (i < num) { filter = &flist[i]; - (*filter->filter_dtor)(filter); + (*filter->filter_dtor)(filter TSRMLS_CC); i++; } mbfl_free((void *)flist); @@ -6255,11 +6259,11 @@ mbfl_identify_encoding(mbfl_string *string, enum mbfl_no_encoding *elist, int el } const char* -mbfl_identify_encoding_name(mbfl_string *string, enum mbfl_no_encoding *elist, int eliztsz) +mbfl_identify_encoding_name(mbfl_string *string, enum mbfl_no_encoding *elist, int eliztsz TSRMLS_DC) { mbfl_encoding *encoding; - encoding = mbfl_identify_encoding(string, elist, eliztsz); + encoding = mbfl_identify_encoding(string, elist, eliztsz TSRMLS_CC); if (encoding != NULL && encoding->no_encoding > mbfl_no_encoding_charset_min && encoding->no_encoding < mbfl_no_encoding_charset_max) { @@ -6270,11 +6274,11 @@ mbfl_identify_encoding_name(mbfl_string *string, enum mbfl_no_encoding *elist, i } enum mbfl_no_encoding -mbfl_identify_encoding_no(mbfl_string *string, enum mbfl_no_encoding *elist, int eliztsz) +mbfl_identify_encoding_no(mbfl_string *string, enum mbfl_no_encoding *elist, int eliztsz TSRMLS_DC) { mbfl_encoding *encoding; - encoding = mbfl_identify_encoding(string, elist, eliztsz); + encoding = mbfl_identify_encoding(string, elist, eliztsz TSRMLS_CC); if (encoding != NULL && encoding->no_encoding > mbfl_no_encoding_charset_min && encoding->no_encoding < mbfl_no_encoding_charset_max) { @@ -6289,14 +6293,14 @@ mbfl_identify_encoding_no(mbfl_string *string, enum mbfl_no_encoding *elist, int * strlen */ static int -filter_count_output(int c, void *data) +filter_count_output(int c, void *data TSRMLS_DC) { (*(int *)data)++; return c; } int -mbfl_strlen(mbfl_string *string) +mbfl_strlen(mbfl_string *string TSRMLS_DC) { int len, n, m, k; unsigned char *p; @@ -6334,7 +6338,7 @@ mbfl_strlen(mbfl_string *string) mbfl_convert_filter *filter = mbfl_convert_filter_new( string->no_encoding, mbfl_no_encoding_wchar, - filter_count_output, 0, &len); + filter_count_output, 0, &len TSRMLS_CC); if (filter == NULL) { return -1; } @@ -6343,11 +6347,11 @@ mbfl_strlen(mbfl_string *string) p = string->val; if (p != NULL) { while (n > 0) { - (*filter->filter_function)(*p++, filter); + (*filter->filter_function)(*p++, filter TSRMLS_CC); n--; } } - mbfl_convert_filter_delete(filter); + mbfl_convert_filter_delete(filter TSRMLS_CC); } return len; @@ -6369,7 +6373,7 @@ struct collector_strpos_data { }; static int -collector_strpos(int c, void* data) +collector_strpos(int c, void* data TSRMLS_DC) { int *p, *h, *m, n; struct collector_strpos_data *pc = (struct collector_strpos_data*)data; @@ -6421,7 +6425,7 @@ mbfl_strpos( mbfl_string *haystack, mbfl_string *needle, int offset, - int reverse) + int reverse TSRMLS_DC) { int n, result; unsigned char *p; @@ -6432,11 +6436,11 @@ mbfl_strpos( return -8; } /* needle is converted into wchar */ - mbfl_wchar_device_init(&pc.needle); + mbfl_wchar_device_init(&pc.needle TSRMLS_CC); filter = mbfl_convert_filter_new( needle->no_encoding, mbfl_no_encoding_wchar, - mbfl_wchar_device_output, 0, &pc.needle); + mbfl_wchar_device_output, 0, &pc.needle TSRMLS_CC); if (filter == NULL) { return -4; } @@ -6444,29 +6448,29 @@ mbfl_strpos( n = needle->len; if (p != NULL) { while (n > 0) { - if ((*filter->filter_function)(*p++, filter) < 0) { + if ((*filter->filter_function)(*p++, filter TSRMLS_CC) < 0) { break; } n--; } } - mbfl_convert_filter_flush(filter); - mbfl_convert_filter_delete(filter); + mbfl_convert_filter_flush(filter TSRMLS_CC); + mbfl_convert_filter_delete(filter TSRMLS_CC); pc.needle_len = pc.needle.pos; if (pc.needle.buffer == NULL) { return -4; } if (pc.needle_len <= 0) { - mbfl_wchar_device_clear(&pc.needle); + mbfl_wchar_device_clear(&pc.needle TSRMLS_CC); return -2; } /* initialize filter and collector data */ filter = mbfl_convert_filter_new( haystack->no_encoding, mbfl_no_encoding_wchar, - collector_strpos, 0, &pc); + collector_strpos, 0, &pc TSRMLS_CC); if (filter == NULL) { - mbfl_wchar_device_clear(&pc.needle); + mbfl_wchar_device_clear(&pc.needle TSRMLS_CC); return -4; } pc.start = offset; @@ -6480,7 +6484,7 @@ mbfl_strpos( n = haystack->len; if (p != NULL) { while (n > 0) { - if ((*filter->filter_function)(*p++, filter) < 0) { + if ((*filter->filter_function)(*p++, filter TSRMLS_CC) < 0) { pc.matched_pos = -4; break; } @@ -6490,10 +6494,10 @@ mbfl_strpos( n--; } } - mbfl_convert_filter_flush(filter); + mbfl_convert_filter_flush(filter TSRMLS_CC); result = pc.matched_pos; - mbfl_convert_filter_delete(filter); - mbfl_wchar_device_clear(&pc.needle); + mbfl_convert_filter_delete(filter TSRMLS_CC); + mbfl_wchar_device_clear(&pc.needle TSRMLS_CC); return result; } @@ -6510,7 +6514,7 @@ struct collector_substr_data { }; static int -collector_substr(int c, void* data) +collector_substr(int c, void* data TSRMLS_DC) { struct collector_substr_data *pc = (struct collector_substr_data*)data; @@ -6519,7 +6523,7 @@ collector_substr(int c, void* data) } if (pc->output >= pc->start) { - (*pc->next_filter->filter_function)(c, pc->next_filter); + (*pc->next_filter->filter_function)(c, pc->next_filter TSRMLS_CC); } pc->output++; @@ -6532,7 +6536,7 @@ mbfl_substr( mbfl_string *string, mbfl_string *result, int from, - int length) + int length TSRMLS_DC) { mbfl_encoding *encoding; int n, m, k, len, start, end; @@ -6636,7 +6640,7 @@ mbfl_substr( mbfl_convert_filter *decoder; mbfl_convert_filter *encoder; - mbfl_memory_device_init(&device, length + 1, 0); + mbfl_memory_device_init(&device, length + 1, 0 TSRMLS_CC); mbfl_string_init(result); result->no_language = string->no_language; result->no_encoding = string->no_encoding; @@ -6644,15 +6648,15 @@ mbfl_substr( decoder = mbfl_convert_filter_new( mbfl_no_encoding_wchar, string->no_encoding, - mbfl_memory_device_output, 0, &device); + mbfl_memory_device_output, 0, &device TSRMLS_CC); /* wchar filter */ encoder = mbfl_convert_filter_new( string->no_encoding, mbfl_no_encoding_wchar, - collector_substr, 0, &pc); + collector_substr, 0, &pc TSRMLS_CC); if (decoder == NULL || encoder == NULL) { - mbfl_convert_filter_delete(encoder); - mbfl_convert_filter_delete(decoder); + mbfl_convert_filter_delete(encoder TSRMLS_CC); + mbfl_convert_filter_delete(decoder TSRMLS_CC); return NULL; } pc.next_filter = decoder; @@ -6665,18 +6669,18 @@ mbfl_substr( n = string->len; if (p != NULL) { while (n > 0) { - if ((*encoder->filter_function)(*p++, encoder) < 0) { + if ((*encoder->filter_function)(*p++, encoder TSRMLS_CC) < 0) { break; } n--; } } - mbfl_convert_filter_flush(encoder); - mbfl_convert_filter_flush(decoder); - result = mbfl_memory_device_result(&device, result); - mbfl_convert_filter_delete(encoder); - mbfl_convert_filter_delete(decoder); + mbfl_convert_filter_flush(encoder TSRMLS_CC); + mbfl_convert_filter_flush(decoder TSRMLS_CC); + result = mbfl_memory_device_result(&device, result TSRMLS_CC); + mbfl_convert_filter_delete(encoder TSRMLS_CC); + mbfl_convert_filter_delete(decoder TSRMLS_CC); } return result; @@ -6691,7 +6695,7 @@ mbfl_strcut( mbfl_string *string, mbfl_string *result, int from, - int length) + int length TSRMLS_DC) { mbfl_encoding *encoding; int n, m, k, len, start, end; @@ -6796,35 +6800,35 @@ mbfl_strcut( encoder = mbfl_convert_filter_new( string->no_encoding, mbfl_no_encoding_wchar, - mbfl_filter_output_null, 0, 0); + mbfl_filter_output_null, 0, 0 TSRMLS_CC); encoder_tmp = mbfl_convert_filter_new( string->no_encoding, mbfl_no_encoding_wchar, - mbfl_filter_output_null, 0, 0); + mbfl_filter_output_null, 0, 0 TSRMLS_CC); /* output code filter */ decoder = mbfl_convert_filter_new( mbfl_no_encoding_wchar, string->no_encoding, - mbfl_memory_device_output, 0, &device); + mbfl_memory_device_output, 0, &device TSRMLS_CC); decoder_tmp = mbfl_convert_filter_new( mbfl_no_encoding_wchar, string->no_encoding, - mbfl_memory_device_output, 0, &device); + mbfl_memory_device_output, 0, &device TSRMLS_CC); if (encoder == NULL || encoder_tmp == NULL || decoder == NULL || decoder_tmp == NULL) { - mbfl_convert_filter_delete(encoder); - mbfl_convert_filter_delete(encoder_tmp); - mbfl_convert_filter_delete(decoder); - mbfl_convert_filter_delete(decoder_tmp); + mbfl_convert_filter_delete(encoder TSRMLS_CC); + mbfl_convert_filter_delete(encoder_tmp TSRMLS_CC); + mbfl_convert_filter_delete(decoder TSRMLS_CC); + mbfl_convert_filter_delete(decoder_tmp TSRMLS_CC); return NULL; } - mbfl_memory_device_init(&device, length + 8, 0); + mbfl_memory_device_init(&device, length + 8, 0 TSRMLS_CC); k = 0; n = 0; p = string->val; if (p != NULL) { /* seartch start position */ while (n < from) { - (*encoder->filter_function)(*p++, encoder); + (*encoder->filter_function)(*p++, encoder TSRMLS_CC); n++; } /* output a little shorter than "length" */ @@ -6833,44 +6837,44 @@ mbfl_strcut( k = length - 20; len = string->len; while (n < len && device.pos < k) { - (*encoder->filter_function)(*p++, encoder); + (*encoder->filter_function)(*p++, encoder TSRMLS_CC); n++; } /* detect end position */ for (;;) { /* backup current state */ k = device.pos; - mbfl_convert_filter_copy(encoder, encoder_tmp); - mbfl_convert_filter_copy(decoder, decoder_tmp); + mbfl_convert_filter_copy(encoder, encoder_tmp TSRMLS_CC); + mbfl_convert_filter_copy(decoder, decoder_tmp TSRMLS_CC); if (n >= len) { break; } /* feed 1byte and flush */ - (*encoder->filter_function)(*p, encoder); - (*encoder->filter_flush)(encoder); - (*decoder->filter_flush)(decoder); + (*encoder->filter_function)(*p, encoder TSRMLS_CC); + (*encoder->filter_flush)(encoder TSRMLS_CC); + (*decoder->filter_flush)(decoder TSRMLS_CC); if (device.pos > length) { break; } /* restore filter and re-feed data */ device.pos = k; - mbfl_convert_filter_copy(encoder_tmp, encoder); - mbfl_convert_filter_copy(decoder_tmp, decoder); - (*encoder->filter_function)(*p, encoder); + mbfl_convert_filter_copy(encoder_tmp, encoder TSRMLS_CC); + mbfl_convert_filter_copy(decoder_tmp, decoder TSRMLS_CC); + (*encoder->filter_function)(*p, encoder TSRMLS_CC); p++; n++; } device.pos = k; - mbfl_convert_filter_copy(encoder_tmp, encoder); - mbfl_convert_filter_copy(decoder_tmp, decoder); - mbfl_convert_filter_flush(encoder); - mbfl_convert_filter_flush(decoder); + mbfl_convert_filter_copy(encoder_tmp, encoder TSRMLS_CC); + mbfl_convert_filter_copy(decoder_tmp, decoder TSRMLS_CC); + mbfl_convert_filter_flush(encoder TSRMLS_CC); + mbfl_convert_filter_flush(decoder TSRMLS_CC); } - result = mbfl_memory_device_result(&device, result); - mbfl_convert_filter_delete(encoder); - mbfl_convert_filter_delete(encoder_tmp); - mbfl_convert_filter_delete(decoder); - mbfl_convert_filter_delete(decoder_tmp); + result = mbfl_memory_device_result(&device, result TSRMLS_CC); + mbfl_convert_filter_delete(encoder TSRMLS_CC); + mbfl_convert_filter_delete(encoder_tmp TSRMLS_CC); + mbfl_convert_filter_delete(decoder TSRMLS_CC); + mbfl_convert_filter_delete(decoder_tmp TSRMLS_CC); } return result; @@ -6881,7 +6885,7 @@ mbfl_strcut( * strwidth */ static int -filter_count_width(int c, void* data) +filter_count_width(int c, void* data TSRMLS_DC) { if (c >= 0x20) { if (c < 0x2000 || (c > 0xff60 && c < 0xffa0)) { @@ -6895,7 +6899,7 @@ filter_count_width(int c, void* data) } int -mbfl_strwidth(mbfl_string *string) +mbfl_strwidth(mbfl_string *string TSRMLS_DC) { int len, n; unsigned char *p; @@ -6907,9 +6911,9 @@ mbfl_strwidth(mbfl_string *string) filter = mbfl_convert_filter_new( string->no_encoding, mbfl_no_encoding_wchar, - filter_count_width, 0, &len); + filter_count_width, 0, &len TSRMLS_CC); if (filter == NULL) { - mbfl_convert_filter_delete(filter); + mbfl_convert_filter_delete(filter TSRMLS_CC); return -1; } @@ -6917,12 +6921,12 @@ mbfl_strwidth(mbfl_string *string) p = string->val; n = string->len; while (n > 0) { - (*filter->filter_function)(*p++, filter); + (*filter->filter_function)(*p++, filter TSRMLS_CC); n--; } - mbfl_convert_filter_flush(filter); - mbfl_convert_filter_delete(filter); + mbfl_convert_filter_flush(filter TSRMLS_CC); + mbfl_convert_filter_delete(filter TSRMLS_CC); } return len; @@ -6945,13 +6949,13 @@ struct collector_strimwidth_data { }; static int -collector_strimwidth(int c, void* data) +collector_strimwidth(int c, void* data TSRMLS_DC) { struct collector_strimwidth_data *pc = (struct collector_strimwidth_data*)data; switch (pc->status) { case 10: - (*pc->decoder->filter_function)(c, pc->decoder); + (*pc->decoder->filter_function)(c, pc->decoder TSRMLS_CC); break; default: if (pc->outchar >= pc->from) { @@ -6965,13 +6969,13 @@ collector_strimwidth(int c, void* data) if (pc->outwidth > pc->width) { if (pc->status == 0) { pc->endpos = pc->device.pos; - mbfl_convert_filter_copy(pc->decoder, pc->decoder_backup); + mbfl_convert_filter_copy(pc->decoder, pc->decoder_backup TSRMLS_CC); } pc->status++; - (*pc->decoder->filter_function)(c, pc->decoder); + (*pc->decoder->filter_function)(c, pc->decoder TSRMLS_CC); c = -1; } else { - (*pc->decoder->filter_function)(c, pc->decoder); + (*pc->decoder->filter_function)(c, pc->decoder TSRMLS_CC); } } pc->outchar++; @@ -6987,7 +6991,7 @@ mbfl_strimwidth( mbfl_string *marker, mbfl_string *result, int from, - int width) + int width TSRMLS_DC) { struct collector_strimwidth_data pc; mbfl_convert_filter *encoder; @@ -7000,31 +7004,31 @@ mbfl_strimwidth( mbfl_string_init(result); result->no_language = string->no_language; result->no_encoding = string->no_encoding; - mbfl_memory_device_init(&pc.device, width, 0); + mbfl_memory_device_init(&pc.device, width, 0 TSRMLS_CC); /* output code filter */ pc.decoder = mbfl_convert_filter_new( mbfl_no_encoding_wchar, string->no_encoding, - mbfl_memory_device_output, 0, &pc.device); + mbfl_memory_device_output, 0, &pc.device TSRMLS_CC); pc.decoder_backup = mbfl_convert_filter_new( mbfl_no_encoding_wchar, string->no_encoding, - mbfl_memory_device_output, 0, &pc.device); + mbfl_memory_device_output, 0, &pc.device TSRMLS_CC); /* wchar filter */ encoder = mbfl_convert_filter_new( string->no_encoding, mbfl_no_encoding_wchar, - collector_strimwidth, 0, &pc); + collector_strimwidth, 0, &pc TSRMLS_CC); if (pc.decoder == NULL || pc.decoder_backup == NULL || encoder == NULL) { - mbfl_convert_filter_delete(encoder); - mbfl_convert_filter_delete(pc.decoder); - mbfl_convert_filter_delete(pc.decoder_backup); + mbfl_convert_filter_delete(encoder TSRMLS_CC); + mbfl_convert_filter_delete(pc.decoder TSRMLS_CC); + mbfl_convert_filter_delete(pc.decoder_backup TSRMLS_CC); return NULL; } mkwidth = 0; if (marker) { - mkwidth = mbfl_strwidth(marker); + mkwidth = mbfl_strwidth(marker TSRMLS_CC); } pc.from = from; pc.width = width - mkwidth; @@ -7039,45 +7043,45 @@ mbfl_strimwidth( if (p != NULL) { while (n > 0) { n--; - if ((*encoder->filter_function)(*p++, encoder) < 0) { + if ((*encoder->filter_function)(*p++, encoder TSRMLS_CC) < 0) { break; } } - mbfl_convert_filter_flush(encoder); + mbfl_convert_filter_flush(encoder TSRMLS_CC); if (pc.status != 0 && mkwidth > 0) { pc.width += mkwidth; while (n > 0) { - if ((*encoder->filter_function)(*p++, encoder) < 0) { + if ((*encoder->filter_function)(*p++, encoder TSRMLS_CC) < 0) { break; } n--; } - mbfl_convert_filter_flush(encoder); + mbfl_convert_filter_flush(encoder TSRMLS_CC); if (pc.status != 1) { pc.status = 10; pc.device.pos = pc.endpos; - mbfl_convert_filter_copy(pc.decoder_backup, pc.decoder); - mbfl_convert_filter_reset(encoder, marker->no_encoding, mbfl_no_encoding_wchar); + mbfl_convert_filter_copy(pc.decoder_backup, pc.decoder TSRMLS_CC); + mbfl_convert_filter_reset(encoder, marker->no_encoding, mbfl_no_encoding_wchar TSRMLS_CC); p = marker->val; n = marker->len; while (n > 0) { - if ((*encoder->filter_function)(*p++, encoder) < 0) { + if ((*encoder->filter_function)(*p++, encoder TSRMLS_CC) < 0) { break; } n--; } - mbfl_convert_filter_flush(encoder); + mbfl_convert_filter_flush(encoder TSRMLS_CC); } } else if (pc.status != 0) { pc.device.pos = pc.endpos; - mbfl_convert_filter_copy(pc.decoder_backup, pc.decoder); + mbfl_convert_filter_copy(pc.decoder_backup, pc.decoder TSRMLS_CC); } - mbfl_convert_filter_flush(pc.decoder); + mbfl_convert_filter_flush(pc.decoder TSRMLS_CC); } - result = mbfl_memory_device_result(&pc.device, result); - mbfl_convert_filter_delete(encoder); - mbfl_convert_filter_delete(pc.decoder); - mbfl_convert_filter_delete(pc.decoder_backup); + result = mbfl_memory_device_result(&pc.device, result TSRMLS_CC); + mbfl_convert_filter_delete(encoder TSRMLS_CC); + mbfl_convert_filter_delete(pc.decoder TSRMLS_CC); + mbfl_convert_filter_delete(pc.decoder_backup TSRMLS_CC); return result; } @@ -7133,7 +7137,7 @@ static const unsigned char zenkana2hankana_table[84][2] = { }; static int -collector_hantozen(int c, void* data) +collector_hantozen(int c, void* data TSRMLS_DC) { int s, mode, n; struct collector_hantozen_data *pc = (struct collector_hantozen_data*)data; @@ -7195,7 +7199,7 @@ collector_hantozen(int c, void* data) if (pc->status) { n = (pc->cache - 0xff60) & 0x3f; pc->status = 0; - (*pc->next_filter->filter_function)(0x3000 + hankana2zenkata_table[n], pc->next_filter); + (*pc->next_filter->filter_function)(0x3000 + hankana2zenkata_table[n], pc->next_filter TSRMLS_CC); } } } else if ((mode & 0x200) && (mode & 0x800)) { /* hankaku kana to zenkaku hirangana and glue voiced sound mark */ @@ -7222,7 +7226,7 @@ collector_hantozen(int c, void* data) if (pc->status) { n = (pc->cache - 0xff60) & 0x3f; pc->status = 0; - (*pc->next_filter->filter_function)(0x3000 + hankana2zenhira_table[n], pc->next_filter); + (*pc->next_filter->filter_function)(0x3000 + hankana2zenhira_table[n], pc->next_filter TSRMLS_CC); } } } else if ((mode & 0x100) && c >= 0xff61 && c <= 0xff9f) { /* hankaku kana to zenkaku katakana */ @@ -7236,7 +7240,7 @@ collector_hantozen(int c, void* data) if ((mode & 0x1000) && c >= 0x30a1 && c <= 0x30f4) { /* Zenkaku katakana to hankaku kana */ n = c - 0x30a1; if (zenkana2hankana_table[n][1] != 0) { - (*pc->next_filter->filter_function)(0xff00 + zenkana2hankana_table[n][0], pc->next_filter); + (*pc->next_filter->filter_function)(0xff00 + zenkana2hankana_table[n][0], pc->next_filter TSRMLS_CC); s = 0xff00 + zenkana2hankana_table[n][1]; } else { s = 0xff00 + zenkana2hankana_table[n][0]; @@ -7244,7 +7248,7 @@ collector_hantozen(int c, void* data) } else if ((mode & 0x2000) && c >= 0x3041 && c <= 0x3093) { /* Zenkaku hirangana to hankaku kana */ n = c - 0x3041; if (zenkana2hankana_table[n][1] != 0) { - (*pc->next_filter->filter_function)(0xff00 + zenkana2hankana_table[n][0], pc->next_filter); + (*pc->next_filter->filter_function)(0xff00 + zenkana2hankana_table[n][0], pc->next_filter TSRMLS_CC); s = 0xff00 + zenkana2hankana_table[n][1]; } else { s = 0xff00 + zenkana2hankana_table[n][0]; @@ -7330,11 +7334,11 @@ collector_hantozen(int c, void* data) } } - return (*pc->next_filter->filter_function)(s, pc->next_filter); + return (*pc->next_filter->filter_function)(s, pc->next_filter TSRMLS_CC); } static int -collector_hantozen_flush(struct collector_hantozen_data *pc) +collector_hantozen_flush(struct collector_hantozen_data *pc TSRMLS_DC) { int ret, n; @@ -7342,9 +7346,9 @@ collector_hantozen_flush(struct collector_hantozen_data *pc) if (pc->status) { n = (pc->cache - 0xff60) & 0x3f; if (pc->mode & 0x100) { /* hankaku kana to zenkaku katakana */ - ret = (*pc->next_filter->filter_function)(0x3000 + hankana2zenkata_table[n], pc->next_filter); + ret = (*pc->next_filter->filter_function)(0x3000 + hankana2zenkata_table[n], pc->next_filter TSRMLS_CC); } else if (pc->mode & 0x200) { /* hankaku kana to zenkaku hirangana */ - ret = (*pc->next_filter->filter_function)(0x3000 + hankana2zenhira_table[n], pc->next_filter); + ret = (*pc->next_filter->filter_function)(0x3000 + hankana2zenhira_table[n], pc->next_filter TSRMLS_CC); } pc->status = 0; } @@ -7356,7 +7360,7 @@ mbfl_string * mbfl_ja_jp_hantozen( mbfl_string *string, mbfl_string *result, - int mode) + int mode TSRMLS_DC) { int n; unsigned char *p; @@ -7374,21 +7378,21 @@ mbfl_ja_jp_hantozen( if (encoding == NULL) { return NULL; } - mbfl_memory_device_init(&device, string->len, 0); + mbfl_memory_device_init(&device, string->len, 0 TSRMLS_CC); mbfl_string_init(result); result->no_language = string->no_language; result->no_encoding = string->no_encoding; decoder = mbfl_convert_filter_new( mbfl_no_encoding_wchar, string->no_encoding, - mbfl_memory_device_output, 0, &device); + mbfl_memory_device_output, 0, &device TSRMLS_CC); encoder = mbfl_convert_filter_new( string->no_encoding, mbfl_no_encoding_wchar, - collector_hantozen, 0, &pc); + collector_hantozen, 0, &pc TSRMLS_CC); if (decoder == NULL || encoder == NULL) { - mbfl_convert_filter_delete(encoder); - mbfl_convert_filter_delete(decoder); + mbfl_convert_filter_delete(encoder TSRMLS_CC); + mbfl_convert_filter_delete(decoder TSRMLS_CC); return NULL; } pc.next_filter = decoder; @@ -7401,19 +7405,19 @@ mbfl_ja_jp_hantozen( n = string->len; if (p != NULL) { while (n > 0) { - if ((*encoder->filter_function)(*p++, encoder) < 0) { + if ((*encoder->filter_function)(*p++, encoder TSRMLS_CC) < 0) { break; } n--; } } - mbfl_convert_filter_flush(encoder); - collector_hantozen_flush(&pc); - mbfl_convert_filter_flush(decoder); - result = mbfl_memory_device_result(&device, result); - mbfl_convert_filter_delete(encoder); - mbfl_convert_filter_delete(decoder); + mbfl_convert_filter_flush(encoder TSRMLS_CC); + collector_hantozen_flush(&pc TSRMLS_CC); + mbfl_convert_filter_flush(decoder TSRMLS_CC); + result = mbfl_memory_device_result(&device, result TSRMLS_CC); + mbfl_convert_filter_delete(encoder TSRMLS_CC); + mbfl_convert_filter_delete(decoder TSRMLS_CC); return result; } @@ -7443,7 +7447,7 @@ struct mime_header_encoder_data { }; static int -mime_header_encoder_block_collector(int c, void *data) +mime_header_encoder_block_collector(int c, void *data TSRMLS_DC) { int n; struct mime_header_encoder_data *pe = (struct mime_header_encoder_data *)data; @@ -7451,32 +7455,32 @@ mime_header_encoder_block_collector(int c, void *data) switch (pe->status2) { case 1: /* encoded word */ pe->prevpos = pe->outdev.pos; - mbfl_convert_filter_copy(pe->conv2_filter, pe->conv2_filter_backup); - mbfl_convert_filter_copy(pe->encod_filter, pe->encod_filter_backup); - (*pe->conv2_filter->filter_function)(c, pe->conv2_filter); - (*pe->conv2_filter->filter_flush)(pe->conv2_filter); - (*pe->encod_filter->filter_flush)(pe->encod_filter); + mbfl_convert_filter_copy(pe->conv2_filter, pe->conv2_filter_backup TSRMLS_CC); + mbfl_convert_filter_copy(pe->encod_filter, pe->encod_filter_backup TSRMLS_CC); + (*pe->conv2_filter->filter_function)(c, pe->conv2_filter TSRMLS_CC); + (*pe->conv2_filter->filter_flush)(pe->conv2_filter TSRMLS_CC); + (*pe->encod_filter->filter_flush)(pe->encod_filter TSRMLS_CC); n = pe->outdev.pos - pe->linehead + pe->firstindent; pe->outdev.pos = pe->prevpos; - mbfl_convert_filter_copy(pe->conv2_filter_backup, pe->conv2_filter); - mbfl_convert_filter_copy(pe->encod_filter_backup, pe->encod_filter); + mbfl_convert_filter_copy(pe->conv2_filter_backup, pe->conv2_filter TSRMLS_CC); + mbfl_convert_filter_copy(pe->encod_filter_backup, pe->encod_filter TSRMLS_CC); if (n >= 74) { - (*pe->conv2_filter->filter_flush)(pe->conv2_filter); - (*pe->encod_filter->filter_flush)(pe->encod_filter); - mbfl_memory_device_strncat(&pe->outdev, "\x3f\x3d", 2); /* ?= */ - mbfl_memory_device_strncat(&pe->outdev, pe->lwsp, pe->lwsplen); + (*pe->conv2_filter->filter_flush)(pe->conv2_filter TSRMLS_CC); + (*pe->encod_filter->filter_flush)(pe->encod_filter TSRMLS_CC); + mbfl_memory_device_strncat(&pe->outdev, "\x3f\x3d", 2 TSRMLS_CC); /* ?= */ + mbfl_memory_device_strncat(&pe->outdev, pe->lwsp, pe->lwsplen TSRMLS_CC); pe->linehead = pe->outdev.pos; pe->firstindent = 0; - mbfl_memory_device_strncat(&pe->outdev, pe->encname, pe->encnamelen); - c = (*pe->conv2_filter->filter_function)(c, pe->conv2_filter); + mbfl_memory_device_strncat(&pe->outdev, pe->encname, pe->encnamelen TSRMLS_CC); + c = (*pe->conv2_filter->filter_function)(c, pe->conv2_filter TSRMLS_CC); } else { - c = (*pe->conv2_filter->filter_function)(c, pe->conv2_filter); + c = (*pe->conv2_filter->filter_function)(c, pe->conv2_filter TSRMLS_CC); } break; default: - mbfl_memory_device_strncat(&pe->outdev, pe->encname, pe->encnamelen); - c = (*pe->conv2_filter->filter_function)(c, pe->conv2_filter); + mbfl_memory_device_strncat(&pe->outdev, pe->encname, pe->encnamelen TSRMLS_CC); + c = (*pe->conv2_filter->filter_function)(c, pe->conv2_filter TSRMLS_CC); pe->status2 = 1; break; } @@ -7485,47 +7489,47 @@ mime_header_encoder_block_collector(int c, void *data) } static int -mime_header_encoder_collector(int c, void *data) +mime_header_encoder_collector(int c, void *data TSRMLS_DC) { int n; struct mime_header_encoder_data *pe = (struct mime_header_encoder_data *)data; switch (pe->status1) { case 11: /* encoded word */ - (*pe->block_filter->filter_function)(c, pe->block_filter); + (*pe->block_filter->filter_function)(c, pe->block_filter TSRMLS_CC); break; default: /* ASCII */ if (c >= 0x21 && c < 0x7f) { /* ASCII exclude SPACE and CTLs */ - mbfl_memory_device_output(c, &pe->tmpdev); + mbfl_memory_device_output(c, &pe->tmpdev TSRMLS_CC); pe->status1 = 1; } else if (pe->status1 == 0 && c == 0x20) { /* repeat SPACE */ - mbfl_memory_device_output(c, &pe->tmpdev); + mbfl_memory_device_output(c, &pe->tmpdev TSRMLS_CC); } else { if (pe->tmpdev.pos < 74 && c == 0x20) { n = pe->outdev.pos - pe->linehead + pe->tmpdev.pos + pe->firstindent; if (n > 74) { - mbfl_memory_device_strncat(&pe->outdev, pe->lwsp, pe->lwsplen); /* LWSP */ + mbfl_memory_device_strncat(&pe->outdev, pe->lwsp, pe->lwsplen TSRMLS_CC); /* LWSP */ pe->linehead = pe->outdev.pos; pe->firstindent = 0; } else if (pe->outdev.pos > 0) { - mbfl_memory_device_output(0x20, &pe->outdev); + mbfl_memory_device_output(0x20, &pe->outdev TSRMLS_CC); } - mbfl_memory_device_devcat(&pe->outdev, &pe->tmpdev); - mbfl_memory_device_reset(&pe->tmpdev); + mbfl_memory_device_devcat(&pe->outdev, &pe->tmpdev TSRMLS_CC); + mbfl_memory_device_reset(&pe->tmpdev TSRMLS_CC); pe->status1 = 0; } else { n = pe->outdev.pos - pe->linehead + pe->encnamelen + pe->firstindent; if (n > 60) { - mbfl_memory_device_strncat(&pe->outdev, pe->lwsp, pe->lwsplen); /* LWSP */ + mbfl_memory_device_strncat(&pe->outdev, pe->lwsp, pe->lwsplen TSRMLS_CC); /* LWSP */ pe->linehead = pe->outdev.pos; pe->firstindent = 0; } else if (pe->outdev.pos > 0) { - mbfl_memory_device_output(0x20, &pe->outdev); + mbfl_memory_device_output(0x20, &pe->outdev TSRMLS_CC); } - mbfl_convert_filter_devcat(pe->block_filter, &pe->tmpdev); - mbfl_memory_device_reset(&pe->tmpdev); - (*pe->block_filter->filter_function)(c, pe->block_filter); + mbfl_convert_filter_devcat(pe->block_filter, &pe->tmpdev TSRMLS_CC); + mbfl_memory_device_reset(&pe->tmpdev TSRMLS_CC); + (*pe->block_filter->filter_function)(c, pe->block_filter TSRMLS_CC); pe->status1 = 11; } } @@ -7536,36 +7540,36 @@ mime_header_encoder_collector(int c, void *data) } mbfl_string * -mime_header_encoder_result(struct mime_header_encoder_data *pe, mbfl_string *result) +mime_header_encoder_result(struct mime_header_encoder_data *pe, mbfl_string *result TSRMLS_DC) { if (pe->status1 >= 10) { - (*pe->conv2_filter->filter_flush)(pe->conv2_filter); - (*pe->encod_filter->filter_flush)(pe->encod_filter); - mbfl_memory_device_strncat(&pe->outdev, "\x3f\x3d", 2); /* ?= */ + (*pe->conv2_filter->filter_flush)(pe->conv2_filter TSRMLS_CC); + (*pe->encod_filter->filter_flush)(pe->encod_filter TSRMLS_CC); + mbfl_memory_device_strncat(&pe->outdev, "\x3f\x3d", 2 TSRMLS_CC); /* ?= */ } else if (pe->tmpdev.pos > 0) { if (pe->outdev.pos > 0) { if ((pe->outdev.pos - pe->linehead + pe->tmpdev.pos) > 74) { - mbfl_memory_device_strncat(&pe->outdev, pe->lwsp, pe->lwsplen); + mbfl_memory_device_strncat(&pe->outdev, pe->lwsp, pe->lwsplen TSRMLS_CC); } else { - mbfl_memory_device_output(0x20, &pe->outdev); + mbfl_memory_device_output(0x20, &pe->outdev TSRMLS_CC); } } - mbfl_memory_device_devcat(&pe->outdev, &pe->tmpdev); + mbfl_memory_device_devcat(&pe->outdev, &pe->tmpdev TSRMLS_CC); } - mbfl_memory_device_reset(&pe->tmpdev); + mbfl_memory_device_reset(&pe->tmpdev TSRMLS_CC); pe->prevpos = 0; pe->linehead = 0; pe->status1 = 0; pe->status2 = 0; - return mbfl_memory_device_result(&pe->outdev, result); + return mbfl_memory_device_result(&pe->outdev, result TSRMLS_CC); } struct mime_header_encoder_data* mime_header_encoder_new( enum mbfl_no_encoding incode, enum mbfl_no_encoding outcode, - enum mbfl_no_encoding transenc) + enum mbfl_no_encoding transenc TSRMLS_DC) { int n; const char *s; @@ -7583,8 +7587,8 @@ mime_header_encoder_new( return NULL; } - mbfl_memory_device_init(&pe->outdev, 0, 0); - mbfl_memory_device_init(&pe->tmpdev, 0, 0); + mbfl_memory_device_init(&pe->outdev, 0, 0 TSRMLS_CC); + mbfl_memory_device_init(&pe->tmpdev, 0, 0 TSRMLS_CC); pe->prevpos = 0; pe->linehead = 0; pe->firstindent = 0; @@ -7618,25 +7622,25 @@ mime_header_encoder_new( pe->lwsplen = n; /* transfer encode filter */ - pe->encod_filter = mbfl_convert_filter_new(outcode, transenc, mbfl_memory_device_output, 0, &(pe->outdev)); - pe->encod_filter_backup = mbfl_convert_filter_new(outcode, transenc, mbfl_memory_device_output, 0, &(pe->outdev)); + pe->encod_filter = mbfl_convert_filter_new(outcode, transenc, mbfl_memory_device_output, 0, &(pe->outdev) TSRMLS_CC); + pe->encod_filter_backup = mbfl_convert_filter_new(outcode, transenc, mbfl_memory_device_output, 0, &(pe->outdev) TSRMLS_CC); /* Output code filter */ - pe->conv2_filter = mbfl_convert_filter_new(mbfl_no_encoding_wchar, outcode, mbfl_filter_output_pipe, 0, pe->encod_filter); - pe->conv2_filter_backup = mbfl_convert_filter_new(mbfl_no_encoding_wchar, outcode, mbfl_filter_output_pipe, 0, pe->encod_filter); + pe->conv2_filter = mbfl_convert_filter_new(mbfl_no_encoding_wchar, outcode, mbfl_filter_output_pipe, 0, pe->encod_filter TSRMLS_CC); + pe->conv2_filter_backup = mbfl_convert_filter_new(mbfl_no_encoding_wchar, outcode, mbfl_filter_output_pipe, 0, pe->encod_filter TSRMLS_CC); /* encoded block filter */ - pe->block_filter = mbfl_convert_filter_new(mbfl_no_encoding_wchar, mbfl_no_encoding_wchar, mime_header_encoder_block_collector, 0, pe); + pe->block_filter = mbfl_convert_filter_new(mbfl_no_encoding_wchar, mbfl_no_encoding_wchar, mime_header_encoder_block_collector, 0, pe TSRMLS_CC); /* Input code filter */ - pe->conv1_filter = mbfl_convert_filter_new(incode, mbfl_no_encoding_wchar, mime_header_encoder_collector, 0, pe); + pe->conv1_filter = mbfl_convert_filter_new(incode, mbfl_no_encoding_wchar, mime_header_encoder_collector, 0, pe TSRMLS_CC); if (pe->encod_filter == NULL || pe->encod_filter_backup == NULL || pe->conv2_filter == NULL || pe->conv2_filter_backup == NULL || pe->conv1_filter == NULL) { - mime_header_encoder_delete(pe); + mime_header_encoder_delete(pe TSRMLS_CC); return NULL; } @@ -7652,25 +7656,25 @@ mime_header_encoder_new( } void -mime_header_encoder_delete(struct mime_header_encoder_data *pe) +mime_header_encoder_delete(struct mime_header_encoder_data *pe TSRMLS_DC) { if (pe) { - mbfl_convert_filter_delete(pe->conv1_filter); - mbfl_convert_filter_delete(pe->block_filter); - mbfl_convert_filter_delete(pe->conv2_filter); - mbfl_convert_filter_delete(pe->conv2_filter_backup); - mbfl_convert_filter_delete(pe->encod_filter); - mbfl_convert_filter_delete(pe->encod_filter_backup); - mbfl_memory_device_clear(&pe->outdev); - mbfl_memory_device_clear(&pe->tmpdev); + mbfl_convert_filter_delete(pe->conv1_filter TSRMLS_CC); + mbfl_convert_filter_delete(pe->block_filter TSRMLS_CC); + mbfl_convert_filter_delete(pe->conv2_filter TSRMLS_CC); + mbfl_convert_filter_delete(pe->conv2_filter_backup TSRMLS_CC); + mbfl_convert_filter_delete(pe->encod_filter TSRMLS_CC); + mbfl_convert_filter_delete(pe->encod_filter_backup TSRMLS_CC); + mbfl_memory_device_clear(&pe->outdev TSRMLS_CC); + mbfl_memory_device_clear(&pe->tmpdev TSRMLS_CC); mbfl_free((void*)pe); } } int -mime_header_encoder_feed(int c, struct mime_header_encoder_data *pe) +mime_header_encoder_feed(int c, struct mime_header_encoder_data *pe TSRMLS_DC) { - return (*pe->conv1_filter->filter_function)(c, pe->conv1_filter); + return (*pe->conv1_filter->filter_function)(c, pe->conv1_filter TSRMLS_CC); } mbfl_string * @@ -7680,7 +7684,7 @@ mbfl_mime_header_encode( enum mbfl_no_encoding outcode, enum mbfl_no_encoding encoding, const char *linefeed, - int indent) + int indent TSRMLS_DC) { int n; unsigned char *p; @@ -7690,7 +7694,7 @@ mbfl_mime_header_encode( result->no_language = string->no_language; result->no_encoding = mbfl_no_encoding_ascii; - pe = mime_header_encoder_new(string->no_encoding, outcode, encoding); + pe = mime_header_encoder_new(string->no_encoding, outcode, encoding TSRMLS_CC); if (pe == NULL) { return NULL; } @@ -7711,12 +7715,12 @@ mbfl_mime_header_encode( n = string->len; p = string->val; while (n > 0) { - (*pe->conv1_filter->filter_function)(*p++, pe->conv1_filter); + (*pe->conv1_filter->filter_function)(*p++, pe->conv1_filter TSRMLS_CC); n--; } - result = mime_header_encoder_result(pe, result); - mime_header_encoder_delete(pe); + result = mime_header_encoder_result(pe, result TSRMLS_CC); + mime_header_encoder_delete(pe TSRMLS_CC); return result; } @@ -7739,7 +7743,7 @@ struct mime_header_decoder_data { }; static int -mime_header_decoder_collector(int c, void* data) +mime_header_decoder_collector(int c, void* data TSRMLS_DC) { mbfl_encoding *encoding; struct mime_header_decoder_data *pd = (struct mime_header_decoder_data*)data; @@ -7747,18 +7751,18 @@ mime_header_decoder_collector(int c, void* data) switch (pd->status) { case 1: if (c == 0x3f) { /* ? */ - mbfl_memory_device_output(c, &pd->tmpdev); + mbfl_memory_device_output(c, &pd->tmpdev TSRMLS_CC); pd->cspos = pd->tmpdev.pos; pd->status = 2; } else { - mbfl_convert_filter_devcat(pd->conv1_filter, &pd->tmpdev); - mbfl_memory_device_reset(&pd->tmpdev); + mbfl_convert_filter_devcat(pd->conv1_filter, &pd->tmpdev TSRMLS_CC); + mbfl_memory_device_reset(&pd->tmpdev TSRMLS_CC); if (c == 0x3d) { /* = */ - mbfl_memory_device_output(c, &pd->tmpdev); + mbfl_memory_device_output(c, &pd->tmpdev TSRMLS_CC); } else if (c == 0x0d || c == 0x0a) { /* CR or LF */ pd->status = 9; } else { - (*pd->conv1_filter->filter_function)(c, pd->conv1_filter); + (*pd->conv1_filter->filter_function)(c, pd->conv1_filter TSRMLS_CC); pd->status = 0; } } @@ -7766,30 +7770,30 @@ mime_header_decoder_collector(int c, void* data) case 2: /* store charset string */ if (c == 0x3f) { /* ? */ /* identify charset */ - mbfl_memory_device_output('\0', &pd->tmpdev); + mbfl_memory_device_output('\0', &pd->tmpdev TSRMLS_CC); encoding = mbfl_name2encoding(&pd->tmpdev.buffer[pd->cspos]); if (encoding != NULL) { pd->incode = encoding->no_encoding; pd->status = 3; } - mbfl_memory_device_unput(&pd->tmpdev); - mbfl_memory_device_output(c, &pd->tmpdev); + mbfl_memory_device_unput(&pd->tmpdev TSRMLS_CC); + mbfl_memory_device_output(c, &pd->tmpdev TSRMLS_CC); } else { - mbfl_memory_device_output(c, &pd->tmpdev); + mbfl_memory_device_output(c, &pd->tmpdev TSRMLS_CC); if (pd->tmpdev.pos > 100) { /* too long charset string */ pd->status = 0; } else if (c == 0x0d || c == 0x0a) { /* CR or LF */ - mbfl_memory_device_unput(&pd->tmpdev); + mbfl_memory_device_unput(&pd->tmpdev TSRMLS_CC); pd->status = 9; } if (pd->status != 2) { - mbfl_convert_filter_devcat(pd->conv1_filter, &pd->tmpdev); - mbfl_memory_device_reset(&pd->tmpdev); + mbfl_convert_filter_devcat(pd->conv1_filter, &pd->tmpdev TSRMLS_CC); + mbfl_memory_device_reset(&pd->tmpdev TSRMLS_CC); } } break; case 3: /* identify encoding */ - mbfl_memory_device_output(c, &pd->tmpdev); + mbfl_memory_device_output(c, &pd->tmpdev TSRMLS_CC); if (c == 0x42 || c == 0x62) { /* 'B' or 'b' */ pd->encoding = mbfl_no_encoding_base64; pd->status = 4; @@ -7798,52 +7802,52 @@ mime_header_decoder_collector(int c, void* data) pd->status = 4; } else { if (c == 0x0d || c == 0x0a) { /* CR or LF */ - mbfl_memory_device_unput(&pd->tmpdev); + mbfl_memory_device_unput(&pd->tmpdev TSRMLS_CC); pd->status = 9; } else { pd->status = 0; } - mbfl_convert_filter_devcat(pd->conv1_filter, &pd->tmpdev); - mbfl_memory_device_reset(&pd->tmpdev); + mbfl_convert_filter_devcat(pd->conv1_filter, &pd->tmpdev TSRMLS_CC); + mbfl_memory_device_reset(&pd->tmpdev TSRMLS_CC); } break; case 4: /* reset filter */ - mbfl_memory_device_output(c, &pd->tmpdev); + mbfl_memory_device_output(c, &pd->tmpdev TSRMLS_CC); if (c == 0x3f) { /* ? */ /* charset convert filter */ - mbfl_convert_filter_reset(pd->conv1_filter, pd->incode, mbfl_no_encoding_wchar); + mbfl_convert_filter_reset(pd->conv1_filter, pd->incode, mbfl_no_encoding_wchar TSRMLS_CC); /* decode filter */ - mbfl_convert_filter_reset(pd->deco_filter, pd->encoding, mbfl_no_encoding_8bit); + mbfl_convert_filter_reset(pd->deco_filter, pd->encoding, mbfl_no_encoding_8bit TSRMLS_CC); pd->status = 5; } else { if (c == 0x0d || c == 0x0a) { /* CR or LF */ - mbfl_memory_device_unput(&pd->tmpdev); + mbfl_memory_device_unput(&pd->tmpdev TSRMLS_CC); pd->status = 9; } else { pd->status = 0; } - mbfl_convert_filter_devcat(pd->conv1_filter, &pd->tmpdev); + mbfl_convert_filter_devcat(pd->conv1_filter, &pd->tmpdev TSRMLS_CC); } - mbfl_memory_device_reset(&pd->tmpdev); + mbfl_memory_device_reset(&pd->tmpdev TSRMLS_CC); break; case 5: /* encoded block */ if (c == 0x3f) { /* ? */ pd->status = 6; } else { - (*pd->deco_filter->filter_function)(c, pd->deco_filter); + (*pd->deco_filter->filter_function)(c, pd->deco_filter TSRMLS_CC); } break; case 6: /* check end position */ if (c == 0x3d) { /* = */ /* flush and reset filter */ - (*pd->deco_filter->filter_flush)(pd->deco_filter); - (*pd->conv1_filter->filter_flush)(pd->conv1_filter); - mbfl_convert_filter_reset(pd->conv1_filter, mbfl_no_encoding_ascii, mbfl_no_encoding_wchar); + (*pd->deco_filter->filter_flush)(pd->deco_filter TSRMLS_CC); + (*pd->conv1_filter->filter_flush)(pd->conv1_filter TSRMLS_CC); + mbfl_convert_filter_reset(pd->conv1_filter, mbfl_no_encoding_ascii, mbfl_no_encoding_wchar TSRMLS_CC); pd->status = 7; } else { - (*pd->deco_filter->filter_function)(0x3f, pd->deco_filter); + (*pd->deco_filter->filter_function)(0x3f, pd->deco_filter TSRMLS_CC); if (c != 0x3f) { /* ? */ - (*pd->deco_filter->filter_function)(c, pd->deco_filter); + (*pd->deco_filter->filter_function)(c, pd->deco_filter TSRMLS_CC); pd->status = 5; } } @@ -7852,12 +7856,12 @@ mime_header_decoder_collector(int c, void* data) if (c == 0x0d || c == 0x0a) { /* CR LF */ pd->status = 8; } else { - mbfl_memory_device_output(c, &pd->tmpdev); + mbfl_memory_device_output(c, &pd->tmpdev TSRMLS_CC); if (c == 0x3d) { /* = */ pd->status = 1; } else if (c != 0x20 && c != 0x09) { /* not space */ - mbfl_convert_filter_devcat(pd->conv1_filter, &pd->tmpdev); - mbfl_memory_device_reset(&pd->tmpdev); + mbfl_convert_filter_devcat(pd->conv1_filter, &pd->tmpdev TSRMLS_CC); + mbfl_memory_device_reset(&pd->tmpdev TSRMLS_CC); pd->status = 0; } } @@ -7867,17 +7871,17 @@ mime_header_decoder_collector(int c, void* data) if (c != 0x0d && c != 0x0a && c != 0x20 && c != 0x09) { if (c == 0x3d) { /* = */ if (pd->status == 8) { - mbfl_memory_device_output(0x20, &pd->tmpdev); /* SPACE */ + mbfl_memory_device_output(0x20, &pd->tmpdev TSRMLS_CC); /* SPACE */ } else { - (*pd->conv1_filter->filter_function)(0x20, pd->conv1_filter); + (*pd->conv1_filter->filter_function)(0x20, pd->conv1_filter TSRMLS_CC); } - mbfl_memory_device_output(c, &pd->tmpdev); + mbfl_memory_device_output(c, &pd->tmpdev TSRMLS_CC); pd->status = 1; } else { - mbfl_memory_device_output(0x20, &pd->tmpdev); - mbfl_memory_device_output(c, &pd->tmpdev); - mbfl_convert_filter_devcat(pd->conv1_filter, &pd->tmpdev); - mbfl_memory_device_reset(&pd->tmpdev); + mbfl_memory_device_output(0x20, &pd->tmpdev TSRMLS_CC); + mbfl_memory_device_output(c, &pd->tmpdev TSRMLS_CC); + mbfl_convert_filter_devcat(pd->conv1_filter, &pd->tmpdev TSRMLS_CC); + mbfl_memory_device_reset(&pd->tmpdev TSRMLS_CC); pd->status = 0; } } @@ -7886,10 +7890,10 @@ mime_header_decoder_collector(int c, void* data) if (c == 0x0d || c == 0x0a) { /* CR LF */ pd->status = 9; } else if (c == 0x3d) { /* = */ - mbfl_memory_device_output(c, &pd->tmpdev); + mbfl_memory_device_output(c, &pd->tmpdev TSRMLS_CC); pd->status = 1; } else { - (*pd->conv1_filter->filter_function)(c, pd->conv1_filter); + (*pd->conv1_filter->filter_function)(c, pd->conv1_filter TSRMLS_CC); } break; } @@ -7898,7 +7902,7 @@ mime_header_decoder_collector(int c, void* data) } mbfl_string * -mime_header_decoder_result(struct mime_header_decoder_data *pd, mbfl_string *result) +mime_header_decoder_result(struct mime_header_decoder_data *pd, mbfl_string *result TSRMLS_DC) { switch (pd->status) { case 1: @@ -7908,23 +7912,23 @@ mime_header_decoder_result(struct mime_header_decoder_data *pd, mbfl_string *res case 7: case 8: case 9: - mbfl_convert_filter_devcat(pd->conv1_filter, &pd->tmpdev); + mbfl_convert_filter_devcat(pd->conv1_filter, &pd->tmpdev TSRMLS_CC); break; case 5: case 6: - (*pd->deco_filter->filter_flush)(pd->deco_filter); - (*pd->conv1_filter->filter_flush)(pd->conv1_filter); + (*pd->deco_filter->filter_flush)(pd->deco_filter TSRMLS_CC); + (*pd->conv1_filter->filter_flush)(pd->conv1_filter TSRMLS_CC); break; } - (*pd->conv2_filter->filter_flush)(pd->conv2_filter); - mbfl_memory_device_reset(&pd->tmpdev); + (*pd->conv2_filter->filter_flush)(pd->conv2_filter TSRMLS_CC); + mbfl_memory_device_reset(&pd->tmpdev TSRMLS_CC); pd->status = 0; - return mbfl_memory_device_result(&pd->outdev, result); + return mbfl_memory_device_result(&pd->outdev, result TSRMLS_CC); } struct mime_header_decoder_data* -mime_header_decoder_new(enum mbfl_no_encoding outcode) +mime_header_decoder_new(enum mbfl_no_encoding outcode TSRMLS_DC) { struct mime_header_decoder_data *pd; @@ -7933,21 +7937,21 @@ mime_header_decoder_new(enum mbfl_no_encoding outcode) return NULL; } - mbfl_memory_device_init(&pd->outdev, 0, 0); - mbfl_memory_device_init(&pd->tmpdev, 0, 0); + mbfl_memory_device_init(&pd->outdev, 0, 0 TSRMLS_CC); + mbfl_memory_device_init(&pd->tmpdev, 0, 0 TSRMLS_CC); pd->cspos = 0; pd->status = 0; pd->encoding = mbfl_no_encoding_pass; pd->incode = mbfl_no_encoding_ascii; pd->outcode = outcode; /* charset convert filter */ - pd->conv2_filter = mbfl_convert_filter_new(mbfl_no_encoding_wchar, pd->outcode, mbfl_memory_device_output, 0, &pd->outdev); - pd->conv1_filter = mbfl_convert_filter_new(pd->incode, mbfl_no_encoding_wchar, mbfl_filter_output_pipe, 0, pd->conv2_filter); + pd->conv2_filter = mbfl_convert_filter_new(mbfl_no_encoding_wchar, pd->outcode, mbfl_memory_device_output, 0, &pd->outdev TSRMLS_CC); + pd->conv1_filter = mbfl_convert_filter_new(pd->incode, mbfl_no_encoding_wchar, mbfl_filter_output_pipe, 0, pd->conv2_filter TSRMLS_CC); /* decode filter */ - pd->deco_filter = mbfl_convert_filter_new(pd->encoding, mbfl_no_encoding_8bit, mbfl_filter_output_pipe, 0, pd->conv1_filter); + pd->deco_filter = mbfl_convert_filter_new(pd->encoding, mbfl_no_encoding_8bit, mbfl_filter_output_pipe, 0, pd->conv1_filter TSRMLS_CC); if (pd->conv1_filter == NULL || pd->conv2_filter == NULL || pd->deco_filter == NULL) { - mime_header_decoder_delete(pd); + mime_header_decoder_delete(pd TSRMLS_CC); return NULL; } @@ -7955,29 +7959,29 @@ mime_header_decoder_new(enum mbfl_no_encoding outcode) } void -mime_header_decoder_delete(struct mime_header_decoder_data *pd) +mime_header_decoder_delete(struct mime_header_decoder_data *pd TSRMLS_DC) { if (pd) { - mbfl_convert_filter_delete(pd->conv2_filter); - mbfl_convert_filter_delete(pd->conv1_filter); - mbfl_convert_filter_delete(pd->deco_filter); - mbfl_memory_device_clear(&pd->outdev); - mbfl_memory_device_clear(&pd->tmpdev); + mbfl_convert_filter_delete(pd->conv2_filter TSRMLS_CC); + mbfl_convert_filter_delete(pd->conv1_filter TSRMLS_CC); + mbfl_convert_filter_delete(pd->deco_filter TSRMLS_CC); + mbfl_memory_device_clear(&pd->outdev TSRMLS_CC); + mbfl_memory_device_clear(&pd->tmpdev TSRMLS_CC); mbfl_free((void*)pd); } } int -mime_header_decoder_feed(int c, struct mime_header_decoder_data *pd) +mime_header_decoder_feed(int c, struct mime_header_decoder_data *pd TSRMLS_DC) { - return mime_header_decoder_collector(c, pd); + return mime_header_decoder_collector(c, pd TSRMLS_CC); } mbfl_string * mbfl_mime_header_decode( mbfl_string *string, mbfl_string *result, - enum mbfl_no_encoding outcode) + enum mbfl_no_encoding outcode TSRMLS_DC) { int n; unsigned char *p; @@ -7987,7 +7991,7 @@ mbfl_mime_header_decode( result->no_language = string->no_language; result->no_encoding = outcode; - pd = mime_header_decoder_new(outcode); + pd = mime_header_decoder_new(outcode TSRMLS_CC); if (pd == NULL) { return NULL; } @@ -7996,12 +8000,12 @@ mbfl_mime_header_decode( n = string->len; p = string->val; while (n > 0) { - mime_header_decoder_collector(*p++, pd); + mime_header_decoder_collector(*p++, pd TSRMLS_CC); n--; } - result = mime_header_decoder_result(pd, result); - mime_header_decoder_delete(pd); + result = mime_header_decoder_result(pd, result TSRMLS_CC); + mime_header_decoder_delete(pd TSRMLS_CC); return result; } @@ -8021,7 +8025,7 @@ struct collector_htmlnumericentity_data { }; static int -collector_encode_htmlnumericentity(int c, void *data) +collector_encode_htmlnumericentity(int c, void *data TSRMLS_DC) { struct collector_htmlnumericentity_data *pc = (struct collector_htmlnumericentity_data *)data; int f, n, s, r, d, size, *mapelm; @@ -8034,8 +8038,8 @@ collector_encode_htmlnumericentity(int c, void *data) if (c >= mapelm[0] && c <= mapelm[1]) { s = (c + mapelm[2]) & mapelm[3]; if (s >= 0) { - (*pc->decoder->filter_function)(0x26, pc->decoder); /* '&' */ - (*pc->decoder->filter_function)(0x23, pc->decoder); /* '#' */ + (*pc->decoder->filter_function)(0x26, pc->decoder TSRMLS_CC); /* '&' */ + (*pc->decoder->filter_function)(0x23, pc->decoder TSRMLS_CC); /* '#' */ r = 100000000; s %= r; while (r > 0) { @@ -8043,15 +8047,15 @@ collector_encode_htmlnumericentity(int c, void *data) if (d || f) { f = 1; s %= r; - (*pc->decoder->filter_function)(mbfl_hexchar_table[d], pc->decoder); + (*pc->decoder->filter_function)(mbfl_hexchar_table[d], pc->decoder TSRMLS_CC); } r /= 10; } if (!f) { f = 1; - (*pc->decoder->filter_function)(mbfl_hexchar_table[0], pc->decoder); + (*pc->decoder->filter_function)(mbfl_hexchar_table[0], pc->decoder TSRMLS_CC); } - (*pc->decoder->filter_function)(0x3b, pc->decoder); /* ';' */ + (*pc->decoder->filter_function)(0x3b, pc->decoder TSRMLS_CC); /* ';' */ } } if (f) { @@ -8060,14 +8064,14 @@ collector_encode_htmlnumericentity(int c, void *data) n++; } if (!f) { - (*pc->decoder->filter_function)(c, pc->decoder); + (*pc->decoder->filter_function)(c, pc->decoder TSRMLS_CC); } return c; } static int -collector_decode_htmlnumericentity(int c, void *data) +collector_decode_htmlnumericentity(int c, void *data TSRMLS_DC) { struct collector_htmlnumericentity_data *pc = (struct collector_htmlnumericentity_data *)data; int f, n, s, r, d, size, *mapelm; @@ -8078,8 +8082,8 @@ collector_decode_htmlnumericentity(int c, void *data) pc->status = 2; } else { pc->status = 0; - (*pc->decoder->filter_function)(0x26, pc->decoder); /* '&' */ - (*pc->decoder->filter_function)(c, pc->decoder); + (*pc->decoder->filter_function)(0x26, pc->decoder TSRMLS_CC); /* '&' */ + (*pc->decoder->filter_function)(c, pc->decoder TSRMLS_CC); } break; case 2: @@ -8089,9 +8093,9 @@ collector_decode_htmlnumericentity(int c, void *data) pc->digit = 1; } else { pc->status = 0; - (*pc->decoder->filter_function)(0x26, pc->decoder); /* '&' */ - (*pc->decoder->filter_function)(0x23, pc->decoder); /* '#' */ - (*pc->decoder->filter_function)(c, pc->decoder); + (*pc->decoder->filter_function)(0x26, pc->decoder TSRMLS_CC); /* '&' */ + (*pc->decoder->filter_function)(0x23, pc->decoder TSRMLS_CC); /* '#' */ + (*pc->decoder->filter_function)(c, pc->decoder TSRMLS_CC); } break; case 3: @@ -8118,9 +8122,9 @@ collector_decode_htmlnumericentity(int c, void *data) d = s - mapelm[2]; if (d >= mapelm[0] && d <= mapelm[1]) { f = 0; - (*pc->decoder->filter_function)(d, pc->decoder); + (*pc->decoder->filter_function)(d, pc->decoder TSRMLS_CC); if (c != 0x3b) { /* ';' */ - (*pc->decoder->filter_function)(c, pc->decoder); + (*pc->decoder->filter_function)(c, pc->decoder TSRMLS_CC); } break; } @@ -8128,8 +8132,8 @@ collector_decode_htmlnumericentity(int c, void *data) } } if (f) { - (*pc->decoder->filter_function)(0x26, pc->decoder); /* '&' */ - (*pc->decoder->filter_function)(0x23, pc->decoder); /* '#' */ + (*pc->decoder->filter_function)(0x26, pc->decoder TSRMLS_CC); /* '&' */ + (*pc->decoder->filter_function)(0x23, pc->decoder TSRMLS_CC); /* '#' */ r = 1; n = pc->digit; while (n > 0) { @@ -8142,16 +8146,16 @@ collector_decode_htmlnumericentity(int c, void *data) d = s/r; s %= r; r /= 10; - (*pc->decoder->filter_function)(mbfl_hexchar_table[d], pc->decoder); + (*pc->decoder->filter_function)(mbfl_hexchar_table[d], pc->decoder TSRMLS_CC); } - (*pc->decoder->filter_function)(c, pc->decoder); + (*pc->decoder->filter_function)(c, pc->decoder TSRMLS_CC); } break; default: if (c == 0x26) { /* '&' */ pc->status = 1; } else { - (*pc->decoder->filter_function)(c, pc->decoder); + (*pc->decoder->filter_function)(c, pc->decoder TSRMLS_CC); } break; } @@ -8165,7 +8169,7 @@ mbfl_html_numeric_entity( mbfl_string *result, int *convmap, int mapsize, - int type) + int type TSRMLS_DC) { struct collector_htmlnumericentity_data pc; mbfl_memory_device device; @@ -8179,28 +8183,28 @@ mbfl_html_numeric_entity( mbfl_string_init(result); result->no_language = string->no_language; result->no_encoding = string->no_encoding; - mbfl_memory_device_init(&device, string->len, 0); + mbfl_memory_device_init(&device, string->len, 0 TSRMLS_CC); /* output code filter */ pc.decoder = mbfl_convert_filter_new( mbfl_no_encoding_wchar, string->no_encoding, - mbfl_memory_device_output, 0, &device); + mbfl_memory_device_output, 0, &device TSRMLS_CC); /* wchar filter */ if (type == 0) { encoder = mbfl_convert_filter_new( string->no_encoding, mbfl_no_encoding_wchar, - collector_encode_htmlnumericentity, 0, &pc); + collector_encode_htmlnumericentity, 0, &pc TSRMLS_CC); } else { encoder = mbfl_convert_filter_new( string->no_encoding, mbfl_no_encoding_wchar, - collector_decode_htmlnumericentity, 0, &pc); + collector_decode_htmlnumericentity, 0, &pc TSRMLS_CC); } if (pc.decoder == NULL || encoder == NULL) { - mbfl_convert_filter_delete(encoder); - mbfl_convert_filter_delete(pc.decoder); + mbfl_convert_filter_delete(encoder TSRMLS_CC); + mbfl_convert_filter_delete(pc.decoder TSRMLS_CC); return NULL; } pc.status = 0; @@ -8214,17 +8218,17 @@ mbfl_html_numeric_entity( n = string->len; if (p != NULL) { while (n > 0) { - if ((*encoder->filter_function)(*p++, encoder) < 0) { + if ((*encoder->filter_function)(*p++, encoder TSRMLS_CC) < 0) { break; } n--; } } - mbfl_convert_filter_flush(encoder); - mbfl_convert_filter_flush(pc.decoder); - result = mbfl_memory_device_result(&device, result); - mbfl_convert_filter_delete(encoder); - mbfl_convert_filter_delete(pc.decoder); + mbfl_convert_filter_flush(encoder TSRMLS_CC); + mbfl_convert_filter_flush(pc.decoder TSRMLS_CC); + result = mbfl_memory_device_result(&device, result TSRMLS_CC); + mbfl_convert_filter_delete(encoder TSRMLS_CC); + mbfl_convert_filter_delete(pc.decoder TSRMLS_CC); return result; } diff --git a/ext/mbstring/mbfilter.h b/ext/mbstring/mbfilter.h index d8dd7725b4..c24d45914b 100644 --- a/ext/mbstring/mbfilter.h +++ b/ext/mbstring/mbfilter.h @@ -293,20 +293,20 @@ typedef struct _mbfl_wchar_device { int allocsz; } mbfl_wchar_device; -void mbfl_memory_device_init(mbfl_memory_device *device, int initsz, int allocsz); -void mbfl_memory_device_realloc(mbfl_memory_device *device, int initsz, int allocsz); -void mbfl_memory_device_clear(mbfl_memory_device *device); -void mbfl_memory_device_reset(mbfl_memory_device *device); -mbfl_string * mbfl_memory_device_result(mbfl_memory_device *device, mbfl_string *result); -int mbfl_memory_device_output(int c, void *data); -int mbfl_memory_device_output2(int c, void *data); -int mbfl_memory_device_output4(int c, void *data); -int mbfl_memory_device_strcat(mbfl_memory_device *device, const char *psrc); -int mbfl_memory_device_strncat(mbfl_memory_device *device, const char *psrc, int len); -int mbfl_memory_device_devcat(mbfl_memory_device *dest, mbfl_memory_device *src); - -void mbfl_wchar_device_init(mbfl_wchar_device *device); -int mbfl_wchar_device_output(int c, void *data); +void mbfl_memory_device_init(mbfl_memory_device *device, int initsz, int allocsz TSRMLS_DC); +void mbfl_memory_device_realloc(mbfl_memory_device *device, int initsz, int allocsz TSRMLS_DC); +void mbfl_memory_device_clear(mbfl_memory_device *device TSRMLS_DC); +void mbfl_memory_device_reset(mbfl_memory_device *device TSRMLS_DC); +mbfl_string * mbfl_memory_device_result(mbfl_memory_device *device, mbfl_string *result TSRMLS_DC); +int mbfl_memory_device_output(int c, void *data TSRMLS_DC); +int mbfl_memory_device_output2(int c, void *data TSRMLS_DC); +int mbfl_memory_device_output4(int c, void *data TSRMLS_DC); +int mbfl_memory_device_strcat(mbfl_memory_device *device, const char *psrc TSRMLS_DC); +int mbfl_memory_device_strncat(mbfl_memory_device *device, const char *psrc, int len TSRMLS_DC); +int mbfl_memory_device_devcat(mbfl_memory_device *dest, mbfl_memory_device *src TSRMLS_DC); + +void mbfl_wchar_device_init(mbfl_wchar_device *device TSRMLS_DC); +int mbfl_wchar_device_output(int c, void *data TSRMLS_DC); /* @@ -319,12 +319,12 @@ int mbfl_wchar_device_output(int c, void *data); typedef struct _mbfl_convert_filter mbfl_convert_filter; struct _mbfl_convert_filter { - void (*filter_ctor)(mbfl_convert_filter *filter); - void (*filter_dtor)(mbfl_convert_filter *filter); - int (*filter_function)(int c, mbfl_convert_filter *filter); - int (*filter_flush)(mbfl_convert_filter *filter); - int (*output_function)(int c, void *data); - int (*flush_function)(void *data); + void (*filter_ctor)(mbfl_convert_filter *filter TSRMLS_DC); + void (*filter_dtor)(mbfl_convert_filter *filter TSRMLS_DC); + int (*filter_function)(int c, mbfl_convert_filter *filter TSRMLS_DC); + int (*filter_flush)(mbfl_convert_filter *filter TSRMLS_DC); + int (*output_function)(int c, void *data TSRMLS_DC); + int (*flush_function)(void *data TSRMLS_DC); void *data; int status; int cache; @@ -337,25 +337,25 @@ struct _mbfl_convert_filter { struct mbfl_convert_vtbl { enum mbfl_no_encoding from; enum mbfl_no_encoding to; - void (*filter_ctor)(mbfl_convert_filter *filter); - void (*filter_dtor)(mbfl_convert_filter *filter); - int (*filter_function)(int c, mbfl_convert_filter *filter); - int (*filter_flush)(mbfl_convert_filter *filter); + void (*filter_ctor)(mbfl_convert_filter *filter TSRMLS_DC); + void (*filter_dtor)(mbfl_convert_filter *filter TSRMLS_DC); + int (*filter_function)(int c, mbfl_convert_filter *filter TSRMLS_DC); + int (*filter_flush)(mbfl_convert_filter *filter TSRMLS_DC); }; mbfl_convert_filter * mbfl_convert_filter_new( enum mbfl_no_encoding from, enum mbfl_no_encoding to, - int (*output_function)(int, void *), - int (*flush_function)(void *), - void *data); -void mbfl_convert_filter_delete(mbfl_convert_filter *filter); -int mbfl_convert_filter_feed(int c, mbfl_convert_filter *filter); -int mbfl_convert_filter_flush(mbfl_convert_filter *filter); -void mbfl_convert_filter_reset(mbfl_convert_filter *filter, enum mbfl_no_encoding from, enum mbfl_no_encoding to); -void mbfl_convert_filter_copy(mbfl_convert_filter *src, mbfl_convert_filter *dist); -int mbfl_filt_conv_illegal_output(int c, mbfl_convert_filter *filter); + int (*output_function)(int, void * TSRMLS_DC), + int (*flush_function)(void * TSRMLS_DC), + void *data TSRMLS_DC); +void mbfl_convert_filter_delete(mbfl_convert_filter *filter TSRMLS_DC); +int mbfl_convert_filter_feed(int c, mbfl_convert_filter *filter TSRMLS_DC); +int mbfl_convert_filter_flush(mbfl_convert_filter *filter TSRMLS_DC); +void mbfl_convert_filter_reset(mbfl_convert_filter *filter, enum mbfl_no_encoding from, enum mbfl_no_encoding to TSRMLS_DC); +void mbfl_convert_filter_copy(mbfl_convert_filter *src, mbfl_convert_filter *dist TSRMLS_DC); +int mbfl_filt_conv_illegal_output(int c, mbfl_convert_filter *filter TSRMLS_DC); /* @@ -364,9 +364,9 @@ int mbfl_filt_conv_illegal_output(int c, mbfl_convert_filter *filter); typedef struct _mbfl_identify_filter mbfl_identify_filter; struct _mbfl_identify_filter { - void (*filter_ctor)(mbfl_identify_filter *filter); - void (*filter_dtor)(mbfl_identify_filter *filter); - int (*filter_function)(int c, mbfl_identify_filter *filter); + void (*filter_ctor)(mbfl_identify_filter *filter TSRMLS_DC); + void (*filter_dtor)(mbfl_identify_filter *filter TSRMLS_DC); + int (*filter_function)(int c, mbfl_identify_filter *filter TSRMLS_DC); int status; int flag; int score; @@ -375,13 +375,13 @@ struct _mbfl_identify_filter { struct mbfl_identify_vtbl { enum mbfl_no_encoding encoding; - void (*filter_ctor)(mbfl_identify_filter *filter); - void (*filter_dtor)(mbfl_identify_filter *filter); - int (*filter_function)(int c, mbfl_identify_filter *filter); + void (*filter_ctor)(mbfl_identify_filter *filter TSRMLS_DC); + void (*filter_dtor)(mbfl_identify_filter *filter TSRMLS_DC); + int (*filter_function)(int c, mbfl_identify_filter *filter TSRMLS_DC); }; -mbfl_identify_filter * mbfl_identify_filter_new(enum mbfl_no_encoding encoding); -void mbfl_identify_filter_delete(mbfl_identify_filter *filter); +mbfl_identify_filter * mbfl_identify_filter_new(enum mbfl_no_encoding encoding TSRMLS_DC); +void mbfl_identify_filter_delete(mbfl_identify_filter *filter TSRMLS_DC); /* @@ -397,17 +397,17 @@ struct _mbfl_buffer_converter { mbfl_encoding *to; }; -mbfl_buffer_converter * mbfl_buffer_converter_new(enum mbfl_no_encoding from, enum mbfl_no_encoding to, int buf_initsz); -void mbfl_buffer_converter_delete(mbfl_buffer_converter *convd); -void mbfl_buffer_converter_reset(mbfl_buffer_converter *convd); -int mbfl_buffer_converter_illegal_mode(mbfl_buffer_converter *convd, int mode); -int mbfl_buffer_converter_illegal_substchar(mbfl_buffer_converter *convd, int substchar); -int mbfl_buffer_converter_strncat(mbfl_buffer_converter *convd, const unsigned char *p, int n); -int mbfl_buffer_converter_feed(mbfl_buffer_converter *convd, mbfl_string *string); -int mbfl_buffer_converter_flush(mbfl_buffer_converter *convd); -mbfl_string * mbfl_buffer_converter_getbuffer(mbfl_buffer_converter *convd, mbfl_string *result); -mbfl_string * mbfl_buffer_converter_result(mbfl_buffer_converter *convd, mbfl_string *result); -mbfl_string * mbfl_buffer_converter_feed_result(mbfl_buffer_converter *convd, mbfl_string *string, mbfl_string *result); +mbfl_buffer_converter * mbfl_buffer_converter_new(enum mbfl_no_encoding from, enum mbfl_no_encoding to, int buf_initsz TSRMLS_DC); +void mbfl_buffer_converter_delete(mbfl_buffer_converter *convd TSRMLS_DC); +void mbfl_buffer_converter_reset(mbfl_buffer_converter *convd TSRMLS_DC); +int mbfl_buffer_converter_illegal_mode(mbfl_buffer_converter *convd, int mode TSRMLS_DC); +int mbfl_buffer_converter_illegal_substchar(mbfl_buffer_converter *convd, int substchar TSRMLS_DC); +int mbfl_buffer_converter_strncat(mbfl_buffer_converter *convd, const unsigned char *p, int n TSRMLS_DC); +int mbfl_buffer_converter_feed(mbfl_buffer_converter *convd, mbfl_string *string TSRMLS_DC); +int mbfl_buffer_converter_flush(mbfl_buffer_converter *convd TSRMLS_DC); +mbfl_string * mbfl_buffer_converter_getbuffer(mbfl_buffer_converter *convd, mbfl_string *result TSRMLS_DC); +mbfl_string * mbfl_buffer_converter_result(mbfl_buffer_converter *convd, mbfl_string *result TSRMLS_DC); +mbfl_string * mbfl_buffer_converter_feed_result(mbfl_buffer_converter *convd, mbfl_string *string, mbfl_string *result TSRMLS_DC); /* @@ -420,66 +420,66 @@ struct _mbfl_encoding_detector { int filter_list_size; }; -mbfl_encoding_detector * mbfl_encoding_detector_new(enum mbfl_no_encoding *elist, int eliztsz); -void mbfl_encoding_detector_delete(mbfl_encoding_detector *identd); -int mbfl_encoding_detector_feed(mbfl_encoding_detector *identd, mbfl_string *string); -enum mbfl_no_encoding mbfl_encoding_detector_judge(mbfl_encoding_detector *identd); +mbfl_encoding_detector * mbfl_encoding_detector_new(enum mbfl_no_encoding *elist, int eliztsz TSRMLS_DC); +void mbfl_encoding_detector_delete(mbfl_encoding_detector *identd TSRMLS_DC); +int mbfl_encoding_detector_feed(mbfl_encoding_detector *identd, mbfl_string *string TSRMLS_DC); +enum mbfl_no_encoding mbfl_encoding_detector_judge(mbfl_encoding_detector *identd TSRMLS_DC); /* * encoding converter */ mbfl_string * -mbfl_convert_encoding(mbfl_string *string, mbfl_string *result, enum mbfl_no_encoding toenc); +mbfl_convert_encoding(mbfl_string *string, mbfl_string *result, enum mbfl_no_encoding toenc TSRMLS_DC); /* * identify encoding */ mbfl_encoding * -mbfl_identify_encoding(mbfl_string *string, enum mbfl_no_encoding *elist, int eliztsz); +mbfl_identify_encoding(mbfl_string *string, enum mbfl_no_encoding *elist, int eliztsz TSRMLS_DC); const char * -mbfl_identify_encoding_name(mbfl_string *string, enum mbfl_no_encoding *elist, int eliztsz); +mbfl_identify_encoding_name(mbfl_string *string, enum mbfl_no_encoding *elist, int eliztsz TSRMLS_DC); enum mbfl_no_encoding -mbfl_identify_encoding_no(mbfl_string *string, enum mbfl_no_encoding *elist, int eliztsz); +mbfl_identify_encoding_no(mbfl_string *string, enum mbfl_no_encoding *elist, int eliztsz TSRMLS_DC); /* * strlen */ int -mbfl_strlen(mbfl_string *string); +mbfl_strlen(mbfl_string *string TSRMLS_DC); /* * strpos */ int -mbfl_strpos(mbfl_string *haystack, mbfl_string *needle, int offset, int reverse); +mbfl_strpos(mbfl_string *haystack, mbfl_string *needle, int offset, int reverse TSRMLS_DC); /* * substr */ mbfl_string * -mbfl_substr(mbfl_string *string, mbfl_string *result, int from, int length); +mbfl_substr(mbfl_string *string, mbfl_string *result, int from, int length TSRMLS_DC); /* * strcut */ mbfl_string * -mbfl_strcut(mbfl_string *string, mbfl_string *result, int from, int length); +mbfl_strcut(mbfl_string *string, mbfl_string *result, int from, int length TSRMLS_DC); /* * strwidth */ int -mbfl_strwidth(mbfl_string *string); +mbfl_strwidth(mbfl_string *string TSRMLS_DC); /* * strimwidth */ mbfl_string * -mbfl_strimwidth(mbfl_string *string, mbfl_string *marker, mbfl_string *result, int from, int width); +mbfl_strimwidth(mbfl_string *string, mbfl_string *marker, mbfl_string *result, int from, int width TSRMLS_DC); /* * MIME header encode @@ -490,16 +490,16 @@ struct mime_header_encoder_data * mime_header_encoder_new( enum mbfl_no_encoding incode, enum mbfl_no_encoding outcode, - enum mbfl_no_encoding encoding); + enum mbfl_no_encoding encoding TSRMLS_DC); void -mime_header_encoder_delete(struct mime_header_encoder_data *pe); +mime_header_encoder_delete(struct mime_header_encoder_data *pe TSRMLS_DC); int -mime_header_encoder_feed(int c, struct mime_header_encoder_data *pe); +mime_header_encoder_feed(int c, struct mime_header_encoder_data *pe TSRMLS_DC); mbfl_string * -mime_header_encoder_result(struct mime_header_encoder_data *pe, mbfl_string *result); +mime_header_encoder_result(struct mime_header_encoder_data *pe, mbfl_string *result TSRMLS_DC); mbfl_string * mbfl_mime_header_encode( @@ -507,7 +507,7 @@ mbfl_mime_header_encode( enum mbfl_no_encoding outcode, enum mbfl_no_encoding encoding, const char *linefeed, - int indent); + int indent TSRMLS_DC); /* * MIME header decode @@ -515,35 +515,35 @@ mbfl_mime_header_encode( struct mime_header_decoder_data; /* forward declaration */ struct mime_header_decoder_data * -mime_header_decoder_new(enum mbfl_no_encoding outcode); +mime_header_decoder_new(enum mbfl_no_encoding outcode TSRMLS_DC); void -mime_header_decoder_delete(struct mime_header_decoder_data *pd); +mime_header_decoder_delete(struct mime_header_decoder_data *pd TSRMLS_DC); int -mime_header_decoder_feed(int c, struct mime_header_decoder_data *pd); +mime_header_decoder_feed(int c, struct mime_header_decoder_data *pd TSRMLS_DC); mbfl_string * -mime_header_decoder_result(struct mime_header_decoder_data *pd, mbfl_string *result); +mime_header_decoder_result(struct mime_header_decoder_data *pd, mbfl_string *result TSRMLS_DC); mbfl_string * mbfl_mime_header_decode( mbfl_string *string, mbfl_string *result, - enum mbfl_no_encoding outcode); + enum mbfl_no_encoding outcode TSRMLS_DC); /* * convert HTML numeric entity */ mbfl_string * -mbfl_html_numeric_entity(mbfl_string *string, mbfl_string *result, int *convmap, int mapsize, int type); +mbfl_html_numeric_entity(mbfl_string *string, mbfl_string *result, int *convmap, int mapsize, int type TSRMLS_DC); /* * convert of harfwidth and fullwidth for japanese */ mbfl_string * -mbfl_ja_jp_hantozen(mbfl_string *string, mbfl_string *result, int mode); +mbfl_ja_jp_hantozen(mbfl_string *string, mbfl_string *result, int mode TSRMLS_DC); #endif /* MBFL_MBFILTER_H */ diff --git a/ext/mbstring/mbfilter_ja.c b/ext/mbstring/mbfilter_ja.c index fa41192e79..412cbc8393 100644 --- a/ext/mbstring/mbfilter_ja.c +++ b/ext/mbstring/mbfilter_ja.c @@ -79,6 +79,9 @@ /* $Id$ */ +#include "php.h" +#include "php_globals.h" + #include "mbfilter.h" #include "mbfilter_ja.h" @@ -135,14 +138,14 @@ * EUC-JP => wchar */ int -mbfl_filt_conv_eucjp_wchar(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_eucjp_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC) { int c1, s, w; switch (filter->status) { case 0: if (c >= 0 && c < 0x80) { /* latin */ - CK((*filter->output_function)(c, filter->data)); + CK((*filter->output_function)(c, filter->data TSRMLS_CC)); } else if (c > 0xa0 && c < 0xff) { /* X 0208 first char */ filter->status = 1; filter->cache = c; @@ -153,7 +156,7 @@ mbfl_filt_conv_eucjp_wchar(int c, mbfl_convert_filter *filter) } else { w = c & MBFL_WCSGROUP_MASK; w |= MBFL_WCSGROUP_THROUGH; - CK((*filter->output_function)(w, filter->data)); + CK((*filter->output_function)(w, filter->data TSRMLS_CC)); } break; @@ -172,14 +175,14 @@ mbfl_filt_conv_eucjp_wchar(int c, mbfl_convert_filter *filter) w &= MBFL_WCSPLANE_MASK; w |= MBFL_WCSPLANE_JIS0208; } - CK((*filter->output_function)(w, filter->data)); + CK((*filter->output_function)(w, filter->data TSRMLS_CC)); } else if ((c >= 0 && c < 0x21) || c == 0x7f) { /* CTLs */ - CK((*filter->output_function)(c, filter->data)); + CK((*filter->output_function)(c, filter->data TSRMLS_CC)); } else { w = (c1 << 8) | c; w &= MBFL_WCSGROUP_MASK; w |= MBFL_WCSGROUP_THROUGH; - CK((*filter->output_function)(w, filter->data)); + CK((*filter->output_function)(w, filter->data TSRMLS_CC)); } break; @@ -187,20 +190,20 @@ mbfl_filt_conv_eucjp_wchar(int c, mbfl_convert_filter *filter) filter->status = 0; if (c > 0xa0 && c < 0xe0) { w = 0xfec0 + c; - CK((*filter->output_function)(w, filter->data)); + CK((*filter->output_function)(w, filter->data TSRMLS_CC)); } else if ((c >= 0 && c < 0x21) || c == 0x7f) { /* CTLs */ - CK((*filter->output_function)(c, filter->data)); + CK((*filter->output_function)(c, filter->data TSRMLS_CC)); } else { w = 0x8e00 | c; w &= MBFL_WCSGROUP_MASK; w |= MBFL_WCSGROUP_THROUGH; - CK((*filter->output_function)(w, filter->data)); + CK((*filter->output_function)(w, filter->data TSRMLS_CC)); } break; case 3: /* got 0x8f, X 0212 first char */ if ((c >= 0 && c < 0x21) || c == 0x7f) { /* CTLs */ - CK((*filter->output_function)(c, filter->data)); + CK((*filter->output_function)(c, filter->data TSRMLS_CC)); filter->status = 0; } else { filter->status++; @@ -222,14 +225,14 @@ mbfl_filt_conv_eucjp_wchar(int c, mbfl_convert_filter *filter) w &= MBFL_WCSPLANE_MASK; w |= MBFL_WCSPLANE_JIS0212; } - CK((*filter->output_function)(w, filter->data)); + CK((*filter->output_function)(w, filter->data TSRMLS_CC)); } else if ((c >= 0 && c < 0x21) || c == 0x7f) { /* CTLs */ - CK((*filter->output_function)(c, filter->data)); + CK((*filter->output_function)(c, filter->data TSRMLS_CC)); } else { w = (c1 << 8) | c | 0x8f0000; w &= MBFL_WCSGROUP_MASK; w |= MBFL_WCSGROUP_THROUGH; - CK((*filter->output_function)(w, filter->data)); + CK((*filter->output_function)(w, filter->data TSRMLS_CC)); } break; @@ -245,7 +248,7 @@ mbfl_filt_conv_eucjp_wchar(int c, mbfl_convert_filter *filter) * wchar => EUC-JP */ int -mbfl_filt_conv_wchar_eucjp(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_wchar_eucjp(int c, mbfl_convert_filter *filter TSRMLS_DC) { int c1, s; @@ -289,21 +292,21 @@ mbfl_filt_conv_wchar_eucjp(int c, mbfl_convert_filter *filter) } if (s >= 0) { if (s < 0x80) { /* latin */ - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); } else if (s < 0x100) { /* kana */ - CK((*filter->output_function)(0x8e, filter->data)); - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(0x8e, filter->data TSRMLS_CC)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); } else if (s < 0x8080) { /* X 0208 */ - CK((*filter->output_function)(((s >> 8) & 0xff) | 0x80, filter->data)); - CK((*filter->output_function)((s & 0xff) | 0x80, filter->data)); + CK((*filter->output_function)(((s >> 8) & 0xff) | 0x80, filter->data TSRMLS_CC)); + CK((*filter->output_function)((s & 0xff) | 0x80, filter->data TSRMLS_CC)); } else { /* X 0212 */ - CK((*filter->output_function)(0x8f, filter->data)); - CK((*filter->output_function)(((s >> 8) & 0xff) | 0x80, filter->data)); - CK((*filter->output_function)((s & 0xff) | 0x80, filter->data)); + CK((*filter->output_function)(0x8f, filter->data TSRMLS_CC)); + CK((*filter->output_function)(((s >> 8) & 0xff) | 0x80, filter->data TSRMLS_CC)); + CK((*filter->output_function)((s & 0xff) | 0x80, filter->data TSRMLS_CC)); } } else { if (filter->illegal_mode != MBFL_OUTPUTFILTER_ILLEGAL_MODE_NONE) { - CK(mbfl_filt_conv_illegal_output(c, filter)); + CK(mbfl_filt_conv_illegal_output(c, filter TSRMLS_CC)); } } @@ -315,14 +318,14 @@ mbfl_filt_conv_wchar_eucjp(int c, mbfl_convert_filter *filter) * eucJP-win => wchar */ int -mbfl_filt_conv_eucjpwin_wchar(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_eucjpwin_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC) { int c1, s, w, n; switch (filter->status) { case 0: if (c >= 0 && c < 0x80) { /* latin */ - CK((*filter->output_function)(c, filter->data)); + CK((*filter->output_function)(c, filter->data TSRMLS_CC)); } else if (c > 0xa0 && c < 0xff) { /* CP932 first char */ filter->status = 1; filter->cache = c; @@ -333,7 +336,7 @@ mbfl_filt_conv_eucjpwin_wchar(int c, mbfl_convert_filter *filter) } else { w = c & MBFL_WCSGROUP_MASK; w |= MBFL_WCSGROUP_THROUGH; - CK((*filter->output_function)(w, filter->data)); + CK((*filter->output_function)(w, filter->data TSRMLS_CC)); } break; @@ -374,14 +377,14 @@ mbfl_filt_conv_eucjpwin_wchar(int c, mbfl_convert_filter *filter) w &= MBFL_WCSPLANE_MASK; w |= MBFL_WCSPLANE_WINCP932; } - CK((*filter->output_function)(w, filter->data)); + CK((*filter->output_function)(w, filter->data TSRMLS_CC)); } else if ((c >= 0 && c < 0x21) || c == 0x7f) { /* CTLs */ - CK((*filter->output_function)(c, filter->data)); + CK((*filter->output_function)(c, filter->data TSRMLS_CC)); } else { w = (c1 << 8) | c; w &= MBFL_WCSGROUP_MASK; w |= MBFL_WCSGROUP_THROUGH; - CK((*filter->output_function)(w, filter->data)); + CK((*filter->output_function)(w, filter->data TSRMLS_CC)); } break; @@ -389,20 +392,20 @@ mbfl_filt_conv_eucjpwin_wchar(int c, mbfl_convert_filter *filter) filter->status = 0; if (c > 0xa0 && c < 0xe0) { w = 0xfec0 + c; - CK((*filter->output_function)(w, filter->data)); + CK((*filter->output_function)(w, filter->data TSRMLS_CC)); } else if ((c >= 0 && c < 0x21) || c == 0x7f) { /* CTLs */ - CK((*filter->output_function)(c, filter->data)); + CK((*filter->output_function)(c, filter->data TSRMLS_CC)); } else { w = 0x8e00 | c; w &= MBFL_WCSGROUP_MASK; w |= MBFL_WCSGROUP_THROUGH; - CK((*filter->output_function)(w, filter->data)); + CK((*filter->output_function)(w, filter->data TSRMLS_CC)); } break; case 3: /* got 0x8f, X 0212 first char */ if ((c >= 0 && c < 0x21) || c == 0x7f) { /* CTLs */ - CK((*filter->output_function)(c, filter->data)); + CK((*filter->output_function)(c, filter->data TSRMLS_CC)); filter->status = 0; } else { filter->status++; @@ -439,14 +442,14 @@ mbfl_filt_conv_eucjpwin_wchar(int c, mbfl_convert_filter *filter) w &= MBFL_WCSPLANE_MASK; w |= MBFL_WCSPLANE_JIS0212; } - CK((*filter->output_function)(w, filter->data)); + CK((*filter->output_function)(w, filter->data TSRMLS_CC)); } else if ((c >= 0 && c < 0x21) || c == 0x7f) { /* CTLs */ - CK((*filter->output_function)(c, filter->data)); + CK((*filter->output_function)(c, filter->data TSRMLS_CC)); } else { w = (c1 << 8) | c | 0x8f0000; w &= MBFL_WCSGROUP_MASK; w |= MBFL_WCSGROUP_THROUGH; - CK((*filter->output_function)(w, filter->data)); + CK((*filter->output_function)(w, filter->data TSRMLS_CC)); } break; @@ -462,7 +465,7 @@ mbfl_filt_conv_eucjpwin_wchar(int c, mbfl_convert_filter *filter) * wchar => eucJP-win */ int -mbfl_filt_conv_wchar_eucjpwin(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_wchar_eucjpwin(int c, mbfl_convert_filter *filter TSRMLS_DC) { int c1, c2, s1; @@ -557,21 +560,21 @@ mbfl_filt_conv_wchar_eucjpwin(int c, mbfl_convert_filter *filter) if (s1 >= 0) { if (s1 < 0x80) { /* latin */ - CK((*filter->output_function)(s1, filter->data)); + CK((*filter->output_function)(s1, filter->data TSRMLS_CC)); } else if (s1 < 0x100) { /* kana */ - CK((*filter->output_function)(0x8e, filter->data)); - CK((*filter->output_function)(s1, filter->data)); + CK((*filter->output_function)(0x8e, filter->data TSRMLS_CC)); + CK((*filter->output_function)(s1, filter->data TSRMLS_CC)); } else if (s1 < 0x8080) { /* X 0208 */ - CK((*filter->output_function)(((s1 >> 8) & 0xff) | 0x80, filter->data)); - CK((*filter->output_function)((s1 & 0xff) | 0x80, filter->data)); + CK((*filter->output_function)(((s1 >> 8) & 0xff) | 0x80, filter->data TSRMLS_CC)); + CK((*filter->output_function)((s1 & 0xff) | 0x80, filter->data TSRMLS_CC)); } else { /* X 0212 */ - CK((*filter->output_function)(0x8f, filter->data)); - CK((*filter->output_function)(((s1 >> 8) & 0xff) | 0x80, filter->data)); - CK((*filter->output_function)((s1 & 0xff) | 0x80, filter->data)); + CK((*filter->output_function)(0x8f, filter->data TSRMLS_CC)); + CK((*filter->output_function)(((s1 >> 8) & 0xff) | 0x80, filter->data TSRMLS_CC)); + CK((*filter->output_function)((s1 & 0xff) | 0x80, filter->data TSRMLS_CC)); } } else { if (filter->illegal_mode != MBFL_OUTPUTFILTER_ILLEGAL_MODE_NONE) { - CK(mbfl_filt_conv_illegal_output(c, filter)); + CK(mbfl_filt_conv_illegal_output(c, filter TSRMLS_CC)); } } @@ -583,23 +586,23 @@ mbfl_filt_conv_wchar_eucjpwin(int c, mbfl_convert_filter *filter) * SJIS => wchar */ int -mbfl_filt_conv_sjis_wchar(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_sjis_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC) { int c1, s1, s2, w; switch (filter->status) { case 0: if (c >= 0 && c < 0x80) { /* latin */ - CK((*filter->output_function)(c, filter->data)); + CK((*filter->output_function)(c, filter->data TSRMLS_CC)); } else if (c > 0xa0 && c < 0xe0) { /* kana */ - CK((*filter->output_function)(0xfec0 + c, filter->data)); + CK((*filter->output_function)(0xfec0 + c, filter->data TSRMLS_CC)); } else if (c > 0x80 && c < 0xfd && c != 0xa0) { /* kanji first char */ filter->status = 1; filter->cache = c; } else { w = c & MBFL_WCSGROUP_MASK; w |= MBFL_WCSGROUP_THROUGH; - CK((*filter->output_function)(w, filter->data)); + CK((*filter->output_function)(w, filter->data TSRMLS_CC)); } break; @@ -625,14 +628,14 @@ mbfl_filt_conv_sjis_wchar(int c, mbfl_convert_filter *filter) w |= MBFL_WCSGROUP_THROUGH; } } - CK((*filter->output_function)(w, filter->data)); + CK((*filter->output_function)(w, filter->data TSRMLS_CC)); } else if ((c >= 0 && c < 0x21) || c == 0x7f) { /* CTLs */ - CK((*filter->output_function)(c, filter->data)); + CK((*filter->output_function)(c, filter->data TSRMLS_CC)); } else { w = (c1 << 8) | c; w &= MBFL_WCSGROUP_MASK; w |= MBFL_WCSGROUP_THROUGH; - CK((*filter->output_function)(w, filter->data)); + CK((*filter->output_function)(w, filter->data TSRMLS_CC)); } break; @@ -648,7 +651,7 @@ mbfl_filt_conv_sjis_wchar(int c, mbfl_convert_filter *filter) * wchar => SJIS */ int -mbfl_filt_conv_wchar_sjis(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_wchar_sjis(int c, mbfl_convert_filter *filter TSRMLS_DC) { int c1, c2, s1, s2; @@ -695,17 +698,17 @@ mbfl_filt_conv_wchar_sjis(int c, mbfl_convert_filter *filter) } if (s1 >= 0) { if (s1 < 0x100) { /* latin or kana */ - CK((*filter->output_function)(s1, filter->data)); + CK((*filter->output_function)(s1, filter->data TSRMLS_CC)); } else { /* kanji */ c1 = (s1 >> 8) & 0xff; c2 = s1 & 0xff; SJIS_ENCODE(c1, c2, s1, s2); - CK((*filter->output_function)(s1, filter->data)); - CK((*filter->output_function)(s2, filter->data)); + CK((*filter->output_function)(s1, filter->data TSRMLS_CC)); + CK((*filter->output_function)(s2, filter->data TSRMLS_CC)); } } else { if (filter->illegal_mode != MBFL_OUTPUTFILTER_ILLEGAL_MODE_NONE) { - CK(mbfl_filt_conv_illegal_output(c, filter)); + CK(mbfl_filt_conv_illegal_output(c, filter TSRMLS_CC)); } } @@ -717,23 +720,23 @@ mbfl_filt_conv_wchar_sjis(int c, mbfl_convert_filter *filter) * SJIS-win => wchar */ int -mbfl_filt_conv_sjiswin_wchar(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_sjiswin_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC) { int c1, s, s1, s2, w; switch (filter->status) { case 0: if (c >= 0 && c < 0x80) { /* latin */ - CK((*filter->output_function)(c, filter->data)); + CK((*filter->output_function)(c, filter->data TSRMLS_CC)); } else if (c > 0xa0 && c < 0xe0) { /* kana */ - CK((*filter->output_function)(0xfec0 + c, filter->data)); + CK((*filter->output_function)(0xfec0 + c, filter->data TSRMLS_CC)); } else if (c > 0x80 && c < 0xfd && c != 0xa0) { /* kanji first char */ filter->status = 1; filter->cache = c; } else { w = c & MBFL_WCSGROUP_MASK; w |= MBFL_WCSGROUP_THROUGH; - CK((*filter->output_function)(w, filter->data)); + CK((*filter->output_function)(w, filter->data TSRMLS_CC)); } break; @@ -779,14 +782,14 @@ mbfl_filt_conv_sjiswin_wchar(int c, mbfl_convert_filter *filter) w &= MBFL_WCSPLANE_MASK; w |= MBFL_WCSPLANE_WINCP932; } - CK((*filter->output_function)(w, filter->data)); + CK((*filter->output_function)(w, filter->data TSRMLS_CC)); } else if ((c >= 0 && c < 0x21) || c == 0x7f) { /* CTLs */ - CK((*filter->output_function)(c, filter->data)); + CK((*filter->output_function)(c, filter->data TSRMLS_CC)); } else { w = (c1 << 8) | c; w &= MBFL_WCSGROUP_MASK; w |= MBFL_WCSGROUP_THROUGH; - CK((*filter->output_function)(w, filter->data)); + CK((*filter->output_function)(w, filter->data TSRMLS_CC)); } break; @@ -802,7 +805,7 @@ mbfl_filt_conv_sjiswin_wchar(int c, mbfl_convert_filter *filter) * wchar => SJIS-win */ int -mbfl_filt_conv_wchar_sjiswin(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_wchar_sjiswin(int c, mbfl_convert_filter *filter TSRMLS_DC) { int c1, c2, s1, s2; @@ -883,17 +886,17 @@ mbfl_filt_conv_wchar_sjiswin(int c, mbfl_convert_filter *filter) } if (s1 >= 0) { if (s1 < 0x100) { /* latin or kana */ - CK((*filter->output_function)(s1, filter->data)); + CK((*filter->output_function)(s1, filter->data TSRMLS_CC)); } else { /* kanji */ c1 = (s1 >> 8) & 0xff; c2 = s1 & 0xff; SJIS_ENCODE(c1, c2, s1, s2); - CK((*filter->output_function)(s1, filter->data)); - CK((*filter->output_function)(s2, filter->data)); + CK((*filter->output_function)(s1, filter->data TSRMLS_CC)); + CK((*filter->output_function)(s2, filter->data TSRMLS_CC)); } } else { if (filter->illegal_mode != MBFL_OUTPUTFILTER_ILLEGAL_MODE_NONE) { - CK(mbfl_filt_conv_illegal_output(c, filter)); + CK(mbfl_filt_conv_illegal_output(c, filter TSRMLS_CC)); } } @@ -905,7 +908,7 @@ mbfl_filt_conv_wchar_sjiswin(int c, mbfl_convert_filter *filter) * JIS => wchar */ int -mbfl_filt_conv_jis_wchar(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_jis_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC) { int c1, s, w; @@ -924,22 +927,22 @@ retry: } else if (c == 0x0f) { /* "kana out" */ filter->status = 0; } else if (filter->status == 0x10 && c == 0x5c) { /* YEN SIGN */ - CK((*filter->output_function)(0xa5, filter->data)); + CK((*filter->output_function)(0xa5, filter->data TSRMLS_CC)); } else if (filter->status == 0x10 && c == 0x7e) { /* OVER LINE */ - CK((*filter->output_function)(0x203e, filter->data)); + CK((*filter->output_function)(0x203e, filter->data TSRMLS_CC)); } else if (filter->status == 0x20 && c > 0x20 && c < 0x60) { /* kana */ - CK((*filter->output_function)(0xff40 + c, filter->data)); + CK((*filter->output_function)(0xff40 + c, filter->data TSRMLS_CC)); } else if ((filter->status == 0x80 || filter->status == 0x90) && c > 0x20 && c < 0x7f) { /* kanji first char */ filter->cache = c; filter->status += 1; } else if (c >= 0 && c < 0x80) { /* latin, CTLs */ - CK((*filter->output_function)(c, filter->data)); + CK((*filter->output_function)(c, filter->data TSRMLS_CC)); } else if (c > 0xa0 && c < 0xe0) { /* GR kana */ - CK((*filter->output_function)(0xfec0 + c, filter->data)); + CK((*filter->output_function)(0xfec0 + c, filter->data TSRMLS_CC)); } else { w = c & MBFL_WCSGROUP_MASK; w |= MBFL_WCSGROUP_THROUGH; - CK((*filter->output_function)(w, filter->data)); + CK((*filter->output_function)(w, filter->data TSRMLS_CC)); } break; @@ -973,16 +976,16 @@ retry: w |= MBFL_WCSPLANE_JIS0212; } } - CK((*filter->output_function)(w, filter->data)); + CK((*filter->output_function)(w, filter->data TSRMLS_CC)); } else if (c == 0x1b) { filter->status += 2; } else if ((c >= 0 && c < 0x21) || c == 0x7f) { /* CTLs */ - CK((*filter->output_function)(c, filter->data)); + CK((*filter->output_function)(c, filter->data TSRMLS_CC)); } else { w = (c1 << 8) | c; w &= MBFL_WCSGROUP_MASK; w |= MBFL_WCSGROUP_THROUGH; - CK((*filter->output_function)(w, filter->data)); + CK((*filter->output_function)(w, filter->data TSRMLS_CC)); } break; @@ -999,7 +1002,7 @@ retry: filter->status += 3; } else { filter->status &= ~0xf; - CK((*filter->output_function)(0x1b, filter->data)); + CK((*filter->output_function)(0x1b, filter->data TSRMLS_CC)); goto retry; } break; @@ -1017,8 +1020,8 @@ retry: filter->status++; } else { filter->status &= ~0xf; - CK((*filter->output_function)(0x1b, filter->data)); - CK((*filter->output_function)(0x24, filter->data)); + CK((*filter->output_function)(0x1b, filter->data TSRMLS_CC)); + CK((*filter->output_function)(0x24, filter->data TSRMLS_CC)); goto retry; } break; @@ -1036,9 +1039,9 @@ retry: filter->status = 0x90; } else { filter->status &= ~0xf; - CK((*filter->output_function)(0x1b, filter->data)); - CK((*filter->output_function)(0x24, filter->data)); - CK((*filter->output_function)(0x28, filter->data)); + CK((*filter->output_function)(0x1b, filter->data TSRMLS_CC)); + CK((*filter->output_function)(0x24, filter->data TSRMLS_CC)); + CK((*filter->output_function)(0x28, filter->data TSRMLS_CC)); goto retry; } break; @@ -1058,8 +1061,8 @@ retry: filter->status = 0x20; } else { filter->status &= ~0xf; - CK((*filter->output_function)(0x1b, filter->data)); - CK((*filter->output_function)(0x28, filter->data)); + CK((*filter->output_function)(0x1b, filter->data TSRMLS_CC)); + CK((*filter->output_function)(0x28, filter->data TSRMLS_CC)); goto retry; } break; @@ -1076,7 +1079,7 @@ retry: * wchar => JIS */ int -mbfl_filt_conv_wchar_jis(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_wchar_jis(int c, mbfl_convert_filter *filter TSRMLS_DC) { int c1, s; @@ -1125,51 +1128,51 @@ mbfl_filt_conv_wchar_jis(int c, mbfl_convert_filter *filter) if (s >= 0) { if (s < 0x80) { /* ASCII */ if ((filter->status & 0xff00) != 0) { - CK((*filter->output_function)(0x1b, filter->data)); /* ESC */ - CK((*filter->output_function)(0x28, filter->data)); /* '(' */ - CK((*filter->output_function)(0x42, filter->data)); /* 'B' */ + CK((*filter->output_function)(0x1b, filter->data TSRMLS_CC)); /* ESC */ + CK((*filter->output_function)(0x28, filter->data TSRMLS_CC)); /* '(' */ + CK((*filter->output_function)(0x42, filter->data TSRMLS_CC)); /* 'B' */ } filter->status = 0; - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); } else if (s < 0x100) { /* kana */ if ((filter->status & 0xff00) != 0x100) { - CK((*filter->output_function)(0x1b, filter->data)); /* ESC */ - CK((*filter->output_function)(0x28, filter->data)); /* '(' */ - CK((*filter->output_function)(0x49, filter->data)); /* 'I' */ + CK((*filter->output_function)(0x1b, filter->data TSRMLS_CC)); /* ESC */ + CK((*filter->output_function)(0x28, filter->data TSRMLS_CC)); /* '(' */ + CK((*filter->output_function)(0x49, filter->data TSRMLS_CC)); /* 'I' */ } filter->status = 0x100; - CK((*filter->output_function)(s & 0x7f, filter->data)); + CK((*filter->output_function)(s & 0x7f, filter->data TSRMLS_CC)); } else if (s < 0x8080) { /* X 0208 */ if ((filter->status & 0xff00) != 0x200) { - CK((*filter->output_function)(0x1b, filter->data)); /* ESC */ - CK((*filter->output_function)(0x24, filter->data)); /* '$' */ - CK((*filter->output_function)(0x42, filter->data)); /* 'B' */ + CK((*filter->output_function)(0x1b, filter->data TSRMLS_CC)); /* ESC */ + CK((*filter->output_function)(0x24, filter->data TSRMLS_CC)); /* '$' */ + CK((*filter->output_function)(0x42, filter->data TSRMLS_CC)); /* 'B' */ } filter->status = 0x200; - CK((*filter->output_function)((s >> 8) & 0x7f, filter->data)); - CK((*filter->output_function)(s & 0x7f, filter->data)); + CK((*filter->output_function)((s >> 8) & 0x7f, filter->data TSRMLS_CC)); + CK((*filter->output_function)(s & 0x7f, filter->data TSRMLS_CC)); } else if (s < 0x10000) { /* X 0212 */ if ((filter->status & 0xff00) != 0x300) { - CK((*filter->output_function)(0x1b, filter->data)); /* ESC */ - CK((*filter->output_function)(0x24, filter->data)); /* '$' */ - CK((*filter->output_function)(0x28, filter->data)); /* '(' */ - CK((*filter->output_function)(0x44, filter->data)); /* 'D' */ + CK((*filter->output_function)(0x1b, filter->data TSRMLS_CC)); /* ESC */ + CK((*filter->output_function)(0x24, filter->data TSRMLS_CC)); /* '$' */ + CK((*filter->output_function)(0x28, filter->data TSRMLS_CC)); /* '(' */ + CK((*filter->output_function)(0x44, filter->data TSRMLS_CC)); /* 'D' */ } filter->status = 0x300; - CK((*filter->output_function)((s >> 8) & 0x7f, filter->data)); - CK((*filter->output_function)(s & 0x7f, filter->data)); + CK((*filter->output_function)((s >> 8) & 0x7f, filter->data TSRMLS_CC)); + CK((*filter->output_function)(s & 0x7f, filter->data TSRMLS_CC)); } else { /* X 0201 latin */ if ((filter->status & 0xff00) != 0x400) { - CK((*filter->output_function)(0x1b, filter->data)); /* ESC */ - CK((*filter->output_function)(0x28, filter->data)); /* '(' */ - CK((*filter->output_function)(0x4a, filter->data)); /* 'J' */ + CK((*filter->output_function)(0x1b, filter->data TSRMLS_CC)); /* ESC */ + CK((*filter->output_function)(0x28, filter->data TSRMLS_CC)); /* '(' */ + CK((*filter->output_function)(0x4a, filter->data TSRMLS_CC)); /* 'J' */ } filter->status = 0x400; - CK((*filter->output_function)(s & 0x7f, filter->data)); + CK((*filter->output_function)(s & 0x7f, filter->data TSRMLS_CC)); } } else { if (filter->illegal_mode != MBFL_OUTPUTFILTER_ILLEGAL_MODE_NONE) { - CK(mbfl_filt_conv_illegal_output(c, filter)); + CK(mbfl_filt_conv_illegal_output(c, filter TSRMLS_CC)); } } @@ -1181,7 +1184,7 @@ mbfl_filt_conv_wchar_jis(int c, mbfl_convert_filter *filter) * wchar => ISO-2022-JP */ int -mbfl_filt_conv_wchar_2022jp(int c, mbfl_convert_filter *filter) +mbfl_filt_conv_wchar_2022jp(int c, mbfl_convert_filter *filter TSRMLS_DC) { int s; @@ -1226,33 +1229,33 @@ mbfl_filt_conv_wchar_2022jp(int c, mbfl_convert_filter *filter) if (s >= 0) { if (s < 0x80) { /* ASCII */ if ((filter->status & 0xff00) != 0) { - CK((*filter->output_function)(0x1b, filter->data)); /* ESC */ - CK((*filter->output_function)(0x28, filter->data)); /* '(' */ - CK((*filter->output_function)(0x42, filter->data)); /* 'B' */ + CK((*filter->output_function)(0x1b, filter->data TSRMLS_CC)); /* ESC */ + CK((*filter->output_function)(0x28, filter->data TSRMLS_CC)); /* '(' */ + CK((*filter->output_function)(0x42, filter->data TSRMLS_CC)); /* 'B' */ } filter->status = 0; - CK((*filter->output_function)(s, filter->data)); + CK((*filter->output_function)(s, filter->data TSRMLS_CC)); } else if (s < 0x10000) { /* X 0208 */ if ((filter->status & 0xff00) != 0x200) { - CK((*filter->output_function)(0x1b, filter->data)); /* ESC */ - CK((*filter->output_function)(0x24, filter->data)); /* '$' */ - CK((*filter->output_function)(0x42, filter->data)); /* 'B' */ + CK((*filter->output_function)(0x1b, filter->data TSRMLS_CC)); /* ESC */ + CK((*filter->output_function)(0x24, filter->data TSRMLS_CC)); /* '$' */ + CK((*filter->output_function)(0x42, filter->data TSRMLS_CC)); /* 'B' */ } filter->status = 0x200; - CK((*filter->output_function)((s >> 8) & 0x7f, filter->data)); - CK((*filter->output_function)(s & 0x7f, filter->data)); + CK((*filter->output_function)((s >> 8) & 0x7f, filter->data TSRMLS_CC)); + CK((*filter->output_function)(s & 0x7f, filter->data TSRMLS_CC)); } else { /* X 0201 latin */ if ((filter->status & 0xff00) != 0x400) { - CK((*filter->output_function)(0x1b, filter->data)); /* ESC */ - CK((*filter->output_function)(0x28, filter->data)); /* '(' */ - CK((*filter->output_function)(0x4a, filter->data)); /* 'J' */ + CK((*filter->output_function)(0x1b, filter->data TSRMLS_CC)); /* ESC */ + CK((*filter->output_function)(0x28, filter->data TSRMLS_CC)); /* '(' */ + CK((*filter->output_function)(0x4a, filter->data TSRMLS_CC)); /* 'J' */ } filter->status = 0x400; - CK((*filter->output_function)(s & 0x7f, filter->data)); + CK((*filter->output_function)(s & 0x7f, filter->data TSRMLS_CC)); } } else { if (filter->illegal_mode != MBFL_OUTPUTFILTER_ILLEGAL_MODE_NONE) { - CK(mbfl_filt_conv_illegal_output(c, filter)); + CK(mbfl_filt_conv_illegal_output(c, filter TSRMLS_CC)); } } @@ -1260,13 +1263,13 @@ mbfl_filt_conv_wchar_2022jp(int c, mbfl_convert_filter *filter) } int -mbfl_filt_conv_any_jis_flush(mbfl_convert_filter *filter) +mbfl_filt_conv_any_jis_flush(mbfl_convert_filter *filter TSRMLS_DC) { /* back to latin */ if ((filter->status & 0xff00) != 0) { - CK((*filter->output_function)(0x1b, filter->data)); /* ESC */ - CK((*filter->output_function)(0x28, filter->data)); /* '(' */ - CK((*filter->output_function)(0x42, filter->data)); /* 'B' */ + CK((*filter->output_function)(0x1b, filter->data TSRMLS_CC)); /* ESC */ + CK((*filter->output_function)(0x28, filter->data TSRMLS_CC)); /* '(' */ + CK((*filter->output_function)(0x42, filter->data TSRMLS_CC)); /* 'B' */ } filter->status &= 0xff; return 0; diff --git a/ext/mbstring/mbfilter_ja.h b/ext/mbstring/mbfilter_ja.h index c1c2ea98c7..5f15542d61 100644 --- a/ext/mbstring/mbfilter_ja.h +++ b/ext/mbstring/mbfilter_ja.h @@ -82,17 +82,17 @@ #ifndef MBFL_MBFILTER_JA_H #define MBFL_MBFILTER_JA_H -int mbfl_filt_conv_eucjp_wchar(int c, mbfl_convert_filter *filter); -int mbfl_filt_conv_wchar_eucjp(int c, mbfl_convert_filter *filter); -int mbfl_filt_conv_eucjpwin_wchar(int c, mbfl_convert_filter *filter); -int mbfl_filt_conv_wchar_eucjpwin(int c, mbfl_convert_filter *filter); -int mbfl_filt_conv_sjis_wchar(int c, mbfl_convert_filter *filter); -int mbfl_filt_conv_wchar_sjis(int c, mbfl_convert_filter *filter); -int mbfl_filt_conv_sjiswin_wchar(int c, mbfl_convert_filter *filter); -int mbfl_filt_conv_wchar_sjiswin(int c, mbfl_convert_filter *filter); -int mbfl_filt_conv_jis_wchar(int c, mbfl_convert_filter *filter); -int mbfl_filt_conv_wchar_jis(int c, mbfl_convert_filter *filter); -int mbfl_filt_conv_wchar_2022jp(int c, mbfl_convert_filter *filter); -int mbfl_filt_conv_any_jis_flush(mbfl_convert_filter *filter); +int mbfl_filt_conv_eucjp_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC); +int mbfl_filt_conv_wchar_eucjp(int c, mbfl_convert_filter *filter TSRMLS_DC); +int mbfl_filt_conv_eucjpwin_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC); +int mbfl_filt_conv_wchar_eucjpwin(int c, mbfl_convert_filter *filter TSRMLS_DC); +int mbfl_filt_conv_sjis_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC); +int mbfl_filt_conv_wchar_sjis(int c, mbfl_convert_filter *filter TSRMLS_DC); +int mbfl_filt_conv_sjiswin_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC); +int mbfl_filt_conv_wchar_sjiswin(int c, mbfl_convert_filter *filter TSRMLS_DC); +int mbfl_filt_conv_jis_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC); +int mbfl_filt_conv_wchar_jis(int c, mbfl_convert_filter *filter TSRMLS_DC); +int mbfl_filt_conv_wchar_2022jp(int c, mbfl_convert_filter *filter TSRMLS_DC); +int mbfl_filt_conv_any_jis_flush(mbfl_convert_filter *filter TSRMLS_DC); #endif /* MBFL_MBFILTER_JA_H */ diff --git a/ext/mbstring/mbstring.c b/ext/mbstring/mbstring.c index 876511d4dc..fd28a39d9d 100644 --- a/ext/mbstring/mbstring.c +++ b/ext/mbstring/mbstring.c @@ -13,6 +13,7 @@ | license@php.net so we can mail you a copy immediately. | +----------------------------------------------------------------------+ | Author: Tsukada Takuya | + | Rui Hirokawa | +----------------------------------------------------------------------+ */ @@ -484,46 +485,51 @@ PHP_INI_END() /* module global initialize handler */ static void -php_mbstring_init_globals(zend_mbstring_globals *pglobals) +php_mbstring_init_globals(zend_mbstring_globals *pglobals TSRMLS_DC) { - pglobals->language = mbfl_no_language_japanese; - pglobals->current_language = mbfl_no_language_japanese; - pglobals->internal_encoding = mbfl_no_encoding_euc_jp; - pglobals->current_internal_encoding = mbfl_no_encoding_euc_jp; - pglobals->http_output_encoding = mbfl_no_encoding_pass; - pglobals->current_http_output_encoding = mbfl_no_encoding_pass; - pglobals->http_input_identify = mbfl_no_encoding_invalid; - pglobals->http_input_identify_get = mbfl_no_encoding_invalid; - pglobals->http_input_identify_post = mbfl_no_encoding_invalid; - pglobals->http_input_identify_cookie = mbfl_no_encoding_invalid; - pglobals->http_input_identify_string = mbfl_no_encoding_invalid; - pglobals->http_input_list = NULL; - pglobals->http_input_list_size = 0; - pglobals->detect_order_list = NULL; - pglobals->detect_order_list_size = 0; - pglobals->current_detect_order_list = NULL; - pglobals->current_detect_order_list_size = 0; - pglobals->filter_illegal_mode = MBFL_OUTPUTFILTER_ILLEGAL_MODE_CHAR; - pglobals->filter_illegal_substchar = 0x3f; /* '?' */ - pglobals->current_filter_illegal_mode = MBFL_OUTPUTFILTER_ILLEGAL_MODE_CHAR; - pglobals->current_filter_illegal_substchar = 0x3f; /* '?' */ - pglobals->func_overload = 0; + MBSTRG(language) = mbfl_no_language_japanese; + MBSTRG(current_language) = mbfl_no_language_japanese; + MBSTRG(internal_encoding) = mbfl_no_encoding_euc_jp; + MBSTRG(current_internal_encoding) = mbfl_no_encoding_euc_jp; + MBSTRG(http_output_encoding) = mbfl_no_encoding_pass; + MBSTRG(current_http_output_encoding) = mbfl_no_encoding_pass; + MBSTRG(http_input_identify) = mbfl_no_encoding_invalid; + MBSTRG(http_input_identify_get) = mbfl_no_encoding_invalid; + MBSTRG(http_input_identify_post) = mbfl_no_encoding_invalid; + MBSTRG(http_input_identify_cookie) = mbfl_no_encoding_invalid; + MBSTRG(http_input_identify_string) = mbfl_no_encoding_invalid; + MBSTRG(http_input_list) = NULL; + MBSTRG(http_input_list_size) = 0; + MBSTRG(detect_order_list) = NULL; + MBSTRG(detect_order_list_size) = 0; + MBSTRG(current_detect_order_list) = NULL; + MBSTRG(current_detect_order_list_size) = 0; + MBSTRG(filter_illegal_mode) = MBFL_OUTPUTFILTER_ILLEGAL_MODE_CHAR; + MBSTRG(filter_illegal_substchar) = 0x3f; /* '?' */ + MBSTRG(current_filter_illegal_mode) = MBFL_OUTPUTFILTER_ILLEGAL_MODE_CHAR; + MBSTRG(current_filter_illegal_substchar) = 0x3f; /* '?' */ + MBSTRG(func_overload) = 0; pglobals->outconv = NULL; #if HAVE_MBREGEX - pglobals->default_mbctype = MBCTYPE_EUC; - pglobals->current_mbctype = MBCTYPE_EUC; - zend_hash_init(&(pglobals->ht_rc), 0, NULL, (void (*)(void *)) php_mbregex_free_cache, 1); - pglobals->search_str = (zval**)0; - pglobals->search_str_val = (zval*)0; - pglobals->search_re = (mb_regex_t*)0; - pglobals->search_pos = 0; - pglobals->search_regs = (struct mbre_registers*)0; + MBSTRG(default_mbctype) = MBCTYPE_EUC; + MBSTRG(current_mbctype) = MBCTYPE_EUC; + zend_hash_init(&(MBSTRG(ht_rc)), 0, NULL, (void (*)(void *)) php_mbregex_free_cache, 1); + MBSTRG(search_str) = (zval**)0; + MBSTRG(search_str_val) = (zval*)0; + MBSTRG(search_re) = (mb_regex_t*)0; + MBSTRG(search_pos) = 0; + MBSTRG(search_regs) = (struct mbre_registers*)0; #endif } PHP_MINIT_FUNCTION(mbstring) { - ZEND_INIT_MODULE_GLOBALS(mbstring, php_mbstring_init_globals, NULL); +#ifdef ZTS + ts_allocate_id(&mbstring_globals_id, sizeof(zend_mbstring_globals), (ts_allocate_ctor) php_mbstring_init_globals, NULL); +#else + php_mbstring_init_globals(&mbstring_globals TSRMLS_CC); +#endif + REGISTER_INI_ENTRIES(); #if defined(MBSTR_ENC_TRANS) @@ -627,7 +633,7 @@ PHP_RSHUTDOWN_FUNCTION(mbstring) MBSTRG(current_detect_order_list_size) = 0; } if (MBSTRG(outconv) != NULL) { - mbfl_buffer_converter_delete(MBSTRG(outconv)); + mbfl_buffer_converter_delete(MBSTRG(outconv) TSRMLS_CC); MBSTRG(outconv) = NULL; } @@ -1065,19 +1071,19 @@ php_mbstr_encoding_handler(zval *arg, char *res, char *separator TSRMLS_DC) } else { /* auto detect */ from_encoding = mbfl_no_encoding_invalid; - identd = mbfl_encoding_detector_new(elist, elistsz); + identd = mbfl_encoding_detector_new(elist, elistsz TSRMLS_CC); if (identd) { n = 0; while (n < num) { string.val = val_list[n]; string.len = len_list[n]; - if (mbfl_encoding_detector_feed(identd, &string)) { + if (mbfl_encoding_detector_feed(identd, &string TSRMLS_CC)) { break; } n++; } - from_encoding = mbfl_encoding_detector_judge(identd); - mbfl_encoding_detector_delete(identd); + from_encoding = mbfl_encoding_detector_judge(identd TSRMLS_CC); + mbfl_encoding_detector_delete(identd TSRMLS_CC); } if (from_encoding == mbfl_no_encoding_invalid) { from_encoding = mbfl_no_encoding_pass; @@ -1085,10 +1091,10 @@ php_mbstr_encoding_handler(zval *arg, char *res, char *separator TSRMLS_DC) } convd = NULL; if (from_encoding != mbfl_no_encoding_pass) { - convd = mbfl_buffer_converter_new(from_encoding, to_encoding, 0); + convd = mbfl_buffer_converter_new(from_encoding, to_encoding, 0 TSRMLS_CC); if (convd != NULL) { - mbfl_buffer_converter_illegal_mode(convd, MBSTRG(current_filter_illegal_mode)); - mbfl_buffer_converter_illegal_substchar(convd, MBSTRG(current_filter_illegal_substchar)); + mbfl_buffer_converter_illegal_mode(convd, MBSTRG(current_filter_illegal_mode) TSRMLS_CC); + mbfl_buffer_converter_illegal_substchar(convd, MBSTRG(current_filter_illegal_substchar) TSRMLS_CC); } else { php_error(E_WARNING, "%s() unable to create converter", get_active_function_name(TSRMLS_C)); @@ -1102,7 +1108,7 @@ php_mbstr_encoding_handler(zval *arg, char *res, char *separator TSRMLS_DC) while (n < num) { string.val = val_list[n]; string.len = len_list[n]; - if (convd != NULL && mbfl_buffer_converter_feed_result(convd, &string, &resvar) != NULL) { + if (convd != NULL && mbfl_buffer_converter_feed_result(convd, &string, &resvar TSRMLS_CC) != NULL) { var = resvar.val; } else { var = val_list[n]; @@ -1110,7 +1116,7 @@ php_mbstr_encoding_handler(zval *arg, char *res, char *separator TSRMLS_DC) n++; string.val = val_list[n]; string.len = len_list[n]; - if (convd != NULL && mbfl_buffer_converter_feed_result(convd, &string, &resval) != NULL) { + if (convd != NULL && mbfl_buffer_converter_feed_result(convd, &string, &resval TSRMLS_CC) != NULL) { val = resval.val; val_len = resval.len; } else { @@ -1126,7 +1132,7 @@ php_mbstr_encoding_handler(zval *arg, char *res, char *separator TSRMLS_DC) MBSTRG(http_input_identify) = from_encoding; if (convd != NULL) { - mbfl_buffer_converter_delete(convd); + mbfl_buffer_converter_delete(convd TSRMLS_CC); } if (val_list != NULL) { efree((void *)val_list); @@ -1372,19 +1378,19 @@ PHP_FUNCTION(mb_parse_str) } else { /* auto detect */ from_encoding = mbfl_no_encoding_invalid; - identd = mbfl_encoding_detector_new(elist, elistsz); + identd = mbfl_encoding_detector_new(elist, elistsz TSRMLS_CC); if (identd != NULL) { n = 0; while (n < num) { string.val = str_list[n]; string.len = len_list[n]; - if (mbfl_encoding_detector_feed(identd, &string)) { + if (mbfl_encoding_detector_feed(identd, &string TSRMLS_CC)) { break; } n++; } - from_encoding = mbfl_encoding_detector_judge(identd); - mbfl_encoding_detector_delete(identd); + from_encoding = mbfl_encoding_detector_judge(identd TSRMLS_CC); + mbfl_encoding_detector_delete(identd TSRMLS_CC); } if (from_encoding == mbfl_no_encoding_invalid) { php_error(E_WARNING, "%s() unable to detect encoding", @@ -1394,10 +1400,10 @@ PHP_FUNCTION(mb_parse_str) } convd = NULL; if (from_encoding != mbfl_no_encoding_pass) { - convd = mbfl_buffer_converter_new(from_encoding, to_encoding, 0); + convd = mbfl_buffer_converter_new(from_encoding, to_encoding, 0 TSRMLS_CC); if (convd != NULL) { - mbfl_buffer_converter_illegal_mode(convd, MBSTRG(current_filter_illegal_mode)); - mbfl_buffer_converter_illegal_substchar(convd, MBSTRG(current_filter_illegal_substchar)); + mbfl_buffer_converter_illegal_mode(convd, MBSTRG(current_filter_illegal_mode) TSRMLS_CC); + mbfl_buffer_converter_illegal_substchar(convd, MBSTRG(current_filter_illegal_substchar) TSRMLS_CC); } else { php_error(E_WARNING, "%s() unable to create converter", get_active_function_name(TSRMLS_C)); @@ -1417,7 +1423,7 @@ PHP_FUNCTION(mb_parse_str) /* convert variable name */ string.val = str_list[n]; string.len = len_list[n]; - if (convd != NULL && mbfl_buffer_converter_feed_result(convd, &string, &resvar) != NULL) { + if (convd != NULL && mbfl_buffer_converter_feed_result(convd, &string, &resvar TSRMLS_CC) != NULL) { var = resvar.val; } else { var = str_list[n]; @@ -1426,7 +1432,7 @@ PHP_FUNCTION(mb_parse_str) /* convert value */ string.val = str_list[n]; string.len = len_list[n]; - if (convd != NULL && mbfl_buffer_converter_feed_result(convd, &string, &resval) != NULL) { + if (convd != NULL && mbfl_buffer_converter_feed_result(convd, &string, &resval TSRMLS_CC) != NULL) { val = resval.val; val_len = resval.len; } else { @@ -1442,7 +1448,7 @@ PHP_FUNCTION(mb_parse_str) PG(register_globals) = old_rg; if (convd != NULL) { - mbfl_buffer_converter_delete(convd); + mbfl_buffer_converter_delete(convd TSRMLS_CC); } efree((void *)str_list); efree((void *)len_list); @@ -1479,7 +1485,7 @@ PHP_FUNCTION(mb_output_handler) if ((arg_status & PHP_OUTPUT_HANDLER_START) != 0) { /* delete the converter just in case. */ if (MBSTRG(outconv)) { - mbfl_buffer_converter_delete(MBSTRG(outconv)); + mbfl_buffer_converter_delete(MBSTRG(outconv) TSRMLS_CC); MBSTRG(outconv) = NULL; } /* if content-type is not yet set, set it and activate the converter */ @@ -1495,7 +1501,7 @@ PHP_FUNCTION(mb_output_handler) if (sapi_add_header(p, len, 0) != FAILURE) SG(sapi_headers).send_default_content_type = 0; /* activate the converter */ - MBSTRG(outconv) = mbfl_buffer_converter_new(MBSTRG(current_internal_encoding), encoding, 0); + MBSTRG(outconv) = mbfl_buffer_converter_new(MBSTRG(current_internal_encoding), encoding, 0 TSRMLS_CC); } } @@ -1510,8 +1516,8 @@ PHP_FUNCTION(mb_output_handler) /* flag */ last_feed = ((arg_status & PHP_OUTPUT_HANDLER_END) != 0); /* mode */ - mbfl_buffer_converter_illegal_mode(MBSTRG(outconv), MBSTRG(current_filter_illegal_mode)); - mbfl_buffer_converter_illegal_substchar(MBSTRG(outconv), MBSTRG(current_filter_illegal_substchar)); + mbfl_buffer_converter_illegal_mode(MBSTRG(outconv), MBSTRG(current_filter_illegal_mode) TSRMLS_CC); + mbfl_buffer_converter_illegal_substchar(MBSTRG(outconv), MBSTRG(current_filter_illegal_substchar) TSRMLS_CC); /* feed the string */ mbfl_string_init(&string); @@ -1519,17 +1525,17 @@ PHP_FUNCTION(mb_output_handler) string.no_encoding = MBSTRG(current_internal_encoding); string.val = arg_string; string.len = arg_string_len; - mbfl_buffer_converter_feed(MBSTRG(outconv), &string); + mbfl_buffer_converter_feed(MBSTRG(outconv), &string TSRMLS_CC); if (last_feed) - mbfl_buffer_converter_flush(MBSTRG(outconv)); + mbfl_buffer_converter_flush(MBSTRG(outconv) TSRMLS_CC); /* get the converter output, and return it */ - mbfl_buffer_converter_result(MBSTRG(outconv), &result); + mbfl_buffer_converter_result(MBSTRG(outconv), &result TSRMLS_CC); RETVAL_STRINGL(result.val, result.len, 0); /* the string is already strdup()'ed */ /* delete the converter if it is the last feed. */ if (last_feed) { - mbfl_buffer_converter_delete(MBSTRG(outconv)); + mbfl_buffer_converter_delete(MBSTRG(outconv) TSRMLS_CC); MBSTRG(outconv) = NULL; } } @@ -1581,7 +1587,7 @@ PHP_FUNCTION(mb_strlen) } } - n = mbfl_strlen(&string); + n = mbfl_strlen(&string TSRMLS_CC); if (n >= 0) { RETVAL_LONG(n); } else { @@ -1656,7 +1662,7 @@ PHP_FUNCTION(mb_strpos) needle.val = Z_STRVAL_PP(arg2); needle.len = Z_STRLEN_PP(arg2); - n = mbfl_strpos(&haystack, &needle, offset, reverse); + n = mbfl_strpos(&haystack, &needle, offset, reverse TSRMLS_CC); if (n >= 0) { RETVAL_LONG(n); } else { @@ -1739,7 +1745,7 @@ PHP_FUNCTION(mb_strrpos) haystack.len = Z_STRLEN_PP(arg1); needle.val = Z_STRVAL_PP(arg2); needle.len = Z_STRLEN_PP(arg2); - n = mbfl_strpos(&haystack, &needle, 0, 1); + n = mbfl_strpos(&haystack, &needle, 0, 1 TSRMLS_CC); if (n >= 0) { RETVAL_LONG(n); } else { @@ -1806,7 +1812,7 @@ PHP_FUNCTION(mb_substr) /* measures length */ mblen = 0; if (from < 0 || len < 0) { - mblen = mbfl_strlen(&string); + mblen = mbfl_strlen(&string TSRMLS_CC); } /* if "from" position is negative, count start position from the end @@ -1829,7 +1835,7 @@ PHP_FUNCTION(mb_substr) } } - ret = mbfl_substr(&string, &result, from, len); + ret = mbfl_substr(&string, &result, from, len TSRMLS_CC); if (ret != NULL) { RETVAL_STRINGL(ret->val, ret->len, 0); /* the string is already strdup()'ed */ } else { @@ -1913,7 +1919,7 @@ PHP_FUNCTION(mb_strcut) } } - ret = mbfl_strcut(&string, &result, from, len); + ret = mbfl_strcut(&string, &result, from, len TSRMLS_CC); if (ret != NULL) { RETVAL_STRINGL(ret->val, ret->len, 0); /* the string is already strdup()'ed */ } else { @@ -1955,7 +1961,7 @@ PHP_FUNCTION(mb_strwidth) } } - n = mbfl_strwidth(&string); + n = mbfl_strwidth(&string TSRMLS_CC); if (n >= 0) { RETVAL_LONG(n); } else { @@ -2037,7 +2043,7 @@ PHP_FUNCTION(mb_strimwidth) marker.len = Z_STRLEN_PP(arg4); } - ret = mbfl_strimwidth(&string, &marker, &result, from, width); + ret = mbfl_strimwidth(&string, &marker, &result, from, width TSRMLS_CC); if (ret != NULL) { RETVAL_STRINGL(ret->val, ret->len, 0); /* the string is already strdup()'ed */ } else { @@ -2092,7 +2098,7 @@ PHPAPI char * php_mb_convert_encoding(char *input, size_t length, char *_to_enco string.no_encoding = from_encoding; } else if (size > 1) { /* auto detect */ - from_encoding = mbfl_identify_encoding_no(&string, list, size); + from_encoding = mbfl_identify_encoding_no(&string, list, size TSRMLS_CC); if (from_encoding != mbfl_no_encoding_invalid) { string.no_encoding = from_encoding; } else { @@ -2112,17 +2118,17 @@ PHPAPI char * php_mb_convert_encoding(char *input, size_t length, char *_to_enco } /* initialize converter */ - convd = mbfl_buffer_converter_new(from_encoding, to_encoding, string.len); + convd = mbfl_buffer_converter_new(from_encoding, to_encoding, string.len TSRMLS_CC); if (convd == NULL) { php_error(E_WARNING, "%s() unable to create character encoding converter", get_active_function_name(TSRMLS_C)); return NULL; } - mbfl_buffer_converter_illegal_mode(convd, MBSTRG(current_filter_illegal_mode)); - mbfl_buffer_converter_illegal_substchar(convd, MBSTRG(current_filter_illegal_substchar)); + mbfl_buffer_converter_illegal_mode(convd, MBSTRG(current_filter_illegal_mode) TSRMLS_CC); + mbfl_buffer_converter_illegal_substchar(convd, MBSTRG(current_filter_illegal_substchar) TSRMLS_CC); /* do it */ - ret = mbfl_buffer_converter_feed_result(convd, &string, &result); + ret = mbfl_buffer_converter_feed_result(convd, &string, &result TSRMLS_CC); if (ret) { if (output_len) { *output_len = ret->len; @@ -2130,7 +2136,7 @@ PHPAPI char * php_mb_convert_encoding(char *input, size_t length, char *_to_enco output = ret->val; } - mbfl_buffer_converter_delete(convd); + mbfl_buffer_converter_delete(convd TSRMLS_CC); return output; } /* }}} */ @@ -2266,7 +2272,7 @@ PHP_FUNCTION(mb_detect_encoding) string.no_language = MBSTRG(current_language); string.val = Z_STRVAL_PP(arg_str); string.len = Z_STRLEN_PP(arg_str); - ret = mbfl_identify_encoding_name(&string, elist, size); + ret = mbfl_identify_encoding_name(&string, elist, size TSRMLS_CC); if (list != NULL) { efree((void *)list); } @@ -2341,7 +2347,7 @@ PHP_FUNCTION(mb_encode_mimeheader) string.no_encoding = MBSTRG(current_internal_encoding); string.val = Z_STRVAL_PP(argv[0]); string.len = Z_STRLEN_PP(argv[0]); - ret = mbfl_mime_header_encode(&string, &result, charset, transenc, linefeed, 0); + ret = mbfl_mime_header_encode(&string, &result, charset, transenc, linefeed, 0 TSRMLS_CC); if (ret != NULL) { RETVAL_STRINGL(ret->val, ret->len, 0) /* the string is already strdup()'ed */ } else { @@ -2369,7 +2375,7 @@ PHP_FUNCTION(mb_decode_mimeheader) string.no_encoding = MBSTRG(current_internal_encoding); string.val = Z_STRVAL_PP(arg_str); string.len = Z_STRLEN_PP(arg_str); - ret = mbfl_mime_header_decode(&string, &result, MBSTRG(current_internal_encoding)); + ret = mbfl_mime_header_decode(&string, &result, MBSTRG(current_internal_encoding) TSRMLS_CC); if (ret != NULL) { RETVAL_STRINGL(ret->val, ret->len, 0) /* the string is already strdup()'ed */ } else { @@ -2486,7 +2492,7 @@ PHP_FUNCTION(mb_convert_kana) } } - ret = mbfl_ja_jp_hantozen(&string, &result, opt); + ret = mbfl_ja_jp_hantozen(&string, &result, opt TSRMLS_CC); if (ret != NULL) { RETVAL_STRINGL(ret->val, ret->len, 0); /* the string is already strdup()'ed */ } else { @@ -2564,7 +2570,7 @@ PHP_FUNCTION(mb_convert_variables) stack = (pval ***)emalloc(stack_max*sizeof(pval **)); if (stack != NULL) { stack_level = 0; - identd = mbfl_encoding_detector_new(elist, elistsz); + identd = mbfl_encoding_detector_new(elist, elistsz TSRMLS_CC); if (identd != NULL) { n = 2; while (n < argc || stack_level > 0) { @@ -2607,7 +2613,7 @@ PHP_FUNCTION(mb_convert_variables) } else if (Z_TYPE_PP(hash_entry) == IS_STRING) { string.val = Z_STRVAL_PP(hash_entry); string.len = Z_STRLEN_PP(hash_entry); - if (mbfl_encoding_detector_feed(identd, &string)) { + if (mbfl_encoding_detector_feed(identd, &string TSRMLS_CC)) { goto detect_end; /* complete detecting */ } } @@ -2616,14 +2622,14 @@ PHP_FUNCTION(mb_convert_variables) } else if (Z_TYPE_PP(var) == IS_STRING) { string.val = Z_STRVAL_PP(args[n]); string.len = Z_STRLEN_PP(args[n]); - if (mbfl_encoding_detector_feed(identd, &string)) { + if (mbfl_encoding_detector_feed(identd, &string TSRMLS_CC)) { goto detect_end; /* complete detecting */ } } } detect_end: - from_encoding = mbfl_encoding_detector_judge(identd); - mbfl_encoding_detector_delete(identd); + from_encoding = mbfl_encoding_detector_judge(identd TSRMLS_CC); + mbfl_encoding_detector_delete(identd TSRMLS_CC); } efree(stack); } @@ -2639,14 +2645,14 @@ detect_end: /* create converter */ convd = NULL; if (from_encoding != mbfl_no_encoding_pass) { - convd = mbfl_buffer_converter_new(from_encoding, to_encoding, 0); + convd = mbfl_buffer_converter_new(from_encoding, to_encoding, 0 TSRMLS_CC); if (convd == NULL) { php_error(E_WARNING, "%s() unable to create converter", get_active_function_name(TSRMLS_C)); RETURN_FALSE; } - mbfl_buffer_converter_illegal_mode(convd, MBSTRG(current_filter_illegal_mode)); - mbfl_buffer_converter_illegal_substchar(convd, MBSTRG(current_filter_illegal_substchar)); + mbfl_buffer_converter_illegal_mode(convd, MBSTRG(current_filter_illegal_mode) TSRMLS_CC); + mbfl_buffer_converter_illegal_substchar(convd, MBSTRG(current_filter_illegal_substchar) TSRMLS_CC); } /* convert */ @@ -2696,7 +2702,7 @@ detect_end: } else if (Z_TYPE_PP(hash_entry) == IS_STRING) { string.val = Z_STRVAL_PP(hash_entry); string.len = Z_STRLEN_PP(hash_entry); - ret = mbfl_buffer_converter_feed_result(convd, &string, &result); + ret = mbfl_buffer_converter_feed_result(convd, &string, &result TSRMLS_CC); if (ret != NULL) { STR_FREE(Z_STRVAL_PP(hash_entry)); Z_STRVAL_PP(hash_entry) = ret->val; @@ -2708,7 +2714,7 @@ detect_end: } else if (Z_TYPE_PP(var) == IS_STRING) { string.val = Z_STRVAL_PP(var); string.len = Z_STRLEN_PP(var); - ret = mbfl_buffer_converter_feed_result(convd, &string, &result); + ret = mbfl_buffer_converter_feed_result(convd, &string, &result TSRMLS_CC); if (ret != NULL) { STR_FREE(Z_STRVAL_PP(var)); Z_STRVAL_PP(var) = ret->val; @@ -2718,7 +2724,7 @@ detect_end: } efree(stack); } - mbfl_buffer_converter_delete(convd); + mbfl_buffer_converter_delete(convd TSRMLS_CC); } efree((void *)args); @@ -2799,7 +2805,7 @@ php_mbstr_numericentity_exec(INTERNAL_FUNCTION_PARAMETERS, int type) } mapsize /= 4; - ret = mbfl_html_numeric_entity(&string, &result, convmap, mapsize, type); + ret = mbfl_html_numeric_entity(&string, &result, convmap, mapsize, type TSRMLS_CC); if (ret != NULL) { RETVAL_STRINGL(ret->val, ret->len, 0); } else { @@ -2846,7 +2852,7 @@ PHP_FUNCTION(mb_send_mail) int err = 0; /* initialize */ - mbfl_memory_device_init(&device, 0, 0); + mbfl_memory_device_init(&device, 0, 0 TSRMLS_CC); mbfl_string_init(&orig_str); mbfl_string_init(&conv_str); @@ -2887,11 +2893,11 @@ PHP_FUNCTION(mb_send_mail) orig_str.no_language = MBSTRG(current_language); orig_str.val = Z_STRVAL_PP(argv[1]); orig_str.len = Z_STRLEN_PP(argv[1]); - orig_str.no_encoding = mbfl_identify_encoding_no(&orig_str, MBSTRG(current_detect_order_list), MBSTRG(current_detect_order_list_size)); + orig_str.no_encoding = mbfl_identify_encoding_no(&orig_str, MBSTRG(current_detect_order_list), MBSTRG(current_detect_order_list_size) TSRMLS_CC); if(orig_str.no_encoding == mbfl_no_encoding_invalid) { orig_str.no_encoding = MBSTRG(current_internal_encoding); } - pstr = mbfl_mime_header_encode(&orig_str, &conv_str, tran_cs, head_enc, "\n", sizeof("Subject: [PHP-jp nnnnnnnn]")); + pstr = mbfl_mime_header_encode(&orig_str, &conv_str, tran_cs, head_enc, "\n", sizeof("Subject: [PHP-jp nnnnnnnn]") TSRMLS_CC); if (pstr != NULL) { subject_buf = subject = pstr->val; } else { @@ -2909,11 +2915,11 @@ PHP_FUNCTION(mb_send_mail) orig_str.no_language = MBSTRG(current_language); orig_str.val = Z_STRVAL_PP(argv[2]); orig_str.len = Z_STRLEN_PP(argv[2]); - orig_str.no_encoding = mbfl_identify_encoding_no(&orig_str, MBSTRG(current_detect_order_list), MBSTRG(current_detect_order_list_size)); + orig_str.no_encoding = mbfl_identify_encoding_no(&orig_str, MBSTRG(current_detect_order_list), MBSTRG(current_detect_order_list_size) TSRMLS_CC); if(orig_str.no_encoding == mbfl_no_encoding_invalid) { orig_str.no_encoding = MBSTRG(current_internal_encoding); } - pstr = mbfl_convert_encoding(&orig_str, &conv_str, tran_cs); + pstr = mbfl_convert_encoding(&orig_str, &conv_str, tran_cs TSRMLS_CC); if (pstr != NULL) { message_buf = message = pstr->val; } else { @@ -2934,24 +2940,24 @@ PHP_FUNCTION(mb_send_mail) convert_to_string_ex(argv[3]); p = Z_STRVAL_PP(argv[3]); n = Z_STRLEN_PP(argv[3]); - mbfl_memory_device_strncat(&device, p, n); + mbfl_memory_device_strncat(&device, p, n TSRMLS_CC); if (p[n - 1] != '\n') { - mbfl_memory_device_strncat(&device, "\n", 1); + mbfl_memory_device_strncat(&device, "\n", 1 TSRMLS_CC); } } - mbfl_memory_device_strncat(&device, PHP_MBSTR_MAIL_MIME_HEADER1, sizeof(PHP_MBSTR_MAIL_MIME_HEADER1) - 1); + mbfl_memory_device_strncat(&device, PHP_MBSTR_MAIL_MIME_HEADER1, sizeof(PHP_MBSTR_MAIL_MIME_HEADER1) - 1 TSRMLS_CC); p = (char *)mbfl_no2preferred_mime_name(tran_cs); if (p != NULL) { - mbfl_memory_device_strncat(&device, PHP_MBSTR_MAIL_MIME_HEADER2, sizeof(PHP_MBSTR_MAIL_MIME_HEADER2) - 1); - mbfl_memory_device_strcat(&device, p); + mbfl_memory_device_strncat(&device, PHP_MBSTR_MAIL_MIME_HEADER2, sizeof(PHP_MBSTR_MAIL_MIME_HEADER2) - 1 TSRMLS_CC); + mbfl_memory_device_strcat(&device, p TSRMLS_CC); } - mbfl_memory_device_strncat(&device, PHP_MBSTR_MAIL_MIME_HEADER3, sizeof(PHP_MBSTR_MAIL_MIME_HEADER3) - 1); + mbfl_memory_device_strncat(&device, PHP_MBSTR_MAIL_MIME_HEADER3, sizeof(PHP_MBSTR_MAIL_MIME_HEADER3) - 1 TSRMLS_CC); p = (char *)mbfl_no2preferred_mime_name(body_enc); if (p == NULL) { p = "7bit"; } - mbfl_memory_device_strcat(&device, p); - mbfl_memory_device_output('\0', &device); + mbfl_memory_device_strcat(&device, p TSRMLS_CC); + mbfl_memory_device_output('\0', &device TSRMLS_CC); headers = device.buffer; if (argc == 5) { /* extra options that get passed to the mailer */ @@ -2959,7 +2965,7 @@ PHP_FUNCTION(mb_send_mail) extra_cmd = Z_STRVAL_PP(argv[4]); } - if (!err && php_mail(to, subject, message, headers, extra_cmd TSRMLS_CC)) { + if (!err && php_mail(to, subject, message, headers, extra_cmd)) { RETVAL_TRUE; } else { RETVAL_FALSE; @@ -2971,7 +2977,7 @@ PHP_FUNCTION(mb_send_mail) if (message_buf) { efree((void *)message_buf); } - mbfl_memory_device_clear(&device); + mbfl_memory_device_clear(&device TSRMLS_CC); } /* }}} */ diff --git a/ext/mbstring/mbstring.h b/ext/mbstring/mbstring.h index 3b892805e8..57f05e1de2 100644 --- a/ext/mbstring/mbstring.h +++ b/ext/mbstring/mbstring.h @@ -143,7 +143,7 @@ ZEND_BEGIN_MODULE_GLOBALS(mbstring) int filter_illegal_substchar; int current_filter_illegal_mode; int current_filter_illegal_substchar; - int func_overload; + long func_overload; mbfl_buffer_converter *outconv; #if HAVE_MBREGEX int default_mbctype;