#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"
*/
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)
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);
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 {
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);
}
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);
}
* 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;
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;
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
*/
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);
}
* 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;
{
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) {
} 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;
{
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) {
}
{
- 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;
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;
/* 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;
}
/* 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);
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) {
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);
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
/* 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);
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);
}
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);
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) {
{
size_t n;
unsigned char *p;
- const mbfl_encoding *encoding;
mbfl_memory_device device;
mbfl_convert_filter *decoder = NULL;
mbfl_convert_filter *encoder = NULL;
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;
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);
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;
}
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';
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 ||
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 {
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)
{
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;
}
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
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);
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 */
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 */
/* 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);
}
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;
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);
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;
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) {
}
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);
}
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);
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) {
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);
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);
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);
mbfl_mime_header_decode(
mbfl_string *string,
mbfl_string *result,
- enum mbfl_no_encoding outcode);
+ const mbfl_encoding *outcode);
/*
* convert HTML numeric entity
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;
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)
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;
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;
}
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;
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 );
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);
#include "mbfl_allocators.h"
#include "mbfl_string.h"
+#include "mbfilter_pass.h"
/*
* string object
{
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;
}
*/
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
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;
} 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) {
}
n++;
}
- from_encoding = mbfl_encoding_detector_judge2(identd);
+ from_encoding = mbfl_encoding_detector_judge(identd);
mbfl_encoding_detector_delete(identd);
}
if (!from_encoding) {
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));
}
/* convert encoding */
- string.no_encoding = from_encoding->no_encoding;
+ string.encoding = from_encoding;
n = 0;
while (n < num) {
#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"
}
}
-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
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)
/* 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;
}
}
}
/* 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);
}
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;
}
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;
}
}
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;
}
}
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;
}
}
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;
}
}
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;
}
}
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;
}
}
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;
}
}
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;
}
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;
}
}
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;
}
}
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;
}
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;
}
/* 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)
) {
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;
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);
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;
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;
}
}
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;
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 */
/* 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;
}
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 */
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) {
}
}
detect_end:
- from_encoding = mbfl_encoding_detector_judge2(identd);
+ from_encoding = mbfl_encoding_detector_judge(identd);
mbfl_encoding_detector_delete(identd);
}
if (recursion_error) {
/* 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;
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;
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;
}
}
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;
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) {
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;
}
}
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:
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;
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) {
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;
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);
}
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);
}
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";
}
{
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;
}
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;
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;
#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)
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;
/* 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);
}
*ret_len = result.len;
- return result.val;
+ return (char *) result.val;
}
projects / php / commitdiff