Refactor mbfl_convert.c

5 files changed, 65 insertions, 136 deletions

diff --git a/ext/mbstring/libmbfl/filters/mbfilter_cp5022x.c b/ext/mbstring/libmbfl/filters/mbfilter_cp5022x.c
index 4b63602916..a201154169 100644
--- a/ext/mbstring/libmbfl/filters/mbfilter_cp5022x.c
+++ b/ext/mbstring/libmbfl/filters/mbfilter_cp5022x.c
@@ -592,7 +592,7 @@ mbfl_filt_conv_wchar_cp50220_ctor(mbfl_convert_filter *filt)
 	filt->filter_function = vtbl_tl_jisx0201_jisx0208.filter_function;
 	filt->filter_flush = vtbl_tl_jisx0201_jisx0208.filter_flush;
 	filt->output_function = (int(*)(int, void *))ctx->last.filter_function;
-	filt->flush_function = (int(*)(void *))ctx->last.filter_flush;
+	filt->flush_function = ctx->last.filter_flush;
 	filt->data = &ctx->last;
 	filt->opaque = ctx;
 	vtbl_tl_jisx0201_jisx0208.filter_ctor(filt);
diff --git a/ext/mbstring/libmbfl/mbfl/mbfilter.c b/ext/mbstring/libmbfl/mbfl/mbfilter.c
index a1191716a1..65817d384a 100644
--- a/ext/mbstring/libmbfl/mbfl/mbfilter.c
+++ b/ext/mbstring/libmbfl/mbfl/mbfilter.c
@@ -131,7 +131,7 @@ mbfl_buffer_converter_new(
 			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->filter_flush,
 					convd->filter2);
 			if (convd->filter1 == NULL) {
 				mbfl_convert_filter_delete(convd->filter2);
@@ -1205,7 +1205,7 @@ mbfl_strcut(
 
 		/* switch the drain direction */
 		encoder->output_function = (int(*)(int,void *))decoder->filter_function;
-		encoder->flush_function = (int(*)(void *))decoder->filter_flush;
+		encoder->flush_function = decoder->filter_flush;
 		encoder->data = decoder;
 
 		q = string->val + string->len;
@@ -1591,7 +1591,7 @@ mbfl_ja_jp_hantozen(
 	tl_filter = mbfl_convert_filter_new2(
 		&vtbl_tl_jisx0201_jisx0208,
 		(int(*)(int, void*))next_filter->filter_function,
-		(int(*)(void*))next_filter->filter_flush,
+		next_filter->filter_flush,
 		next_filter);
 	if (tl_filter == NULL) {
 		efree(param);
@@ -1605,7 +1605,7 @@ mbfl_ja_jp_hantozen(
 		string->encoding,
 		&mbfl_encoding_wchar,
 		(int(*)(int, void*))next_filter->filter_function,
-		(int(*)(void*))next_filter->filter_flush,
+		next_filter->filter_flush,
 		next_filter);
 	if (encoder == NULL) {
 		goto out;
@@ -2623,7 +2623,7 @@ mbfl_html_numeric_entity(
 		    string->encoding,
 		    &mbfl_encoding_wchar,
 		    collector_decode_htmlnumericentity,
-			(int (*)(void*))mbfl_filt_decode_htmlnumericentity_flush, &pc);
+		    mbfl_filt_decode_htmlnumericentity_flush, &pc);
 	}
 	if (pc.decoder == NULL || encoder == NULL) {
 		mbfl_convert_filter_delete(encoder);
diff --git a/ext/mbstring/libmbfl/mbfl/mbfl_convert.c b/ext/mbstring/libmbfl/mbfl/mbfl_convert.c
index e301254e03..0f41e35b25 100644
--- a/ext/mbstring/libmbfl/mbfl/mbfl_convert.c
+++ b/ext/mbstring/libmbfl/mbfl/mbfl_convert.c
@@ -115,15 +115,8 @@ static const struct mbfl_convert_vtbl *mbfl_special_filter_list[] = {
 	NULL
 };
 
-static int
-mbfl_convert_filter_common_init(
-	mbfl_convert_filter *filter,
-	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)
+static void mbfl_convert_filter_common_init(mbfl_convert_filter *filter, const mbfl_encoding *from, const mbfl_encoding *to,
+	const struct mbfl_convert_vtbl *vtbl, filter_output_func output_function, filter_flush_func flush_function, void* data)
 {
 	/* encoding structure */
 	filter->from = from;
@@ -138,7 +131,7 @@ mbfl_convert_filter_common_init(
 	filter->flush_function = flush_function;
 	filter->data = data;
 	filter->illegal_mode = MBFL_OUTPUTFILTER_ILLEGAL_MODE_CHAR;
-	filter->illegal_substchar = 0x3f;		/* '?' */
+	filter->illegal_substchar = '?';
 	filter->num_illegalchar = 0;
 	filter->filter_ctor = vtbl->filter_ctor;
 	filter->filter_dtor = vtbl->filter_dtor;
@@ -147,102 +140,63 @@ mbfl_convert_filter_common_init(
 	filter->filter_copy = vtbl->filter_copy;
 
 	(*filter->filter_ctor)(filter);
-
-	return 0;
 }
 
 
-mbfl_convert_filter *
-mbfl_convert_filter_new(
-    const mbfl_encoding *from,
-    const mbfl_encoding *to,
-    int (*output_function)(int, void* ),
-    int (*flush_function)(void*),
-    void* data)
+mbfl_convert_filter* mbfl_convert_filter_new(const mbfl_encoding *from, const mbfl_encoding *to, filter_output_func output_function,
+	filter_flush_func flush_function, void* data)
 {
-	mbfl_convert_filter *filter;
-	const struct mbfl_convert_vtbl *vtbl;
-
-	vtbl = mbfl_convert_filter_get_vtbl(from, to);
+	const struct mbfl_convert_vtbl *vtbl = mbfl_convert_filter_get_vtbl(from, to);
 	if (vtbl == NULL) {
 		return NULL;
 	}
 
-	filter = emalloc(sizeof(mbfl_convert_filter));
-
-	if (mbfl_convert_filter_common_init(filter, from, to, vtbl,
-			output_function, flush_function, data)) {
-		efree(filter);
-		return NULL;
-	}
-
+	mbfl_convert_filter *filter = emalloc(sizeof(mbfl_convert_filter));
+	mbfl_convert_filter_common_init(filter, from, to, vtbl, output_function, flush_function, data);
 	return filter;
 }
 
-mbfl_convert_filter *
-mbfl_convert_filter_new2(
-	const struct mbfl_convert_vtbl *vtbl,
-    int (*output_function)(int, void* ),
-    int (*flush_function)(void*),
-    void* data)
+mbfl_convert_filter* mbfl_convert_filter_new2(const struct mbfl_convert_vtbl *vtbl, filter_output_func output_function,
+	filter_flush_func flush_function, 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);
-
-	filter = emalloc(sizeof(mbfl_convert_filter));
-
-	if (mbfl_convert_filter_common_init(filter, from_encoding, to_encoding, vtbl,
-			output_function, flush_function, data)) {
-		efree(filter);
-		return NULL;
-	}
+	const mbfl_encoding *from_encoding = mbfl_no2encoding(vtbl->from);
+	const mbfl_encoding *to_encoding = mbfl_no2encoding(vtbl->to);
 
+	mbfl_convert_filter *filter = emalloc(sizeof(mbfl_convert_filter));
+	mbfl_convert_filter_common_init(filter, from_encoding, to_encoding, vtbl, output_function, flush_function, data);
 	return filter;
 }
 
-void
-mbfl_convert_filter_delete(mbfl_convert_filter *filter)
+void mbfl_convert_filter_delete(mbfl_convert_filter *filter)
 {
-	if (filter) {
-		(*filter->filter_dtor)(filter);
-		efree((void*)filter);
-	}
+	(*filter->filter_dtor)(filter);
+	efree(filter);
 }
 
-int
-mbfl_convert_filter_feed_string(mbfl_convert_filter *filter, const unsigned char *p, size_t len) {
-	while (len > 0) {
+/* Feed string into `filter` byte by byte; return pointer to first byte not processed */
+unsigned char* mbfl_convert_filter_feed_string(mbfl_convert_filter *filter, unsigned char *p, size_t len)
+{
+	while (len--) {
 		if ((*filter->filter_function)(*p++, filter) < 0) {
-			return -1;
+			break;
 		}
-		len--;
 	}
-	return 0;
+	return p;
 }
 
-int
-mbfl_convert_filter_flush(mbfl_convert_filter *filter)
+int mbfl_convert_filter_flush(mbfl_convert_filter *filter)
 {
 	(*filter->filter_flush)(filter);
-	return (filter->flush_function ? (*filter->flush_function)(filter->data) : 0);
+	return filter->flush_function ? (*filter->flush_function)(filter->data) : 0;
 }
 
-void mbfl_convert_filter_reset(mbfl_convert_filter *filter,
-	    const mbfl_encoding *from, const mbfl_encoding *to)
+void mbfl_convert_filter_reset(mbfl_convert_filter *filter, const mbfl_encoding *from, const mbfl_encoding *to)
 {
-	const struct mbfl_convert_vtbl *vtbl;
-
-	/* destruct old filter */
-	(*filter->filter_dtor)(filter);
+	if (filter->filter_dtor) {
+		(*filter->filter_dtor)(filter);
+	}
 
-	vtbl = mbfl_convert_filter_get_vtbl(from, to);
+	const struct mbfl_convert_vtbl *vtbl = mbfl_convert_filter_get_vtbl(from, to);
 
 	if (vtbl == NULL) {
 		vtbl = &vtbl_pass;
@@ -252,10 +206,7 @@ void mbfl_convert_filter_reset(mbfl_convert_filter *filter,
 			filter->output_function, filter->flush_function, filter->data);
 }
 
-void
-mbfl_convert_filter_copy(
-    mbfl_convert_filter *src,
-    mbfl_convert_filter *dest)
+void mbfl_convert_filter_copy(mbfl_convert_filter *src, mbfl_convert_filter *dest)
 {
 	if (src->filter_copy != NULL) {
 		src->filter_copy(src, dest);
@@ -265,28 +216,15 @@ mbfl_convert_filter_copy(
 	*dest = *src;
 }
 
-int mbfl_convert_filter_devcat(mbfl_convert_filter *filter, mbfl_memory_device *src)
+void mbfl_convert_filter_devcat(mbfl_convert_filter *filter, mbfl_memory_device *src)
 {
-	size_t n;
-	unsigned char *p;
-
-	p = src->buffer;
-	n = src->pos;
-	while (n > 0) {
-		if ((*filter->filter_function)(*p++, filter) < 0) {
-			return -1;
-		}
-		n--;
-	}
-
-	return 0;
+	mbfl_convert_filter_feed_string(filter, src->buffer, src->pos);
 }
 
 int mbfl_convert_filter_strcat(mbfl_convert_filter *filter, const unsigned char *p)
 {
 	int c;
-
-	while ((c = *p++) != '\0') {
+	while ((c = *p++)) {
 		if ((*filter->filter_function)(c, filter) < 0) {
 			return -1;
 		}
@@ -296,22 +234,20 @@ int mbfl_convert_filter_strcat(mbfl_convert_filter *filter, const unsigned char
 }
 
 /* illegal character output function for conv-filter */
-int
-mbfl_filt_conv_illegal_output(int c, mbfl_convert_filter *filter)
+int mbfl_filt_conv_illegal_output(int c, mbfl_convert_filter *filter)
 {
-	int mode_backup, substchar_backup, ret, n, m, r;
-
-	ret = 0;
+	int n, m, r;
 
-	mode_backup = filter->illegal_mode;
-	substchar_backup = filter->illegal_substchar;
+	int ret = 0;
+	int mode_backup = filter->illegal_mode;
+	int substchar_backup = filter->illegal_substchar;
 
 	/* The used substitution character may not be supported by the target character encoding.
 	 * If that happens, first try to use "?" instead and if that also fails, silently drop the
 	 * character. */
 	if (filter->illegal_mode == MBFL_OUTPUTFILTER_ILLEGAL_MODE_CHAR
-			&& filter->illegal_substchar != 0x3f) {
-		filter->illegal_substchar = 0x3f;
+			&& filter->illegal_substchar != '?') {
+		filter->illegal_substchar = '?';
 	} else {
 		filter->illegal_mode = MBFL_OUTPUTFILTER_ILLEGAL_MODE_NONE;
 	}
@@ -370,7 +306,7 @@ mbfl_filt_conv_illegal_output(int c, mbfl_convert_filter *filter)
 					}
 					r -= 4;
 				}
-				if (m == 0 && ret >= 0) {
+				if (m == 0) {
 					ret = (*filter->filter_function)(mbfl_hexchar_table[0], filter);
 				}
 			}
@@ -396,11 +332,9 @@ mbfl_filt_conv_illegal_output(int c, mbfl_convert_filter *filter)
 					}
 					r -= 4;
 				}
-				if (ret < 0) {
-					break;
-				}
 				if (m == 0) {
-					ret = (*filter->filter_function)(mbfl_hexchar_table[0], filter);
+					/* illegal character was zero; no hex digits were output by above loop */
+					ret = (*filter->filter_function)('0', filter);
 				}
 				ret = mbfl_convert_filter_strcat(filter, (const unsigned char *)";");
 			} else {
@@ -420,8 +354,7 @@ mbfl_filt_conv_illegal_output(int c, mbfl_convert_filter *filter)
 	return ret;
 }
 
-const struct mbfl_convert_vtbl * mbfl_convert_filter_get_vtbl(
-		const mbfl_encoding *from, const mbfl_encoding *to)
+const struct mbfl_convert_vtbl* mbfl_convert_filter_get_vtbl(const mbfl_encoding *from, const mbfl_encoding *to)
 {
 	if (to->no_encoding == mbfl_no_encoding_base64 ||
 	    to->no_encoding == mbfl_no_encoding_qprint ||
@@ -444,7 +377,7 @@ const struct mbfl_convert_vtbl * mbfl_convert_filter_get_vtbl(
 	} else {
 		int i = 0;
 		const struct mbfl_convert_vtbl *vtbl;
-		while ((vtbl = mbfl_special_filter_list[i++]) != NULL){
+		while ((vtbl = mbfl_special_filter_list[i++])) {
 			if (vtbl->from == from->no_encoding && vtbl->to == to->no_encoding) {
 				return vtbl;
 			}
diff --git a/ext/mbstring/libmbfl/mbfl/mbfl_convert.h b/ext/mbstring/libmbfl/mbfl/mbfl_convert.h
index 852e669dac..f38de7eefe 100644
--- a/ext/mbstring/libmbfl/mbfl/mbfl_convert.h
+++ b/ext/mbstring/libmbfl/mbfl/mbfl_convert.h
@@ -37,14 +37,17 @@
 
 typedef struct _mbfl_convert_filter mbfl_convert_filter;
 
+typedef int (*filter_output_func)(int, void*);
+typedef int (*filter_flush_func)(mbfl_convert_filter*);
+
 struct _mbfl_convert_filter {
 	void (*filter_ctor)(mbfl_convert_filter *filter);
 	void (*filter_dtor)(mbfl_convert_filter *filter);
 	void (*filter_copy)(mbfl_convert_filter *src, mbfl_convert_filter *dest);
 	int (*filter_function)(int c, mbfl_convert_filter *filter);
-	int (*filter_flush)(mbfl_convert_filter *filter);
-	int (*output_function)(int c, void *data);
-	int (*flush_function)(void *data);
+	filter_flush_func  filter_flush;
+	filter_output_func output_function;
+	filter_flush_func  flush_function;
 	void *data;
 	int status;
 	int cache;
@@ -56,19 +59,12 @@ struct _mbfl_convert_filter {
 	void *opaque;
 };
 
-MBFLAPI extern mbfl_convert_filter *mbfl_convert_filter_new(
-    const mbfl_encoding *from,
-    const mbfl_encoding *to,
-    int (*output_function)(int, void *),
-    int (*flush_function)(void *),
-    void *data );
-MBFLAPI extern mbfl_convert_filter *mbfl_convert_filter_new2(
-	const struct mbfl_convert_vtbl *vtbl,
-    int (*output_function)(int, void *),
-    int (*flush_function)(void *),
-    void *data );
+MBFLAPI extern mbfl_convert_filter *mbfl_convert_filter_new(const mbfl_encoding *from, const mbfl_encoding *to, filter_output_func output_function,
+	filter_flush_func flush_function, void *data);
+MBFLAPI extern mbfl_convert_filter *mbfl_convert_filter_new2(const struct mbfl_convert_vtbl *vtbl, filter_output_func output_function,
+	filter_flush_func flush_function, void *data);
 MBFLAPI extern void mbfl_convert_filter_delete(mbfl_convert_filter *filter);
-MBFLAPI extern int mbfl_convert_filter_feed_string(mbfl_convert_filter *filter, const unsigned char *p, size_t len);
+MBFLAPI extern unsigned char* mbfl_convert_filter_feed_string(mbfl_convert_filter *filter, unsigned char *p, size_t len);
 MBFLAPI extern int mbfl_convert_filter_flush(mbfl_convert_filter *filter);
 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);
@@ -79,7 +75,7 @@ MBFLAPI extern void mbfl_filt_conv_common_ctor(mbfl_convert_filter *filter);
 MBFLAPI extern int mbfl_filt_conv_common_flush(mbfl_convert_filter *filter);
 MBFLAPI extern void mbfl_filt_conv_common_dtor(mbfl_convert_filter *filter);
 
-MBFLAPI extern int mbfl_convert_filter_devcat(mbfl_convert_filter *filter, mbfl_memory_device *src);
+MBFLAPI extern void mbfl_convert_filter_devcat(mbfl_convert_filter *filter, mbfl_memory_device *src);
 MBFLAPI extern int mbfl_convert_filter_strcat(mbfl_convert_filter *filter, const unsigned char *p);
 
 #endif /* MBFL_CONVERT_H */
diff --git a/ext/mbstring/mbstring.c b/ext/mbstring/mbstring.c
index 13031d90d3..24c5550975 100644
--- a/ext/mbstring/mbstring.c
+++ b/ext/mbstring/mbstring.c
@@ -4104,7 +4104,7 @@ static inline zend_long php_mb_ord(const char *str, size_t str_len, zend_string
 		/* If this assertion fails this means some memory allocation failure which is a bug */
 		ZEND_ASSERT(filter != NULL);
 
-		mbfl_convert_filter_feed_string(filter, (const unsigned char *) str, str_len);
+		mbfl_convert_filter_feed_string(filter, (unsigned char*)str, str_len);
 		mbfl_convert_filter_flush(filter);
 
 		if (dev.pos < 1 || filter->num_illegalchar || dev.buffer[0] >= MBFL_WCSGROUP_UCS4MAX) {