Commit | Line | Data |
---|---|---|
3d458a81 | 1 | # iconv_open-utf.m4 serial 1 |
af07e104 | 2 | dnl Copyright (C) 2007-2013 Free Software Foundation, Inc. |
3d458a81 AW |
3 | dnl This file is free software; the Free Software Foundation |
4 | dnl gives unlimited permission to copy and/or distribute it, | |
5 | dnl with or without modifications, as long as this notice is preserved. | |
6 | ||
7 | # A placeholder to ensure that this m4 file gets included by aclocal. | |
8 | AC_DEFUN([gl_FUNC_ICONV_OPEN_UTF], []) | |
9 | ||
10 | AC_DEFUN([gl_FUNC_ICONV_OPEN_UTF_SUPPORT], | |
11 | [ | |
12 | dnl This macro relies on am_cv_func_iconv and gl_func_iconv_gnu from | |
13 | dnl gl_FUNC_ICONV_OPEN, but is called from within gl_FUNC_ICONV_OPEN. | |
14 | dnl *Not* AC_REQUIRE([gl_FUNC_ICONV_OPEN]). | |
15 | AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles | |
16 | AC_REQUIRE([gl_ICONV_H_DEFAULTS]) | |
17 | if test "$am_cv_func_iconv" = yes; then | |
18 | AC_CACHE_CHECK([whether iconv supports conversion between UTF-8 and UTF-{16,32}{BE,LE}], | |
19 | [gl_cv_func_iconv_supports_utf], | |
20 | [ | |
21 | save_LIBS="$LIBS" | |
22 | LIBS="$LIBS $LIBICONV" | |
23 | AC_RUN_IFELSE( | |
24 | [AC_LANG_SOURCE([[ | |
25 | #include <iconv.h> | |
26 | #include <errno.h> | |
27 | #include <stdio.h> | |
28 | #include <stdlib.h> | |
29 | #include <string.h> | |
30 | int main () | |
31 | { | |
32 | int result = 0; | |
33 | /* Test conversion from UTF-8 to UTF-16BE with no errors. */ | |
34 | { | |
35 | static const char input[] = | |
36 | "Japanese (\346\227\245\346\234\254\350\252\236) [\360\235\224\215\360\235\224\236\360\235\224\255]"; | |
37 | static const char expected[] = | |
38 | "\000J\000a\000p\000a\000n\000e\000s\000e\000 \000(\145\345\147\054\212\236\000)\000 \000[\330\065\335\015\330\065\335\036\330\065\335\055\000]"; | |
39 | iconv_t cd; | |
40 | cd = iconv_open ("UTF-16BE", "UTF-8"); | |
41 | if (cd == (iconv_t)(-1)) | |
42 | result |= 1; | |
43 | else | |
44 | { | |
45 | char buf[100]; | |
46 | const char *inptr; | |
47 | size_t inbytesleft; | |
48 | char *outptr; | |
49 | size_t outbytesleft; | |
50 | size_t res; | |
51 | inptr = input; | |
52 | inbytesleft = sizeof (input) - 1; | |
53 | outptr = buf; | |
54 | outbytesleft = sizeof (buf); | |
55 | res = iconv (cd, | |
56 | (ICONV_CONST char **) &inptr, &inbytesleft, | |
57 | &outptr, &outbytesleft); | |
58 | if (!(res == 0 && inbytesleft == 0)) | |
59 | result |= 1; | |
60 | else if (!(outptr == buf + (sizeof (expected) - 1))) | |
61 | result |= 1; | |
62 | else if (!(memcmp (buf, expected, sizeof (expected) - 1) == 0)) | |
63 | result |= 1; | |
64 | else if (!(iconv_close (cd) == 0)) | |
65 | result |= 1; | |
66 | } | |
67 | } | |
68 | /* Test conversion from UTF-8 to UTF-16LE with no errors. */ | |
69 | { | |
70 | static const char input[] = | |
71 | "Japanese (\346\227\245\346\234\254\350\252\236) [\360\235\224\215\360\235\224\236\360\235\224\255]"; | |
72 | static const char expected[] = | |
73 | "J\000a\000p\000a\000n\000e\000s\000e\000 \000(\000\345\145\054\147\236\212)\000 \000[\000\065\330\015\335\065\330\036\335\065\330\055\335]\000"; | |
74 | iconv_t cd; | |
75 | cd = iconv_open ("UTF-16LE", "UTF-8"); | |
76 | if (cd == (iconv_t)(-1)) | |
77 | result |= 2; | |
78 | else | |
79 | { | |
80 | char buf[100]; | |
81 | const char *inptr; | |
82 | size_t inbytesleft; | |
83 | char *outptr; | |
84 | size_t outbytesleft; | |
85 | size_t res; | |
86 | inptr = input; | |
87 | inbytesleft = sizeof (input) - 1; | |
88 | outptr = buf; | |
89 | outbytesleft = sizeof (buf); | |
90 | res = iconv (cd, | |
91 | (ICONV_CONST char **) &inptr, &inbytesleft, | |
92 | &outptr, &outbytesleft); | |
93 | if (!(res == 0 && inbytesleft == 0)) | |
94 | result |= 2; | |
95 | else if (!(outptr == buf + (sizeof (expected) - 1))) | |
96 | result |= 2; | |
97 | else if (!(memcmp (buf, expected, sizeof (expected) - 1) == 0)) | |
98 | result |= 2; | |
99 | else if (!(iconv_close (cd) == 0)) | |
100 | result |= 2; | |
101 | } | |
102 | } | |
103 | /* Test conversion from UTF-8 to UTF-32BE with no errors. */ | |
104 | { | |
105 | static const char input[] = | |
106 | "Japanese (\346\227\245\346\234\254\350\252\236) [\360\235\224\215\360\235\224\236\360\235\224\255]"; | |
107 | static const char expected[] = | |
108 | "\000\000\000J\000\000\000a\000\000\000p\000\000\000a\000\000\000n\000\000\000e\000\000\000s\000\000\000e\000\000\000 \000\000\000(\000\000\145\345\000\000\147\054\000\000\212\236\000\000\000)\000\000\000 \000\000\000[\000\001\325\015\000\001\325\036\000\001\325\055\000\000\000]"; | |
109 | iconv_t cd; | |
110 | cd = iconv_open ("UTF-32BE", "UTF-8"); | |
111 | if (cd == (iconv_t)(-1)) | |
112 | result |= 4; | |
113 | else | |
114 | { | |
115 | char buf[100]; | |
116 | const char *inptr; | |
117 | size_t inbytesleft; | |
118 | char *outptr; | |
119 | size_t outbytesleft; | |
120 | size_t res; | |
121 | inptr = input; | |
122 | inbytesleft = sizeof (input) - 1; | |
123 | outptr = buf; | |
124 | outbytesleft = sizeof (buf); | |
125 | res = iconv (cd, | |
126 | (ICONV_CONST char **) &inptr, &inbytesleft, | |
127 | &outptr, &outbytesleft); | |
128 | if (!(res == 0 && inbytesleft == 0)) | |
129 | result |= 4; | |
130 | else if (!(outptr == buf + (sizeof (expected) - 1))) | |
131 | result |= 4; | |
132 | else if (!(memcmp (buf, expected, sizeof (expected) - 1) == 0)) | |
133 | result |= 4; | |
134 | else if (!(iconv_close (cd) == 0)) | |
135 | result |= 4; | |
136 | } | |
137 | } | |
138 | /* Test conversion from UTF-8 to UTF-32LE with no errors. */ | |
139 | { | |
140 | static const char input[] = | |
141 | "Japanese (\346\227\245\346\234\254\350\252\236) [\360\235\224\215\360\235\224\236\360\235\224\255]"; | |
142 | static const char expected[] = | |
143 | "J\000\000\000a\000\000\000p\000\000\000a\000\000\000n\000\000\000e\000\000\000s\000\000\000e\000\000\000 \000\000\000(\000\000\000\345\145\000\000\054\147\000\000\236\212\000\000)\000\000\000 \000\000\000[\000\000\000\015\325\001\000\036\325\001\000\055\325\001\000]\000\000\000"; | |
144 | iconv_t cd; | |
145 | cd = iconv_open ("UTF-32LE", "UTF-8"); | |
146 | if (cd == (iconv_t)(-1)) | |
147 | result |= 8; | |
148 | else | |
149 | { | |
150 | char buf[100]; | |
151 | const char *inptr; | |
152 | size_t inbytesleft; | |
153 | char *outptr; | |
154 | size_t outbytesleft; | |
155 | size_t res; | |
156 | inptr = input; | |
157 | inbytesleft = sizeof (input) - 1; | |
158 | outptr = buf; | |
159 | outbytesleft = sizeof (buf); | |
160 | res = iconv (cd, | |
161 | (ICONV_CONST char **) &inptr, &inbytesleft, | |
162 | &outptr, &outbytesleft); | |
163 | if (!(res == 0 && inbytesleft == 0)) | |
164 | result |= 8; | |
165 | else if (!(outptr == buf + (sizeof (expected) - 1))) | |
166 | result |= 8; | |
167 | else if (!(memcmp (buf, expected, sizeof (expected) - 1) == 0)) | |
168 | result |= 8; | |
169 | else if (!(iconv_close (cd) == 0)) | |
170 | result |= 8; | |
171 | } | |
172 | } | |
173 | /* Test conversion from UTF-16BE to UTF-8 with no errors. | |
174 | This test fails on NetBSD 3.0. */ | |
175 | { | |
176 | static const char input[] = | |
177 | "\000J\000a\000p\000a\000n\000e\000s\000e\000 \000(\145\345\147\054\212\236\000)\000 \000[\330\065\335\015\330\065\335\036\330\065\335\055\000]"; | |
178 | static const char expected[] = | |
179 | "Japanese (\346\227\245\346\234\254\350\252\236) [\360\235\224\215\360\235\224\236\360\235\224\255]"; | |
180 | iconv_t cd; | |
181 | cd = iconv_open ("UTF-8", "UTF-16BE"); | |
182 | if (cd == (iconv_t)(-1)) | |
183 | result |= 16; | |
184 | else | |
185 | { | |
186 | char buf[100]; | |
187 | const char *inptr; | |
188 | size_t inbytesleft; | |
189 | char *outptr; | |
190 | size_t outbytesleft; | |
191 | size_t res; | |
192 | inptr = input; | |
193 | inbytesleft = sizeof (input) - 1; | |
194 | outptr = buf; | |
195 | outbytesleft = sizeof (buf); | |
196 | res = iconv (cd, | |
197 | (ICONV_CONST char **) &inptr, &inbytesleft, | |
198 | &outptr, &outbytesleft); | |
199 | if (!(res == 0 && inbytesleft == 0)) | |
200 | result |= 16; | |
201 | else if (!(outptr == buf + (sizeof (expected) - 1))) | |
202 | result |= 16; | |
203 | else if (!(memcmp (buf, expected, sizeof (expected) - 1) == 0)) | |
204 | result |= 16; | |
205 | else if (!(iconv_close (cd) == 0)) | |
206 | result |= 16; | |
207 | } | |
208 | } | |
209 | return result; | |
210 | }]])], | |
211 | [gl_cv_func_iconv_supports_utf=yes], | |
212 | [gl_cv_func_iconv_supports_utf=no], | |
213 | [ | |
214 | dnl We know that GNU libiconv, GNU libc, and Solaris >= 9 do. | |
215 | dnl OSF/1 5.1 has these encodings, but inserts a BOM in the "to" | |
216 | dnl direction. | |
217 | gl_cv_func_iconv_supports_utf=no | |
218 | if test $gl_func_iconv_gnu = yes; then | |
219 | gl_cv_func_iconv_supports_utf=yes | |
220 | else | |
221 | changequote(,)dnl | |
222 | case "$host_os" in | |
223 | solaris2.9 | solaris2.1[0-9]) gl_cv_func_iconv_supports_utf=yes ;; | |
224 | esac | |
225 | changequote([,])dnl | |
226 | fi | |
227 | ]) | |
228 | LIBS="$save_LIBS" | |
229 | ]) | |
230 | fi | |
231 | ]) |