summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--ext/mbstring/CREDITS2
-rw-r--r--ext/mbstring/mbfilter.c1690
-rw-r--r--ext/mbstring/mbfilter.h156
-rw-r--r--ext/mbstring/mbfilter_ja.c267
-rw-r--r--ext/mbstring/mbfilter_ja.h24
-rw-r--r--ext/mbstring/mbstring.c218
-rw-r--r--ext/mbstring/mbstring.h2
7 files changed, 1186 insertions, 1173 deletions
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 <stdlib.h>
#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 <tsukada@fminn.nagano.nagano.jp> |
+ | Rui Hirokawa <hirokawa@php.net> |
+----------------------------------------------------------------------+
*/
@@ -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;
View Lorry Controller Status