Moriyoshi Koizumi
moriy****@users*****
2006年 11月 15日 (水) 17:55:08 JST
moriyoshi 06/11/15 17:55:08
Modified: . Tag: LIBMBFL_1_0 configure.in
filters Tag: LIBMBFL_1_0 Makefile.am Makefile.bcc32
mbfilter_cp932.c mbfilter_euc_jp_win.c
mbfilter_jis.c
mbfl Tag: LIBMBFL_1_0 mbfilter.c mbfl_convert.c
mbfl_convert.h mbfl_encoding.c mbfl_encoding.h
mbfl_filter_output.c mbfl_filter_output.h
mbfl_ident.c
Added: filters Tag: LIBMBFL_1_0 mbfilter_cp5022x.c
mbfilter_cp5022x.h mbfilter_tl_jisx0201_jisx0208.c
mbfilter_tl_jisx0201_jisx0208.h
translit_kana_jisx0201_jisx0208.h
tests/conv_encoding.tests Tag: LIBMBFL_1_0
cp51932_cp50220raw.exp
Log:
- Initial CP50220 support
- Some coordination with the Miracle Linux team gonna be necessary.
Revision Changes Path
No revision
No revision
1.2.2.13 +2 -2 libmbfl/configure.in
Index: configure.in
===================================================================
RCS file: /cvsroot/php-i18n/libmbfl/configure.in,v
retrieving revision 1.2.2.12
retrieving revision 1.2.2.13
diff -u -r1.2.2.12 -r1.2.2.13
--- configure.in 23 Sep 2006 03:28:33 -0000 1.2.2.12
+++ configure.in 15 Nov 2006 08:55:07 -0000 1.2.2.13
@@ -1,10 +1,10 @@
# Process this file with autoconf to produce a configure script.
AC_INIT(mbfl/mbfilter.c)
-AM_INIT_AUTOMAKE(libmbfl, 1.0.1)
+AM_INIT_AUTOMAKE(libmbfl, 1.1.0rc3)
AC_CONFIG_SRCDIR(mbfl/mbfilter.c)
AM_CONFIG_HEADER(config.h)
-SHLIB_VERSION="1:0:0"
+SHLIB_VERSION="1:1:0"
AC_SUBST(SHLIB_VERSION)
# Checks for programs.
No revision
No revision
1.7.2.10 +6 -1 libmbfl/filters/Makefile.am
Index: Makefile.am
===================================================================
RCS file: /cvsroot/php-i18n/libmbfl/filters/Makefile.am,v
retrieving revision 1.7.2.9
retrieving revision 1.7.2.10
diff -u -r1.7.2.9 -r1.7.2.10
--- Makefile.am 9 Sep 2006 12:17:55 -0000 1.7.2.9
+++ Makefile.am 15 Nov 2006 08:55:07 -0000 1.7.2.10
@@ -49,6 +49,8 @@
mbfilter_cp866.c \
mbfilter_koi8r.c \
mbfilter_armscii8.c \
+ mbfilter_cp5022x.c \
+ mbfilter_tl_jisx0201_jisx0208.c \
html_entities.c \
cp932_table.h \
html_entities.h \
@@ -99,6 +101,8 @@
mbfilter_utf7imap.h \
mbfilter_utf8.h \
mbfilter_uuencode.h \
+ mbfilter_cp5022x.h \
+ mbfilter_tl_jisx0201_jisx0208.h \
unicode_prop.h \
unicode_table_big5.h \
unicode_table_cns11643.h \
@@ -123,7 +127,8 @@
unicode_table_jis.h \
unicode_table_koi8r.h \
unicode_table_armscii8.h \
- unicode_table_uhc.h
+ unicode_table_uhc.h \
+ translit_kana_jisx0201_jisx0208.h
mbfilter_iso8859_2.c: unicode_table_iso8859_2.h
1.2.2.5 +2 -0 libmbfl/filters/Makefile.bcc32
Index: Makefile.bcc32
===================================================================
RCS file: /cvsroot/php-i18n/libmbfl/filters/Makefile.bcc32,v
retrieving revision 1.2.2.4
retrieving revision 1.2.2.5
diff -u -r1.2.2.4 -r1.2.2.5
--- Makefile.bcc32 9 Sep 2006 12:17:55 -0000 1.2.2.4
+++ Makefile.bcc32 15 Nov 2006 08:55:07 -0000 1.2.2.5
@@ -46,6 +46,8 @@
mbfilter_iso2022_kr.obj \
mbfilter_cp866.obj \
mbfilter_koi8r.obj \
+ mbfilter_cp5022x.obj
+ mbfilter_tl_jisx0201_jisx0208.obj \
html_entities.obj \
mbfilter_armscii8.obj
1.3.2.1 +6 -2 libmbfl/filters/mbfilter_cp932.c
Index: mbfilter_cp932.c
===================================================================
RCS file: /cvsroot/php-i18n/libmbfl/filters/mbfilter_cp932.c,v
retrieving revision 1.3
retrieving revision 1.3.2.1
diff -u -r1.3 -r1.3.2.1
--- mbfilter_cp932.c 20 Dec 2002 18:17:31 -0000 1.3
+++ mbfilter_cp932.c 15 Nov 2006 08:55:07 -0000 1.3.2.1
@@ -285,18 +285,22 @@
c1 = 0;
c2 = cp932ext1_ucs_table_max - cp932ext1_ucs_table_min;
while (c1 < c2) { /* CP932 vendor ext1 (13ku) */
+ static const int oh = cp932ext1_ucs_table_min / 94;
+
if (c == cp932ext1_ucs_table[c1]) {
- s1 = ((c1/94 + 0x2d) << 8) + (c1%94 + 0x21);
+ s1 = ((c1/94 + oh + 0x21) << 8) + (c1%94 + 0x21);
break;
}
c1++;
}
if (s1 <= 0) {
+ static const int oh = cp932ext3_ucs_table_min / 94;
c1 = 0;
c2 = cp932ext3_ucs_table_max - cp932ext3_ucs_table_min;
+
while (c1 < c2) { /* CP932 vendor ext3 (115ku - 119ku) */
if (c == cp932ext3_ucs_table[c1]) {
- s1 = ((c1/94 + 0x93) << 8) + (c1%94 + 0x21);
+ s1 = ((c1 / 94 + oh + 0x21) << 8) + (c1 % 94 + 0x21);
break;
}
c1++;
1.3.2.1 +6 -3 libmbfl/filters/mbfilter_euc_jp_win.c
Index: mbfilter_euc_jp_win.c
===================================================================
RCS file: /cvsroot/php-i18n/libmbfl/filters/mbfilter_euc_jp_win.c,v
retrieving revision 1.3
retrieving revision 1.3.2.1
diff -u -r1.3 -r1.3.2.1
--- mbfilter_euc_jp_win.c 20 Dec 2002 18:17:31 -0000 1.3
+++ mbfilter_euc_jp_win.c 15 Nov 2006 08:55:07 -0000 1.3.2.1
@@ -152,8 +152,8 @@
w = cp932ext1_ucs_table[s - cp932ext1_ucs_table_min];
} else if (s >= 0 && s < jisx0208_ucs_table_size) { /* X 0208 */
w = jisx0208_ucs_table[s];
- } else if (s >= (84*94)) { /* user (85ku - 94ku) */
- w = s - (84*94) + 0xe000;
+ } else if (s >= (84 * 94)) { /* user (85ku - 94ku) */
+ w = s - (84 * 94) + 0xe000;
}
}
if (w <= 0) {
@@ -315,8 +315,10 @@
c1 = 0;
c2 = cp932ext1_ucs_table_max - cp932ext1_ucs_table_min;
while (c1 < c2) { /* CP932 vendor ext1 (13ku) */
+ static const int oh = cp932ext1_ucs_table_min / 94;
+
if (c == cp932ext1_ucs_table[c1]) {
- s1 = ((c1/94 + 0x2d) << 8) + (c1%94 + 0x21);
+ s1 = ((c1 / 94 + oh + 0x21) << 8) + (c1 % 94 + 0x21);
break;
}
c1++;
@@ -324,6 +326,7 @@
if (s1 < 0) {
c1 = 0;
c2 = cp932ext3_ucs_table_max - cp932ext3_ucs_table_min;
+
while (c1 < c2) { /* CP932 vendor ext3 (115ku - 119ku) */
if (c == cp932ext3_ucs_table[c1]) {
if (c1 < cp932ext3_eucjp_table_size) {
1.3.2.2 +1 -1 libmbfl/filters/mbfilter_jis.c
Index: mbfilter_jis.c
===================================================================
RCS file: /cvsroot/php-i18n/libmbfl/filters/mbfilter_jis.c,v
retrieving revision 1.3.2.1
retrieving revision 1.3.2.2
diff -u -r1.3.2.1 -r1.3.2.2
--- mbfilter_jis.c 22 Sep 2006 05:32:09 -0000 1.3.2.1
+++ mbfilter_jis.c 15 Nov 2006 08:55:07 -0000 1.3.2.2
@@ -480,7 +480,7 @@
filter->status &= 0xff;
if (filter->flush_function != NULL) {
- (*filter->flush_function)(filter->data);
+ return (*filter->flush_function)(filter->data);
}
return 0;
No revision
No revision
1.1.2.1 +1238 -0 libmbfl/filters/Attic/mbfilter_cp5022x.c
1.1.2.1 +63 -0 libmbfl/filters/Attic/mbfilter_cp5022x.h
1.1.2.1 +302 -0 libmbfl/filters/Attic/mbfilter_tl_jisx0201_jisx0208.c
1.1.2.1 +79 -0 libmbfl/filters/Attic/mbfilter_tl_jisx0201_jisx0208.h
1.1.2.1 +67 -0 libmbfl/filters/Attic/translit_kana_jisx0201_jisx0208.h
No revision
No revision
1.8.2.18 +307 -441 libmbfl/mbfl/mbfilter.c
Index: mbfilter.c
===================================================================
RCS file: /cvsroot/php-i18n/libmbfl/mbfl/mbfilter.c,v
retrieving revision 1.8.2.17
retrieving revision 1.8.2.18
diff -u -r1.8.2.17 -r1.8.2.18
--- mbfilter.c 9 Sep 2006 12:17:55 -0000 1.8.2.17
+++ mbfilter.c 15 Nov 2006 08:55:07 -0000 1.8.2.18
@@ -2,7 +2,6 @@
* charset=UTF-8
* vim600: encoding=utf-8
*/
-
/*
* "streamable kanji code filter and converter"
*
@@ -85,8 +84,6 @@
#include "config.h"
#endif
-#include <stddef.h>
-
#ifdef HAVE_STRING_H
#include <string.h>
#endif
@@ -102,6 +99,7 @@
#include "mbfilter.h"
#include "mbfl_filter_output.h"
#include "mbfilter_pass.h"
+#include "filters/mbfilter_tl_jisx0201_jisx0208.h"
#include "eaw_table.h"
@@ -149,11 +147,15 @@
convd->filter1 = 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, 0, &convd->device);
+ convd->filter1 = mbfl_convert_filter_new(convd->from->no_encoding, convd->to->no_encoding, mbfl_memory_device_output, NULL, &convd->device);
} else {
- convd->filter2 = mbfl_convert_filter_new(mbfl_no_encoding_wchar, convd->to->no_encoding, mbfl_memory_device_output, 0, &convd->device);
+ convd->filter2 = mbfl_convert_filter_new(mbfl_no_encoding_wchar, convd->to->no_encoding, mbfl_memory_device_output, NULL, &convd->device);
if (convd->filter2 != NULL) {
- convd->filter1 = mbfl_convert_filter_new(convd->from->no_encoding, mbfl_no_encoding_wchar, (int (*)(int, void*))convd->filter2->filter_function, NULL, convd->filter2);
+ convd->filter1 = mbfl_convert_filter_new(convd->from->no_encoding,
+ mbfl_no_encoding_wchar,
+ (int (*)(int, void*))convd->filter2->filter_function,
+ (int (*)(void*))convd->filter2->filter_flush,
+ convd->filter2);
if (convd->filter1 == NULL) {
mbfl_convert_filter_delete(convd->filter2);
}
@@ -1202,7 +1204,6 @@
return result;
}
-
/*
* strcut
*/
@@ -1214,183 +1215,280 @@
int length)
{
const mbfl_encoding *encoding;
- int n, m, k, len, start, end;
- unsigned char *p, *w;
- const unsigned char *mbtab;
mbfl_memory_device device;
- mbfl_convert_filter *encoder, *encoder_tmp, *decoder, *decoder_tmp;
+
+ /* validate the parameters */
+ if (string == NULL || string->val == NULL || result == NULL) {
+ return NULL;
+ }
+
+ if (from < 0 || length < 0) {
+ return NULL;
+ }
+
+ if (from >= string->len) {
+ from = string->len;
+ }
encoding = mbfl_no2encoding(string->no_encoding);
- if (encoding == NULL || string == NULL || result == NULL) {
+ if (encoding == NULL) {
return NULL;
}
+
mbfl_string_init(result);
result->no_language = string->no_language;
result->no_encoding = string->no_encoding;
- if ((encoding->flag & (MBFL_ENCTYPE_SBCS | MBFL_ENCTYPE_WCS2BE | MBFL_ENCTYPE_WCS2LE | MBFL_ENCTYPE_WCS4BE | MBFL_ENCTYPE_WCS4LE)) ||
- encoding->mblen_table != NULL) {
- len = string->len;
- start = from;
- end = from + length;
+ if ((encoding->flag & (MBFL_ENCTYPE_SBCS
+ | MBFL_ENCTYPE_WCS2BE
+ | MBFL_ENCTYPE_WCS2LE
+ | MBFL_ENCTYPE_WCS4BE
+ | MBFL_ENCTYPE_WCS4LE))
+ || encoding->mblen_table != NULL) {
+ const unsigned char *start = NULL;
+ const unsigned char *end = NULL;
+ unsigned char *w;
+ unsigned int sz;
+
if (encoding->flag & (MBFL_ENCTYPE_WCS2BE | MBFL_ENCTYPE_WCS2LE)) {
- start /= 2;
- start *= 2;
- end = length/2;
- end *= 2;
- end += start;
+ from &= -2;
+
+ if (from + length >= string->len) {
+ length = string->len - from;
+ }
+
+ start = string->val + from;
+ end = start + (length & -2);
} else if (encoding->flag & (MBFL_ENCTYPE_WCS4BE | MBFL_ENCTYPE_WCS4LE)) {
- start /= 4;
- start *= 4;
- end = length/4;
- end *= 4;
- end += start;
+ from &= -4;
+
+ if (from + length >= string->len) {
+ length = string->len - from;
+ }
+
+ start = string->val + from;
+ end = start + (length & -4);
+ } else if ((encoding->flag & MBFL_ENCTYPE_SBCS)) {
+ start = string->val + from;
+ end = start + length;
} else if (encoding->mblen_table != NULL) {
- mbtab = encoding->mblen_table;
- start = 0;
- end = 0;
- n = 0;
- p = string->val;
- if (p != NULL) {
- /* search start position */
- for (;;) {
- m = mbtab[*p];
- n += m;
- p += m;
- if (n > from) {
- break;
- }
- start = n;
- }
- /* search end position */
- k = start + length;
- if (k >= (int)string->len) {
- end = string->len;
- } else {
- end = start;
- while (n <= k) {
- end = n;
- m = mbtab[*p];
- n += m;
- p += m;
- }
+ const unsigned char *mbtab = encoding->mblen_table;
+ const unsigned char *p, *q;
+ int m;
+
+ /* search start position */
+ for (m = 0, p = string->val, q = p + from;
+ p < q; p += (m = mbtab[*p]));
+
+ if (p > q) {
+ p -= m;
+ }
+
+ start = p;
+
+ /* search end position */
+ if ((start - string->val) + length >= (int)string->len) {
+ end = string->val + string->len;
+ } else {
+ for (q = p + length; p < q; p += (m = mbtab[*p]));
+
+ if (p > q) {
+ p -= m;
}
+ end = p;
}
+ } else {
+ /* never reached */
+ return NULL;
}
- 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;
- }
/* allocate memory and copy string */
- n = end - start;
- result->len = 0;
- result->val = w = (unsigned char*)mbfl_malloc((n + 8)*sizeof(unsigned char));
- if (w != NULL) {
- result->len = n;
- p = &(string->val[start]);
- while (n > 0) {
- *w++ = *p++;
- n--;
- }
- *w++ = '\0';
- *w++ = '\0';
- *w++ = '\0';
- *w = '\0';
- } else {
- result = NULL;
+ sz = end - start;
+ if ((w = (unsigned char*)mbfl_calloc(sz + 8,
+ sizeof(unsigned char))) == NULL) {
+ return NULL;
}
+
+ memcpy(w, start, sz);
+ w[sz] = '\0';
+ w[sz + 1] = '\0';
+ w[sz + 2] = '\0';
+ w[sz + 3] = '\0';
+
+ result->val = w;
+ result->len = sz;
} else {
- /* wchar filter */
- encoder = mbfl_convert_filter_new(
- string->no_encoding,
- mbfl_no_encoding_wchar,
- mbfl_filter_output_null, 0, 0);
- encoder_tmp = mbfl_convert_filter_new(
- string->no_encoding,
- mbfl_no_encoding_wchar,
- mbfl_filter_output_null, 0, 0);
+ mbfl_convert_filter *encoder = NULL;
+ mbfl_convert_filter *decoder = NULL;
+ const unsigned char *p, *q, *r;
+ struct {
+ mbfl_convert_filter encoder;
+ mbfl_convert_filter decoder;
+ const unsigned char *p;
+ int pos;
+ } bk, _bk;
+
/* output code filter */
- decoder = mbfl_convert_filter_new(
- mbfl_no_encoding_wchar,
- string->no_encoding,
- mbfl_memory_device_output, 0, &device);
- decoder_tmp = mbfl_convert_filter_new(
- mbfl_no_encoding_wchar,
- string->no_encoding,
- mbfl_memory_device_output, 0, &device);
- if (encoder == NULL || encoder_tmp == NULL || decoder == NULL || decoder_tmp == NULL) {
- mbfl_convert_filter_delete(encoder);
- mbfl_convert_filter_delete(encoder_tmp);
+ if (!(decoder = mbfl_convert_filter_new(
+ mbfl_no_encoding_wchar,
+ string->no_encoding,
+ mbfl_memory_device_output, 0, &device))) {
+ return NULL;
+ }
+
+ /* wchar filter */
+ if (!(encoder = mbfl_convert_filter_new(
+ string->no_encoding,
+ mbfl_no_encoding_wchar,
+ mbfl_filter_output_null,
+ NULL, NULL))) {
mbfl_convert_filter_delete(decoder);
- mbfl_convert_filter_delete(decoder_tmp);
return NULL;
}
+
mbfl_memory_device_init(&device, length + 8, 0);
- k = 0;
- n = 0;
+
p = string->val;
- if (p != NULL) {
- /* seartch start position */
- while (n < from) {
- (*encoder->filter_function)(*p++, encoder);
- n++;
- }
+
+ /* search start position */
+ for (q = string->val + from; p < q; p++) {
+ (*encoder->filter_function)(*p, encoder);
+ }
+
+ /* switch the drain direction */
+ encoder->output_function = (int(*)(int,void *))decoder->filter_function;
+ encoder->flush_function = (int(*)(void *))decoder->filter_flush;
+ encoder->data = decoder;
+
+ q = string->val + string->len;
+
+ /* save the encoder, decoder state and the pointer */
+ mbfl_convert_filter_copy(decoder, &_bk.decoder);
+ mbfl_convert_filter_copy(encoder, &_bk.encoder);
+ _bk.p = p;
+ _bk.pos = device.pos;
+
+ if (length > q - p) {
+ length = q - p;
+ }
+
+ if (length >= 20) {
/* output a little shorter than "length" */
- encoder->output_function = mbfl_filter_output_pipe;
- encoder->data = decoder;
- k = length - 20;
- len = string->len;
- while (n < len && device.pos < k) {
- (*encoder->filter_function)(*p++, encoder);
- n++;
- }
- /* detect end position */
- for (;;) {
- /* backup current state */
- k = device.pos;
- mbfl_convert_filter_copy(encoder, encoder_tmp);
- mbfl_convert_filter_copy(decoder, decoder_tmp);
- if (n >= len) {
- break;
- }
- /* feed 1byte and flush */
+ /* XXX: the constant "20" was determined purely on the heuristics. */
+ for (r = p + length - 20; p < r; p++) {
(*encoder->filter_function)(*p, encoder);
+ }
+
+ /* if the offset of the resulting string exceeds the length,
+ * then restore the state */
+ if (device.pos > length) {
+ p = _bk.p;
+ device.pos = _bk.pos;
+ decoder->filter_dtor(decoder);
+ encoder->filter_dtor(encoder);
+ mbfl_convert_filter_copy(&_bk.decoder, decoder);
+ mbfl_convert_filter_copy(&_bk.encoder, encoder);
+ bk = _bk;
+ } else {
+ /* save the encoder, decoder state and the pointer */
+ mbfl_convert_filter_copy(decoder, &bk.decoder);
+ mbfl_convert_filter_copy(encoder, &bk.encoder);
+ bk.p = p;
+ bk.pos = device.pos;
+
+ /* flush the stream */
(*encoder->filter_flush)(encoder);
- (*decoder->filter_flush)(decoder);
+
+ /* if the offset of the resulting string exceeds the length,
+ * then restore the state */
if (device.pos > length) {
- break;
+ bk.decoder.filter_dtor(&bk.decoder);
+ bk.encoder.filter_dtor(&bk.encoder);
+
+ p = _bk.p;
+ device.pos = _bk.pos;
+ decoder->filter_dtor(decoder);
+ encoder->filter_dtor(encoder);
+ mbfl_convert_filter_copy(&_bk.decoder, decoder);
+ mbfl_convert_filter_copy(&_bk.encoder, encoder);
+ bk = _bk;
+ } else {
+ _bk.decoder.filter_dtor(&_bk.decoder);
+ _bk.encoder.filter_dtor(&_bk.encoder);
+
+ p = bk.p;
+ device.pos = bk.pos;
+ decoder->filter_dtor(decoder);
+ encoder->filter_dtor(encoder);
+ mbfl_convert_filter_copy(&bk.decoder, decoder);
+ mbfl_convert_filter_copy(&bk.encoder, encoder);
}
- /* restore filter and re-feed data */
- device.pos = k;
- mbfl_convert_filter_copy(encoder_tmp, encoder);
- mbfl_convert_filter_copy(decoder_tmp, decoder);
- (*encoder->filter_function)(*p, encoder);
- p++;
- n++;
}
- device.pos = k;
- mbfl_convert_filter_copy(encoder_tmp, encoder);
- mbfl_convert_filter_copy(decoder_tmp, decoder);
- mbfl_convert_filter_flush(encoder);
- mbfl_convert_filter_flush(decoder);
+ } else {
+ bk = _bk;
+ }
+
+ /* detect end position */
+ while (p < q) {
+ (*encoder->filter_function)(*p, encoder);
+
+ if (device.pos > length) {
+ /* restore filter */
+ p = bk.p;
+ device.pos = bk.pos;
+ decoder->filter_dtor(decoder);
+ encoder->filter_dtor(encoder);
+ mbfl_convert_filter_copy(&bk.decoder, decoder);
+ mbfl_convert_filter_copy(&bk.encoder, encoder);
+ break;
+ }
+
+ p++;
+
+ /* backup current state */
+ mbfl_convert_filter_copy(decoder, &_bk.decoder);
+ mbfl_convert_filter_copy(encoder, &_bk.encoder);
+ _bk.pos = device.pos;
+ _bk.p = p;
+
+ (*encoder->filter_flush)(encoder);
+
+ if (device.pos > length) {
+ _bk.decoder.filter_dtor(&_bk.decoder);
+ _bk.encoder.filter_dtor(&_bk.encoder);
+
+ /* restore filter */
+ p = bk.p;
+ device.pos = bk.pos;
+ decoder->filter_dtor(decoder);
+ encoder->filter_dtor(encoder);
+ mbfl_convert_filter_copy(&bk.decoder, decoder);
+ mbfl_convert_filter_copy(&bk.encoder, encoder);
+ break;
+ }
+
+ bk.decoder.filter_dtor(&bk.decoder);
+ bk.encoder.filter_dtor(&bk.encoder);
+
+ p = _bk.p;
+ device.pos = _bk.pos;
+ decoder->filter_dtor(decoder);
+ encoder->filter_dtor(encoder);
+ mbfl_convert_filter_copy(&_bk.decoder, decoder);
+ mbfl_convert_filter_copy(&_bk.encoder, encoder);
+
+ bk = _bk;
}
+
+ (*encoder->filter_flush)(encoder);
+
+ bk.decoder.filter_dtor(&bk.decoder);
+ bk.encoder.filter_dtor(&bk.encoder);
+
result = mbfl_memory_device_result(&device, result);
+
mbfl_convert_filter_delete(encoder);
- mbfl_convert_filter_delete(encoder_tmp);
mbfl_convert_filter_delete(decoder);
- mbfl_convert_filter_delete(decoder_tmp);
}
return result;
@@ -1607,276 +1705,6 @@
return result;
}
-
-
-/*
- * convert Hankaku and Zenkaku
- */
-struct collector_hantozen_data {
- mbfl_convert_filter *next_filter;
- int mode;
- int status;
- int cache;
-};
-
-static const unsigned char hankana2zenkata_table[64] = {
- 0x00,0x02,0x0C,0x0D,0x01,0xFB,0xF2,0xA1,0xA3,0xA5,
- 0xA7,0xA9,0xE3,0xE5,0xE7,0xC3,0xFC,0xA2,0xA4,0xA6,
- 0xA8,0xAA,0xAB,0xAD,0xAF,0xB1,0xB3,0xB5,0xB7,0xB9,
- 0xBB,0xBD,0xBF,0xC1,0xC4,0xC6,0xC8,0xCA,0xCB,0xCC,
- 0xCD,0xCE,0xCF,0xD2,0xD5,0xD8,0xDB,0xDE,0xDF,0xE0,
- 0xE1,0xE2,0xE4,0xE6,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,
- 0xEF,0xF3,0x9B,0x9C
-};
-static const unsigned char hankana2zenhira_table[64] = {
- 0x00,0x02,0x0C,0x0D,0x01,0xFB,0x92,0x41,0x43,0x45,
- 0x47,0x49,0x83,0x85,0x87,0x63,0xFC,0x42,0x44,0x46,
- 0x48,0x4A,0x4B,0x4D,0x4F,0x51,0x53,0x55,0x57,0x59,
- 0x5B,0x5D,0x5F,0x61,0x64,0x66,0x68,0x6A,0x6B,0x6C,
- 0x6D,0x6E,0x6F,0x72,0x75,0x78,0x7B,0x7E,0x7F,0x80,
- 0x81,0x82,0x84,0x86,0x88,0x89,0x8A,0x8B,0x8C,0x8D,
- 0x8F,0x93,0x9B,0x9C
-};
-static const unsigned char zenkana2hankana_table[84][2] = {
- {0x67,0x00},{0x71,0x00},{0x68,0x00},{0x72,0x00},{0x69,0x00},
- {0x73,0x00},{0x6A,0x00},{0x74,0x00},{0x6B,0x00},{0x75,0x00},
- {0x76,0x00},{0x76,0x9E},{0x77,0x00},{0x77,0x9E},{0x78,0x00},
- {0x78,0x9E},{0x79,0x00},{0x79,0x9E},{0x7A,0x00},{0x7A,0x9E},
- {0x7B,0x00},{0x7B,0x9E},{0x7C,0x00},{0x7C,0x9E},{0x7D,0x00},
- {0x7D,0x9E},{0x7E,0x00},{0x7E,0x9E},{0x7F,0x00},{0x7F,0x9E},
- {0x80,0x00},{0x80,0x9E},{0x81,0x00},{0x81,0x9E},{0x6F,0x00},
- {0x82,0x00},{0x82,0x9E},{0x83,0x00},{0x83,0x9E},{0x84,0x00},
- {0x84,0x9E},{0x85,0x00},{0x86,0x00},{0x87,0x00},{0x88,0x00},
- {0x89,0x00},{0x8A,0x00},{0x8A,0x9E},{0x8A,0x9F},{0x8B,0x00},
- {0x8B,0x9E},{0x8B,0x9F},{0x8C,0x00},{0x8C,0x9E},{0x8C,0x9F},
- {0x8D,0x00},{0x8D,0x9E},{0x8D,0x9F},{0x8E,0x00},{0x8E,0x9E},
- {0x8E,0x9F},{0x8F,0x00},{0x90,0x00},{0x91,0x00},{0x92,0x00},
- {0x93,0x00},{0x6C,0x00},{0x94,0x00},{0x6D,0x00},{0x95,0x00},
- {0x6E,0x00},{0x96,0x00},{0x97,0x00},{0x98,0x00},{0x99,0x00},
- {0x9A,0x00},{0x9B,0x00},{0x9C,0x00},{0x9C,0x00},{0x72,0x00},
- {0x74,0x00},{0x66,0x00},{0x9D,0x00},{0x73,0x9E}
-};
-
-static int
-collector_hantozen(int c, void* data)
-{
- int s, mode, n;
- struct collector_hantozen_data *pc = (struct collector_hantozen_data*)data;
-
- s = c;
- mode = pc->mode;
-
- if (mode & 0xf) { /* hankaku to zenkaku */
- if ((mode & 0x1) && c >= 0x21 && c <= 0x7d && c != 0x22 && c != 0x27 && c != 0x5c) { /* all except <"> <'> <\> <~> */
- s = c + 0xfee0;
- } else if ((mode & 0x2) && ((c >= 0x41 && c <= 0x5a) || (c >= 0x61 && c <= 0x7a))) { /* alpha */
- s = c + 0xfee0;
- } else if ((mode & 0x4) && c >= 0x30 && c <= 0x39) { /* num */
- s = c + 0xfee0;
- } else if ((mode & 0x8) && c == 0x20) { /* spase */
- s = 0x3000;
- }
- }
-
- if (mode & 0xf0) { /* zenkaku to hankaku */
- if ((mode & 0x10) && c >= 0xff01 && c <= 0xff5d && c != 0xff02 && c != 0xff07 && c!= 0xff3c) { /* all except <"> <'> <\> <~> */
- s = c - 0xfee0;
- } else if ((mode & 0x20) && ((c >= 0xff21 && c <= 0xff3a) || (c >= 0xff41 && c <= 0xff5a))) { /* alpha */
- s = c - 0xfee0;
- } else if ((mode & 0x40) && (c >= 0xff10 && c <= 0xff19)) { /* num */
- s = c - 0xfee0;
- } else if ((mode & 0x80) && (c == 0x3000)) { /* spase */
- s = 0x20;
- } else if ((mode & 0x10) && (c == 0x2212)) { /* MINUS SIGN */
- s = 0x2d;
- }
- }
-
- if (mode & 0x300) { /* hankaku kana to zenkaku kana */
- if ((mode & 0x100) && (mode & 0x800)) { /* hankaku kana to zenkaku katakana and glue voiced sound mark */
- if (c >= 0xff61 && c <= 0xff9f) {
- if (pc->status) {
- n = (pc->cache - 0xff60) & 0x3f;
- if (c == 0xff9e && ((n >= 22 && n <= 36) || (n >= 42 && n <= 46))) {
- pc->status = 0;
- s = 0x3001 + hankana2zenkata_table[n];
- } else if (c == 0xff9e && n == 19) {
- pc->status = 0;
- s = 0x30f4;
- } else if (c == 0xff9f && (n >= 42 && n <= 46)) {
- pc->status = 0;
- s = 0x3002 + hankana2zenkata_table[n];
- } else {
- pc->status = 1;
- pc->cache = c;
- s = 0x3000 + hankana2zenkata_table[n];
- }
- } else {
- pc->status = 1;
- pc->cache = c;
- return c;
- }
- } else {
- if (pc->status) {
- n = (pc->cache - 0xff60) & 0x3f;
- pc->status = 0;
- (*pc->next_filter->filter_function)(0x3000 + hankana2zenkata_table[n], pc->next_filter);
- }
- }
- } else if ((mode & 0x200) && (mode & 0x800)) { /* hankaku kana to zenkaku hirangana and glue voiced sound mark */
- if (c >= 0xff61 && c <= 0xff9f) {
- if (pc->status) {
- n = (pc->cache - 0xff60) & 0x3f;
- if (c == 0xff9e && ((n >= 22 && n <= 36) || (n >= 42 && n <= 46))) {
- pc->status = 0;
- s = 0x3001 + hankana2zenhira_table[n];
- } else if (c == 0xff9f && (n >= 42 && n <= 46)) {
- pc->status = 0;
- s = 0x3002 + hankana2zenhira_table[n];
- } else {
- pc->status = 1;
- pc->cache = c;
- s = 0x3000 + hankana2zenhira_table[n];
- }
- } else {
- pc->status = 1;
- pc->cache = c;
- return c;
- }
- } else {
- if (pc->status) {
- n = (pc->cache - 0xff60) & 0x3f;
- pc->status = 0;
- (*pc->next_filter->filter_function)(0x3000 + hankana2zenhira_table[n], pc->next_filter);
- }
- }
- } else if ((mode & 0x100) && c >= 0xff61 && c <= 0xff9f) { /* hankaku kana to zenkaku katakana */
- s = 0x3000 + hankana2zenkata_table[c - 0xff60];
- } else if ((mode & 0x200) && c >= 0xff61 && c <= 0xff9f) { /* hankaku kana to zenkaku hirangana */
- s = 0x3000 + hankana2zenhira_table[c - 0xff60];
- }
- }
-
- if (mode & 0x3000) { /* Zenkaku kana to hankaku kana */
- if ((mode & 0x1000) && c >= 0x30a1 && c <= 0x30f4) { /* Zenkaku katakana to hankaku kana */
- n = c - 0x30a1;
- if (zenkana2hankana_table[n][1] != 0) {
- (*pc->next_filter->filter_function)(0xff00 + zenkana2hankana_table[n][0], pc->next_filter);
- s = 0xff00 + zenkana2hankana_table[n][1];
- } else {
- s = 0xff00 + zenkana2hankana_table[n][0];
- }
- } else if ((mode & 0x2000) && c >= 0x3041 && c <= 0x3093) { /* Zenkaku hirangana to hankaku kana */
- n = c - 0x3041;
- if (zenkana2hankana_table[n][1] != 0) {
- (*pc->next_filter->filter_function)(0xff00 + zenkana2hankana_table[n][0], pc->next_filter);
- s = 0xff00 + zenkana2hankana_table[n][1];
- } else {
- s = 0xff00 + zenkana2hankana_table[n][0];
- }
- } else if (c == 0x3001) {
- s = 0xff64; /* HALFWIDTH IDEOGRAPHIC COMMA */
- } else if (c == 0x3002) {
- s = 0xff61; /* HALFWIDTH IDEOGRAPHIC FULL STOP */
- } else if (c == 0x300c) {
- s = 0xff62; /* HALFWIDTH LEFT CORNER BRACKET */
- } else if (c == 0x300d) {
- s = 0xff63; /* HALFWIDTH RIGHT CORNER BRACKET */
- } else if (c == 0x309b) {
- s = 0xff9e; /* HALFWIDTH KATAKANA VOICED SOUND MARK */
- } else if (c == 0x309c) {
- s = 0xff9f; /* HALFWIDTH KATAKANA SEMI-VOICED SOUND MARK */
- } else if (c == 0x30fc) {
- s = 0xff70; /* HALFWIDTH KATAKANA-HIRAGANA PROLONGED SOUND MARK */
- } else if (c == 0x30fb) {
- s = 0xff65; /* HALFWIDTH KATAKANA MIDDLE DOT */
- }
- } else if (mode & 0x30000) {
- if ((mode & 0x10000) && c >= 0x3041 && c <= 0x3093) { /* Zenkaku hirangana to Zenkaku katakana */
- s = c + 0x60;
- } else if ((mode & 0x20000) && c >= 0x30a1 && c <= 0x30f3) { /* Zenkaku katakana to Zenkaku hirangana */
- s = c - 0x60;
- }
- }
-
- if (mode & 0x100000) { /* special ascii to symbol */
- if (c == 0x5c) {
- s = 0xffe5; /* FULLWIDTH YEN SIGN */
- } else if (c == 0xa5) { /* YEN SIGN */
- s = 0xffe5; /* FULLWIDTH YEN SIGN */
- } else if (c == 0x7e) {
- s = 0xffe3; /* FULLWIDTH MACRON */
- } else if (c == 0x203e) { /* OVERLINE */
- s = 0xffe3; /* FULLWIDTH MACRON */
- } else if (c == 0x27) {
- s = 0x2019; /* RIGHT SINGLE QUOTATION MARK */
- } else if (c == 0x22) {
- s = 0x201d; /* RIGHT DOUBLE QUOTATION MARK */
- }
- } else if (mode & 0x200000) { /* special symbol to ascii */
- if (c == 0xffe5) { /* FULLWIDTH YEN SIGN */
- s = 0x5c;
- } else if (c == 0xff3c) { /* FULLWIDTH REVERSE SOLIDUS */
- s = 0x5c;
- } else if (c == 0xffe3) { /* FULLWIDTH MACRON */
- s = 0x7e;
- } else if (c == 0x203e) { /* OVERLINE */
- s = 0x7e;
- } else if (c == 0x2018) { /* LEFT SINGLE QUOTATION MARK*/
- s = 0x27;
- } else if (c == 0x2019) { /* RIGHT SINGLE QUOTATION MARK */
- s = 0x27;
- } else if (c == 0x201c) { /* LEFT DOUBLE QUOTATION MARK */
- s = 0x22;
- } else if (c == 0x201d) { /* RIGHT DOUBLE QUOTATION MARK */
- s = 0x22;
- }
- }
-
- if (mode & 0x400000) { /* special ascii to symbol */
- if (c == 0x5c) {
- s = 0xff3c; /* FULLWIDTH REVERSE SOLIDUS */
- } else if (c == 0x7e) {
- s = 0xff5e; /* FULLWIDTH TILDE */
- } else if (c == 0x27) {
- s = 0xff07; /* FULLWIDTH APOSTROPHE */
- } else if (c == 0x22) {
- s = 0xff02; /* FULLWIDTH QUOTATION MARK */
- }
- } else if (mode & 0x800000) { /* special symbol to ascii */
- if (c == 0xff3c) { /* FULLWIDTH REVERSE SOLIDUS */
- s = 0x5c;
- } else if (c == 0xff5e) { /* FULLWIDTH TILDE */
- s = 0x7e;
- } else if (c == 0xff07) { /* FULLWIDTH APOSTROPHE */
- s = 0x27;
- } else if (c == 0xff02) { /* FULLWIDTH QUOTATION MARK */
- s = 0x22;
- }
- }
-
- return (*pc->next_filter->filter_function)(s, pc->next_filter);
-}
-
-static int
-collector_hantozen_flush(struct collector_hantozen_data *pc)
-{
- int ret, n;
-
- ret = 0;
- if (pc->status) {
- n = (pc->cache - 0xff60) & 0x3f;
- if (pc->mode & 0x100) { /* hankaku kana to zenkaku katakana */
- ret = (*pc->next_filter->filter_function)(0x3000 + hankana2zenkata_table[n], pc->next_filter);
- } else if (pc->mode & 0x200) { /* hankaku kana to zenkaku hirangana */
- ret = (*pc->next_filter->filter_function)(0x3000 + hankana2zenhira_table[n], pc->next_filter);
- }
- pc->status = 0;
- }
-
- return ret;
-}
-
mbfl_string *
mbfl_ja_jp_hantozen(
mbfl_string *string,
@@ -1887,39 +1715,66 @@
unsigned char *p;
const mbfl_encoding *encoding;
mbfl_memory_device device;
- struct collector_hantozen_data pc;
- mbfl_convert_filter *decoder;
- mbfl_convert_filter *encoder;
+ mbfl_convert_filter *decoder = NULL;
+ mbfl_convert_filter *encoder = NULL;
+ mbfl_convert_filter *tl_filter = NULL;
+ mbfl_convert_filter *next_filter = NULL;
- /* initialize */
+ /* validate parameters */
if (string == NULL || result == NULL) {
return NULL;
}
+
encoding = mbfl_no2encoding(string->no_encoding);
if (encoding == NULL) {
return NULL;
}
+
mbfl_memory_device_init(&device, string->len, 0);
mbfl_string_init(result);
+
result->no_language = string->no_language;
result->no_encoding = string->no_encoding;
+
decoder = mbfl_convert_filter_new(
- mbfl_no_encoding_wchar,
- string->no_encoding,
- mbfl_memory_device_output, 0, &device);
+ mbfl_no_encoding_wchar,
+ string->no_encoding,
+ mbfl_memory_device_output, 0, &device);
+ if (decoder == NULL) {
+ goto out;
+ }
+ next_filter = decoder;
+
+ mbfl_filt_tl_jisx0201_jisx0208_param *param =
+ mbfl_malloc(sizeof(mbfl_filt_tl_jisx0201_jisx0208_param));
+ if (param == NULL) {
+ goto out;
+ }
+
+ param->mode = mode;
+
+ 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);
+ if (tl_filter == NULL) {
+ mbfl_free(param);
+ goto out;
+ }
+
+ tl_filter->opaque = param;
+ next_filter = tl_filter;
+
encoder = mbfl_convert_filter_new(
- string->no_encoding,
- mbfl_no_encoding_wchar,
- collector_hantozen, 0, &pc);
- if (decoder == NULL || encoder == NULL) {
- mbfl_convert_filter_delete(encoder);
- mbfl_convert_filter_delete(decoder);
- return NULL;
+ string->no_encoding,
+ mbfl_no_encoding_wchar,
+ (int(*)(int, void*))next_filter->filter_function,
+ (int(*)(void*))next_filter->filter_flush,
+ next_filter);
+ if (encoder == NULL) {
+ goto out;
}
- pc.next_filter = decoder;
- pc.mode = mode;
- pc.status = 0;
- pc.cache = 0;
/* feed data */
p = string->val;
@@ -1934,11 +1789,22 @@
}
mbfl_convert_filter_flush(encoder);
- collector_hantozen_flush(&pc);
- mbfl_convert_filter_flush(decoder);
result = mbfl_memory_device_result(&device, result);
- mbfl_convert_filter_delete(encoder);
- mbfl_convert_filter_delete(decoder);
+out:
+ if (tl_filter != NULL) {
+ if (tl_filter->opaque != NULL) {
+ mbfl_free(tl_filter->opaque);
+ }
+ mbfl_convert_filter_delete(tl_filter);
+ }
+
+ if (decoder != NULL) {
+ mbfl_convert_filter_delete(decoder);
+ }
+
+ if (encoder != NULL) {
+ mbfl_convert_filter_delete(encoder);
+ }
return result;
}
1.1.2.7 +103 -56 libmbfl/mbfl/mbfl_convert.c
Index: mbfl_convert.c
===================================================================
RCS file: /cvsroot/php-i18n/libmbfl/mbfl/mbfl_convert.c,v
retrieving revision 1.1.2.6
retrieving revision 1.1.2.7
diff -u -r1.1.2.6 -r1.1.2.7
--- mbfl_convert.c 22 Sep 2006 05:32:09 -0000 1.1.2.6
+++ mbfl_convert.c 15 Nov 2006 08:55:07 -0000 1.1.2.7
@@ -61,6 +61,7 @@
#include "filters/mbfilter_cp936.h"
#include "filters/mbfilter_cp1251.h"
#include "filters/mbfilter_cp1252.h"
+#include "filters/mbfilter_cp5022x.h"
#include "filters/mbfilter_iso8859_1.h"
#include "filters/mbfilter_iso8859_2.h"
#include "filters/mbfilter_iso8859_3.h"
@@ -90,8 +91,6 @@
#include "filters/mbfilter_htmlent.h"
#include "filters/mbfilter_armscii8.h"
-static void mbfl_convert_filter_reset_vtbl(mbfl_convert_filter *filter);
-
/* hex character table "0123456789ABCDEF" */
static char mbfl_hexchar_table[] = {
0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x41,0x42,0x43,0x44,0x45,0x46
@@ -106,6 +105,8 @@
&vtbl_wchar_sjis,
&vtbl_jis_wchar,
&vtbl_wchar_jis,
+ &vtbl_jis_ms_wchar,
+ &vtbl_wchar_jis_ms,
&vtbl_2022jp_wchar,
&vtbl_wchar_2022jp,
&vtbl_eucjpwin_wchar,
@@ -136,6 +137,14 @@
&vtbl_wchar_koi8r,
&vtbl_cp1252_wchar,
&vtbl_wchar_cp1252,
+ &vtbl_cp50220_wchar,
+ &vtbl_wchar_cp50220,
+ &vtbl_cp50220raw_wchar,
+ &vtbl_wchar_cp50220raw,
+ &vtbl_cp50221_wchar,
+ &vtbl_wchar_cp50221,
+ &vtbl_cp50222_wchar,
+ &vtbl_wchar_cp50222,
&vtbl_ascii_wchar,
&vtbl_wchar_ascii,
&vtbl_8859_1_wchar,
@@ -215,6 +224,47 @@
NULL
};
+static int
+mbfl_convert_filter_common_init(
+ mbfl_convert_filter *filter,
+ enum mbfl_no_encoding from,
+ enum mbfl_no_encoding to,
+ const struct mbfl_convert_vtbl *vtbl,
+ int (*output_function)(int, void* ),
+ int (*flush_function)(void*),
+ void* data)
+{
+ /* encoding structure */
+ if ((filter->from = mbfl_no2encoding(from)) == NULL) {
+ return 1;
+ }
+
+ if ((filter->to = mbfl_no2encoding(to)) == NULL) {
+ return 1;
+ }
+
+ if (output_function != NULL) {
+ filter->output_function = output_function;
+ } else {
+ filter->output_function = mbfl_filter_output_null;
+ }
+
+ filter->flush_function = flush_function;
+ filter->data = data;
+ filter->illegal_mode = MBFL_OUTPUTFILTER_ILLEGAL_MODE_CHAR;
+ filter->illegal_substchar = 0x3f; /* '?' */
+ filter->filter_ctor = vtbl->filter_ctor;
+ filter->filter_dtor = vtbl->filter_dtor;
+ filter->filter_function = vtbl->filter_function;
+ filter->filter_flush = vtbl->filter_flush;
+ filter->filter_copy = vtbl->filter_copy;
+
+ (*filter->filter_ctor)(filter);
+
+ return 0;
+}
+
+
mbfl_convert_filter *
mbfl_convert_filter_new(
enum mbfl_no_encoding from,
@@ -224,6 +274,13 @@
void* data)
{
mbfl_convert_filter * filter;
+ const struct mbfl_convert_vtbl *vtbl;
+
+ vtbl = mbfl_convert_filter_get_vtbl(from, to);
+
+ if (vtbl == NULL) {
+ vtbl = &vtbl_pass;
+ }
/* allocate */
filter = (mbfl_convert_filter *)mbfl_malloc(sizeof(mbfl_convert_filter));
@@ -231,32 +288,45 @@
return NULL;
}
- /* encoding structure */
- filter->from = mbfl_no2encoding(from);
- filter->to = mbfl_no2encoding(to);
- if (filter->from == NULL) {
- filter->from = &mbfl_encoding_pass;
+ if (mbfl_convert_filter_common_init(filter, from, to, vtbl,
+ output_function, flush_function, data)) {
+ mbfl_free(filter);
+ return NULL;
}
- if (filter->to == NULL) {
- filter->to = &mbfl_encoding_pass;
+
+ 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 * filter;
+
+ /* allocate */
+ filter = (mbfl_convert_filter *)mbfl_malloc(sizeof(mbfl_convert_filter));
+ if (filter == NULL) {
+ return NULL;
}
- if (output_function != NULL) {
- filter->output_function = output_function;
- } else {
- filter->output_function = mbfl_filter_output_null;
+ if (vtbl == NULL) {
+ vtbl = &vtbl_pass;
}
+
filter->flush_function = flush_function;
filter->data = data;
filter->illegal_mode = MBFL_OUTPUTFILTER_ILLEGAL_MODE_CHAR;
filter->illegal_substchar = 0x3f; /* '?' */
filter->num_illegalchar = 0;
- /* setup the function table */
- mbfl_convert_filter_reset_vtbl(filter);
-
- /* constructor */
- (*filter->filter_ctor)(filter);
+ if (mbfl_convert_filter_common_init(filter, vtbl->from, vtbl->to, vtbl,
+ output_function, flush_function, data)) {
+ mbfl_free(filter);
+ return NULL;
+ }
return filter;
}
@@ -286,39 +356,32 @@
void mbfl_convert_filter_reset(mbfl_convert_filter *filter,
enum mbfl_no_encoding from, enum mbfl_no_encoding to)
{
+ const struct mbfl_convert_vtbl *vtbl;
+
/* destruct old filter */
(*filter->filter_dtor)(filter);
- /* resset filter member */
- filter->from = mbfl_no2encoding(from);
- filter->to = mbfl_no2encoding(to);
+ vtbl = mbfl_convert_filter_get_vtbl(from, to);
- /* set the vtbl */
- mbfl_convert_filter_reset_vtbl(filter);
+ if (vtbl == NULL) {
+ vtbl = &vtbl_pass;
+ }
- /* construct new filter */
- (*filter->filter_ctor)(filter);
+ mbfl_convert_filter_common_init(filter, from, to, vtbl,
+ filter->output_function, filter->flush_function, filter->data);
}
void
mbfl_convert_filter_copy(
mbfl_convert_filter *src,
- mbfl_convert_filter *dist)
+ mbfl_convert_filter *dest)
{
- dist->filter_ctor = src->filter_ctor;
- dist->filter_dtor = src->filter_dtor;
- dist->filter_function = src->filter_function;
- dist->filter_flush = src->filter_flush;
- dist->output_function = src->output_function;
- dist->flush_function = src->flush_function;
- dist->data = src->data;
- dist->status = src->status;
- dist->cache = src->cache;
- dist->from = src->from;
- dist->to = src->to;
- dist->illegal_mode = src->illegal_mode;
- dist->illegal_substchar = src->illegal_substchar;
- dist->num_illegalchar = src->num_illegalchar;
+ if (src->filter_copy != NULL) {
+ src->filter_copy(src, dest);
+ return;
+ }
+
+ *dest = *src;
}
int mbfl_convert_filter_devcat(mbfl_convert_filter *filter, mbfl_memory_device *src)
@@ -464,22 +527,6 @@
return NULL;
}
-
-static void mbfl_convert_filter_reset_vtbl(mbfl_convert_filter *filter)
-{
- const struct mbfl_convert_vtbl *vtbl;
-
- vtbl = mbfl_convert_filter_get_vtbl(filter->from->no_encoding, filter->to->no_encoding);
- if (vtbl == NULL) {
- vtbl = &vtbl_pass;
- }
-
- filter->filter_ctor = vtbl->filter_ctor;
- filter->filter_dtor = vtbl->filter_dtor;
- filter->filter_function = vtbl->filter_function;
- filter->filter_flush = vtbl->filter_flush;
-}
-
/*
* commonly used constructor and destructor
*/
1.1.2.5 +7 -0 libmbfl/mbfl/mbfl_convert.h
Index: mbfl_convert.h
===================================================================
RCS file: /cvsroot/php-i18n/libmbfl/mbfl/mbfl_convert.h,v
retrieving revision 1.1.2.4
retrieving revision 1.1.2.5
diff -u -r1.1.2.4 -r1.1.2.5
--- mbfl_convert.h 9 Sep 2006 12:17:55 -0000 1.1.2.4
+++ mbfl_convert.h 15 Nov 2006 08:55:07 -0000 1.1.2.5
@@ -40,6 +40,7 @@
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);
@@ -62,6 +63,7 @@
void (*filter_dtor)(mbfl_convert_filter *filter);
int (*filter_function)(int c, mbfl_convert_filter *filter);
int (*filter_flush)(mbfl_convert_filter *filter);
+ void (*filter_copy)(mbfl_convert_filter *src, mbfl_convert_filter *dest);
};
MBFLAPI extern const struct mbfl_convert_vtbl *mbfl_convert_filter_list[];
@@ -72,6 +74,11 @@
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 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_flush(mbfl_convert_filter *filter);
1.1.2.11 +6 -0 libmbfl/mbfl/mbfl_encoding.c
Index: mbfl_encoding.c
===================================================================
RCS file: /cvsroot/php-i18n/libmbfl/mbfl/mbfl_encoding.c,v
retrieving revision 1.1.2.10
retrieving revision 1.1.2.11
diff -u -r1.1.2.10 -r1.1.2.11
--- mbfl_encoding.c 21 Jan 2006 04:02:50 -0000 1.1.2.10
+++ mbfl_encoding.c 15 Nov 2006 08:55:07 -0000 1.1.2.11
@@ -67,6 +67,7 @@
#include "filters/mbfilter_cp936.h"
#include "filters/mbfilter_cp1251.h"
#include "filters/mbfilter_cp1252.h"
+#include "filters/mbfilter_cp5022x.h"
#include "filters/mbfilter_iso8859_1.h"
#include "filters/mbfilter_iso8859_2.h"
#include "filters/mbfilter_iso8859_3.h"
@@ -178,6 +179,11 @@
&mbfl_encoding_cp866,
&mbfl_encoding_koi8r,
&mbfl_encoding_armscii8,
+ &mbfl_encoding_jis_ms,
+ &mbfl_encoding_cp50220,
+ &mbfl_encoding_cp50220raw,
+ &mbfl_encoding_cp50221,
+ &mbfl_encoding_cp50222,
NULL
};
1.1.2.7 +5 -0 libmbfl/mbfl/mbfl_encoding.h
Index: mbfl_encoding.h
===================================================================
RCS file: /cvsroot/php-i18n/libmbfl/mbfl/mbfl_encoding.h,v
retrieving revision 1.1.2.6
retrieving revision 1.1.2.7
diff -u -r1.1.2.6 -r1.1.2.7
--- mbfl_encoding.h 22 Mar 2005 19:41:14 -0000 1.1.2.6
+++ mbfl_encoding.h 15 Nov 2006 08:55:07 -0000 1.1.2.7
@@ -99,6 +99,11 @@
mbfl_no_encoding_koi8r,
mbfl_no_encoding_8859_16,
mbfl_no_encoding_armscii8,
+ mbfl_no_encoding_jis_ms,
+ mbfl_no_encoding_cp50220,
+ mbfl_no_encoding_cp50220raw,
+ mbfl_no_encoding_cp50221,
+ mbfl_no_encoding_cp50222,
mbfl_no_encoding_charset_max
};
1.1.2.1 +10 -2 libmbfl/mbfl/mbfl_filter_output.c
Index: mbfl_filter_output.c
===================================================================
RCS file: /cvsroot/php-i18n/libmbfl/mbfl/mbfl_filter_output.c,v
retrieving revision 1.1
retrieving revision 1.1.2.1
diff -u -r1.1 -r1.1.2.1
--- mbfl_filter_output.c 20 Dec 2002 19:36:28 -0000 1.1
+++ mbfl_filter_output.c 15 Nov 2006 08:55:07 -0000 1.1.2.1
@@ -41,9 +41,17 @@
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;
}
-
-
1.1.2.2 +1 -0 libmbfl/mbfl/mbfl_filter_output.h
Index: mbfl_filter_output.h
===================================================================
RCS file: /cvsroot/php-i18n/libmbfl/mbfl/mbfl_filter_output.h,v
retrieving revision 1.1.2.1
retrieving revision 1.1.2.2
diff -u -r1.1.2.1 -r1.1.2.2
--- mbfl_filter_output.h 25 Aug 2003 01:15:33 -0000 1.1.2.1
+++ mbfl_filter_output.h 15 Nov 2006 08:55:07 -0000 1.1.2.2
@@ -32,6 +32,7 @@
#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 */
1.1.2.5 +6 -0 libmbfl/mbfl/mbfl_ident.c
Index: mbfl_ident.c
===================================================================
RCS file: /cvsroot/php-i18n/libmbfl/mbfl/mbfl_ident.c,v
retrieving revision 1.1.2.4
retrieving revision 1.1.2.5
diff -u -r1.1.2.4 -r1.1.2.5
--- mbfl_ident.c 22 Mar 2005 19:41:14 -0000 1.1.2.4
+++ mbfl_ident.c 15 Nov 2006 08:55:07 -0000 1.1.2.5
@@ -60,6 +60,7 @@
#include "filters/mbfilter_cp936.h"
#include "filters/mbfilter_cp1251.h"
#include "filters/mbfilter_cp1252.h"
+#include "filters/mbfilter_cp5022x.h"
#include "filters/mbfilter_iso8859_1.h"
#include "filters/mbfilter_iso8859_2.h"
#include "filters/mbfilter_iso8859_3.h"
@@ -105,6 +106,7 @@
&vtbl_identify_eucjpwin,
&vtbl_identify_sjiswin,
&vtbl_identify_jis,
+ &vtbl_identify_jis_ms,
&vtbl_identify_2022jp,
&vtbl_identify_euccn,
&vtbl_identify_cp936,
@@ -132,6 +134,10 @@
&vtbl_identify_8859_14,
&vtbl_identify_8859_15,
&vtbl_identify_armscii8,
+ &vtbl_identify_jis_ms,
+ &vtbl_identify_cp50220,
+ &vtbl_identify_cp50221,
+ &vtbl_identify_cp50222,
&vtbl_identify_false,
NULL
};
No revision
No revision
1.1.2.1 +33 -0 libmbfl/tests/conv_encoding.tests/Attic/cp51932_cp50220raw.exp