Mirrors
/
php
mirror of https://github.com/php/php-src
3
0
Fork 0
Code Releases Activity
Browse Source

changed mbstring to make thread safe.

experimental/new_ui_api
Rui Hirokawa 25 years ago
parent
f833895afd
commit
1f847267e7
7 changed files with 1186 additions and 1173 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      ext/mbstring/CREDITS
  2. 1690
      ext/mbstring/mbfilter.c
  3. 156
      ext/mbstring/mbfilter.h
  4. 267
      ext/mbstring/mbfilter_ja.c
  5. 24
      ext/mbstring/mbfilter_ja.h
  6. 218
      ext/mbstring/mbstring.c
  7. 2
      ext/mbstring/mbstring.h

2
ext/mbstring/CREDITS
View File

@ -1,2 +1,2 @@
Multibyte (Japanese) String Functions
Tsukada Takuya
Tsukada Takuya, Rui Hirokawa

1690
ext/mbstring/mbfilter.c
File diff suppressed because it is too large
View File

156
ext/mbstring/mbfilter.h
View File

@ -293,20 +293,20 @@ typedef struct _mbfl_wchar_device {
int allocsz;
} mbfl_wchar_device;
void mbfl_memory_device_init(mbfl_memory_device *device, int initsz, int allocsz);
void mbfl_memory_device_realloc(mbfl_memory_device *device, int initsz, int allocsz);
void mbfl_memory_device_clear(mbfl_memory_device *device);
void mbfl_memory_device_reset(mbfl_memory_device *device);
mbfl_string * mbfl_memory_device_result(mbfl_memory_device *device, mbfl_string *result);
int mbfl_memory_device_output(int c, void *data);
int mbfl_memory_device_output2(int c, void *data);
int mbfl_memory_device_output4(int c, void *data);
int mbfl_memory_device_strcat(mbfl_memory_device *device, const char *psrc);
int mbfl_memory_device_strncat(mbfl_memory_device *device, const char *psrc, int len);
int mbfl_memory_device_devcat(mbfl_memory_device *dest, mbfl_memory_device *src);
void mbfl_wchar_device_init(mbfl_wchar_device *device);
int mbfl_wchar_device_output(int c, void *data);
void mbfl_memory_device_init(mbfl_memory_device *device, int initsz, int allocsz TSRMLS_DC);
void mbfl_memory_device_realloc(mbfl_memory_device *device, int initsz, int allocsz TSRMLS_DC);
void mbfl_memory_device_clear(mbfl_memory_device *device TSRMLS_DC);
void mbfl_memory_device_reset(mbfl_memory_device *device TSRMLS_DC);
mbfl_string * mbfl_memory_device_result(mbfl_memory_device *device, mbfl_string *result TSRMLS_DC);
int mbfl_memory_device_output(int c, void *data TSRMLS_DC);
int mbfl_memory_device_output2(int c, void *data TSRMLS_DC);
int mbfl_memory_device_output4(int c, void *data TSRMLS_DC);
int mbfl_memory_device_strcat(mbfl_memory_device *device, const char *psrc TSRMLS_DC);
int mbfl_memory_device_strncat(mbfl_memory_device *device, const char *psrc, int len TSRMLS_DC);
int mbfl_memory_device_devcat(mbfl_memory_device *dest, mbfl_memory_device *src TSRMLS_DC);
void mbfl_wchar_device_init(mbfl_wchar_device *device TSRMLS_DC);
int mbfl_wchar_device_output(int c, void *data TSRMLS_DC);
/*
@ -319,12 +319,12 @@ int mbfl_wchar_device_output(int c, void *data);
typedef struct _mbfl_convert_filter mbfl_convert_filter;
struct _mbfl_convert_filter {
void (*filter_ctor)(mbfl_convert_filter *filter);
void (*filter_dtor)(mbfl_convert_filter *filter);
int (*filter_function)(int c, mbfl_convert_filter *filter);
int (*filter_flush)(mbfl_convert_filter *filter);
int (*output_function)(int c, void *data);
int (*flush_function)(void *data);
void (*filter_ctor)(mbfl_convert_filter *filter TSRMLS_DC);
void (*filter_dtor)(mbfl_convert_filter *filter TSRMLS_DC);
int (*filter_function)(int c, mbfl_convert_filter *filter TSRMLS_DC);
int (*filter_flush)(mbfl_convert_filter *filter TSRMLS_DC);
int (*output_function)(int c, void *data TSRMLS_DC);
int (*flush_function)(void *data TSRMLS_DC);
void *data;
int status;
int cache;
@ -337,25 +337,25 @@ struct _mbfl_convert_filter {
struct mbfl_convert_vtbl {
enum mbfl_no_encoding from;
enum mbfl_no_encoding to;
void (*filter_ctor)(mbfl_convert_filter *filter);
void (*filter_dtor)(mbfl_convert_filter *filter);
int (*filter_function)(int c, mbfl_convert_filter *filter);
int (*filter_flush)(mbfl_convert_filter *filter);
void (*filter_ctor)(mbfl_convert_filter *filter TSRMLS_DC);
void (*filter_dtor)(mbfl_convert_filter *filter TSRMLS_DC);
int (*filter_function)(int c, mbfl_convert_filter *filter TSRMLS_DC);
int (*filter_flush)(mbfl_convert_filter *filter TSRMLS_DC);
};
mbfl_convert_filter *
mbfl_convert_filter_new(
enum mbfl_no_encoding from,
enum mbfl_no_encoding to,
int (*output_function)(int, void *),
int (*flush_function)(void *),
void *data);
void mbfl_convert_filter_delete(mbfl_convert_filter *filter);
int mbfl_convert_filter_feed(int c, mbfl_convert_filter *filter);
int mbfl_convert_filter_flush(mbfl_convert_filter *filter);
void mbfl_convert_filter_reset(mbfl_convert_filter *filter, enum mbfl_no_encoding from, enum mbfl_no_encoding to);
void mbfl_convert_filter_copy(mbfl_convert_filter *src, mbfl_convert_filter *dist);
int mbfl_filt_conv_illegal_output(int c, mbfl_convert_filter *filter);
int (*output_function)(int, void * TSRMLS_DC),
int (*flush_function)(void * TSRMLS_DC),
void *data TSRMLS_DC);
void mbfl_convert_filter_delete(mbfl_convert_filter *filter TSRMLS_DC);
int mbfl_convert_filter_feed(int c, mbfl_convert_filter *filter TSRMLS_DC);
int mbfl_convert_filter_flush(mbfl_convert_filter *filter TSRMLS_DC);
void mbfl_convert_filter_reset(mbfl_convert_filter *filter, enum mbfl_no_encoding from, enum mbfl_no_encoding to TSRMLS_DC);
void mbfl_convert_filter_copy(mbfl_convert_filter *src, mbfl_convert_filter *dist TSRMLS_DC);
int mbfl_filt_conv_illegal_output(int c, mbfl_convert_filter *filter TSRMLS_DC);
/*
@ -364,9 +364,9 @@ int mbfl_filt_conv_illegal_output(int c, mbfl_convert_filter *filter);
typedef struct _mbfl_identify_filter mbfl_identify_filter;
struct _mbfl_identify_filter {
void (*filter_ctor)(mbfl_identify_filter *filter);
void (*filter_dtor)(mbfl_identify_filter *filter);
int (*filter_function)(int c, mbfl_identify_filter *filter);
void (*filter_ctor)(mbfl_identify_filter *filter TSRMLS_DC);
void (*filter_dtor)(mbfl_identify_filter *filter TSRMLS_DC);
int (*filter_function)(int c, mbfl_identify_filter *filter TSRMLS_DC);
int status;
int flag;
int score;
@ -375,13 +375,13 @@ struct _mbfl_identify_filter {
struct mbfl_identify_vtbl {
enum mbfl_no_encoding encoding;
void (*filter_ctor)(mbfl_identify_filter *filter);
void (*filter_dtor)(mbfl_identify_filter *filter);
int (*filter_function)(int c, mbfl_identify_filter *filter);
void (*filter_ctor)(mbfl_identify_filter *filter TSRMLS_DC);
void (*filter_dtor)(mbfl_identify_filter *filter TSRMLS_DC);
int (*filter_function)(int c, mbfl_identify_filter *filter TSRMLS_DC);
};
mbfl_identify_filter * mbfl_identify_filter_new(enum mbfl_no_encoding encoding);
void mbfl_identify_filter_delete(mbfl_identify_filter *filter);
mbfl_identify_filter * mbfl_identify_filter_new(enum mbfl_no_encoding encoding TSRMLS_DC);
void mbfl_identify_filter_delete(mbfl_identify_filter *filter TSRMLS_DC);
/*
@ -397,17 +397,17 @@ struct _mbfl_buffer_converter {
mbfl_encoding *to;
};
mbfl_buffer_converter * mbfl_buffer_converter_new(enum mbfl_no_encoding from, enum mbfl_no_encoding to, int buf_initsz);
void mbfl_buffer_converter_delete(mbfl_buffer_converter *convd);
void mbfl_buffer_converter_reset(mbfl_buffer_converter *convd);
int mbfl_buffer_converter_illegal_mode(mbfl_buffer_converter *convd, int mode);
int mbfl_buffer_converter_illegal_substchar(mbfl_buffer_converter *convd, int substchar);
int mbfl_buffer_converter_strncat(mbfl_buffer_converter *convd, const unsigned char *p, int n);
int mbfl_buffer_converter_feed(mbfl_buffer_converter *convd, mbfl_string *string);
int mbfl_buffer_converter_flush(mbfl_buffer_converter *convd);
mbfl_string * mbfl_buffer_converter_getbuffer(mbfl_buffer_converter *convd, mbfl_string *result);
mbfl_string * mbfl_buffer_converter_result(mbfl_buffer_converter *convd, mbfl_string *result);
mbfl_string * mbfl_buffer_converter_feed_result(mbfl_buffer_converter *convd, mbfl_string *string, mbfl_string *result);
mbfl_buffer_converter * mbfl_buffer_converter_new(enum mbfl_no_encoding from, enum mbfl_no_encoding to, int buf_initsz TSRMLS_DC);
void mbfl_buffer_converter_delete(mbfl_buffer_converter *convd TSRMLS_DC);
void mbfl_buffer_converter_reset(mbfl_buffer_converter *convd TSRMLS_DC);
int mbfl_buffer_converter_illegal_mode(mbfl_buffer_converter *convd, int mode TSRMLS_DC);
int mbfl_buffer_converter_illegal_substchar(mbfl_buffer_converter *convd, int substchar TSRMLS_DC);
int mbfl_buffer_converter_strncat(mbfl_buffer_converter *convd, const unsigned char *p, int n TSRMLS_DC);
int mbfl_buffer_converter_feed(mbfl_buffer_converter *convd, mbfl_string *string TSRMLS_DC);
int mbfl_buffer_converter_flush(mbfl_buffer_converter *convd TSRMLS_DC);
mbfl_string * mbfl_buffer_converter_getbuffer(mbfl_buffer_converter *convd, mbfl_string *result TSRMLS_DC);
mbfl_string * mbfl_buffer_converter_result(mbfl_buffer_converter *convd, mbfl_string *result TSRMLS_DC);
mbfl_string * mbfl_buffer_converter_feed_result(mbfl_buffer_converter *convd, mbfl_string *string, mbfl_string *result TSRMLS_DC);
/*
@ -420,66 +420,66 @@ struct _mbfl_encoding_detector {
int filter_list_size;
};
mbfl_encoding_detector * mbfl_encoding_detector_new(enum mbfl_no_encoding *elist, int eliztsz);
void mbfl_encoding_detector_delete(mbfl_encoding_detector *identd);
int mbfl_encoding_detector_feed(mbfl_encoding_detector *identd, mbfl_string *string);
enum mbfl_no_encoding mbfl_encoding_detector_judge(mbfl_encoding_detector *identd);
mbfl_encoding_detector * mbfl_encoding_detector_new(enum mbfl_no_encoding *elist, int eliztsz TSRMLS_DC);
void mbfl_encoding_detector_delete(mbfl_encoding_detector *identd TSRMLS_DC);
int mbfl_encoding_detector_feed(mbfl_encoding_detector *identd, mbfl_string *string TSRMLS_DC);
enum mbfl_no_encoding mbfl_encoding_detector_judge(mbfl_encoding_detector *identd TSRMLS_DC);
/*
* encoding converter
*/
mbfl_string *
mbfl_convert_encoding(mbfl_string *string, mbfl_string *result, enum mbfl_no_encoding toenc);
mbfl_convert_encoding(mbfl_string *string, mbfl_string *result, enum mbfl_no_encoding toenc TSRMLS_DC);
/*
* identify encoding
*/
mbfl_encoding *
mbfl_identify_encoding(mbfl_string *string, enum mbfl_no_encoding *elist, int eliztsz);
mbfl_identify_encoding(mbfl_string *string, enum mbfl_no_encoding *elist, int eliztsz TSRMLS_DC);
const char *
mbfl_identify_encoding_name(mbfl_string *string, enum mbfl_no_encoding *elist, int eliztsz);
mbfl_identify_encoding_name(mbfl_string *string, enum mbfl_no_encoding *elist, int eliztsz TSRMLS_DC);
enum mbfl_no_encoding
mbfl_identify_encoding_no(mbfl_string *string, enum mbfl_no_encoding *elist, int eliztsz);
mbfl_identify_encoding_no(mbfl_string *string, enum mbfl_no_encoding *elist, int eliztsz TSRMLS_DC);
/*
* strlen
*/
int
mbfl_strlen(mbfl_string *string);
mbfl_strlen(mbfl_string *string TSRMLS_DC);
/*
* strpos
*/
int
mbfl_strpos(mbfl_string *haystack, mbfl_string *needle, int offset, int reverse);
mbfl_strpos(mbfl_string *haystack, mbfl_string *needle, int offset, int reverse TSRMLS_DC);
/*
* substr
*/
mbfl_string *
mbfl_substr(mbfl_string *string, mbfl_string *result, int from, int length);
mbfl_substr(mbfl_string *string, mbfl_string *result, int from, int length TSRMLS_DC);
/*
* strcut
*/
mbfl_string *
mbfl_strcut(mbfl_string *string, mbfl_string *result, int from, int length);
mbfl_strcut(mbfl_string *string, mbfl_string *result, int from, int length TSRMLS_DC);
/*
* strwidth
*/
int
mbfl_strwidth(mbfl_string *string);
mbfl_strwidth(mbfl_string *string TSRMLS_DC);
/*
* strimwidth
*/
mbfl_string *
mbfl_strimwidth(mbfl_string *string, mbfl_string *marker, mbfl_string *result, int from, int width);
mbfl_strimwidth(mbfl_string *string, mbfl_string *marker, mbfl_string *result, int from, int width TSRMLS_DC);
/*
* MIME header encode
@ -490,16 +490,16 @@ struct mime_header_encoder_data *
mime_header_encoder_new(
enum mbfl_no_encoding incode,
enum mbfl_no_encoding outcode,
enum mbfl_no_encoding encoding);
enum mbfl_no_encoding encoding TSRMLS_DC);
void
mime_header_encoder_delete(struct mime_header_encoder_data *pe);
mime_header_encoder_delete(struct mime_header_encoder_data *pe TSRMLS_DC);
int
mime_header_encoder_feed(int c, struct mime_header_encoder_data *pe);
mime_header_encoder_feed(int c, struct mime_header_encoder_data *pe TSRMLS_DC);
mbfl_string *
mime_header_encoder_result(struct mime_header_encoder_data *pe, mbfl_string *result);
mime_header_encoder_result(struct mime_header_encoder_data *pe, mbfl_string *result TSRMLS_DC);
mbfl_string *
mbfl_mime_header_encode(
@ -507,7 +507,7 @@ mbfl_mime_header_encode(
enum mbfl_no_encoding outcode,
enum mbfl_no_encoding encoding,
const char *linefeed,
int indent);
int indent TSRMLS_DC);
/*
* MIME header decode
@ -515,35 +515,35 @@ mbfl_mime_header_encode(
struct mime_header_decoder_data; /* forward declaration */
struct mime_header_decoder_data *
mime_header_decoder_new(enum mbfl_no_encoding outcode);
mime_header_decoder_new(enum mbfl_no_encoding outcode TSRMLS_DC);
void
mime_header_decoder_delete(struct mime_header_decoder_data *pd);
mime_header_decoder_delete(struct mime_header_decoder_data *pd TSRMLS_DC);
int
mime_header_decoder_feed(int c, struct mime_header_decoder_data *pd);
mime_header_decoder_feed(int c, struct mime_header_decoder_data *pd TSRMLS_DC);
mbfl_string *
mime_header_decoder_result(struct mime_header_decoder_data *pd, mbfl_string *result);
mime_header_decoder_result(struct mime_header_decoder_data *pd, mbfl_string *result TSRMLS_DC);
mbfl_string *
mbfl_mime_header_decode(
mbfl_string *string,
mbfl_string *result,
enum mbfl_no_encoding outcode);
enum mbfl_no_encoding outcode TSRMLS_DC);
/*
* convert HTML numeric entity
*/
mbfl_string *
mbfl_html_numeric_entity(mbfl_string *string, mbfl_string *result, int *convmap, int mapsize, int type);
mbfl_html_numeric_entity(mbfl_string *string, mbfl_string *result, int *convmap, int mapsize, int type TSRMLS_DC);
/*
* convert of harfwidth and fullwidth for japanese
*/
mbfl_string *
mbfl_ja_jp_hantozen(mbfl_string *string, mbfl_string *result, int mode);
mbfl_ja_jp_hantozen(mbfl_string *string, mbfl_string *result, int mode TSRMLS_DC);
#endif /* MBFL_MBFILTER_H */

