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;
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;
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;
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);
*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;
}
}
/* 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;
}
}
r -= 4;
}
- if (m == 0 && ret >= 0) {
+ if (m == 0) {
ret = (*filter->filter_function)(mbfl_hexchar_table[0], 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 {
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 ||
} 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;
}
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;
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);
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 */