Remove unused functions from mbstring

- mbfl_buffer_converter_reset
- mbfl_buffer_converter_strncat
- mbfl_buffer_converter_getbuffer
- mbfl_oddlen
- mbfl_filter_output_pipe_flush
- mbfl_memory_device_output2
- mbfl_memory_device_output4
- mbfl_is_support_encoding
- mbfl_buffer_converter_feed2
- _php_mb_regex_globals_dtor
- mime_header_encoder_feed
- mime_header_decoder_feed
- mbfl_convert_filter_feed

diff --git a/ext/mbstring/libmbfl/mbfl/mbfilter.c b/ext/mbstring/libmbfl/mbfl/mbfilter.c
index 3eb8cd196756bb8bd0037d99c9997379a54a3623..e8eb61e0f3d18606b1032134be7d6cd20e94585c 100644 (file)
--- a/ext/mbstring/libmbfl/mbfl/mbfilter.c
+++ b/ext/mbstring/libmbfl/mbfl/mbfilter.c
@@ -172,12 +172,6 @@ mbfl_buffer_converter_delete(mbfl_buffer_converter *convd)
        }
 }
 
-void
-mbfl_buffer_converter_reset(mbfl_buffer_converter *convd)
-{
-       mbfl_memory_device_reset(&convd->device);
-}
-
 int
 mbfl_buffer_converter_illegal_mode(mbfl_buffer_converter *convd, int mode)
 {
@@ -210,45 +204,16 @@ mbfl_buffer_converter_illegal_substchar(mbfl_buffer_converter *convd, int substc
        return 1;
 }
 
-int
-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);
-
-       if (convd != NULL && p != NULL) {
-               filter = convd->filter1;
-               if (filter != NULL) {
-                       filter_function = filter->filter_function;
-                       while (n > 0) {
-                               if ((*filter_function)(*p++, filter) < 0) {
-                                       break;
-                               }
-                               n--;
-                       }
-               }
-       }
-
-       return n;
-}
-
-int
-mbfl_buffer_converter_feed(mbfl_buffer_converter *convd, mbfl_string *string)
-{
-       return mbfl_buffer_converter_feed2(convd, string, NULL);
-}
-
-int
-mbfl_buffer_converter_feed2(mbfl_buffer_converter *convd, mbfl_string *string, size_t *loc)
+size_t mbfl_buffer_converter_feed(mbfl_buffer_converter *convd, mbfl_string *string)
 {
        size_t n;
        unsigned char *p;
        mbfl_convert_filter *filter;
        int (*filter_function)(int c, mbfl_convert_filter *filter);
 
-       if (convd == NULL || string == NULL) {
-               return -1;
-       }
+       ZEND_ASSERT(convd);
+       ZEND_ASSERT(string);
+
        mbfl_memory_device_realloc(&convd->device, convd->device.pos + string->len, string->len/4);
        /* feed data */
        n = string->len;
@@ -259,18 +224,12 @@ mbfl_buffer_converter_feed2(mbfl_buffer_converter *convd, mbfl_string *string, s
                filter_function = filter->filter_function;
                while (n > 0) {
                        if ((*filter_function)(*p++, filter) < 0) {
-                               if (loc) {
-                                       *loc = p - string->val;
-                               }
-                               return -1;
+                               return p - string->val;
                        }
                        n--;
                }
        }
-       if (loc) {
-               *loc = p - string->val;
-       }
-       return 0;
+       return p - string->val;
 }
 
 
@@ -291,20 +250,6 @@ mbfl_buffer_converter_flush(mbfl_buffer_converter *convd)
        return 0;
 }
 
-mbfl_string *
-mbfl_buffer_converter_getbuffer(mbfl_buffer_converter *convd, mbfl_string *result)
-{
-       if (convd != NULL && result != NULL && convd->device.buffer != NULL) {
-               result->encoding = convd->to;
-               result->val = convd->device.buffer;
-               result->len = convd->device.pos;
-       } else {
-               result = NULL;
-       }
-
-       return result;
-}
-
 mbfl_string *
 mbfl_buffer_converter_result(mbfl_buffer_converter *convd, mbfl_string *result)
 {
@@ -755,44 +700,6 @@ retry:
        return c;
 }
 
