mbfl_no_encoding_armscii8,
"ArmSCII-8",
"ArmSCII-8",
- (const char *(*)[])&mbfl_encoding_armscii8_aliases,
+ mbfl_encoding_armscii8_aliases,
NULL,
MBFL_ENCTYPE_SBCS,
&vtbl_armscii8_wchar,
mbfl_no_encoding_ascii,
"ASCII",
"US-ASCII", /* preferred MIME name */
- (const char *(*)[])&mbfl_encoding_ascii_aliases,
+ mbfl_encoding_ascii_aliases,
NULL,
MBFL_ENCTYPE_SBCS,
&vtbl_ascii_wchar,
mbfl_no_encoding_big5,
"BIG-5",
"BIG5",
- (const char *(*)[])&mbfl_encoding_big5_aliases,
+ mbfl_encoding_big5_aliases,
mblen_table_big5,
MBFL_ENCTYPE_MBCS | MBFL_ENCTYPE_GL_UNSAFE,
&vtbl_big5_wchar,
mbfl_no_encoding_cp1251,
"Windows-1251",
"Windows-1251",
- (const char *(*)[])&mbfl_encoding_cp1251_aliases,
+ mbfl_encoding_cp1251_aliases,
NULL,
MBFL_ENCTYPE_SBCS,
&vtbl_cp1251_wchar,
mbfl_no_encoding_cp1252,
"Windows-1252",
"Windows-1252",
- (const char *(*)[])&mbfl_encoding_cp1252_aliases,
+ mbfl_encoding_cp1252_aliases,
NULL,
MBFL_ENCTYPE_SBCS,
&vtbl_cp1252_wchar,
mbfl_no_encoding_cp1254,
"Windows-1254",
"Windows-1254",
- (const char *(*)[])&mbfl_encoding_cp1254_aliases,
+ mbfl_encoding_cp1254_aliases,
NULL,
MBFL_ENCTYPE_SBCS,
&vtbl_cp1254_wchar,
mbfl_no_encoding_cp50220,
"CP50220",
"ISO-2022-JP",
- (const char *(*)[])NULL,
+ NULL,
NULL,
MBFL_ENCTYPE_MBCS | MBFL_ENCTYPE_GL_UNSAFE,
&vtbl_cp50220_wchar,
mbfl_no_encoding_cp50220raw,
"CP50220raw",
"ISO-2022-JP",
- (const char *(*)[])NULL,
+ NULL,
NULL,
MBFL_ENCTYPE_MBCS | MBFL_ENCTYPE_GL_UNSAFE,
&vtbl_cp50220raw_wchar,
mbfl_no_encoding_cp51932,
"CP51932",
"CP51932",
- (const char *(*)[])&mbfl_encoding_cp51932_aliases,
+ mbfl_encoding_cp51932_aliases,
mblen_table_eucjp,
MBFL_ENCTYPE_MBCS,
&vtbl_cp51932_wchar,
mbfl_no_encoding_cp850,
"CP850",
"CP850",
- (const char *(*)[])&mbfl_encoding_cp850_aliases,
+ mbfl_encoding_cp850_aliases,
NULL,
MBFL_ENCTYPE_SBCS,
&vtbl_cp850_wchar,
mbfl_no_encoding_cp866,
"CP866",
"CP866",
- (const char *(*)[])&mbfl_encoding_cp866_aliases,
+ mbfl_encoding_cp866_aliases,
NULL,
MBFL_ENCTYPE_SBCS,
&vtbl_cp866_wchar,
mbfl_no_encoding_cp932,
"CP932",
"Shift_JIS",
- (const char *(*)[])&mbfl_encoding_cp932_aliases,
+ mbfl_encoding_cp932_aliases,
mblen_table_sjis,
MBFL_ENCTYPE_MBCS | MBFL_ENCTYPE_GL_UNSAFE,
&vtbl_cp932_wchar,
mbfl_no_encoding_cp936,
"CP936",
"CP936",
- (const char *(*)[])&mbfl_encoding_cp936_aliases,
+ mbfl_encoding_cp936_aliases,
mblen_table_cp936,
MBFL_ENCTYPE_MBCS | MBFL_ENCTYPE_GL_UNSAFE,
&vtbl_cp936_wchar,
mbfl_no_encoding_euc_cn,
"EUC-CN",
"CN-GB",
- (const char *(*)[])&mbfl_encoding_euc_cn_aliases,
+ mbfl_encoding_euc_cn_aliases,
mblen_table_euccn,
MBFL_ENCTYPE_MBCS,
&vtbl_euccn_wchar,
mbfl_no_encoding_euc_jp,
"EUC-JP",
"EUC-JP",
- (const char *(*)[])&mbfl_encoding_euc_jp_aliases,
+ mbfl_encoding_euc_jp_aliases,
mblen_table_eucjp,
MBFL_ENCTYPE_MBCS,
&vtbl_eucjp_wchar,
mbfl_no_encoding_eucjp2004,
"EUC-JP-2004",
"EUC-JP",
- (const char *(*)[])&mbfl_encoding_eucjp2004_aliases,
+ mbfl_encoding_eucjp2004_aliases,
mblen_table_eucjp,
MBFL_ENCTYPE_MBCS,
&vtbl_eucjp2004_wchar,
mbfl_no_encoding_eucjp_win,
"eucJP-win",
"EUC-JP",
- (const char *(*)[])&mbfl_encoding_eucjp_win_aliases,
+ mbfl_encoding_eucjp_win_aliases,
mblen_table_eucjp,
MBFL_ENCTYPE_MBCS,
&vtbl_eucjpwin_wchar,
mbfl_no_encoding_euc_kr,
"EUC-KR",
"EUC-KR",
- (const char *(*)[])&mbfl_encoding_euc_kr_aliases,
+ mbfl_encoding_euc_kr_aliases,
mblen_table_euckr,
MBFL_ENCTYPE_MBCS,
&vtbl_euckr_wchar,
mbfl_no_encoding_euc_tw,
"EUC-TW",
"EUC-TW",
- (const char *(*)[])&mbfl_encoding_euc_tw_aliases,
+ mbfl_encoding_euc_tw_aliases,
mblen_table_euctw,
MBFL_ENCTYPE_MBCS,
&vtbl_euctw_wchar,
mbfl_no_encoding_gb18030,
"GB18030",
"GB18030",
- (const char *(*)[])&mbfl_encoding_gb18030_aliases,
+ mbfl_encoding_gb18030_aliases,
NULL,
MBFL_ENCTYPE_MBCS | MBFL_ENCTYPE_GL_UNSAFE,
&vtbl_gb18030_wchar,
mbfl_no_encoding_html_ent,
"HTML-ENTITIES",
"HTML-ENTITIES",
- (const char *(*)[])&mbfl_encoding_html_ent_aliases,
+ mbfl_encoding_html_ent_aliases,
NULL,
MBFL_ENCTYPE_GL_UNSAFE,
&vtbl_html_wchar,
mbfl_no_encoding_2022jpms,
"ISO-2022-JP-MS",
"ISO-2022-JP",
- (const char *(*)[])&mbfl_encoding_2022jpms_aliases,
+ mbfl_encoding_2022jpms_aliases,
NULL,
MBFL_ENCTYPE_MBCS | MBFL_ENCTYPE_GL_UNSAFE,
&vtbl_2022jpms_wchar,
mbfl_no_encoding_2022jp_kddi,
"ISO-2022-JP-MOBILE#KDDI",
"ISO-2022-JP",
- (const char *(*)[])&mbfl_encoding_2022jp_kddi_aliases,
+ mbfl_encoding_2022jp_kddi_aliases,
NULL,
MBFL_ENCTYPE_MBCS | MBFL_ENCTYPE_GL_UNSAFE,
&vtbl_2022jp_kddi_wchar,
mbfl_no_encoding_8859_1,
"ISO-8859-1",
"ISO-8859-1",
- (const char *(*)[])&mbfl_encoding_8859_1_aliases,
+ mbfl_encoding_8859_1_aliases,
NULL,
MBFL_ENCTYPE_SBCS,
&vtbl_8859_1_wchar,
mbfl_no_encoding_8859_10,
"ISO-8859-10",
"ISO-8859-10",
- (const char *(*)[])&mbfl_encoding_8859_10_aliases,
+ mbfl_encoding_8859_10_aliases,
NULL,
MBFL_ENCTYPE_SBCS,
&vtbl_8859_10_wchar,
mbfl_no_encoding_8859_13,
"ISO-8859-13",
"ISO-8859-13",
- (const char *(*)[])&mbfl_encoding_8859_13_aliases,
+ mbfl_encoding_8859_13_aliases,
NULL,
MBFL_ENCTYPE_SBCS,
&vtbl_8859_13_wchar,
mbfl_no_encoding_8859_14,
"ISO-8859-14",
"ISO-8859-14",
- (const char *(*)[])&mbfl_encoding_8859_14_aliases,
+ mbfl_encoding_8859_14_aliases,
NULL,
MBFL_ENCTYPE_SBCS,
&vtbl_8859_14_wchar,
mbfl_no_encoding_8859_15,
"ISO-8859-15",
"ISO-8859-15",
- (const char *(*)[])&mbfl_encoding_8859_15_aliases,
+ mbfl_encoding_8859_15_aliases,
NULL,
MBFL_ENCTYPE_SBCS,
&vtbl_8859_15_wchar,
mbfl_no_encoding_8859_16,
"ISO-8859-16",
"ISO-8859-16",
- (const char *(*)[])&mbfl_encoding_8859_16_aliases,
+ mbfl_encoding_8859_16_aliases,
NULL,
MBFL_ENCTYPE_SBCS,
&vtbl_8859_16_wchar,
mbfl_no_encoding_8859_2,
"ISO-8859-2",
"ISO-8859-2",
- (const char *(*)[])&mbfl_encoding_8859_2_aliases,
+ mbfl_encoding_8859_2_aliases,
NULL,
MBFL_ENCTYPE_SBCS,
&vtbl_8859_2_wchar,
mbfl_no_encoding_8859_3,
"ISO-8859-3",
"ISO-8859-3",
- (const char *(*)[])&mbfl_encoding_8859_3_aliases,
+ mbfl_encoding_8859_3_aliases,
NULL,
MBFL_ENCTYPE_SBCS,
&vtbl_8859_3_wchar,
mbfl_no_encoding_8859_4,
"ISO-8859-4",
"ISO-8859-4",
- (const char *(*)[])&mbfl_encoding_8859_4_aliases,
+ mbfl_encoding_8859_4_aliases,
NULL,
MBFL_ENCTYPE_SBCS,
&vtbl_8859_4_wchar,
mbfl_no_encoding_8859_5,
"ISO-8859-5",
"ISO-8859-5",
- (const char *(*)[])&mbfl_encoding_8859_5_aliases,
+ mbfl_encoding_8859_5_aliases,
NULL,
MBFL_ENCTYPE_SBCS,
&vtbl_8859_5_wchar,
mbfl_no_encoding_8859_6,
"ISO-8859-6",
"ISO-8859-6",
- (const char *(*)[])&mbfl_encoding_8859_6_aliases,
+ mbfl_encoding_8859_6_aliases,
NULL,
MBFL_ENCTYPE_SBCS,
&vtbl_8859_6_wchar,
mbfl_no_encoding_8859_7,
"ISO-8859-7",
"ISO-8859-7",
- (const char *(*)[])&mbfl_encoding_8859_7_aliases,
+ mbfl_encoding_8859_7_aliases,
NULL,
MBFL_ENCTYPE_SBCS,
&vtbl_8859_7_wchar,
mbfl_no_encoding_8859_8,
"ISO-8859-8",
"ISO-8859-8",
- (const char *(*)[])&mbfl_encoding_8859_8_aliases,
+ mbfl_encoding_8859_8_aliases,
NULL,
MBFL_ENCTYPE_SBCS,
&vtbl_8859_8_wchar,
mbfl_no_encoding_8859_9,
"ISO-8859-9",
"ISO-8859-9",
- (const char *(*)[])&mbfl_encoding_8859_9_aliases,
+ mbfl_encoding_8859_9_aliases,
NULL,
MBFL_ENCTYPE_SBCS,
&vtbl_8859_9_wchar,
mbfl_no_encoding_koi8r,
"KOI8-R",
"KOI8-R",
- (const char *(*)[])&mbfl_encoding_koi8r_aliases,
+ mbfl_encoding_koi8r_aliases,
NULL,
MBFL_ENCTYPE_SBCS,
&vtbl_koi8r_wchar,
mbfl_no_encoding_koi8u,
"KOI8-U",
"KOI8-U",
- (const char *(*)[])&mbfl_encoding_koi8u_aliases,
+ mbfl_encoding_koi8u_aliases,
NULL,
MBFL_ENCTYPE_SBCS,
&vtbl_koi8u_wchar,
mbfl_no_encoding_qprint,
"Quoted-Printable",
"Quoted-Printable",
- (const char *(*)[])&mbfl_encoding_qprint_aliases,
+ mbfl_encoding_qprint_aliases,
NULL,
MBFL_ENCTYPE_GL_UNSAFE,
NULL,
mbfl_no_encoding_sjis,
"SJIS",
"Shift_JIS",
- (const char *(*)[])&mbfl_encoding_sjis_aliases,
+ mbfl_encoding_sjis_aliases,
mblen_table_sjis,
MBFL_ENCTYPE_MBCS | MBFL_ENCTYPE_GL_UNSAFE,
&vtbl_sjis_wchar,
mbfl_no_encoding_sjis2004,
"SJIS-2004",
"Shift_JIS",
- (const char *(*)[])&mbfl_encoding_sjis2004_aliases,
+ mbfl_encoding_sjis2004_aliases,
mblen_table_sjis,
MBFL_ENCTYPE_MBCS | MBFL_ENCTYPE_GL_UNSAFE,
&vtbl_sjis2004_wchar,
mbfl_no_encoding_sjis_mac,
"SJIS-mac",
"Shift_JIS",
- (const char *(*)[])&mbfl_encoding_sjis_mac_aliases,
+ mbfl_encoding_sjis_mac_aliases,
mblen_table_sjis,
MBFL_ENCTYPE_MBCS | MBFL_ENCTYPE_GL_UNSAFE,
&vtbl_sjis_mac_wchar,
mbfl_no_encoding_sjis_docomo,
"SJIS-Mobile#DOCOMO",
"Shift_JIS",
- (const char *(*)[])&mbfl_encoding_sjis_docomo_aliases,
+ mbfl_encoding_sjis_docomo_aliases,
mblen_table_sjis,
MBFL_ENCTYPE_MBCS | MBFL_ENCTYPE_GL_UNSAFE,
&vtbl_sjis_docomo_wchar,
mbfl_no_encoding_sjis_kddi,
"SJIS-Mobile#KDDI",
"Shift_JIS",
- (const char *(*)[])&mbfl_encoding_sjis_kddi_aliases,
+ mbfl_encoding_sjis_kddi_aliases,
mblen_table_sjis,
MBFL_ENCTYPE_MBCS | MBFL_ENCTYPE_GL_UNSAFE,
&vtbl_sjis_kddi_wchar,
mbfl_no_encoding_sjis_sb,
"SJIS-Mobile#SOFTBANK",
"Shift_JIS",
- (const char *(*)[])&mbfl_encoding_sjis_sb_aliases,
+ mbfl_encoding_sjis_sb_aliases,
mblen_table_sjis,
MBFL_ENCTYPE_MBCS | MBFL_ENCTYPE_GL_UNSAFE,
&vtbl_sjis_sb_wchar,
mbfl_no_encoding_sjis_open,
"SJIS-win",
"Shift_JIS",
- (const char *(*)[])&mbfl_encoding_sjis_open_aliases,
+ mbfl_encoding_sjis_open_aliases,
mblen_table_sjis,
MBFL_ENCTYPE_MBCS | MBFL_ENCTYPE_GL_UNSAFE,
&vtbl_sjis_open_wchar,
mbfl_no_encoding_ucs2,
"UCS-2",
"UCS-2",
- (const char *(*)[])&mbfl_encoding_ucs2_aliases,
+ mbfl_encoding_ucs2_aliases,
NULL,
MBFL_ENCTYPE_WCS2BE,
&vtbl_ucs2_wchar,
mbfl_no_encoding_ucs4,
"UCS-4",
"UCS-4",
- (const char *(*)[])&mbfl_encoding_ucs4_aliases,
+ mbfl_encoding_ucs4_aliases,
NULL,
MBFL_ENCTYPE_WCS4BE,
&vtbl_ucs4_wchar,
mbfl_no_encoding_uhc,
"UHC",
"UHC",
- (const char *(*)[])&mbfl_encoding_uhc_aliases,
+ mbfl_encoding_uhc_aliases,
mblen_table_uhc,
MBFL_ENCTYPE_MBCS,
&vtbl_uhc_wchar,
mbfl_no_encoding_utf16,
"UTF-16",
"UTF-16",
- (const char *(*)[])&mbfl_encoding_utf16_aliases,
+ mbfl_encoding_utf16_aliases,
NULL,
MBFL_ENCTYPE_MWC2BE,
&vtbl_utf16_wchar,
mbfl_no_encoding_utf32,
"UTF-32",
"UTF-32",
- (const char *(*)[])&mbfl_encoding_utf32_aliases,
+ mbfl_encoding_utf32_aliases,
NULL,
MBFL_ENCTYPE_WCS4BE,
&vtbl_utf32_wchar,
mbfl_no_encoding_utf7,
"UTF-7",
"UTF-7",
- (const char *(*)[])&mbfl_encoding_utf7_aliases,
+ mbfl_encoding_utf7_aliases,
NULL,
MBFL_ENCTYPE_MBCS | MBFL_ENCTYPE_GL_UNSAFE,
&vtbl_utf7_wchar,
mbfl_no_encoding_utf8,
"UTF-8",
"UTF-8",
- (const char *(*)[])&mbfl_encoding_utf8_aliases,
+ mbfl_encoding_utf8_aliases,
mblen_table_utf8,
MBFL_ENCTYPE_MBCS,
&vtbl_utf8_wchar,
mbfl_no_encoding_utf8_docomo,
"UTF-8-Mobile#DOCOMO",
"UTF-8",
- (const char *(*)[])&mbfl_encoding_utf8_docomo_aliases,
+ mbfl_encoding_utf8_docomo_aliases,
mblen_table_utf8,
MBFL_ENCTYPE_MBCS,
&vtbl_utf8_docomo_wchar,
mbfl_no_encoding_utf8_kddi_a,
"UTF-8-Mobile#KDDI-A",
"UTF-8",
- (const char *(*)[])&mbfl_encoding_utf8_kddi_a_aliases,
+ mbfl_encoding_utf8_kddi_a_aliases,
mblen_table_utf8,
MBFL_ENCTYPE_MBCS,
&vtbl_utf8_kddi_a_wchar,
mbfl_no_encoding_utf8_kddi_b,
"UTF-8-Mobile#KDDI-B",
"UTF-8",
- (const char *(*)[])&mbfl_encoding_utf8_kddi_b_aliases,
+ mbfl_encoding_utf8_kddi_b_aliases,
mblen_table_utf8,
MBFL_ENCTYPE_MBCS,
&vtbl_utf8_kddi_b_wchar,
mbfl_no_encoding_utf8_sb,
"UTF-8-Mobile#SOFTBANK",
"UTF-8",
- (const char *(*)[])&mbfl_encoding_utf8_sb_aliases,
+ mbfl_encoding_utf8_sb_aliases,
mblen_table_utf8,
MBFL_ENCTYPE_MBCS,
&vtbl_utf8_sb_wchar,
const mbfl_encoding *
mbfl_identify_encoding(mbfl_string *string, const mbfl_encoding **elist, int elistsz, int strict)
{
- int i, num, bad;
+ int i, bad;
size_t n;
unsigned char *p;
mbfl_identify_filter *flist, *filter;
/* flist is an array of mbfl_identify_filter instances */
flist = ecalloc(elistsz, sizeof(mbfl_identify_filter));
- num = 0;
if (elist != NULL) {
for (i = 0; i < elistsz; i++) {
- if (!mbfl_identify_filter_init2(&flist[num], elist[i])) {
- num++;
- }
+ mbfl_identify_filter_init2(&flist[i], elist[i]);
}
}
if (p != NULL) {
bad = 0;
while (n > 0) {
- for (i = 0; i < num; i++) {
+ for (i = 0; i < elistsz; i++) {
filter = &flist[i];
if (!filter->flag) {
(*filter->filter_function)(*p, filter);
}
}
}
- if ((num - 1) <= bad && !strict) {
+ if ((elistsz - 1) <= bad && !strict) {
break;
}
p++;
/* judge */
encoding = NULL;
- for (i = 0; i < num; i++) {
+ for (i = 0; i < elistsz; i++) {
filter = &flist[i];
if (!filter->flag) {
if (strict && filter->status) {
/* fall-back judge */
if (!encoding) {
- for (i = 0; i < num; i++) {
+ for (i = 0; i < elistsz; i++) {
filter = &flist[i];
if (!filter->flag && (!strict || !filter->status)) {
encoding = filter->encoding;
mbfl_no_encoding_8bit,
"8bit",
"8bit",
- (const char *(*)[])&mbfl_encoding_8bit_aliases,
+ mbfl_encoding_8bit_aliases,
NULL,
MBFL_ENCTYPE_SBCS,
&vtbl_8bit_wchar,
mbfl_no_encoding_pass,
"pass",
NULL,
- (const char *(*)[])&mbfl_encoding_pass_aliases,
+ mbfl_encoding_pass_aliases,
NULL,
0,
NULL,
NULL
};
-/* encoding resolver */
-const mbfl_encoding *
-mbfl_name2encoding(const char *name)
+const mbfl_encoding *mbfl_name2encoding(const char *name)
{
- const mbfl_encoding *encoding;
- int i, j;
+ const mbfl_encoding **encoding;
- if (name == NULL) {
- return NULL;
- }
-
- i = 0;
- while ((encoding = mbfl_encoding_ptr_list[i++]) != NULL){
- if (strcasecmp(encoding->name, name) == 0) {
- return encoding;
+ for (encoding = mbfl_encoding_ptr_list; *encoding; encoding++) {
+ if (strcasecmp((*encoding)->name, name) == 0) {
+ return *encoding;
}
}
- /* serch MIME charset name */
- i = 0;
- while ((encoding = mbfl_encoding_ptr_list[i++]) != NULL) {
- if (encoding->mime_name != NULL) {
- if (strcasecmp(encoding->mime_name, name) == 0) {
- return encoding;
+ /* search MIME charset name */
+ for (encoding = mbfl_encoding_ptr_list; *encoding; encoding++) {
+ if ((*encoding)->mime_name) {
+ if (strcasecmp((*encoding)->mime_name, name) == 0) {
+ return *encoding;
}
}
}
- /* serch aliases */
- i = 0;
- while ((encoding = mbfl_encoding_ptr_list[i++]) != NULL) {
- if (encoding->aliases != NULL) {
- j = 0;
- while ((*encoding->aliases)[j] != NULL) {
- if (strcasecmp((*encoding->aliases)[j], name) == 0) {
- return encoding;
+ /* search aliases */
+ for (encoding = mbfl_encoding_ptr_list; *encoding; encoding++) {
+ if ((*encoding)->aliases) {
+ for (const char **alias = (*encoding)->aliases; *alias; alias++) {
+ if (strcasecmp(*alias, name) == 0) {
+ return *encoding;
}
- j++;
}
}
}
return NULL;
}
-const mbfl_encoding *
-mbfl_no2encoding(enum mbfl_no_encoding no_encoding)
+const mbfl_encoding *mbfl_no2encoding(enum mbfl_no_encoding no_encoding)
{
- const mbfl_encoding *encoding;
- int i;
+ const mbfl_encoding **encoding;
- i = 0;
- while ((encoding = mbfl_encoding_ptr_list[i++]) != NULL){
- if (encoding->no_encoding == no_encoding) {
- return encoding;
+ for (encoding = mbfl_encoding_ptr_list; *encoding; encoding++) {
+ if ((*encoding)->no_encoding == no_encoding) {
+ return *encoding;
}
}
return NULL;
}
-enum mbfl_no_encoding
-mbfl_name2no_encoding(const char *name)
+enum mbfl_no_encoding mbfl_name2no_encoding(const char *name)
{
- const mbfl_encoding *encoding;
-
- encoding = mbfl_name2encoding(name);
- if (encoding == NULL) {
- return mbfl_no_encoding_invalid;
- } else {
- return encoding->no_encoding;
- }
+ const mbfl_encoding *encoding = mbfl_name2encoding(name);
+ return encoding ? encoding->no_encoding : mbfl_no_encoding_invalid;
}
-const char *
-mbfl_no_encoding2name(enum mbfl_no_encoding no_encoding)
+const char *mbfl_no_encoding2name(enum mbfl_no_encoding no_encoding)
{
- const mbfl_encoding *encoding;
-
- encoding = mbfl_no2encoding(no_encoding);
- if (encoding == NULL) {
- return "";
- } else {
- return encoding->name;
- }
+ const mbfl_encoding *encoding = mbfl_no2encoding(no_encoding);
+ return encoding ? encoding->name : "";
}
-const mbfl_encoding **
-mbfl_get_supported_encodings(void)
+const mbfl_encoding **mbfl_get_supported_encodings(void)
{
return mbfl_encoding_ptr_list;
}
-const char *
-mbfl_no2preferred_mime_name(enum mbfl_no_encoding no_encoding)
+const char *mbfl_no2preferred_mime_name(enum mbfl_no_encoding no_encoding)
{
- const mbfl_encoding *encoding;
+ return mbfl_encoding_preferred_mime_name(mbfl_no2encoding(no_encoding));
+}
- encoding = mbfl_no2encoding(no_encoding);
- if (encoding != NULL && encoding->mime_name != NULL && encoding->mime_name[0] != '\0') {
+const char *mbfl_encoding_preferred_mime_name(const mbfl_encoding *encoding)
+{
+ if (encoding->mime_name && encoding->mime_name[0] != '\0') {
return encoding->mime_name;
- } else {
- return NULL;
}
+ return NULL;
}
enum mbfl_no_encoding no_encoding;
const char *name;
const char *mime_name;
- const char *(*aliases)[];
+ const char **aliases;
const unsigned char *mblen_table;
unsigned int flag;
const struct mbfl_convert_vtbl *input_filter;
const struct mbfl_convert_vtbl *output_filter;
} mbfl_encoding;
-MBFLAPI extern const mbfl_encoding * mbfl_name2encoding(const char *name);
-MBFLAPI extern const mbfl_encoding * mbfl_no2encoding(enum mbfl_no_encoding no_encoding);
+MBFLAPI extern const mbfl_encoding *mbfl_name2encoding(const char *name);
+MBFLAPI extern const mbfl_encoding *mbfl_no2encoding(enum mbfl_no_encoding no_encoding);
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 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 const char *mbfl_encoding_preferred_mime_name(const mbfl_encoding *encoding);
#endif /* MBFL_ENCODING_H */
NULL
};
-/*
- * identify filter
- */
-const struct mbfl_identify_vtbl * mbfl_identify_filter_get_vtbl(enum mbfl_no_encoding encoding)
+const struct mbfl_identify_vtbl* mbfl_identify_filter_get_vtbl(enum mbfl_no_encoding encoding)
{
- const struct mbfl_identify_vtbl * vtbl;
- int i;
+ const struct mbfl_identify_vtbl** vtbl;
- i = 0;
- while ((vtbl = mbfl_identify_filter_list[i++]) != NULL) {
- if (vtbl->encoding == encoding) {
- break;
+ for (vtbl = mbfl_identify_filter_list; *vtbl; vtbl++) {
+ if ((*vtbl)->encoding == encoding) {
+ return *vtbl;
}
}
- return vtbl;
+ return NULL;
}
mbfl_identify_filter *mbfl_identify_filter_new(enum mbfl_no_encoding encoding)
{
mbfl_identify_filter *filter = emalloc(sizeof(mbfl_identify_filter));
- if (mbfl_identify_filter_init(filter, encoding)) {
- efree(filter);
- return NULL;
- }
-
+ mbfl_identify_filter_init(filter, encoding);
return filter;
}
mbfl_identify_filter *mbfl_identify_filter_new2(const mbfl_encoding *encoding)
{
mbfl_identify_filter *filter = emalloc(sizeof(mbfl_identify_filter));
- if (mbfl_identify_filter_init2(filter, encoding)) {
- efree(filter);
- return NULL;
- }
-
+ mbfl_identify_filter_init2(filter, encoding);
return filter;
}
-
-int mbfl_identify_filter_init(mbfl_identify_filter *filter, enum mbfl_no_encoding encoding)
+void mbfl_identify_filter_init(mbfl_identify_filter *filter, enum mbfl_no_encoding encoding)
{
const mbfl_encoding *enc = mbfl_no2encoding(encoding);
- return mbfl_identify_filter_init2(filter, enc ? enc: &mbfl_encoding_pass);
+ mbfl_identify_filter_init2(filter, enc ? enc : &mbfl_encoding_pass);
}
-int mbfl_identify_filter_init2(mbfl_identify_filter *filter, const mbfl_encoding *encoding)
+void mbfl_identify_filter_init2(mbfl_identify_filter *filter, const mbfl_encoding *encoding)
{
- const struct mbfl_identify_vtbl *vtbl;
-
- /* encoding structure */
filter->encoding = encoding;
-
- filter->status = 0;
- filter->flag = 0;
- filter->score = 0;
+ filter->status = filter->flag = filter->score = 0;
/* setup the function table */
- vtbl = mbfl_identify_filter_get_vtbl(filter->encoding->no_encoding);
+ const struct mbfl_identify_vtbl *vtbl = mbfl_identify_filter_get_vtbl(filter->encoding->no_encoding);
if (vtbl == NULL) {
vtbl = &vtbl_identify_false;
}
filter->filter_ctor = vtbl->filter_ctor;
filter->filter_function = vtbl->filter_function;
- /* constructor */
(*filter->filter_ctor)(filter);
-
- return 0;
}
void mbfl_identify_filter_delete(mbfl_identify_filter *filter)
{
- if (filter == NULL) {
- return;
- }
-
- efree((void*)filter);
+ efree(filter);
}
void mbfl_filt_ident_common_ctor(mbfl_identify_filter *filter)
{
- filter->status = 0;
- filter->flag = 0;
+ filter->status = filter->flag = 0;
}
+/* A (useless) filter which says that _every_ string is invalid in a certain encoding.
+ * Obviously, that cannot be true. Remove after all encodings have proper identify filters */
int mbfl_filt_ident_false(int c, mbfl_identify_filter *filter)
{
filter->flag = 1; /* bad */
filter->flag = 1;
}
+/* For encodings in which _every_ possible input string is valid */
int mbfl_filt_ident_true(int c, mbfl_identify_filter *filter)
{
return c;
MBFLAPI extern mbfl_identify_filter * mbfl_identify_filter_new(enum mbfl_no_encoding encoding);
MBFLAPI extern mbfl_identify_filter * mbfl_identify_filter_new2(const mbfl_encoding *encoding);
MBFLAPI extern void mbfl_identify_filter_delete(mbfl_identify_filter *filter);
-MBFLAPI extern int mbfl_identify_filter_init(mbfl_identify_filter *filter, enum mbfl_no_encoding encoding);
-MBFLAPI extern int mbfl_identify_filter_init2(mbfl_identify_filter *filter, const mbfl_encoding *encoding);
+MBFLAPI extern void mbfl_identify_filter_init(mbfl_identify_filter *filter, enum mbfl_no_encoding encoding);
+MBFLAPI extern void mbfl_identify_filter_init2(mbfl_identify_filter *filter, const mbfl_encoding *encoding);
MBFLAPI extern void mbfl_filt_ident_common_ctor(mbfl_identify_filter *filter);
MBFLAPI extern void mbfl_filt_ident_false_ctor(mbfl_identify_filter *filter);
/*
* memory device output functions
*/
-void
-mbfl_memory_device_init(mbfl_memory_device *device, size_t initsz, size_t allocsz)
+void mbfl_memory_device_init(mbfl_memory_device *device, size_t initsz, size_t allocsz)
{
- if (device) {
- device->length = 0;
- device->buffer = NULL;
- if (initsz > 0) {
- device->buffer = emalloc(initsz);
- device->length = initsz;
- }
- device->pos = 0;
- if (allocsz > MBFL_MEMORY_DEVICE_ALLOC_SIZE) {
- device->allocsz = allocsz;
- } else {
- device->allocsz = MBFL_MEMORY_DEVICE_ALLOC_SIZE;
- }
- }
+ device->buffer = (initsz > 0) ? emalloc(initsz) : NULL;
+ device->length = initsz;
+ device->pos = 0;
+ device->allocsz = MAX(allocsz, MBFL_MEMORY_DEVICE_ALLOC_SIZE);
}
-void
-mbfl_memory_device_realloc(mbfl_memory_device *device, size_t initsz, size_t allocsz)
+void mbfl_memory_device_realloc(mbfl_memory_device *device, size_t initsz, size_t allocsz)
{
- if (device) {
- if (initsz > device->length) {
- device->buffer = erealloc(device->buffer, initsz);
- device->length = initsz;
- }
- if (allocsz > MBFL_MEMORY_DEVICE_ALLOC_SIZE) {
- device->allocsz = allocsz;
- } else {
- device->allocsz = MBFL_MEMORY_DEVICE_ALLOC_SIZE;
- }
+ if (initsz > device->length) {
+ device->buffer = erealloc(device->buffer, initsz);
+ device->length = initsz;
}
+ device->allocsz = MAX(allocsz, MBFL_MEMORY_DEVICE_ALLOC_SIZE);
}
-void
-mbfl_memory_device_clear(mbfl_memory_device *device)
+void mbfl_memory_device_clear(mbfl_memory_device *device)
{
- if (device) {
- if (device->buffer) {
- efree(device->buffer);
- }
- device->buffer = NULL;
- device->length = 0;
- device->pos = 0;
+ if (device->buffer) {
+ efree(device->buffer);
}
+ device->buffer = NULL;
+ device->length = device->pos = 0;
}
-void
-mbfl_memory_device_reset(mbfl_memory_device *device)
+void mbfl_memory_device_reset(mbfl_memory_device *device)
{
- if (device) {
- device->pos = 0;
- }
+ device->pos = 0;
}
-void
-mbfl_memory_device_unput(mbfl_memory_device *device)
+void mbfl_memory_device_unput(mbfl_memory_device *device)
{
if (device->pos > 0) {
device->pos--;
}
}
-mbfl_string *
-mbfl_memory_device_result(mbfl_memory_device *device, mbfl_string *result)
+mbfl_string* mbfl_memory_device_result(mbfl_memory_device *device, mbfl_string *result)
{
- if (device && result) {
- result->len = device->pos;
- mbfl_memory_device_output('\0', device);
- result->val = device->buffer;
- device->buffer = NULL;
- device->length = 0;
- device->pos= 0;
- if (result->val == NULL) {
- result->len = 0;
- result = NULL;
- }
- } else {
- result = NULL;
- }
-
+ result->len = device->pos;
+ mbfl_memory_device_output('\0', device);
+ result->val = device->buffer;
+ device->buffer = NULL;
+ device->length = device->pos = 0;
return result;
}
-int
-mbfl_memory_device_output(int c, void *data)
+int mbfl_memory_device_output(int c, void *data)
{
mbfl_memory_device *device = (mbfl_memory_device *)data;
if (device->pos >= device->length) {
/* reallocate buffer */
- size_t newlen;
if (device->length > SIZE_MAX - device->allocsz) {
/* overflow */
return -1;
}
- newlen = device->length + device->allocsz;
+ size_t newlen = device->length + device->allocsz;
device->buffer = erealloc(device->buffer, newlen);
device->length = newlen;
}
return c;
}
-int
-mbfl_memory_device_strcat(mbfl_memory_device *device, const char *psrc)
+int mbfl_memory_device_strcat(mbfl_memory_device *device, const char *psrc)
{
return mbfl_memory_device_strncat(device, psrc, strlen(psrc));
}
-int
-mbfl_memory_device_strncat(mbfl_memory_device *device, const char *psrc, size_t len)
+int mbfl_memory_device_strncat(mbfl_memory_device *device, const char *psrc, size_t len)
{
- unsigned char *w;
-
if (len > device->length - device->pos) {
/* reallocate buffer */
- size_t newlen;
if (len > SIZE_MAX - MBFL_MEMORY_DEVICE_ALLOC_SIZE
|| device->length > SIZE_MAX - (len + MBFL_MEMORY_DEVICE_ALLOC_SIZE)) {
return -1;
}
- newlen = device->length + len + MBFL_MEMORY_DEVICE_ALLOC_SIZE;
+ size_t newlen = device->length + len + MBFL_MEMORY_DEVICE_ALLOC_SIZE;
device->buffer = erealloc(device->buffer, newlen);
device->length = newlen;
}
- w = &device->buffer[device->pos];
+ unsigned char *w = &device->buffer[device->pos];
memcpy(w, psrc, len);
device->pos += len;
return 0;
}
-int
-mbfl_memory_device_devcat(mbfl_memory_device *dest, mbfl_memory_device *src)
+int mbfl_memory_device_devcat(mbfl_memory_device *dest, mbfl_memory_device *src)
{
- return mbfl_memory_device_strncat(dest, (const char *) src->buffer, src->pos);
+ return mbfl_memory_device_strncat(dest, (const char*)src->buffer, src->pos);
}
-void
-mbfl_wchar_device_init(mbfl_wchar_device *device)
+void mbfl_wchar_device_init(mbfl_wchar_device *device)
{
- if (device) {
- device->buffer = NULL;
- device->length = 0;
- device->pos= 0;
- device->allocsz = MBFL_MEMORY_DEVICE_ALLOC_SIZE;
- }
+ device->buffer = NULL;
+ device->length = 0;
+ device->pos = 0;
+ device->allocsz = MBFL_MEMORY_DEVICE_ALLOC_SIZE;
}
-void
-mbfl_wchar_device_clear(mbfl_wchar_device *device)
+void mbfl_wchar_device_clear(mbfl_wchar_device *device)
{
- if (device) {
- if (device->buffer) {
- efree(device->buffer);
- }
- device->buffer = NULL;
- device->length = 0;
- device->pos = 0;
+ if (device->buffer) {
+ efree(device->buffer);
}
+ device->buffer = NULL;
+ device->length = device->pos = 0;
}
-int
-mbfl_wchar_device_output(int c, void *data)
+int mbfl_wchar_device_output(int c, void *data)
{
mbfl_wchar_device *device = (mbfl_wchar_device *)data;
return -1;
}
- device->buffer = erealloc(device->buffer, newlen*sizeof(int));
+ device->buffer = erealloc(device->buffer, newlen * sizeof(int));
device->length = newlen;
}
device->buffer[device->pos++] = c;
-
return c;
}
MBFLAPI extern int mbfl_wchar_device_output(int c, void *data);
MBFLAPI extern void mbfl_wchar_device_clear(mbfl_wchar_device *device);
-
-
#endif /* MBFL_MEMORY_DEVICE_H */
#include "mbfl_string.h"
#include "mbfilter_pass.h"
-/*
- * string object
- */
-void
-mbfl_string_init(mbfl_string *string)
+void mbfl_string_init_set(mbfl_string *string, const mbfl_encoding *encoding)
{
- string->encoding = &mbfl_encoding_pass;
- string->val = (unsigned char*)NULL;
+ string->encoding = encoding;
+ string->val = NULL;
string->len = 0;
}
-void
-mbfl_string_init_set(mbfl_string *string, const mbfl_encoding *encoding)
+void mbfl_string_init(mbfl_string *string)
{
- string->encoding = encoding;
- string->val = (unsigned char*)NULL;
- string->len = 0;
+ mbfl_string_init_set(string, &mbfl_encoding_pass);
}
-void
-mbfl_string_clear(mbfl_string *string)
+void mbfl_string_clear(mbfl_string *string)
{
- if (string->val != (unsigned char*)NULL) {
+ if (string->val) {
efree(string->val);
}
- string->val = (unsigned char*)NULL;
- string->len = 0;
+ mbfl_string_init_set(string, NULL); /* Poison it so any attempt to reuse will fail hard */
}
array_init(return_value);
if (encoding->aliases != NULL) {
- const char **alias;
- for (alias = *encoding->aliases; *alias; ++alias) {
+ for (const char **alias = encoding->aliases; *alias; ++alias) {
add_next_index_string(return_value, (char *)*alias);
}
}
if (!suppressed_hdrs.cnt_type) {
mbfl_memory_device_strncat(&device, PHP_MBSTR_MAIL_MIME_HEADER2, sizeof(PHP_MBSTR_MAIL_MIME_HEADER2) - 1);
- p = (char *)mbfl_no2preferred_mime_name(tran_cs->no_encoding);
+ p = (char *)mbfl_encoding_preferred_mime_name(tran_cs);
if (p != NULL) {
mbfl_memory_device_strncat(&device, PHP_MBSTR_MAIL_MIME_HEADER3, sizeof(PHP_MBSTR_MAIL_MIME_HEADER3) - 1);
mbfl_memory_device_strcat(&device, p);
}
if (!suppressed_hdrs.cnt_trans_enc) {
mbfl_memory_device_strncat(&device, PHP_MBSTR_MAIL_MIME_HEADER4, sizeof(PHP_MBSTR_MAIL_MIME_HEADER4) - 1);
- p = (char *)mbfl_no2preferred_mime_name(body_enc->no_encoding);
+ p = (char *)mbfl_encoding_preferred_mime_name(body_enc);
if (p == NULL) {
p = "7bit";
}
projects / php / commitdiff