Refactor mbfl_convert.c
authorAlex Dowad <alexinbeijing@gmail.com>
Wed, 15 Jul 2020 19:56:33 +0000 (21:56 +0200)
committerAlex Dowad <alexinbeijing@gmail.com>
Thu, 3 Sep 2020 13:56:29 +0000 (15:56 +0200)
ext/mbstring/libmbfl/filters/mbfilter_cp5022x.c
ext/mbstring/libmbfl/mbfl/mbfilter.c
ext/mbstring/libmbfl/mbfl/mbfl_convert.c
ext/mbstring/libmbfl/mbfl/mbfl_convert.h
ext/mbstring/mbstring.c

index 4b63602916de20e172abaf97b470e74762e1f0ae..a20115416999d0c97ed9672578166ada8e55d93b 100644 (file)
@@ -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);
index a1191716a170f3ccf7815ca7343758832723e2f1..65817d384a2f0b860ed054c477887af7b59b2c65 100644 (file)
@@ -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);
index e301254e031a3f01bb37c052ad8f5ba55183a6ee..0f41e35b251586242531f2802a18e498d2b08638 100644 (file)
@@ -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;
                        }
index 852e669dac9139fd319a59e65bcb07d920aefcdc..f38de7eefe628aec2d9c1a12a83a6e973cca75ee 100644 (file)
 
 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 */
index 13031d90d3e39c726871701cfe9cc01d491f6989..24c55509759dcaf0a867c34aa1a905a98ce4506b 100644 (file)
@@ -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) {