gui: Fix behavior of print preview in psppire-output-window.
[pspp] / src / libpspp / u8-istream.c
1 /* PSPP - a program for statistical analysis.
2    Copyright (C) 2010, 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 "u8-istream.h"
20
21 #include <assert.h>
22 #include <errno.h>
23 #include <fcntl.h>
24 #include <iconv.h>
25 #include <limits.h>
26 #include <stdint.h>
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <string.h>
30 #include <unistd.h>
31 #include <unistr.h>
32
33 #include "libpspp/assertion.h"
34 #include "libpspp/cast.h"
35 #include "libpspp/compiler.h"
36 #include "libpspp/encoding-guesser.h"
37
38 #include "gl/c-strcase.h"
39 #include "gl/localcharset.h"
40 #include "gl/minmax.h"
41
42 enum u8_istream_state
43   {
44     S_AUTO,                     /* Stream encoding not yet known. */
45     S_UTF8,                     /* Stream encoding is known to be UTF-8. */
46     S_CONVERT                   /* Stream encoding is known but not UTF-8. */
47   };
48
49 struct u8_istream
50   {
51     int fd;
52     iconv_t converter;
53     enum u8_istream_state state;
54
55     char *buffer;
56     char *head;
57     size_t length;
58
59     char outbuf[4];
60     size_t outlen;
61   };
62
63 static ssize_t fill_buffer (struct u8_istream *);
64
65 /* Opens FILENAME, which is encoded in FROMCODE, for reading as an UTF-8
66    stream, passing FLAGS to the open() function.  Returns a new u8_istream if
67    successful, otherwise returns NULL and sets errno to an appropriate value.
68
69    The accepted forms for FROMCODE are listed at the top of
70    encoding-guesser.h. */
71 struct u8_istream *
72 u8_istream_for_file (const char *fromcode, const char *filename, int flags)
73 {
74   struct u8_istream *is;
75   int fd;
76
77   assert (!(flags & O_CREAT));
78
79   fd = open (filename, flags);
80   if (fd < 0)
81     return NULL;
82
83   is = u8_istream_for_fd (fromcode, fd);
84   if (is == NULL)
85     {
86       int save_errno = errno;
87       close (fd);
88       errno = save_errno;
89     }
90
91   return is;
92 }
93
94 /* Creates and returns a new u8_istream that reads its input from FD.  Returns
95    a new u8_istream if successful, otherwise returns NULL and sets errno to an
96    appropriate value.
97
98    The accepted forms for FROMCODE are listed at the top of
99    encoding-guesser.h. */
100 struct u8_istream *
101 u8_istream_for_fd (const char *fromcode, int fd)
102 {
103   struct u8_istream *is;
104   const char *encoding;
105
106   is = malloc (sizeof *is);
107   if (is == NULL)
108     return NULL;
109
110   is->fd = fd;
111   is->converter = (iconv_t) -1;
112   is->buffer = malloc (U8_ISTREAM_BUFFER_SIZE);
113   if (is->buffer == NULL)
114     goto error;
115   is->head = is->buffer;
116   is->length = 0;
117   is->outlen = 0;
118
119   if (fill_buffer (is) < 0)
120     goto error;
121
122   encoding = encoding_guess_head_encoding (fromcode, is->buffer, is->length);
123   if (!strcmp (encoding, "UTF-8"))
124     is->state = S_UTF8;
125   else
126     {
127       if (encoding_guess_encoding_is_auto (fromcode)
128           && !strcmp (encoding, "ASCII"))
129         is->state = S_AUTO;
130       else
131         is->state = S_CONVERT;
132
133       is->converter = iconv_open ("UTF-8",
134                                   encoding_guess_parse_encoding (fromcode));
135       if (is->converter == (iconv_t) -1)
136         goto error;
137     }
138
139   return is;
140
141 error:
142   u8_istream_free (is);
143   return NULL;
144 }
145
146 /* Closes IS and its underlying file descriptor and frees all associated
147    resources.  Returns the return value from close(). */
148 int
149 u8_istream_close (struct u8_istream *is)
150 {
151   if (is != NULL)
152     {
153       int fd = is->fd;
154       u8_istream_free (is);
155       return close (fd);
156     }
157   return 0;
158 }
159
160 /* Frees IS and associated resources, but does not close the underlying file
161    descriptor.  (Thus, the client must close the file descriptor when it is no
162    longer needed.) */
163 void
164 u8_istream_free (struct u8_istream *is)
165 {
166   if (is != NULL)
167     {
168       if (is->converter != (iconv_t) -1)
169         iconv_close (is->converter);
170       free (is->buffer);
171       free (is);
172     }
173 }
174
175 static void
176 substitute_invalid_input_byte (struct u8_istream *is)
177 {
178   assert (is->outlen == 0);
179   is->head++;
180   is->length--;
181   is->outlen = u8_uctomb (CHAR_CAST (uint8_t *, is->outbuf),
182                           0xfffd, sizeof is->outbuf);
183 }
184
185 static ssize_t
186 fill_buffer (struct u8_istream *is)
187 {
188   ssize_t n;
189
190   /* Move any unused bytes to the beginning of the input buffer. */
191   if (is->length > 0 && is->buffer != is->head)
192     memmove (is->buffer, is->head, is->length);
193   is->head = is->buffer;
194
195   /* Read more input. */
196   n = read (is->fd, is->buffer + is->length,
197             U8_ISTREAM_BUFFER_SIZE - is->length);
198   if (n > 0)
199     is->length += n;
200   return n;
201 }
202
203 static ssize_t
204 read_auto (struct u8_istream *is, char *buffer, size_t size)
205 {
206   size_t original_size = size;
207   int retval = 0;
208
209   while (size > 0)
210     {
211       if (is->length > 0)
212         {
213           size_t n_ascii;
214
215           n_ascii = encoding_guess_count_ascii (is->head,
216                                                 MIN (is->length, size));
217
218           memcpy (buffer, is->head, n_ascii);
219           buffer += n_ascii;
220           size -= n_ascii;
221
222           is->head += n_ascii;
223           is->length -= n_ascii;
224
225           if (size == 0)
226             break;
227         }
228
229       if (is->length == 0)
230         {
231           retval = fill_buffer (is);
232           if (retval > 0)
233             continue;
234           else
235             break;
236         }
237
238       /* is->head points to a byte that isn't a printable ASCII character.
239          Fill up the buffer and check for UTF-8. */
240       fill_buffer (is);
241       is->state = (encoding_guess_tail_is_utf8 (is->head, is->length)
242                    ? S_UTF8 : S_CONVERT);
243       if (size == original_size)
244         return u8_istream_read (is, buffer, size);
245       break;
246     }
247
248   return original_size - size;
249 }
250
251 static int
252 convert_iconv (iconv_t converter,
253                char **inbufp, size_t *inbytesleft,
254                char **outbufp, size_t *outbytesleft)
255 {
256   size_t n = iconv (converter, (ICONV_CONST char **) inbufp, inbytesleft,
257                     outbufp, outbytesleft);
258   return n == SIZE_MAX ? errno : 0;
259 }
260
261 static int
262 convert_utf8 (iconv_t converter UNUSED,
263               char **inbufp, size_t *inbytesleft,
264               char **outbufp, size_t *outbytesleft)
265 {
266   const uint8_t *in = CHAR_CAST (const uint8_t *, *inbufp);
267   size_t n = MIN (*inbytesleft, *outbytesleft);
268   size_t ofs = 0;
269   int error;
270
271   for (;;)
272     {
273       ucs4_t uc;
274       int mblen;
275
276       if (ofs >= n)
277         {
278           error = ofs < *inbytesleft ? E2BIG : 0;
279           break;
280         }
281
282       mblen = u8_mbtouc (&uc, in + ofs, n - ofs);
283       if (uc == 0xfffd)
284         {
285           int retval = u8_mbtoucr (&uc, in + ofs, *inbytesleft - ofs);
286           if (retval == mblen)
287             {
288               /* There's an actual U+FFFD in the input stream.  Carry on. */
289             }
290           else
291             {
292               error = (retval == -1 ? EILSEQ
293                        : retval == -2 ? EINVAL
294                        : E2BIG);
295               break;
296             }
297         }
298
299       ofs += mblen;
300     }
301
302   if (ofs > 0)
303     {
304       memcpy (*outbufp, *inbufp, ofs);
305       *inbufp += ofs;
306       *inbytesleft -= ofs;
307       *outbufp += ofs;
308       *outbytesleft -= ofs;
309     }
310
311   return error;
312 }
313
314 static ssize_t
315 read_convert (struct u8_istream *is,
316               int (*convert) (iconv_t converter,
317                               char **inbufp, size_t *inbytesleft,
318                               char **outbufp, size_t *outbytesleft),
319               char *buffer, size_t size)
320 {
321   size_t original_size = size;
322
323   while (size > 0)
324     {
325       ssize_t n_read;
326
327       if (is->outlen > 0)
328         {
329           size_t n = MIN (size, is->outlen);
330
331           memcpy (buffer, is->outbuf, n);
332           is->outlen -= n;
333           if (is->outlen > 0)
334             memmove (is->outbuf, is->outbuf + n, is->outlen);
335
336           buffer += n;
337           size -= n;
338
339           if (size == 0)
340             break;
341         }
342
343       if (is->length)
344         {
345           int error = convert (is->converter,
346                                &is->head, &is->length,
347                                &buffer, &size);
348           if (size == 0)
349             break;
350
351           switch (error)
352             {
353             case 0:
354               /* Converted all of the input into output, possibly with space
355                  for output left over.
356
357                  Read more input. */
358               break;
359
360             case EILSEQ:
361               substitute_invalid_input_byte (is);
362               continue;
363
364             case EINVAL:
365               /* Incomplete byte sequence at end of input.  Read more
366                  input. */
367               break;
368
369             default:
370               /* A real error of some kind (ENOMEM?). */
371               return -1;
372
373             case E2BIG:
374               /* Ran out of room for output.
375                  Convert into outbuf and copy from there instead. */
376               {
377                 char *outptr = is->outbuf;
378                 size_t outleft = sizeof is->outbuf;
379
380                 error = convert (is->converter,
381                                  &is->head, &is->length,
382                                  &outptr, &outleft);
383                 is->outlen = outptr - is->outbuf;
384                 if (is->outlen > 0)
385                   continue;
386
387                 switch (error)
388                   {
389                   case EILSEQ:
390                     substitute_invalid_input_byte (is);
391                     continue;
392
393                   case E2BIG:
394                   case EINVAL:
395                     continue;
396
397                   default:
398                     /* A real error of some kind (ENOMEM?). */
399                     return -1;
400                   }
401               }
402             }
403         }
404
405       assert (is->length <= MB_LEN_MAX);
406       n_read = fill_buffer (is);
407       if (n_read <= 0)
408         {
409           if (original_size != size)
410             {
411               /* We produced some output so don't report EOF or error yet. */
412               break;
413             }
414           else if (n_read == 0 && is->length != 0)
415             {
416               /* Incomplete byte sequence at end of file. */
417               substitute_invalid_input_byte (is);
418             }
419           else
420             {
421               /* Propagate end-of-file or error to caller. */
422               return n_read;
423             }
424         }
425     }
426
427   return original_size - size;
428 }
429
430 /* Reads up to SIZE bytes of UTF-8 text from IS into BUFFER.  Returns the
431    number of bytes read if successful, 0 at end of file, or -1 if an error
432    occurred before any data could be read.  Upon error, sets errno to an
433    appropriate value. */
434 ssize_t
435 u8_istream_read (struct u8_istream *is, char *buffer, size_t size)
436 {
437   switch (is->state)
438     {
439     case S_CONVERT:
440       return read_convert (is, convert_iconv, buffer, size);
441
442     case S_AUTO:
443       return read_auto (is, buffer, size);
444
445     case S_UTF8:
446       return read_convert (is, convert_utf8, buffer, size);
447     }
448
449   NOT_REACHED ();
450 }
451
452 /* Returns the file descriptor underlying IS. */
453 int
454 u8_istream_fileno (const struct u8_istream *is)
455 {
456   return is->fd;
457 }
458 \f
459 /* Test functions.
460
461    These functions are probably useful only for white-box testing. */
462
463 /* Returns true if the encoding of the file being read by IS is not yet
464    known. */
465 bool
466 u8_istream_is_auto (const struct u8_istream *is)
467 {
468   return is->state == S_AUTO;
469 }
470
471 /* Returns true if the encoding of the file being read by IS has been
472    determined to be UTF-8. */
473 bool
474 u8_istream_is_utf8 (const struct u8_istream *is)
475 {
476   return is->state == S_UTF8;
477 }