[WIP] Move meat of mb_str_split to mbfl_str_split (in mbfilter.c)

This follows the pattern of most other PHP-level functions in mbstring; mbstring.c
handles marshalling of PHP-level arguments and return values, as well as dealing
with .INI parameters, built-in globals, and so on, and calls into functions in
mbfilter.c for the core logic.

Note: It also fixes a bug! mb_str_split did one thing wrong in that after feeding
the entire input string into a conversion filter function, it never called the
corresponding flush function! That is a no-no in mbfl; conversion filters may
cache bytes and only send them to the output when flushed.

I need to add a test to expose the bug.

Author: alexdowad

ext/mbstring/libmbfl/mbfl/mbfilter.c

@@ -95,6 +95,8 @@
 #include "eaw_table.h"
 #include "filters/unicode_prop.h"
 
+#include "zend_API.h"
+
 static inline void mbfl_filter_feed_char(int c, mbfl_convert_filter *filter)
 {
 	(filter->filter_function)(c, filter);
@@ -1510,3 +1512,91 @@ mbfl_string *mbfl_html_numeric_entity_decode(mbfl_string *string, mbfl_string *r
 	mbfl_convert_filter_delete(decoder);
 	return result;
 }
+
+HashTable *mbfl_str_split(mbfl_string *string, unsigned int split_length)
+{
+	HashTable *result = NULL;
+	unsigned int mb_len;
+	size_t chunk_len = 0;
+	zval chunk;
+	unsigned char *p = string->val, *last = p + string->len;
+	const mbfl_encoding *encoding = string->encoding;
+
+	/* first scenario: 1/2/4-byte fixed width encoding */
+	if (encoding->flag & MBFL_ENCTYPE_SBCS) { /* 1 byte */
+		mb_len = string->len;
+		chunk_len = split_length; /* chunk length in bytes */
+	} else if (encoding->flag & (MBFL_ENCTYPE_WCS2BE | MBFL_ENCTYPE_WCS2LE)) { /* 2 bytes */
+		mb_len = string->len / 2;
+		chunk_len = split_length * 2;
+	} else if (encoding->flag & (MBFL_ENCTYPE_WCS4BE | MBFL_ENCTYPE_WCS4LE)) { /* 4 bytes */
+		mb_len = string->len / 4;
+		chunk_len = split_length * 4;
+	} else if (encoding->mblen_table) {
+		/* second scenario: variable width encoding with length table */
+		const unsigned char *mbtab = encoding->mblen_table;
+
+		/* assume that we have 1-byte characters */
+		result = zend_new_array((string->len + split_length - 1) / split_length); /* round up */
+
+		while (p < last) {
+			unsigned char *chunk_p = p; /* pointer to first byte in chunk */
+
+			for (int char_count = 0; char_count < split_length && p < last; char_count++) {
+				p += mbtab[*(unsigned char*)p]; /* character byte length table */
+			}
+			if (p > last) { /* check if chunk is in bounds */
+				p = last;
+			}
+			ZVAL_STRINGL(&chunk, (const char*)chunk_p, p - chunk_p);
+			zend_hash_next_index_insert(result, &chunk);
+		}
+
+		return result;
+	} else {
+		/* third scenario: other multibyte encodings */
+		/* assume that we have 1-byte characters */
+		result = zend_new_array((string->len + split_length - 1) / split_length); /* round up */
+
+		/* decoder filter to decode wchar to encoding */
+		mbfl_memory_device device;
+		mbfl_memory_device_init(&device, split_length + 1, 0);
+		mbfl_convert_filter *decoder = mbfl_convert_filter_new(&mbfl_encoding_wchar, encoding,
+			mbfl_memory_device_output, NULL, &device);
+		ZEND_ASSERT(decoder);
+
+		size_t len;
+		unsigned int *wc_buffer = convert_string_to_wchar(string, &len), *w = wc_buffer, *e = wc_buffer + len;
+
+		while (w < e) {
+			(decoder->filter_function)(*w++, decoder);
+
+			if (split_length == ++chunk_len) { /* if current chunk size reached defined chunk size */
+				mbfl_convert_filter_flush(decoder);
+				ZVAL_STRINGL(&chunk, (const char*)device.buffer, device.pos);
+				zend_hash_next_index_insert(result, &chunk);
+				mbfl_memory_device_reset(&device);
+				chunk_len = 0;
+			}
+		}
+
+		if (chunk_len > 0) {
+			mbfl_convert_filter_flush(decoder);
+			ZVAL_STRINGL(&chunk, (const char*)device.buffer, device.pos);
+			zend_hash_next_index_insert(result, &chunk);
+		}
+
+		efree(wc_buffer);
+		mbfl_memory_device_clear(&device);
+		mbfl_convert_filter_delete(decoder);
+		return result;
+	}
+
+	/* first scenario: 1/2/4-byte fixed width encoding */
+	result = zend_new_array((mb_len + split_length - 1) / split_length); /* round up */
+	for (; p < last; p += chunk_len) {
+		ZVAL_STRINGL(&chunk, (const char*)p, chunk_len);
+		zend_hash_next_index_insert(result, &chunk);
+	}
+	return result;
+}

ext/mbstring/libmbfl/mbfl/mbfilter.h

@@ -309,4 +309,9 @@ mbfl_html_numeric_entity_decode(mbfl_string *string, mbfl_string *result, int *c
  */
 MBFLAPI extern mbfl_string* mbfl_ja_jp_hantozen(mbfl_string *string, mbfl_string *result, intptr_t mode);
 
+/*
+ * str_split
+ */
+MBFLAPI extern HashTable* mbfl_str_split(mbfl_string *string, unsigned int split_length);
+
 #endif	/* MBFL_MBFILTER_H */

ext/mbstring/mbstring.c

@@ -1712,41 +1712,10 @@ PHP_FUNCTION(mb_output_handler)
 /* {{{ Convert a multibyte string to an array. If split_length is specified,
  break the string down into chunks each split_length characters long. */
 
-/* structure to pass split params to the callback */
-struct mbfl_split_params {
-	zval *return_value; /* php function return value structure pointer */
-	mbfl_string *result_string; /* string to store result chunk */
-	size_t mb_chunk_length; /* actual chunk length in chars */
-	size_t split_length; /* split length in chars */
-	mbfl_convert_filter *next_filter; /* widechar to encoding converter */
-};
-
-/* callback function to fill split array */
-static int mbfl_split_output(int c, void *data)
-{
-	struct mbfl_split_params *params = (struct mbfl_split_params *)data; /* cast passed data */
-
-	(*params->next_filter->filter_function)(c, params->next_filter); /* decoder filter */
-
-	if (params->split_length == ++params->mb_chunk_length) { /* if current chunk size reached defined chunk size or last char reached */
-		mbfl_convert_filter_flush(params->next_filter);/* concatenate separate decoded chars to the solid string */
-		mbfl_memory_device *device = (mbfl_memory_device *)params->next_filter->data; /* chars container */
-		mbfl_string *chunk = params->result_string;
-		mbfl_memory_device_result(device, chunk); /* make chunk */
-		add_next_index_stringl(params->return_value, (const char *)chunk->val, chunk->len); /* add chunk to the array */
-		efree(chunk->val);
-		params->mb_chunk_length = 0; /* reset mb_chunk size */
-	}
-
-	return 0;
-}
-
 /* TODO Document this function on php.net */
 PHP_FUNCTION(mb_str_split)
 {
 	zend_string *str, *encoding = NULL;
-	size_t mb_len, chunks, chunk_len;
-	mbfl_string string, result_string;
 	zend_long split_length = 1;
 
 	ZEND_PARSE_PARAMETERS_START(1, 3)
@@ -1761,91 +1730,17 @@ PHP_FUNCTION(mb_str_split)
 		RETURN_THROWS();
 	}
 
-	string.val = (unsigned char *) ZSTR_VAL(str);
-	string.len = ZSTR_LEN(str);
-	const mbfl_encoding *mbfl_encoding = string.encoding = php_mb_get_encoding(encoding, 3);
-	if (!string.encoding) {
+	const mbfl_encoding *mbfl_encoding = php_mb_get_encoding(encoding, 3);
+	if (!mbfl_encoding) {
 		RETURN_THROWS();
 	}
 
-	const char *p = ZSTR_VAL(str);
-	const char *last = ZSTR_VAL(str) + ZSTR_LEN(str);
-
-	/* first scenario: 1/2/4-byte fixed width encoding */
-	if (mbfl_encoding->flag & MBFL_ENCTYPE_SBCS) { /* 1 byte */
-		mb_len = string.len;
-		chunk_len = (size_t)split_length; /* chunk length in bytes */
-	} else if (mbfl_encoding->flag & (MBFL_ENCTYPE_WCS2BE | MBFL_ENCTYPE_WCS2LE)) { /* 2 bytes */
-		mb_len = string.len / 2;
-		chunk_len = split_length * 2;
-	} else if (mbfl_encoding->flag & (MBFL_ENCTYPE_WCS4BE | MBFL_ENCTYPE_WCS4LE)) { /* 4 bytes */
-		mb_len = string.len / 4;
-		chunk_len = split_length * 4;
-	} else if (mbfl_encoding->mblen_table) {
-		/* second scenario: variable width encoding with length table */
-		const unsigned char *mbtab = mbfl_encoding->mblen_table;
-
-		/* assume that we have 1-byte characters */
-		array_init_size(return_value, (string.len + split_length) / split_length); /* round up */
-
-		while (p < last) {
-			char *chunk_p = p; /* pointer to first byte in chunk */
-
-			for (int char_count = 0; char_count < split_length && p < last; char_count++) {
-				p += mbtab[*(unsigned char*)p]; /* character byte length table */
-			}
-			if (p > last) { /* check if chunk is in bounds */
-				p = last;
-			}
-			add_next_index_stringl(return_value, chunk_p, p - chunk_p);
-		}
-		return;
-	} else {
-		/* third scenario: other multibyte encodings */
-		/* assume that we have 1-byte characters */
-		array_init_size(return_value, (string.len + split_length) / split_length); /* round up */
-
-		/* decoder filter to decode wchar to encoding */
-		mbfl_memory_device device;
-		mbfl_memory_device_init(&device, split_length + 1, 0);
-
-		mbfl_convert_filter *decoder = mbfl_convert_filter_new(&mbfl_encoding_wchar, string.encoding,
-			mbfl_memory_device_output, NULL, &device);
-		ZEND_ASSERT(decoder);
-
-		/* wchar filter */
-		mbfl_string_init(&result_string); /* mbfl_string to store chunk in the callback */
-		struct mbfl_split_params params = { /* init callback function params structure */
-			.return_value = return_value,
-			.result_string = &result_string,
-			.mb_chunk_length = 0,
-			.split_length = (size_t)split_length,
-			.next_filter = decoder,
-		};
-
-		mbfl_convert_filter *filter = mbfl_convert_filter_new(string.encoding, &mbfl_encoding_wchar,
-			mbfl_split_output, NULL, &params);
-		ZEND_ASSERT(filter);
-
-		while (p < last - 1) { /* cycle each byte except last with callback function */
-			(*filter->filter_function)(*p++, filter);
-		}
-		params.mb_chunk_length = split_length - 1; /* force to finish current chunk */
-		(*filter->filter_function)(*p++, filter); /* process last char */
-
-		mbfl_convert_filter_delete(decoder);
-		mbfl_convert_filter_delete(filter);
-		mbfl_memory_device_clear(&device);
-		return;
-	}
+	mbfl_string string;
+	string.val = (unsigned char*)ZSTR_VAL(str);
+	string.len = ZSTR_LEN(str);
+	string.encoding = mbfl_encoding;
 
-	/* first scenario: 1/2/4-byte fixed width encoding */
-	chunks = (mb_len + split_length - 1) / split_length; /* round up */
-	array_init_size(return_value, chunks);
-	while (chunks--) {
-		add_next_index_stringl(return_value, p, chunk_len);
-		p += chunk_len;
-	}
+	RETVAL_ARR(mbfl_str_split(&string, split_length));
 }
 /* }}} */