OSDN Git Service

* charset.c (convert_using_iconv): Close out any shift states,
[pf3gnuchains/gcc-fork.git] / libcpp / charset.c
1 /* CPP Library - charsets
2    Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2006
3    Free Software Foundation, Inc.
4
5    Broken out of c-lex.c Apr 2003, adding valid C99 UCN ranges.
6
7 This program is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by the
9 Free Software Foundation; either version 2, or (at your option) any
10 later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
20
21 #include "config.h"
22 #include "system.h"
23 #include "cpplib.h"
24 #include "internal.h"
25
26 /* Character set handling for C-family languages.
27
28    Terminological note: In what follows, "charset" or "character set"
29    will be taken to mean both an abstract set of characters and an
30    encoding for that set.
31
32    The C99 standard discusses two character sets: source and execution.
33    The source character set is used for internal processing in translation
34    phases 1 through 4; the execution character set is used thereafter.
35    Both are required by 5.2.1.2p1 to be multibyte encodings, not wide
36    character encodings (see 3.7.2, 3.7.3 for the standardese meanings
37    of these terms).  Furthermore, the "basic character set" (listed in
38    5.2.1p3) is to be encoded in each with values one byte wide, and is
39    to appear in the initial shift state.
40
41    It is not explicitly mentioned, but there is also a "wide execution
42    character set" used to encode wide character constants and wide
43    string literals; this is supposed to be the result of applying the
44    standard library function mbstowcs() to an equivalent narrow string
45    (6.4.5p5).  However, the behavior of hexadecimal and octal
46    \-escapes is at odds with this; they are supposed to be translated
47    directly to wchar_t values (6.4.4.4p5,6).
48
49    The source character set is not necessarily the character set used
50    to encode physical source files on disk; translation phase 1 converts
51    from whatever that encoding is to the source character set.
52
53    The presence of universal character names in C99 (6.4.3 et seq.)
54    forces the source character set to be isomorphic to ISO 10646,
55    that is, Unicode.  There is no such constraint on the execution
56    character set; note also that the conversion from source to
57    execution character set does not occur for identifiers (5.1.1.2p1#5).
58
59    For convenience of implementation, the source character set's
60    encoding of the basic character set should be identical to the
61    execution character set OF THE HOST SYSTEM's encoding of the basic
62    character set, and it should not be a state-dependent encoding.
63
64    cpplib uses UTF-8 or UTF-EBCDIC for the source character set,
65    depending on whether the host is based on ASCII or EBCDIC (see
66    respectively Unicode section 2.3/ISO10646 Amendment 2, and Unicode
67    Technical Report #16).  With limited exceptions, it relies on the
68    system library's iconv() primitive to do charset conversion
69    (specified in SUSv2).  */
70
71 #if !HAVE_ICONV
72 /* Make certain that the uses of iconv(), iconv_open(), iconv_close()
73    below, which are guarded only by if statements with compile-time
74    constant conditions, do not cause link errors.  */
75 #define iconv_open(x, y) (errno = EINVAL, (iconv_t)-1)
76 #define iconv(a,b,c,d,e) (errno = EINVAL, (size_t)-1)
77 #define iconv_close(x)   (void)0
78 #define ICONV_CONST
79 #endif
80
81 #if HOST_CHARSET == HOST_CHARSET_ASCII
82 #define SOURCE_CHARSET "UTF-8"
83 #define LAST_POSSIBLY_BASIC_SOURCE_CHAR 0x7e
84 #elif HOST_CHARSET == HOST_CHARSET_EBCDIC
85 #define SOURCE_CHARSET "UTF-EBCDIC"
86 #define LAST_POSSIBLY_BASIC_SOURCE_CHAR 0xFF
87 #else
88 #error "Unrecognized basic host character set"
89 #endif
90
91 #ifndef EILSEQ
92 #define EILSEQ EINVAL
93 #endif
94
95 /* This structure is used for a resizable string buffer throughout.  */
96 /* Don't call it strbuf, as that conflicts with unistd.h on systems
97    such as DYNIX/ptx where unistd.h includes stropts.h.  */
98 struct _cpp_strbuf
99 {
100   uchar *text;
101   size_t asize;
102   size_t len;
103 };
104
105 /* This is enough to hold any string that fits on a single 80-column
106    line, even if iconv quadruples its size (e.g. conversion from
107    ASCII to UTF-32) rounded up to a power of two.  */
108 #define OUTBUF_BLOCK_SIZE 256
109
110 /* Conversions between UTF-8 and UTF-16/32 are implemented by custom
111    logic.  This is because a depressing number of systems lack iconv,
112    or have have iconv libraries that do not do these conversions, so
113    we need a fallback implementation for them.  To ensure the fallback
114    doesn't break due to neglect, it is used on all systems.
115
116    UTF-32 encoding is nice and simple: a four-byte binary number,
117    constrained to the range 00000000-7FFFFFFF to avoid questions of
118    signedness.  We do have to cope with big- and little-endian
119    variants.
120
121    UTF-16 encoding uses two-byte binary numbers, again in big- and
122    little-endian variants, for all values in the 00000000-0000FFFF
123    range.  Values in the 00010000-0010FFFF range are encoded as pairs
124    of two-byte numbers, called "surrogate pairs": given a number S in
125    this range, it is mapped to a pair (H, L) as follows:
126
127      H = (S - 0x10000) / 0x400 + 0xD800
128      L = (S - 0x10000) % 0x400 + 0xDC00
129
130    Two-byte values in the D800...DFFF range are ill-formed except as a
131    component of a surrogate pair.  Even if the encoding within a
132    two-byte value is little-endian, the H member of the surrogate pair
133    comes first.
134
135    There is no way to encode values in the 00110000-7FFFFFFF range,
136    which is not currently a problem as there are no assigned code
137    points in that range; however, the author expects that it will
138    eventually become necessary to abandon UTF-16 due to this
139    limitation.  Note also that, because of these pairs, UTF-16 does
140    not meet the requirements of the C standard for a wide character
141    encoding (see 3.7.3 and 6.4.4.4p11).
142
143    UTF-8 encoding looks like this:
144
145    value range         encoded as
146    00000000-0000007F   0xxxxxxx
147    00000080-000007FF   110xxxxx 10xxxxxx
148    00000800-0000FFFF   1110xxxx 10xxxxxx 10xxxxxx
149    00010000-001FFFFF   11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
150    00200000-03FFFFFF   111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
151    04000000-7FFFFFFF   1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
152
153    Values in the 0000D800 ... 0000DFFF range (surrogates) are invalid,
154    which means that three-byte sequences ED xx yy, with A0 <= xx <= BF,
155    never occur.  Note also that any value that can be encoded by a
156    given row of the table can also be encoded by all successive rows,
157    but this is not done; only the shortest possible encoding for any
158    given value is valid.  For instance, the character 07C0 could be
159    encoded as any of DF 80, E0 9F 80, F0 80 9F 80, F8 80 80 9F 80, or
160    FC 80 80 80 9F 80.  Only the first is valid.
161
162    An implementation note: the transformation from UTF-16 to UTF-8, or
163    vice versa, is easiest done by using UTF-32 as an intermediary.  */
164
165 /* Internal primitives which go from an UTF-8 byte stream to native-endian
166    UTF-32 in a cppchar_t, or vice versa; this avoids an extra marshal/unmarshal
167    operation in several places below.  */
168 static inline int
169 one_utf8_to_cppchar (const uchar **inbufp, size_t *inbytesleftp,
170                      cppchar_t *cp)
171 {
172   static const uchar masks[6] = { 0x7F, 0x1F, 0x0F, 0x07, 0x02, 0x01 };
173   static const uchar patns[6] = { 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };
174
175   cppchar_t c;
176   const uchar *inbuf = *inbufp;
177   size_t nbytes, i;
178
179   if (*inbytesleftp < 1)
180     return EINVAL;
181
182   c = *inbuf;
183   if (c < 0x80)
184     {
185       *cp = c;
186       *inbytesleftp -= 1;
187       *inbufp += 1;
188       return 0;
189     }
190
191   /* The number of leading 1-bits in the first byte indicates how many
192      bytes follow.  */
193   for (nbytes = 2; nbytes < 7; nbytes++)
194     if ((c & ~masks[nbytes-1]) == patns[nbytes-1])
195       goto found;
196   return EILSEQ;
197  found:
198
199   if (*inbytesleftp < nbytes)
200     return EINVAL;
201
202   c = (c & masks[nbytes-1]);
203   inbuf++;
204   for (i = 1; i < nbytes; i++)
205     {
206       cppchar_t n = *inbuf++;
207       if ((n & 0xC0) != 0x80)
208         return EILSEQ;
209       c = ((c << 6) + (n & 0x3F));
210     }
211
212   /* Make sure the shortest possible encoding was used.  */
213   if (c <=      0x7F && nbytes > 1) return EILSEQ;
214   if (c <=     0x7FF && nbytes > 2) return EILSEQ;
215   if (c <=    0xFFFF && nbytes > 3) return EILSEQ;
216   if (c <=  0x1FFFFF && nbytes > 4) return EILSEQ;
217   if (c <= 0x3FFFFFF && nbytes > 5) return EILSEQ;
218
219   /* Make sure the character is valid.  */
220   if (c > 0x7FFFFFFF || (c >= 0xD800 && c <= 0xDFFF)) return EILSEQ;
221
222   *cp = c;
223   *inbufp = inbuf;
224   *inbytesleftp -= nbytes;
225   return 0;
226 }
227
228 static inline int
229 one_cppchar_to_utf8 (cppchar_t c, uchar **outbufp, size_t *outbytesleftp)
230 {
231   static const uchar masks[6] =  { 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };
232   static const uchar limits[6] = { 0x80, 0xE0, 0xF0, 0xF8, 0xFC, 0xFE };
233   size_t nbytes;
234   uchar buf[6], *p = &buf[6];
235   uchar *outbuf = *outbufp;
236
237   nbytes = 1;
238   if (c < 0x80)
239     *--p = c;
240   else
241     {
242       do
243         {
244           *--p = ((c & 0x3F) | 0x80);
245           c >>= 6;
246           nbytes++;
247         }
248       while (c >= 0x3F || (c & limits[nbytes-1]));
249       *--p = (c | masks[nbytes-1]);
250     }
251
252   if (*outbytesleftp < nbytes)
253     return E2BIG;
254
255   while (p < &buf[6])
256     *outbuf++ = *p++;
257   *outbytesleftp -= nbytes;
258   *outbufp = outbuf;
259   return 0;
260 }
261
262 /* The following four functions transform one character between the two
263    encodings named in the function name.  All have the signature
264    int (*)(iconv_t bigend, const uchar **inbufp, size_t *inbytesleftp,
265            uchar **outbufp, size_t *outbytesleftp)
266
267    BIGEND must have the value 0 or 1, coerced to (iconv_t); it is
268    interpreted as a boolean indicating whether big-endian or
269    little-endian encoding is to be used for the member of the pair
270    that is not UTF-8.
271
272    INBUFP, INBYTESLEFTP, OUTBUFP, OUTBYTESLEFTP work exactly as they
273    do for iconv.
274
275    The return value is either 0 for success, or an errno value for
276    failure, which may be E2BIG (need more space), EILSEQ (ill-formed
277    input sequence), ir EINVAL (incomplete input sequence).  */
278
279 static inline int
280 one_utf8_to_utf32 (iconv_t bigend, const uchar **inbufp, size_t *inbytesleftp,
281                    uchar **outbufp, size_t *outbytesleftp)
282 {
283   uchar *outbuf;
284   cppchar_t s = 0;
285   int rval;
286
287   /* Check for space first, since we know exactly how much we need.  */
288   if (*outbytesleftp < 4)
289     return E2BIG;
290
291   rval = one_utf8_to_cppchar (inbufp, inbytesleftp, &s);
292   if (rval)
293     return rval;
294
295   outbuf = *outbufp;
296   outbuf[bigend ? 3 : 0] = (s & 0x000000FF);
297   outbuf[bigend ? 2 : 1] = (s & 0x0000FF00) >> 8;
298   outbuf[bigend ? 1 : 2] = (s & 0x00FF0000) >> 16;
299   outbuf[bigend ? 0 : 3] = (s & 0xFF000000) >> 24;
300
301   *outbufp += 4;
302   *outbytesleftp -= 4;
303   return 0;
304 }
305
306 static inline int
307 one_utf32_to_utf8 (iconv_t bigend, const uchar **inbufp, size_t *inbytesleftp,
308                    uchar **outbufp, size_t *outbytesleftp)
309 {
310   cppchar_t s;
311   int rval;
312   const uchar *inbuf;
313
314   if (*inbytesleftp < 4)
315     return EINVAL;
316
317   inbuf = *inbufp;
318
319   s  = inbuf[bigend ? 0 : 3] << 24;
320   s += inbuf[bigend ? 1 : 2] << 16;
321   s += inbuf[bigend ? 2 : 1] << 8;
322   s += inbuf[bigend ? 3 : 0];
323
324   if (s >= 0x7FFFFFFF || (s >= 0xD800 && s <= 0xDFFF))
325     return EILSEQ;
326
327   rval = one_cppchar_to_utf8 (s, outbufp, outbytesleftp);
328   if (rval)
329     return rval;
330
331   *inbufp += 4;
332   *inbytesleftp -= 4;
333   return 0;
334 }
335
336 static inline int
337 one_utf8_to_utf16 (iconv_t bigend, const uchar **inbufp, size_t *inbytesleftp,
338                    uchar **outbufp, size_t *outbytesleftp)
339 {
340   int rval;
341   cppchar_t s = 0;
342   const uchar *save_inbuf = *inbufp;
343   size_t save_inbytesleft = *inbytesleftp;
344   uchar *outbuf = *outbufp;
345
346   rval = one_utf8_to_cppchar (inbufp, inbytesleftp, &s);
347   if (rval)
348     return rval;
349
350   if (s > 0x0010FFFF)
351     {
352       *inbufp = save_inbuf;
353       *inbytesleftp = save_inbytesleft;
354       return EILSEQ;
355     }
356
357   if (s < 0xFFFF)
358     {
359       if (*outbytesleftp < 2)
360         {
361           *inbufp = save_inbuf;
362           *inbytesleftp = save_inbytesleft;
363           return E2BIG;
364         }
365       outbuf[bigend ? 1 : 0] = (s & 0x00FF);
366       outbuf[bigend ? 0 : 1] = (s & 0xFF00) >> 8;
367
368       *outbufp += 2;
369       *outbytesleftp -= 2;
370       return 0;
371     }
372   else
373     {
374       cppchar_t hi, lo;
375
376       if (*outbytesleftp < 4)
377         {
378           *inbufp = save_inbuf;
379           *inbytesleftp = save_inbytesleft;
380           return E2BIG;
381         }
382
383       hi = (s - 0x10000) / 0x400 + 0xD800;
384       lo = (s - 0x10000) % 0x400 + 0xDC00;
385
386       /* Even if we are little-endian, put the high surrogate first.
387          ??? Matches practice?  */
388       outbuf[bigend ? 1 : 0] = (hi & 0x00FF);
389       outbuf[bigend ? 0 : 1] = (hi & 0xFF00) >> 8;
390       outbuf[bigend ? 3 : 2] = (lo & 0x00FF);
391       outbuf[bigend ? 2 : 3] = (lo & 0xFF00) >> 8;
392
393       *outbufp += 4;
394       *outbytesleftp -= 4;
395       return 0;
396     }
397 }
398
399 static inline int
400 one_utf16_to_utf8 (iconv_t bigend, const uchar **inbufp, size_t *inbytesleftp,
401                    uchar **outbufp, size_t *outbytesleftp)
402 {
403   cppchar_t s;
404   const uchar *inbuf = *inbufp;
405   int rval;
406
407   if (*inbytesleftp < 2)
408     return EINVAL;
409   s  = inbuf[bigend ? 0 : 1] << 8;
410   s += inbuf[bigend ? 1 : 0];
411
412   /* Low surrogate without immediately preceding high surrogate is invalid.  */
413   if (s >= 0xDC00 && s <= 0xDFFF)
414     return EILSEQ;
415   /* High surrogate must have a following low surrogate.  */
416   else if (s >= 0xD800 && s <= 0xDBFF)
417     {
418       cppchar_t hi = s, lo;
419       if (*inbytesleftp < 4)
420         return EINVAL;
421
422       lo  = inbuf[bigend ? 2 : 3] << 8;
423       lo += inbuf[bigend ? 3 : 2];
424
425       if (lo < 0xDC00 || lo > 0xDFFF)
426         return EILSEQ;
427
428       s = (hi - 0xD800) * 0x400 + (lo - 0xDC00) + 0x10000;
429     }
430
431   rval = one_cppchar_to_utf8 (s, outbufp, outbytesleftp);
432   if (rval)
433     return rval;
434
435   /* Success - update the input pointers (one_cppchar_to_utf8 has done
436      the output pointers for us).  */
437   if (s <= 0xFFFF)
438     {
439       *inbufp += 2;
440       *inbytesleftp -= 2;
441     }
442   else
443     {
444       *inbufp += 4;
445       *inbytesleftp -= 4;
446     }
447   return 0;
448 }
449
450 /* Helper routine for the next few functions.  The 'const' on
451    one_conversion means that we promise not to modify what function is
452    pointed to, which lets the inliner see through it.  */
453
454 static inline bool
455 conversion_loop (int (*const one_conversion)(iconv_t, const uchar **, size_t *,
456                                              uchar **, size_t *),
457                  iconv_t cd, const uchar *from, size_t flen, struct _cpp_strbuf *to)
458 {
459   const uchar *inbuf;
460   uchar *outbuf;
461   size_t inbytesleft, outbytesleft;
462   int rval;
463
464   inbuf = from;
465   inbytesleft = flen;
466   outbuf = to->text + to->len;
467   outbytesleft = to->asize - to->len;
468
469   for (;;)
470     {
471       do
472         rval = one_conversion (cd, &inbuf, &inbytesleft,
473                                &outbuf, &outbytesleft);
474       while (inbytesleft && !rval);
475
476       if (__builtin_expect (inbytesleft == 0, 1))
477         {
478           to->len = to->asize - outbytesleft;
479           return true;
480         }
481       if (rval != E2BIG)
482         {
483           errno = rval;
484           return false;
485         }
486
487       outbytesleft += OUTBUF_BLOCK_SIZE;
488       to->asize += OUTBUF_BLOCK_SIZE;
489       to->text = XRESIZEVEC (uchar, to->text, to->asize);
490       outbuf = to->text + to->asize - outbytesleft;
491     }
492 }
493
494
495 /* These functions convert entire strings between character sets.
496    They all have the signature
497
498    bool (*)(iconv_t cd, const uchar *from, size_t flen, struct _cpp_strbuf *to);
499
500    The input string FROM is converted as specified by the function
501    name plus the iconv descriptor CD (which may be fake), and the
502    result appended to TO.  On any error, false is returned, otherwise true.  */
503
504 /* These four use the custom conversion code above.  */
505 static bool
506 convert_utf8_utf16 (iconv_t cd, const uchar *from, size_t flen,
507                     struct _cpp_strbuf *to)
508 {
509   return conversion_loop (one_utf8_to_utf16, cd, from, flen, to);
510 }
511
512 static bool
513 convert_utf8_utf32 (iconv_t cd, const uchar *from, size_t flen,
514                     struct _cpp_strbuf *to)
515 {
516   return conversion_loop (one_utf8_to_utf32, cd, from, flen, to);
517 }
518
519 static bool
520 convert_utf16_utf8 (iconv_t cd, const uchar *from, size_t flen,
521                     struct _cpp_strbuf *to)
522 {
523   return conversion_loop (one_utf16_to_utf8, cd, from, flen, to);
524 }
525
526 static bool
527 convert_utf32_utf8 (iconv_t cd, const uchar *from, size_t flen,
528                     struct _cpp_strbuf *to)
529 {
530   return conversion_loop (one_utf32_to_utf8, cd, from, flen, to);
531 }
532
533 /* Identity conversion, used when we have no alternative.  */
534 static bool
535 convert_no_conversion (iconv_t cd ATTRIBUTE_UNUSED,
536                        const uchar *from, size_t flen, struct _cpp_strbuf *to)
537 {
538   if (to->len + flen > to->asize)
539     {
540       to->asize = to->len + flen;
541       to->text = XRESIZEVEC (uchar, to->text, to->asize);
542     }
543   memcpy (to->text + to->len, from, flen);
544   to->len += flen;
545   return true;
546 }
547
548 /* And this one uses the system iconv primitive.  It's a little
549    different, since iconv's interface is a little different.  */
550 #if HAVE_ICONV
551
552 #define CONVERT_ICONV_GROW_BUFFER \
553   do { \
554       outbytesleft += OUTBUF_BLOCK_SIZE; \
555       to->asize += OUTBUF_BLOCK_SIZE; \
556       to->text = XRESIZEVEC (uchar, to->text, to->asize); \
557       outbuf = (char *)to->text + to->asize - outbytesleft; \
558   } while (0)
559
560 static bool
561 convert_using_iconv (iconv_t cd, const uchar *from, size_t flen,
562                      struct _cpp_strbuf *to)
563 {
564   ICONV_CONST char *inbuf;
565   char *outbuf;
566   size_t inbytesleft, outbytesleft;
567
568   /* Reset conversion descriptor and check that it is valid.  */
569   if (iconv (cd, 0, 0, 0, 0) == (size_t)-1)
570     return false;
571
572   inbuf = (ICONV_CONST char *)from;
573   inbytesleft = flen;
574   outbuf = (char *)to->text + to->len;
575   outbytesleft = to->asize - to->len;
576
577   for (;;)
578     {
579       iconv (cd, &inbuf, &inbytesleft, &outbuf, &outbytesleft);
580       if (__builtin_expect (inbytesleft == 0, 1))
581         {
582           /* Close out any shift states, returning to the initial state.  */
583           if (iconv (cd, 0, 0, &outbuf, &outbytesleft) == (size_t)-1)
584             {
585               if (errno != E2BIG)
586                 return false;
587
588               CONVERT_ICONV_GROW_BUFFER;
589               if (iconv (cd, 0, 0, &outbuf, &outbytesleft) == (size_t)-1)
590                 return false;
591             }
592
593           to->len = to->asize - outbytesleft;
594           return true;
595         }
596       if (errno != E2BIG)
597         return false;
598
599       CONVERT_ICONV_GROW_BUFFER;
600     }
601 }
602 #else
603 #define convert_using_iconv 0 /* prevent undefined symbol error below */
604 #endif
605
606 /* Arrange for the above custom conversion logic to be used automatically
607    when conversion between a suitable pair of character sets is requested.  */
608
609 #define APPLY_CONVERSION(CONVERTER, FROM, FLEN, TO) \
610    CONVERTER.func (CONVERTER.cd, FROM, FLEN, TO)
611
612 struct conversion
613 {
614   const char *pair;
615   convert_f func;
616   iconv_t fake_cd;
617 };
618 static const struct conversion conversion_tab[] = {
619   { "UTF-8/UTF-32LE", convert_utf8_utf32, (iconv_t)0 },
620   { "UTF-8/UTF-32BE", convert_utf8_utf32, (iconv_t)1 },
621   { "UTF-8/UTF-16LE", convert_utf8_utf16, (iconv_t)0 },
622   { "UTF-8/UTF-16BE", convert_utf8_utf16, (iconv_t)1 },
623   { "UTF-32LE/UTF-8", convert_utf32_utf8, (iconv_t)0 },
624   { "UTF-32BE/UTF-8", convert_utf32_utf8, (iconv_t)1 },
625   { "UTF-16LE/UTF-8", convert_utf16_utf8, (iconv_t)0 },
626   { "UTF-16BE/UTF-8", convert_utf16_utf8, (iconv_t)1 },
627 };
628
629 /* Subroutine of cpp_init_iconv: initialize and return a
630    cset_converter structure for conversion from FROM to TO.  If
631    iconv_open() fails, issue an error and return an identity
632    converter.  Silently return an identity converter if FROM and TO
633    are identical.  */
634 static struct cset_converter
635 init_iconv_desc (cpp_reader *pfile, const char *to, const char *from)
636 {
637   struct cset_converter ret;
638   char *pair;
639   size_t i;
640
641   if (!strcasecmp (to, from))
642     {
643       ret.func = convert_no_conversion;
644       ret.cd = (iconv_t) -1;
645       return ret;
646     }
647
648   pair = (char *) alloca(strlen(to) + strlen(from) + 2);
649
650   strcpy(pair, from);
651   strcat(pair, "/");
652   strcat(pair, to);
653   for (i = 0; i < ARRAY_SIZE (conversion_tab); i++)
654     if (!strcasecmp (pair, conversion_tab[i].pair))
655       {
656         ret.func = conversion_tab[i].func;
657         ret.cd = conversion_tab[i].fake_cd;
658         return ret;
659       }
660
661   /* No custom converter - try iconv.  */
662   if (HAVE_ICONV)
663     {
664       ret.func = convert_using_iconv;
665       ret.cd = iconv_open (to, from);
666
667       if (ret.cd == (iconv_t) -1)
668         {
669           if (errno == EINVAL)
670             cpp_error (pfile, CPP_DL_ERROR, /* FIXME should be DL_SORRY */
671                        "conversion from %s to %s not supported by iconv",
672                        from, to);
673           else
674             cpp_errno (pfile, CPP_DL_ERROR, "iconv_open");
675
676           ret.func = convert_no_conversion;
677         }
678     }
679   else
680     {
681       cpp_error (pfile, CPP_DL_ERROR, /* FIXME: should be DL_SORRY */
682                  "no iconv implementation, cannot convert from %s to %s",
683                  from, to);
684       ret.func = convert_no_conversion;
685       ret.cd = (iconv_t) -1;
686     }
687   return ret;
688 }
689
690 /* If charset conversion is requested, initialize iconv(3) descriptors
691    for conversion from the source character set to the execution
692    character sets.  If iconv is not present in the C library, and
693    conversion is requested, issue an error.  */
694
695 void
696 cpp_init_iconv (cpp_reader *pfile)
697 {
698   const char *ncset = CPP_OPTION (pfile, narrow_charset);
699   const char *wcset = CPP_OPTION (pfile, wide_charset);
700   const char *default_wcset;
701
702   bool be = CPP_OPTION (pfile, bytes_big_endian);
703
704   if (CPP_OPTION (pfile, wchar_precision) >= 32)
705     default_wcset = be ? "UTF-32BE" : "UTF-32LE";
706   else if (CPP_OPTION (pfile, wchar_precision) >= 16)
707     default_wcset = be ? "UTF-16BE" : "UTF-16LE";
708   else
709     /* This effectively means that wide strings are not supported,
710        so don't do any conversion at all.  */
711    default_wcset = SOURCE_CHARSET;
712
713   if (!ncset)
714     ncset = SOURCE_CHARSET;
715   if (!wcset)
716     wcset = default_wcset;
717
718   pfile->narrow_cset_desc = init_iconv_desc (pfile, ncset, SOURCE_CHARSET);
719   pfile->wide_cset_desc = init_iconv_desc (pfile, wcset, SOURCE_CHARSET);
720 }
721
722 /* Destroy iconv(3) descriptors set up by cpp_init_iconv, if necessary.  */
723 void
724 _cpp_destroy_iconv (cpp_reader *pfile)
725 {
726   if (HAVE_ICONV)
727     {
728       if (pfile->narrow_cset_desc.func == convert_using_iconv)
729         iconv_close (pfile->narrow_cset_desc.cd);
730       if (pfile->wide_cset_desc.func == convert_using_iconv)
731         iconv_close (pfile->wide_cset_desc.cd);
732     }
733 }
734
735 /* Utility routine for use by a full compiler.  C is a character taken
736    from the *basic* source character set, encoded in the host's
737    execution encoding.  Convert it to (the target's) execution
738    encoding, and return that value.
739
740    Issues an internal error if C's representation in the narrow
741    execution character set fails to be a single-byte value (C99
742    5.2.1p3: "The representation of each member of the source and
743    execution character sets shall fit in a byte.")  May also issue an
744    internal error if C fails to be a member of the basic source
745    character set (testing this exactly is too hard, especially when
746    the host character set is EBCDIC).  */
747 cppchar_t
748 cpp_host_to_exec_charset (cpp_reader *pfile, cppchar_t c)
749 {
750   uchar sbuf[1];
751   struct _cpp_strbuf tbuf;
752
753   /* This test is merely an approximation, but it suffices to catch
754      the most important thing, which is that we don't get handed a
755      character outside the unibyte range of the host character set.  */
756   if (c > LAST_POSSIBLY_BASIC_SOURCE_CHAR)
757     {
758       cpp_error (pfile, CPP_DL_ICE,
759                  "character 0x%lx is not in the basic source character set\n",
760                  (unsigned long)c);
761       return 0;
762     }
763
764   /* Being a character in the unibyte range of the host character set,
765      we can safely splat it into a one-byte buffer and trust that that
766      is a well-formed string.  */
767   sbuf[0] = c;
768
769   /* This should never need to reallocate, but just in case... */
770   tbuf.asize = 1;
771   tbuf.text = XNEWVEC (uchar, tbuf.asize);
772   tbuf.len = 0;
773
774   if (!APPLY_CONVERSION (pfile->narrow_cset_desc, sbuf, 1, &tbuf))
775     {
776       cpp_errno (pfile, CPP_DL_ICE, "converting to execution character set");
777       return 0;
778     }
779   if (tbuf.len != 1)
780     {
781       cpp_error (pfile, CPP_DL_ICE,
782                  "character 0x%lx is not unibyte in execution character set",
783                  (unsigned long)c);
784       return 0;
785     }
786   c = tbuf.text[0];
787   free(tbuf.text);
788   return c;
789 }
790
791 \f
792
793 /* Utility routine that computes a mask of the form 0000...111... with
794    WIDTH 1-bits.  */
795 static inline size_t
796 width_to_mask (size_t width)
797 {
798   width = MIN (width, BITS_PER_CPPCHAR_T);
799   if (width >= CHAR_BIT * sizeof (size_t))
800     return ~(size_t) 0;
801   else
802     return ((size_t) 1 << width) - 1;
803 }
804
805 /* A large table of unicode character information.  */
806 enum {
807   /* Valid in a C99 identifier?  */
808   C99 = 1,
809   /* Valid in a C99 identifier, but not as the first character?  */
810   DIG = 2,
811   /* Valid in a C++ identifier?  */
812   CXX = 4,
813   /* NFC representation is not valid in an identifier?  */
814   CID = 8,
815   /* Might be valid NFC form?  */
816   NFC = 16,
817   /* Might be valid NFKC form?  */
818   NKC = 32,
819   /* Certain preceding characters might make it not valid NFC/NKFC form?  */
820   CTX = 64
821 };
822
823 static const struct {
824   /* Bitmap of flags above.  */
825   unsigned char flags;
826   /* Combining class of the character.  */
827   unsigned char combine;
828   /* Last character in the range described by this entry.  */
829   unsigned short end;
830 } ucnranges[] = {
831 #include "ucnid.h"
832 };
833
834 /* Returns 1 if C is valid in an identifier, 2 if C is valid except at
835    the start of an identifier, and 0 if C is not valid in an
836    identifier.  We assume C has already gone through the checks of
837    _cpp_valid_ucn.  Also update NST for C if returning nonzero.  The
838    algorithm is a simple binary search on the table defined in
839    ucnid.h.  */
840
841 static int
842 ucn_valid_in_identifier (cpp_reader *pfile, cppchar_t c,
843                          struct normalize_state *nst)
844 {
845   int mn, mx, md;
846
847   if (c > 0xFFFF)
848     return 0;
849
850   mn = 0;
851   mx = ARRAY_SIZE (ucnranges) - 1;
852   while (mx != mn)
853     {
854       md = (mn + mx) / 2;
855       if (c <= ucnranges[md].end)
856         mx = md;
857       else
858         mn = md + 1;
859     }
860
861   /* When -pedantic, we require the character to have been listed by
862      the standard for the current language.  Otherwise, we accept the
863      union of the acceptable sets for C++98 and C99.  */
864   if (! (ucnranges[mn].flags & (C99 | CXX)))
865       return 0;
866
867   if (CPP_PEDANTIC (pfile)
868       && ((CPP_OPTION (pfile, c99) && !(ucnranges[mn].flags & C99))
869           || (CPP_OPTION (pfile, cplusplus)
870               && !(ucnranges[mn].flags & CXX))))
871     return 0;
872
873   /* Update NST.  */
874   if (ucnranges[mn].combine != 0 && ucnranges[mn].combine < nst->prev_class)
875     nst->level = normalized_none;
876   else if (ucnranges[mn].flags & CTX)
877     {
878       bool safe;
879       cppchar_t p = nst->previous;
880
881       /* Easy cases from Bengali, Oriya, Tamil, Jannada, and Malayalam.  */
882       if (c == 0x09BE)
883         safe = p != 0x09C7;  /* Use 09CB instead of 09C7 09BE.  */
884       else if (c == 0x0B3E)
885         safe = p != 0x0B47;  /* Use 0B4B instead of 0B47 0B3E.  */
886       else if (c == 0x0BBE)
887         safe = p != 0x0BC6 && p != 0x0BC7;  /* Use 0BCA/0BCB instead.  */
888       else if (c == 0x0CC2)
889         safe = p != 0x0CC6;  /* Use 0CCA instead of 0CC6 0CC2.  */
890       else if (c == 0x0D3E)
891         safe = p != 0x0D46 && p != 0x0D47;  /* Use 0D4A/0D4B instead.  */
892       /* For Hangul, characters in the range AC00-D7A3 are NFC/NFKC,
893          and are combined algorithmically from a sequence of the form
894          1100-1112 1161-1175 11A8-11C2
895          (if the third is not present, it is treated as 11A7, which is not
896          really a valid character).
897          Unfortunately, C99 allows (only) the NFC form, but C++ allows
898          only the combining characters.  */
899       else if (c >= 0x1161 && c <= 0x1175)
900         safe = p < 0x1100 || p > 0x1112;
901       else if (c >= 0x11A8 && c <= 0x11C2)
902         safe = (p < 0xAC00 || p > 0xD7A3 || (p - 0xAC00) % 28 != 0);
903       else
904         {
905           /* Uh-oh, someone updated ucnid.h without updating this code.  */
906           cpp_error (pfile, CPP_DL_ICE, "Character %x might not be NFKC", c);
907           safe = true;
908         }
909       if (!safe && c < 0x1161)
910         nst->level = normalized_none;
911       else if (!safe)
912         nst->level = MAX (nst->level, normalized_identifier_C);
913     }
914   else if (ucnranges[mn].flags & NKC)
915     ;
916   else if (ucnranges[mn].flags & NFC)
917     nst->level = MAX (nst->level, normalized_C);
918   else if (ucnranges[mn].flags & CID)
919     nst->level = MAX (nst->level, normalized_identifier_C);
920   else
921     nst->level = normalized_none;
922   nst->previous = c;
923   nst->prev_class = ucnranges[mn].combine;
924
925   /* In C99, UCN digits may not begin identifiers.  */
926   if (CPP_OPTION (pfile, c99) && (ucnranges[mn].flags & DIG))
927     return 2;
928
929   return 1;
930 }
931
932 /* [lex.charset]: The character designated by the universal character
933    name \UNNNNNNNN is that character whose character short name in
934    ISO/IEC 10646 is NNNNNNNN; the character designated by the
935    universal character name \uNNNN is that character whose character
936    short name in ISO/IEC 10646 is 0000NNNN.  If the hexadecimal value
937    for a universal character name is less than 0x20 or in the range
938    0x7F-0x9F (inclusive), or if the universal character name
939    designates a character in the basic source character set, then the
940    program is ill-formed.
941
942    *PSTR must be preceded by "\u" or "\U"; it is assumed that the
943    buffer end is delimited by a non-hex digit.  Returns zero if the
944    UCN has not been consumed.
945
946    Otherwise the nonzero value of the UCN, whether valid or invalid,
947    is returned.  Diagnostics are emitted for invalid values.  PSTR
948    is updated to point one beyond the UCN, or to the syntactically
949    invalid character.
950
951    IDENTIFIER_POS is 0 when not in an identifier, 1 for the start of
952    an identifier, or 2 otherwise.  */
953
954 cppchar_t
955 _cpp_valid_ucn (cpp_reader *pfile, const uchar **pstr,
956                 const uchar *limit, int identifier_pos,
957                 struct normalize_state *nst)
958 {
959   cppchar_t result, c;
960   unsigned int length;
961   const uchar *str = *pstr;
962   const uchar *base = str - 2;
963
964   if (!CPP_OPTION (pfile, cplusplus) && !CPP_OPTION (pfile, c99))
965     cpp_error (pfile, CPP_DL_WARNING,
966                "universal character names are only valid in C++ and C99");
967   else if (CPP_WTRADITIONAL (pfile) && identifier_pos == 0)
968     cpp_error (pfile, CPP_DL_WARNING,
969                "the meaning of '\\%c' is different in traditional C",
970                (int) str[-1]);
971
972   if (str[-1] == 'u')
973     length = 4;
974   else if (str[-1] == 'U')
975     length = 8;
976   else
977     {
978       cpp_error (pfile, CPP_DL_ICE, "In _cpp_valid_ucn but not a UCN");
979       length = 4;
980     }
981
982   result = 0;
983   do
984     {
985       c = *str;
986       if (!ISXDIGIT (c))
987         break;
988       str++;
989       result = (result << 4) + hex_value (c);
990     }
991   while (--length && str < limit);
992
993   /* Partial UCNs are not valid in strings, but decompose into
994      multiple tokens in identifiers, so we can't give a helpful
995      error message in that case.  */
996   if (length && identifier_pos)
997     return 0;
998   
999   *pstr = str;
1000   if (length)
1001     {
1002       cpp_error (pfile, CPP_DL_ERROR,
1003                  "incomplete universal character name %.*s",
1004                  (int) (str - base), base);
1005       result = 1;
1006     }
1007   /* The standard permits $, @ and ` to be specified as UCNs.  We use
1008      hex escapes so that this also works with EBCDIC hosts.  */
1009   else if ((result < 0xa0
1010             && (result != 0x24 && result != 0x40 && result != 0x60))
1011            || (result & 0x80000000)
1012            || (result >= 0xD800 && result <= 0xDFFF))
1013     {
1014       cpp_error (pfile, CPP_DL_ERROR,
1015                  "%.*s is not a valid universal character",
1016                  (int) (str - base), base);
1017       result = 1;
1018     }
1019   else if (identifier_pos && result == 0x24 
1020            && CPP_OPTION (pfile, dollars_in_ident))
1021     {
1022       if (CPP_OPTION (pfile, warn_dollars) && !pfile->state.skipping)
1023         {
1024           CPP_OPTION (pfile, warn_dollars) = 0;
1025           cpp_error (pfile, CPP_DL_PEDWARN, "'$' in identifier or number");
1026         }
1027       NORMALIZE_STATE_UPDATE_IDNUM (nst);
1028     }
1029   else if (identifier_pos)
1030     {
1031       int validity = ucn_valid_in_identifier (pfile, result, nst);
1032
1033       if (validity == 0)
1034         cpp_error (pfile, CPP_DL_ERROR,
1035                    "universal character %.*s is not valid in an identifier",
1036                    (int) (str - base), base);
1037       else if (validity == 2 && identifier_pos == 1)
1038         cpp_error (pfile, CPP_DL_ERROR,
1039    "universal character %.*s is not valid at the start of an identifier",
1040                    (int) (str - base), base);
1041     }
1042
1043   if (result == 0)
1044     result = 1;
1045
1046   return result;
1047 }
1048
1049 /* Convert an UCN, pointed to by FROM, to UTF-8 encoding, then translate
1050    it to the execution character set and write the result into TBUF.
1051    An advanced pointer is returned.  Issues all relevant diagnostics.  */
1052 static const uchar *
1053 convert_ucn (cpp_reader *pfile, const uchar *from, const uchar *limit,
1054              struct _cpp_strbuf *tbuf, bool wide)
1055 {
1056   cppchar_t ucn;
1057   uchar buf[6];
1058   uchar *bufp = buf;
1059   size_t bytesleft = 6;
1060   int rval;
1061   struct cset_converter cvt
1062     = wide ? pfile->wide_cset_desc : pfile->narrow_cset_desc;
1063   struct normalize_state nst = INITIAL_NORMALIZE_STATE;
1064
1065   from++;  /* Skip u/U.  */
1066   ucn = _cpp_valid_ucn (pfile, &from, limit, 0, &nst);
1067
1068   rval = one_cppchar_to_utf8 (ucn, &bufp, &bytesleft);
1069   if (rval)
1070     {
1071       errno = rval;
1072       cpp_errno (pfile, CPP_DL_ERROR,
1073                  "converting UCN to source character set");
1074     }
1075   else if (!APPLY_CONVERSION (cvt, buf, 6 - bytesleft, tbuf))
1076     cpp_errno (pfile, CPP_DL_ERROR,
1077                "converting UCN to execution character set");
1078
1079   return from;
1080 }
1081
1082 /* Subroutine of convert_hex and convert_oct.  N is the representation
1083    in the execution character set of a numeric escape; write it into the
1084    string buffer TBUF and update the end-of-string pointer therein.  WIDE
1085    is true if it's a wide string that's being assembled in TBUF.  This
1086    function issues no diagnostics and never fails.  */
1087 static void
1088 emit_numeric_escape (cpp_reader *pfile, cppchar_t n,
1089                      struct _cpp_strbuf *tbuf, bool wide)
1090 {
1091   if (wide)
1092     {
1093       /* We have to render this into the target byte order, which may not
1094          be our byte order.  */
1095       bool bigend = CPP_OPTION (pfile, bytes_big_endian);
1096       size_t width = CPP_OPTION (pfile, wchar_precision);
1097       size_t cwidth = CPP_OPTION (pfile, char_precision);
1098       size_t cmask = width_to_mask (cwidth);
1099       size_t nbwc = width / cwidth;
1100       size_t i;
1101       size_t off = tbuf->len;
1102       cppchar_t c;
1103
1104       if (tbuf->len + nbwc > tbuf->asize)
1105         {
1106           tbuf->asize += OUTBUF_BLOCK_SIZE;
1107           tbuf->text = XRESIZEVEC (uchar, tbuf->text, tbuf->asize);
1108         }
1109
1110       for (i = 0; i < nbwc; i++)
1111         {
1112           c = n & cmask;
1113           n >>= cwidth;
1114           tbuf->text[off + (bigend ? nbwc - i - 1 : i)] = c;
1115         }
1116       tbuf->len += nbwc;
1117     }
1118   else
1119     {
1120       /* Note: this code does not handle the case where the target
1121          and host have a different number of bits in a byte.  */
1122       if (tbuf->len + 1 > tbuf->asize)
1123         {
1124           tbuf->asize += OUTBUF_BLOCK_SIZE;
1125           tbuf->text = XRESIZEVEC (uchar, tbuf->text, tbuf->asize);
1126         }
1127       tbuf->text[tbuf->len++] = n;
1128     }
1129 }
1130
1131 /* Convert a hexadecimal escape, pointed to by FROM, to the execution
1132    character set and write it into the string buffer TBUF.  Returns an
1133    advanced pointer, and issues diagnostics as necessary.
1134    No character set translation occurs; this routine always produces the
1135    execution-set character with numeric value equal to the given hex
1136    number.  You can, e.g. generate surrogate pairs this way.  */
1137 static const uchar *
1138 convert_hex (cpp_reader *pfile, const uchar *from, const uchar *limit,
1139              struct _cpp_strbuf *tbuf, bool wide)
1140 {
1141   cppchar_t c, n = 0, overflow = 0;
1142   int digits_found = 0;
1143   size_t width = (wide ? CPP_OPTION (pfile, wchar_precision)
1144                   : CPP_OPTION (pfile, char_precision));
1145   size_t mask = width_to_mask (width);
1146
1147   if (CPP_WTRADITIONAL (pfile))
1148     cpp_error (pfile, CPP_DL_WARNING,
1149                "the meaning of '\\x' is different in traditional C");
1150
1151   from++;  /* Skip 'x'.  */
1152   while (from < limit)
1153     {
1154       c = *from;
1155       if (! hex_p (c))
1156         break;
1157       from++;
1158       overflow |= n ^ (n << 4 >> 4);
1159       n = (n << 4) + hex_value (c);
1160       digits_found = 1;
1161     }
1162
1163   if (!digits_found)
1164     {
1165       cpp_error (pfile, CPP_DL_ERROR,
1166                  "\\x used with no following hex digits");
1167       return from;
1168     }
1169
1170   if (overflow | (n != (n & mask)))
1171     {
1172       cpp_error (pfile, CPP_DL_PEDWARN,
1173                  "hex escape sequence out of range");
1174       n &= mask;
1175     }
1176
1177   emit_numeric_escape (pfile, n, tbuf, wide);
1178
1179   return from;
1180 }
1181
1182 /* Convert an octal escape, pointed to by FROM, to the execution
1183    character set and write it into the string buffer TBUF.  Returns an
1184    advanced pointer, and issues diagnostics as necessary.
1185    No character set translation occurs; this routine always produces the
1186    execution-set character with numeric value equal to the given octal
1187    number.  */
1188 static const uchar *
1189 convert_oct (cpp_reader *pfile, const uchar *from, const uchar *limit,
1190              struct _cpp_strbuf *tbuf, bool wide)
1191 {
1192   size_t count = 0;
1193   cppchar_t c, n = 0;
1194   size_t width = (wide ? CPP_OPTION (pfile, wchar_precision)
1195                   : CPP_OPTION (pfile, char_precision));
1196   size_t mask = width_to_mask (width);
1197   bool overflow = false;
1198
1199   while (from < limit && count++ < 3)
1200     {
1201       c = *from;
1202       if (c < '0' || c > '7')
1203         break;
1204       from++;
1205       overflow |= n ^ (n << 3 >> 3);
1206       n = (n << 3) + c - '0';
1207     }
1208
1209   if (n != (n & mask))
1210     {
1211       cpp_error (pfile, CPP_DL_PEDWARN,
1212                  "octal escape sequence out of range");
1213       n &= mask;
1214     }
1215
1216   emit_numeric_escape (pfile, n, tbuf, wide);
1217
1218   return from;
1219 }
1220
1221 /* Convert an escape sequence (pointed to by FROM) to its value on
1222    the target, and to the execution character set.  Do not scan past
1223    LIMIT.  Write the converted value into TBUF.  Returns an advanced
1224    pointer.  Handles all relevant diagnostics.  */
1225 static const uchar *
1226 convert_escape (cpp_reader *pfile, const uchar *from, const uchar *limit,
1227                 struct _cpp_strbuf *tbuf, bool wide)
1228 {
1229   /* Values of \a \b \e \f \n \r \t \v respectively.  */
1230 #if HOST_CHARSET == HOST_CHARSET_ASCII
1231   static const uchar charconsts[] = {  7,  8, 27, 12, 10, 13,  9, 11 };
1232 #elif HOST_CHARSET == HOST_CHARSET_EBCDIC
1233   static const uchar charconsts[] = { 47, 22, 39, 12, 21, 13,  5, 11 };
1234 #else
1235 #error "unknown host character set"
1236 #endif
1237
1238   uchar c;
1239   struct cset_converter cvt
1240     = wide ? pfile->wide_cset_desc : pfile->narrow_cset_desc;
1241
1242   c = *from;
1243   switch (c)
1244     {
1245       /* UCNs, hex escapes, and octal escapes are processed separately.  */
1246     case 'u': case 'U':
1247       return convert_ucn (pfile, from, limit, tbuf, wide);
1248
1249     case 'x':
1250       return convert_hex (pfile, from, limit, tbuf, wide);
1251       break;
1252
1253     case '0':  case '1':  case '2':  case '3':
1254     case '4':  case '5':  case '6':  case '7':
1255       return convert_oct (pfile, from, limit, tbuf, wide);
1256
1257       /* Various letter escapes.  Get the appropriate host-charset
1258          value into C.  */
1259     case '\\': case '\'': case '"': case '?': break;
1260
1261     case '(': case '{': case '[': case '%':
1262       /* '\(', etc, can be used at the beginning of a line in a long
1263          string split onto multiple lines with \-newline, to prevent
1264          Emacs or other text editors from getting confused.  '\%' can
1265          be used to prevent SCCS from mangling printf format strings.  */
1266       if (CPP_PEDANTIC (pfile))
1267         goto unknown;
1268       break;
1269
1270     case 'b': c = charconsts[1];  break;
1271     case 'f': c = charconsts[3];  break;
1272     case 'n': c = charconsts[4];  break;
1273     case 'r': c = charconsts[5];  break;
1274     case 't': c = charconsts[6];  break;
1275     case 'v': c = charconsts[7];  break;
1276
1277     case 'a':
1278       if (CPP_WTRADITIONAL (pfile))
1279         cpp_error (pfile, CPP_DL_WARNING,
1280                    "the meaning of '\\a' is different in traditional C");
1281       c = charconsts[0];
1282       break;
1283
1284     case 'e': case 'E':
1285       if (CPP_PEDANTIC (pfile))
1286         cpp_error (pfile, CPP_DL_PEDWARN,
1287                    "non-ISO-standard escape sequence, '\\%c'", (int) c);
1288       c = charconsts[2];
1289       break;
1290
1291     default:
1292     unknown:
1293       if (ISGRAPH (c))
1294         cpp_error (pfile, CPP_DL_PEDWARN,
1295                    "unknown escape sequence '\\%c'", (int) c);
1296       else
1297         {
1298           /* diagnostic.c does not support "%03o".  When it does, this
1299              code can use %03o directly in the diagnostic again.  */
1300           char buf[32];
1301           sprintf(buf, "%03o", (int) c);
1302           cpp_error (pfile, CPP_DL_PEDWARN,
1303                      "unknown escape sequence: '\\%s'", buf);
1304         }
1305     }
1306
1307   /* Now convert what we have to the execution character set.  */
1308   if (!APPLY_CONVERSION (cvt, &c, 1, tbuf))
1309     cpp_errno (pfile, CPP_DL_ERROR,
1310                "converting escape sequence to execution character set");
1311
1312   return from + 1;
1313 }
1314 \f
1315 /* FROM is an array of cpp_string structures of length COUNT.  These
1316    are to be converted from the source to the execution character set,
1317    escape sequences translated, and finally all are to be
1318    concatenated.  WIDE indicates whether or not to produce a wide
1319    string.  The result is written into TO.  Returns true for success,
1320    false for failure.  */
1321 bool
1322 cpp_interpret_string (cpp_reader *pfile, const cpp_string *from, size_t count,
1323                       cpp_string *to, bool wide)
1324 {
1325   struct _cpp_strbuf tbuf;
1326   const uchar *p, *base, *limit;
1327   size_t i;
1328   struct cset_converter cvt
1329     = wide ? pfile->wide_cset_desc : pfile->narrow_cset_desc;
1330
1331   tbuf.asize = MAX (OUTBUF_BLOCK_SIZE, from->len);
1332   tbuf.text = XNEWVEC (uchar, tbuf.asize);
1333   tbuf.len = 0;
1334
1335   for (i = 0; i < count; i++)
1336     {
1337       p = from[i].text;
1338       if (*p == 'L') p++;
1339       p++; /* Skip leading quote.  */
1340       limit = from[i].text + from[i].len - 1; /* Skip trailing quote.  */
1341
1342       for (;;)
1343         {
1344           base = p;
1345           while (p < limit && *p != '\\')
1346             p++;
1347           if (p > base)
1348             {
1349               /* We have a run of normal characters; these can be fed
1350                  directly to convert_cset.  */
1351               if (!APPLY_CONVERSION (cvt, base, p - base, &tbuf))
1352                 goto fail;
1353             }
1354           if (p == limit)
1355             break;
1356
1357           p = convert_escape (pfile, p + 1, limit, &tbuf, wide);
1358         }
1359     }
1360   /* NUL-terminate the 'to' buffer and translate it to a cpp_string
1361      structure.  */
1362   emit_numeric_escape (pfile, 0, &tbuf, wide);
1363   tbuf.text = XRESIZEVEC (uchar, tbuf.text, tbuf.len);
1364   to->text = tbuf.text;
1365   to->len = tbuf.len;
1366   return true;
1367
1368  fail:
1369   cpp_errno (pfile, CPP_DL_ERROR, "converting to execution character set");
1370   free (tbuf.text);
1371   return false;
1372 }
1373
1374 /* Subroutine of do_line and do_linemarker.  Convert escape sequences
1375    in a string, but do not perform character set conversion.  */
1376 bool
1377 cpp_interpret_string_notranslate (cpp_reader *pfile, const cpp_string *from,
1378                                   size_t count, cpp_string *to, bool wide)
1379 {
1380   struct cset_converter save_narrow_cset_desc = pfile->narrow_cset_desc;
1381   bool retval;
1382
1383   pfile->narrow_cset_desc.func = convert_no_conversion;
1384   pfile->narrow_cset_desc.cd = (iconv_t) -1;
1385
1386   retval = cpp_interpret_string (pfile, from, count, to, wide);
1387
1388   pfile->narrow_cset_desc = save_narrow_cset_desc;
1389   return retval;
1390 }
1391
1392 \f
1393 /* Subroutine of cpp_interpret_charconst which performs the conversion
1394    to a number, for narrow strings.  STR is the string structure returned
1395    by cpp_interpret_string.  PCHARS_SEEN and UNSIGNEDP are as for
1396    cpp_interpret_charconst.  */
1397 static cppchar_t
1398 narrow_str_to_charconst (cpp_reader *pfile, cpp_string str,
1399                          unsigned int *pchars_seen, int *unsignedp)
1400 {
1401   size_t width = CPP_OPTION (pfile, char_precision);
1402   size_t max_chars = CPP_OPTION (pfile, int_precision) / width;
1403   size_t mask = width_to_mask (width);
1404   size_t i;
1405   cppchar_t result, c;
1406   bool unsigned_p;
1407
1408   /* The value of a multi-character character constant, or a
1409      single-character character constant whose representation in the
1410      execution character set is more than one byte long, is
1411      implementation defined.  This implementation defines it to be the
1412      number formed by interpreting the byte sequence in memory as a
1413      big-endian binary number.  If overflow occurs, the high bytes are
1414      lost, and a warning is issued.
1415
1416      We don't want to process the NUL terminator handed back by
1417      cpp_interpret_string.  */
1418   result = 0;
1419   for (i = 0; i < str.len - 1; i++)
1420     {
1421       c = str.text[i] & mask;
1422       if (width < BITS_PER_CPPCHAR_T)
1423         result = (result << width) | c;
1424       else
1425         result = c;
1426     }
1427
1428   if (i > max_chars)
1429     {
1430       i = max_chars;
1431       cpp_error (pfile, CPP_DL_WARNING,
1432                  "character constant too long for its type");
1433     }
1434   else if (i > 1 && CPP_OPTION (pfile, warn_multichar))
1435     cpp_error (pfile, CPP_DL_WARNING, "multi-character character constant");
1436
1437   /* Multichar constants are of type int and therefore signed.  */
1438   if (i > 1)
1439     unsigned_p = 0;
1440   else
1441     unsigned_p = CPP_OPTION (pfile, unsigned_char);
1442
1443   /* Truncate the constant to its natural width, and simultaneously
1444      sign- or zero-extend to the full width of cppchar_t.
1445      For single-character constants, the value is WIDTH bits wide.
1446      For multi-character constants, the value is INT_PRECISION bits wide.  */
1447   if (i > 1)
1448     width = CPP_OPTION (pfile, int_precision);
1449   if (width < BITS_PER_CPPCHAR_T)
1450     {
1451       mask = ((cppchar_t) 1 << width) - 1;
1452       if (unsigned_p || !(result & (1 << (width - 1))))
1453         result &= mask;
1454       else
1455         result |= ~mask;
1456     }
1457   *pchars_seen = i;
1458   *unsignedp = unsigned_p;
1459   return result;
1460 }
1461
1462 /* Subroutine of cpp_interpret_charconst which performs the conversion
1463    to a number, for wide strings.  STR is the string structure returned
1464    by cpp_interpret_string.  PCHARS_SEEN and UNSIGNEDP are as for
1465    cpp_interpret_charconst.  */
1466 static cppchar_t
1467 wide_str_to_charconst (cpp_reader *pfile, cpp_string str,
1468                        unsigned int *pchars_seen, int *unsignedp)
1469 {
1470   bool bigend = CPP_OPTION (pfile, bytes_big_endian);
1471   size_t width = CPP_OPTION (pfile, wchar_precision);
1472   size_t cwidth = CPP_OPTION (pfile, char_precision);
1473   size_t mask = width_to_mask (width);
1474   size_t cmask = width_to_mask (cwidth);
1475   size_t nbwc = width / cwidth;
1476   size_t off, i;
1477   cppchar_t result = 0, c;
1478
1479   /* This is finicky because the string is in the target's byte order,
1480      which may not be our byte order.  Only the last character, ignoring
1481      the NUL terminator, is relevant.  */
1482   off = str.len - (nbwc * 2);
1483   result = 0;
1484   for (i = 0; i < nbwc; i++)
1485     {
1486       c = bigend ? str.text[off + i] : str.text[off + nbwc - i - 1];
1487       result = (result << cwidth) | (c & cmask);
1488     }
1489
1490   /* Wide character constants have type wchar_t, and a single
1491      character exactly fills a wchar_t, so a multi-character wide
1492      character constant is guaranteed to overflow.  */
1493   if (off > 0)
1494     cpp_error (pfile, CPP_DL_WARNING,
1495                "character constant too long for its type");
1496
1497   /* Truncate the constant to its natural width, and simultaneously
1498      sign- or zero-extend to the full width of cppchar_t.  */
1499   if (width < BITS_PER_CPPCHAR_T)
1500     {
1501       if (CPP_OPTION (pfile, unsigned_wchar) || !(result & (1 << (width - 1))))
1502         result &= mask;
1503       else
1504         result |= ~mask;
1505     }
1506
1507   *unsignedp = CPP_OPTION (pfile, unsigned_wchar);
1508   *pchars_seen = 1;
1509   return result;
1510 }
1511
1512 /* Interpret a (possibly wide) character constant in TOKEN.
1513    PCHARS_SEEN points to a variable that is filled in with the number
1514    of characters seen, and UNSIGNEDP to a variable that indicates
1515    whether the result has signed type.  */
1516 cppchar_t
1517 cpp_interpret_charconst (cpp_reader *pfile, const cpp_token *token,
1518                          unsigned int *pchars_seen, int *unsignedp)
1519 {
1520   cpp_string str = { 0, 0 };
1521   bool wide = (token->type == CPP_WCHAR);
1522   cppchar_t result;
1523
1524   /* an empty constant will appear as L'' or '' */
1525   if (token->val.str.len == (size_t) (2 + wide))
1526     {
1527       cpp_error (pfile, CPP_DL_ERROR, "empty character constant");
1528       return 0;
1529     }
1530   else if (!cpp_interpret_string (pfile, &token->val.str, 1, &str, wide))
1531     return 0;
1532
1533   if (wide)
1534     result = wide_str_to_charconst (pfile, str, pchars_seen, unsignedp);
1535   else
1536     result = narrow_str_to_charconst (pfile, str, pchars_seen, unsignedp);
1537
1538   if (str.text != token->val.str.text)
1539     free ((void *)str.text);
1540
1541   return result;
1542 }
1543 \f
1544 /* Convert an identifier denoted by ID and LEN, which might contain
1545    UCN escapes, to the source character set, either UTF-8 or
1546    UTF-EBCDIC.  Assumes that the identifier is actually a valid identifier.  */
1547 cpp_hashnode *
1548 _cpp_interpret_identifier (cpp_reader *pfile, const uchar *id, size_t len)
1549 {
1550   /* It turns out that a UCN escape always turns into fewer characters
1551      than the escape itself, so we can allocate a temporary in advance.  */
1552   uchar * buf = (uchar *) alloca (len + 1);
1553   uchar * bufp = buf;
1554   size_t idp;
1555   
1556   for (idp = 0; idp < len; idp++)
1557     if (id[idp] != '\\')
1558       *bufp++ = id[idp];
1559     else
1560       {
1561         unsigned length = id[idp+1] == 'u' ? 4 : 8;
1562         cppchar_t value = 0;
1563         size_t bufleft = len - (bufp - buf);
1564         int rval;
1565
1566         idp += 2;
1567         while (length && idp < len && ISXDIGIT (id[idp]))
1568           {
1569             value = (value << 4) + hex_value (id[idp]);
1570             idp++;
1571             length--;
1572           }
1573         idp--;
1574
1575         /* Special case for EBCDIC: if the identifier contains
1576            a '$' specified using a UCN, translate it to EBCDIC.  */
1577         if (value == 0x24)
1578           {
1579             *bufp++ = '$';
1580             continue;
1581           }
1582
1583         rval = one_cppchar_to_utf8 (value, &bufp, &bufleft);
1584         if (rval)
1585           {
1586             errno = rval;
1587             cpp_errno (pfile, CPP_DL_ERROR,
1588                        "converting UCN to source character set");
1589             break;
1590           }
1591       }
1592
1593   return CPP_HASHNODE (ht_lookup (pfile->hash_table, 
1594                                   buf, bufp - buf, HT_ALLOC));
1595 }
1596 \f
1597 /* Convert an input buffer (containing the complete contents of one
1598    source file) from INPUT_CHARSET to the source character set.  INPUT
1599    points to the input buffer, SIZE is its allocated size, and LEN is
1600    the length of the meaningful data within the buffer.  The
1601    translated buffer is returned, and *ST_SIZE is set to the length of
1602    the meaningful data within the translated buffer.
1603
1604    INPUT is expected to have been allocated with xmalloc.  This function
1605    will either return INPUT, or free it and return a pointer to another
1606    xmalloc-allocated block of memory.  */
1607 uchar * 
1608 _cpp_convert_input (cpp_reader *pfile, const char *input_charset,
1609                     uchar *input, size_t size, size_t len, off_t *st_size)
1610 {
1611   struct cset_converter input_cset;
1612   struct _cpp_strbuf to;
1613
1614   input_cset = init_iconv_desc (pfile, SOURCE_CHARSET, input_charset);
1615   if (input_cset.func == convert_no_conversion)
1616     {
1617       to.text = input;
1618       to.asize = size;
1619       to.len = len;
1620     }
1621   else
1622     {
1623       to.asize = MAX (65536, len);
1624       to.text = XNEWVEC (uchar, to.asize);
1625       to.len = 0;
1626
1627       if (!APPLY_CONVERSION (input_cset, input, len, &to))
1628         cpp_error (pfile, CPP_DL_ERROR,
1629                    "failure to convert %s to %s",
1630                    CPP_OPTION (pfile, input_charset), SOURCE_CHARSET);
1631
1632       free (input);
1633     }
1634
1635   /* Clean up the mess.  */
1636   if (input_cset.func == convert_using_iconv)
1637     iconv_close (input_cset.cd);
1638
1639   /* Resize buffer if we allocated substantially too much, or if we
1640      haven't enough space for the \n-terminator.  */
1641   if (to.len + 4096 < to.asize || to.len >= to.asize)
1642     to.text = XRESIZEVEC (uchar, to.text, to.len + 1);
1643
1644   /* If the file is using old-school Mac line endings (\r only),
1645      terminate with another \r, not an \n, so that we do not mistake
1646      the \r\n sequence for a single DOS line ending and erroneously
1647      issue the "No newline at end of file" diagnostic.  */
1648   if (to.len && to.text[to.len - 1] == '\r')
1649     to.text[to.len] = '\r';
1650   else
1651     to.text[to.len] = '\n';
1652
1653   *st_size = to.len;
1654   return to.text;
1655 }
1656
1657 /* Decide on the default encoding to assume for input files.  */
1658 const char *
1659 _cpp_default_encoding (void)
1660 {
1661   const char *current_encoding = NULL;
1662
1663   /* We disable this because the default codeset is 7-bit ASCII on
1664      most platforms, and this causes conversion failures on every
1665      file in GCC that happens to have one of the upper 128 characters
1666      in it -- most likely, as part of the name of a contributor.
1667      We should definitely recognize in-band markers of file encoding,
1668      like:
1669      - the appropriate Unicode byte-order mark (FE FF) to recognize
1670        UTF16 and UCS4 (in both big-endian and little-endian flavors)
1671        and UTF8
1672      - a "#i", "#d", "/ *", "//", " #p" or "#p" (for #pragma) to
1673        distinguish ASCII and EBCDIC.
1674      - now we can parse something like "#pragma GCC encoding <xyz>
1675        on the first line, or even Emacs/VIM's mode line tags (there's
1676        a problem here in that VIM uses the last line, and Emacs has
1677        its more elaborate "local variables" convention).
1678      - investigate whether Java has another common convention, which
1679        would be friendly to support.
1680      (Zack Weinberg and Paolo Bonzini, May 20th 2004)  */
1681 #if defined (HAVE_LOCALE_H) && defined (HAVE_LANGINFO_CODESET) && 0
1682   setlocale (LC_CTYPE, "");
1683   current_encoding = nl_langinfo (CODESET);
1684 #endif
1685   if (current_encoding == NULL || *current_encoding == '\0')
1686     current_encoding = SOURCE_CHARSET;
1687
1688   return current_encoding;
1689 }