-/*
- *     oddlen
- */
-size_t
-mbfl_oddlen(mbfl_string *string)
-{
-       size_t len, n, k;
-       unsigned char *p;
-       const mbfl_encoding *encoding = string->encoding;
-
-       len = 0;
-       if (encoding->flag & MBFL_ENCTYPE_SBCS) {
-               return 0;
-       } else if (encoding->flag & (MBFL_ENCTYPE_WCS2BE | MBFL_ENCTYPE_WCS2LE)) {
-               return len % 2;
-       } else if (encoding->flag & (MBFL_ENCTYPE_WCS4BE | MBFL_ENCTYPE_WCS4LE)) {
-               return len % 4;
-       } else if (encoding->mblen_table != NULL) {
-               const unsigned char *mbtab = encoding->mblen_table;
-               n = 0;
-               p = string->val;
-               k = string->len;
-               /* count */
-               if (p != NULL) {
-                       while (n < k) {
-                               unsigned m = mbtab[*p];
-                               n += m;
-                               p += m;
-                       };
-               }
-               return n-k;
-       } else {
-               /* how can i do ? */
-               return 0;
-       }
-       /* NOT REACHED */
-}
-
 static const unsigned char *mbfl_find_offset_utf8(
                const unsigned char *str, const unsigned char *end, ssize_t offset) {
        if (offset < 0) {
@@ -2007,12 +1914,6 @@ mime_header_encoder_delete(struct mime_header_encoder_data *pe)
        }
 }
 
-int
-mime_header_encoder_feed(int c, struct mime_header_encoder_data *pe)
-{
-       return (*pe->conv1_filter->filter_function)(c, pe->conv1_filter);
-}
-
 mbfl_string *
 mbfl_mime_header_encode(
     mbfl_string *string,
@@ -2301,12 +2202,6 @@ mime_header_decoder_delete(struct mime_header_decoder_data *pd)
        }
 }
 
-int
-mime_header_decoder_feed(int c, struct mime_header_decoder_data *pd)
-{
-       return mime_header_decoder_collector(c, pd);
-}
-
 mbfl_string *
 mbfl_mime_header_decode(
     mbfl_string *string,

diff --git a/ext/mbstring/libmbfl/mbfl/mbfilter.h b/ext/mbstring/libmbfl/mbfl/mbfilter.h
index b672b474742de7e65da9321b0f03425628dcd4b7..c57d0eac9faf298210fbf418e0238dddf92bb4fb 100644 (file)
--- a/ext/mbstring/libmbfl/mbfl/mbfilter.h
+++ b/ext/mbstring/libmbfl/mbfl/mbfilter.h
@@ -143,14 +143,10 @@ struct _mbfl_buffer_converter {
 
 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);
 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, 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, size_t *loc);
+MBFLAPI extern size_t mbfl_buffer_converter_feed(mbfl_buffer_converter *convd, mbfl_string *string);
 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 size_t mbfl_buffer_illegalchars(mbfl_buffer_converter *convd);
