gui: Fix behavior of print preview in psppire-output-window.
[pspp] / src / libpspp / encoding-guesser.c
1 /* PSPP - a program for statistical analysis.
2    Copyright (C) 2011 Free Software Foundation, Inc.
3
4    This program is free software: you can redistribute it and/or modify
5    it under the terms of the GNU General Public License as published by
6    the Free Software Foundation, either version 3 of the License, or
7    (at your option) any later version.
8
9    This program is distributed in the hope that it will be useful,
10    but WITHOUT ANY WARRANTY; without even the implied warranty of
11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12    GNU General Public License for more details.
13
14    You should have received a copy of the GNU General Public License
15    along with this program.  If not, see <http://www.gnu.org/licenses/>. */
16
17 #include <config.h>
18
19 #include "libpspp/encoding-guesser.h"
20
21 #include <errno.h>
22 #include <iconv.h>
23 #include <stdbool.h>
24 #include <stdio.h>
25 #include <stdint.h>
26 #include <string.h>
27 #include <unistr.h>
28
29 #include "libpspp/cast.h"
30 #include "libpspp/i18n.h"
31
32 #include "gl/localcharset.h"
33 #include "gl/c-strcase.h"
34
35 /* http://www.w3.org/TR/REC-xml/#sec-guessing-no-ext-info is a useful source
36    of information about encoding detection.
37 */
38
39 /* Parses and returns the fallback encoding from ENCODING, which must be in one
40    of the forms described at the top of encoding-guesser.h.  The returned
41    string might be ENCODING itself or a suffix of it, or it might be a
42    statically allocated string. */
43 const char *
44 encoding_guess_parse_encoding (const char *encoding)
45 {
46   if (encoding == NULL
47       || !c_strcasecmp (encoding, "auto")
48       || !c_strcasecmp (encoding, "auto,locale")
49       || !c_strcasecmp (encoding, "locale"))
50     return locale_charset ();
51   else if (!c_strncasecmp (encoding, "auto,", 5))
52     return encoding + 5;
53   else
54     return encoding;
55 }
56
57 /* Returns true if ENCODING, which must be in one of the forms described at the
58    top of encoding-guesser.h, is one that performs encoding autodetection,
59    false otherwise. */
60 bool
61 encoding_guess_encoding_is_auto (const char *encoding)
62 {
63   return (encoding == NULL
64           || (!c_strncasecmp (encoding, "auto", 4)
65               && (encoding[4] == ',' || encoding[4] == '\0')));
66 }
67
68 static uint16_t
69 get_be16 (const uint8_t *data)
70 {
71   return (data[0] << 8) | data[1];
72 }
73
74 static uint16_t
75 get_le16 (const uint8_t *data)
76 {
77   return (data[1] << 8) | data[0];
78 }
79
80 static uint32_t
81 get_be32 (const uint8_t *data)
82 {
83   return (data[0] << 24) | (data[1] << 16) | (data[2] << 8) | data[3];
84
85 }
86
87 static uint32_t
88 get_le32 (const uint8_t *data)
89 {
90   return (data[3] << 24) | (data[2] << 16) | (data[1] << 8) | data[0];
91
92 }
93
94 static const char *
95 guess_utf16 (const uint8_t *data, size_t n)
96 {
97   size_t even_nulls, odd_nulls;
98
99   if (n < ENCODING_GUESS_MIN && n % 2 != 0)
100     return NULL;
101
102   even_nulls = odd_nulls = 0;
103   while (n >= 2)
104     {
105       even_nulls += data[0] == 0;
106       odd_nulls += data[1] == 0;
107       if (data[0] == 0 && data[1] == 0)
108         return NULL;
109
110       data += 2;
111       n -= 2;
112     }
113
114   if (odd_nulls > even_nulls)
115     return "UTF-16LE";
116   else if (even_nulls > 0)
117     return "UTF-16BE";
118   else
119     return NULL;
120 }
121
122 static bool
123 is_utf32 (const uint8_t *data, size_t n, uint32_t (*get_u32) (const uint8_t *))
124 {
125   if (n < ENCODING_GUESS_MIN && n % 4 != 0)
126     return false;
127
128   while (n >= 4)
129     {
130       uint32_t uc = get_u32 (data);
131
132       if (uc < 0x09 || uc > 0x10ffff)
133         return false;
134
135       data += 4;
136       n -= 4;
137     }
138
139   return true;
140 }
141
142 /* Counts and returns the number of bytes, but no more than N, starting at S
143    that are ASCII text characters. */
144 size_t
145 encoding_guess_count_ascii (const void *s_, size_t n)
146 {
147   const uint8_t *s = s_;
148   size_t ofs;
149
150   for (ofs = 0; ofs < n; ofs++)
151     if (!encoding_guess_is_ascii_text (s[ofs]))
152       break;
153   return ofs;
154 }
155
156 static bool
157 is_all_utf8_text (const void *s_, size_t n)
158 {
159   const uint8_t *s = s_;
160   size_t ofs;
161
162   ofs = 0;
163   while (ofs < n)
164     {
165       uint8_t c = s[ofs];
166       if (c < 0x80)
167         {
168           if (!encoding_guess_is_ascii_text (c))
169             return false;
170           ofs++;
171         }
172       else
173         {
174           ucs4_t uc;
175           int mblen;
176
177           mblen = u8_mbtoucr (&uc, s + ofs, n - ofs);
178           if (mblen < 0)
179             return mblen == -2;
180
181           ofs += mblen;
182         }
183     }
184   return true;
185 }
186
187 /* Attempts to guess the encoding of a text file based on ENCODING, an encoding
188    name in one of the forms described at the top of encoding-guesser.h, and
189    DATA, which contains the first N bytes of the file.  Returns the guessed
190    encoding, which might be ENCODING itself or a suffix of it or a statically
191    allocated string.
192
193    Encoding autodetection only takes place if ENCODING actually specifies
194    autodetection.  See encoding-guesser.h for details.
195
196    UTF-8 cannot be distinguished from other ASCII-based encodings until a
197    non-ASCII text character is encountered.  If ENCODING specifies
198    autodetection and this function returns "ASCII", then the client should
199    process the input until it encounters an non-ASCII character (as returned by
200    encoding_guess_is_ascii_text()) and then use encoding_guess_tail_encoding()
201    to make a final encoding guess.  See encoding-guesser.h for details.
202
203    N must be at least ENCODING_GUESS_MIN, unless the file is shorter than
204    that. */
205 const char *
206 encoding_guess_head_encoding (const char *encoding,
207                               const void *data_, size_t n)
208 {
209   const uint8_t *data = data_;
210   const char *fallback_encoding;
211   const char *guess;
212
213   fallback_encoding = encoding_guess_parse_encoding (encoding);
214   if (!encoding_guess_encoding_is_auto (encoding))
215     return fallback_encoding;
216
217   if (n == 0)
218     return fallback_encoding;
219
220   if ((n >= ENCODING_GUESS_MIN || n % 4 == 0)
221       && (get_be32 (data) == 0xfeff || get_le32 (data) == 0xfeff))
222     return "UTF-32";
223
224   if (n >= 4)
225     {
226       uint32_t x = get_be32 (data);
227       if (x == 0x84319533)
228         return "GB-18030";
229       else if (x == 0xdd736673)
230         return "UTF-EBCDIC";
231     }
232
233   if ((n >= ENCODING_GUESS_MIN || n % 2 == 0)
234       && (get_be16 (data) == 0xfeff || get_le16 (data) == 0xfeff))
235     return "UTF-16";
236
237   if (n >= 3 && data[0] == 0xef && data[1] == 0xbb && data[2] == 0xbf)
238     return "UTF-8";
239
240   guess = guess_utf16 (data, n);
241   if (guess != NULL)
242     return guess;
243
244   if (is_utf32 (data, n, get_be32))
245     return "UTF-32BE";
246   if (is_utf32 (data, n, get_le32))
247     return "UTF-32LE";
248
249   if (!is_encoding_ascii_compatible (fallback_encoding)
250       || !encoding_guess_tail_is_utf8 (data, n))
251     return fallback_encoding;
252
253   return "ASCII";
254 }
255
256 /* Returns an encoding guess based on ENCODING and the N bytes of text starting
257    at DATA.  DATA should start with the first non-ASCII text character (as
258    determined by encoding_guess_is_ascii_text()) found in the input.
259
260    The return value will either be "UTF-8" or the fallback encoding for
261    ENCODING.
262
263    See encoding-guesser.h for intended use of this function.
264
265    N must be at least ENCODING_GUESS_MIN, unless the file has fewer bytes than
266    that starting with the first non-ASCII text character. */
267 const char *
268 encoding_guess_tail_encoding (const char *encoding,
269                               const void *data, size_t n)
270 {
271   return (encoding_guess_tail_is_utf8 (data, n)
272           ? "UTF-8"
273           : encoding_guess_parse_encoding (encoding));
274 }
275
276 /* Same as encoding_guess_tail_encoding() but returns true for UTF-8 or false
277    for the fallback encoding. */
278 bool
279 encoding_guess_tail_is_utf8 (const void *data, size_t n)
280 {
281   return (n < ENCODING_GUESS_MIN
282           ? u8_check (data, n) == NULL
283           : is_all_utf8_text (data, n));
284 }
285
286 /* Attempts to guess the encoding of a text file based on ENCODING, an encoding
287    name in one of the forms described at the top of encoding-guesser.h, and the
288    SIZE byts in DATA, which contains the entire contents of the file.  Returns
289    the guessed encoding, which might be ENCODING itself or a suffix of it or a
290    statically allocated string.
291
292    Encoding autodetection only takes place if ENCODING actually specifies
293    autodetection.  See encoding-guesser.h for details. */
294 const char *
295 encoding_guess_whole_file (const char *encoding, const void *text, size_t size)
296 {
297   const char *guess;
298
299   guess = encoding_guess_head_encoding (encoding, text, size);
300   if (!strcmp (guess, "ASCII") && encoding_guess_encoding_is_auto (encoding))
301     {
302       size_t ofs = encoding_guess_count_ascii (text, size);
303       if (ofs < size)
304         return encoding_guess_tail_encoding (encoding,
305                                              (const char *) text + ofs,
306                                              size - ofs);
307       else
308         return encoding_guess_parse_encoding (encoding);
309     }
310   else
311     return guess;
312 }