From b3c1d9d1118438a3dae3544447db2b39ca5cfa25 Mon Sep 17 00:00:00 2001 From: Nikita Popov Date: Thu, 20 Jul 2017 19:35:48 +0200 Subject: [PATCH] Directly use encodings instead of no_encoding in libmbfl In particular strings now store encoding rather than the no_encoding. I've also pruned out libmbfl APIs that existed in two forms, one using no_encoding and the other using encoding. We were not actually using any of the former. --- ext/mbstring/libmbfl/mbfl/mbfilter.c | 396 ++++++----------------- ext/mbstring/libmbfl/mbfl/mbfilter.h | 30 +- ext/mbstring/libmbfl/mbfl/mbfl_convert.c | 29 +- ext/mbstring/libmbfl/mbfl/mbfl_convert.h | 6 +- ext/mbstring/libmbfl/mbfl/mbfl_string.c | 7 +- ext/mbstring/libmbfl/mbfl/mbfl_string.h | 4 +- ext/mbstring/mb_gpc.c | 14 +- ext/mbstring/mbstring.c | 196 ++++++----- ext/mbstring/php_unicode.c | 10 +- 9 files changed, 248 insertions(+), 444 deletions(-) diff --git a/ext/mbstring/libmbfl/mbfl/mbfilter.c b/ext/mbstring/libmbfl/mbfl/mbfilter.c index 3a68558d45..d76c54ecf7 100644 --- a/ext/mbstring/libmbfl/mbfl/mbfilter.c +++ b/ext/mbstring/libmbfl/mbfl/mbfilter.c @@ -101,8 +101,14 @@ #include "mbfilter.h" #include "mbfl_filter_output.h" +#include "mbfilter_8bit.h" #include "mbfilter_pass.h" +#include "mbfilter_wchar.h" +#include "filters/mbfilter_ascii.h" +#include "filters/mbfilter_base64.h" +#include "filters/mbfilter_qprint.h" #include "filters/mbfilter_tl_jisx0201_jisx0208.h" +#include "filters/mbfilter_utf8.h" #include "eaw_table.h" @@ -124,18 +130,6 @@ static char mbfl_hexchar_table[] = { */ mbfl_buffer_converter * mbfl_buffer_converter_new( - enum mbfl_no_encoding from, - enum mbfl_no_encoding to, - size_t buf_initsz) -{ - const mbfl_encoding *_from = mbfl_no2encoding(from); - const mbfl_encoding *_to = mbfl_no2encoding(to); - - return mbfl_buffer_converter_new2(_from ? _from: &mbfl_encoding_pass, _to ? _to: &mbfl_encoding_pass, buf_initsz); -} - -mbfl_buffer_converter * -mbfl_buffer_converter_new2( const mbfl_encoding *from, const mbfl_encoding *to, size_t buf_initsz) @@ -156,12 +150,12 @@ mbfl_buffer_converter_new2( 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, NULL, &convd->device); + convd->filter1 = mbfl_convert_filter_new(convd->from, convd->to, mbfl_memory_device_output, NULL, &convd->device); } else { - convd->filter2 = mbfl_convert_filter_new(mbfl_no_encoding_wchar, convd->to->no_encoding, mbfl_memory_device_output, NULL, &convd->device); + convd->filter2 = mbfl_convert_filter_new(&mbfl_encoding_wchar, convd->to, mbfl_memory_device_output, NULL, &convd->device); if (convd->filter2 != NULL) { - convd->filter1 = mbfl_convert_filter_new(convd->from->no_encoding, - mbfl_no_encoding_wchar, + convd->filter1 = mbfl_convert_filter_new(convd->from, + &mbfl_encoding_wchar, (int (*)(int, void*))convd->filter2->filter_function, (int (*)(void*))convd->filter2->filter_flush, convd->filter2); @@ -318,7 +312,7 @@ mbfl_string * mbfl_buffer_converter_getbuffer(mbfl_buffer_converter *convd, mbfl_string *result) { if (convd != NULL && result != NULL && convd->device.buffer != NULL) { - result->no_encoding = convd->to->no_encoding; + result->encoding = convd->to; result->val = convd->device.buffer; result->len = convd->device.pos; } else { @@ -334,7 +328,7 @@ mbfl_buffer_converter_result(mbfl_buffer_converter *convd, mbfl_string *result) if (convd == NULL || result == NULL) { return NULL; } - result->no_encoding = convd->to->no_encoding; + result->encoding = convd->to; return mbfl_memory_device_result(&convd->device, result); } @@ -352,7 +346,7 @@ mbfl_buffer_converter_feed_result(mbfl_buffer_converter *convd, mbfl_string *str if (convd->filter2 != NULL) { mbfl_convert_filter_flush(convd->filter2); } - result->no_encoding = convd->to->no_encoding; + result->encoding = convd->to; return mbfl_memory_device_result(&convd->device, result); } @@ -379,49 +373,7 @@ size_t mbfl_buffer_illegalchars(mbfl_buffer_converter *convd) * encoding detector */ mbfl_encoding_detector * -mbfl_encoding_detector_new(enum mbfl_no_encoding *elist, int elistsz, int strict) -{ - mbfl_encoding_detector *identd; - - int i, num; - mbfl_identify_filter *filter; - - if (elist == NULL || elistsz <= 0) { - return NULL; - } - - /* allocate */ - identd = (mbfl_encoding_detector*)mbfl_malloc(sizeof(mbfl_encoding_detector)); - if (identd == NULL) { - return NULL; - } - identd->filter_list = (mbfl_identify_filter **)mbfl_calloc(elistsz, sizeof(mbfl_identify_filter *)); - if (identd->filter_list == NULL) { - mbfl_free(identd); - return NULL; - } - - /* create filters */ - i = 0; - num = 0; - while (i < elistsz) { - filter = mbfl_identify_filter_new(elist[i]); - if (filter != NULL) { - identd->filter_list[num] = filter; - num++; - } - i++; - } - identd->filter_list_size = num; - - /* set strict flag */ - identd->strict = strict; - - return identd; -} - -mbfl_encoding_detector * -mbfl_encoding_detector_new2(const mbfl_encoding **elist, int elistsz, int strict) +mbfl_encoding_detector_new(const mbfl_encoding **elist, int elistsz, int strict) { mbfl_encoding_detector *identd; @@ -514,7 +466,7 @@ mbfl_encoding_detector_feed(mbfl_encoding_detector *identd, mbfl_string *string) return res; } -const mbfl_encoding *mbfl_encoding_detector_judge2(mbfl_encoding_detector *identd) +const mbfl_encoding *mbfl_encoding_detector_judge(mbfl_encoding_detector *identd) { mbfl_identify_filter *filter; const mbfl_encoding *encoding = NULL; @@ -549,13 +501,6 @@ const mbfl_encoding *mbfl_encoding_detector_judge2(mbfl_encoding_detector *ident return encoding; } -enum mbfl_no_encoding mbfl_encoding_detector_judge(mbfl_encoding_detector *identd) -{ - const mbfl_encoding *encoding = mbfl_encoding_detector_judge2(identd); - return !encoding ? mbfl_no_encoding_invalid: encoding->no_encoding; -} - - /* * encoding converter */ @@ -563,29 +508,27 @@ mbfl_string * mbfl_convert_encoding( mbfl_string *string, mbfl_string *result, - enum mbfl_no_encoding toenc) + const mbfl_encoding *toenc) { size_t n; unsigned char *p; - const mbfl_encoding *encoding; mbfl_memory_device device; mbfl_convert_filter *filter1; mbfl_convert_filter *filter2; /* initialize */ - encoding = mbfl_no2encoding(toenc); - if (encoding == NULL || string == NULL || result == NULL) { + if (toenc == NULL || string == NULL || result == NULL) { return NULL; } 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); + if (mbfl_convert_filter_get_vtbl(string->encoding->no_encoding, toenc->no_encoding) != NULL) { + filter1 = mbfl_convert_filter_new(string->encoding, toenc, mbfl_memory_device_output, 0, &device); } else { - filter2 = mbfl_convert_filter_new(mbfl_no_encoding_wchar, toenc, mbfl_memory_device_output, 0, &device); + filter2 = mbfl_convert_filter_new(&mbfl_encoding_wchar, toenc, mbfl_memory_device_output, 0, &device); 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->encoding, &mbfl_encoding_wchar, (int (*)(int, void*))filter2->filter_function, NULL, filter2); if (filter1 == NULL) { mbfl_convert_filter_delete(filter2); } @@ -629,92 +572,7 @@ mbfl_convert_encoding( * identify encoding */ const mbfl_encoding * -mbfl_identify_encoding(mbfl_string *string, enum mbfl_no_encoding *elist, int elistsz, int strict) -{ - int i, num, bad; - size_t n; - unsigned char *p; - mbfl_identify_filter *flist, *filter; - const mbfl_encoding *encoding; - - /* flist is an array of mbfl_identify_filter instances */ - flist = (mbfl_identify_filter *)mbfl_calloc(elistsz, sizeof(mbfl_identify_filter)); - if (flist == NULL) { - return NULL; - } - - num = 0; - if (elist != NULL) { - for (i = 0; i < elistsz; i++) { - if (!mbfl_identify_filter_init(&flist[num], elist[i])) { - num++; - } - } - } - - /* feed data */ - n = string->len; - p = string->val; - - if (p != NULL) { - bad = 0; - while (n > 0) { - for (i = 0; i < num; i++) { - filter = &flist[i]; - if (!filter->flag) { - (*filter->filter_function)(*p, filter); - if (filter->flag) { - bad++; - } - } - } - if ((num - 1) <= bad && !strict) { - break; - } - p++; - n--; - } - } - - /* judge */ - encoding = NULL; - - for (i = 0; i < num; i++) { - filter = &flist[i]; - if (!filter->flag) { - if (strict && filter->status) { - continue; - } - encoding = filter->encoding; - break; - } - } - - /* fall-back judge */ - if (!encoding) { - for (i = 0; i < num; i++) { - filter = &flist[i]; - if (!filter->flag && (!strict || !filter->status)) { - encoding = filter->encoding; - break; - } - } - } - - /* cleanup */ - /* dtors should be called in reverse order */ - i = num; - while (--i >= 0) { - mbfl_identify_filter_cleanup(&flist[i]); - } - - mbfl_free((void *)flist); - - return encoding; -} - -const mbfl_encoding * -mbfl_identify_encoding2(mbfl_string *string, const mbfl_encoding **elist, int elistsz, int strict) +mbfl_identify_encoding(mbfl_string *string, const mbfl_encoding **elist, int elistsz, int strict) { int i, num, bad; size_t n; @@ -813,12 +671,7 @@ mbfl_strlen(mbfl_string *string) { size_t len, n, k; unsigned char *p; - const mbfl_encoding *encoding; - - encoding = mbfl_no2encoding(string->no_encoding); - if (encoding == NULL || string == NULL) { - return (size_t) -1; - } + const mbfl_encoding *encoding = string->encoding; len = 0; if (encoding->flag & MBFL_ENCTYPE_SBCS) { @@ -844,8 +697,8 @@ mbfl_strlen(mbfl_string *string) } else { /* wchar filter */ mbfl_convert_filter *filter = mbfl_convert_filter_new( - string->no_encoding, - mbfl_no_encoding_wchar, + string->encoding, + &mbfl_encoding_wchar, filter_count_output, 0, &len); if (filter == NULL) { return (size_t) -1; @@ -936,16 +789,7 @@ mbfl_oddlen(mbfl_string *string) { size_t len, n, k; unsigned char *p; - const mbfl_encoding *encoding; - - - if (string == NULL) { - return (size_t) -1; - } - encoding = mbfl_no2encoding(string->no_encoding); - if (encoding == NULL) { - return (size_t) -1; - } + const mbfl_encoding *encoding = string->encoding; len = 0; if (encoding->flag & MBFL_ENCTYPE_SBCS) { @@ -992,17 +836,16 @@ mbfl_strpos( } { - const mbfl_encoding *u8_enc; - u8_enc = mbfl_no2encoding(mbfl_no_encoding_utf8); - if (u8_enc == NULL || u8_enc->mblen_table == NULL) { + const mbfl_encoding *u8_enc = &mbfl_encoding_utf8; + if (u8_enc->mblen_table == NULL) { return (size_t) -8; } u8_tbl = u8_enc->mblen_table; } - if (haystack->no_encoding != mbfl_no_encoding_utf8) { + if (haystack->encoding->no_encoding != mbfl_no_encoding_utf8) { mbfl_string_init(&_haystack_u8); - haystack_u8 = mbfl_convert_encoding(haystack, &_haystack_u8, mbfl_no_encoding_utf8); + haystack_u8 = mbfl_convert_encoding(haystack, &_haystack_u8, &mbfl_encoding_utf8); if (haystack_u8 == NULL) { result = (size_t) -4; goto out; @@ -1011,9 +854,9 @@ mbfl_strpos( haystack_u8 = haystack; } - if (needle->no_encoding != mbfl_no_encoding_utf8) { + if (needle->encoding->no_encoding != mbfl_no_encoding_utf8) { mbfl_string_init(&_needle_u8); - needle_u8 = mbfl_convert_encoding(needle, &_needle_u8, mbfl_no_encoding_utf8); + needle_u8 = mbfl_convert_encoding(needle, &_needle_u8, &mbfl_encoding_utf8); if (needle_u8 == NULL) { result = (size_t) -4; goto out; @@ -1203,8 +1046,8 @@ mbfl_substr_count( /* needle is converted into wchar */ mbfl_wchar_device_init(&pc.needle); filter = mbfl_convert_filter_new( - needle->no_encoding, - mbfl_no_encoding_wchar, + needle->encoding, + &mbfl_encoding_wchar, mbfl_wchar_device_output, 0, &pc.needle); if (filter == NULL) { return (size_t) -4; @@ -1231,8 +1074,8 @@ mbfl_substr_count( } /* initialize filter and collector data */ filter = mbfl_convert_filter_new( - haystack->no_encoding, - mbfl_no_encoding_wchar, + haystack->encoding, + &mbfl_encoding_wchar, collector_strpos, 0, &pc); if (filter == NULL) { mbfl_wchar_device_clear(&pc.needle); @@ -1303,18 +1146,14 @@ mbfl_substr( size_t from, size_t length) { - const mbfl_encoding *encoding; + const mbfl_encoding *encoding = string->encoding; size_t n, k, len, start, end; unsigned m; unsigned char *p, *w; - encoding = mbfl_no2encoding(string->no_encoding); - if (encoding == NULL || string == NULL || result == NULL) { - return NULL; - } mbfl_string_init(result); result->no_language = string->no_language; - result->no_encoding = string->no_encoding; + result->encoding = string->encoding; if ((encoding->flag & (MBFL_ENCTYPE_SBCS | MBFL_ENCTYPE_WCS2BE | MBFL_ENCTYPE_WCS2LE | MBFL_ENCTYPE_WCS4BE | MBFL_ENCTYPE_WCS4LE)) || encoding->mblen_table != NULL) { @@ -1402,16 +1241,16 @@ mbfl_substr( mbfl_memory_device_init(&device, length + 1, 0); mbfl_string_init(result); result->no_language = string->no_language; - result->no_encoding = string->no_encoding; + result->encoding = string->encoding; /* output code filter */ decoder = mbfl_convert_filter_new( - mbfl_no_encoding_wchar, - string->no_encoding, + &mbfl_encoding_wchar, + string->encoding, mbfl_memory_device_output, 0, &device); /* wchar filter */ encoder = mbfl_convert_filter_new( - string->no_encoding, - mbfl_no_encoding_wchar, + string->encoding, + &mbfl_encoding_wchar, collector_substr, 0, &pc); if (decoder == NULL || encoder == NULL) { mbfl_convert_filter_delete(encoder); @@ -1455,26 +1294,16 @@ mbfl_strcut( size_t from, size_t length) { - const mbfl_encoding *encoding; + const mbfl_encoding *encoding = string->encoding; mbfl_memory_device device; - /* validate the parameters */ - if (string == NULL || string->val == NULL || result == NULL) { - return NULL; - } - if (from >= string->len) { from = string->len; } - encoding = mbfl_no2encoding(string->no_encoding); - if (encoding == NULL) { - return NULL; - } - mbfl_string_init(result); result->no_language = string->no_language; - result->no_encoding = string->no_encoding; + result->encoding = string->encoding; if ((encoding->flag & (MBFL_ENCTYPE_SBCS | MBFL_ENCTYPE_WCS2BE @@ -1571,16 +1400,16 @@ mbfl_strcut( /* output code filter */ if (!(decoder = mbfl_convert_filter_new( - mbfl_no_encoding_wchar, - string->no_encoding, + &mbfl_encoding_wchar, + string->encoding, mbfl_memory_device_output, 0, &device))) { return NULL; } /* wchar filter */ if (!(encoder = mbfl_convert_filter_new( - string->no_encoding, - mbfl_no_encoding_wchar, + string->encoding, + &mbfl_encoding_wchar, mbfl_filter_output_null, NULL, NULL))) { mbfl_convert_filter_delete(decoder); @@ -1774,8 +1603,8 @@ mbfl_strwidth(mbfl_string *string) if (string->len > 0 && string->val != NULL) { /* wchar filter */ filter = mbfl_convert_filter_new( - string->no_encoding, - mbfl_no_encoding_wchar, + string->encoding, + &mbfl_encoding_wchar, filter_count_width, 0, &len); if (filter == NULL) { mbfl_convert_filter_delete(filter); @@ -1863,22 +1692,22 @@ mbfl_strimwidth( } mbfl_string_init(result); result->no_language = string->no_language; - result->no_encoding = string->no_encoding; + result->encoding = string->encoding; mbfl_memory_device_init(&pc.device, width, 0); /* output code filter */ pc.decoder = mbfl_convert_filter_new( - mbfl_no_encoding_wchar, - string->no_encoding, + &mbfl_encoding_wchar, + string->encoding, mbfl_memory_device_output, 0, &pc.device); pc.decoder_backup = mbfl_convert_filter_new( - mbfl_no_encoding_wchar, - string->no_encoding, + &mbfl_encoding_wchar, + string->encoding, mbfl_memory_device_output, 0, &pc.device); /* wchar filter */ encoder = mbfl_convert_filter_new( - string->no_encoding, - mbfl_no_encoding_wchar, + string->encoding, + &mbfl_encoding_wchar, collector_strimwidth, 0, &pc); if (pc.decoder == NULL || pc.decoder_backup == NULL || encoder == NULL) { mbfl_convert_filter_delete(encoder); @@ -1921,7 +1750,7 @@ mbfl_strimwidth( 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_reset(encoder, marker->encoding, &mbfl_encoding_wchar); p = marker->val; n = marker->len; while (n > 0) { @@ -1954,7 +1783,6 @@ mbfl_ja_jp_hantozen( { size_t n; unsigned char *p; - const mbfl_encoding *encoding; mbfl_memory_device device; mbfl_convert_filter *decoder = NULL; mbfl_convert_filter *encoder = NULL; @@ -1962,25 +1790,15 @@ mbfl_ja_jp_hantozen( mbfl_convert_filter *next_filter = NULL; mbfl_filt_tl_jisx0201_jisx0208_param *param = NULL; - /* validate parameters */ - if (string == NULL || result == NULL) { - return NULL; - } - - encoding = mbfl_no2encoding(string->no_encoding); - if (encoding == NULL) { - return NULL; - } - mbfl_memory_device_init(&device, string->len, 0); mbfl_string_init(result); result->no_language = string->no_language; - result->no_encoding = string->no_encoding; + result->encoding = string->encoding; decoder = mbfl_convert_filter_new( - mbfl_no_encoding_wchar, - string->no_encoding, + &mbfl_encoding_wchar, + string->encoding, mbfl_memory_device_output, 0, &device); if (decoder == NULL) { goto out; @@ -2009,8 +1827,8 @@ mbfl_ja_jp_hantozen( next_filter = tl_filter; encoder = mbfl_convert_filter_new( - string->no_encoding, - mbfl_no_encoding_wchar, + string->encoding, + &mbfl_encoding_wchar, (int(*)(int, void*))next_filter->filter_function, (int(*)(void*))next_filter->filter_flush, next_filter); @@ -2215,18 +2033,16 @@ mime_header_encoder_result(struct mime_header_encoder_data *pe, mbfl_string *res struct mime_header_encoder_data* mime_header_encoder_new( - enum mbfl_no_encoding incode, - enum mbfl_no_encoding outcode, - enum mbfl_no_encoding transenc) + const mbfl_encoding *incode, + const mbfl_encoding *outcode, + const mbfl_encoding *transenc) { size_t n; const char *s; - const mbfl_encoding *outencoding; struct mime_header_encoder_data *pe; /* get output encoding and check MIME charset name */ - outencoding = mbfl_no2encoding(outcode); - if (outencoding == NULL || outencoding->mime_name == NULL || outencoding->mime_name[0] == '\0') { + if (outcode->mime_name == NULL || outcode->mime_name[0] == '\0') { return NULL; } @@ -2247,16 +2063,16 @@ mime_header_encoder_new( n = 0; pe->encname[n++] = 0x3d; pe->encname[n++] = 0x3f; - s = outencoding->mime_name; + s = outcode->mime_name; while (*s) { pe->encname[n++] = *s++; } pe->encname[n++] = 0x3f; - if (transenc == mbfl_no_encoding_qprint) { + if (transenc->no_encoding == mbfl_no_encoding_qprint) { pe->encname[n++] = 0x51; } else { pe->encname[n++] = 0x42; - transenc = mbfl_no_encoding_base64; + transenc = &mbfl_encoding_base64; } pe->encname[n++] = 0x3f; pe->encname[n] = '\0'; @@ -2274,14 +2090,14 @@ mime_header_encoder_new( pe->encod_filter_backup = mbfl_convert_filter_new(outcode, transenc, mbfl_memory_device_output, 0, &(pe->outdev)); /* 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_encoding_wchar, outcode, mbfl_filter_output_pipe, 0, pe->encod_filter); + pe->conv2_filter_backup = mbfl_convert_filter_new(&mbfl_encoding_wchar, outcode, mbfl_filter_output_pipe, 0, pe->encod_filter); /* 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_encoding_wchar, &mbfl_encoding_wchar, mime_header_encoder_block_collector, 0, pe); /* 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_encoding_wchar, mime_header_encoder_collector, 0, pe); if (pe->encod_filter == NULL || pe->encod_filter_backup == NULL || @@ -2292,7 +2108,7 @@ mime_header_encoder_new( return NULL; } - if (transenc == mbfl_no_encoding_qprint) { + if (transenc->no_encoding == mbfl_no_encoding_qprint) { pe->encod_filter->status |= MBFL_QPRINT_STS_MIME_HEADER; pe->encod_filter_backup->status |= MBFL_QPRINT_STS_MIME_HEADER; } else { @@ -2329,8 +2145,8 @@ mbfl_string * mbfl_mime_header_encode( mbfl_string *string, mbfl_string *result, - enum mbfl_no_encoding outcode, - enum mbfl_no_encoding encoding, + const mbfl_encoding *outcode, + const mbfl_encoding *encoding, const char *linefeed, int indent) { @@ -2340,9 +2156,9 @@ mbfl_mime_header_encode( mbfl_string_init(result); result->no_language = string->no_language; - result->no_encoding = mbfl_no_encoding_ascii; + result->encoding = &mbfl_encoding_ascii; - pe = mime_header_encoder_new(string->no_encoding, outcode, encoding); + pe = mime_header_encoder_new(string->encoding, outcode, encoding); if (pe == NULL) { return NULL; } @@ -2385,9 +2201,9 @@ struct mime_header_decoder_data { mbfl_memory_device tmpdev; size_t cspos; int status; - enum mbfl_no_encoding encoding; - enum mbfl_no_encoding incode; - enum mbfl_no_encoding outcode; + const mbfl_encoding *encoding; + const mbfl_encoding *incode; + const mbfl_encoding *outcode; }; static int @@ -2421,7 +2237,7 @@ mime_header_decoder_collector(int c, void* data) mbfl_memory_device_output('\0', &pd->tmpdev); encoding = mbfl_name2encoding((const char *)&pd->tmpdev.buffer[pd->cspos]); if (encoding != NULL) { - pd->incode = encoding->no_encoding; + pd->incode = encoding; pd->status = 3; } mbfl_memory_device_unput(&pd->tmpdev); @@ -2443,10 +2259,10 @@ mime_header_decoder_collector(int c, void* data) case 3: /* identify encoding */ mbfl_memory_device_output(c, &pd->tmpdev); if (c == 0x42 || c == 0x62) { /* 'B' or 'b' */ - pd->encoding = mbfl_no_encoding_base64; + pd->encoding = &mbfl_encoding_base64; pd->status = 4; } else if (c == 0x51 || c == 0x71) { /* 'Q' or 'q' */ - pd->encoding = mbfl_no_encoding_qprint; + pd->encoding = &mbfl_encoding_qprint; pd->status = 4; } else { if (c == 0x0d || c == 0x0a) { /* CR or LF */ @@ -2463,9 +2279,9 @@ mime_header_decoder_collector(int c, void* data) mbfl_memory_device_output(c, &pd->tmpdev); 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_encoding_wchar); /* 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_encoding_8bit); pd->status = 5; } else { if (c == 0x0d || c == 0x0a) { /* CR or LF */ @@ -2490,7 +2306,7 @@ mime_header_decoder_collector(int c, void* data) /* 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); + mbfl_convert_filter_reset(pd->conv1_filter, &mbfl_encoding_ascii, &mbfl_encoding_wchar); pd->status = 7; } else { (*pd->deco_filter->filter_function)(0x3f, pd->deco_filter); @@ -2576,7 +2392,7 @@ mime_header_decoder_result(struct mime_header_decoder_data *pd, mbfl_string *res } struct mime_header_decoder_data* -mime_header_decoder_new(enum mbfl_no_encoding outcode) +mime_header_decoder_new(const mbfl_encoding *outcode) { struct mime_header_decoder_data *pd; @@ -2589,14 +2405,14 @@ mime_header_decoder_new(enum mbfl_no_encoding outcode) mbfl_memory_device_init(&pd->tmpdev, 0, 0); pd->cspos = 0; pd->status = 0; - pd->encoding = mbfl_no_encoding_pass; - pd->incode = mbfl_no_encoding_ascii; + pd->encoding = &mbfl_encoding_pass; + pd->incode = &mbfl_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_encoding_wchar, pd->outcode, mbfl_memory_device_output, 0, &pd->outdev); + pd->conv1_filter = mbfl_convert_filter_new(pd->incode, &mbfl_encoding_wchar, mbfl_filter_output_pipe, 0, pd->conv2_filter); /* 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_encoding_8bit, mbfl_filter_output_pipe, 0, pd->conv1_filter); if (pd->conv1_filter == NULL || pd->conv2_filter == NULL || pd->deco_filter == NULL) { mime_header_decoder_delete(pd); @@ -2629,7 +2445,7 @@ mbfl_string * mbfl_mime_header_decode( mbfl_string *string, mbfl_string *result, - enum mbfl_no_encoding outcode) + const mbfl_encoding *outcode) { size_t n; unsigned char *p; @@ -2637,7 +2453,7 @@ mbfl_mime_header_decode( mbfl_string_init(result); result->no_language = string->no_language; - result->no_encoding = outcode; + result->encoding = outcode; pd = mime_header_decoder_new(outcode); if (pd == NULL) { @@ -3036,29 +2852,29 @@ mbfl_html_numeric_entity( } mbfl_string_init(result); result->no_language = string->no_language; - result->no_encoding = string->no_encoding; + result->encoding = string->encoding; mbfl_memory_device_init(&device, string->len, 0); /* output code filter */ pc.decoder = mbfl_convert_filter_new( - mbfl_no_encoding_wchar, - string->no_encoding, + &mbfl_encoding_wchar, + string->encoding, mbfl_memory_device_output, 0, &device); /* wchar filter */ if (type == 0) { /* decimal output */ encoder = mbfl_convert_filter_new( - string->no_encoding, - mbfl_no_encoding_wchar, + string->encoding, + &mbfl_encoding_wchar, collector_encode_htmlnumericentity, 0, &pc); } else if (type == 2) { /* hex output */ encoder = mbfl_convert_filter_new( - string->no_encoding, - mbfl_no_encoding_wchar, + string->encoding, + &mbfl_encoding_wchar, collector_encode_hex_htmlnumericentity, 0, &pc); } else { /* type == 1: decimal/hex input */ encoder = mbfl_convert_filter_new( - string->no_encoding, - mbfl_no_encoding_wchar, + string->encoding, + &mbfl_encoding_wchar, collector_decode_htmlnumericentity, (int (*)(void*))mbfl_filt_decode_htmlnumericentity_flush, &pc); } diff --git a/ext/mbstring/libmbfl/mbfl/mbfilter.h b/ext/mbstring/libmbfl/mbfl/mbfilter.h index 11d9ce40b9..d376e7d46d 100644 --- a/ext/mbstring/libmbfl/mbfl/mbfilter.h +++ b/ext/mbstring/libmbfl/mbfl/mbfilter.h @@ -126,8 +126,7 @@ struct _mbfl_buffer_converter { const mbfl_encoding *to; }; -MBFLAPI extern mbfl_buffer_converter * mbfl_buffer_converter_new(enum mbfl_no_encoding from, enum mbfl_no_encoding to, size_t buf_initsz); -MBFLAPI extern mbfl_buffer_converter * mbfl_buffer_converter_new2(const mbfl_encoding *from, const mbfl_encoding *to, size_t buf_initsz); +MBFLAPI extern mbfl_buffer_converter * mbfl_buffer_converter_new(const mbfl_encoding *from, const mbfl_encoding *to, size_t buf_initsz); MBFLAPI extern void mbfl_buffer_converter_delete(mbfl_buffer_converter *convd); MBFLAPI extern void mbfl_buffer_converter_reset(mbfl_buffer_converter *convd); MBFLAPI extern int mbfl_buffer_converter_illegal_mode(mbfl_buffer_converter *convd, int mode); @@ -152,29 +151,24 @@ struct _mbfl_encoding_detector { int strict; }; -MBFLAPI extern mbfl_encoding_detector * mbfl_encoding_detector_new(enum mbfl_no_encoding *elist, int elistsz, int strict); -MBFLAPI extern mbfl_encoding_detector * mbfl_encoding_detector_new2(const mbfl_encoding **elist, int elistsz, int strict); +MBFLAPI extern mbfl_encoding_detector * mbfl_encoding_detector_new(const mbfl_encoding **elist, int elistsz, int strict); MBFLAPI extern void mbfl_encoding_detector_delete(mbfl_encoding_detector *identd); MBFLAPI extern int mbfl_encoding_detector_feed(mbfl_encoding_detector *identd, mbfl_string *string); -MBFLAPI extern enum mbfl_no_encoding mbfl_encoding_detector_judge(mbfl_encoding_detector *identd); -MBFLAPI extern const mbfl_encoding *mbfl_encoding_detector_judge2(mbfl_encoding_detector *identd); +MBFLAPI extern const mbfl_encoding *mbfl_encoding_detector_judge(mbfl_encoding_detector *identd); /* * encoding converter */ MBFLAPI extern 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, const mbfl_encoding *toenc); /* * identify encoding */ MBFLAPI extern const mbfl_encoding * -mbfl_identify_encoding(mbfl_string *string, enum mbfl_no_encoding *elist, int elistsz, int strict); - -MBFLAPI extern const mbfl_encoding * -mbfl_identify_encoding2(mbfl_string *string, const mbfl_encoding **elist, int elistsz, int strict); +mbfl_identify_encoding(mbfl_string *string, const mbfl_encoding **elist, int elistsz, int strict); /* Lengths -1 through -16 are reserved for error return values */ static inline int mbfl_is_error(size_t len) { @@ -237,9 +231,9 @@ struct mime_header_encoder_data; /* forward declaration */ MBFLAPI extern struct mime_header_encoder_data * mime_header_encoder_new( - enum mbfl_no_encoding incode, - enum mbfl_no_encoding outcode, - enum mbfl_no_encoding encoding); + const mbfl_encoding *incode, + const mbfl_encoding *outcode, + const mbfl_encoding *encoding); MBFLAPI extern void mime_header_encoder_delete(struct mime_header_encoder_data *pe); @@ -253,8 +247,8 @@ mime_header_encoder_result(struct mime_header_encoder_data *pe, mbfl_string *res MBFLAPI extern mbfl_string * mbfl_mime_header_encode( mbfl_string *string, mbfl_string *result, - enum mbfl_no_encoding outcode, - enum mbfl_no_encoding encoding, + const mbfl_encoding *outcode, + const mbfl_encoding *encoding, const char *linefeed, int indent); @@ -264,7 +258,7 @@ mbfl_mime_header_encode( struct mime_header_decoder_data; /* forward declaration */ MBFLAPI extern struct mime_header_decoder_data * -mime_header_decoder_new(enum mbfl_no_encoding outcode); +mime_header_decoder_new(const mbfl_encoding *outcode); MBFLAPI extern void mime_header_decoder_delete(struct mime_header_decoder_data *pd); @@ -279,7 +273,7 @@ MBFLAPI extern mbfl_string * mbfl_mime_header_decode( mbfl_string *string, mbfl_string *result, - enum mbfl_no_encoding outcode); + const mbfl_encoding *outcode); /* * convert HTML numeric entity diff --git a/ext/mbstring/libmbfl/mbfl/mbfl_convert.c b/ext/mbstring/libmbfl/mbfl/mbfl_convert.c index 557704d515..2f98b58178 100644 --- a/ext/mbstring/libmbfl/mbfl/mbfl_convert.c +++ b/ext/mbstring/libmbfl/mbfl/mbfl_convert.c @@ -281,21 +281,16 @@ const struct mbfl_convert_vtbl *mbfl_convert_filter_list[] = { static int mbfl_convert_filter_common_init( mbfl_convert_filter *filter, - enum mbfl_no_encoding from, - enum mbfl_no_encoding to, + const mbfl_encoding *from, + const mbfl_encoding *to, const struct mbfl_convert_vtbl *vtbl, int (*output_function)(int, void* ), int (*flush_function)(void*), void* data) { /* encoding structure */ - if ((filter->from = mbfl_no2encoding(from)) == NULL) { - return 1; - } - - if ((filter->to = mbfl_no2encoding(to)) == NULL) { - return 1; - } + filter->from = from; + filter->to = to; if (output_function != NULL) { filter->output_function = output_function; @@ -322,8 +317,8 @@ mbfl_convert_filter_common_init( mbfl_convert_filter * mbfl_convert_filter_new( - enum mbfl_no_encoding from, - enum mbfl_no_encoding to, + const mbfl_encoding *from, + const mbfl_encoding *to, int (*output_function)(int, void* ), int (*flush_function)(void*), void* data) @@ -331,7 +326,7 @@ mbfl_convert_filter_new( mbfl_convert_filter * filter; const struct mbfl_convert_vtbl *vtbl; - vtbl = mbfl_convert_filter_get_vtbl(from, to); + vtbl = mbfl_convert_filter_get_vtbl(from->no_encoding, to->no_encoding); if (vtbl == NULL) { vtbl = &vtbl_pass; @@ -360,18 +355,22 @@ mbfl_convert_filter_new2( void* data) { mbfl_convert_filter * filter; + const mbfl_encoding *from_encoding, *to_encoding; if (vtbl == NULL) { vtbl = &vtbl_pass; } + from_encoding = mbfl_no2encoding(vtbl->from); + to_encoding = mbfl_no2encoding(vtbl->to); + /* allocate */ filter = (mbfl_convert_filter *)mbfl_malloc(sizeof(mbfl_convert_filter)); if (filter == NULL) { return NULL; } - if (mbfl_convert_filter_common_init(filter, vtbl->from, vtbl->to, vtbl, + if (mbfl_convert_filter_common_init(filter, from_encoding, to_encoding, vtbl, output_function, flush_function, data)) { mbfl_free(filter); return NULL; @@ -403,14 +402,14 @@ 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) + const mbfl_encoding *from, const mbfl_encoding *to) { const struct mbfl_convert_vtbl *vtbl; /* destruct old filter */ (*filter->filter_dtor)(filter); - vtbl = mbfl_convert_filter_get_vtbl(from, to); + vtbl = mbfl_convert_filter_get_vtbl(from->no_encoding, to->no_encoding); if (vtbl == NULL) { vtbl = &vtbl_pass; diff --git a/ext/mbstring/libmbfl/mbfl/mbfl_convert.h b/ext/mbstring/libmbfl/mbfl/mbfl_convert.h index 794c386e65..0fe9e4607e 100644 --- a/ext/mbstring/libmbfl/mbfl/mbfl_convert.h +++ b/ext/mbstring/libmbfl/mbfl/mbfl_convert.h @@ -69,8 +69,8 @@ struct mbfl_convert_vtbl { MBFLAPI extern const struct mbfl_convert_vtbl *mbfl_convert_filter_list[]; MBFLAPI extern mbfl_convert_filter *mbfl_convert_filter_new( - enum mbfl_no_encoding from, - enum mbfl_no_encoding to, + const mbfl_encoding *from, + const mbfl_encoding *to, int (*output_function)(int, void *), int (*flush_function)(void *), void *data ); @@ -82,7 +82,7 @@ MBFLAPI extern mbfl_convert_filter *mbfl_convert_filter_new2( MBFLAPI extern void mbfl_convert_filter_delete(mbfl_convert_filter *filter); MBFLAPI extern int mbfl_convert_filter_feed(int c, mbfl_convert_filter *filter); MBFLAPI extern int mbfl_convert_filter_flush(mbfl_convert_filter *filter); -MBFLAPI extern void mbfl_convert_filter_reset(mbfl_convert_filter *filter, enum mbfl_no_encoding from, enum mbfl_no_encoding to); +MBFLAPI extern void mbfl_convert_filter_reset(mbfl_convert_filter *filter, const mbfl_encoding *from, const mbfl_encoding *to); MBFLAPI extern void mbfl_convert_filter_copy(mbfl_convert_filter *src, mbfl_convert_filter *dist); MBFLAPI extern int mbfl_filt_conv_illegal_output(int c, mbfl_convert_filter *filter); MBFLAPI extern const struct mbfl_convert_vtbl * mbfl_convert_filter_get_vtbl(enum mbfl_no_encoding from, enum mbfl_no_encoding to); diff --git a/ext/mbstring/libmbfl/mbfl/mbfl_string.c b/ext/mbstring/libmbfl/mbfl/mbfl_string.c index 69f594350e..b26226500b 100644 --- a/ext/mbstring/libmbfl/mbfl/mbfl_string.c +++ b/ext/mbstring/libmbfl/mbfl/mbfl_string.c @@ -38,6 +38,7 @@ #include "mbfl_allocators.h" #include "mbfl_string.h" +#include "mbfilter_pass.h" /* * string object @@ -47,18 +48,18 @@ mbfl_string_init(mbfl_string *string) { if (string) { string->no_language = mbfl_no_language_uni; - string->no_encoding = mbfl_no_encoding_pass; + string->encoding = &mbfl_encoding_pass; string->val = (unsigned char*)NULL; string->len = 0; } } void -mbfl_string_init_set(mbfl_string *string, mbfl_language_id no_language, mbfl_encoding_id no_encoding) +mbfl_string_init_set(mbfl_string *string, mbfl_language_id no_language, const mbfl_encoding *encoding) { if (string) { string->no_language = no_language; - string->no_encoding = no_encoding; + string->encoding = encoding; string->val = (unsigned char*)NULL; string->len = 0; } diff --git a/ext/mbstring/libmbfl/mbfl/mbfl_string.h b/ext/mbstring/libmbfl/mbfl/mbfl_string.h index 88fabd5c4f..43f4a5fa75 100644 --- a/ext/mbstring/libmbfl/mbfl/mbfl_string.h +++ b/ext/mbstring/libmbfl/mbfl/mbfl_string.h @@ -41,13 +41,13 @@ */ typedef struct _mbfl_string { enum mbfl_no_language no_language; - enum mbfl_no_encoding no_encoding; + const mbfl_encoding *encoding; unsigned char *val; size_t len; } mbfl_string; MBFLAPI extern void mbfl_string_init(mbfl_string *string); -MBFLAPI extern void mbfl_string_init_set(mbfl_string *string, mbfl_language_id no_language, mbfl_encoding_id no_encoding); +MBFLAPI extern void mbfl_string_init_set(mbfl_string *string, mbfl_language_id no_language, const mbfl_encoding *encoding); MBFLAPI extern void mbfl_string_clear(mbfl_string *string); #ifndef NULL diff --git a/ext/mbstring/mb_gpc.c b/ext/mbstring/mb_gpc.c index dfe96ccf13..1cd44c90e0 100644 --- a/ext/mbstring/mb_gpc.c +++ b/ext/mbstring/mb_gpc.c @@ -203,9 +203,9 @@ const mbfl_encoding *_php_mb_encoding_handler_ex(const php_mb_encoding_handler_i mbfl_encoding_detector *identd = NULL; mbfl_buffer_converter *convd = NULL; - mbfl_string_init_set(&string, info->to_language, info->to_encoding->no_encoding); - mbfl_string_init_set(&resvar, info->to_language, info->to_encoding->no_encoding); - mbfl_string_init_set(&resval, info->to_language, info->to_encoding->no_encoding); + mbfl_string_init_set(&string, info->to_language, info->to_encoding); + mbfl_string_init_set(&resvar, info->to_language, info->to_encoding); + mbfl_string_init_set(&resval, info->to_language, info->to_encoding); if (!res || *res == '\0') { goto out; @@ -268,7 +268,7 @@ const mbfl_encoding *_php_mb_encoding_handler_ex(const php_mb_encoding_handler_i } else { /* auto detect */ from_encoding = NULL; - identd = mbfl_encoding_detector_new2(info->from_encodings, info->num_from_encodings, MBSTRG(strict_detection)); + identd = mbfl_encoding_detector_new(info->from_encodings, info->num_from_encodings, MBSTRG(strict_detection)); if (identd != NULL) { n = 0; while (n < num) { @@ -279,7 +279,7 @@ const mbfl_encoding *_php_mb_encoding_handler_ex(const php_mb_encoding_handler_i } n++; } - from_encoding = mbfl_encoding_detector_judge2(identd); + from_encoding = mbfl_encoding_detector_judge(identd); mbfl_encoding_detector_delete(identd); } if (!from_encoding) { @@ -292,7 +292,7 @@ const mbfl_encoding *_php_mb_encoding_handler_ex(const php_mb_encoding_handler_i convd = NULL; if (from_encoding != &mbfl_encoding_pass) { - convd = mbfl_buffer_converter_new2(from_encoding, info->to_encoding, 0); + convd = mbfl_buffer_converter_new(from_encoding, info->to_encoding, 0); 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)); @@ -305,7 +305,7 @@ const mbfl_encoding *_php_mb_encoding_handler_ex(const php_mb_encoding_handler_i } /* convert encoding */ - string.no_encoding = from_encoding->no_encoding; + string.encoding = from_encoding; n = 0; while (n < num) { diff --git a/ext/mbstring/mbstring.c b/ext/mbstring/mbstring.c index 9674a8371a..97e9bfcec3 100644 --- a/ext/mbstring/mbstring.c +++ b/ext/mbstring/mbstring.c @@ -61,8 +61,13 @@ #include "ext/standard/info.h" #include "libmbfl/mbfl/mbfl_allocators.h" +#include "libmbfl/mbfl/mbfilter_8bit.h" #include "libmbfl/mbfl/mbfilter_pass.h" +#include "libmbfl/filters/mbfilter_ascii.h" +#include "libmbfl/filters/mbfilter_base64.h" +#include "libmbfl/filters/mbfilter_qprint.h" #include "libmbfl/filters/mbfilter_ucs4.h" +#include "libmbfl/filters/mbfilter_utf8.h" #include "php_variables.h" #include "php_globals.h" @@ -728,14 +733,6 @@ static const mbfl_encoding *php_mb_get_encoding(const char *encoding_name) { } } -static enum mbfl_no_encoding php_mb_get_no_encoding(const char *encoding_name) { - const mbfl_encoding *encoding = php_mb_get_encoding(encoding_name); - if (!encoding) { - return mbfl_no_encoding_invalid; - } - return encoding->no_encoding; -} - /* {{{ static int php_mb_parse_encoding_list() * Return 0 if input contains any illegal encoding, otherwise 1. * Even if any illegal encoding is detected the result may contain a list @@ -947,7 +944,7 @@ static const zend_encoding *php_mb_zend_encoding_detector(const unsigned char *a string.no_language = MBSTRG(language); string.val = (unsigned char *)arg_string; string.len = arg_length; - return (const zend_encoding *) mbfl_identify_encoding2(&string, (const mbfl_encoding **)list, list_size, 0); + return (const zend_encoding *) mbfl_identify_encoding(&string, (const mbfl_encoding **)list, list_size, 0); } static size_t php_mb_zend_encoding_converter(unsigned char **to, size_t *to_length, const unsigned char *from, size_t from_length, const zend_encoding *encoding_to, const zend_encoding *encoding_from) @@ -961,13 +958,13 @@ static size_t php_mb_zend_encoding_converter(unsigned char **to, size_t *to_leng /* initialize string */ mbfl_string_init(&string); mbfl_string_init(&result); - string.no_encoding = ((const mbfl_encoding*)encoding_from)->no_encoding; + string.encoding = (const mbfl_encoding*)encoding_from; string.no_language = MBSTRG(language); string.val = (unsigned char*)from; string.len = from_length; /* initialize converter */ - convd = mbfl_buffer_converter_new2((const mbfl_encoding *)encoding_from, (const mbfl_encoding *)encoding_to, string.len); + convd = mbfl_buffer_converter_new((const mbfl_encoding *)encoding_from, (const mbfl_encoding *)encoding_to, string.len); if (convd == NULL) { return (size_t) -1; } @@ -2290,7 +2287,7 @@ PHP_FUNCTION(mb_output_handler) } } /* activate the converter */ - MBSTRG(outconv) = mbfl_buffer_converter_new2(MBSTRG(current_internal_encoding), encoding, 0); + MBSTRG(outconv) = mbfl_buffer_converter_new(MBSTRG(current_internal_encoding), encoding, 0); if (send_text_mimetype){ efree(mimetype); } @@ -2312,7 +2309,7 @@ PHP_FUNCTION(mb_output_handler) mbfl_string_init(&string); /* these are not needed. convd has encoding info. string.no_language = MBSTRG(language); - string.no_encoding = MBSTRG(current_internal_encoding)->no_encoding; + string.encoding = MBSTRG(current_internal_encoding); */ string.val = (unsigned char *)arg_string; string.len = arg_string_len; @@ -2351,8 +2348,8 @@ PHP_FUNCTION(mb_strlen) } string.no_language = MBSTRG(language); - string.no_encoding = php_mb_get_no_encoding(enc_name); - if (string.no_encoding == mbfl_no_encoding_invalid) { + string.encoding = php_mb_get_encoding(enc_name); + if (!string.encoding) { RETURN_FALSE; } @@ -2383,8 +2380,8 @@ PHP_FUNCTION(mb_strpos) } haystack.no_language = needle.no_language = MBSTRG(language); - haystack.no_encoding = needle.no_encoding = php_mb_get_no_encoding(enc_name); - if (haystack.no_encoding == mbfl_no_encoding_invalid) { + haystack.encoding = needle.encoding = php_mb_get_encoding(enc_name); + if (!haystack.encoding) { RETURN_FALSE; } @@ -2446,8 +2443,8 @@ PHP_FUNCTION(mb_strrpos) } haystack.no_language = needle.no_language = MBSTRG(language); - haystack.no_encoding = needle.no_encoding = php_mb_get_no_encoding(enc_name); - if (haystack.no_encoding == mbfl_no_encoding_invalid) { + haystack.encoding = needle.encoding = php_mb_get_encoding(enc_name); + if (!haystack.encoding) { RETURN_FALSE; } @@ -2581,8 +2578,8 @@ PHP_FUNCTION(mb_strstr) } haystack.no_language = needle.no_language = MBSTRG(language); - haystack.no_encoding = needle.no_encoding = php_mb_get_no_encoding(enc_name); - if (haystack.no_encoding == mbfl_no_encoding_invalid) { + haystack.encoding = needle.encoding = php_mb_get_encoding(enc_name); + if (!haystack.encoding) { RETURN_FALSE; } @@ -2638,8 +2635,8 @@ PHP_FUNCTION(mb_strrchr) } haystack.no_language = needle.no_language = MBSTRG(language); - haystack.no_encoding = needle.no_encoding = php_mb_get_no_encoding(enc_name); - if (haystack.no_encoding == mbfl_no_encoding_invalid) { + haystack.encoding = needle.encoding = php_mb_get_encoding(enc_name); + if (!haystack.encoding) { RETURN_FALSE; } @@ -2695,8 +2692,8 @@ PHP_FUNCTION(mb_stristr) } haystack.no_language = needle.no_language = MBSTRG(language); - haystack.no_encoding = needle.no_encoding = php_mb_get_no_encoding(from_encoding); - if (haystack.no_encoding == mbfl_no_encoding_invalid) { + haystack.encoding = needle.encoding = php_mb_get_encoding(from_encoding); + if (!haystack.encoding) { RETURN_FALSE; } @@ -2752,8 +2749,8 @@ PHP_FUNCTION(mb_strrichr) } haystack.no_language = needle.no_language = MBSTRG(language); - haystack.no_encoding = needle.no_encoding = php_mb_get_no_encoding(from_encoding); - if (haystack.no_encoding == mbfl_no_encoding_invalid) { + haystack.encoding = needle.encoding = php_mb_get_encoding(from_encoding); + if (!haystack.encoding) { RETURN_FALSE; } @@ -2804,8 +2801,8 @@ PHP_FUNCTION(mb_substr_count) } haystack.no_language = needle.no_language = MBSTRG(language); - haystack.no_encoding = needle.no_encoding = php_mb_get_no_encoding(enc_name); - if (haystack.no_encoding == mbfl_no_encoding_invalid) { + haystack.encoding = needle.encoding = php_mb_get_encoding(enc_name); + if (!haystack.encoding) { RETURN_FALSE; } @@ -2840,8 +2837,8 @@ PHP_FUNCTION(mb_substr) mbfl_string_init(&string); string.no_language = MBSTRG(language); - string.no_encoding = php_mb_get_no_encoding(encoding); - if (string.no_encoding == mbfl_no_encoding_invalid) { + string.encoding = php_mb_get_encoding(encoding); + if (!string.encoding) { RETURN_FALSE; } @@ -2918,8 +2915,8 @@ PHP_FUNCTION(mb_strcut) } string.no_language = MBSTRG(language); - string.no_encoding = php_mb_get_no_encoding(encoding); - if (string.no_encoding == mbfl_no_encoding_invalid) { + string.encoding = php_mb_get_encoding(encoding); + if (!string.encoding) { RETURN_FALSE; } @@ -2978,8 +2975,8 @@ PHP_FUNCTION(mb_strwidth) } string.no_language = MBSTRG(language); - string.no_encoding = php_mb_get_no_encoding(enc_name); - if (string.no_encoding == mbfl_no_encoding_invalid) { + string.encoding = php_mb_get_encoding(enc_name); + if (!string.encoding) { RETURN_FALSE; } @@ -3009,8 +3006,8 @@ PHP_FUNCTION(mb_strimwidth) mbfl_string_init(&marker); string.no_language = marker.no_language = MBSTRG(language); - string.no_encoding = marker.no_encoding = php_mb_get_no_encoding(encoding); - if (string.no_encoding == mbfl_no_encoding_invalid) { + string.encoding = marker.encoding = php_mb_get_encoding(encoding); + if (!string.encoding) { RETURN_FALSE; } @@ -3094,25 +3091,25 @@ MBSTRING_API char *php_mb_convert_encoding_ex(const char *input, size_t length, /* initialize string */ mbfl_string_init(&string); mbfl_string_init(&result); - string.no_encoding = from_encoding->no_encoding; + string.encoding = from_encoding; string.no_language = MBSTRG(language); string.val = (unsigned char *)input; string.len = length; /* initialize converter */ - convd = mbfl_buffer_converter_new2(from_encoding, to_encoding, string.len); + convd = mbfl_buffer_converter_new(from_encoding, to_encoding, string.len); if (convd == NULL) { php_error_docref(NULL, E_WARNING, "Unable to create character encoding converter"); return NULL; } mbfl_buffer_converter_illegal_mode(convd, MBSTRG(current_filter_illegal_mode)); - if (string.no_encoding == MBSTRG(current_internal_encoding)->no_encoding) { + if (string.encoding == MBSTRG(current_internal_encoding)) { mbfl_buffer_converter_illegal_substchar(convd, MBSTRG(current_filter_illegal_substchar)); - } else if (php_mb_is_no_encoding_unicode(string.no_encoding) + } else if (php_mb_is_no_encoding_unicode(string.encoding->no_encoding) && php_mb_is_no_encoding_unicode(MBSTRG(current_internal_encoding)->no_encoding)) { - if (php_mb_is_no_encoding_utf8(string.no_encoding)) { + if (php_mb_is_no_encoding_utf8(string.encoding->no_encoding)) { if (MBSTRG(current_filter_illegal_substchar) > 0xd7ff && 0xe000 > MBSTRG(current_filter_illegal_substchar) ) { @@ -3180,7 +3177,7 @@ MBSTRING_API char *php_mb_convert_encoding(const char *input, size_t length, con mbfl_string_init(&string); string.val = (unsigned char *)input; string.len = length; - from_encoding = mbfl_identify_encoding2(&string, list, size, MBSTRG(strict_detection)); + from_encoding = mbfl_identify_encoding(&string, list, size, MBSTRG(strict_detection)); if (!from_encoding) { php_error_docref(NULL, E_WARNING, "Unable to detect character encoding"); from_encoding = &mbfl_encoding_pass; @@ -3510,7 +3507,7 @@ PHP_FUNCTION(mb_detect_encoding) string.no_language = MBSTRG(language); string.val = (unsigned char *)str; string.len = str_len; - ret = mbfl_identify_encoding2(&string, elist, size, strict); + ret = mbfl_identify_encoding(&string, elist, size, strict); if (list != NULL) { efree((void *)list); @@ -3577,7 +3574,7 @@ PHP_FUNCTION(mb_encoding_aliases) Converts the string to MIME "encoded-word" in the format of =?charset?(B|Q)?encoded_string?= */ PHP_FUNCTION(mb_encode_mimeheader) { - enum mbfl_no_encoding charset, transenc; + const mbfl_encoding *charset, *transenc; mbfl_string string, result, *ret; char *charset_name = NULL; size_t charset_name_len; @@ -3589,34 +3586,34 @@ PHP_FUNCTION(mb_encode_mimeheader) mbfl_string_init(&string); string.no_language = MBSTRG(language); - string.no_encoding = MBSTRG(current_internal_encoding)->no_encoding; + string.encoding = MBSTRG(current_internal_encoding); if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|sssl", (char **)&string.val, &string.len, &charset_name, &charset_name_len, &trans_enc_name, &trans_enc_name_len, &linefeed, &linefeed_len, &indent) == FAILURE) { return; } - charset = mbfl_no_encoding_pass; - transenc = mbfl_no_encoding_base64; + charset = &mbfl_encoding_pass; + transenc = &mbfl_encoding_base64; if (charset_name != NULL) { - charset = mbfl_name2no_encoding(charset_name); - if (charset == mbfl_no_encoding_invalid) { + charset = mbfl_name2encoding(charset_name); + if (!charset) { php_error_docref(NULL, E_WARNING, "Unknown encoding \"%s\"", charset_name); RETURN_FALSE; } } else { const mbfl_language *lang = mbfl_no2language(MBSTRG(language)); if (lang != NULL) { - charset = lang->mail_charset; - transenc = lang->mail_header_encoding; + charset = mbfl_no2encoding(lang->mail_charset); + transenc = mbfl_no2encoding(lang->mail_header_encoding); } } if (trans_enc_name != NULL) { if (*trans_enc_name == 'B' || *trans_enc_name == 'b') { - transenc = mbfl_no_encoding_base64; + transenc = &mbfl_encoding_base64; } else if (*trans_enc_name == 'Q' || *trans_enc_name == 'q') { - transenc = mbfl_no_encoding_qprint; + transenc = &mbfl_encoding_qprint; } } @@ -3641,7 +3638,7 @@ PHP_FUNCTION(mb_decode_mimeheader) mbfl_string_init(&string); string.no_language = MBSTRG(language); - string.no_encoding = MBSTRG(current_internal_encoding)->no_encoding; + string.encoding = MBSTRG(current_internal_encoding); if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", (char **)&string.val, &string_len) == FAILURE) { return; @@ -3655,7 +3652,7 @@ PHP_FUNCTION(mb_decode_mimeheader) string.len = (uint32_t)string_len; mbfl_string_init(&result); - ret = mbfl_mime_header_decode(&string, &result, MBSTRG(current_internal_encoding)->no_encoding); + ret = mbfl_mime_header_decode(&string, &result, MBSTRG(current_internal_encoding)); if (ret != NULL) { // TODO: avoid reallocation ??? RETVAL_STRINGL((char *)ret->val, ret->len); /* the string is already strdup()'ed */ @@ -3750,8 +3747,8 @@ PHP_FUNCTION(mb_convert_kana) /* encoding */ string.no_language = MBSTRG(language); - string.no_encoding = php_mb_get_no_encoding(encname); - if (string.no_encoding == mbfl_no_encoding_invalid) { + string.encoding = php_mb_get_encoding(encname); + if (!string.encoding) { RETURN_FALSE; } @@ -3801,7 +3798,7 @@ PHP_FUNCTION(mb_convert_variables) mbfl_string_init(&string); mbfl_string_init(&result); from_encoding = MBSTRG(current_internal_encoding); - string.no_encoding = from_encoding->no_encoding; + string.encoding = from_encoding; string.no_language = MBSTRG(language); /* pre-conversion encoding */ @@ -3827,7 +3824,7 @@ PHP_FUNCTION(mb_convert_variables) stack_max = PHP_MBSTR_STACK_BLOCK_SIZE; stack = (zval *)safe_emalloc(stack_max, sizeof(zval), 0); stack_level = 0; - identd = mbfl_encoding_detector_new2(elist, elistsz, MBSTRG(strict_detection)); + identd = mbfl_encoding_detector_new(elist, elistsz, MBSTRG(strict_detection)); if (identd != NULL) { n = 0; while (n < argc || stack_level > 0) { @@ -3893,7 +3890,7 @@ PHP_FUNCTION(mb_convert_variables) } } detect_end: - from_encoding = mbfl_encoding_detector_judge2(identd); + from_encoding = mbfl_encoding_detector_judge(identd); mbfl_encoding_detector_delete(identd); } if (recursion_error) { @@ -3924,7 +3921,7 @@ detect_end: /* create converter */ convd = NULL; if (from_encoding != &mbfl_encoding_pass) { - convd = mbfl_buffer_converter_new2(from_encoding, to_encoding, 0); + convd = mbfl_buffer_converter_new(from_encoding, to_encoding, 0); if (convd == NULL) { php_error_docref(NULL, E_WARNING, "Unable to create converter"); RETURN_FALSE; @@ -4051,7 +4048,6 @@ php_mb_numericentity_exec(INTERNAL_FUNCTION_PARAMETERS, int type) int i, *convmap, *mapelm, mapsize=0; zend_bool is_hex = 0; mbfl_string string, result, *ret; - enum mbfl_no_encoding no_encoding; if (zend_parse_parameters(ZEND_NUM_ARGS(), "sz|sb", &str, &str_len, &zconvmap, &encoding, &encoding_len, &is_hex) == FAILURE) { return; @@ -4059,18 +4055,16 @@ php_mb_numericentity_exec(INTERNAL_FUNCTION_PARAMETERS, int type) mbfl_string_init(&string); string.no_language = MBSTRG(language); - string.no_encoding = MBSTRG(current_internal_encoding)->no_encoding; + string.encoding = MBSTRG(current_internal_encoding); string.val = (unsigned char *)str; string.len = str_len; /* encoding */ if (encoding && encoding_len > 0) { - no_encoding = mbfl_name2no_encoding(encoding); - if (no_encoding == mbfl_no_encoding_invalid) { + string.encoding = mbfl_name2encoding(encoding); + if (!string.encoding) { php_error_docref(NULL, E_WARNING, "Unknown encoding \"%s\"", encoding); RETURN_FALSE; - } else { - string.no_encoding = no_encoding; } } @@ -4337,10 +4331,10 @@ PHP_FUNCTION(mb_send_mail) char *message_buf = NULL, *subject_buf = NULL, *p; mbfl_string orig_str, conv_str; mbfl_string *pstr; /* pointer to mbfl string for return value */ - enum mbfl_no_encoding - tran_cs, /* transfar text charset */ - head_enc, /* header transfar encoding */ - body_enc; /* body transfar encoding */ + enum mbfl_no_encoding; + const mbfl_encoding *tran_cs, /* transfar text charset */ + *head_enc, /* header transfar encoding */ + *body_enc; /* body transfar encoding */ mbfl_memory_device device; /* automatic allocateable buffer for additional header */ const mbfl_language *lang; int err = 0; @@ -4355,14 +4349,14 @@ PHP_FUNCTION(mb_send_mail) mbfl_string_init(&conv_str); /* character-set, transfer-encoding */ - tran_cs = mbfl_no_encoding_utf8; - head_enc = mbfl_no_encoding_base64; - body_enc = mbfl_no_encoding_base64; + tran_cs = &mbfl_encoding_utf8; + head_enc = &mbfl_encoding_base64; + body_enc = &mbfl_encoding_base64; lang = mbfl_no2language(MBSTRG(language)); if (lang != NULL) { - tran_cs = lang->mail_charset; - head_enc = lang->mail_header_encoding; - body_enc = lang->mail_body_encoding; + tran_cs = mbfl_no2encoding(lang->mail_charset); + head_enc = mbfl_no2encoding(lang->mail_header_encoding); + body_enc = mbfl_no2encoding(lang->mail_body_encoding); } if (zend_parse_parameters(ZEND_NUM_ARGS(), "sss|zS", &to, &to_len, &subject, &subject_len, &message, &message_len, &headers, &extra_cmd) == FAILURE) { @@ -4416,16 +4410,16 @@ PHP_FUNCTION(mb_send_mail) if (*p != '\0') { if ((param_name = php_strtok_r(p, "= ", &tmp)) != NULL) { if (strcasecmp(param_name, "charset") == 0) { - enum mbfl_no_encoding _tran_cs = tran_cs; + const mbfl_encoding *_tran_cs = tran_cs; charset = php_strtok_r(NULL, "= \"", &tmp); if (charset != NULL) { - _tran_cs = mbfl_name2no_encoding(charset); + _tran_cs = mbfl_name2encoding(charset); } - if (_tran_cs == mbfl_no_encoding_invalid) { + if (!_tran_cs) { php_error_docref(NULL, E_WARNING, "Unsupported charset \"%s\" - will be regarded as ascii", charset); - _tran_cs = mbfl_no_encoding_ascii; + _tran_cs = &mbfl_encoding_ascii; } tran_cs = _tran_cs; } @@ -4436,11 +4430,11 @@ PHP_FUNCTION(mb_send_mail) } if ((s = zend_hash_str_find(&ht_headers, "CONTENT-TRANSFER-ENCODING", sizeof("CONTENT-TRANSFER-ENCODING") - 1))) { - enum mbfl_no_encoding _body_enc; + const mbfl_encoding *_body_enc; ZEND_ASSERT(Z_TYPE_P(s) == IS_STRING); - _body_enc = mbfl_name2no_encoding(Z_STRVAL_P(s)); - switch (_body_enc) { + _body_enc = mbfl_name2encoding(Z_STRVAL_P(s)); + switch (_body_enc ? _body_enc->no_encoding : mbfl_no_encoding_invalid) { case mbfl_no_encoding_base64: case mbfl_no_encoding_7bit: case mbfl_no_encoding_8bit: @@ -4449,7 +4443,7 @@ PHP_FUNCTION(mb_send_mail) default: php_error_docref(NULL, E_WARNING, "Unsupported transfer encoding \"%s\" - will be regarded as 8bit", Z_STRVAL_P(s)); - body_enc = mbfl_no_encoding_8bit; + body_enc = &mbfl_encoding_8bit; break; } suppressed_hdrs.cnt_trans_enc = 1; @@ -4489,10 +4483,10 @@ PHP_FUNCTION(mb_send_mail) orig_str.no_language = MBSTRG(language); orig_str.val = (unsigned char *)subject; orig_str.len = subject_len; - orig_str.no_encoding = MBSTRG(current_internal_encoding)->no_encoding; - if (orig_str.no_encoding == mbfl_no_encoding_invalid || orig_str.no_encoding == mbfl_no_encoding_pass) { - const mbfl_encoding *encoding = mbfl_identify_encoding2(&orig_str, MBSTRG(current_detect_order_list), MBSTRG(current_detect_order_list_size), MBSTRG(strict_detection)); - orig_str.no_encoding = encoding ? encoding->no_encoding: mbfl_no_encoding_invalid; + orig_str.encoding = MBSTRG(current_internal_encoding); + if (orig_str.encoding->no_encoding == mbfl_no_encoding_invalid + || orig_str.encoding->no_encoding == mbfl_no_encoding_pass) { + orig_str.encoding = mbfl_identify_encoding(&orig_str, MBSTRG(current_detect_order_list), MBSTRG(current_detect_order_list_size), MBSTRG(strict_detection)); } pstr = mbfl_mime_header_encode(&orig_str, &conv_str, tran_cs, head_enc, "\n", sizeof("Subject: [PHP-jp nnnnnnnn]")); if (pstr != NULL) { @@ -4508,11 +4502,11 @@ PHP_FUNCTION(mb_send_mail) orig_str.no_language = MBSTRG(language); orig_str.val = (unsigned char *)message; orig_str.len = (unsigned int)message_len; - orig_str.no_encoding = MBSTRG(current_internal_encoding)->no_encoding; + orig_str.encoding = MBSTRG(current_internal_encoding); - if (orig_str.no_encoding == mbfl_no_encoding_invalid || orig_str.no_encoding == mbfl_no_encoding_pass) { - const mbfl_encoding *encoding = mbfl_identify_encoding2(&orig_str, MBSTRG(current_detect_order_list), MBSTRG(current_detect_order_list_size), MBSTRG(strict_detection)); - orig_str.no_encoding = encoding ? encoding->no_encoding: mbfl_no_encoding_invalid; + if (orig_str.encoding->no_encoding == mbfl_no_encoding_invalid + || orig_str.encoding->no_encoding == mbfl_no_encoding_pass) { + orig_str.encoding = mbfl_identify_encoding(&orig_str, MBSTRG(current_detect_order_list), MBSTRG(current_detect_order_list_size), MBSTRG(strict_detection)); } pstr = NULL; @@ -4520,7 +4514,7 @@ PHP_FUNCTION(mb_send_mail) mbfl_string tmpstr; if (mbfl_convert_encoding(&orig_str, &tmpstr, tran_cs) != NULL) { - tmpstr.no_encoding=mbfl_no_encoding_8bit; + tmpstr.encoding = &mbfl_encoding_8bit; pstr = mbfl_convert_encoding(&tmpstr, &conv_str, body_enc); efree(tmpstr.val); } @@ -4557,7 +4551,7 @@ PHP_FUNCTION(mb_send_mail) if (!suppressed_hdrs.cnt_type) { mbfl_memory_device_strncat(&device, PHP_MBSTR_MAIL_MIME_HEADER2, sizeof(PHP_MBSTR_MAIL_MIME_HEADER2) - 1); - p = (char *)mbfl_no2preferred_mime_name(tran_cs); + p = (char *)mbfl_no2preferred_mime_name(tran_cs->no_encoding); if (p != NULL) { mbfl_memory_device_strncat(&device, PHP_MBSTR_MAIL_MIME_HEADER3, sizeof(PHP_MBSTR_MAIL_MIME_HEADER3) - 1); mbfl_memory_device_strcat(&device, p); @@ -4566,7 +4560,7 @@ PHP_FUNCTION(mb_send_mail) } if (!suppressed_hdrs.cnt_trans_enc) { mbfl_memory_device_strncat(&device, PHP_MBSTR_MAIL_MIME_HEADER4, sizeof(PHP_MBSTR_MAIL_MIME_HEADER4) - 1); - p = (char *)mbfl_no2preferred_mime_name(body_enc); + p = (char *)mbfl_no2preferred_mime_name(body_enc->no_encoding); if (p == NULL) { p = "7bit"; } @@ -4801,7 +4795,7 @@ static inline mbfl_buffer_converter *php_mb_init_convd(const mbfl_encoding *enco { mbfl_buffer_converter *convd; - convd = mbfl_buffer_converter_new2(encoding, encoding, 0); + convd = mbfl_buffer_converter_new(encoding, encoding, 0); if (convd == NULL) { return NULL; } @@ -4816,7 +4810,7 @@ static inline int php_mb_check_encoding_impl(mbfl_buffer_converter *convd, const long illegalchars = 0; /* initialize string */ - mbfl_string_init_set(&string, mbfl_no_language_neutral, encoding->no_encoding); + mbfl_string_init_set(&string, mbfl_no_language_neutral, encoding); mbfl_string_init(&result); string.val = (unsigned char *) input; @@ -5415,9 +5409,9 @@ MBSTRING_API size_t php_mb_stripos(int mode, const char *old_haystack, size_t ol mbfl_string_init(&haystack); mbfl_string_init(&needle); haystack.no_language = MBSTRG(language); - haystack.no_encoding = enc->no_encoding; + haystack.encoding = enc; needle.no_language = MBSTRG(language); - needle.no_encoding = enc->no_encoding; + needle.encoding = enc; do { size_t len = 0; diff --git a/ext/mbstring/php_unicode.c b/ext/mbstring/php_unicode.c index f6f0e3f0e0..208c10319e 100644 --- a/ext/mbstring/php_unicode.c +++ b/ext/mbstring/php_unicode.c @@ -43,7 +43,7 @@ #include "mbstring.h" #include "php_unicode.h" #include "unicode_data.h" -#include "libmbfl/filters/mbfilter_ucs4.h" +#include "libmbfl/mbfl/mbfilter_wchar.h" ZEND_EXTERN_MODULE_GLOBALS(mbstring) @@ -310,8 +310,8 @@ MBSTRING_API char *php_unicode_convert_case( mbfl_memory_device_init(&device, srclen + 1, 0); /* encoding -> wchar filter */ - to_wchar = mbfl_convert_filter_new(src_encoding->no_encoding, - mbfl_no_encoding_wchar, convert_case_filter, NULL, &data); + to_wchar = mbfl_convert_filter_new(src_encoding, + &mbfl_encoding_wchar, convert_case_filter, NULL, &data); if (to_wchar == NULL) { mbfl_memory_device_clear(&device); return NULL; @@ -319,7 +319,7 @@ MBSTRING_API char *php_unicode_convert_case( /* wchar -> encoding filter */ from_wchar = mbfl_convert_filter_new( - mbfl_no_encoding_wchar, src_encoding->no_encoding, + &mbfl_encoding_wchar, src_encoding, mbfl_memory_device_output, NULL, &device); if (from_wchar == NULL) { mbfl_convert_filter_delete(to_wchar); @@ -355,7 +355,7 @@ MBSTRING_API char *php_unicode_convert_case( } *ret_len = result.len; - return result.val; + return (char *) result.val; } -- 2.40.0