@@ -196,12 +192,6 @@ static inline int mbfl_is_error(size_t len) {
 MBFLAPI extern size_t
 mbfl_strlen(const mbfl_string *string);
 
-/*
- * oddlen
- */
-MBFLAPI extern size_t
-mbfl_oddlen(mbfl_string *string);
-
 #define MBFL_ERROR_NOT_FOUND ((size_t) -1)
 #define MBFL_ERROR_ENCODING ((size_t) -4)
 #define MBFL_ERROR_EMPTY ((size_t) -8)
@@ -263,9 +253,6 @@ mime_header_encoder_new(
 MBFLAPI extern void
 mime_header_encoder_delete(struct mime_header_encoder_data *pe);
 
-MBFLAPI extern int
-mime_header_encoder_feed(int c, struct mime_header_encoder_data *pe);
-
 MBFLAPI extern mbfl_string *
 mime_header_encoder_result(struct mime_header_encoder_data *pe, mbfl_string *result);
 
@@ -288,9 +275,6 @@ mime_header_decoder_new(const mbfl_encoding *outcode);
 MBFLAPI extern void
 mime_header_decoder_delete(struct mime_header_decoder_data *pd);
 
-MBFLAPI extern int
-mime_header_decoder_feed(int c, struct mime_header_decoder_data *pd);
-
 MBFLAPI extern mbfl_string *
 mime_header_decoder_result(struct mime_header_decoder_data *pd, mbfl_string *result);
 

diff --git a/ext/mbstring/libmbfl/mbfl/mbfl_convert.c b/ext/mbstring/libmbfl/mbfl/mbfl_convert.c
index 28539aa4baac44b71b3c6205dc37f6ed6e553d32..53a722f8138ba6c5efa4d360193fd109b7775e0c 100644 (file)
--- a/ext/mbstring/libmbfl/mbfl/mbfl_convert.c
+++ b/ext/mbstring/libmbfl/mbfl/mbfl_convert.c
@@ -220,12 +220,6 @@ mbfl_convert_filter_delete(mbfl_convert_filter *filter)
        }
 }
 
-int
-mbfl_convert_filter_feed(int c, mbfl_convert_filter *filter)
-{
-       return (*filter->filter_function)(c, filter);
-}
-
 int
 mbfl_convert_filter_feed_string(mbfl_convert_filter *filter, const unsigned char *p, size_t len) {
        while (len > 0) {

diff --git a/ext/mbstring/libmbfl/mbfl/mbfl_convert.h b/ext/mbstring/libmbfl/mbfl/mbfl_convert.h
index 31e54c61d18bf6f34ffeaac08749cd1a37dcfb99..852e669dac9139fd319a59e65bcb07d920aefcdc 100644 (file)
--- a/ext/mbstring/libmbfl/mbfl/mbfl_convert.h
+++ b/ext/mbstring/libmbfl/mbfl/mbfl_convert.h
@@ -68,7 +68,6 @@ MBFLAPI extern mbfl_convert_filter *mbfl_convert_filter_new2(
     int (*flush_function)(void *),
     void *data );
 MBFLAPI extern void mbfl_convert_filter_delete(mbfl_convert_filter *filter);
-MBFLAPI extern int mbfl_convert_filter_feed(int c, mbfl_convert_filter *filter);
 MBFLAPI extern int mbfl_convert_filter_feed_string(mbfl_convert_filter *filter, const 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);

diff --git a/ext/mbstring/libmbfl/mbfl/mbfl_encoding.c b/ext/mbstring/libmbfl/mbfl/mbfl_encoding.c
index 4feaadd542663cc8a03155cbd844821752d40c86..a1522e2c30f775e327f36e10f0ffc09feb210f20 100644 (file)
--- a/ext/mbstring/libmbfl/mbfl/mbfl_encoding.c
+++ b/ext/mbstring/libmbfl/mbfl/mbfl_encoding.c
@@ -308,16 +308,3 @@ mbfl_no2preferred_mime_name(enum mbfl_no_encoding no_encoding)
                return NULL;
        }
 }
-
-int
-mbfl_is_support_encoding(const char *name)
-{
-       const mbfl_encoding *encoding;
-
-       encoding = mbfl_name2encoding(name);
-       if (encoding == NULL) {
-               return 0;
-       } else {
-               return 1;
-       }
-}