267
ext/mbstring/mbfilter_ja.c
View File

@ -79,6 +79,9 @@
/* $Id$ */
#include "php.h"
#include "php_globals.h"
#include "mbfilter.h"
#include "mbfilter_ja.h"
@ -135,14 +138,14 @@
* EUC-JP => wchar
*/
int
mbfl_filt_conv_eucjp_wchar(int c, mbfl_convert_filter *filter)
mbfl_filt_conv_eucjp_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC)
{
int c1, s, w;
switch (filter->status) {
case 0:
if (c >= 0 && c < 0x80) { /* latin */
CK((*filter->output_function)(c, filter->data));
CK((*filter->output_function)(c, filter->data TSRMLS_CC));
} else if (c > 0xa0 && c < 0xff) { /* X 0208 first char */
filter->status = 1;
filter->cache = c;
@ -153,7 +156,7 @@ mbfl_filt_conv_eucjp_wchar(int c, mbfl_convert_filter *filter)
} else {
w = c & MBFL_WCSGROUP_MASK;
w |= MBFL_WCSGROUP_THROUGH;
CK((*filter->output_function)(w, filter->data));
CK((*filter->output_function)(w, filter->data TSRMLS_CC));
}
break;
@ -172,14 +175,14 @@ mbfl_filt_conv_eucjp_wchar(int c, mbfl_convert_filter *filter)
w &= MBFL_WCSPLANE_MASK;
w |= MBFL_WCSPLANE_JIS0208;
}
CK((*filter->output_function)(w, filter->data));
CK((*filter->output_function)(w, filter->data TSRMLS_CC));
} else if ((c >= 0 && c < 0x21) || c == 0x7f) { /* CTLs */
CK((*filter->output_function)(c, filter->data));
CK((*filter->output_function)(c, filter->data TSRMLS_CC));
} else {
w = (c1 << 8) | c;
w &= MBFL_WCSGROUP_MASK;
w |= MBFL_WCSGROUP_THROUGH;
CK((*filter->output_function)(w, filter->data));
CK((*filter->output_function)(w, filter->data TSRMLS_CC));
}
break;
@ -187,20 +190,20 @@ mbfl_filt_conv_eucjp_wchar(int c, mbfl_convert_filter *filter)
filter->status = 0;
if (c > 0xa0 && c < 0xe0) {
w = 0xfec0 + c;
CK((*filter->output_function)(w, filter->data));
CK((*filter->output_function)(w, filter->data TSRMLS_CC));
} else if ((c >= 0 && c < 0x21) || c == 0x7f) { /* CTLs */
CK((*filter->output_function)(c, filter->data));
CK((*filter->output_function)(c, filter->data TSRMLS_CC));
} else {
w = 0x8e00 | c;
w &= MBFL_WCSGROUP_MASK;
w |= MBFL_WCSGROUP_THROUGH;
CK((*filter->output_function)(w, filter->data));
CK((*filter->output_function)(w, filter->data TSRMLS_CC));
}
break;
case 3: /* got 0x8f, X 0212 first char */
if ((c >= 0 && c < 0x21) || c == 0x7f) { /* CTLs */
CK((*filter->output_function)(c, filter->data));
CK((*filter->output_function)(c, filter->data TSRMLS_CC));
filter->status = 0;
} else {
filter->status++;
@ -222,14 +225,14 @@ mbfl_filt_conv_eucjp_wchar(int c, mbfl_convert_filter *filter)
w &= MBFL_WCSPLANE_MASK;
w |= MBFL_WCSPLANE_JIS0212;
}
CK((*filter->output_function)(w, filter->data));
CK((*filter->output_function)(w, filter->data TSRMLS_CC));
} else if ((c >= 0 && c < 0x21) || c == 0x7f) { /* CTLs */
CK((*filter->output_function)(c, filter->data));
CK((*filter->output_function)(c, filter->data TSRMLS_CC));
} else {
w = (c1 << 8) | c | 0x8f0000;
w &= MBFL_WCSGROUP_MASK;
w |= MBFL_WCSGROUP_THROUGH;
CK((*filter->output_function)(w, filter->data));
CK((*filter->output_function)(w, filter->data TSRMLS_CC));
}
break;
@ -245,7 +248,7 @@ mbfl_filt_conv_eucjp_wchar(int c, mbfl_convert_filter *filter)
* wchar => EUC-JP
*/
int
mbfl_filt_conv_wchar_eucjp(int c, mbfl_convert_filter *filter)
mbfl_filt_conv_wchar_eucjp(int c, mbfl_convert_filter *filter TSRMLS_DC)
{
int c1, s;
@ -289,21 +292,21 @@ mbfl_filt_conv_wchar_eucjp(int c, mbfl_convert_filter *filter)
}
if (s >= 0) {
if (s < 0x80) { /* latin */
CK((*filter->output_function)(s, filter->data));
CK((*filter->output_function)(s, filter->data TSRMLS_CC));
} else if (s < 0x100) { /* kana */
CK((*filter->output_function)(0x8e, filter->data));
CK((*filter->output_function)(s, filter->data));
CK((*filter->output_function)(0x8e, filter->data TSRMLS_CC));
CK((*filter->output_function)(s, filter->data TSRMLS_CC));
} else if (s < 0x8080) { /* X 0208 */
CK((*filter->output_function)(((s >> 8) & 0xff) | 0x80, filter->data));
CK((*filter->output_function)((s & 0xff) | 0x80, filter->data));
CK((*filter->output_function)(((s >> 8) & 0xff) | 0x80, filter->data TSRMLS_CC));
CK((*filter->output_function)((s & 0xff) | 0x80, filter->data TSRMLS_CC));
} else { /* X 0212 */
CK((*filter->output_function)(0x8f, filter->data));
CK((*filter->output_function)(((s >> 8) & 0xff) | 0x80, filter->data));
CK((*filter->output_function)((s & 0xff) | 0x80, filter->data));
CK((*filter->output_function)(0x8f, filter->data TSRMLS_CC));
CK((*filter->output_function)(((s >> 8) & 0xff) | 0x80, filter->data TSRMLS_CC));
CK((*filter->output_function)((s & 0xff) | 0x80, filter->data TSRMLS_CC));
}
} else {
if (filter->illegal_mode != MBFL_OUTPUTFILTER_ILLEGAL_MODE_NONE) {
CK(mbfl_filt_conv_illegal_output(c, filter));
CK(mbfl_filt_conv_illegal_output(c, filter TSRMLS_CC));
}
}
@ -315,14 +318,14 @@ mbfl_filt_conv_wchar_eucjp(int c, mbfl_convert_filter *filter)
* eucJP-win => wchar
*/
int
mbfl_filt_conv_eucjpwin_wchar(int c, mbfl_convert_filter *filter)
mbfl_filt_conv_eucjpwin_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC)
{
int c1, s, w, n;
switch (filter->status) {
case 0:
if (c >= 0 && c < 0x80) { /* latin */
CK((*filter->output_function)(c, filter->data));
CK((*filter->output_function)(c, filter->data TSRMLS_CC));
} else if (c > 0xa0 && c < 0xff) { /* CP932 first char */
filter->status = 1;
filter->cache = c;
@ -333,7 +336,7 @@ mbfl_filt_conv_eucjpwin_wchar(int c, mbfl_convert_filter *filter)
} else {
w = c & MBFL_WCSGROUP_MASK;
w |= MBFL_WCSGROUP_THROUGH;
CK((*filter->output_function)(w, filter->data));
CK((*filter->output_function)(w, filter->data TSRMLS_CC));
}
break;
@ -374,14 +377,14 @@ mbfl_filt_conv_eucjpwin_wchar(int c, mbfl_convert_filter *filter)
w &= MBFL_WCSPLANE_MASK;
w |= MBFL_WCSPLANE_WINCP932;
}
CK((*filter->output_function)(w, filter->data));
CK((*filter->output_function)(w, filter->data TSRMLS_CC));
} else if ((c >= 0 && c < 0x21) || c == 0x7f) { /* CTLs */
CK((*filter->output_function)(c, filter->data));
CK((*filter->output_function)(c, filter->data TSRMLS_CC));
} else {
w = (c1 << 8) | c;
w &= MBFL_WCSGROUP_MASK;
w |= MBFL_WCSGROUP_THROUGH;
CK((*filter->output_function)(w, filter->data));
CK((*filter->output_function)(w, filter->data TSRMLS_CC));
}
break;
@ -389,20 +392,20 @@ mbfl_filt_conv_eucjpwin_wchar(int c, mbfl_convert_filter *filter)
filter->status = 0;
if (c > 0xa0 && c < 0xe0) {
w = 0xfec0 + c;
CK((*filter->output_function)(w, filter->data));
CK((*filter->output_function)(w, filter->data TSRMLS_CC));
} else if ((c >= 0 && c < 0x21) || c == 0x7f) { /* CTLs */
CK((*filter->output_function)(c, filter->data));
CK((*filter->output_function)(c, filter->data TSRMLS_CC));
} else {
w = 0x8e00 | c;
w &= MBFL_WCSGROUP_MASK;
w |= MBFL_WCSGROUP_THROUGH;
CK((*filter->output_function)(w, filter->data));
CK((*filter->output_function)(w, filter->data TSRMLS_CC));
}
break;
case 3: /* got 0x8f, X 0212 first char */
if ((c >= 0 && c < 0x21) || c == 0x7f) { /* CTLs */
CK((*filter->output_function)(c, filter->data));
CK((*filter->output_function)(c, filter->data TSRMLS_CC));
filter->status = 0;
} else {
filter->status++;
@ -439,14 +442,14 @@ mbfl_filt_conv_eucjpwin_wchar(int c, mbfl_convert_filter *filter)
w &= MBFL_WCSPLANE_MASK;
w |= MBFL_WCSPLANE_JIS0212;
}
CK((*filter->output_function)(w, filter->data));
CK((*filter->output_function)(w, filter->data TSRMLS_CC));
} else if ((c >= 0 && c < 0x21) || c == 0x7f) { /* CTLs */
CK((*filter->output_function)(c, filter->data));
CK((*filter->output_function)(c, filter->data TSRMLS_CC));
} else {
w = (c1 << 8) | c | 0x8f0000;
w &= MBFL_WCSGROUP_MASK;
w |= MBFL_WCSGROUP_THROUGH;
CK((*filter->output_function)(w, filter->data));
CK((*filter->output_function)(w, filter->data TSRMLS_CC));
}
break;
@ -462,7 +465,7 @@ mbfl_filt_conv_eucjpwin_wchar(int c, mbfl_convert_filter *filter)
* wchar => eucJP-win
*/
int
mbfl_filt_conv_wchar_eucjpwin(int c, mbfl_convert_filter *filter)
mbfl_filt_conv_wchar_eucjpwin(int c, mbfl_convert_filter *filter TSRMLS_DC)
{
int c1, c2, s1;
@ -557,21 +560,21 @@ mbfl_filt_conv_wchar_eucjpwin(int c, mbfl_convert_filter *filter)
if (s1 >= 0) {
if (s1 < 0x80) { /* latin */
CK((*filter->output_function)(s1, filter->data));
CK((*filter->output_function)(s1, filter->data TSRMLS_CC));
} else if (s1 < 0x100) { /* kana */
CK((*filter->output_function)(0x8e, filter->data));
CK((*filter->output_function)(s1, filter->data));
CK((*filter->output_function)(0x8e, filter->data TSRMLS_CC));
CK((*filter->output_function)(s1, filter->data TSRMLS_CC));
} else if (s1 < 0x8080) { /* X 0208 */
CK((*filter->output_function)(((s1 >> 8) & 0xff) | 0x80, filter->data));
CK((*filter->output_function)((s1 & 0xff) | 0x80, filter->data));
CK((*filter->output_function)(((s1 >> 8) & 0xff) | 0x80, filter->data TSRMLS_CC));
CK((*filter->output_function)((s1 & 0xff) | 0x80, filter->data TSRMLS_CC));
} else { /* X 0212 */
CK((*filter->output_function)(0x8f, filter->data));
CK((*filter->output_function)(((s1 >> 8) & 0xff) | 0x80, filter->data));
CK((*filter->output_function)((s1 & 0xff) | 0x80, filter->data));
CK((*filter->output_function)(0x8f, filter->data TSRMLS_CC));
CK((*filter->output_function)(((s1 >> 8) & 0xff) | 0x80, filter->data TSRMLS_CC));
CK((*filter->output_function)((s1 & 0xff) | 0x80, filter->data TSRMLS_CC));
}
} else {
if (filter->illegal_mode != MBFL_OUTPUTFILTER_ILLEGAL_MODE_NONE) {
CK(mbfl_filt_conv_illegal_output(c, filter));
CK(mbfl_filt_conv_illegal_output(c, filter TSRMLS_CC));
}
}
@ -583,23 +586,23 @@ mbfl_filt_conv_wchar_eucjpwin(int c, mbfl_convert_filter *filter)
* SJIS => wchar
*/
int
mbfl_filt_conv_sjis_wchar(int c, mbfl_convert_filter *filter)
mbfl_filt_conv_sjis_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC)
{
int c1, s1, s2, w;
switch (filter->status) {
case 0:
if (c >= 0 && c < 0x80) { /* latin */
CK((*filter->output_function)(c, filter->data));
CK((*filter->output_function)(c, filter->data TSRMLS_CC));
} else if (c > 0xa0 && c < 0xe0) { /* kana */
CK((*filter->output_function)(0xfec0 + c, filter->data));
CK((*filter->output_function)(0xfec0 + c, filter->data TSRMLS_CC));
} else if (c > 0x80 && c < 0xfd && c != 0xa0) { /* kanji first char */
filter->status = 1;
filter->cache = c;
} else {
w = c & MBFL_WCSGROUP_MASK;
w |= MBFL_WCSGROUP_THROUGH;
CK((*filter->output_function)(w, filter->data));
CK((*filter->output_function)(w, filter->data TSRMLS_CC));
}
break;
@ -625,14 +628,14 @@ mbfl_filt_conv_sjis_wchar(int c, mbfl_convert_filter *filter)
w |= MBFL_WCSGROUP_THROUGH;
}
}
CK((*filter->output_function)(w, filter->data));
CK((*filter->output_function)(w, filter->data TSRMLS_CC));
} else if ((c >= 0 && c < 0x21) || c == 0x7f) { /* CTLs */
CK((*filter->output_function)(c, filter->data));
CK((*filter->output_function)(c, filter->data TSRMLS_CC));
} else {
w = (c1 << 8) | c;
w &= MBFL_WCSGROUP_MASK;
w |= MBFL_WCSGROUP_THROUGH;
CK((*filter->output_function)(w, filter->data));
CK((*filter->output_function)(w, filter->data TSRMLS_CC));
}
break;
@ -648,7 +651,7 @@ mbfl_filt_conv_sjis_wchar(int c, mbfl_convert_filter *filter)
* wchar => SJIS
*/
int
mbfl_filt_conv_wchar_sjis(int c, mbfl_convert_filter *filter)
mbfl_filt_conv_wchar_sjis(int c, mbfl_convert_filter *filter TSRMLS_DC)
{
int c1, c2, s1, s2;
@ -695,17 +698,17 @@ mbfl_filt_conv_wchar_sjis(int c, mbfl_convert_filter *filter)
}
if (s1 >= 0) {
if (s1 < 0x100) { /* latin or kana */
CK((*filter->output_function)(s1, filter->data));
CK((*filter->output_function)(s1, filter->data TSRMLS_CC));
} else { /* kanji */
c1 = (s1 >> 8) & 0xff;
c2 = s1 & 0xff;
SJIS_ENCODE(c1, c2, s1, s2);
CK((*filter->output_function)(s1, filter->data));
CK((*filter->output_function)(s2, filter->data));
CK((*filter->output_function)(s1, filter->data TSRMLS_CC));
CK((*filter->output_function)(s2, filter->data TSRMLS_CC));
}
} else {
if (filter->illegal_mode != MBFL_OUTPUTFILTER_ILLEGAL_MODE_NONE) {
CK(mbfl_filt_conv_illegal_output(c, filter));
CK(mbfl_filt_conv_illegal_output(c, filter TSRMLS_CC));
}
}
@ -717,23 +720,23 @@ mbfl_filt_conv_wchar_sjis(int c, mbfl_convert_filter *filter)
* SJIS-win => wchar
*/
int
mbfl_filt_conv_sjiswin_wchar(int c, mbfl_convert_filter *filter)
mbfl_filt_conv_sjiswin_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC)
{
int c1, s, s1, s2, w;
switch (filter->status) {
case 0:
if (c >= 0 && c < 0x80) { /* latin */
CK((*filter->output_function)(c, filter->data));
CK((*filter->output_function)(c, filter->data TSRMLS_CC));
} else if (c > 0xa0 && c < 0xe0) { /* kana */
CK((*filter->output_function)(0xfec0 + c, filter->data));
CK((*filter->output_function)(0xfec0 + c, filter->data TSRMLS_CC));
} else if (c > 0x80 && c < 0xfd && c != 0xa0) { /* kanji first char */
filter->status = 1;
filter->cache = c;
} else {
w = c & MBFL_WCSGROUP_MASK;
w |= MBFL_WCSGROUP_THROUGH;
CK((*filter->output_function)(w, filter->data));
CK((*filter->output_function)(w, filter->data TSRMLS_CC));
}
break;
@ -779,14 +782,14 @@ mbfl_filt_conv_sjiswin_wchar(int c, mbfl_convert_filter *filter)
w &= MBFL_WCSPLANE_MASK;
w |= MBFL_WCSPLANE_WINCP932;
}
CK((*filter->output_function)(w, filter->data));
CK((*filter->output_function)(w, filter->data TSRMLS_CC));
} else if ((c >= 0 && c < 0x21) || c == 0x7f) { /* CTLs */
CK((*filter->output_function)(c, filter->data));
CK((*filter->output_function)(c, filter->data TSRMLS_CC));
} else {
w = (c1 << 8) | c;
w &= MBFL_WCSGROUP_MASK;
w |= MBFL_WCSGROUP_THROUGH;
CK((*filter->output_function)(w, filter->data));
CK((*filter->output_function)(w, filter->data TSRMLS_CC));
}
break;
@ -802,7 +805,7 @@ mbfl_filt_conv_sjiswin_wchar(int c, mbfl_convert_filter *filter)
* wchar => SJIS-win
*/
int
mbfl_filt_conv_wchar_sjiswin(int c, mbfl_convert_filter *filter)
mbfl_filt_conv_wchar_sjiswin(int c, mbfl_convert_filter *filter TSRMLS_DC)
{
int c1, c2, s1, s2;
@ -883,17 +886,17 @@ mbfl_filt_conv_wchar_sjiswin(int c, mbfl_convert_filter *filter)
}
if (s1 >= 0) {
if (s1 < 0x100) { /* latin or kana */
CK((*filter->output_function)(s1, filter->data));
CK((*filter->output_function)(s1, filter->data TSRMLS_CC));
} else { /* kanji */
c1 = (s1 >> 8) & 0xff;
c2 = s1 & 0xff;
SJIS_ENCODE(c1, c2, s1, s2);
CK((*filter->output_function)(s1, filter->data));
CK((*filter->output_function)(s2, filter->data));
CK((*filter->output_function)(s1, filter->data TSRMLS_CC));
CK((*filter->output_function)(s2, filter->data TSRMLS_CC));
}
} else {
if (filter->illegal_mode != MBFL_OUTPUTFILTER_ILLEGAL_MODE_NONE) {
CK(mbfl_filt_conv_illegal_output(c, filter));
CK(mbfl_filt_conv_illegal_output(c, filter TSRMLS_CC));
}
}
@ -905,7 +908,7 @@ mbfl_filt_conv_wchar_sjiswin(int c, mbfl_convert_filter *filter)
* JIS => wchar
*/
int
mbfl_filt_conv_jis_wchar(int c, mbfl_convert_filter *filter)
mbfl_filt_conv_jis_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC)
{
int c1, s, w;
@ -924,22 +927,22 @@ retry:
} else if (c == 0x0f) { /* "kana out" */
filter->status = 0;
} else if (filter->status == 0x10 && c == 0x5c) { /* YEN SIGN */
CK((*filter->output_function)(0xa5, filter->data));
CK((*filter->output_function)(0xa5, filter->data TSRMLS_CC));
} else if (filter->status == 0x10 && c == 0x7e) { /* OVER LINE */
CK((*filter->output_function)(0x203e, filter->data));
CK((*filter->output_function)(0x203e, filter->data TSRMLS_CC));
} else if (filter->status == 0x20 && c > 0x20 && c < 0x60) { /* kana */
CK((*filter->output_function)(0xff40 + c, filter->data));
CK((*filter->output_function)(0xff40 + c, filter->data TSRMLS_CC));
} else if ((filter->status == 0x80 || filter->status == 0x90) && c > 0x20 && c < 0x7f) { /* kanji first char */
filter->cache = c;
filter->status += 1;
} else if (c >= 0 && c < 0x80) { /* latin, CTLs */
CK((*filter->output_function)(c, filter->data));
CK((*filter->output_function)(c, filter->data TSRMLS_CC));
} else if (c > 0xa0 && c < 0xe0) { /* GR kana */
CK((*filter->output_function)(0xfec0 + c, filter->data));
CK((*filter->output_function)(0xfec0 + c, filter->data TSRMLS_CC));
} else {
w = c & MBFL_WCSGROUP_MASK;
w |= MBFL_WCSGROUP_THROUGH;
CK((*filter->output_function)(w, filter->data));
CK((*filter->output_function)(w, filter->data TSRMLS_CC));
}
break;
@ -973,16 +976,16 @@ retry:
w |= MBFL_WCSPLANE_JIS0212;
}
}
CK((*filter->output_function)(w, filter->data));
CK((*filter->output_function)(w, filter->data TSRMLS_CC));
} else if (c == 0x1b) {
filter->status += 2;
} else if ((c >= 0 && c < 0x21) || c == 0x7f) { /* CTLs */
CK((*filter->output_function)(c, filter->data));
CK((*filter->output_function)(c, filter->data TSRMLS_CC));
} else {
w = (c1 << 8) | c;
w &= MBFL_WCSGROUP_MASK;
w |= MBFL_WCSGROUP_THROUGH;
CK((*filter->output_function)(w, filter->data));
CK((*filter->output_function)(w, filter->data TSRMLS_CC));
}
break;
@ -999,7 +1002,7 @@ retry:
filter->status += 3;
} else {
filter->status &= ~0xf;
CK((*filter->output_function)(0x1b, filter->data));
CK((*filter->output_function)(0x1b, filter->data TSRMLS_CC));
goto retry;
}
break;
@ -1017,8 +1020,8 @@ retry:
filter->status++;
} else {
filter->status &= ~0xf;
CK((*filter->output_function)(0x1b, filter->data));
CK((*filter->output_function)(0x24, filter->data));
CK((*filter->output_function)(0x1b, filter->data TSRMLS_CC));
CK((*filter->output_function)(0x24, filter->data TSRMLS_CC));
goto retry;
}
break;
@ -1036,9 +1039,9 @@ retry:
filter->status = 0x90;
} else {
filter->status &= ~0xf;
CK((*filter->output_function)(0x1b, filter->data));
CK((*filter->output_function)(0x24, filter->data));
CK((*filter->output_function)(0x28, filter->data));
CK((*filter->output_function)(0x1b, filter->data TSRMLS_CC));
CK((*filter->output_function)(0x24, filter->data TSRMLS_CC));
CK((*filter->output_function)(0x28, filter->data TSRMLS_CC));
goto retry;
}
break;
@ -1058,8 +1061,8 @@ retry:
filter->status = 0x20;
} else {
filter->status &= ~0xf;
CK((*filter->output_function)(0x1b, filter->data));
CK((*filter->output_function)(0x28, filter->data));
CK((*filter->output_function)(0x1b, filter->data TSRMLS_CC));
CK((*filter->output_function)(0x28, filter->data TSRMLS_CC));
goto retry;
}
break;
@ -1076,7 +1079,7 @@ retry:
* wchar => JIS
*/
int
mbfl_filt_conv_wchar_jis(int c, mbfl_convert_filter *filter)
mbfl_filt_conv_wchar_jis(int c, mbfl_convert_filter *filter TSRMLS_DC)
{
int c1, s;
@ -1125,51 +1128,51 @@ mbfl_filt_conv_wchar_jis(int c, mbfl_convert_filter *filter)
if (s >= 0) {
if (s < 0x80) { /* ASCII */
if ((filter->status & 0xff00) != 0) {
CK((*filter->output_function)(0x1b, filter->data)); /* ESC */
CK((*filter->output_function)(0x28, filter->data)); /* '(' */
CK((*filter->output_function)(0x42, filter->data)); /* 'B' */
CK((*filter->output_function)(0x1b, filter->data TSRMLS_CC)); /* ESC */
CK((*filter->output_function)(0x28, filter->data TSRMLS_CC)); /* '(' */
CK((*filter->output_function)(0x42, filter->data TSRMLS_CC)); /* 'B' */
}
filter->status = 0;
CK((*filter->output_function)(s, filter->data));
CK((*filter->output_function)(s, filter->data TSRMLS_CC));
} else if (s < 0x100) { /* kana */
if ((filter->status & 0xff00) != 0x100) {
CK((*filter->output_function)(0x1b, filter->data)); /* ESC */
CK((*filter->output_function)(0x28, filter->data)); /* '(' */
CK((*filter->output_function)(0x49, filter->data)); /* 'I' */
CK((*filter->output_function)(0x1b, filter->data TSRMLS_CC)); /* ESC */
CK((*filter->output_function)(0x28, filter->data TSRMLS_CC)); /* '(' */
CK((*filter->output_function)(0x49, filter->data TSRMLS_CC)); /* 'I' */
}
filter->status = 0x100;
CK((*filter->output_function)(s & 0x7f, filter->data));
CK((*filter->output_function)(s & 0x7f, filter->data TSRMLS_CC));
} else if (s < 0x8080) { /* X 0208 */
if ((filter->status & 0xff00) != 0x200) {
CK((*filter->output_function)(0x1b, filter->data)); /* ESC */
CK((*filter->output_function)(0x24, filter->data)); /* '$' */
CK((*filter->output_function)(0x42, filter->data)); /* 'B' */
CK((*filter->output_function)(0x1b, filter->data TSRMLS_CC)); /* ESC */
CK((*filter->output_function)(0x24, filter->data TSRMLS_CC)); /* '$' */
CK((*filter->output_function)(0x42, filter->data TSRMLS_CC)); /* 'B' */
}
filter->status = 0x200;
CK((*filter->output_function)((s >> 8) & 0x7f, filter->data));
CK((*filter->output_function)(s & 0x7f, filter->data));
CK((*filter->output_function)((s >> 8) & 0x7f, filter->data TSRMLS_CC));
CK((*filter->output_function)(s & 0x7f, filter->data TSRMLS_CC));
} else if (s < 0x10000) { /* X 0212 */
if ((filter->status & 0xff00) != 0x300) {
CK((*filter->output_function)(0x1b, filter->data)); /* ESC */
CK((*filter->output_function)(0x24, filter->data)); /* '$' */
CK((*filter->output_function)(0x28, filter->data)); /* '(' */
CK((*filter->output_function)(0x44, filter->data)); /* 'D' */
CK((*filter->output_function)(0x1b, filter->data TSRMLS_CC)); /* ESC */
CK((*filter->output_function)(0x24, filter->data TSRMLS_CC)); /* '$' */
CK((*filter->output_function)(0x28, filter->data TSRMLS_CC)); /* '(' */
CK((*filter->output_function)(0x44, filter->data TSRMLS_CC)); /* 'D' */
}
filter->status = 0x300;
CK((*filter->output_function)((s >> 8) & 0x7f, filter->data));
CK((*filter->output_function)(s & 0x7f, filter->data));
CK((*filter->output_function)((s >> 8) & 0x7f, filter->data TSRMLS_CC));
CK((*filter->output_function)(s & 0x7f, filter->data TSRMLS_CC));
} else { /* X 0201 latin */
if ((filter->status & 0xff00) != 0x400) {
CK((*filter->output_function)(0x1b, filter->data)); /* ESC */
CK((*filter->output_function)(0x28, filter->data)); /* '(' */
CK((*filter->output_function)(0x4a, filter->data)); /* 'J' */
CK((*filter->output_function)(0x1b, filter->data TSRMLS_CC)); /* ESC */
CK((*filter->output_function)(0x28, filter->data TSRMLS_CC)); /* '(' */
CK((*filter->output_function)(0x4a, filter->data TSRMLS_CC)); /* 'J' */
}
filter->status = 0x400;
CK((*filter->output_function)(s & 0x7f, filter->data));
CK((*filter->output_function)(s & 0x7f, filter->data TSRMLS_CC));
}
} else {
if (filter->illegal_mode != MBFL_OUTPUTFILTER_ILLEGAL_MODE_NONE) {
CK(mbfl_filt_conv_illegal_output(c, filter));
CK(mbfl_filt_conv_illegal_output(c, filter TSRMLS_CC));
}
}
@ -1181,7 +1184,7 @@ mbfl_filt_conv_wchar_jis(int c, mbfl_convert_filter *filter)
* wchar => ISO-2022-JP
*/
int
mbfl_filt_conv_wchar_2022jp(int c, mbfl_convert_filter *filter)
mbfl_filt_conv_wchar_2022jp(int c, mbfl_convert_filter *filter TSRMLS_DC)
{
int s;
@ -1226,33 +1229,33 @@ mbfl_filt_conv_wchar_2022jp(int c, mbfl_convert_filter *filter)
if (s >= 0) {
if (s < 0x80) { /* ASCII */
if ((filter->status & 0xff00) != 0) {
CK((*filter->output_function)(0x1b, filter->data)); /* ESC */
CK((*filter->output_function)(0x28, filter->data)); /* '(' */
CK((*filter->output_function)(0x42, filter->data)); /* 'B' */
CK((*filter->output_function)(0x1b, filter->data TSRMLS_CC)); /* ESC */
CK((*filter->output_function)(0x28, filter->data TSRMLS_CC)); /* '(' */
CK((*filter->output_function)(0x42, filter->data TSRMLS_CC)); /* 'B' */
}
filter->status = 0;
CK((*filter->output_function)(s, filter->data));
CK((*filter->output_function)(s, filter->data TSRMLS_CC));
} else if (s < 0x10000) { /* X 0208 */
if ((filter->status & 0xff00) != 0x200) {
CK((*filter->output_function)(0x1b, filter->data)); /* ESC */
CK((*filter->output_function)(0x24, filter->data)); /* '$' */
CK((*filter->output_function)(0x42, filter->data)); /* 'B' */
CK((*filter->output_function)(0x1b, filter->data TSRMLS_CC)); /* ESC */
CK((*filter->output_function)(0x24, filter->data TSRMLS_CC)); /* '$' */
CK((*filter->output_function)(0x42, filter->data TSRMLS_CC)); /* 'B' */
}
filter->status = 0x200;
CK((*filter->output_function)((s >> 8) & 0x7f, filter->data));
CK((*filter->output_function)(s & 0x7f, filter->data));
CK((*filter->output_function)((s >> 8) & 0x7f, filter->data TSRMLS_CC));
CK((*filter->output_function)(s & 0x7f, filter->data TSRMLS_CC));
} else { /* X 0201 latin */
if ((filter->status & 0xff00) != 0x400) {
CK((*filter->output_function)(0x1b, filter->data)); /* ESC */
CK((*filter->output_function)(0x28, filter->data)); /* '(' */
CK((*filter->output_function)(0x4a, filter->data)); /* 'J' */
CK((*filter->output_function)(0x1b, filter->data TSRMLS_CC)); /* ESC */
CK((*filter->output_function)(0x28, filter->data TSRMLS_CC)); /* '(' */
CK((*filter->output_function)(0x4a, filter->data TSRMLS_CC)); /* 'J' */
}
filter->status = 0x400;
CK((*filter->output_function)(s & 0x7f, filter->data));
CK((*filter->output_function)(s & 0x7f, filter->data TSRMLS_CC));
}
} else {
if (filter->illegal_mode != MBFL_OUTPUTFILTER_ILLEGAL_MODE_NONE) {
CK(mbfl_filt_conv_illegal_output(c, filter));
CK(mbfl_filt_conv_illegal_output(c, filter TSRMLS_CC));
}
}
@ -1260,13 +1263,13 @@ mbfl_filt_conv_wchar_2022jp(int c, mbfl_convert_filter *filter)
}
int
mbfl_filt_conv_any_jis_flush(mbfl_convert_filter *filter)
mbfl_filt_conv_any_jis_flush(mbfl_convert_filter *filter TSRMLS_DC)
{
/* back to latin */
if ((filter->status & 0xff00) != 0) {
CK((*filter->output_function)(0x1b, filter->data)); /* ESC */
CK((*filter->output_function)(0x28, filter->data)); /* '(' */
CK((*filter->output_function)(0x42, filter->data)); /* 'B' */
CK((*filter->output_function)(0x1b, filter->data TSRMLS_CC)); /* ESC */
CK((*filter->output_function)(0x28, filter->data TSRMLS_CC)); /* '(' */
CK((*filter->output_function)(0x42, filter->data TSRMLS_CC)); /* 'B' */
}
filter->status &= 0xff;
return 0;

24
ext/mbstring/mbfilter_ja.h
View File

@ -82,17 +82,17 @@
#ifndef MBFL_MBFILTER_JA_H
#define MBFL_MBFILTER_JA_H
int mbfl_filt_conv_eucjp_wchar(int c, mbfl_convert_filter *filter);
int mbfl_filt_conv_wchar_eucjp(int c, mbfl_convert_filter *filter);
int mbfl_filt_conv_eucjpwin_wchar(int c, mbfl_convert_filter *filter);
int mbfl_filt_conv_wchar_eucjpwin(int c, mbfl_convert_filter *filter);
int mbfl_filt_conv_sjis_wchar(int c, mbfl_convert_filter *filter);
int mbfl_filt_conv_wchar_sjis(int c, mbfl_convert_filter *filter);
int mbfl_filt_conv_sjiswin_wchar(int c, mbfl_convert_filter *filter);
int mbfl_filt_conv_wchar_sjiswin(int c, mbfl_convert_filter *filter);
int mbfl_filt_conv_jis_wchar(int c, mbfl_convert_filter *filter);
int mbfl_filt_conv_wchar_jis(int c, mbfl_convert_filter *filter);
int mbfl_filt_conv_wchar_2022jp(int c, mbfl_convert_filter *filter);
int mbfl_filt_conv_any_jis_flush(mbfl_convert_filter *filter);
int mbfl_filt_conv_eucjp_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC);
int mbfl_filt_conv_wchar_eucjp(int c, mbfl_convert_filter *filter TSRMLS_DC);
int mbfl_filt_conv_eucjpwin_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC);
int mbfl_filt_conv_wchar_eucjpwin(int c, mbfl_convert_filter *filter TSRMLS_DC);
int mbfl_filt_conv_sjis_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC);
int mbfl_filt_conv_wchar_sjis(int c, mbfl_convert_filter *filter TSRMLS_DC);
int mbfl_filt_conv_sjiswin_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC);
int mbfl_filt_conv_wchar_sjiswin(int c, mbfl_convert_filter *filter TSRMLS_DC);
int mbfl_filt_conv_jis_wchar(int c, mbfl_convert_filter *filter TSRMLS_DC);
int mbfl_filt_conv_wchar_jis(int c, mbfl_convert_filter *filter TSRMLS_DC);
int mbfl_filt_conv_wchar_2022jp(int c, mbfl_convert_filter *filter TSRMLS_DC);
int mbfl_filt_conv_any_jis_flush(mbfl_convert_filter *filter TSRMLS_DC);
#endif /* MBFL_MBFILTER_JA_H */

