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.

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;
 }