diff --git a/ext/mbstring/libmbfl/mbfl/mbfl_encoding.h b/ext/mbstring/libmbfl/mbfl/mbfl_encoding.h
index c3a9c0affc7050a95be10d4ddd2fedf776142ac8..0b39153c9d6454a73d9eeaf94d311c50181949ff 100644 (file)
--- a/ext/mbstring/libmbfl/mbfl/mbfl_encoding.h
+++ b/ext/mbstring/libmbfl/mbfl/mbfl_encoding.h
@@ -158,7 +158,6 @@ MBFLAPI extern enum mbfl_no_encoding mbfl_name2no_encoding(const char *name);
 MBFLAPI extern const mbfl_encoding ** mbfl_get_supported_encodings();
 MBFLAPI extern const char * mbfl_no_encoding2name(enum mbfl_no_encoding no_encoding);
 MBFLAPI extern const char * mbfl_no2preferred_mime_name(enum mbfl_no_encoding no_encoding);
-MBFLAPI extern int mbfl_is_support_encoding(const char *name);
 
 
 #endif /* MBFL_ENCODING_H */

diff --git a/ext/mbstring/libmbfl/mbfl/mbfl_filter_output.c b/ext/mbstring/libmbfl/mbfl/mbfl_filter_output.c
index c75c19ac19446e3e6353f30ef4325e4fffd21685..df01450db28c7c781a39d9a4e3584426883f3da9 100644 (file)
--- a/ext/mbstring/libmbfl/mbfl/mbfl_filter_output.c
+++ b/ext/mbstring/libmbfl/mbfl/mbfl_filter_output.c
@@ -41,16 +41,6 @@ int mbfl_filter_output_pipe(int c, void* data)
        return (*filter->filter_function)(c, filter);
 }
 
-int mbfl_filter_output_pipe_flush(void *data)
-{
-       mbfl_convert_filter *filter = (mbfl_convert_filter*)data;
-       if (filter->filter_flush != NULL) {
-               return (*filter->filter_flush)(filter);
-       }
-
-       return 0;
-}
-
 int mbfl_filter_output_null(int c, void* data)
 {
        return c;

diff --git a/ext/mbstring/libmbfl/mbfl/mbfl_filter_output.h b/ext/mbstring/libmbfl/mbfl/mbfl_filter_output.h
index eeae05ac9ce67c7db556eb8a01371fa6a66c681c..d10fa76b0cf5e7e97d92a4c30d920a24afcb52ea 100644 (file)
--- a/ext/mbstring/libmbfl/mbfl/mbfl_filter_output.h
+++ b/ext/mbstring/libmbfl/mbfl/mbfl_filter_output.h
@@ -32,7 +32,6 @@
 #define MBFL_FILTER_OUTPUT_H
 
 MBFLAPI extern int mbfl_filter_output_pipe(int c, void* data);
-MBFLAPI extern int mbfl_filter_output_pipe_flush(void* data);
 MBFLAPI extern int mbfl_filter_output_null(int c, void* data);
 
 #endif /* MBFL_FILTER_OUTPUT_H */

diff --git a/ext/mbstring/libmbfl/mbfl/mbfl_memory_device.c b/ext/mbstring/libmbfl/mbfl/mbfl_memory_device.c
index def9495678b26d21e8c6799feb7b35bb77cc5dde..46f3fae2f8d7be02c3aa1c5c33c983780c5f33f9 100644 (file)
--- a/ext/mbstring/libmbfl/mbfl/mbfl_memory_device.c
+++ b/ext/mbstring/libmbfl/mbfl/mbfl_memory_device.c
@@ -150,58 +150,6 @@ mbfl_memory_device_output(int c, void *data)
        return c;
 }
 
