Switch libmbfl to use size_t

Switch mbfl_string and related structures to use size_t lengths.

Quite likely that I broke some things along the way...

9 files changed, 241 insertions, 374 deletions

diff --git a/ext/mbstring/libmbfl/mbfl/mbfilter.c b/ext/mbstring/libmbfl/mbfl/mbfilter.c
index 4986472b9b..8a2ef80054 100644
--- a/ext/mbstring/libmbfl/mbfl/mbfilter.c
+++ b/ext/mbstring/libmbfl/mbfl/mbfilter.c
@@ -126,7 +126,7 @@ mbfl_buffer_converter *
 mbfl_buffer_converter_new(
     enum mbfl_no_encoding from,
     enum mbfl_no_encoding to,
-    int buf_initsz)
+    size_t buf_initsz)
 {
 	const mbfl_encoding *_from = mbfl_no2encoding(from);
 	const mbfl_encoding *_to = mbfl_no2encoding(to);
@@ -138,12 +138,12 @@ mbfl_buffer_converter *
 mbfl_buffer_converter_new2(
 	const mbfl_encoding *from,
 	const mbfl_encoding *to,
-    int buf_initsz)
+    size_t buf_initsz)
 {
 	mbfl_buffer_converter *convd;
 
 	/* allocate */
-	convd = (mbfl_buffer_converter*)mbfl_malloc(sizeof (mbfl_buffer_converter));
+	convd = (mbfl_buffer_converter*)mbfl_malloc(sizeof(mbfl_buffer_converter));
 	if (convd == NULL) {
 		return NULL;
 	}
@@ -154,7 +154,7 @@ mbfl_buffer_converter_new2(
 
 	/* create convert filter */
 	convd->filter1 = NULL;
-	convd->filter2 = 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);
 	} else {
@@ -234,7 +234,7 @@ mbfl_buffer_converter_illegal_substchar(mbfl_buffer_converter *convd, int substc
 }
 
 int
-mbfl_buffer_converter_strncat(mbfl_buffer_converter *convd, const unsigned char *p, int n)
+mbfl_buffer_converter_strncat(mbfl_buffer_converter *convd, const unsigned char *p, size_t n)
 {
 	mbfl_convert_filter *filter;
 	int (*filter_function)(int c, mbfl_convert_filter *filter);
@@ -262,9 +262,9 @@ mbfl_buffer_converter_feed(mbfl_buffer_converter *convd, mbfl_string *string)
 }
 
 int
-mbfl_buffer_converter_feed2(mbfl_buffer_converter *convd, mbfl_string *string, int *loc)
+mbfl_buffer_converter_feed2(mbfl_buffer_converter *convd, mbfl_string *string, size_t *loc)
 {
-	int n;
+	size_t n;
 	unsigned char *p;
 	mbfl_convert_filter *filter;
 	int (*filter_function)(int c, mbfl_convert_filter *filter);
@@ -356,9 +356,9 @@ mbfl_buffer_converter_feed_result(mbfl_buffer_converter *convd, mbfl_string *str
 	return mbfl_memory_device_result(&convd->device, result);
 }
 
-int mbfl_buffer_illegalchars(mbfl_buffer_converter *convd)
+size_t mbfl_buffer_illegalchars(mbfl_buffer_converter *convd)
 {
-	int num_illegalchars = 0;
+	size_t num_illegalchars = 0;
 
 	if (convd == NULL) {
 		return 0;
@@ -372,7 +372,7 @@ int mbfl_buffer_illegalchars(mbfl_buffer_converter *convd)
 		num_illegalchars += convd->filter2->num_illegalchar;
 	}
 
-	return (num_illegalchars);
+	return num_illegalchars;
 }
 
 /*
@@ -484,20 +484,17 @@ mbfl_encoding_detector_delete(mbfl_encoding_detector *identd)
 int
 mbfl_encoding_detector_feed(mbfl_encoding_detector *identd, mbfl_string *string)
 {
-	int i, n, num, bad, res;
-	unsigned char *p;
-	mbfl_identify_filter *filter;
-
-	res = 0;
+	int res = 0;
 	/* feed data */
 	if (identd != NULL && string != NULL && string->val != NULL) {
-		num = identd->filter_list_size;
-		n = string->len;
-		p = string->val;
-		bad = 0;
+		int num = identd->filter_list_size;
+		size_t n = string->len;
+		unsigned char *p = string->val;
+		int bad = 0;
 		while (n > 0) {
+			int i;
 			for (i = 0; i < num; i++) {
-				filter = identd->filter_list[i];
+				mbfl_identify_filter *filter = identd->filter_list[i];
 				if (!filter->flag) {
 					(*filter->filter_function)(*p, filter);
 					if (filter->flag) {
@@ -568,7 +565,7 @@ mbfl_convert_encoding(
     mbfl_string *result,
     enum mbfl_no_encoding toenc)
 {
-	int n;
+	size_t n;
 	unsigned char *p;
 	const mbfl_encoding *encoding;
 	mbfl_memory_device device;
@@ -634,7 +631,8 @@ mbfl_convert_encoding(
 const mbfl_encoding *
 mbfl_identify_encoding(mbfl_string *string, enum mbfl_no_encoding *elist, int elistsz, int strict)
 {
-	int i, n, num, bad;
+	int i, num, bad;
+	size_t n;
 	unsigned char *p;
 	mbfl_identify_filter *flist, *filter;
 	const mbfl_encoding *encoding;
@@ -705,7 +703,8 @@ mbfl_identify_encoding(mbfl_string *string, enum mbfl_no_encoding *elist, int el
 
 	/* cleanup */
 	/* dtors should be called in reverse order */
-	i = num; while (--i >= 0) {
+	i = num;
+	while (--i >= 0) {
 		mbfl_identify_filter_cleanup(&flist[i]);
 	}
 
@@ -717,7 +716,8 @@ mbfl_identify_encoding(mbfl_string *string, enum mbfl_no_encoding *elist, int el
 const mbfl_encoding *
 mbfl_identify_encoding2(mbfl_string *string, const mbfl_encoding **elist, int elistsz, int strict)
 {
-	int i, n, num, bad;
+	int i, num, bad;
+	size_t n;
 	unsigned char *p;
 	mbfl_identify_filter *flist, *filter;
 	const mbfl_encoding *encoding;
@@ -788,7 +788,8 @@ mbfl_identify_encoding2(mbfl_string *string, const mbfl_encoding **elist, int el
 
 	/* cleanup */
 	/* dtors should be called in reverse order */
-	i = num; while (--i >= 0) {
+	i = num;
+	while (--i >= 0) {
 		mbfl_identify_filter_cleanup(&flist[i]);
 	}
 
@@ -803,21 +804,20 @@ mbfl_identify_encoding2(mbfl_string *string, const mbfl_encoding **elist, int el
 static int
 filter_count_output(int c, void *data)
 {
-	(*(int *)data)++;
+	(*(size_t *)data)++;
 	return c;
 }
 
-int
+size_t
 mbfl_strlen(mbfl_string *string)
 {
-	int len, n, m, k;
+	size_t len, n, k;
 	unsigned char *p;
-	const unsigned char *mbtab;
 	const mbfl_encoding *encoding;
 
 	encoding = mbfl_no2encoding(string->no_encoding);
 	if (encoding == NULL || string == NULL) {
-		return -1;
+		return (size_t) -1;
 	}
 
 	len = 0;
@@ -828,18 +828,18 @@ mbfl_strlen(mbfl_string *string)
 	} else if (encoding->flag & (MBFL_ENCTYPE_WCS4BE | MBFL_ENCTYPE_WCS4LE)) {
 		len = string->len/4;
 	} else if (encoding->mblen_table != NULL) {
-		mbtab = encoding->mblen_table;
+		const unsigned char *mbtab = encoding->mblen_table;
 		n = 0;
 		p = string->val;
 		k = string->len;
 		/* count */
 		if (p != NULL) {
 			while (n < k) {
-				m = mbtab[*p];
+				unsigned m = mbtab[*p];
 				n += m;
 				p += m;
 				len++;
-			};
+			}
 		}
 	} else {
 		/* wchar filter */
@@ -848,7 +848,7 @@ mbfl_strlen(mbfl_string *string)
 		  mbfl_no_encoding_wchar,
 		  filter_count_output, 0, &len);
 		if (filter == NULL) {
-			return -1;
+			return (size_t) -1;
 		}
 		/* count */
 		n = string->len;
@@ -872,12 +872,12 @@ mbfl_strlen(mbfl_string *string)
 struct collector_strpos_data {
 	mbfl_convert_filter *next_filter;
 	mbfl_wchar_device needle;
-	int needle_len;
-	int start;
-	int output;
-	int found_pos;
-	int needle_pos;
-	int matched_pos;
+	size_t needle_len;
+	size_t start;
+	size_t output;
+	size_t found_pos;
+	size_t needle_pos;
+	size_t matched_pos;
 };
 
 static int
@@ -931,21 +931,20 @@ retry:
 /*
  *	oddlen
  */
-int
+size_t
 mbfl_oddlen(mbfl_string *string)
 {
-	int len, n, m, k;
+	size_t len, n, k;
 	unsigned char *p;
-	const unsigned char *mbtab;
 	const mbfl_encoding *encoding;
 
 
 	if (string == NULL) {
-		return -1;
+		return (size_t) -1;
 	}
 	encoding = mbfl_no2encoding(string->no_encoding);
 	if (encoding == NULL) {
-		return -1;
+		return (size_t) -1;
 	}
 
 	len = 0;
@@ -956,14 +955,14 @@ mbfl_oddlen(mbfl_string *string)
 	} else if (encoding->flag & (MBFL_ENCTYPE_WCS4BE | MBFL_ENCTYPE_WCS4LE)) {
 		return len % 4;
 	} else if (encoding->mblen_table != NULL) {
- 		mbtab = encoding->mblen_table;
+		const unsigned char *mbtab = encoding->mblen_table;
  		n = 0;
 		p = string->val;
 		k = string->len;
 		/* count */
 		if (p != NULL) {
 			while (n < k) {
-				m = mbtab[*p];
+				unsigned m = mbtab[*p];
 				n += m;
 				p += m;
 			};
@@ -976,27 +975,27 @@ mbfl_oddlen(mbfl_string *string)
 	/* NOT REACHED */
 }
 
-int
+size_t
 mbfl_strpos(
     mbfl_string *haystack,
     mbfl_string *needle,
-    int offset,
+    ssize_t offset,
     int reverse)
 {
-	int result;
+	size_t result;
 	mbfl_string _haystack_u8, _needle_u8;
 	const mbfl_string *haystack_u8, *needle_u8 = NULL;
 	const unsigned char *u8_tbl;
 
 	if (haystack == NULL || haystack->val == NULL || needle == NULL || needle->val == NULL) {
-		return -8;
+		return (size_t) -8;
 	}
 
 	{
 		const mbfl_encoding *u8_enc;
 		u8_enc = mbfl_no2encoding(mbfl_no_encoding_utf8);
 		if (u8_enc == NULL || u8_enc->mblen_table == NULL) {
-			return -8;
+			return (size_t) -8;
 		}
 		u8_tbl = u8_enc->mblen_table;
 	}
@@ -1005,7 +1004,7 @@ mbfl_strpos(
 		mbfl_string_init(&_haystack_u8);
 		haystack_u8 = mbfl_convert_encoding(haystack, &_haystack_u8, mbfl_no_encoding_utf8);
 		if (haystack_u8 == NULL) {
-			result = -4;
+			result = (size_t) -4;
 			goto out;
 		}
 	} else {
@@ -1016,7 +1015,7 @@ mbfl_strpos(
 		mbfl_string_init(&_needle_u8);
 		needle_u8 = mbfl_convert_encoding(needle, &_needle_u8, mbfl_no_encoding_utf8);
 		if (needle_u8 == NULL) {
-			result = -4;
+			result = (size_t) -4;
 			goto out;
 		}
 	} else {
@@ -1024,19 +1023,19 @@ mbfl_strpos(
 	}
 
 	if (needle_u8->len < 1) {
-		result = -8;
+		result = (size_t) -8;
 		goto out;
 	}
 
-	result = -1;
+	result = (size_t) -1;
 	if (haystack_u8->len < needle_u8->len) {
 		goto out;
 	}
 
 	if (!reverse) {
-		unsigned int jtbl[1 << (sizeof(unsigned char) * 8)];
-		unsigned int needle_u8_len = needle_u8->len;
-		unsigned int i;
+		size_t jtbl[1 << (sizeof(unsigned char) * 8)];
+		size_t needle_u8_len = needle_u8->len;
+		size_t i;
 		const unsigned char *p, *q, *e;
 		const unsigned char *haystack_u8_val = haystack_u8->val,
 		                    *needle_u8_val = needle_u8->val;
@@ -1048,9 +1047,9 @@ mbfl_strpos(
 		}
 		e = haystack_u8_val + haystack_u8->len;
 		p = haystack_u8_val;
-		while (--offset >= 0) {
+		while (offset-- > 0) {
 			if (p >= e) {
-				result = -16;
+				result = (size_t) -16;
 				goto out;
 			}
 			p += u8_tbl[*p];
@@ -1085,9 +1084,9 @@ mbfl_strpos(
 			}
 		}
 	} else {
-		unsigned int jtbl[1 << (sizeof(unsigned char) * 8)];
-		unsigned int needle_u8_len = needle_u8->len, needle_len = 0;
-		unsigned int i;
+		size_t jtbl[1 << (sizeof(unsigned char) * 8)];
+		size_t needle_u8_len = needle_u8->len, needle_len = 0;
+		size_t i;
 		const unsigned char *p, *e, *q, *qe;
 		const unsigned char *haystack_u8_val = haystack_u8->val,
 		                    *needle_u8_val = needle_u8->val;
@@ -1120,7 +1119,7 @@ mbfl_strpos(
 				while (offset < 0) {
 					unsigned char c;
 					if (p <= e) {
-						result = -16;
+						result = (size_t) -16;
 						goto out;
 					}
 					c = *(--p);
@@ -1133,9 +1132,9 @@ mbfl_strpos(
 			}
 		} else {
 			const unsigned char *ee = haystack_u8_val + haystack_u8->len;
-			while (--offset >= 0) {
+			while (offset-- > 0) {
 				if (e >= ee) {
-					result = -16;
+					result = (size_t) -16;
 					goto out;
 				}
 				e += u8_tbl[*e];
@@ -1187,19 +1186,19 @@ out:
  *  substr_count
  */
 
-int
+size_t
 mbfl_substr_count(
     mbfl_string *haystack,
     mbfl_string *needle
    )
 {
-	int n, result = 0;
+	size_t n, result = 0;
 	unsigned char *p;
 	mbfl_convert_filter *filter;
 	struct collector_strpos_data pc;
 
 	if (haystack == NULL || needle == NULL) {
-		return -8;
+		return (size_t) -8;
 	}
 	/* needle is converted into wchar */
 	mbfl_wchar_device_init(&pc.needle);
@@ -1208,7 +1207,7 @@ mbfl_substr_count(
 	  mbfl_no_encoding_wchar,
 	  mbfl_wchar_device_output, 0, &pc.needle);
 	if (filter == NULL) {
-		return -4;
+		return (size_t) -4;
 	}
 	p = needle->val;
 	n = needle->len;
@@ -1224,11 +1223,11 @@ mbfl_substr_count(
 	mbfl_convert_filter_delete(filter);
 	pc.needle_len = pc.needle.pos;
 	if (pc.needle.buffer == NULL) {
-		return -4;
+		return (size_t) -4;
 	}
 	if (pc.needle_len <= 0) {
 		mbfl_wchar_device_clear(&pc.needle);
-		return -2;
+		return (size_t) -2;
 	}
 	/* initialize filter and collector data */
 	filter = mbfl_convert_filter_new(
@@ -1237,13 +1236,13 @@ mbfl_substr_count(
 	  collector_strpos, 0, &pc);
 	if (filter == NULL) {
 		mbfl_wchar_device_clear(&pc.needle);
-		return -4;
+		return (size_t) -4;
 	}
 	pc.start = 0;
 	pc.output = 0;
 	pc.needle_pos = 0;
 	pc.found_pos = 0;
-	pc.matched_pos = -1;
+	pc.matched_pos = (size_t) -1;
 
 	/* feed data */
 	p = haystack->val;
@@ -1251,12 +1250,12 @@ mbfl_substr_count(
 	if (p != NULL) {
 		while (n > 0) {
 			if ((*filter->filter_function)(*p++, filter) < 0) {
-				pc.matched_pos = -4;
+				pc.matched_pos = (size_t) -4;
 				break;
 			}
-			if (pc.matched_pos >= 0) {
+			if (pc.matched_pos != (size_t) -1) {
 				++result;
-				pc.matched_pos = -1;
+				pc.matched_pos = (size_t) -1;
 				pc.needle_pos = 0;
 			}
 			n--;
@@ -1274,9 +1273,9 @@ mbfl_substr_count(
  */
 struct collector_substr_data {
 	mbfl_convert_filter *next_filter;
-	int start;
-	int stop;
-	int output;
+	size_t start;
+	size_t stop;
+	size_t output;
 };
 
 static int
@@ -1301,13 +1300,13 @@ mbfl_string *
 mbfl_substr(
     mbfl_string *string,
     mbfl_string *result,
-    int from,
-    int length)
+    size_t from,
+    size_t length)
 {
 	const mbfl_encoding *encoding;
-	int n, m, k, len, start, end;
+	size_t n, k, len, start, end;
+	unsigned m;
 	unsigned char *p, *w;
-	const unsigned char *mbtab;
 
 	encoding = mbfl_no2encoding(string->no_encoding);
 	if (encoding == NULL || string == NULL || result == NULL) {
@@ -1329,7 +1328,7 @@ mbfl_substr(
 			start *= 4;
 			end = start + length*4;
 		} else if (encoding->mblen_table != NULL) {
-			mbtab = encoding->mblen_table;
+			const unsigned char *mbtab = encoding->mblen_table;
 			start = 0;
 			end = 0;
 			n = 0;
@@ -1366,15 +1365,9 @@ mbfl_substr(
 		if (start > len) {
 			start = len;
 		}
-		if (start < 0) {
-			start = 0;
-		}
 		if (end > len) {
 			end = len;
 		}
-		if (end < 0) {
-			end = 0;
-		}
 		if (start > end) {
 			start = end;
 		}
@@ -1459,8 +1452,8 @@ mbfl_string *
 mbfl_strcut(
     mbfl_string *string,
     mbfl_string *result,
-    int from,
-    int length)
+    size_t from,
+    size_t length)
 {
 	const mbfl_encoding *encoding;
 	mbfl_memory_device device;
@@ -1470,10 +1463,6 @@ mbfl_strcut(
 		return NULL;
 	}
 
-	if (from < 0 || length < 0) {
-		return NULL;
-	}
-
 	if (from >= string->len) {
 		from = string->len;
 	}
@@ -1496,7 +1485,7 @@ mbfl_strcut(
 		const unsigned char *start = NULL;
 		const unsigned char *end = NULL;
 		unsigned char *w;
-		unsigned int sz;
+		size_t sz;
 
 		if (encoding->flag & (MBFL_ENCTYPE_WCS2BE | MBFL_ENCTYPE_WCS2LE)) {
 			from &= -2;
@@ -1539,7 +1528,7 @@ mbfl_strcut(
 			start = p;
 
 			/* search end position */
-			if (length >= (int)string->len - (start - string->val)) {
+			if (length >= string->len - (start - string->val)) {
 				end = string->val + string->len;
 			} else {
 				for (q = p + length; p < q; p += (m = mbtab[*p]));
@@ -1577,7 +1566,7 @@ mbfl_strcut(
 			mbfl_convert_filter encoder;
 			mbfl_convert_filter decoder;
 			const unsigned char *p;
-			int pos;
+			size_t pos;
 		} bk, _bk;
 
 		/* output code filter */
@@ -1750,7 +1739,7 @@ mbfl_strcut(
 /*
  *  strwidth
  */
-static int is_fullwidth(int c)
+static size_t is_fullwidth(int c)
 {
 	int i;
 
@@ -1770,14 +1759,14 @@ static int is_fullwidth(int c)
 static int
 filter_count_width(int c, void* data)
 {
-	(*(int *)data) += (is_fullwidth(c) ? 2: 1);
+	(*(size_t *)data) += (is_fullwidth(c) ? 2: 1);
 	return c;
 }
 
-int
+size_t
 mbfl_strwidth(mbfl_string *string)
 {
-	int len, n;
+	size_t len, n;
 	unsigned char *p;
 	mbfl_convert_filter *filter;
 
@@ -1816,12 +1805,12 @@ struct collector_strimwidth_data {
 	mbfl_convert_filter *decoder;
 	mbfl_convert_filter *decoder_backup;
 	mbfl_memory_device device;
-	int from;
-	int width;
-	int outwidth;
-	int outchar;
+	size_t from;
+	size_t width;
+	size_t outwidth;
+	size_t outchar;
+	size_t endpos;
 	int status;
-	int endpos;
 };
 
 static int
@@ -1861,12 +1850,12 @@ mbfl_strimwidth(
     mbfl_string *string,
     mbfl_string *marker,
     mbfl_string *result,
-    int from,
-    int width)
+    size_t from,
+    size_t width)
 {
 	struct collector_strimwidth_data pc;
 	mbfl_convert_filter *encoder;
-	int n, mkwidth;
+	size_t n, mkwidth;
 	unsigned char *p;
 
 	if (string == NULL || result == NULL) {
@@ -1963,7 +1952,7 @@ mbfl_ja_jp_hantozen(
     mbfl_string *result,
     int mode)
 {
-	int n;
+	size_t n;
 	unsigned char *p;
 	const mbfl_encoding *encoding;
 	mbfl_memory_device device;
@@ -2077,9 +2066,9 @@ struct mime_header_encoder_data {
 	mbfl_memory_device tmpdev;
 	int status1;
 	int status2;
-	int prevpos;
-	int linehead;
-	int firstindent;
+	size_t prevpos;
+	size_t linehead;
+	size_t firstindent;
 	int encnamelen;
 	int lwsplen;
 	char encname[128];
@@ -2089,7 +2078,7 @@ struct mime_header_encoder_data {
 static int
 mime_header_encoder_block_collector(int c, void *data)
 {
-	int n;
+	size_t n;
 	struct mime_header_encoder_data *pe = (struct mime_header_encoder_data *)data;
 
 	switch (pe->status2) {
@@ -2150,7 +2139,7 @@ mime_header_encoder_collector(int c, void *data)
 		1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1  /* 0xF0 */
 	};
 
-	int n;
+	size_t n;
 	struct mime_header_encoder_data *pe = (struct mime_header_encoder_data *)data;
 
 	switch (pe->status1) {
@@ -2230,7 +2219,7 @@ mime_header_encoder_new(
     enum mbfl_no_encoding outcode,
     enum mbfl_no_encoding transenc)
 {
-	int n;
+	size_t n;
 	const char *s;
 	const mbfl_encoding *outencoding;
 	struct mime_header_encoder_data *pe;
@@ -2345,7 +2334,7 @@ mbfl_mime_header_encode(
     const char *linefeed,
     int indent)
 {
-	int n;
+	size_t n;
 	unsigned char *p;
 	struct mime_header_encoder_data *pe;
 
@@ -2394,7 +2383,7 @@ struct mime_header_decoder_data {
 	mbfl_convert_filter *conv2_filter;
 	mbfl_memory_device outdev;
 	mbfl_memory_device tmpdev;
-	int cspos;
+	size_t cspos;
 	int status;
 	enum mbfl_no_encoding encoding;
 	enum mbfl_no_encoding incode;
@@ -2642,7 +2631,7 @@ mbfl_mime_header_decode(
     mbfl_string *result,
     enum mbfl_no_encoding outcode)
 {
-	int n;
+	size_t n;
 	unsigned char *p;
 	struct mime_header_decoder_data *pd;
 
@@ -3039,7 +3028,7 @@ mbfl_html_numeric_entity(
 	struct collector_htmlnumericentity_data pc;
 	mbfl_memory_device device;
 	mbfl_convert_filter *encoder;
-	int n;
+	size_t n;
 	unsigned char *p;
 
 	if (string == NULL || result == NULL) {
diff --git a/ext/mbstring/libmbfl/mbfl/mbfilter.h b/ext/mbstring/libmbfl/mbfl/mbfilter.h
index 565ed3252d..53001d84e6 100644
--- a/ext/mbstring/libmbfl/mbfl/mbfilter.h
+++ b/ext/mbstring/libmbfl/mbfl/mbfilter.h
@@ -126,20 +126,20 @@ 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, int buf_initsz);
-MBFLAPI extern mbfl_buffer_converter * mbfl_buffer_converter_new2(const mbfl_encoding *from, const mbfl_encoding *to, int buf_initsz);
+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 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);
 MBFLAPI extern int mbfl_buffer_converter_illegal_substchar(mbfl_buffer_converter *convd, int substchar);
-MBFLAPI extern int mbfl_buffer_converter_strncat(mbfl_buffer_converter *convd, const unsigned char *p, int n);
+MBFLAPI extern int mbfl_buffer_converter_strncat(mbfl_buffer_converter *convd, const unsigned char *p, size_t n);
 MBFLAPI extern int mbfl_buffer_converter_feed(mbfl_buffer_converter *convd, mbfl_string *string);
-MBFLAPI extern int mbfl_buffer_converter_feed2(mbfl_buffer_converter *convd, mbfl_string *string, int *loc);
+MBFLAPI extern int mbfl_buffer_converter_feed2(mbfl_buffer_converter *convd, mbfl_string *string, size_t *loc);
 MBFLAPI extern int mbfl_buffer_converter_flush(mbfl_buffer_converter *convd);
 MBFLAPI extern mbfl_string * mbfl_buffer_converter_getbuffer(mbfl_buffer_converter *convd, mbfl_string *result);
 MBFLAPI extern mbfl_string * mbfl_buffer_converter_result(mbfl_buffer_converter *convd, mbfl_string *result);
 MBFLAPI extern mbfl_string * mbfl_buffer_converter_feed_result(mbfl_buffer_converter *convd, mbfl_string *string, mbfl_string *result);
-MBFLAPI extern int mbfl_buffer_illegalchars(mbfl_buffer_converter *convd);
+MBFLAPI extern size_t mbfl_buffer_illegalchars(mbfl_buffer_converter *convd);
 
 /*
  * encoding detector
@@ -175,54 +175,60 @@ mbfl_identify_encoding(mbfl_string *string, enum mbfl_no_encoding *elist, int el
 
 MBFLAPI extern const mbfl_encoding *
 mbfl_identify_encoding2(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) {
+	return len >= (size_t) -16;
+}
+
 /*
  * strlen
  */
-MBFLAPI extern int
+MBFLAPI extern size_t
 mbfl_strlen(mbfl_string *string);
 
 /*
  * oddlen
  */
-MBFLAPI extern int
+MBFLAPI extern size_t
 mbfl_oddlen(mbfl_string *string);
 
 /*
  * strpos
  */
-MBFLAPI extern int
-mbfl_strpos(mbfl_string *haystack, mbfl_string *needle, int offset, int reverse);
+MBFLAPI extern size_t
+mbfl_strpos(mbfl_string *haystack, mbfl_string *needle, ssize_t offset, int reverse);
 
 
 /*
  * substr_count
  */
-MBFLAPI extern int
+MBFLAPI extern size_t
 mbfl_substr_count(mbfl_string *haystack, mbfl_string *needle);
 
 /*
  * substr
  */
 MBFLAPI extern mbfl_string *
-mbfl_substr(mbfl_string *string, mbfl_string *result, int from, int length);
+mbfl_substr(mbfl_string *string, mbfl_string *result, size_t from, size_t length);
 
 /*
  * strcut
  */
 MBFLAPI extern mbfl_string *
-mbfl_strcut(mbfl_string *string, mbfl_string *result, int from, int length);
+mbfl_strcut(mbfl_string *string, mbfl_string *result, size_t from, size_t length);
 
 /*
  *  strwidth
  */
-MBFLAPI extern int
+MBFLAPI extern size_t
 mbfl_strwidth(mbfl_string *string);
 
 /*
  *  strimwidth
  */
 MBFLAPI extern mbfl_string *
-mbfl_strimwidth(mbfl_string *string, mbfl_string *marker, mbfl_string *result, int from, int width);
+mbfl_strimwidth(mbfl_string *string, mbfl_string *marker, mbfl_string *result, size_t from, size_t width);
 
 /*
  * MIME header encode
diff --git a/ext/mbstring/libmbfl/mbfl/mbfl_convert.c b/ext/mbstring/libmbfl/mbfl/mbfl_convert.c
index b553ad5d13..557704d515 100644
--- a/ext/mbstring/libmbfl/mbfl/mbfl_convert.c
+++ b/ext/mbstring/libmbfl/mbfl/mbfl_convert.c
@@ -435,7 +435,7 @@ mbfl_convert_filter_copy(
 
 int mbfl_convert_filter_devcat(mbfl_convert_filter *filter, mbfl_memory_device *src)
 {
-	int n;
+	size_t n;
 	unsigned char *p;
 
 	p = src->buffer;
@@ -447,7 +447,7 @@ int mbfl_convert_filter_devcat(mbfl_convert_filter *filter, mbfl_memory_device *
 		n--;
 	}
 
-	return n;
+	return 0;
 }
 
 int mbfl_convert_filter_strcat(mbfl_convert_filter *filter, const unsigned char *p)
diff --git a/ext/mbstring/libmbfl/mbfl/mbfl_convert.h b/ext/mbstring/libmbfl/mbfl/mbfl_convert.h
index ad0911723a..794c386e65 100644
--- a/ext/mbstring/libmbfl/mbfl/mbfl_convert.h
+++ b/ext/mbstring/libmbfl/mbfl/mbfl_convert.h
@@ -52,7 +52,7 @@ struct _mbfl_convert_filter {
 	const mbfl_encoding *to;
 	int illegal_mode;
 	int illegal_substchar;
-	int num_illegalchar;
+	size_t num_illegalchar;
 	void *opaque;
 };
 
diff --git a/ext/mbstring/libmbfl/mbfl/mbfl_memory_device.c b/ext/mbstring/libmbfl/mbfl/mbfl_memory_device.c
index eae05953b2..5a28613014 100644
--- a/ext/mbstring/libmbfl/mbfl/mbfl_memory_device.c
+++ b/ext/mbstring/libmbfl/mbfl/mbfl_memory_device.c
@@ -44,7 +44,7 @@
  * memory device output functions
  */
 void
-mbfl_memory_device_init(mbfl_memory_device *device, int initsz, int allocsz)
+mbfl_memory_device_init(mbfl_memory_device *device, size_t initsz, size_t allocsz)
 {
 	if (device) {
 		device->length = 0;
@@ -55,7 +55,7 @@ mbfl_memory_device_init(mbfl_memory_device *device, int initsz, int allocsz)
 				device->length = initsz;
 			}
 		}
-		device->pos= 0;
+		device->pos = 0;
 		if (allocsz > MBFL_MEMORY_DEVICE_ALLOC_SIZE) {
 			device->allocsz = allocsz;
 		} else {
@@ -65,7 +65,7 @@ mbfl_memory_device_init(mbfl_memory_device *device, int initsz, int allocsz)
 }
 
 void
-mbfl_memory_device_realloc(mbfl_memory_device *device, int initsz, int allocsz)
+mbfl_memory_device_realloc(mbfl_memory_device *device, size_t initsz, size_t allocsz)
 {
 	unsigned char *tmp;
 
@@ -142,7 +142,7 @@ mbfl_memory_device_output(int c, void *data)
 
 	if (device->pos >= device->length) {
 		/* reallocate buffer */
-		int newlen;
+		size_t newlen;
 		unsigned char *tmp;
 
 		newlen = device->length + device->allocsz;
@@ -169,7 +169,7 @@ mbfl_memory_device_output2(int c, void *data)
 
 	if ((device->pos + 2) >= device->length) {
 		/* reallocate buffer */
-		int newlen;
+		size_t newlen;
 		unsigned char *tmp;
 
 		newlen = device->length + device->allocsz;
@@ -198,7 +198,7 @@ mbfl_memory_device_output4(int c, void* data)
 
 	if ((device->pos + 4) >= device->length) {
 		/* reallocate buffer */
-		int newlen;
+		size_t newlen;
 		unsigned char *tmp;
 
 		newlen = device->length + device->allocsz;
@@ -225,7 +225,7 @@ mbfl_memory_device_output4(int c, void* data)
 int
 mbfl_memory_device_strcat(mbfl_memory_device *device, const char *psrc)
 {
-	int len;
+	size_t len;
 	unsigned char *w;
 	const unsigned char *p;
 
@@ -238,7 +238,7 @@ mbfl_memory_device_strcat(mbfl_memory_device *device, const char *psrc)
 
 	if ((device->pos + len) >= device->length) {
 		/* reallocate buffer */
-		int newlen = device->length + (len + MBFL_MEMORY_DEVICE_ALLOC_SIZE)*sizeof(unsigned char);
+		size_t newlen = device->length + (len + MBFL_MEMORY_DEVICE_ALLOC_SIZE)*sizeof(unsigned char);
 		unsigned char *tmp;
 		if (newlen <= 0) {
 			/* overflow */
@@ -260,17 +260,17 @@ mbfl_memory_device_strcat(mbfl_memory_device *device, const char *psrc)
 		len--;
 	}
 
-	return len;
+	return 0;
 }
 
 int
-mbfl_memory_device_strncat(mbfl_memory_device *device, const char *psrc, int len)
+mbfl_memory_device_strncat(mbfl_memory_device *device, const char *psrc, size_t len)
 {
 	unsigned char *w;
 
 	if ((device->pos + len) >= device->length) {
 		/* reallocate buffer */
-		int newlen = device->length + len + MBFL_MEMORY_DEVICE_ALLOC_SIZE;
+		size_t newlen = device->length + len + MBFL_MEMORY_DEVICE_ALLOC_SIZE;
 		unsigned char *tmp;
 		if (newlen <= 0) {
 			/* overflow */
@@ -291,18 +291,18 @@ mbfl_memory_device_strncat(mbfl_memory_device *device, const char *psrc, int len
 		len--;
 	}
 
-	return len;
+	return 0;
 }
 
 int
 mbfl_memory_device_devcat(mbfl_memory_device *dest, mbfl_memory_device *src)
 {
-	int n;
+	size_t n;
 	unsigned char *p, *w;
 
 	if ((dest->pos + src->pos) >= dest->length) {
 		/* reallocate buffer */
-		int newlen = dest->length + src->pos + MBFL_MEMORY_DEVICE_ALLOC_SIZE;
+		size_t newlen = dest->length + src->pos + MBFL_MEMORY_DEVICE_ALLOC_SIZE;
 		unsigned char *tmp;
 		if (newlen <= 0) {
 			/* overflow */
@@ -325,7 +325,7 @@ mbfl_memory_device_devcat(mbfl_memory_device *dest, mbfl_memory_device *src)
 		n--;
 	}
 
-	return n;
+	return 0;
 }
 
 void
@@ -359,7 +359,7 @@ mbfl_wchar_device_output(int c, void *data)
 
 	if (device->pos >= device->length) {
 		/* reallocate buffer */
-		int newlen;
+		size_t newlen;
 		unsigned int *tmp;
 
 		newlen = device->length + device->allocsz;
diff --git a/ext/mbstring/libmbfl/mbfl/mbfl_memory_device.h b/ext/mbstring/libmbfl/mbfl/mbfl_memory_device.h
index 0e8a82f0e8..985e251158 100644
--- a/ext/mbstring/libmbfl/mbfl/mbfl_memory_device.h
+++ b/ext/mbstring/libmbfl/mbfl/mbfl_memory_device.h
@@ -38,29 +38,33 @@
 
 typedef struct _mbfl_memory_device {
 	unsigned char *buffer;
-	int length;
-	int pos;
-	int allocsz;
+	size_t length;
+	size_t pos;
+	size_t allocsz;
 } mbfl_memory_device;
 
 typedef struct _mbfl_wchar_device {
 	unsigned int *buffer;
-	int length;
-	int pos;
-	int allocsz;
+	size_t length;
+	size_t pos;
+	size_t allocsz;
 } mbfl_wchar_device;
 
-MBFLAPI extern void mbfl_memory_device_init(mbfl_memory_device *device, int initsz, int allocsz);
-MBFLAPI extern void mbfl_memory_device_realloc(mbfl_memory_device *device, int initsz, int allocsz);
+MBFLAPI extern void mbfl_memory_device_init(
+		mbfl_memory_device *device, size_t initsz, size_t allocsz);
+MBFLAPI extern void mbfl_memory_device_realloc(
+		mbfl_memory_device *device, size_t initsz, size_t allocsz);
 MBFLAPI extern void mbfl_memory_device_clear(mbfl_memory_device *device);
 MBFLAPI extern void mbfl_memory_device_reset(mbfl_memory_device *device);
-MBFLAPI extern mbfl_string * mbfl_memory_device_result(mbfl_memory_device *device, mbfl_string *result);
+MBFLAPI extern mbfl_string * mbfl_memory_device_result(
+		mbfl_memory_device *device, mbfl_string *result);
 MBFLAPI extern void mbfl_memory_device_unput(mbfl_memory_device *device);
 MBFLAPI extern int mbfl_memory_device_output(int c, void *data);
 MBFLAPI extern int mbfl_memory_device_output2(int c, void *data);
 MBFLAPI extern int mbfl_memory_device_output4(int c, void *data);
 MBFLAPI extern int mbfl_memory_device_strcat(mbfl_memory_device *device, const char *psrc);
-MBFLAPI extern int mbfl_memory_device_strncat(mbfl_memory_device *device, const char *psrc, int len);
+MBFLAPI extern int mbfl_memory_device_strncat(
+		mbfl_memory_device *device, const char *psrc, size_t len);
 MBFLAPI extern int mbfl_memory_device_devcat(mbfl_memory_device *dest, mbfl_memory_device *src);
 
 MBFLAPI extern void mbfl_wchar_device_init(mbfl_wchar_device *device);
diff --git a/ext/mbstring/libmbfl/mbfl/mbfl_string.h b/ext/mbstring/libmbfl/mbfl/mbfl_string.h
index 560944737e..88fabd5c4f 100644
--- a/ext/mbstring/libmbfl/mbfl/mbfl_string.h
+++ b/ext/mbstring/libmbfl/mbfl/mbfl_string.h
@@ -31,6 +31,7 @@
 #ifndef MBFL_STRING_H
 #define MBFL_STRING_H
 
+#include <stddef.h>
 #include "mbfl_defs.h"
 #include "mbfl_encoding.h"
 #include "mbfl_language.h"
@@ -42,7 +43,7 @@ typedef struct _mbfl_string {
 	enum mbfl_no_language no_language;
 	enum mbfl_no_encoding no_encoding;
 	unsigned char *val;
-	unsigned int len;
+	size_t len;
 } mbfl_string;
 
 MBFLAPI extern void mbfl_string_init(mbfl_string *string);
diff --git a/ext/mbstring/mbstring.c b/ext/mbstring/mbstring.c
index 1ce966610c..224e3f172b 100644
--- a/ext/mbstring/mbstring.c
+++ b/ext/mbstring/mbstring.c
@@ -934,7 +934,8 @@ static size_t php_mb_zend_encoding_converter(unsigned char **to, size_t *to_leng
 {
 	mbfl_string string, result;
 	mbfl_buffer_converter *convd;
-	int status, loc;
+	int status;
+	size_t loc;
 
 	/* new encoding */
 	/* initialize string */
@@ -948,7 +949,7 @@ static size_t php_mb_zend_encoding_converter(unsigned char **to, size_t *to_leng
 	/* initialize converter */
 	convd = mbfl_buffer_converter_new2((const mbfl_encoding *)encoding_from, (const mbfl_encoding *)encoding_to, string.len);
 	if (convd == NULL) {
-		return -1;
+		return (size_t) -1;
 	}
 	mbfl_buffer_converter_illegal_mode(convd, MBSTRG(current_filter_illegal_mode));
 	mbfl_buffer_converter_illegal_substchar(convd, MBSTRG(current_filter_illegal_substchar));
@@ -1095,11 +1096,11 @@ static int php_mb_nls_get_default_detect_order_list(enum mbfl_no_language lang,
 }
 /* }}} */
 
-static char *php_mb_rfc1867_substring_conf(const zend_encoding *encoding, char *start, int len, char quote)
+static char *php_mb_rfc1867_substring_conf(const zend_encoding *encoding, char *start, size_t len, char quote)
 {
 	char *result = emalloc(len + 2);
 	char *resp = result;
-	int i;
+	size_t i;
 
 	for (i = 0; i < len && start[i] != quote; ++i) {
 		if (start[i] == '\\' && (start[i + 1] == '\\' || (quote && start[i + 1] == quote))) {
@@ -2213,7 +2214,8 @@ PHP_FUNCTION(mb_output_handler)
 	const char *charset;
 	char *p;
 	const mbfl_encoding *encoding;
-	int last_feed, len;
+	int last_feed;
+	size_t len;
 	unsigned char send_text_mimetype = 0;
 	char *s, *mimetype = NULL;
 
@@ -2313,21 +2315,14 @@ PHP_FUNCTION(mb_strlen)
 	int n;
 	mbfl_string string;
 	char *enc_name = NULL;
-	size_t enc_name_len, string_len;
+	size_t enc_name_len;
 
 	mbfl_string_init(&string);
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|s", (char **)&string.val, &string_len, &enc_name, &enc_name_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|s", (char **)&string.val, &string.len, &enc_name, &enc_name_len) == FAILURE) {
 		return;
 	}
 
-	if (ZEND_SIZE_T_UINT_OVFL(string_len)) {
-			php_error_docref(NULL, E_WARNING, "String overflows the max allowed length of %u", UINT_MAX);
-			return;
-	}
-
-	string.len = (uint32_t)string_len;
-
 	string.no_language = MBSTRG(language);
 	if (enc_name == NULL) {
 		string.no_encoding = MBSTRG(current_internal_encoding)->no_encoding;
@@ -2340,7 +2335,7 @@ PHP_FUNCTION(mb_strlen)
 	}
 
 	n = mbfl_strlen(&string);
-	if (n >= 0) {
+	if (!mbfl_is_error(n)) {
 		RETVAL_LONG(n);
 	} else {
 		RETVAL_FALSE;
@@ -2352,11 +2347,11 @@ PHP_FUNCTION(mb_strlen)
    Find position of first occurrence of a string within another */
 PHP_FUNCTION(mb_strpos)
 {
-	int n, reverse = 0;
+	int reverse = 0;
 	zend_long offset = 0, slen;
 	mbfl_string haystack, needle;
 	char *enc_name = NULL;
-	size_t enc_name_len, haystack_len, needle_len;
+	size_t enc_name_len, n;
 
 	mbfl_string_init(&haystack);
 	mbfl_string_init(&needle);
@@ -2365,21 +2360,10 @@ PHP_FUNCTION(mb_strpos)
 	needle.no_language = MBSTRG(language);
 	needle.no_encoding = MBSTRG(current_internal_encoding)->no_encoding;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss|ls", (char **)&haystack.val, &haystack_len, (char **)&needle.val, &needle_len, &offset, &enc_name, &enc_name_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss|ls", (char **)&haystack.val, &haystack.len, (char **)&needle.val, &needle.len, &offset, &enc_name, &enc_name_len) == FAILURE) {
 		return;
 	}
 
-	if (ZEND_SIZE_T_UINT_OVFL(haystack_len)) {
-			php_error_docref(NULL, E_WARNING, "Haystack length overflows the max allowed length of %u", UINT_MAX);
-			return;
-	} else if (ZEND_SIZE_T_UINT_OVFL(needle_len)) {
-			php_error_docref(NULL, E_WARNING, "Needle length overflows the max allowed length of %u", UINT_MAX);
-			return;
-	}
-
-	haystack.len = (uint32_t)haystack_len;
-	needle.len = (uint32_t)needle_len;
-
 	if (enc_name != NULL) {
 		haystack.no_encoding = needle.no_encoding = mbfl_name2no_encoding(enc_name);
 		if (haystack.no_encoding == mbfl_no_encoding_invalid) {
@@ -2402,7 +2386,7 @@ PHP_FUNCTION(mb_strpos)
 	}
 
 	n = mbfl_strpos(&haystack, &needle, offset, reverse);
-	if (n >= 0) {
+	if (!mbfl_is_error(n)) {
 		RETVAL_LONG(n);
 	} else {
 		switch (-n) {
@@ -2430,12 +2414,11 @@ PHP_FUNCTION(mb_strpos)
    Find position of last occurrence of a string within another */
 PHP_FUNCTION(mb_strrpos)
 {
-	int n;
 	mbfl_string haystack, needle;
 	char *enc_name = NULL;
-	size_t enc_name_len, haystack_len, needle_len;
+	size_t enc_name_len;
 	zval *zoffset = NULL;
-	long offset = 0, str_flg;
+	long offset = 0, str_flg, n;
 	char *enc_name2 = NULL;
 	int enc_name_len2;
 
@@ -2446,21 +2429,10 @@ PHP_FUNCTION(mb_strrpos)
 	needle.no_language = MBSTRG(language);
 	needle.no_encoding = MBSTRG(current_internal_encoding)->no_encoding;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss|zs", (char **)&haystack.val, &haystack_len, (char **)&needle.val, &needle_len, &zoffset, &enc_name, &enc_name_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss|zs", (char **)&haystack.val, &haystack.len, (char **)&needle.val, &needle.len, &zoffset, &enc_name, &enc_name_len) == FAILURE) {
 		return;
 	}
 
-	if (ZEND_SIZE_T_UINT_OVFL(haystack_len)) {
-			php_error_docref(NULL, E_WARNING, "Haystack length overflows the max allowed length of %u", UINT_MAX);
-			return;
-	} else if (ZEND_SIZE_T_UINT_OVFL(needle_len)) {
-			php_error_docref(NULL, E_WARNING, "Needle length overflows the max allowed length of %u", UINT_MAX);
-			return;
-	}
-
-	haystack.len = (uint32_t)haystack_len;
-	needle.len = (uint32_t)needle_len;
-
 	if (zoffset) {
 		if (Z_TYPE_P(zoffset) == IS_STRING) {
 			enc_name2     = Z_STRVAL_P(zoffset);
@@ -2510,15 +2482,8 @@ PHP_FUNCTION(mb_strrpos)
 		}
 	}
 
-	if (haystack.len <= 0) {
-		RETURN_FALSE;
-	}
-	if (needle.len <= 0) {
-		RETURN_FALSE;
-	}
-
 	{
-		int haystack_char_len = mbfl_strlen(&haystack);
+		size_t haystack_char_len = mbfl_strlen(&haystack);
 		if ((offset > 0 && offset > haystack_char_len) ||
 			(offset < 0 && -offset > haystack_char_len)) {
 			php_error_docref(NULL, E_WARNING, "Offset is greater than the length of haystack string");
@@ -2527,7 +2492,7 @@ PHP_FUNCTION(mb_strrpos)
 	}
 
 	n = mbfl_strpos(&haystack, &needle, offset, 1);
-	if (n >= 0) {
+	if (!mbfl_is_error(n)) {
 		RETVAL_LONG(n);
 	} else {
 		RETVAL_FALSE;
@@ -2539,34 +2504,24 @@ PHP_FUNCTION(mb_strrpos)
    Finds position of first occurrence of a string within another, case insensitive */
 PHP_FUNCTION(mb_stripos)
 {
-	int n = -1;
+	size_t n = (size_t) -1;
 	zend_long offset = 0;
 	mbfl_string haystack, needle;
 	const char *from_encoding = MBSTRG(current_internal_encoding)->mime_name;
-	size_t from_encoding_len, haystack_len, needle_len;
+	size_t from_encoding_len;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss|ls", (char **)&haystack.val, &haystack_len, (char **)&needle.val, &needle_len, &offset, &from_encoding, &from_encoding_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss|ls", (char **)&haystack.val, &haystack.len, (char **)&needle.val, &needle.len, &offset, &from_encoding, &from_encoding_len) == FAILURE) {
 		return;
 	}
 
-	if (ZEND_SIZE_T_UINT_OVFL(haystack_len)) {
-			php_error_docref(NULL, E_WARNING, "Haystack length overflows the max allowed length of %u", UINT_MAX);
-			return;
-	} else if (ZEND_SIZE_T_UINT_OVFL(needle_len)) {
-			php_error_docref(NULL, E_WARNING, "Needle length overflows the max allowed length of %u", UINT_MAX);
-			return;
-	}
-
-	haystack.len = (uint32_t)haystack_len;
-	needle.len = (uint32_t)needle_len;
-
 	if (needle.len == 0) {
 		php_error_docref(NULL, E_WARNING, "Empty delimiter");
 		RETURN_FALSE;
 	}
+
 	n = php_mb_stripos(0, (char *)haystack.val, haystack.len, (char *)needle.val, needle.len, offset, from_encoding);
 
-	if (n >= 0) {
+	if (!mbfl_is_error(n)) {
 		RETVAL_LONG(n);
 	} else {
 		RETVAL_FALSE;
@@ -2578,30 +2533,19 @@ PHP_FUNCTION(mb_stripos)
    Finds position of last occurrence of a string within another, case insensitive */
 PHP_FUNCTION(mb_strripos)
 {
-	int n = -1;
+	size_t n = (size_t) -1;
 	zend_long offset = 0;
 	mbfl_string haystack, needle;
 	const char *from_encoding = MBSTRG(current_internal_encoding)->mime_name;
-	size_t from_encoding_len, haystack_len, needle_len;
+	size_t from_encoding_len;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss|ls", (char **)&haystack.val, &haystack_len, (char **)&needle.val, &needle_len, &offset, &from_encoding, &from_encoding_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss|ls", (char **)&haystack.val, &haystack.len, (char **)&needle.val, &needle.len, &offset, &from_encoding, &from_encoding_len) == FAILURE) {
 		return;
 	}
 
-	if (ZEND_SIZE_T_UINT_OVFL(haystack_len)) {
-			php_error_docref(NULL, E_WARNING, "Haystack length overflows the max allowed length of %u", UINT_MAX);
-			return;
-	} else if (ZEND_SIZE_T_UINT_OVFL(needle_len)) {
-			php_error_docref(NULL, E_WARNING, "Needle length overflows the max allowed length of %u", UINT_MAX);
-			return;
-	}
-
-	haystack.len = (uint32_t)haystack_len;
-	needle.len = (uint32_t)needle_len;
-
 	n = php_mb_stripos(1, (char *)haystack.val, haystack.len, (char *)needle.val, needle.len, offset, from_encoding);
 
-	if (n >= 0) {
+	if (!mbfl_is_error(n)) {
 		RETVAL_LONG(n);
 	} else {
 		RETVAL_FALSE;
@@ -2613,10 +2557,10 @@ PHP_FUNCTION(mb_strripos)
    Finds first occurrence of a string within another */
 PHP_FUNCTION(mb_strstr)
 {
-	int n, len, mblen;
+	size_t n;
 	mbfl_string haystack, needle, result, *ret = NULL;
 	char *enc_name = NULL;
-	size_t enc_name_len, haystack_len, needle_len;
+	size_t enc_name_len;
 	zend_bool part = 0;
 
 	mbfl_string_init(&haystack);
@@ -2626,21 +2570,10 @@ PHP_FUNCTION(mb_strstr)
 	needle.no_language = MBSTRG(language);
 	needle.no_encoding = MBSTRG(current_internal_encoding)->no_encoding;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss|bs", (char **)&haystack.val, &haystack_len, (char **)&needle.val, &needle_len, &part, &enc_name, &enc_name_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss|bs", (char **)&haystack.val, &haystack.len, (char **)&needle.val, &needle.len, &part, &enc_name, &enc_name_len) == FAILURE) {
 		return;
 	}
 
-	if (ZEND_SIZE_T_UINT_OVFL(haystack_len)) {
-			php_error_docref(NULL, E_WARNING, "Haystack length overflows the max allowed length of %u", UINT_MAX);
-			return;
-	} else if (ZEND_SIZE_T_UINT_OVFL(needle_len)) {
-			php_error_docref(NULL, E_WARNING, "Needle length overflows the max allowed length of %u", UINT_MAX);
-			return;
-	}
-
-	haystack.len = (uint32_t)haystack_len;
-	needle.len = (uint32_t)needle_len;
-
 	if (enc_name != NULL) {
 		haystack.no_encoding = needle.no_encoding = mbfl_name2no_encoding(enc_name);
 		if (haystack.no_encoding == mbfl_no_encoding_invalid) {
@@ -2649,13 +2582,14 @@ PHP_FUNCTION(mb_strstr)
 		}
 	}
 
-	if (needle.len <= 0) {
+	if (needle.len == 0) {
 		php_error_docref(NULL, E_WARNING, "Empty delimiter");
 		RETURN_FALSE;
 	}
+
 	n = mbfl_strpos(&haystack, &needle, 0, 0);
-	if (n >= 0) {
-		mblen = mbfl_strlen(&haystack);
+	if (!mbfl_is_error(n)) {
+		size_t mblen = mbfl_strlen(&haystack);
 		if (part) {
 			ret = mbfl_substr(&haystack, &result, 0, n);
 			if (ret != NULL) {
@@ -2666,7 +2600,7 @@ PHP_FUNCTION(mb_strstr)
 				RETVAL_FALSE;
 			}
 		} else {
-			len = (mblen - n);
+			size_t len = (mblen - n);
 			ret = mbfl_substr(&haystack, &result, n, len);
 			if (ret != NULL) {
 				// TODO: avoid reallocation ???
@@ -2686,10 +2620,10 @@ PHP_FUNCTION(mb_strstr)
    Finds the last occurrence of a character in a string within another */
 PHP_FUNCTION(mb_strrchr)
 {
-	int n, len, mblen;
+	size_t n;
 	mbfl_string haystack, needle, result, *ret = NULL;
 	char *enc_name = NULL;
-	size_t enc_name_len, haystack_len, needle_len;
+	size_t enc_name_len;
 	zend_bool part = 0;
 
 	mbfl_string_init(&haystack);
@@ -2699,21 +2633,10 @@ PHP_FUNCTION(mb_strrchr)
 	needle.no_language = MBSTRG(language);
 	needle.no_encoding = MBSTRG(current_internal_encoding)->no_encoding;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss|bs", (char **)&haystack.val, &haystack_len, (char **)&needle.val, &needle_len, &part, &enc_name, &enc_name_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss|bs", (char **)&haystack.val, &haystack.len, (char **)&needle.val, &needle.len, &part, &enc_name, &enc_name_len) == FAILURE) {
 		return;
 	}
 
-	if (ZEND_SIZE_T_UINT_OVFL(haystack_len)) {
-			php_error_docref(NULL, E_WARNING, "Haystack length overflows the max allowed length of %u", UINT_MAX);
-			return;
-	} else if (ZEND_SIZE_T_UINT_OVFL(needle_len)) {
-			php_error_docref(NULL, E_WARNING, "Needle length overflows the max allowed length of %u", UINT_MAX);
-			return;
-	}
-
-	haystack.len = (uint32_t)haystack_len;
-	needle.len = (uint32_t)needle_len;
-
 	if (enc_name != NULL) {
 		haystack.no_encoding = needle.no_encoding = mbfl_name2no_encoding(enc_name);
 		if (haystack.no_encoding == mbfl_no_encoding_invalid) {
@@ -2722,15 +2645,16 @@ PHP_FUNCTION(mb_strrchr)
 		}
 	}
 
-	if (haystack.len <= 0) {
+	if (haystack.len == 0) {
 		RETURN_FALSE;
 	}
-	if (needle.len <= 0) {
+	if (needle.len == 0) {
 		RETURN_FALSE;
 	}
+
 	n = mbfl_strpos(&haystack, &needle, 0, 1);
-	if (n >= 0) {
-		mblen = mbfl_strlen(&haystack);
+	if (!mbfl_is_error(n)) {
+		size_t mblen = mbfl_strlen(&haystack);
 		if (part) {
 			ret = mbfl_substr(&haystack, &result, 0, n);
 			if (ret != NULL) {
@@ -2741,7 +2665,7 @@ PHP_FUNCTION(mb_strrchr)
 				RETVAL_FALSE;
 			}
 		} else {
-			len = (mblen - n);
+			size_t len = (mblen - n);
 			ret = mbfl_substr(&haystack, &result, n, len);
 			if (ret != NULL) {
 				// TODO: avoid reallocation ???
@@ -2762,8 +2686,7 @@ PHP_FUNCTION(mb_strrchr)
 PHP_FUNCTION(mb_stristr)
 {
 	zend_bool part = 0;
-	size_t from_encoding_len, len, mblen, haystack_len, needle_len;
-	int n;
+	size_t from_encoding_len, n, len, mblen;
 	mbfl_string haystack, needle, result, *ret = NULL;
 	const char *from_encoding = MBSTRG(current_internal_encoding)->mime_name;
 	mbfl_string_init(&haystack);
@@ -2773,22 +2696,10 @@ PHP_FUNCTION(mb_stristr)
 	needle.no_language = MBSTRG(language);
 	needle.no_encoding = MBSTRG(current_internal_encoding)->no_encoding;
 
-
-	if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss|bs", (char **)&haystack.val, &haystack_len, (char **)&needle.val, &needle_len, &part, &from_encoding, &from_encoding_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss|bs", (char **)&haystack.val, &haystack.len, (char **)&needle.val, &needle.len, &part, &from_encoding, &from_encoding_len) == FAILURE) {
 		return;
 	}
 
-	if (ZEND_SIZE_T_UINT_OVFL(haystack_len)) {
-			php_error_docref(NULL, E_WARNING, "Haystack length overflows the max allowed length of %u", UINT_MAX);
-			return;
-	} else if (ZEND_SIZE_T_UINT_OVFL(needle_len)) {
-			php_error_docref(NULL, E_WARNING, "Needle length overflows the max allowed length of %u", UINT_MAX);
-			return;
-	}
-
-	haystack.len = (uint32_t)haystack_len;
-	needle.len = (uint32_t)needle_len;
-
 	if (!needle.len) {
 		php_error_docref(NULL, E_WARNING, "Empty delimiter");
 		RETURN_FALSE;
@@ -2801,8 +2712,7 @@ PHP_FUNCTION(mb_stristr)
 	}
 
 	n = php_mb_stripos(0, (char *)haystack.val, haystack.len, (char *)needle.val, needle.len, 0, from_encoding);
-
-	if (n <0) {
+	if (mbfl_is_error(n)) {
 		RETURN_FALSE;
 	}
 
@@ -2836,8 +2746,8 @@ PHP_FUNCTION(mb_stristr)
 PHP_FUNCTION(mb_strrichr)
 {
 	zend_bool part = 0;
-	int n, len, mblen;
-	size_t from_encoding_len, haystack_len, needle_len;
+	size_t n, len, mblen;
+	size_t from_encoding_len;
 	mbfl_string haystack, needle, result, *ret = NULL;
 	const char *from_encoding = MBSTRG(current_internal_encoding)->name;
 	mbfl_string_init(&haystack);
@@ -2848,21 +2758,10 @@ PHP_FUNCTION(mb_strrichr)
 	needle.no_encoding = MBSTRG(current_internal_encoding)->no_encoding;
 
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss|bs", (char **)&haystack.val, &haystack_len, (char **)&needle.val, &needle_len, &part, &from_encoding, &from_encoding_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss|bs", (char **)&haystack.val, &haystack.len, (char **)&needle.val, &needle.len, &part, &from_encoding, &from_encoding_len) == FAILURE) {
 		return;
 	}
 
-	if (ZEND_SIZE_T_UINT_OVFL(haystack_len)) {
-			php_error_docref(NULL, E_WARNING, "Haystack length overflows the max allowed length of %u", UINT_MAX);
-			return;
-	} else if (ZEND_SIZE_T_UINT_OVFL(needle_len)) {
-			php_error_docref(NULL, E_WARNING, "Needle length overflows the max allowed length of %u", UINT_MAX);
-			return;
-	}
-
-	haystack.len = (uint32_t)haystack_len;
-	needle.len = (uint32_t)needle_len;
-
 	haystack.no_encoding = needle.no_encoding = mbfl_name2no_encoding(from_encoding);
 	if (haystack.no_encoding == mbfl_no_encoding_invalid) {
 		php_error_docref(NULL, E_WARNING, "Unknown encoding \"%s\"", from_encoding);
@@ -2870,8 +2769,7 @@ PHP_FUNCTION(mb_strrichr)
 	}
 
 	n = php_mb_stripos(1, (char *)haystack.val, haystack.len, (char *)needle.val, needle.len, 0, from_encoding);
-
-	if (n <0) {
+	if (mbfl_is_error(n)) {
 		RETURN_FALSE;
 	}
 
@@ -2904,10 +2802,10 @@ PHP_FUNCTION(mb_strrichr)
    Count the number of substring occurrences */
 PHP_FUNCTION(mb_substr_count)
 {
-	int n;
+	size_t n;
 	mbfl_string haystack, needle;
 	char *enc_name = NULL;
-	size_t enc_name_len, haystack_len, needle_len;
+	size_t enc_name_len;
 
 	mbfl_string_init(&haystack);
 	mbfl_string_init(&needle);
@@ -2916,21 +2814,10 @@ PHP_FUNCTION(mb_substr_count)
 	needle.no_language = MBSTRG(language);
 	needle.no_encoding = MBSTRG(current_internal_encoding)->no_encoding;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss|s", (char **)&haystack.val, &haystack_len, (char **)&needle.val, &needle_len, &enc_name, &enc_name_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss|s", (char **)&haystack.val, &haystack.len, (char **)&needle.val, &needle.len, &enc_name, &enc_name_len) == FAILURE) {
 		return;
 	}
 
-	if (ZEND_SIZE_T_UINT_OVFL(haystack_len)) {
-			php_error_docref(NULL, E_WARNING, "Haystack length overflows the max allowed length of %u", UINT_MAX);
-			return;
-	} else if (ZEND_SIZE_T_UINT_OVFL(needle_len)) {
-			php_error_docref(NULL, E_WARNING, "Needle length overflows the max allowed length of %u", UINT_MAX);
-			return;
-	}
-
-	haystack.len = (uint32_t)haystack_len;
-	needle.len = (uint32_t)needle_len;
-
 	if (enc_name != NULL) {
 		haystack.no_encoding = needle.no_encoding = mbfl_name2no_encoding(enc_name);
 		if (haystack.no_encoding == mbfl_no_encoding_invalid) {
@@ -2939,13 +2826,13 @@ PHP_FUNCTION(mb_substr_count)
 		}
 	}
 
-	if (needle.len <= 0) {
+	if (needle.len == 0) {
 		php_error_docref(NULL, E_WARNING, "Empty substring");
 		RETURN_FALSE;
 	}
 
 	n = mbfl_substr_count(&haystack, &needle);
-	if (n >= 0) {
+	if (!mbfl_is_error(n)) {
 		RETVAL_LONG(n);
 	} else {
 		RETVAL_FALSE;
@@ -2959,7 +2846,7 @@ PHP_FUNCTION(mb_substr)
 {
 	char *str, *encoding = NULL;
 	zend_long from, len;
-	int mblen;
+	size_t mblen;
 	size_t str_len, encoding_len;
 	zend_bool len_is_null = 1;
 	mbfl_string string, result, *ret;
@@ -3042,7 +2929,7 @@ PHP_FUNCTION(mb_strcut)
 {
 	char *encoding = NULL;
 	zend_long from, len;
-	size_t encoding_len, string_len;
+	size_t encoding_len;
 	zend_bool len_is_null = 1;
 	mbfl_string string, result, *ret;
 
@@ -3050,17 +2937,10 @@ PHP_FUNCTION(mb_strcut)
 	string.no_language = MBSTRG(language);
 	string.no_encoding = MBSTRG(current_internal_encoding)->no_encoding;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS(), "sl|l!s", (char **)&string.val, &string_len, &from, &len, &len_is_null, &encoding, &encoding_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS(), "sl|l!s", (char **)&string.val, &string.len, &from, &len, &len_is_null, &encoding, &encoding_len) == FAILURE) {
 		return;
 	}
 
-	if (ZEND_SIZE_T_UINT_OVFL(string_len)) {
-			php_error_docref(NULL, E_WARNING, "String length overflows the max allowed length of %u", UINT_MAX);
-			return;
-	}
-
-	string.len = (uint32_t)string_len;
-
 	if (encoding) {
 		string.no_encoding = mbfl_name2no_encoding(encoding);
 		if (string.no_encoding == mbfl_no_encoding_invalid) {
@@ -3112,27 +2992,20 @@ PHP_FUNCTION(mb_strcut)
    Gets terminal width of a string */
 PHP_FUNCTION(mb_strwidth)
 {
-	int n;
+	size_t n;
 	mbfl_string string;
 	char *enc_name = NULL;
-	size_t enc_name_len, string_len;
+	size_t enc_name_len;
 
 	mbfl_string_init(&string);
 
 	string.no_language = MBSTRG(language);
 	string.no_encoding = MBSTRG(current_internal_encoding)->no_encoding;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|s", (char **)&string.val, &string_len, &enc_name, &enc_name_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|s", (char **)&string.val, &string.len, &enc_name, &enc_name_len) == FAILURE) {
 		return;
 	}
 
-	if (ZEND_SIZE_T_UINT_OVFL(string_len)) {
-			php_error_docref(NULL, E_WARNING, "String length overflows the max allowed length of %u", UINT_MAX);
-			return;
-	}
-
-	string.len = (uint32_t)string_len;
-
 	if (enc_name != NULL) {
 		string.no_encoding = mbfl_name2no_encoding(enc_name);
 		if (string.no_encoding == mbfl_no_encoding_invalid) {
@@ -3142,7 +3015,7 @@ PHP_FUNCTION(mb_strwidth)
 	}
 
 	n = mbfl_strwidth(&string);
-	if (n >= 0) {
+	if (!mbfl_is_error(n)) {
 		RETVAL_LONG(n);
 	} else {
 		RETVAL_FALSE;
@@ -3841,7 +3714,7 @@ PHP_FUNCTION(mb_decode_mimeheader)
    Conversion between full-width character and half-width character (Japanese) */
 PHP_FUNCTION(mb_convert_kana)
 {
-	int opt, i;
+	int opt;
 	mbfl_string string, result, *ret;
 	char *optstr = NULL;
 	size_t optstr_len;
@@ -3866,8 +3739,7 @@ PHP_FUNCTION(mb_convert_kana)
 	/* option */
 	if (optstr != NULL) {
 		char *p = optstr;
-		int n = optstr_len;
-		i = 0;
+		size_t i = 0, n = optstr_len;
 		opt = 0;
 		while (i < n) {
 			i++;
@@ -5584,15 +5456,15 @@ MBSTRING_API char *php_mb_safe_strrchr(const char *s, unsigned int c, size_t nby
 
 /* {{{ MBSTRING_API int php_mb_stripos()
  */
-MBSTRING_API int php_mb_stripos(int mode, const char *old_haystack, unsigned int old_haystack_len, const char *old_needle, unsigned int old_needle_len, long offset, const char *from_encoding)
+MBSTRING_API size_t php_mb_stripos(int mode, const char *old_haystack, size_t old_haystack_len, const char *old_needle, size_t old_needle_len, long offset, const char *from_encoding)
 {
-	int n = -1;
+	size_t n = (size_t) -1;
 	mbfl_string haystack, needle;
 	const mbfl_encoding *enc;
 
 	enc = php_mb_get_encoding(from_encoding);
 	if (!enc) {
-		return -1;
+		return (size_t) -1;
 	}
 
 	mbfl_string_init(&haystack);
@@ -5611,7 +5483,7 @@ MBSTRING_API int php_mb_stripos(int mode, const char *old_haystack, unsigned int
 			break;
 		}
 
-		if (haystack.len <= 0) {
+		if (haystack.len == 0) {
 			break;
 		}
 
@@ -5622,12 +5494,12 @@ MBSTRING_API int php_mb_stripos(int mode, const char *old_haystack, unsigned int
 			break;
 		}
 
-		if (needle.len <= 0) {
+		if (needle.len == 0) {
 			break;
 		}
 
  		{
- 			int haystack_char_len = mbfl_strlen(&haystack);
+ 			size_t haystack_char_len = mbfl_strlen(&haystack);
 
  			if (mode) {
  				if ((offset > 0 && offset > haystack_char_len) ||
diff --git a/ext/mbstring/mbstring.h b/ext/mbstring/mbstring.h
index 207227b036..6862bf0392 100644
--- a/ext/mbstring/mbstring.h
+++ b/ext/mbstring/mbstring.h
@@ -153,12 +153,7 @@ MBSTRING_API int php_mb_check_encoding_list(const char *encoding_list);
 MBSTRING_API size_t php_mb_mbchar_bytes_ex(const char *s, const mbfl_encoding *enc);
 MBSTRING_API size_t php_mb_mbchar_bytes(const char *s);
 
-MBSTRING_API int php_mb_encoding_detector_ex(const char *arg_string, int arg_length,
-											 char *arg_list);
-
-MBSTRING_API int php_mb_encoding_converter_ex(char **str, int *len, const char *encoding_to,
-											  const char *encoding_from);
-MBSTRING_API int php_mb_stripos(int mode, const char *old_haystack, unsigned int old_haystack_len, const char *old_needle, unsigned int old_needle_len, long offset, const char *from_encoding);
+MBSTRING_API size_t php_mb_stripos(int mode, const char *old_haystack, size_t old_haystack_len, const char *old_needle, size_t old_needle_len, long offset, const char *from_encoding);
 MBSTRING_API int php_mb_check_encoding(const char *input, size_t length, const char *enc);
 
 /* internal use only */