218
ext/mbstring/mbstring.c
View File

@ -13,6 +13,7 @@
| license@php.net so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Author: Tsukada Takuya <tsukada@fminn.nagano.nagano.jp> |
| Rui Hirokawa <hirokawa@php.net> |
+----------------------------------------------------------------------+
*/
@ -484,46 +485,51 @@ PHP_INI_END()
/* module global initialize handler */
static void
php_mbstring_init_globals(zend_mbstring_globals *pglobals)
php_mbstring_init_globals(zend_mbstring_globals *pglobals TSRMLS_DC)
{
pglobals->language = mbfl_no_language_japanese;
pglobals->current_language = mbfl_no_language_japanese;
pglobals->internal_encoding = mbfl_no_encoding_euc_jp;
pglobals->current_internal_encoding = mbfl_no_encoding_euc_jp;
pglobals->http_output_encoding = mbfl_no_encoding_pass;
pglobals->current_http_output_encoding = mbfl_no_encoding_pass;
pglobals->http_input_identify = mbfl_no_encoding_invalid;
pglobals->http_input_identify_get = mbfl_no_encoding_invalid;
pglobals->http_input_identify_post = mbfl_no_encoding_invalid;
pglobals->http_input_identify_cookie = mbfl_no_encoding_invalid;
pglobals->http_input_identify_string = mbfl_no_encoding_invalid;
pglobals->http_input_list = NULL;
pglobals->http_input_list_size = 0;
pglobals->detect_order_list = NULL;
pglobals->detect_order_list_size = 0;
pglobals->current_detect_order_list = NULL;
pglobals->current_detect_order_list_size = 0;
pglobals->filter_illegal_mode = MBFL_OUTPUTFILTER_ILLEGAL_MODE_CHAR;
pglobals->filter_illegal_substchar = 0x3f; /* '?' */
pglobals->current_filter_illegal_mode = MBFL_OUTPUTFILTER_ILLEGAL_MODE_CHAR;
pglobals->current_filter_illegal_substchar = 0x3f; /* '?' */
pglobals->func_overload = 0;
MBSTRG(language) = mbfl_no_language_japanese;
MBSTRG(current_language) = mbfl_no_language_japanese;
MBSTRG(internal_encoding) = mbfl_no_encoding_euc_jp;
MBSTRG(current_internal_encoding) = mbfl_no_encoding_euc_jp;
MBSTRG(http_output_encoding) = mbfl_no_encoding_pass;
MBSTRG(current_http_output_encoding) = mbfl_no_encoding_pass;
MBSTRG(http_input_identify) = mbfl_no_encoding_invalid;
MBSTRG(http_input_identify_get) = mbfl_no_encoding_invalid;
MBSTRG(http_input_identify_post) = mbfl_no_encoding_invalid;
MBSTRG(http_input_identify_cookie) = mbfl_no_encoding_invalid;
MBSTRG(http_input_identify_string) = mbfl_no_encoding_invalid;
MBSTRG(http_input_list) = NULL;
MBSTRG(http_input_list_size) = 0;
MBSTRG(detect_order_list) = NULL;
MBSTRG(detect_order_list_size) = 0;
MBSTRG(current_detect_order_list) = NULL;
MBSTRG(current_detect_order_list_size) = 0;
MBSTRG(filter_illegal_mode) = MBFL_OUTPUTFILTER_ILLEGAL_MODE_CHAR;
MBSTRG(filter_illegal_substchar) = 0x3f; /* '?' */
MBSTRG(current_filter_illegal_mode) = MBFL_OUTPUTFILTER_ILLEGAL_MODE_CHAR;
MBSTRG(current_filter_illegal_substchar) = 0x3f; /* '?' */
MBSTRG(func_overload) = 0;
pglobals->outconv = NULL;
#if HAVE_MBREGEX
pglobals->default_mbctype = MBCTYPE_EUC;
pglobals->current_mbctype = MBCTYPE_EUC;
zend_hash_init(&(pglobals->ht_rc), 0, NULL, (void (*)(void *)) php_mbregex_free_cache, 1);
pglobals->search_str = (zval**)0;
pglobals->search_str_val = (zval*)0;
pglobals->search_re = (mb_regex_t*)0;
pglobals->search_pos = 0;
pglobals->search_regs = (struct mbre_registers*)0;
MBSTRG(default_mbctype) = MBCTYPE_EUC;
MBSTRG(current_mbctype) = MBCTYPE_EUC;
zend_hash_init(&(MBSTRG(ht_rc)), 0, NULL, (void (*)(void *)) php_mbregex_free_cache, 1);
MBSTRG(search_str) = (zval**)0;
MBSTRG(search_str_val) = (zval*)0;
MBSTRG(search_re) = (mb_regex_t*)0;
MBSTRG(search_pos) = 0;
MBSTRG(search_regs) = (struct mbre_registers*)0;
#endif
}
PHP_MINIT_FUNCTION(mbstring)
{
ZEND_INIT_MODULE_GLOBALS(mbstring, php_mbstring_init_globals, NULL);
#ifdef ZTS
ts_allocate_id(&mbstring_globals_id, sizeof(zend_mbstring_globals), (ts_allocate_ctor) php_mbstring_init_globals, NULL);
#else
php_mbstring_init_globals(&mbstring_globals TSRMLS_CC);
#endif
REGISTER_INI_ENTRIES();
#if defined(MBSTR_ENC_TRANS)
@ -627,7 +633,7 @@ PHP_RSHUTDOWN_FUNCTION(mbstring)
MBSTRG(current_detect_order_list_size) = 0;
}
if (MBSTRG(outconv) != NULL) {
mbfl_buffer_converter_delete(MBSTRG(outconv));
mbfl_buffer_converter_delete(MBSTRG(outconv) TSRMLS_CC);
MBSTRG(outconv) = NULL;
}
@ -1065,19 +1071,19 @@ php_mbstr_encoding_handler(zval *arg, char *res, char *separator TSRMLS_DC)
} else {
/* auto detect */
from_encoding = mbfl_no_encoding_invalid;
identd = mbfl_encoding_detector_new(elist, elistsz);
identd = mbfl_encoding_detector_new(elist, elistsz TSRMLS_CC);
if (identd) {
n = 0;
while (n < num) {
string.val = val_list[n];
string.len = len_list[n];
if (mbfl_encoding_detector_feed(identd, &string)) {
if (mbfl_encoding_detector_feed(identd, &string TSRMLS_CC)) {
break;
}
n++;
}
from_encoding = mbfl_encoding_detector_judge(identd);
mbfl_encoding_detector_delete(identd);
from_encoding = mbfl_encoding_detector_judge(identd TSRMLS_CC);
mbfl_encoding_detector_delete(identd TSRMLS_CC);
}
if (from_encoding == mbfl_no_encoding_invalid) {
from_encoding = mbfl_no_encoding_pass;
@ -1085,10 +1091,10 @@ php_mbstr_encoding_handler(zval *arg, char *res, char *separator TSRMLS_DC)
}
convd = NULL;
if (from_encoding != mbfl_no_encoding_pass) {
convd = mbfl_buffer_converter_new(from_encoding, to_encoding, 0);
convd = mbfl_buffer_converter_new(from_encoding, to_encoding, 0 TSRMLS_CC);
if (convd != NULL) {
mbfl_buffer_converter_illegal_mode(convd, MBSTRG(current_filter_illegal_mode));
mbfl_buffer_converter_illegal_substchar(convd, MBSTRG(current_filter_illegal_substchar));
mbfl_buffer_converter_illegal_mode(convd, MBSTRG(current_filter_illegal_mode) TSRMLS_CC);
mbfl_buffer_converter_illegal_substchar(convd, MBSTRG(current_filter_illegal_substchar) TSRMLS_CC);
} else {
php_error(E_WARNING, "%s() unable to create converter",
get_active_function_name(TSRMLS_C));
@ -1102,7 +1108,7 @@ php_mbstr_encoding_handler(zval *arg, char *res, char *separator TSRMLS_DC)
while (n < num) {
string.val = val_list[n];
string.len = len_list[n];
if (convd != NULL && mbfl_buffer_converter_feed_result(convd, &string, &resvar) != NULL) {
if (convd != NULL && mbfl_buffer_converter_feed_result(convd, &string, &resvar TSRMLS_CC) != NULL) {
var = resvar.val;
} else {
var = val_list[n];
@ -1110,7 +1116,7 @@ php_mbstr_encoding_handler(zval *arg, char *res, char *separator TSRMLS_DC)
n++;
string.val = val_list[n];
string.len = len_list[n];
if (convd != NULL && mbfl_buffer_converter_feed_result(convd, &string, &resval) != NULL) {
if (convd != NULL && mbfl_buffer_converter_feed_result(convd, &string, &resval TSRMLS_CC) != NULL) {
val = resval.val;
val_len = resval.len;
} else {
@ -1126,7 +1132,7 @@ php_mbstr_encoding_handler(zval *arg, char *res, char *separator TSRMLS_DC)
MBSTRG(http_input_identify) = from_encoding;
if (convd != NULL) {
mbfl_buffer_converter_delete(convd);
mbfl_buffer_converter_delete(convd TSRMLS_CC);
}
if (val_list != NULL) {
efree((void *)val_list);
@ -1372,19 +1378,19 @@ PHP_FUNCTION(mb_parse_str)
} else {
/* auto detect */
from_encoding = mbfl_no_encoding_invalid;
identd = mbfl_encoding_detector_new(elist, elistsz);
identd = mbfl_encoding_detector_new(elist, elistsz TSRMLS_CC);
if (identd != NULL) {
n = 0;
while (n < num) {
string.val = str_list[n];
string.len = len_list[n];
if (mbfl_encoding_detector_feed(identd, &string)) {
if (mbfl_encoding_detector_feed(identd, &string TSRMLS_CC)) {
break;
}
n++;
}
from_encoding = mbfl_encoding_detector_judge(identd);
mbfl_encoding_detector_delete(identd);
from_encoding = mbfl_encoding_detector_judge(identd TSRMLS_CC);
mbfl_encoding_detector_delete(identd TSRMLS_CC);
}
if (from_encoding == mbfl_no_encoding_invalid) {
php_error(E_WARNING, "%s() unable to detect encoding",
@ -1394,10 +1400,10 @@ PHP_FUNCTION(mb_parse_str)
}
convd = NULL;
if (from_encoding != mbfl_no_encoding_pass) {
convd = mbfl_buffer_converter_new(from_encoding, to_encoding, 0);
convd = mbfl_buffer_converter_new(from_encoding, to_encoding, 0 TSRMLS_CC);
if (convd != NULL) {
mbfl_buffer_converter_illegal_mode(convd, MBSTRG(current_filter_illegal_mode));
mbfl_buffer_converter_illegal_substchar(convd, MBSTRG(current_filter_illegal_substchar));
mbfl_buffer_converter_illegal_mode(convd, MBSTRG(current_filter_illegal_mode) TSRMLS_CC);
mbfl_buffer_converter_illegal_substchar(convd, MBSTRG(current_filter_illegal_substchar) TSRMLS_CC);
} else {
php_error(E_WARNING, "%s() unable to create converter",
get_active_function_name(TSRMLS_C));
@ -1417,7 +1423,7 @@ PHP_FUNCTION(mb_parse_str)
/* convert variable name */
string.val = str_list[n];
string.len = len_list[n];
if (convd != NULL && mbfl_buffer_converter_feed_result(convd, &string, &resvar) != NULL) {
if (convd != NULL && mbfl_buffer_converter_feed_result(convd, &string, &resvar TSRMLS_CC) != NULL) {
var = resvar.val;
} else {
var = str_list[n];
@ -1426,7 +1432,7 @@ PHP_FUNCTION(mb_parse_str)
/* convert value */
string.val = str_list[n];
string.len = len_list[n];
if (convd != NULL && mbfl_buffer_converter_feed_result(convd, &string, &resval) != NULL) {
if (convd != NULL && mbfl_buffer_converter_feed_result(convd, &string, &resval TSRMLS_CC) != NULL) {
val = resval.val;
val_len = resval.len;
} else {
@ -1442,7 +1448,7 @@ PHP_FUNCTION(mb_parse_str)
PG(register_globals) = old_rg;
if (convd != NULL) {
mbfl_buffer_converter_delete(convd);
mbfl_buffer_converter_delete(convd TSRMLS_CC);
}
efree((void *)str_list);
efree((void *)len_list);
@ -1479,7 +1485,7 @@ PHP_FUNCTION(mb_output_handler)
if ((arg_status & PHP_OUTPUT_HANDLER_START) != 0) {
/* delete the converter just in case. */
if (MBSTRG(outconv)) {
mbfl_buffer_converter_delete(MBSTRG(outconv));
mbfl_buffer_converter_delete(MBSTRG(outconv) TSRMLS_CC);
MBSTRG(outconv) = NULL;
}
/* if content-type is not yet set, set it and activate the converter */
@ -1495,7 +1501,7 @@ PHP_FUNCTION(mb_output_handler)
if (sapi_add_header(p, len, 0) != FAILURE)
SG(sapi_headers).send_default_content_type = 0;
/* activate the converter */
MBSTRG(outconv) = mbfl_buffer_converter_new(MBSTRG(current_internal_encoding), encoding, 0);
MBSTRG(outconv) = mbfl_buffer_converter_new(MBSTRG(current_internal_encoding), encoding, 0 TSRMLS_CC);
}
}
@ -1510,8 +1516,8 @@ PHP_FUNCTION(mb_output_handler)
/* flag */
last_feed = ((arg_status & PHP_OUTPUT_HANDLER_END) != 0);
/* mode */
mbfl_buffer_converter_illegal_mode(MBSTRG(outconv), MBSTRG(current_filter_illegal_mode));
mbfl_buffer_converter_illegal_substchar(MBSTRG(outconv), MBSTRG(current_filter_illegal_substchar));
mbfl_buffer_converter_illegal_mode(MBSTRG(outconv), MBSTRG(current_filter_illegal_mode) TSRMLS_CC);
mbfl_buffer_converter_illegal_substchar(MBSTRG(outconv), MBSTRG(current_filter_illegal_substchar) TSRMLS_CC);
/* feed the string */
mbfl_string_init(&string);
@ -1519,17 +1525,17 @@ PHP_FUNCTION(mb_output_handler)
string.no_encoding = MBSTRG(current_internal_encoding);
string.val = arg_string;
string.len = arg_string_len;
mbfl_buffer_converter_feed(MBSTRG(outconv), &string);
mbfl_buffer_converter_feed(MBSTRG(outconv), &string TSRMLS_CC);
if (last_feed)
mbfl_buffer_converter_flush(MBSTRG(outconv));
mbfl_buffer_converter_flush(MBSTRG(outconv) TSRMLS_CC);
/* get the converter output, and return it */
mbfl_buffer_converter_result(MBSTRG(outconv), &result);
mbfl_buffer_converter_result(MBSTRG(outconv), &result TSRMLS_CC);
RETVAL_STRINGL(result.val, result.len, 0); /* the string is already strdup()'ed */
/* delete the converter if it is the last feed. */
if (last_feed) {
mbfl_buffer_converter_delete(MBSTRG(outconv));
mbfl_buffer_converter_delete(MBSTRG(outconv) TSRMLS_CC);
MBSTRG(outconv) = NULL;
}
}
@ -1581,7 +1587,7 @@ PHP_FUNCTION(mb_strlen)
}
}
n = mbfl_strlen(&string);
n = mbfl_strlen(&string TSRMLS_CC);
if (n >= 0) {
RETVAL_LONG(n);
} else {
@ -1656,7 +1662,7 @@ PHP_FUNCTION(mb_strpos)
needle.val = Z_STRVAL_PP(arg2);
needle.len = Z_STRLEN_PP(arg2);
n = mbfl_strpos(&haystack, &needle, offset, reverse);
n = mbfl_strpos(&haystack, &needle, offset, reverse TSRMLS_CC);
if (n >= 0) {
RETVAL_LONG(n);
} else {
@ -1739,7 +1745,7 @@ PHP_FUNCTION(mb_strrpos)
haystack.len = Z_STRLEN_PP(arg1);
needle.val = Z_STRVAL_PP(arg2);
needle.len = Z_STRLEN_PP(arg2);
n = mbfl_strpos(&haystack, &needle, 0, 1);
n = mbfl_strpos(&haystack, &needle, 0, 1 TSRMLS_CC);
if (n >= 0) {
RETVAL_LONG(n);
} else {
@ -1806,7 +1812,7 @@ PHP_FUNCTION(mb_substr)
/* measures length */
mblen = 0;
if (from < 0 || len < 0) {
mblen = mbfl_strlen(&string);
mblen = mbfl_strlen(&string TSRMLS_CC);
}
/* if "from" position is negative, count start position from the end
@ -1829,7 +1835,7 @@ PHP_FUNCTION(mb_substr)
}
}
ret = mbfl_substr(&string, &result, from, len);
ret = mbfl_substr(&string, &result, from, len TSRMLS_CC);
if (ret != NULL) {
RETVAL_STRINGL(ret->val, ret->len, 0); /* the string is already strdup()'ed */
} else {
@ -1913,7 +1919,7 @@ PHP_FUNCTION(mb_strcut)
}
}
ret = mbfl_strcut(&string, &result, from, len);
ret = mbfl_strcut(&string, &result, from, len TSRMLS_CC);
if (ret != NULL) {
RETVAL_STRINGL(ret->val, ret->len, 0); /* the string is already strdup()'ed */
} else {
@ -1955,7 +1961,7 @@ PHP_FUNCTION(mb_strwidth)
}
}
n = mbfl_strwidth(&string);
n = mbfl_strwidth(&string TSRMLS_CC);
if (n >= 0) {
RETVAL_LONG(n);
} else {
@ -2037,7 +2043,7 @@ PHP_FUNCTION(mb_strimwidth)
marker.len = Z_STRLEN_PP(arg4);
}
ret = mbfl_strimwidth(&string, &marker, &result, from, width);
ret = mbfl_strimwidth(&string, &marker, &result, from, width TSRMLS_CC);
if (ret != NULL) {
RETVAL_STRINGL(ret->val, ret->len, 0); /* the string is already strdup()'ed */
} else {
@ -2092,7 +2098,7 @@ PHPAPI char * php_mb_convert_encoding(char *input, size_t length, char *_to_enco
string.no_encoding = from_encoding;
} else if (size > 1) {
/* auto detect */
from_encoding = mbfl_identify_encoding_no(&string, list, size);
from_encoding = mbfl_identify_encoding_no(&string, list, size TSRMLS_CC);
if (from_encoding != mbfl_no_encoding_invalid) {
string.no_encoding = from_encoding;
} else {
@ -2112,17 +2118,17 @@ PHPAPI char * php_mb_convert_encoding(char *input, size_t length, char *_to_enco
}
/* initialize converter */
convd = mbfl_buffer_converter_new(from_encoding, to_encoding, string.len);
convd = mbfl_buffer_converter_new(from_encoding, to_encoding, string.len TSRMLS_CC);
if (convd == NULL) {
php_error(E_WARNING, "%s() unable to create character encoding converter",
get_active_function_name(TSRMLS_C));
return NULL;
}
mbfl_buffer_converter_illegal_mode(convd, MBSTRG(current_filter_illegal_mode));
mbfl_buffer_converter_illegal_substchar(convd, MBSTRG(current_filter_illegal_substchar));
mbfl_buffer_converter_illegal_mode(convd, MBSTRG(current_filter_illegal_mode) TSRMLS_CC);
mbfl_buffer_converter_illegal_substchar(convd, MBSTRG(current_filter_illegal_substchar) TSRMLS_CC);
/* do it */
ret = mbfl_buffer_converter_feed_result(convd, &string, &result);
ret = mbfl_buffer_converter_feed_result(convd, &string, &result TSRMLS_CC);
if (ret) {
if (output_len) {
*output_len = ret->len;
@ -2130,7 +2136,7 @@ PHPAPI char * php_mb_convert_encoding(char *input, size_t length, char *_to_enco
output = ret->val;
}
mbfl_buffer_converter_delete(convd);
mbfl_buffer_converter_delete(convd TSRMLS_CC);
return output;
}
/* }}} */
@ -2266,7 +2272,7 @@ PHP_FUNCTION(mb_detect_encoding)
string.no_language = MBSTRG(current_language);
string.val = Z_STRVAL_PP(arg_str);
string.len = Z_STRLEN_PP(arg_str);
ret = mbfl_identify_encoding_name(&string, elist, size);
ret = mbfl_identify_encoding_name(&string, elist, size TSRMLS_CC);
if (list != NULL) {
efree((void *)list);
}
@ -2341,7 +2347,7 @@ PHP_FUNCTION(mb_encode_mimeheader)
string.no_encoding = MBSTRG(current_internal_encoding);
string.val = Z_STRVAL_PP(argv[0]);
string.len = Z_STRLEN_PP(argv[0]);
ret = mbfl_mime_header_encode(&string, &result, charset, transenc, linefeed, 0);
ret = mbfl_mime_header_encode(&string, &result, charset, transenc, linefeed, 0 TSRMLS_CC);
if (ret != NULL) {
RETVAL_STRINGL(ret->val, ret->len, 0) /* the string is already strdup()'ed */
} else {
@ -2369,7 +2375,7 @@ PHP_FUNCTION(mb_decode_mimeheader)
string.no_encoding = MBSTRG(current_internal_encoding);
string.val = Z_STRVAL_PP(arg_str);
string.len = Z_STRLEN_PP(arg_str);
ret = mbfl_mime_header_decode(&string, &result, MBSTRG(current_internal_encoding));
ret = mbfl_mime_header_decode(&string, &result, MBSTRG(current_internal_encoding) TSRMLS_CC);
if (ret != NULL) {
RETVAL_STRINGL(ret->val, ret->len, 0) /* the string is already strdup()'ed */
} else {
@ -2486,7 +2492,7 @@ PHP_FUNCTION(mb_convert_kana)
}
}
ret = mbfl_ja_jp_hantozen(&string, &result, opt);
ret = mbfl_ja_jp_hantozen(&string, &result, opt TSRMLS_CC);
if (ret != NULL) {
RETVAL_STRINGL(ret->val, ret->len, 0); /* the string is already strdup()'ed */
} else {
@ -2564,7 +2570,7 @@ PHP_FUNCTION(mb_convert_variables)
stack = (pval ***)emalloc(stack_max*sizeof(pval **));
if (stack != NULL) {
stack_level = 0;
identd = mbfl_encoding_detector_new(elist, elistsz);
identd = mbfl_encoding_detector_new(elist, elistsz TSRMLS_CC);
if (identd != NULL) {
n = 2;
while (n < argc || stack_level > 0) {
@ -2607,7 +2613,7 @@ PHP_FUNCTION(mb_convert_variables)
} else if (Z_TYPE_PP(hash_entry) == IS_STRING) {
string.val = Z_STRVAL_PP(hash_entry);
string.len = Z_STRLEN_PP(hash_entry);
if (mbfl_encoding_detector_feed(identd, &string)) {
if (mbfl_encoding_detector_feed(identd, &string TSRMLS_CC)) {
goto detect_end; /* complete detecting */
}
}
@ -2616,14 +2622,14 @@ PHP_FUNCTION(mb_convert_variables)
} else if (Z_TYPE_PP(var) == IS_STRING) {
string.val = Z_STRVAL_PP(args[n]);
string.len = Z_STRLEN_PP(args[n]);
if (mbfl_encoding_detector_feed(identd, &string)) {
if (mbfl_encoding_detector_feed(identd, &string TSRMLS_CC)) {
goto detect_end; /* complete detecting */
}
}
}
detect_end:
from_encoding = mbfl_encoding_detector_judge(identd);
mbfl_encoding_detector_delete(identd);
from_encoding = mbfl_encoding_detector_judge(identd TSRMLS_CC);
mbfl_encoding_detector_delete(identd TSRMLS_CC);
}
efree(stack);
}
@ -2639,14 +2645,14 @@ detect_end:
/* create converter */
convd = NULL;
if (from_encoding != mbfl_no_encoding_pass) {
convd = mbfl_buffer_converter_new(from_encoding, to_encoding, 0);
convd = mbfl_buffer_converter_new(from_encoding, to_encoding, 0 TSRMLS_CC);
if (convd == NULL) {
php_error(E_WARNING, "%s() unable to create converter",
get_active_function_name(TSRMLS_C));
RETURN_FALSE;
}
mbfl_buffer_converter_illegal_mode(convd, MBSTRG(current_filter_illegal_mode));
mbfl_buffer_converter_illegal_substchar(convd, MBSTRG(current_filter_illegal_substchar));
mbfl_buffer_converter_illegal_mode(convd, MBSTRG(current_filter_illegal_mode) TSRMLS_CC);
mbfl_buffer_converter_illegal_substchar(convd, MBSTRG(current_filter_illegal_substchar) TSRMLS_CC);
}
/* convert */
@ -2696,7 +2702,7 @@ detect_end:
} else if (Z_TYPE_PP(hash_entry) == IS_STRING) {
string.val = Z_STRVAL_PP(hash_entry);
string.len = Z_STRLEN_PP(hash_entry);
ret = mbfl_buffer_converter_feed_result(convd, &string, &result);
ret = mbfl_buffer_converter_feed_result(convd, &string, &result TSRMLS_CC);
if (ret != NULL) {
STR_FREE(Z_STRVAL_PP(hash_entry));
Z_STRVAL_PP(hash_entry) = ret->val;
@ -2708,7 +2714,7 @@ detect_end:
} else if (Z_TYPE_PP(var) == IS_STRING) {
string.val = Z_STRVAL_PP(var);
string.len = Z_STRLEN_PP(var);
ret = mbfl_buffer_converter_feed_result(convd, &string, &result);
ret = mbfl_buffer_converter_feed_result(convd, &string, &result TSRMLS_CC);
if (ret != NULL) {
STR_FREE(Z_STRVAL_PP(var));
Z_STRVAL_PP(var) = ret->val;
@ -2718,7 +2724,7 @@ detect_end:
}
efree(stack);
}
mbfl_buffer_converter_delete(convd);
mbfl_buffer_converter_delete(convd TSRMLS_CC);
}
efree((void *)args);
@ -2799,7 +2805,7 @@ php_mbstr_numericentity_exec(INTERNAL_FUNCTION_PARAMETERS, int type)
}
mapsize /= 4;
ret = mbfl_html_numeric_entity(&string, &result, convmap, mapsize, type);
ret = mbfl_html_numeric_entity(&string, &result, convmap, mapsize, type TSRMLS_CC);
if (ret != NULL) {
RETVAL_STRINGL(ret->val, ret->len, 0);
} else {
@ -2846,7 +2852,7 @@ PHP_FUNCTION(mb_send_mail)
int err = 0;
/* initialize */
mbfl_memory_device_init(&device, 0, 0);
mbfl_memory_device_init(&device, 0, 0 TSRMLS_CC);
mbfl_string_init(&orig_str);
mbfl_string_init(&conv_str);
@ -2887,11 +2893,11 @@ PHP_FUNCTION(mb_send_mail)
orig_str.no_language = MBSTRG(current_language);
orig_str.val = Z_STRVAL_PP(argv[1]);
orig_str.len = Z_STRLEN_PP(argv[1]);
orig_str.no_encoding = mbfl_identify_encoding_no(&orig_str, MBSTRG(current_detect_order_list), MBSTRG(current_detect_order_list_size));
orig_str.no_encoding = mbfl_identify_encoding_no(&orig_str, MBSTRG(current_detect_order_list), MBSTRG(current_detect_order_list_size) TSRMLS_CC);
if(orig_str.no_encoding == mbfl_no_encoding_invalid) {
orig_str.no_encoding = MBSTRG(current_internal_encoding);
}
pstr = mbfl_mime_header_encode(&orig_str, &conv_str, tran_cs, head_enc, "\n", sizeof("Subject: [PHP-jp nnnnnnnn]"));
pstr = mbfl_mime_header_encode(&orig_str, &conv_str, tran_cs, head_enc, "\n", sizeof("Subject: [PHP-jp nnnnnnnn]") TSRMLS_CC);
if (pstr != NULL) {
subject_buf = subject = pstr->val;
} else {
@ -2909,11 +2915,11 @@ PHP_FUNCTION(mb_send_mail)
orig_str.no_language = MBSTRG(current_language);
orig_str.val = Z_STRVAL_PP(argv[2]);
orig_str.len = Z_STRLEN_PP(argv[2]);
orig_str.no_encoding = mbfl_identify_encoding_no(&orig_str, MBSTRG(current_detect_order_list), MBSTRG(current_detect_order_list_size));
orig_str.no_encoding = mbfl_identify_encoding_no(&orig_str, MBSTRG(current_detect_order_list), MBSTRG(current_detect_order_list_size) TSRMLS_CC);
if(orig_str.no_encoding == mbfl_no_encoding_invalid) {
orig_str.no_encoding = MBSTRG(current_internal_encoding);
}
pstr = mbfl_convert_encoding(&orig_str, &conv_str, tran_cs);
pstr = mbfl_convert_encoding(&orig_str, &conv_str, tran_cs TSRMLS_CC);
if (pstr != NULL) {
message_buf = message = pstr->val;
} else {
@ -2934,24 +2940,24 @@ PHP_FUNCTION(mb_send_mail)
convert_to_string_ex(argv[3]);
p = Z_STRVAL_PP(argv[3]);
n = Z_STRLEN_PP(argv[3]);
mbfl_memory_device_strncat(&device, p, n);
mbfl_memory_device_strncat(&device, p, n TSRMLS_CC);
if (p[n - 1] != '\n') {
mbfl_memory_device_strncat(&device, "\n", 1);
mbfl_memory_device_strncat(&device, "\n", 1 TSRMLS_CC);
}
}
mbfl_memory_device_strncat(&device, PHP_MBSTR_MAIL_MIME_HEADER1, sizeof(PHP_MBSTR_MAIL_MIME_HEADER1) - 1);
mbfl_memory_device_strncat(&device, PHP_MBSTR_MAIL_MIME_HEADER1, sizeof(PHP_MBSTR_MAIL_MIME_HEADER1) - 1 TSRMLS_CC);
p = (char *)mbfl_no2preferred_mime_name(tran_cs);
if (p != NULL) {
mbfl_memory_device_strncat(&device, PHP_MBSTR_MAIL_MIME_HEADER2, sizeof(PHP_MBSTR_MAIL_MIME_HEADER2) - 1);
mbfl_memory_device_strcat(&device, p);
mbfl_memory_device_strncat(&device, PHP_MBSTR_MAIL_MIME_HEADER2, sizeof(PHP_MBSTR_MAIL_MIME_HEADER2) - 1 TSRMLS_CC);
mbfl_memory_device_strcat(&device, p TSRMLS_CC);
}
mbfl_memory_device_strncat(&device, PHP_MBSTR_MAIL_MIME_HEADER3, sizeof(PHP_MBSTR_MAIL_MIME_HEADER3) - 1);
mbfl_memory_device_strncat(&device, PHP_MBSTR_MAIL_MIME_HEADER3, sizeof(PHP_MBSTR_MAIL_MIME_HEADER3) - 1 TSRMLS_CC);
p = (char *)mbfl_no2preferred_mime_name(body_enc);
if (p == NULL) {
p = "7bit";
}
mbfl_memory_device_strcat(&device, p);
mbfl_memory_device_output('\0', &device);
mbfl_memory_device_strcat(&device, p TSRMLS_CC);
mbfl_memory_device_output('\0', &device TSRMLS_CC);
headers = device.buffer;
if (argc == 5) { /* extra options that get passed to the mailer */
@ -2959,7 +2965,7 @@ PHP_FUNCTION(mb_send_mail)
extra_cmd = Z_STRVAL_PP(argv[4]);
}
if (!err && php_mail(to, subject, message, headers, extra_cmd TSRMLS_CC)) {
if (!err && php_mail(to, subject, message, headers, extra_cmd)) {
RETVAL_TRUE;
} else {
RETVAL_FALSE;
@ -2971,7 +2977,7 @@ PHP_FUNCTION(mb_send_mail)
if (message_buf) {
efree((void *)message_buf);
}
mbfl_memory_device_clear(&device);
mbfl_memory_device_clear(&device TSRMLS_CC);
}
/* }}} */

2
ext/mbstring/mbstring.h
View File

@ -143,7 +143,7 @@ ZEND_BEGIN_MODULE_GLOBALS(mbstring)
int filter_illegal_substchar;
int current_filter_illegal_mode;
int current_filter_illegal_substchar;
int func_overload;
long func_overload;
mbfl_buffer_converter *outconv;
#if HAVE_MBREGEX
int default_mbctype;

Write Preview
Loading…
Cancel
Save