-int
-mbfl_memory_device_output2(int c, void *data)
-{
-       mbfl_memory_device *device = (mbfl_memory_device *)data;
-
-       if (2 > device->length - device->pos) {
-               /* reallocate buffer */
-               size_t newlen;
-
-               if (device->length > SIZE_MAX - device->allocsz) {
-                       /* overflow */
-                       return -1;
-               }
-
-               newlen = device->length + device->allocsz;
-               device->buffer = erealloc(device->buffer, newlen);
-               device->length = newlen;
-       }
-
-       device->buffer[device->pos++] = (unsigned char)((c >> 8) & 0xff);
-       device->buffer[device->pos++] = (unsigned char)(c & 0xff);
-
-       return c;
-}
-
-int
-mbfl_memory_device_output4(int c, void* data)
-{
-       mbfl_memory_device *device = (mbfl_memory_device *)data;
-
-       if (4 > device->length - device->pos) {
-               /* reallocate buffer */
-               size_t newlen;
-
-               if (device->length > SIZE_MAX - device->allocsz) {
-                       /* overflow */
-                       return -1;
-               }
-
-               newlen = device->length + device->allocsz;
-               device->buffer = erealloc(device->buffer, newlen);
-               device->length = newlen;
-       }
-
-       device->buffer[device->pos++] = (unsigned char)((c >> 24) & 0xff);
-       device->buffer[device->pos++] = (unsigned char)((c >> 16) & 0xff);
-       device->buffer[device->pos++] = (unsigned char)((c >> 8) & 0xff);
-       device->buffer[device->pos++] = (unsigned char)(c & 0xff);
-
-       return c;
-}
-
 int
 mbfl_memory_device_strcat(mbfl_memory_device *device, const char *psrc)
 {

diff --git a/ext/mbstring/libmbfl/mbfl/mbfl_memory_device.h b/ext/mbstring/libmbfl/mbfl/mbfl_memory_device.h
index d85a10fb2800382ce8cd3720c8f5e154fb8fec8d..7e86db3e066225e089af0c9b9696244809ad20c1 100644 (file)
--- a/ext/mbstring/libmbfl/mbfl/mbfl_memory_device.h
+++ b/ext/mbstring/libmbfl/mbfl/mbfl_memory_device.h
@@ -60,8 +60,6 @@ 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, size_t len);

diff --git a/ext/mbstring/mbstring.c b/ext/mbstring/mbstring.c
index 0f5e91a4d4cffc7d88b9584069ac8a6222f918a6..2bb27ff2ee5cdcb06fa8adc9dfaa5ad971e30b96 100644 (file)
--- a/ext/mbstring/mbstring.c
+++ b/ext/mbstring/mbstring.c
@@ -451,8 +451,6 @@ 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;
-       size_t loc;
 
        /* new encoding */
        /* initialize string */
@@ -470,11 +468,7 @@ static size_t php_mb_zend_encoding_converter(unsigned char **to, size_t *to_leng
        mbfl_buffer_converter_illegal_substchar(convd, MBSTRG(current_filter_illegal_substchar));
 
        /* do it */
-       status = mbfl_buffer_converter_feed2(convd, &string, &loc);
-       if (status) {
-               mbfl_buffer_converter_delete(convd);
-               return (size_t)-1;
-       }
+       size_t loc = mbfl_buffer_converter_feed(convd, &string);
 
        mbfl_buffer_converter_flush(convd);
        mbfl_string_init(&result);

diff --git a/ext/mbstring/php_mbregex.c b/ext/mbstring/php_mbregex.c
index 85309e7cfdb8b01e5df52f340de708d8b18df9c0..04811165600320d5688eb3289eb930b5267082f9 100644 (file)
--- a/ext/mbstring/php_mbregex.c
+++ b/ext/mbstring/php_mbregex.c
@@ -86,12 +86,6 @@ static int _php_mb_regex_globals_ctor(zend_mb_regex_globals *pglobals)
 }
 /* }}} */
 
-/* {{{ _php_mb_regex_globals_dtor */
-static void _php_mb_regex_globals_dtor(zend_mb_regex_globals *pglobals)
-{
-}
-/* }}} */
-
 /* {{{ php_mb_regex_globals_alloc */
 zend_mb_regex_globals *php_mb_regex_globals_alloc(void)
 {
@@ -111,7 +105,6 @@ void php_mb_regex_globals_free(zend_mb_regex_globals *pglobals)
        if (!pglobals) {
                return;
        }
-       _php_mb_regex_globals_dtor(pglobals);
        pefree(pglobals, 1);
 }
 /* }}} */