/* $Id$ */
#include "php.h"
+#include "php_globals.h"
#include <stdlib.h>
#include "mbfilter.h"
};
/* 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 = {
* 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;
}
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;
}
void
-mbfl_memory_device_clear(mbfl_memory_device *device)
+mbfl_memory_device_clear(mbfl_memory_device *device TSRMLS_DC)
{
if (device) {
if (device->buffer) {
}
void
-mbfl_memory_device_reset(mbfl_memory_device *device)
+mbfl_memory_device_reset(mbfl_memory_device *device TSRMLS_DC)
{
if (device) {
device->pos = 0;
}
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--;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
void
-mbfl_wchar_device_clear(mbfl_wchar_device *device)
+mbfl_wchar_device_clear(mbfl_wchar_device *device TSRMLS_DC)
{
if (device) {
if (device->buffer) {
}
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;
* 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;
}
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;
} 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;
} 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;
} 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;
} 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;
}
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;
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)
#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;
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;
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;
* 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;
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;
}
}
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;
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;
#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;
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) {
}
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;
}
|| ((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;
}
}
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;
* 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;
} 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;
} 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;
if (c == 0x3d) { /* '=' */
filter->status = 1;
} else {
- CK((*filter->output_function)(c, filter->data));
+ CK((*filter->output_function)(c, filter->data TSRMLS_CC));
}
break;
}
}
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;
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;
* 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;
} 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;
}
* 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));
}
}
* 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));
}
}
* 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;
} 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;
}
* 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));
}
}
* 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));
}
}
* 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;
} 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) {
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;
}
* 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;
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;
}
* 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));
}
}
* 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;
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;
}
* 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));
}
}
* 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) {
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 */
* 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));
}
}
* 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;
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;
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;
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;
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;
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;
* 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;
;
} 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;
}
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;
}
/* 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++;
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++;
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;
}
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;
/* 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;
* 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;
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;
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;
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;
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;
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;
* 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;
;
} 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;
}
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;
}
/* 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 {
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 {
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 {
}
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;
/* 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;
* 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));
}
}
* 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;
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;
* 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;
s = c;
}
- CK((*filter->output_function)(s, filter->data));
+ CK((*filter->output_function)(s, filter->data TSRMLS_CC));
return c;
}
* 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));
}
}
* 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;
s |= MBFL_WCSGROUP_THROUGH;
}
- CK((*filter->output_function)(s, filter->data));
+ CK((*filter->output_function)(s, filter->data TSRMLS_CC));
return c;
}
* 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;
}
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));
}
}
* 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;
s |= MBFL_WCSGROUP_THROUGH;
}
- CK((*filter->output_function)(s, filter->data));
+ CK((*filter->output_function)(s, filter->data TSRMLS_CC));
return c;
}
* 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;
}
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));
}
}
* 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;
s |= MBFL_WCSGROUP_THROUGH;
}
- CK((*filter->output_function)(s, filter->data));
+ CK((*filter->output_function)(s, filter->data TSRMLS_CC));
return c;
}
* 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;
}
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));
}
}
* 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;
s |= MBFL_WCSGROUP_THROUGH;
}
- CK((*filter->output_function)(s, filter->data));
+ CK((*filter->output_function)(s, filter->data TSRMLS_CC));
return c;
}
* 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;
}
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));
}
}
* 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;
s |= MBFL_WCSGROUP_THROUGH;
}
- CK((*filter->output_function)(s, filter->data));
+ CK((*filter->output_function)(s, filter->data TSRMLS_CC));
return c;
}
* 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;
}
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));
}
}
* 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;
s |= MBFL_WCSGROUP_THROUGH;
}
- CK((*filter->output_function)(s, filter->data));
+ CK((*filter->output_function)(s, filter->data TSRMLS_CC));
return c;
}
* 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;
}
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));
}
}
* 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;
s |= MBFL_WCSGROUP_THROUGH;
}
- CK((*filter->output_function)(s, filter->data));
+ CK((*filter->output_function)(s, filter->data TSRMLS_CC));
return c;
}
* 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;
}
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));
}
}
* 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;
s |= MBFL_WCSGROUP_THROUGH;
}
- CK((*filter->output_function)(s, filter->data));
+ CK((*filter->output_function)(s, filter->data TSRMLS_CC));
return c;
}
* 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;
}
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));
}
}
* 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;
s |= MBFL_WCSGROUP_THROUGH;
}
- CK((*filter->output_function)(s, filter->data));
+ CK((*filter->output_function)(s, filter->data TSRMLS_CC));
return c;
}
* 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;
}
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));
}
}
* 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;
s |= MBFL_WCSGROUP_THROUGH;
}
- CK((*filter->output_function)(s, filter->data));
+ CK((*filter->output_function)(s, filter->data TSRMLS_CC));
return c;
}
* 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;
}
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));
}
}
* 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;
s |= MBFL_WCSGROUP_THROUGH;
}
- CK((*filter->output_function)(s, filter->data));
+ CK((*filter->output_function)(s, filter->data TSRMLS_CC));
return c;
}
* 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;
}
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));
}
}
* 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;
s |= MBFL_WCSGROUP_THROUGH;
}
- CK((*filter->output_function)(s, filter->data));
+ CK((*filter->output_function)(s, filter->data TSRMLS_CC));
return c;
}
* 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;
}
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));
}
}
*/
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) {
;
}
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) {
}
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;
}
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 */
}
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 */
}
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 */
}
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) {
* 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;
}
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) {
}
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;
}
/* 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;
}
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;
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);
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;
}
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;
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--;
}
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;
}
}
#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--;
/* 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;
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;
}
}
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;
}
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);
}
}
}
}
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;
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);
}
}
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;
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);
}
}
}
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) {
}
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) {
}
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--;
}
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;
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--;
}
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;
}
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);
}
* 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;
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++;
}
void
-mbfl_encoding_detector_delete(mbfl_encoding_detector *identd)
+mbfl_encoding_detector_delete(mbfl_encoding_detector *identd TSRMLS_DC)
{
int i;
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);
}
}
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;
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++;
}
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;
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;
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);
}
}
}
}
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);
}
* 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;
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++;
bad = 0;
while (i < num) {
filter = &flist[i];
- (*filter->filter_function)(*p, filter);
+ (*filter->filter_function)(*p, filter TSRMLS_CC);
if (filter->flag) {
bad++;
}
i = 0;
while (i < num) {
filter = &flist[i];
- (*filter->filter_dtor)(filter);
+ (*filter->filter_dtor)(filter TSRMLS_CC);
i++;
}
mbfl_free((void *)flist);
}
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) {
}
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) {
* 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;
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;
}
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;
};
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;
mbfl_string *haystack,
mbfl_string *needle,
int offset,
- int reverse)
+ int reverse TSRMLS_DC)
{
int n, result;
unsigned char *p;
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;
}
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;
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;
}
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;
}
};
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;
}
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++;
mbfl_string *string,
mbfl_string *result,
int from,
- int length)
+ int length TSRMLS_DC)
{
mbfl_encoding *encoding;
int n, m, k, len, start, end;
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;
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;
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;
mbfl_string *string,
mbfl_string *result,
int from,
- int length)
+ int length TSRMLS_DC)
{
mbfl_encoding *encoding;
int n, m, k, len, start, end;
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" */
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;
* 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)) {
}
int
-mbfl_strwidth(mbfl_string *string)
+mbfl_strwidth(mbfl_string *string TSRMLS_DC)
{
int len, n;
unsigned char *p;
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;
}
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;
};
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) {
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++;
mbfl_string *marker,
mbfl_string *result,
int from,
- int width)
+ int width TSRMLS_DC)
{
struct collector_strimwidth_data pc;
mbfl_convert_filter *encoder;
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;
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;
}
};
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;
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 */
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 */
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];
} 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];
}
}
- 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;
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;
}
mbfl_ja_jp_hantozen(
mbfl_string *string,
mbfl_string *result,
- int mode)
+ int mode TSRMLS_DC)
{
int n;
unsigned char *p;
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;
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;
}
};
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;
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;
}
}
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;
}
}
}
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;
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;
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;
}
}
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 *
enum mbfl_no_encoding outcode,
enum mbfl_no_encoding encoding,
const char *linefeed,
- int indent)
+ int indent TSRMLS_DC)
{
int n;
unsigned char *p;
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;
}
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;
}
};
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;
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;
}
}
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;
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;
}
}
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;
}
}
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;
}
}
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;
}
}
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:
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;
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;
}
}
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;
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;
}
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;
}
};
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;
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) {
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) {
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;
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:
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:
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;
}
}
}
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) {
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;
}
mbfl_string *result,
int *convmap,
int mapsize,
- int type)
+ int type TSRMLS_DC)
{
struct collector_htmlnumericentity_data pc;
mbfl_memory_device device;
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;
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;
}
projects / php / commitdiff