1 /*
2  * Copyright © 1991-2015 Unicode, Inc. All rights reserved.
3  * Distributed under the Terms of Use in
4  * http://www.unicode.org/copyright.html.
5  *
6  * Permission is hereby granted, free of charge, to any person obtaining
7  * a copy of the Unicode data files and any associated documentation
8  * (the "Data Files") or Unicode software and any associated documentation
9  * (the "Software") to deal in the Data Files or Software
10  * without restriction, including without limitation the rights to use,
11  * copy, modify, merge, publish, distribute, and/or sell copies of
12  * the Data Files or Software, and to permit persons to whom the Data Files
13  * or Software are furnished to do so, provided that
14  * (a) this copyright and permission notice appear with all copies
15  * of the Data Files or Software,
16  * (b) this copyright and permission notice appear in associated
17  * documentation, and
18  * (c) there is clear notice in each modified Data File or in the Software
19  * as well as in the documentation associated with the Data File(s) or
20  * Software that the data or software has been modified.
21  *
22  * THE DATA FILES AND SOFTWARE ARE PROVIDED "AS IS", WITHOUT WARRANTY OF
23  * ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
24  * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
25  * NONINFRINGEMENT OF THIRD PARTY RIGHTS.
26  * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS
27  * NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL
28  * DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
29  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
30  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
31  * PERFORMANCE OF THE DATA FILES OR SOFTWARE.
32  *
33  * Except as contained in this notice, the name of a copyright holder
34  * shall not be used in advertising or otherwise to promote the sale,
35  * use or other dealings in these Data Files or Software without prior
36  * written authorization of the copyright holder.
37  */
38 
39 /* ---------------------------------------------------------------------
40 
41 Conversions between UTF32, UTF-16, and UTF-8. Source code file.
42 Author: Mark E. Davis, 1994.
43 Rev History: Rick McGowan, fixes & updates May 2001.
44 Sept 2001: fixed const & error conditions per
45 mods suggested by S. Parent & A. Lillich.
46 June 2002: Tim Dodd added detection and handling of incomplete
47 source sequences, enhanced error detection, added casts
48 to eliminate compiler warnings.
49 July 2003: slight mods to back out aggressive FFFE detection.
50 Jan 2004: updated switches in from-UTF8 conversions.
51 Oct 2004: updated to use UNI_MAX_LEGAL_UTF32 in UTF-32 conversions.
52 
53 See the header file "ConvertUTF.h" for complete documentation.
54 
55 ------------------------------------------------------------------------ */
56 
57 
58 #include "convert_UTF.h"
59 #ifdef CVTUTF_DEBUG
60 #include <stdio.h>
61 #endif
62 
63 static const int halfShift  = 10; /* used for shifting by 10 bits */
64 
65 static const UTF32 halfBase = 0x0010000UL;
66 static const UTF32 halfMask = 0x3FFUL;
67 
68 #define UNI_SUR_HIGH_START  (UTF32)0xD800
69 #define UNI_SUR_HIGH_END    (UTF32)0xDBFF
70 #define UNI_SUR_LOW_START   (UTF32)0xDC00
71 #define UNI_SUR_LOW_END     (UTF32)0xDFFF
72 
73 #ifndef false
74 #define false	   0
75 #endif
76 #ifndef true
77 #define true	    1
78 #endif
79 
80 /* --------------------------------------------------------------------- */
81 
ConvertUTF32toUTF16(const UTF32 ** sourceStart,const UTF32 * sourceEnd,UTF16 ** targetStart,UTF16 * targetEnd,ConversionFlags flags)82 ConversionResult ConvertUTF32toUTF16 (const UTF32** sourceStart, const UTF32* sourceEnd,
83                                       UTF16** targetStart, UTF16* targetEnd, ConversionFlags flags) {
84   ConversionResult result = conversionOK;
85   const UTF32* source = *sourceStart;
86   UTF16* target = *targetStart;
87   while (source < sourceEnd) {
88     UTF32 ch;
89     if (target >= targetEnd) {
90 	    result = targetExhausted; break;
91     }
92     ch = *source++;
93     if (ch <= UNI_MAX_BMP) { /* Target is a character <= 0xFFFF */
94 	    /* UTF-16 surrogate values are illegal in UTF-32; 0xffff or 0xfffe are both reserved values */
95 	    if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) {
96         if (flags == strictConversion) {
97           --source; /* return to the illegal value itself */
98           result = sourceIllegal;
99           break;
100         } else {
101           *target++ = UNI_REPLACEMENT_CHAR;
102         }
103 	    } else {
104         *target++ = (UTF16)ch; /* normal case */
105 	    }
106     } else if (ch > UNI_MAX_LEGAL_UTF32) {
107 	    if (flags == strictConversion) {
108         result = sourceIllegal;
109 	    } else {
110         *target++ = UNI_REPLACEMENT_CHAR;
111 	    }
112     } else {
113 	    /* target is a character in range 0xFFFF - 0x10FFFF. */
114 	    if (target + 1 >= targetEnd) {
115         --source; /* Back up source pointer! */
116         result = targetExhausted; break;
117 	    }
118 	    ch -= halfBase;
119 	    *target++ = (UTF16)((ch >> halfShift) + UNI_SUR_HIGH_START);
120 	    *target++ = (UTF16)((ch & halfMask) + UNI_SUR_LOW_START);
121     }
122   }
123 *sourceStart = source;
124 *targetStart = target;
125 return result;
126 }
127 
128 /* --------------------------------------------------------------------- */
129 
ConvertUTF16toUTF32(const UTF16 ** sourceStart,const UTF16 * sourceEnd,UTF32 ** targetStart,UTF32 * targetEnd,ConversionFlags flags)130 ConversionResult ConvertUTF16toUTF32 (const UTF16** sourceStart, const UTF16* sourceEnd,
131                                       UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags) {
132   ConversionResult result = conversionOK;
133   const UTF16* source = *sourceStart;
134   UTF32* target = *targetStart;
135   UTF32 ch, ch2;
136   while (source < sourceEnd) {
137     const UTF16* oldSource = source; /*  In case we have to back up because of target overflow. */
138     ch = *source++;
139     /* If we have a surrogate pair, convert to UTF32 first. */
140     if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_HIGH_END) {
141 	    /* If the 16 bits following the high surrogate are in the source buffer... */
142 	    if (source < sourceEnd) {
143         ch2 = *source;
144         /* If it's a low surrogate, convert to UTF32. */
145         if (ch2 >= UNI_SUR_LOW_START && ch2 <= UNI_SUR_LOW_END) {
146           ch = ((ch - UNI_SUR_HIGH_START) << halfShift)
147           + (ch2 - UNI_SUR_LOW_START) + halfBase;
148           ++source;
149         } else if (flags == strictConversion) { /* it's an unpaired high surrogate */
150           --source; /* return to the illegal value itself */
151           result = sourceIllegal;
152           break;
153         }
154 	    } else { /* We don't have the 16 bits following the high surrogate. */
155         --source; /* return to the high surrogate */
156         result = sourceExhausted;
157         break;
158 	    }
159     } else if (flags == strictConversion) {
160 	    /* UTF-16 surrogate values are illegal in UTF-32 */
161 	    if (ch >= UNI_SUR_LOW_START && ch <= UNI_SUR_LOW_END) {
162         --source; /* return to the illegal value itself */
163         result = sourceIllegal;
164         break;
165 	    }
166     }
167     if (target >= targetEnd) {
168 	    source = oldSource; /* Back up source pointer! */
169 	    result = targetExhausted; break;
170     }
171     *target++ = ch;
172   }
173   *sourceStart = source;
174   *targetStart = target;
175 #ifdef CVTUTF_DEBUG
176   if (result == sourceIllegal) {
177     fprintf(stderr, "ConvertUTF16toUTF32 illegal seq 0x%04x,%04x\n", ch, ch2);
178     fflush(stderr);
179   }
180 #endif
181   return result;
182 }
183 
184 /* --------------------------------------------------------------------- */
185 
186 /*
187  * Index into the table below with the first byte of a UTF-8 sequence to
188  * get the number of trailing bytes that are supposed to follow it.
189  * Note that *legal* UTF-8 values can't have 4 or 5-bytes. The table is
190  * left as-is for anyone who may want to do such conversion, which was
191  * allowed in earlier algorithms.
192  */
193 static const char trailingBytesForUTF8[256] = {
194   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
195   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
196   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
197   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
198   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
199   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
200   1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
201   2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, 3,3,3,3,3,3,3,3,4,4,4,4,5,5,5,5
202 };
203 
204 /*
205  * Magic values subtracted from a buffer value during UTF8 conversion.
206  * This table contains as many values as there might be trailing bytes
207  * in a UTF-8 sequence.
208  */
209 static const UTF32 offsetsFromUTF8[6] = { 0x00000000UL, 0x00003080UL, 0x000E2080UL,
210   0x03C82080UL, 0xFA082080UL, 0x82082080UL };
211 
212 /*
213  * Once the bits are split out into bytes of UTF-8, this is a mask OR-ed
214  * into the first byte, depending on how many bytes follow.  There are
215  * as many entries in this table as there are UTF-8 sequence types.
216  * (I.e., one byte sequence, two byte... etc.). Remember that sequencs
217  * for *legal* UTF-8 will be 4 or fewer bytes total.
218  */
219 static const UTF8 firstByteMark[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };
220 
221 /* --------------------------------------------------------------------- */
222 
223 /* The interface converts a whole buffer to avoid function-call overhead.
224 * Constants have been gathered. Loops & conditionals have been removed as
225 * much as possible for efficiency, in favor of drop-through switches.
226 * (See "Note A" at the bottom of the file for equivalent code.)
227 * If your compiler supports it, the "isLegalUTF8" call can be turned
228 * into an inline function.
229 */
230 
231 /* --------------------------------------------------------------------- */
232 
ConvertUTF16toUTF8(const UTF16 ** sourceStart,const UTF16 * sourceEnd,UTF8 ** targetStart,UTF8 * targetEnd,ConversionFlags flags)233 ConversionResult ConvertUTF16toUTF8 (const UTF16** sourceStart, const UTF16* sourceEnd,
234                                      UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags) {
235   ConversionResult result = conversionOK;
236   const UTF16* source = *sourceStart;
237   UTF8* target = *targetStart;
238   while (source < sourceEnd) {
239     UTF32 ch;
240     unsigned short bytesToWrite = 0;
241     const UTF32 byteMask = 0xBF;
242     const UTF32 byteMark = 0x80;
243     const UTF16* oldSource = source; /* In case we have to back up because of target overflow. */
244     ch = *source++;
245     /* If we have a surrogate pair, convert to UTF32 first. */
246     if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_HIGH_END) {
247 	    /* If the 16 bits following the high surrogate are in the source buffer... */
248 	    if (source < sourceEnd) {
249         UTF32 ch2 = *source;
250         /* If it's a low surrogate, convert to UTF32. */
251         if (ch2 >= UNI_SUR_LOW_START && ch2 <= UNI_SUR_LOW_END) {
252           ch = ((ch - UNI_SUR_HIGH_START) << halfShift)
253           + (ch2 - UNI_SUR_LOW_START) + halfBase;
254           ++source;
255         } else if (flags == strictConversion) { /* it's an unpaired high surrogate */
256           --source; /* return to the illegal value itself */
257           result = sourceIllegal;
258           break;
259         }
260 	    } else { /* We don't have the 16 bits following the high surrogate. */
261         --source; /* return to the high surrogate */
262         result = sourceExhausted;
263         break;
264 	    }
265     } else if (flags == strictConversion) {
266 	    /* UTF-16 surrogate values are illegal in UTF-32 */
267 	    if (ch >= UNI_SUR_LOW_START && ch <= UNI_SUR_LOW_END) {
268         --source; /* return to the illegal value itself */
269         result = sourceIllegal;
270         break;
271 	    }
272     }
273     /* Figure out how many bytes the result will require */
274     if (ch < (UTF32)0x80) {	     bytesToWrite = 1;
275     } else if (ch < (UTF32)0x800) {     bytesToWrite = 2;
276     } else if (ch < (UTF32)0x10000) {   bytesToWrite = 3;
277     } else if (ch < (UTF32)0x110000) {  bytesToWrite = 4;
278     } else {			    bytesToWrite = 3;
279       ch = UNI_REPLACEMENT_CHAR;
280     }
281 
282     target += bytesToWrite;
283     if (target > targetEnd) {
284 	    source = oldSource; /* Back up source pointer! */
285 	    target -= bytesToWrite; result = targetExhausted; break;
286     }
287     switch (bytesToWrite) { /* note: everything falls through. */
288 	    case 4: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
289 	    case 3: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
290 	    case 2: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
291 	    case 1: *--target =  (UTF8)(ch | firstByteMark[bytesToWrite]);
292     }
293     target += bytesToWrite;
294   }
295 *sourceStart = source;
296 *targetStart = target;
297 return result;
298 }
299 
300 /* --------------------------------------------------------------------- */
301 
302 /*
303  * Utility routine to tell whether a sequence of bytes is legal UTF-8.
304  * This must be called with the length pre-determined by the first byte.
305  * If not calling this from ConvertUTF8to*, then the length can be set by:
306  *  length = trailingBytesForUTF8[*source]+1;
307  * and the sequence is illegal right away if there aren't that many bytes
308  * available.
309  * If presented with a length > 4, this returns false.  The Unicode
310  * definition of UTF-8 goes up to 4-byte sequences.
311  */
312 
isLegalUTF8(const UTF8 * source,int length)313 static Boolean isLegalUTF8(const UTF8 *source, int length) {
314   UTF8 a;
315   const UTF8 *srcptr = source+length;
316   switch (length) {
317     default: return false;
318       /* Everything else falls through when "true"... */
319     case 4: if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return false;
320     case 3: if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return false;
321     case 2: if ((a = (*--srcptr)) > 0xBF) return false;
322 
323       switch (*source) {
324         /* no fall-through in this inner switch */
325         case 0xE0: if (a < 0xA0) return false; break;
326         case 0xED: if (a > 0x9F) return false; break;
327         case 0xF0: if (a < 0x90) return false; break;
328         case 0xF4: if (a > 0x8F) return false; break;
329         default:   if (a < 0x80) return false;
330       }
331 
332       case 1: if (*source >= 0x80 && *source < 0xC2) return false;
333   }
334   if (*source > 0xF4) return false;
335   return true;
336 }
337 
338 /* --------------------------------------------------------------------- */
339 
340 /*
341  * Exported function to return whether a UTF-8 sequence is legal or not.
342  * This is not used here; it's just exported.
343  */
isLegalUTF8Sequence(const UTF8 * source,const UTF8 * sourceEnd)344 Boolean isLegalUTF8Sequence(const UTF8 *source, const UTF8 *sourceEnd) {
345   int length = trailingBytesForUTF8[*source]+1;
346   if (source+length > sourceEnd) {
347     return false;
348   }
349   return isLegalUTF8(source, length);
350 }
351 
352 /* --------------------------------------------------------------------- */
353 
ConvertUTF8toUTF16(const UTF8 ** sourceStart,const UTF8 * sourceEnd,UTF16 ** targetStart,UTF16 * targetEnd,ConversionFlags flags)354 ConversionResult ConvertUTF8toUTF16 (const UTF8** sourceStart, const UTF8* sourceEnd,
355                                      UTF16** targetStart, UTF16* targetEnd, ConversionFlags flags) {
356   ConversionResult result = conversionOK;
357   const UTF8* source = *sourceStart;
358   UTF16* target = *targetStart;
359   while (source < sourceEnd) {
360     UTF32 ch = 0;
361     unsigned short extraBytesToRead = trailingBytesForUTF8[*source];
362     if (source + extraBytesToRead >= sourceEnd) {
363 	    result = sourceExhausted; break;
364     }
365     /* Do this check whether lenient or strict */
366     if (! isLegalUTF8(source, extraBytesToRead+1)) {
367 	    result = sourceIllegal;
368 	    break;
369     }
370     /*
371      * The cases all fall through. See "Note A" below.
372      */
373     switch (extraBytesToRead) {
374 	    case 5: ch += *source++; ch <<= 6; /* remember, illegal UTF-8 */
375 	    case 4: ch += *source++; ch <<= 6; /* remember, illegal UTF-8 */
376 	    case 3: ch += *source++; ch <<= 6;
377 	    case 2: ch += *source++; ch <<= 6;
378 	    case 1: ch += *source++; ch <<= 6;
379 	    case 0: ch += *source++;
380     }
381     ch -= offsetsFromUTF8[extraBytesToRead];
382 
383     if (target >= targetEnd) {
384 	    source -= (extraBytesToRead+1); /* Back up source pointer! */
385 	    result = targetExhausted; break;
386     }
387     if (ch <= UNI_MAX_BMP) { /* Target is a character <= 0xFFFF */
388 	    /* UTF-16 surrogate values are illegal in UTF-32 */
389 	    if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) {
390         if (flags == strictConversion) {
391           source -= (extraBytesToRead+1); /* return to the illegal value itself */
392           result = sourceIllegal;
393           break;
394         } else {
395           *target++ = UNI_REPLACEMENT_CHAR;
396         }
397 	    } else {
398         *target++ = (UTF16)ch; /* normal case */
399 	    }
400     } else if (ch > UNI_MAX_UTF16) {
401 	    if (flags == strictConversion) {
402         result = sourceIllegal;
403         source -= (extraBytesToRead+1); /* return to the start */
404         break; /* Bail out; shouldn't continue */
405 	    } else {
406         *target++ = UNI_REPLACEMENT_CHAR;
407 	    }
408     } else {
409 	    /* target is a character in range 0xFFFF - 0x10FFFF. */
410 	    if (target + 1 >= targetEnd) {
411         source -= (extraBytesToRead+1); /* Back up source pointer! */
412         result = targetExhausted; break;
413 	    }
414 	    ch -= halfBase;
415 	    *target++ = (UTF16)((ch >> halfShift) + UNI_SUR_HIGH_START);
416 	    *target++ = (UTF16)((ch & halfMask) + UNI_SUR_LOW_START);
417     }
418   }
419 *sourceStart = source;
420 *targetStart = target;
421 return result;
422 }
423 
424 /* --------------------------------------------------------------------- */
425 
ConvertUTF32toUTF8(const UTF32 ** sourceStart,const UTF32 * sourceEnd,UTF8 ** targetStart,UTF8 * targetEnd,ConversionFlags flags)426 ConversionResult ConvertUTF32toUTF8 (const UTF32** sourceStart, const UTF32* sourceEnd,
427                                      UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags) {
428   ConversionResult result = conversionOK;
429   const UTF32* source = *sourceStart;
430   UTF8* target = *targetStart;
431   while (source < sourceEnd) {
432     UTF32 ch;
433     unsigned short bytesToWrite = 0;
434     const UTF32 byteMask = 0xBF;
435     const UTF32 byteMark = 0x80;
436     ch = *source++;
437     if (flags == strictConversion ) {
438 	    /* UTF-16 surrogate values are illegal in UTF-32 */
439 	    if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) {
440         --source; /* return to the illegal value itself */
441         result = sourceIllegal;
442         break;
443 	    }
444     }
445     /*
446      * Figure out how many bytes the result will require. Turn any
447      * illegally large UTF32 things (> Plane 17) into replacement chars.
448      */
449     if (ch < (UTF32)0x80) {	     bytesToWrite = 1;
450     } else if (ch < (UTF32)0x800) {     bytesToWrite = 2;
451     } else if (ch < (UTF32)0x10000) {   bytesToWrite = 3;
452     } else if (ch <= UNI_MAX_LEGAL_UTF32) {  bytesToWrite = 4;
453     } else {			    bytesToWrite = 3;
454       ch = UNI_REPLACEMENT_CHAR;
455       result = sourceIllegal;
456     }
457 
458     target += bytesToWrite;
459     if (target > targetEnd) {
460 	    --source; /* Back up source pointer! */
461 	    target -= bytesToWrite; result = targetExhausted; break;
462     }
463     switch (bytesToWrite) { /* note: everything falls through. */
464 	    case 4: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
465 	    case 3: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
466 	    case 2: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
467 	    case 1: *--target = (UTF8) (ch | firstByteMark[bytesToWrite]);
468     }
469     target += bytesToWrite;
470   }
471 *sourceStart = source;
472 *targetStart = target;
473 return result;
474 }
475 
476 /* --------------------------------------------------------------------- */
477 
ConvertUTF8toUTF32(const UTF8 ** sourceStart,const UTF8 * sourceEnd,UTF32 ** targetStart,UTF32 * targetEnd,ConversionFlags flags)478 ConversionResult ConvertUTF8toUTF32 (const UTF8** sourceStart, const UTF8* sourceEnd,
479                                      UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags) {
480   ConversionResult result = conversionOK;
481   const UTF8* source = *sourceStart;
482   UTF32* target = *targetStart;
483   while (source < sourceEnd) {
484     UTF32 ch = 0;
485     unsigned short extraBytesToRead = trailingBytesForUTF8[*source];
486     if (source + extraBytesToRead >= sourceEnd) {
487 	    result = sourceExhausted; break;
488     }
489     /* Do this check whether lenient or strict */
490     if (! isLegalUTF8(source, extraBytesToRead+1)) {
491 	    result = sourceIllegal;
492 	    break;
493     }
494     /*
495      * The cases all fall through. See "Note A" below.
496      */
497     switch (extraBytesToRead) {
498 	    case 5: ch += *source++; ch <<= 6;
499 	    case 4: ch += *source++; ch <<= 6;
500 	    case 3: ch += *source++; ch <<= 6;
501 	    case 2: ch += *source++; ch <<= 6;
502 	    case 1: ch += *source++; ch <<= 6;
503 	    case 0: ch += *source++;
504     }
505     ch -= offsetsFromUTF8[extraBytesToRead];
506 
507     if (target >= targetEnd) {
508 	    source -= (extraBytesToRead+1); /* Back up the source pointer! */
509 	    result = targetExhausted; break;
510     }
511     if (ch <= UNI_MAX_LEGAL_UTF32) {
512 	    /*
513 	     * UTF-16 surrogate values are illegal in UTF-32, and anything
514 	     * over Plane 17 (> 0x10FFFF) is illegal.
515 	     */
516 	    if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) {
517         if (flags == strictConversion) {
518           source -= (extraBytesToRead+1); /* return to the illegal value itself */
519           result = sourceIllegal;
520           break;
521         } else {
522           *target++ = UNI_REPLACEMENT_CHAR;
523         }
524 	    } else {
525         *target++ = ch;
526 	    }
527     } else { /* i.e., ch > UNI_MAX_LEGAL_UTF32 */
528 	    result = sourceIllegal;
529 	    *target++ = UNI_REPLACEMENT_CHAR;
530     }
531   }
532   *sourceStart = source;
533   *targetStart = target;
534   return result;
535 }
536 
537 /* ---------------------------------------------------------------------
538 
539 Note A.
540 The fall-through switches in UTF-8 reading code save a
541 temp variable, some decrements & conditionals.  The switches
542 are equivalent to the following loop:
543 {
544   int tmpBytesToRead = extraBytesToRead+1;
545   do {
546 		ch += *source++;
547 		--tmpBytesToRead;
548 		if (tmpBytesToRead) ch <<= 6;
549   } while (tmpBytesToRead > 0);
550 }
551 In UTF-8 writing code, the switches on "bytesToWrite" are
552 similarly unrolled loops.
553 
554 --------------------------------------------------------------------- */
555