View Javadoc
1   /*
2    *  Licensed to the Apache Software Foundation (ASF) under one
3    *  or more contributor license agreements.  See the NOTICE file
4    *  distributed with this work for additional information
5    *  regarding copyright ownership.  The ASF licenses this file
6    *  to you under the Apache License, Version 2.0 (the
7    *  "License"); you may not use this file except in compliance
8    *  with the License.  You may obtain a copy of the License at
9    *  
10   *    http://www.apache.org/licenses/LICENSE-2.0
11   *  
12   *  Unless required by applicable law or agreed to in writing,
13   *  software distributed under the License is distributed on an
14   *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15   *  KIND, either express or implied.  See the License for the
16   *  specific language governing permissions and limitations
17   *  under the License. 
18   *  
19   */
20  
21  package org.apache.directory.api.ldap.model.schema;
22  
23  
24  import java.io.IOException;
25  
26  import org.apache.directory.api.util.Strings;
27  import org.apache.directory.api.util.exception.InvalidCharacterException;
28  
29  
30  /**
31   * 
32   * This class implements the 6 steps described in RFC 4518
33   *
34   * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
35   */
36  public final class PrepareString
37  {
38      /** A flag used to lowercase chars during the map process */
39      private static final boolean CASE_SENSITIVE = true;
40  
41      /** A flag used to keep casing during the map process */
42      private static final boolean IGNORE_CASE = false;
43  
44      /** All the possible combining marks */
45      private static final char[][] COMBINING_MARKS = new char[][]
46          {
47              { 0x0300, 0x034F },
48              { 0x0360, 0x036F },
49              { 0x0483, 0x0486 },
50              { 0x0488, 0x0489 },
51              { 0x0591, 0x05A1 },
52              { 0x05A3, 0x05B9 },
53              { 0x05BB, 0x05BC },
54              { 0x05BF, 0x05BF },
55              { 0x05C1, 0x05C2 },
56              { 0x05C4, 0x05C4 },
57              { 0x064B, 0x0655 },
58              { 0x0670, 0x0670 },
59              { 0x06D6, 0x06DC },
60              { 0x06DE, 0x06E4 },
61              { 0x06E7, 0x06E8 },
62              { 0x06EA, 0x06ED },
63              { 0x0711, 0x0711 },
64              { 0x0730, 0x074A },
65              { 0x07A6, 0x07B0 },
66              { 0x0901, 0x0903 },
67              { 0x093C, 0x093C },
68              { 0x093E, 0x094F },
69              { 0x0951, 0x0954 },
70              { 0x0962, 0x0963 },
71              { 0x0981, 0x0983 },
72              { 0x09BC, 0x09BC },
73              { 0x09BE, 0x09C4 },
74              { 0x09C7, 0x09C8 },
75              { 0x09CB, 0x09CD },
76              { 0x09D7, 0x09D7 },
77              { 0x09E2, 0x09E3 },
78              { 0x0A02, 0x0A02 },
79              { 0x0A3C, 0x0A3C },
80              { 0x0A3E, 0x0A42 },
81              { 0x0A47, 0x0A48 },
82              { 0x0A4B, 0x0A4D },
83              { 0x0A70, 0x0A71 },
84              { 0x0A81, 0x0A83 },
85              { 0x0ABC, 0x0ABC },
86              { 0x0ABE, 0x0AC5 },
87              { 0x0AC7, 0x0AC9 },
88              { 0x0ACB, 0x0ACD },
89              { 0x0B01, 0x0B03 },
90              { 0x0B3C, 0x0B3C },
91              { 0x0B3E, 0x0B43 },
92              { 0x0B47, 0x0B48 },
93              { 0x0B4B, 0x0B4D },
94              { 0x0B56, 0x0B57 },
95              { 0x0B82, 0x0B82 },
96              { 0x0BBE, 0x0BC2 },
97              { 0x0BC6, 0x0BC8 },
98              { 0x0BCA, 0x0BCD },
99              { 0x0BD7, 0x0BD7 },
100             { 0x0C01, 0x0C03 },
101             { 0x0C3E, 0x0C44 },
102             { 0x0C46, 0x0C48 },
103             { 0x0C4A, 0x0C4D },
104             { 0x0C55, 0x0C56 },
105             { 0x0C82, 0x0C83 },
106             { 0x0CBE, 0x0CC4 },
107             { 0x0CC6, 0x0CC8 },
108             { 0x0CCA, 0x0CCD },
109             { 0x0CD5, 0x0CD6 },
110             { 0x0D02, 0x0D03 },
111             { 0x0D3E, 0x0D43 },
112             { 0x0D46, 0x0D48 },
113             { 0x0D4A, 0x0D4D },
114             { 0x0D57, 0x0D57 },
115             { 0x0D82, 0x0D83 },
116             { 0x0DCA, 0x0DCA },
117             { 0x0DCF, 0x0DD4 },
118             { 0x0DD6, 0x0DD6 },
119             { 0x0DD8, 0x0DDF },
120             { 0x0DF2, 0x0DF3 },
121             { 0x0E31, 0x0E31 },
122             { 0x0E34, 0x0E3A },
123             { 0x0E47, 0x0E4E },
124             { 0x0EB1, 0x0EB1 },
125             { 0x0EB4, 0x0EB9 },
126             { 0x0EBB, 0x0EBC },
127             { 0x0EC8, 0x0ECD },
128             { 0x0F18, 0x0F19 },
129             { 0x0F35, 0x0F35 },
130             { 0x0F37, 0x0F37 },
131             { 0x0F39, 0x0F39 },
132             { 0x0F3E, 0x0F3F },
133             { 0x0F71, 0x0F84 },
134             { 0x0F86, 0x0F87 },
135             { 0x0F90, 0x0F97 },
136             { 0x0F99, 0x0FBC },
137             { 0x0FC6, 0x0FC6 },
138             { 0x102C, 0x1032 },
139             { 0x1036, 0x1039 },
140             { 0x1056, 0x1059 },
141             { 0x1712, 0x1714 },
142             { 0x1732, 0x1734 },
143             { 0x1752, 0x1753 },
144             { 0x1772, 0x1773 },
145             { 0x17B4, 0x17D3 },
146             { 0x180B, 0x180D },
147             { 0x18A9, 0x18A9 },
148             { 0x20D0, 0x20EA },
149             { 0x302A, 0x302F },
150             { 0x3099, 0x309A },
151             { 0xFB1E, 0xFB1E },
152             { 0xFE00, 0xFE0F },
153             { 0xFE20, 0xFE23 }
154     };
155 
156     /**
157      * The type of String we have to normalize
158      */
159     public enum StringType
160     {
161         /** Not a String */
162         NOT_STRING,
163         
164         /** A numeric String */
165         NUMERIC_STRING,
166         
167         /** Case sensitive String */
168         CASE_EXACT,
169         
170         /** IA5 case sensitive String */
171         CASE_EXACT_IA5,
172         
173         /** IA5 case insensitive String */
174         CASE_IGNORE_IA5,
175         
176         /** Case insensitive String list */
177         CASE_IGNORE_LIST,
178         
179         /** Case insensitive String */
180         CASE_IGNORE,
181         
182         /** Directory String */
183         DIRECTORY_STRING,
184         
185         /** Telephone number String */
186         TELEPHONE_NUMBER,
187         
188         /** A word */
189         WORD
190     }
191 
192 
193     /**
194      * A private constructor, to avoid instance creation of this static class.
195      */
196     private PrepareString()
197     {
198         // Do nothing
199     }
200 
201 
202     /**
203      * Tells if a char is a combining mark.
204      *
205      * @param c The char to check
206      * @return true if the char is a combining mark, false otherwise
207      */
208     private static boolean isCombiningMark( char c )
209     {
210         if ( c < COMBINING_MARKS[0][0] )
211         {
212             return false;
213         }
214 
215         for ( char[] interval : COMBINING_MARKS )
216         {
217             if ( ( c >= interval[0] ) && ( c <= interval[1] ) )
218             {
219                 return true;
220             }
221         }
222 
223         return false;
224     }
225 
226 
227     /**
228     *
229     * We have to go through 6 steps :
230     *
231     * 1) Transcode
232     * 2) Map
233     * 3) Normalize
234     * 4) Prohibit
235     * 5) Bidi
236     * 6) Insignifiant Character Handling
237     *
238     * The first step is already done, the step (3) is not done.
239     *
240     * @param str The String to normalize
241     * @param type The string type
242     * @return A normalized string.
243     * @throws IOException If teh normalization failed
244     */
245     public static String normalize( String str, StringType type ) throws IOException
246     {
247         switch ( type )
248         {
249             case NUMERIC_STRING:
250                 return insignifiantCharNumericString( str );
251 
252             case TELEPHONE_NUMBER:
253                 return insignifiantCharTelephoneNumber( str );
254 
255             case CASE_EXACT:
256             case CASE_EXACT_IA5:
257             case DIRECTORY_STRING:
258                 try
259                 {
260                     return insignifiantSpacesStringAscii( str, CASE_SENSITIVE );
261                 }
262                 catch ( Exception e )
263                 {
264                     return insignifiantSpacesString( str, CASE_SENSITIVE );
265                 }
266 
267             case CASE_IGNORE_IA5:
268             case CASE_IGNORE_LIST:
269             case CASE_IGNORE:
270                 try
271                 {
272                     return insignifiantSpacesStringAscii( str, IGNORE_CASE );
273                 }
274                 catch ( Exception e )
275                 {
276                     return insignifiantSpacesString( str, IGNORE_CASE );
277                 }
278 
279             case WORD:
280                 return str;
281 
282             default:
283                 return str;
284 
285         }
286     }
287 
288 
289     /**
290      * Execute the mapping step of the string preparation :
291      * - suppress useless chars
292      * - transform to spaces
293      * - lowercase
294      * 
295      * @param c The char to map
296      * @param array The array which will collect the transformed char
297      * @param pos The current position in the target
298      * @param lowerCase A mask to lowercase the char, if necessary
299      * @return The transformed StringBuilder
300      */
301     // CHECKSTYLE:OFF
302     private static int map( char[] src, char[] target, char lowerCase )
303     {
304         int limit = 0;
305 
306         for ( char c : src )
307         {
308             switch ( c )
309             {
310                 case 0x0000:
311                 case 0x0001:
312                 case 0x0002:
313                 case 0x0003:
314                 case 0x0004:
315                 case 0x0005:
316                 case 0x0006:
317                 case 0x0007:
318                 case 0x0008:
319                     break;
320 
321                 case 0x0009:
322                 case 0x000A:
323                 case 0x000B:
324                 case 0x000C:
325                 case 0x000D:
326                     target[limit++] = ( char ) 0x20;
327                     break;
328 
329                 case 0x000E:
330                 case 0x000F:
331                 case 0x0010:
332                 case 0x0011:
333                 case 0x0012:
334                 case 0x0013:
335                 case 0x0014:
336                 case 0x0015:
337                 case 0x0016:
338                 case 0x0017:
339                 case 0x0018:
340                 case 0x0019:
341                 case 0x001A:
342                 case 0x001B:
343                 case 0x001C:
344                 case 0x001D:
345                 case 0x001E:
346                 case 0x001F:
347                     break;
348 
349                 case 0x0041:
350                 case 0x0042:
351                 case 0x0043:
352                 case 0x0044:
353                 case 0x0045:
354                 case 0x0046:
355                 case 0x0047:
356                 case 0x0048:
357                 case 0x0049:
358                 case 0x004A:
359                 case 0x004B:
360                 case 0x004C:
361                 case 0x004D:
362                 case 0x004E:
363                 case 0x004F:
364                 case 0x0050:
365                 case 0x0051:
366                 case 0x0052:
367                 case 0x0053:
368                 case 0x0054:
369                 case 0x0055:
370                 case 0x0056:
371                 case 0x0057:
372                 case 0x0058:
373                 case 0x0059:
374                 case 0x005A:
375                     target[limit++] = ( char ) ( c | lowerCase );
376                     break;
377 
378                 case 0x007F:
379                 case 0x0080:
380                 case 0x0081:
381                 case 0x0082:
382                 case 0x0083:
383                 case 0x0084:
384                     break;
385 
386                 case 0x0085:
387                     target[limit] = ( char ) 0x20;
388                     break;
389 
390                 case 0x0086:
391                 case 0x0087:
392                 case 0x0088:
393                 case 0x0089:
394                 case 0x008A:
395                 case 0x008B:
396                 case 0x008C:
397                 case 0x008D:
398                 case 0x008E:
399                 case 0x008F:
400                 case 0x0090:
401                 case 0x0091:
402                 case 0x0092:
403                 case 0x0093:
404                 case 0x0094:
405                 case 0x0095:
406                 case 0x0096:
407                 case 0x0097:
408                 case 0x0098:
409                 case 0x0099:
410                 case 0x009A:
411                 case 0x009B:
412                 case 0x009C:
413                 case 0x009D:
414                 case 0x009E:
415                 case 0x009F:
416                     break;
417 
418                 case 0x00A0:
419                     target[limit++] = ( char ) 0x20;
420                     break;
421 
422                 case 0x00AD:
423                     break;
424 
425                 case 0x00B5:
426                     target[limit++] = ( char ) 0x03BC;
427                     break;
428 
429                 case 0x00C0:
430                 case 0x00C1:
431                 case 0x00C2:
432                 case 0x00C3:
433                 case 0x00C4:
434                 case 0x00C5:
435                 case 0x00C6:
436                 case 0x00C7:
437                 case 0x00C8:
438                 case 0x00C9:
439                 case 0x00CA:
440                 case 0x00CB:
441                 case 0x00CC:
442                 case 0x00CD:
443                 case 0x00CE:
444                 case 0x00CF:
445                 case 0x00D0:
446                 case 0x00D1:
447                 case 0x00D2:
448                 case 0x00D3:
449                 case 0x00D4:
450                 case 0x00D5:
451                 case 0x00D6:
452                 case 0x00D8:
453                 case 0x00D9:
454                 case 0x00DA:
455                 case 0x00DB:
456                 case 0x00DC:
457                 case 0x00DD:
458                 case 0x00DE:
459                     target[limit++] = ( char ) ( c | lowerCase );
460                     break;
461 
462                 case 0x00DF:
463                     target[limit++] = ( char ) 0x0073;
464                     target[limit++] = ( char ) 0x0073;
465                     break;
466 
467                 case 0x0100:
468                     target[limit++] = ( char ) 0x0101;
469                     break;
470 
471                 case 0x0102:
472                     target[limit++] = ( char ) 0x0103;
473                     break;
474 
475                 case 0x0104:
476                     target[limit++] = 0x0105;
477                     break;
478 
479                 case 0x0106:
480                     target[limit++] = 0x0107;
481                     break;
482 
483                 case 0x0108:
484                     target[limit++] = 0x0109;
485                     break;
486 
487                 case 0x010A:
488                     target[limit++] = 0x010B;
489                     break;
490 
491                 case 0x010C:
492                     target[limit++] = 0x010D;
493                     break;
494 
495                 case 0x010E:
496                     target[limit++] = 0x010F;
497                     break;
498 
499                 case 0x0110:
500                     target[limit++] = 0x0111;
501                     break;
502 
503                 case 0x0112:
504                     target[limit++] = 0x0113;
505                     break;
506 
507                 case 0x0114:
508                     target[limit++] = 0x0115;
509                     break;
510 
511                 case 0x0116:
512                     target[limit++] = 0x0117;
513                     break;
514 
515                 case 0x0118:
516                     target[limit++] = 0x0119;
517                     break;
518 
519                 case 0x011A:
520                     target[limit++] = 0x011B;
521                     break;
522 
523                 case 0x011C:
524                     target[limit++] = 0x011D;
525                     break;
526 
527                 case 0x011E:
528                     target[limit++] = 0x011F;
529                     break;
530 
531                 case 0x0120:
532                     target[limit++] = 0x0121;
533                     break;
534 
535                 case 0x0122:
536                     target[limit++] = 0x0123;
537                     break;
538 
539                 case 0x0124:
540                     target[limit++] = 0x0125;
541                     break;
542 
543                 case 0x0126:
544                     target[limit++] = 0x0127;
545                     break;
546 
547                 case 0x0128:
548                     target[limit++] = 0x0129;
549                     break;
550 
551                 case 0x012A:
552                     target[limit++] = 0x012B;
553                     break;
554 
555                 case 0x012C:
556                     target[limit++] = 0x012D;
557                     break;
558 
559                 case 0x012E:
560                     target[limit++] = 0x012F;
561                     break;
562 
563                 case 0x0130:
564                     target[limit++] = 0x0069;
565                     target[limit++] = 0x0307;
566                     break;
567 
568                 case 0x0132:
569                     target[limit++] = 0x0133;
570                     break;
571 
572                 case 0x0134:
573                     target[limit++] = 0x0135;
574                     break;
575 
576                 case 0x0136:
577                     target[limit++] = 0x0137;
578                     break;
579 
580                 case 0x0139:
581                     target[limit++] = 0x013A;
582                     break;
583 
584                 case 0x013B:
585                     target[limit++] = 0x013C;
586                     break;
587 
588                 case 0x013D:
589                     target[limit++] = 0x013E;
590                     break;
591 
592                 case 0x013F:
593                     target[limit++] = 0x0140;
594                     break;
595 
596                 case 0x0141:
597                     target[limit++] = 0x0142;
598                     break;
599 
600                 case 0x0143:
601                     target[limit++] = 0x0144;
602                     break;
603 
604                 case 0x0145:
605                     target[limit++] = 0x0146;
606                     break;
607 
608                 case 0x0147:
609                     target[limit++] = 0x0148;
610                     break;
611 
612                 case 0x0149:
613                     target[limit++] = 0x02BC;
614                     target[limit++] = 0x006E;
615                     break;
616 
617                 case 0x014A:
618                     target[limit++] = 0x014B;
619                     break;
620 
621                 case 0x014C:
622                     target[limit++] = 0x014D;
623                     break;
624 
625                 case 0x014E:
626                     target[limit++] = 0x014F;
627                     break;
628 
629                 case 0x0150:
630                     target[limit++] = 0x0151;
631                     break;
632 
633                 case 0x0152:
634                     target[limit++] = 0x0153;
635                     break;
636 
637                 case 0x0154:
638                     target[limit++] = 0x0155;
639                     break;
640 
641                 case 0x0156:
642                     target[limit++] = 0x0157;
643                     break;
644 
645                 case 0x0158:
646                     target[limit++] = 0x0159;
647                     break;
648 
649                 case 0x015A:
650                     target[limit++] = 0x015B;
651                     break;
652 
653                 case 0x015C:
654                     target[limit++] = 0x015D;
655                     break;
656 
657                 case 0x015E:
658                     target[limit++] = 0x015F;
659                     break;
660 
661                 case 0x0160:
662                     target[limit++] = 0x0161;
663                     break;
664 
665                 case 0x0162:
666                     target[limit++] = 0x0163;
667                     break;
668 
669                 case 0x0164:
670                     target[limit++] = 0x0165;
671                     break;
672 
673                 case 0x0166:
674                     target[limit++] = 0x0167;
675                     break;
676 
677                 case 0x0168:
678                     target[limit++] = 0x0169;
679                     break;
680 
681                 case 0x016A:
682                     target[limit++] = 0x016B;
683                     break;
684 
685                 case 0x016C:
686                     target[limit++] = 0x016D;
687                     break;
688 
689                 case 0x016E:
690                     target[limit++] = 0x016F;
691                     break;
692 
693                 case 0x0170:
694                     target[limit++] = 0x0171;
695                     break;
696 
697                 case 0x0172:
698                     target[limit++] = 0x0173;
699                     break;
700 
701                 case 0x0174:
702                     target[limit++] = 0x0175;
703                     break;
704 
705                 case 0x0176:
706                     target[limit++] = 0x0177;
707                     break;
708 
709                 case 0x0178:
710                     target[limit++] = 0x00FF;
711                     break;
712 
713                 case 0x0179:
714                     target[limit++] = 0x017A;
715                     break;
716 
717                 case 0x017B:
718                     target[limit++] = 0x017C;
719                     break;
720 
721                 case 0x017D:
722                     target[limit++] = 0x017E;
723                     break;
724 
725                 case 0x017F:
726                     target[limit++] = 0x0073;
727                     break;
728 
729                 case 0x0181:
730                     target[limit++] = 0x0253;
731                     break;
732 
733                 case 0x0182:
734                     target[limit++] = 0x0183;
735                     break;
736 
737                 case 0x0184:
738                     target[limit++] = 0x0185;
739                     break;
740 
741                 case 0x0186:
742                     target[limit++] = 0x0254;
743                     break;
744 
745                 case 0x0187:
746                     target[limit++] = 0x0188;
747                     break;
748 
749                 case 0x0189:
750                     target[limit++] = 0x0256;
751                     break;
752 
753                 case 0x018A:
754                     target[limit++] = 0x0257;
755                     break;
756 
757                 case 0x018B:
758                     target[limit++] = 0x018C;
759                     break;
760 
761                 case 0x018E:
762                     target[limit++] = 0x01DD;
763                     break;
764 
765                 case 0x018F:
766                     target[limit++] = 0x0259;
767                     break;
768 
769                 case 0x0190:
770                     target[limit++] = 0x025B;
771                     break;
772 
773                 case 0x0191:
774                     target[limit++] = 0x0192;
775                     break;
776 
777                 case 0x0193:
778                     target[limit++] = 0x0260;
779                     break;
780 
781                 case 0x0194:
782                     target[limit++] = 0x0263;
783                     break;
784 
785                 case 0x0196:
786                     target[limit++] = 0x0269;
787                     break;
788 
789                 case 0x0197:
790                     target[limit++] = 0x0268;
791                     break;
792 
793                 case 0x0198:
794                     target[limit++] = 0x0199;
795                     break;
796 
797                 case 0x019C:
798                     target[limit++] = 0x026F;
799                     break;
800 
801                 case 0x019D:
802                     target[limit++] = 0x0272;
803                     break;
804 
805                 case 0x019F:
806                     target[limit++] = 0x0275;
807                     break;
808 
809                 case 0x01A0:
810                     target[limit++] = 0x01A1;
811                     break;
812 
813                 case 0x01A2:
814                     target[limit++] = 0x01A3;
815                     break;
816 
817                 case 0x01A4:
818                     target[limit++] = 0x01A5;
819                     break;
820 
821                 case 0x01A6:
822                     target[limit++] = 0x0280;
823                     break;
824 
825                 case 0x01A7:
826                     target[limit++] = 0x01A8;
827                     break;
828 
829                 case 0x01A9:
830                     target[limit++] = 0x0283;
831                     break;
832 
833                 case 0x01AC:
834                     target[limit++] = 0x01AD;
835                     break;
836 
837                 case 0x01AE:
838                     target[limit++] = 0x0288;
839                     break;
840 
841                 case 0x01AF:
842                     target[limit++] = 0x01B0;
843                     break;
844 
845                 case 0x01B1:
846                     target[limit++] = 0x028A;
847                     break;
848 
849                 case 0x01B2:
850                     target[limit++] = 0x028B;
851                     break;
852 
853                 case 0x01B3:
854                     target[limit++] = 0x01B4;
855                     break;
856 
857                 case 0x01B5:
858                     target[limit++] = 0x01B6;
859                     break;
860 
861                 case 0x01B7:
862                     target[limit++] = 0x0292;
863                     break;
864 
865                 case 0x01B8:
866                     target[limit++] = 0x01B9;
867                     break;
868 
869                 case 0x01BC:
870                     target[limit++] = 0x01BD;
871                     break;
872 
873                 case 0x01C4:
874                     target[limit++] = 0x01C6;
875                     break;
876 
877                 case 0x01C5:
878                     target[limit++] = 0x01C6;
879                     break;
880 
881                 case 0x01C7:
882                     target[limit++] = 0x01C9;
883                     break;
884 
885                 case 0x01C8:
886                     target[limit++] = 0x01C9;
887                     break;
888 
889                 case 0x01CA:
890                     target[limit++] = 0x01CC;
891                     break;
892 
893                 case 0x01CB:
894                     target[limit++] = 0x01CC;
895                     break;
896 
897                 case 0x01CD:
898                     target[limit++] = 0x01CE;
899                     break;
900 
901                 case 0x01CF:
902                     target[limit++] = 0x01D0;
903                     break;
904 
905                 case 0x01D1:
906                     target[limit++] = 0x01D2;
907                     break;
908 
909                 case 0x01D3:
910                     target[limit++] = 0x01D4;
911                     break;
912 
913                 case 0x01D5:
914                     target[limit++] = 0x01D6;
915                     break;
916 
917                 case 0x01D7:
918                     target[limit++] = 0x01D8;
919                     break;
920 
921                 case 0x01D9:
922                     target[limit++] = 0x01DA;
923                     break;
924 
925                 case 0x01DB:
926                     target[limit++] = 0x01DC;
927                     break;
928 
929                 case 0x01DE:
930                     target[limit++] = 0x01DF;
931                     break;
932 
933                 case 0x01E0:
934                     target[limit++] = 0x01E1;
935                     break;
936 
937                 case 0x01E2:
938                     target[limit++] = 0x01E3;
939                     break;
940 
941                 case 0x01E4:
942                     target[limit++] = 0x01E5;
943                     break;
944 
945                 case 0x01E6:
946                     target[limit++] = 0x01E7;
947                     break;
948 
949                 case 0x01E8:
950                     target[limit++] = 0x01E9;
951                     break;
952 
953                 case 0x01EA:
954                     target[limit++] = 0x01EB;
955                     break;
956 
957                 case 0x01EC:
958                     target[limit++] = 0x01ED;
959                     break;
960 
961                 case 0x01EE:
962                     target[limit++] = 0x01EF;
963                     break;
964 
965                 case 0x01F0:
966                     target[limit++] = 0x006A;
967                     target[limit++] = 0x030C;
968                     break;
969 
970                 case 0x01F1:
971                     target[limit++] = 0x01F3;
972                     break;
973 
974                 case 0x01F2:
975                     target[limit++] = 0x01F3;
976                     break;
977 
978                 case 0x01F4:
979                     target[limit++] = 0x01F5;
980                     break;
981 
982                 case 0x01F6:
983                     target[limit++] = 0x0195;
984                     break;
985 
986                 case 0x01F7:
987                     target[limit++] = 0x01BF;
988                     break;
989 
990                 case 0x01F8:
991                     target[limit++] = 0x01F9;
992                     break;
993 
994                 case 0x01FA:
995                     target[limit++] = 0x01FB;
996                     break;
997 
998                 case 0x01FC:
999                     target[limit++] = 0x01FD;
1000                     break;
1001 
1002                 case 0x01FE:
1003                     target[limit++] = 0x01FF;
1004                     break;
1005 
1006                 case 0x0200:
1007                     target[limit++] = 0x0201;
1008                     break;
1009 
1010                 case 0x0202:
1011                     target[limit++] = 0x0203;
1012                     break;
1013 
1014                 case 0x0204:
1015                     target[limit++] = 0x0205;
1016                     break;
1017 
1018                 case 0x0206:
1019                     target[limit++] = 0x0207;
1020                     break;
1021 
1022                 case 0x0208:
1023                     target[limit++] = 0x0209;
1024                     break;
1025 
1026                 case 0x020A:
1027                     target[limit++] = 0x020B;
1028                     break;
1029 
1030                 case 0x020C:
1031                     target[limit++] = 0x020D;
1032                     break;
1033 
1034                 case 0x020E:
1035                     target[limit++] = 0x020F;
1036                     break;
1037 
1038                 case 0x0210:
1039                     target[limit++] = 0x0211;
1040                     break;
1041 
1042                 case 0x0212:
1043                     target[limit++] = 0x0213;
1044                     break;
1045 
1046                 case 0x0214:
1047                     target[limit++] = 0x0215;
1048                     break;
1049 
1050                 case 0x0216:
1051                     target[limit++] = 0x0217;
1052                     break;
1053 
1054                 case 0x0218:
1055                     target[limit++] = 0x0219;
1056                     break;
1057 
1058                 case 0x021A:
1059                     target[limit++] = 0x021B;
1060                     break;
1061 
1062                 case 0x021C:
1063                     target[limit++] = 0x021D;
1064                     break;
1065 
1066                 case 0x021E:
1067                     target[limit++] = 0x021F;
1068                     break;
1069 
1070                 case 0x0220:
1071                     target[limit++] = 0x019E;
1072                     break;
1073 
1074                 case 0x0222:
1075                     target[limit++] = 0x0223;
1076                     break;
1077 
1078                 case 0x0224:
1079                     target[limit++] = 0x0225;
1080                     break;
1081 
1082                 case 0x0226:
1083                     target[limit++] = 0x0227;
1084                     break;
1085 
1086                 case 0x0228:
1087                     target[limit++] = 0x0229;
1088                     break;
1089 
1090                 case 0x022A:
1091                     target[limit++] = 0x022B;
1092                     break;
1093 
1094                 case 0x022C:
1095                     target[limit++] = 0x022D;
1096                     break;
1097 
1098                 case 0x022E:
1099                     target[limit++] = 0x022F;
1100                     break;
1101 
1102                 case 0x0230:
1103                     target[limit++] = 0x0231;
1104                     break;
1105 
1106                 case 0x0232:
1107                     target[limit++] = 0x0233;
1108                     break;
1109 
1110                 case 0x0345:
1111                     target[limit++] = 0x03B9;
1112                     break;
1113 
1114                 case 0x034F:
1115                     break;
1116 
1117                 case 0x037A:
1118                     target[limit++] = 0x0020;
1119                     target[limit++] = 0x03B9;
1120                     break;
1121 
1122                 case 0x0386:
1123                     target[limit++] = 0x03AC;
1124                     break;
1125 
1126                 case 0x0388:
1127                     target[limit++] = 0x03AD;
1128                     break;
1129 
1130                 case 0x0389:
1131                     target[limit++] = 0x03AE;
1132                     break;
1133 
1134                 case 0x038A:
1135                     target[limit++] = 0x03AF;
1136                     break;
1137 
1138                 case 0x038C:
1139                     target[limit++] = 0x03CC;
1140                     break;
1141 
1142                 case 0x038E:
1143                     target[limit++] = 0x03CD;
1144                     break;
1145 
1146                 case 0x038F:
1147                     target[limit++] = 0x03CE;
1148                     break;
1149 
1150                 case 0x0390:
1151                     target[limit++] = 0x03B9;
1152                     target[limit++] = 0x0308;
1153                     target[limit++] = 0x0301;
1154                     break;
1155 
1156                 case 0x0391:
1157                     target[limit++] = 0x03B1;
1158                     break;
1159 
1160                 case 0x0392:
1161                     target[limit++] = 0x03B2;
1162                     break;
1163 
1164                 case 0x0393:
1165                     target[limit++] = 0x03B3;
1166                     break;
1167 
1168                 case 0x0394:
1169                     target[limit++] = 0x03B4;
1170                     break;
1171 
1172                 case 0x0395:
1173                     target[limit++] = 0x03B5;
1174                     break;
1175 
1176                 case 0x0396:
1177                     target[limit++] = 0x03B6;
1178                     break;
1179 
1180                 case 0x0397:
1181                     target[limit++] = 0x03B7;
1182                     break;
1183 
1184                 case 0x0398:
1185                     target[limit++] = 0x03B8;
1186                     break;
1187 
1188                 case 0x0399:
1189                     target[limit++] = 0x03B9;
1190                     break;
1191 
1192                 case 0x039A:
1193                     target[limit++] = 0x03BA;
1194                     break;
1195 
1196                 case 0x039B:
1197                     target[limit++] = 0x03BB;
1198                     break;
1199 
1200                 case 0x039C:
1201                     target[limit++] = 0x03BC;
1202                     break;
1203 
1204                 case 0x039D:
1205                     target[limit++] = 0x03BD;
1206                     break;
1207 
1208                 case 0x039E:
1209                     target[limit++] = 0x03BE;
1210                     break;
1211 
1212                 case 0x039F:
1213                     target[limit++] = 0x03BF;
1214                     break;
1215 
1216                 case 0x03A0:
1217                     target[limit++] = 0x03C0;
1218                     break;
1219 
1220                 case 0x03A1:
1221                     target[limit++] = 0x03C1;
1222                     break;
1223 
1224                 case 0x03A3:
1225                     target[limit++] = 0x03C3;
1226                     break;
1227 
1228                 case 0x03A4:
1229                     target[limit++] = 0x03C4;
1230                     break;
1231 
1232                 case 0x03A5:
1233                     target[limit++] = 0x03C5;
1234                     break;
1235 
1236                 case 0x03A6:
1237                     target[limit++] = 0x03C6;
1238                     break;
1239 
1240                 case 0x03A7:
1241                     target[limit++] = 0x03C7;
1242                     break;
1243 
1244                 case 0x03A8:
1245                     target[limit++] = 0x03C8;
1246                     break;
1247 
1248                 case 0x03A9:
1249                     target[limit++] = 0x03C9;
1250                     break;
1251 
1252                 case 0x03AA:
1253                     target[limit++] = 0x03CA;
1254                     break;
1255 
1256                 case 0x03AB:
1257                     target[limit++] = 0x03CB;
1258                     break;
1259 
1260                 case 0x03B0:
1261                     target[limit++] = 0x03C5;
1262                     target[limit++] = 0x0308;
1263                     target[limit++] = 0x0301;
1264                     break;
1265 
1266                 case 0x03C2:
1267                     target[limit++] = 0x03C3;
1268                     break;
1269 
1270                 case 0x03D0:
1271                     target[limit++] = 0x03B2;
1272                     break;
1273 
1274                 case 0x03D1:
1275                     target[limit++] = 0x03B8;
1276                     break;
1277 
1278                 case 0x03D2:
1279                     target[limit++] = 0x03C5;
1280                     break;
1281 
1282                 case 0x03D3:
1283                     target[limit++] = 0x03CD;
1284                     break;
1285 
1286                 case 0x03D4:
1287                     target[limit++] = 0x03CB;
1288                     break;
1289 
1290                 case 0x03D5:
1291                     target[limit++] = 0x03C6;
1292                     break;
1293 
1294                 case 0x03D6:
1295                     target[limit++] = 0x03C0;
1296                     break;
1297 
1298                 case 0x03D8:
1299                     target[limit++] = 0x03D9;
1300                     break;
1301 
1302                 case 0x03DA:
1303                     target[limit++] = 0x03DB;
1304                     break;
1305 
1306                 case 0x03DC:
1307                     target[limit++] = 0x03DD;
1308                     break;
1309 
1310                 case 0x03DE:
1311                     target[limit++] = 0x03DF;
1312                     break;
1313 
1314                 case 0x03E0:
1315                     target[limit++] = 0x03E1;
1316                     break;
1317 
1318                 case 0x03E2:
1319                     target[limit++] = 0x03E3;
1320                     break;
1321 
1322                 case 0x03E4:
1323                     target[limit++] = 0x03E5;
1324                     break;
1325 
1326                 case 0x03E6:
1327                     target[limit++] = 0x03E7;
1328                     break;
1329 
1330                 case 0x03E8:
1331                     target[limit++] = 0x03E9;
1332                     break;
1333 
1334                 case 0x03EA:
1335                     target[limit++] = 0x03EB;
1336                     break;
1337 
1338                 case 0x03EC:
1339                     target[limit++] = 0x03ED;
1340                     break;
1341 
1342                 case 0x03EE:
1343                     target[limit++] = 0x03EF;
1344                     break;
1345 
1346                 case 0x03F0:
1347                     target[limit++] = 0x03BA;
1348                     break;
1349 
1350                 case 0x03F1:
1351                     target[limit++] = 0x03C1;
1352                     break;
1353 
1354                 case 0x03F2:
1355                     target[limit++] = 0x03C3;
1356                     break;
1357 
1358                 case 0x03F4:
1359                     target[limit++] = 0x03B8;
1360                     break;
1361 
1362                 case 0x03F5:
1363                     target[limit++] = 0x03B5;
1364                     break;
1365 
1366                 case 0x0400:
1367                     target[limit++] = 0x0450;
1368                     break;
1369 
1370                 case 0x0401:
1371                     target[limit++] = 0x0451;
1372                     break;
1373 
1374                 case 0x0402:
1375                     target[limit++] = 0x0452;
1376                     break;
1377 
1378                 case 0x0403:
1379                     target[limit++] = 0x0453;
1380                     break;
1381 
1382                 case 0x0404:
1383                     target[limit++] = 0x0454;
1384                     break;
1385 
1386                 case 0x0405:
1387                     target[limit++] = 0x0455;
1388                     break;
1389 
1390                 case 0x0406:
1391                     target[limit++] = 0x0456;
1392                     break;
1393 
1394                 case 0x0407:
1395                     target[limit++] = 0x0457;
1396                     break;
1397 
1398                 case 0x0408:
1399                     target[limit++] = 0x0458;
1400                     break;
1401 
1402                 case 0x0409:
1403                     target[limit++] = 0x0459;
1404                     break;
1405 
1406                 case 0x040A:
1407                     target[limit++] = 0x045A;
1408                     break;
1409 
1410                 case 0x040B:
1411                     target[limit++] = 0x045B;
1412                     break;
1413 
1414                 case 0x040C:
1415                     target[limit++] = 0x045C;
1416                     break;
1417 
1418                 case 0x040D:
1419                     target[limit++] = 0x045D;
1420                     break;
1421 
1422                 case 0x040E:
1423                     target[limit++] = 0x045E;
1424                     break;
1425 
1426                 case 0x040F:
1427                     target[limit++] = 0x045F;
1428                     break;
1429 
1430                 case 0x0410:
1431                     target[limit++] = 0x0430;
1432                     break;
1433 
1434                 case 0x0411:
1435                     target[limit++] = 0x0431;
1436                     break;
1437 
1438                 case 0x0412:
1439                     target[limit++] = 0x0432;
1440                     break;
1441 
1442                 case 0x0413:
1443                     target[limit++] = 0x0433;
1444                     break;
1445 
1446                 case 0x0414:
1447                     target[limit++] = 0x0434;
1448                     break;
1449 
1450                 case 0x0415:
1451                     target[limit++] = 0x0435;
1452                     break;
1453 
1454                 case 0x0416:
1455                     target[limit++] = 0x0436;
1456                     break;
1457 
1458                 case 0x0417:
1459                     target[limit++] = 0x0437;
1460                     break;
1461 
1462                 case 0x0418:
1463                     target[limit++] = 0x0438;
1464                     break;
1465 
1466                 case 0x0419:
1467                     target[limit++] = 0x0439;
1468                     break;
1469 
1470                 case 0x041A:
1471                     target[limit++] = 0x043A;
1472                     break;
1473 
1474                 case 0x041B:
1475                     target[limit++] = 0x043B;
1476                     break;
1477 
1478                 case 0x041C:
1479                     target[limit++] = 0x043C;
1480                     break;
1481 
1482                 case 0x041D:
1483                     target[limit++] = 0x043D;
1484                     break;
1485 
1486                 case 0x041E:
1487                     target[limit++] = 0x043E;
1488                     break;
1489 
1490                 case 0x041F:
1491                     target[limit++] = 0x043F;
1492                     break;
1493 
1494                 case 0x0420:
1495                     target[limit++] = 0x0440;
1496                     break;
1497 
1498                 case 0x0421:
1499                     target[limit++] = 0x0441;
1500                     break;
1501 
1502                 case 0x0422:
1503                     target[limit++] = 0x0442;
1504                     break;
1505 
1506                 case 0x0423:
1507                     target[limit++] = 0x0443;
1508                     break;
1509 
1510                 case 0x0424:
1511                     target[limit++] = 0x0444;
1512                     break;
1513 
1514                 case 0x0425:
1515                     target[limit++] = 0x0445;
1516                     break;
1517 
1518                 case 0x0426:
1519                     target[limit++] = 0x0446;
1520                     break;
1521 
1522                 case 0x0427:
1523                     target[limit++] = 0x0447;
1524                     break;
1525 
1526                 case 0x0428:
1527                     target[limit++] = 0x0448;
1528                     break;
1529 
1530                 case 0x0429:
1531                     target[limit++] = 0x0449;
1532                     break;
1533 
1534                 case 0x042A:
1535                     target[limit++] = 0x044A;
1536                     break;
1537 
1538                 case 0x042B:
1539                     target[limit++] = 0x044B;
1540                     break;
1541 
1542                 case 0x042C:
1543                     target[limit++] = 0x044C;
1544                     break;
1545 
1546                 case 0x042D:
1547                     target[limit++] = 0x044D;
1548                     break;
1549 
1550                 case 0x042E:
1551                     target[limit++] = 0x044E;
1552                     break;
1553 
1554                 case 0x042F:
1555                     target[limit++] = 0x044F;
1556                     break;
1557 
1558                 case 0x0460:
1559                     target[limit++] = 0x0461;
1560                     break;
1561 
1562                 case 0x0462:
1563                     target[limit++] = 0x0463;
1564                     break;
1565 
1566                 case 0x0464:
1567                     target[limit++] = 0x0465;
1568                     break;
1569 
1570                 case 0x0466:
1571                     target[limit++] = 0x0467;
1572                     break;
1573 
1574                 case 0x0468:
1575                     target[limit++] = 0x0469;
1576                     break;
1577 
1578                 case 0x046A:
1579                     target[limit++] = 0x046B;
1580                     break;
1581 
1582                 case 0x046C:
1583                     target[limit++] = 0x046D;
1584                     break;
1585 
1586                 case 0x046E:
1587                     target[limit++] = 0x046F;
1588                     break;
1589 
1590                 case 0x0470:
1591                     target[limit++] = 0x0471;
1592                     break;
1593 
1594                 case 0x0472:
1595                     target[limit++] = 0x0473;
1596                     break;
1597 
1598                 case 0x0474:
1599                     target[limit++] = 0x0475;
1600                     break;
1601 
1602                 case 0x0476:
1603                     target[limit++] = 0x0477;
1604                     break;
1605 
1606                 case 0x0478:
1607                     target[limit++] = 0x0479;
1608                     break;
1609 
1610                 case 0x047A:
1611                     target[limit++] = 0x047B;
1612                     break;
1613 
1614                 case 0x047C:
1615                     target[limit++] = 0x047D;
1616                     break;
1617 
1618                 case 0x047E:
1619                     target[limit++] = 0x047F;
1620                     break;
1621 
1622                 case 0x0480:
1623                     target[limit++] = 0x0481;
1624                     break;
1625 
1626                 case 0x048A:
1627                     target[limit++] = 0x048B;
1628                     break;
1629 
1630                 case 0x048C:
1631                     target[limit++] = 0x048D;
1632                     break;
1633 
1634                 case 0x048E:
1635                     target[limit++] = 0x048F;
1636                     break;
1637 
1638                 case 0x0490:
1639                     target[limit++] = 0x0491;
1640                     break;
1641 
1642                 case 0x0492:
1643                     target[limit++] = 0x0493;
1644                     break;
1645 
1646                 case 0x0494:
1647                     target[limit++] = 0x0495;
1648                     break;
1649 
1650                 case 0x0496:
1651                     target[limit++] = 0x0497;
1652                     break;
1653 
1654                 case 0x0498:
1655                     target[limit++] = 0x0499;
1656                     break;
1657 
1658                 case 0x049A:
1659                     target[limit++] = 0x049B;
1660                     break;
1661 
1662                 case 0x049C:
1663                     target[limit++] = 0x049D;
1664                     break;
1665 
1666                 case 0x049E:
1667                     target[limit++] = 0x049F;
1668                     break;
1669 
1670                 case 0x04A0:
1671                     target[limit++] = 0x04A1;
1672                     break;
1673 
1674                 case 0x04A2:
1675                     target[limit++] = 0x04A3;
1676                     break;
1677 
1678                 case 0x04A4:
1679                     target[limit++] = 0x04A5;
1680                     break;
1681 
1682                 case 0x04A6:
1683                     target[limit++] = 0x04A7;
1684                     break;
1685 
1686                 case 0x04A8:
1687                     target[limit++] = 0x04A9;
1688                     break;
1689 
1690                 case 0x04AA:
1691                     target[limit++] = 0x04AB;
1692                     break;
1693 
1694                 case 0x04AC:
1695                     target[limit++] = 0x04AD;
1696                     break;
1697 
1698                 case 0x04AE:
1699                     target[limit++] = 0x04AF;
1700                     break;
1701 
1702                 case 0x04B0:
1703                     target[limit++] = 0x04B1;
1704                     break;
1705 
1706                 case 0x04B2:
1707                     target[limit++] = 0x04B3;
1708                     break;
1709 
1710                 case 0x04B4:
1711                     target[limit++] = 0x04B5;
1712                     break;
1713 
1714                 case 0x04B6:
1715                     target[limit++] = 0x04B7;
1716                     break;
1717 
1718                 case 0x04B8:
1719                     target[limit++] = 0x04B9;
1720                     break;
1721 
1722                 case 0x04BA:
1723                     target[limit++] = 0x04BB;
1724                     break;
1725 
1726                 case 0x04BC:
1727                     target[limit++] = 0x04BD;
1728                     break;
1729 
1730                 case 0x04BE:
1731                     target[limit++] = 0x04BF;
1732                     break;
1733 
1734                 case 0x04C1:
1735                     target[limit++] = 0x04C2;
1736                     break;
1737 
1738                 case 0x04C3:
1739                     target[limit++] = 0x04C4;
1740                     break;
1741 
1742                 case 0x04C5:
1743                     target[limit++] = 0x04C6;
1744                     break;
1745 
1746                 case 0x04C7:
1747                     target[limit++] = 0x04C8;
1748                     break;
1749 
1750                 case 0x04C9:
1751                     target[limit++] = 0x04CA;
1752                     break;
1753 
1754                 case 0x04CB:
1755                     target[limit++] = 0x04CC;
1756                     break;
1757 
1758                 case 0x04CD:
1759                     target[limit++] = 0x04CE;
1760                     break;
1761 
1762                 case 0x04D0:
1763                     target[limit++] = 0x04D1;
1764                     break;
1765 
1766                 case 0x04D2:
1767                     target[limit++] = 0x04D3;
1768                     break;
1769 
1770                 case 0x04D4:
1771                     target[limit++] = 0x04D5;
1772                     break;
1773 
1774                 case 0x04D6:
1775                     target[limit++] = 0x04D7;
1776                     break;
1777 
1778                 case 0x04D8:
1779                     target[limit++] = 0x04D9;
1780                     break;
1781 
1782                 case 0x04DA:
1783                     target[limit++] = 0x04DB;
1784                     break;
1785 
1786                 case 0x04DC:
1787                     target[limit++] = 0x04DD;
1788                     break;
1789 
1790                 case 0x04DE:
1791                     target[limit++] = 0x04DF;
1792                     break;
1793 
1794                 case 0x04E0:
1795                     target[limit++] = 0x04E1;
1796                     break;
1797 
1798                 case 0x04E2:
1799                     target[limit++] = 0x04E3;
1800                     break;
1801 
1802                 case 0x04E4:
1803                     target[limit++] = 0x04E5;
1804                     break;
1805 
1806                 case 0x04E6:
1807                     target[limit++] = 0x04E7;
1808                     break;
1809 
1810                 case 0x04E8:
1811                     target[limit++] = 0x04E9;
1812                     break;
1813 
1814                 case 0x04EA:
1815                     target[limit++] = 0x04EB;
1816                     break;
1817 
1818                 case 0x04EC:
1819                     target[limit++] = 0x04ED;
1820                     break;
1821 
1822                 case 0x04EE:
1823                     target[limit++] = 0x04EF;
1824                     break;
1825 
1826                 case 0x04F0:
1827                     target[limit++] = 0x04F1;
1828                     break;
1829 
1830                 case 0x04F2:
1831                     target[limit++] = 0x04F3;
1832                     break;
1833 
1834                 case 0x04F4:
1835                     target[limit++] = 0x04F5;
1836                     break;
1837 
1838                 case 0x04F8:
1839                     target[limit++] = 0x04F9;
1840                     break;
1841 
1842                 case 0x0500:
1843                     target[limit++] = 0x0501;
1844                     break;
1845 
1846                 case 0x0502:
1847                     target[limit++] = 0x0503;
1848                     break;
1849 
1850                 case 0x0504:
1851                     target[limit++] = 0x0505;
1852                     break;
1853 
1854                 case 0x0506:
1855                     target[limit++] = 0x0507;
1856                     break;
1857 
1858                 case 0x0508:
1859                     target[limit++] = 0x0509;
1860                     break;
1861 
1862                 case 0x050A:
1863                     target[limit++] = 0x050B;
1864                     break;
1865 
1866                 case 0x050C:
1867                     target[limit++] = 0x050D;
1868                     break;
1869 
1870                 case 0x050E:
1871                     target[limit++] = 0x050F;
1872                     break;
1873 
1874                 case 0x0531:
1875                     target[limit++] = 0x0561;
1876                     break;
1877 
1878                 case 0x0532:
1879                     target[limit++] = 0x0562;
1880                     break;
1881 
1882                 case 0x0533:
1883                     target[limit++] = 0x0563;
1884                     break;
1885 
1886                 case 0x0534:
1887                     target[limit++] = 0x0564;
1888                     break;
1889 
1890                 case 0x0535:
1891                     target[limit++] = 0x0565;
1892                     break;
1893 
1894                 case 0x0536:
1895                     target[limit++] = 0x0566;
1896                     break;
1897 
1898                 case 0x0537:
1899                     target[limit++] = 0x0567;
1900                     break;
1901 
1902                 case 0x0538:
1903                     target[limit++] = 0x0568;
1904                     break;
1905 
1906                 case 0x0539:
1907                     target[limit++] = 0x0569;
1908                     break;
1909 
1910                 case 0x053A:
1911                     target[limit++] = 0x056A;
1912                     break;
1913 
1914                 case 0x053B:
1915                     target[limit++] = 0x056B;
1916                     break;
1917 
1918                 case 0x053C:
1919                     target[limit++] = 0x056C;
1920                     break;
1921 
1922                 case 0x053D:
1923                     target[limit++] = 0x056D;
1924                     break;
1925 
1926                 case 0x053E:
1927                     target[limit++] = 0x056E;
1928                     break;
1929 
1930                 case 0x053F:
1931                     target[limit++] = 0x056F;
1932                     break;
1933 
1934                 case 0x0540:
1935                     target[limit++] = 0x0570;
1936                     break;
1937 
1938                 case 0x0541:
1939                     target[limit++] = 0x0571;
1940                     break;
1941 
1942                 case 0x0542:
1943                     target[limit++] = 0x0572;
1944                     break;
1945 
1946                 case 0x0543:
1947                     target[limit++] = 0x0573;
1948                     break;
1949 
1950                 case 0x0544:
1951                     target[limit++] = 0x0574;
1952                     break;
1953 
1954                 case 0x0545:
1955                     target[limit++] = 0x0575;
1956                     break;
1957 
1958                 case 0x0546:
1959                     target[limit++] = 0x0576;
1960                     break;
1961 
1962                 case 0x0547:
1963                     target[limit++] = 0x0577;
1964                     break;
1965 
1966                 case 0x0548:
1967                     target[limit++] = 0x0578;
1968                     break;
1969 
1970                 case 0x0549:
1971                     target[limit++] = 0x0579;
1972                     break;
1973 
1974                 case 0x054A:
1975                     target[limit++] = 0x057A;
1976                     break;
1977 
1978                 case 0x054B:
1979                     target[limit++] = 0x057B;
1980                     break;
1981 
1982                 case 0x054C:
1983                     target[limit++] = 0x057C;
1984                     break;
1985 
1986                 case 0x054D:
1987                     target[limit++] = 0x057D;
1988                     break;
1989 
1990                 case 0x054E:
1991                     target[limit++] = 0x057E;
1992                     break;
1993 
1994                 case 0x054F:
1995                     target[limit++] = 0x057F;
1996                     break;
1997 
1998                 case 0x0550:
1999                     target[limit++] = 0x0580;
2000                     break;
2001 
2002                 case 0x0551:
2003                     target[limit++] = 0x0581;
2004                     break;
2005 
2006                 case 0x0552:
2007                     target[limit++] = 0x0582;
2008                     break;
2009 
2010                 case 0x0553:
2011                     target[limit++] = 0x0583;
2012                     break;
2013 
2014                 case 0x0554:
2015                     target[limit++] = 0x0584;
2016                     break;
2017 
2018                 case 0x0555:
2019                     target[limit++] = 0x0585;
2020                     break;
2021 
2022                 case 0x0556:
2023                     target[limit++] = 0x0586;
2024                     break;
2025 
2026                 case 0x0587:
2027                     target[limit++] = 0x0565;
2028                     target[limit++] = 0x0582;
2029                     break;
2030 
2031                 case 0x06DD:
2032                     break;
2033 
2034                 case 0x070F:
2035                     break;
2036 
2037                 case 0x1680:
2038                     target[limit++] = 0x0020;
2039                     break;
2040 
2041                 case 0x1806:
2042                     break;
2043 
2044                 case 0x180B:
2045                 case 0x180C:
2046                 case 0x180D:
2047                 case 0x180E:
2048                     break;
2049 
2050                 case 0x1E00:
2051                     target[limit++] = 0x1E01;
2052                     break;
2053 
2054                 case 0x1E02:
2055                     target[limit++] = 0x1E03;
2056                     break;
2057 
2058                 case 0x1E04:
2059                     target[limit++] = 0x1E05;
2060                     break;
2061 
2062                 case 0x1E06:
2063                     target[limit++] = 0x1E07;
2064                     break;
2065 
2066                 case 0x1E08:
2067                     target[limit++] = 0x1E09;
2068                     break;
2069 
2070                 case 0x1E0A:
2071                     target[limit++] = 0x1E0B;
2072                     break;
2073 
2074                 case 0x1E0C:
2075                     target[limit++] = 0x1E0D;
2076                     break;
2077 
2078                 case 0x1E0E:
2079                     target[limit++] = 0x1E0F;
2080                     break;
2081 
2082                 case 0x1E10:
2083                     target[limit++] = 0x1E11;
2084                     break;
2085 
2086                 case 0x1E12:
2087                     target[limit++] = 0x1E13;
2088                     break;
2089 
2090                 case 0x1E14:
2091                     target[limit++] = 0x1E15;
2092                     break;
2093 
2094                 case 0x1E16:
2095                     target[limit++] = 0x1E17;
2096                     break;
2097 
2098                 case 0x1E18:
2099                     target[limit++] = 0x1E19;
2100                     break;
2101 
2102                 case 0x1E1A:
2103                     target[limit++] = 0x1E1B;
2104                     break;
2105 
2106                 case 0x1E1C:
2107                     target[limit++] = 0x1E1D;
2108                     break;
2109 
2110                 case 0x1E1E:
2111                     target[limit++] = 0x1E1F;
2112                     break;
2113 
2114                 case 0x1E20:
2115                     target[limit++] = 0x1E21;
2116                     break;
2117 
2118                 case 0x1E22:
2119                     target[limit++] = 0x1E23;
2120                     break;
2121 
2122                 case 0x1E24:
2123                     target[limit++] = 0x1E25;
2124                     break;
2125 
2126                 case 0x1E26:
2127                     target[limit++] = 0x1E27;
2128                     break;
2129 
2130                 case 0x1E28:
2131                     target[limit++] = 0x1E29;
2132                     break;
2133 
2134                 case 0x1E2A:
2135                     target[limit++] = 0x1E2B;
2136                     break;
2137 
2138                 case 0x1E2C:
2139                     target[limit++] = 0x1E2D;
2140                     break;
2141 
2142                 case 0x1E2E:
2143                     target[limit++] = 0x1E2F;
2144                     break;
2145 
2146                 case 0x1E30:
2147                     target[limit++] = 0x1E31;
2148                     break;
2149 
2150                 case 0x1E32:
2151                     target[limit++] = 0x1E33;
2152                     break;
2153 
2154                 case 0x1E34:
2155                     target[limit++] = 0x1E35;
2156                     break;
2157 
2158                 case 0x1E36:
2159                     target[limit++] = 0x1E37;
2160                     break;
2161 
2162                 case 0x1E38:
2163                     target[limit++] = 0x1E39;
2164                     break;
2165 
2166                 case 0x1E3A:
2167                     target[limit++] = 0x1E3B;
2168                     break;
2169 
2170                 case 0x1E3C:
2171                     target[limit++] = 0x1E3D;
2172                     break;
2173 
2174                 case 0x1E3E:
2175                     target[limit++] = 0x1E3F;
2176                     break;
2177 
2178                 case 0x1E40:
2179                     target[limit++] = 0x1E41;
2180                     break;
2181 
2182                 case 0x1E42:
2183                     target[limit++] = 0x1E43;
2184                     break;
2185 
2186                 case 0x1E44:
2187                     target[limit++] = 0x1E45;
2188                     break;
2189 
2190                 case 0x1E46:
2191                     target[limit++] = 0x1E47;
2192                     break;
2193 
2194                 case 0x1E48:
2195                     target[limit++] = 0x1E49;
2196                     break;
2197 
2198                 case 0x1E4A:
2199                     target[limit++] = 0x1E4B;
2200                     break;
2201 
2202                 case 0x1E4C:
2203                     target[limit++] = 0x1E4D;
2204                     break;
2205 
2206                 case 0x1E4E:
2207                     target[limit++] = 0x1E4F;
2208                     break;
2209 
2210                 case 0x1E50:
2211                     target[limit++] = 0x1E51;
2212                     break;
2213 
2214                 case 0x1E52:
2215                     target[limit++] = 0x1E53;
2216                     break;
2217 
2218                 case 0x1E54:
2219                     target[limit++] = 0x1E55;
2220                     break;
2221 
2222                 case 0x1E56:
2223                     target[limit++] = 0x1E57;
2224                     break;
2225 
2226                 case 0x1E58:
2227                     target[limit++] = 0x1E59;
2228                     break;
2229 
2230                 case 0x1E5A:
2231                     target[limit++] = 0x1E5B;
2232                     break;
2233 
2234                 case 0x1E5C:
2235                     target[limit++] = 0x1E5D;
2236                     break;
2237 
2238                 case 0x1E5E:
2239                     target[limit++] = 0x1E5F;
2240                     break;
2241 
2242                 case 0x1E60:
2243                     target[limit++] = 0x1E61;
2244                     break;
2245 
2246                 case 0x1E62:
2247                     target[limit++] = 0x1E63;
2248                     break;
2249 
2250                 case 0x1E64:
2251                     target[limit++] = 0x1E65;
2252                     break;
2253 
2254                 case 0x1E66:
2255                     target[limit++] = 0x1E67;
2256                     break;
2257 
2258                 case 0x1E68:
2259                     target[limit++] = 0x1E69;
2260                     break;
2261 
2262                 case 0x1E6A:
2263                     target[limit++] = 0x1E6B;
2264                     break;
2265 
2266                 case 0x1E6C:
2267                     target[limit++] = 0x1E6D;
2268                     break;
2269 
2270                 case 0x1E6E:
2271                     target[limit++] = 0x1E6F;
2272                     break;
2273 
2274                 case 0x1E70:
2275                     target[limit++] = 0x1E71;
2276                     break;
2277 
2278                 case 0x1E72:
2279                     target[limit++] = 0x1E73;
2280                     break;
2281 
2282                 case 0x1E74:
2283                     target[limit++] = 0x1E75;
2284                     break;
2285 
2286                 case 0x1E76:
2287                     target[limit++] = 0x1E77;
2288                     break;
2289 
2290                 case 0x1E78:
2291                     target[limit++] = 0x1E79;
2292                     break;
2293 
2294                 case 0x1E7A:
2295                     target[limit++] = 0x1E7B;
2296                     break;
2297 
2298                 case 0x1E7C:
2299                     target[limit++] = 0x1E7D;
2300                     break;
2301 
2302                 case 0x1E7E:
2303                     target[limit++] = 0x1E7F;
2304                     break;
2305 
2306                 case 0x1E80:
2307                     target[limit++] = 0x1E81;
2308                     break;
2309 
2310                 case 0x1E82:
2311                     target[limit++] = 0x1E83;
2312                     break;
2313 
2314                 case 0x1E84:
2315                     target[limit++] = 0x1E85;
2316                     break;
2317 
2318                 case 0x1E86:
2319                     target[limit++] = 0x1E87;
2320                     break;
2321 
2322                 case 0x1E88:
2323                     target[limit++] = 0x1E89;
2324                     break;
2325 
2326                 case 0x1E8A:
2327                     target[limit++] = 0x1E8B;
2328                     break;
2329 
2330                 case 0x1E8C:
2331                     target[limit++] = 0x1E8D;
2332                     break;
2333 
2334                 case 0x1E8E:
2335                     target[limit++] = 0x1E8F;
2336                     break;
2337 
2338                 case 0x1E90:
2339                     target[limit++] = 0x1E91;
2340                     break;
2341 
2342                 case 0x1E92:
2343                     target[limit++] = 0x1E93;
2344                     break;
2345 
2346                 case 0x1E94:
2347                     target[limit++] = 0x1E95;
2348                     break;
2349 
2350                 case 0x1E96:
2351                     target[limit++] = 0x0068;
2352                     target[limit++] = 0x0331;
2353                     break;
2354 
2355                 case 0x1E97:
2356                     target[limit++] = 0x0074;
2357                     target[limit++] = 0x0308;
2358                     break;
2359 
2360                 case 0x1E98:
2361                     target[limit++] = 0x0077;
2362                     target[limit++] = 0x030A;
2363                     break;
2364 
2365                 case 0x1E99:
2366                     target[limit++] = 0x0079;
2367                     target[limit++] = 0x030A;
2368                     break;
2369 
2370                 case 0x1E9A:
2371                     target[limit++] = 0x0061;
2372                     target[limit++] = 0x02BE;
2373                     break;
2374 
2375                 case 0x1E9B:
2376                     target[limit++] = 0x1E61;
2377                     break;
2378 
2379                 case 0x1EA0:
2380                     target[limit++] = 0x1EA1;
2381                     break;
2382 
2383                 case 0x1EA2:
2384                     target[limit++] = 0x1EA3;
2385                     break;
2386 
2387                 case 0x1EA4:
2388                     target[limit++] = 0x1EA5;
2389                     break;
2390 
2391                 case 0x1EA6:
2392                     target[limit++] = 0x1EA7;
2393                     break;
2394 
2395                 case 0x1EA8:
2396                     target[limit++] = 0x1EA9;
2397                     break;
2398 
2399                 case 0x1EAA:
2400                     target[limit++] = 0x1EAB;
2401                     break;
2402 
2403                 case 0x1EAC:
2404                     target[limit++] = 0x1EAD;
2405                     break;
2406 
2407                 case 0x1EAE:
2408                     target[limit++] = 0x1EAF;
2409                     break;
2410 
2411                 case 0x1EB0:
2412                     target[limit++] = 0x1EB1;
2413                     break;
2414 
2415                 case 0x1EB2:
2416                     target[limit++] = 0x1EB3;
2417                     break;
2418 
2419                 case 0x1EB4:
2420                     target[limit++] = 0x1EB5;
2421                     break;
2422 
2423                 case 0x1EB6:
2424                     target[limit++] = 0x1EB7;
2425                     break;
2426 
2427                 case 0x1EB8:
2428                     target[limit++] = 0x1EB9;
2429                     break;
2430 
2431                 case 0x1EBA:
2432                     target[limit++] = 0x1EBB;
2433                     break;
2434 
2435                 case 0x1EBC:
2436                     target[limit++] = 0x1EBD;
2437                     break;
2438 
2439                 case 0x1EBE:
2440                     target[limit++] = 0x1EBF;
2441                     break;
2442 
2443                 case 0x1EC0:
2444                     target[limit++] = 0x1EC1;
2445                     break;
2446 
2447                 case 0x1EC2:
2448                     target[limit++] = 0x1EC3;
2449                     break;
2450 
2451                 case 0x1EC4:
2452                     target[limit++] = 0x1EC5;
2453                     break;
2454 
2455                 case 0x1EC6:
2456                     target[limit++] = 0x1EC7;
2457                     break;
2458 
2459                 case 0x1EC8:
2460                     target[limit++] = 0x1EC9;
2461                     break;
2462 
2463                 case 0x1ECA:
2464                     target[limit++] = 0x1ECB;
2465                     break;
2466 
2467                 case 0x1ECC:
2468                     target[limit++] = 0x1ECD;
2469                     break;
2470 
2471                 case 0x1ECE:
2472                     target[limit++] = 0x1ECF;
2473                     break;
2474 
2475                 case 0x1ED0:
2476                     target[limit++] = 0x1ED1;
2477                     break;
2478 
2479                 case 0x1ED2:
2480                     target[limit++] = 0x1ED3;
2481                     break;
2482 
2483                 case 0x1ED4:
2484                     target[limit++] = 0x1ED5;
2485                     break;
2486 
2487                 case 0x1ED6:
2488                     target[limit++] = 0x1ED7;
2489                     break;
2490 
2491                 case 0x1ED8:
2492                     target[limit++] = 0x1ED9;
2493                     break;
2494 
2495                 case 0x1EDA:
2496                     target[limit++] = 0x1EDB;
2497                     break;
2498 
2499                 case 0x1EDC:
2500                     target[limit++] = 0x1EDD;
2501                     break;
2502 
2503                 case 0x1EDE:
2504                     target[limit++] = 0x1EDF;
2505                     break;
2506 
2507                 case 0x1EE0:
2508                     target[limit++] = 0x1EE1;
2509                     break;
2510 
2511                 case 0x1EE2:
2512                     target[limit++] = 0x1EE3;
2513                     break;
2514 
2515                 case 0x1EE4:
2516                     target[limit++] = 0x1EE5;
2517                     break;
2518 
2519                 case 0x1EE6:
2520                     target[limit++] = 0x1EE7;
2521                     break;
2522 
2523                 case 0x1EE8:
2524                     target[limit++] = 0x1EE9;
2525                     break;
2526 
2527                 case 0x1EEA:
2528                     target[limit++] = 0x1EEB;
2529                     break;
2530 
2531                 case 0x1EEC:
2532                     target[limit++] = 0x1EED;
2533                     break;
2534 
2535                 case 0x1EEE:
2536                     target[limit++] = 0x1EEF;
2537                     break;
2538 
2539                 case 0x1EF0:
2540                     target[limit++] = 0x1EF1;
2541                     break;
2542 
2543                 case 0x1EF2:
2544                     target[limit++] = 0x1EF3;
2545                     break;
2546 
2547                 case 0x1EF4:
2548                     target[limit++] = 0x1EF5;
2549                     break;
2550 
2551                 case 0x1EF6:
2552                     target[limit++] = 0x1EF7;
2553                     break;
2554 
2555                 case 0x1EF8:
2556                     target[limit++] = 0x1EF9;
2557                     break;
2558 
2559                 case 0x1F08:
2560                     target[limit++] = 0x1F00;
2561                     break;
2562 
2563                 case 0x1F09:
2564                     target[limit++] = 0x1F01;
2565                     break;
2566 
2567                 case 0x1F0A:
2568                     target[limit++] = 0x1F02;
2569                     break;
2570 
2571                 case 0x1F0B:
2572                     target[limit++] = 0x1F03;
2573                     break;
2574 
2575                 case 0x1F0C:
2576                     target[limit++] = 0x1F04;
2577                     break;
2578 
2579                 case 0x1F0D:
2580                     target[limit++] = 0x1F05;
2581                     break;
2582 
2583                 case 0x1F0E:
2584                     target[limit++] = 0x1F06;
2585                     break;
2586 
2587                 case 0x1F0F:
2588                     target[limit++] = 0x1F07;
2589                     break;
2590 
2591                 case 0x1F18:
2592                     target[limit++] = 0x1F10;
2593                     break;
2594 
2595                 case 0x1F19:
2596                     target[limit++] = 0x1F11;
2597                     break;
2598 
2599                 case 0x1F1A:
2600                     target[limit++] = 0x1F12;
2601                     break;
2602 
2603                 case 0x1F1B:
2604                     target[limit++] = 0x1F13;
2605                     break;
2606 
2607                 case 0x1F1C:
2608                     target[limit++] = 0x1F14;
2609                     break;
2610 
2611                 case 0x1F1D:
2612                     target[limit++] = 0x1F15;
2613                     break;
2614 
2615                 case 0x1F28:
2616                     target[limit++] = 0x1F20;
2617                     break;
2618 
2619                 case 0x1F29:
2620                     target[limit++] = 0x1F21;
2621                     break;
2622 
2623                 case 0x1F2A:
2624                     target[limit++] = 0x1F22;
2625                     break;
2626 
2627                 case 0x1F2B:
2628                     target[limit++] = 0x1F23;
2629                     break;
2630 
2631                 case 0x1F2C:
2632                     target[limit++] = 0x1F24;
2633                     break;
2634 
2635                 case 0x1F2D:
2636                     target[limit++] = 0x1F25;
2637                     break;
2638 
2639                 case 0x1F2E:
2640                     target[limit++] = 0x1F26;
2641                     break;
2642 
2643                 case 0x1F2F:
2644                     target[limit++] = 0x1F27;
2645                     break;
2646 
2647                 case 0x1F38:
2648                     target[limit++] = 0x1F30;
2649                     break;
2650 
2651                 case 0x1F39:
2652                     target[limit++] = 0x1F31;
2653                     break;
2654 
2655                 case 0x1F3A:
2656                     target[limit++] = 0x1F32;
2657                     break;
2658 
2659                 case 0x1F3B:
2660                     target[limit++] = 0x1F33;
2661                     break;
2662 
2663                 case 0x1F3C:
2664                     target[limit++] = 0x1F34;
2665                     break;
2666 
2667                 case 0x1F3D:
2668                     target[limit++] = 0x1F35;
2669                     break;
2670 
2671                 case 0x1F3E:
2672                     target[limit++] = 0x1F36;
2673                     break;
2674 
2675                 case 0x1F3F:
2676                     target[limit++] = 0x1F37;
2677                     break;
2678 
2679                 case 0x1F48:
2680                     target[limit++] = 0x1F40;
2681                     break;
2682 
2683                 case 0x1F49:
2684                     target[limit++] = 0x1F41;
2685                     break;
2686 
2687                 case 0x1F4A:
2688                     target[limit++] = 0x1F42;
2689                     break;
2690 
2691                 case 0x1F4B:
2692                     target[limit++] = 0x1F43;
2693                     break;
2694 
2695                 case 0x1F4C:
2696                     target[limit++] = 0x1F44;
2697                     break;
2698 
2699                 case 0x1F4D:
2700                     target[limit++] = 0x1F45;
2701                     break;
2702 
2703                 case 0x1F50:
2704                     target[limit++] = 0x03C5;
2705                     target[limit++] = 0x0313;
2706                     break;
2707 
2708                 case 0x1F52:
2709                     target[limit++] = 0x03C5;
2710                     target[limit++] = 0x0313;
2711                     target[limit++] = 0x0300;
2712                     break;
2713 
2714                 case 0x1F54:
2715                     target[limit++] = 0x03C5;
2716                     target[limit++] = 0x0313;
2717                     target[limit++] = 0x0301;
2718                     break;
2719 
2720                 case 0x1F56:
2721                     target[limit++] = 0x03C5;
2722                     target[limit++] = 0x0313;
2723                     target[limit++] = 0x0342;
2724                     break;
2725 
2726                 case 0x1F59:
2727                     target[limit++] = 0x1F51;
2728                     break;
2729 
2730                 case 0x1F5B:
2731                     target[limit++] = 0x1F53;
2732                     break;
2733 
2734                 case 0x1F5D:
2735                     target[limit++] = 0x1F55;
2736                     break;
2737 
2738                 case 0x1F5F:
2739                     target[limit++] = 0x1F57;
2740                     break;
2741 
2742                 case 0x1F68:
2743                     target[limit++] = 0x1F60;
2744                     break;
2745 
2746                 case 0x1F69:
2747                     target[limit++] = 0x1F61;
2748                     break;
2749 
2750                 case 0x1F6A:
2751                     target[limit++] = 0x1F62;
2752                     break;
2753 
2754                 case 0x1F6B:
2755                     target[limit++] = 0x1F63;
2756                     break;
2757 
2758                 case 0x1F6C:
2759                     target[limit++] = 0x1F64;
2760                     break;
2761 
2762                 case 0x1F6D:
2763                     target[limit++] = 0x1F65;
2764                     break;
2765 
2766                 case 0x1F6E:
2767                     target[limit++] = 0x1F66;
2768                     break;
2769 
2770                 case 0x1F6F:
2771                     target[limit++] = 0x1F67;
2772                     break;
2773 
2774                 case 0x1F80:
2775                     target[limit++] = 0x1F00;
2776                     target[limit++] = 0x03B9;
2777                     break;
2778 
2779                 case 0x1F81:
2780                     target[limit++] = 0x1F01;
2781                     target[limit++] = 0x03B9;
2782                     break;
2783 
2784                 case 0x1F82:
2785                     target[limit++] = 0x1F02;
2786                     target[limit++] = 0x03B9;
2787                     break;
2788 
2789                 case 0x1F83:
2790                     target[limit++] = 0x1F03;
2791                     target[limit++] = 0x03B9;
2792                     break;
2793 
2794                 case 0x1F84:
2795                     target[limit++] = 0x1F04;
2796                     target[limit++] = 0x03B9;
2797                     break;
2798 
2799                 case 0x1F85:
2800                     target[limit++] = 0x1F05;
2801                     target[limit++] = 0x03B9;
2802                     break;
2803 
2804                 case 0x1F86:
2805                     target[limit++] = 0x1F06;
2806                     target[limit++] = 0x03B9;
2807                     break;
2808 
2809                 case 0x1F87:
2810                     target[limit++] = 0x1F07;
2811                     target[limit++] = 0x03B9;
2812                     break;
2813 
2814                 case 0x1F88:
2815                     target[limit++] = 0x1F00;
2816                     target[limit++] = 0x03B9;
2817                     break;
2818 
2819                 case 0x1F89:
2820                     target[limit++] = 0x1F01;
2821                     target[limit++] = 0x03B9;
2822                     break;
2823 
2824                 case 0x1F8A:
2825                     target[limit++] = 0x1F02;
2826                     target[limit++] = 0x03B9;
2827                     break;
2828 
2829                 case 0x1F8B:
2830                     target[limit++] = 0x1F03;
2831                     target[limit++] = 0x03B9;
2832                     break;
2833 
2834                 case 0x1F8C:
2835                     target[limit++] = 0x1F04;
2836                     target[limit++] = 0x03B9;
2837                     break;
2838 
2839                 case 0x1F8D:
2840                     target[limit++] = 0x1F05;
2841                     target[limit++] = 0x03B9;
2842                     break;
2843 
2844                 case 0x1F8E:
2845                     target[limit++] = 0x1F06;
2846                     target[limit++] = 0x03B9;
2847                     break;
2848 
2849                 case 0x1F8F:
2850                     target[limit++] = 0x1F07;
2851                     target[limit++] = 0x03B9;
2852                     break;
2853 
2854                 case 0x1F90:
2855                     target[limit++] = 0x1F20;
2856                     target[limit++] = 0x03B9;
2857                     break;
2858 
2859                 case 0x1F91:
2860                     target[limit++] = 0x1F21;
2861                     target[limit++] = 0x03B9;
2862                     break;
2863 
2864                 case 0x1F92:
2865                     target[limit++] = 0x1F22;
2866                     target[limit++] = 0x03B9;
2867                     break;
2868 
2869                 case 0x1F93:
2870                     target[limit++] = 0x1F23;
2871                     target[limit++] = 0x03B9;
2872                     break;
2873 
2874                 case 0x1F94:
2875                     target[limit++] = 0x1F24;
2876                     target[limit++] = 0x03B9;
2877                     break;
2878 
2879                 case 0x1F95:
2880                     target[limit++] = 0x1F25;
2881                     target[limit++] = 0x03B9;
2882                     break;
2883 
2884                 case 0x1F96:
2885                     target[limit++] = 0x1F26;
2886                     target[limit++] = 0x03B9;
2887                     break;
2888 
2889                 case 0x1F97:
2890                     target[limit++] = 0x1F27;
2891                     target[limit++] = 0x03B9;
2892                     break;
2893 
2894                 case 0x1F98:
2895                     target[limit++] = 0x1F20;
2896                     target[limit++] = 0x03B9;
2897                     break;
2898 
2899                 case 0x1F99:
2900                     target[limit++] = 0x1F21;
2901                     target[limit++] = 0x03B9;
2902                     break;
2903 
2904                 case 0x1F9A:
2905                     target[limit++] = 0x1F22;
2906                     target[limit++] = 0x03B9;
2907                     break;
2908 
2909                 case 0x1F9B:
2910                     target[limit++] = 0x1F23;
2911                     target[limit++] = 0x03B9;
2912                     break;
2913 
2914                 case 0x1F9C:
2915                     target[limit++] = 0x1F24;
2916                     target[limit++] = 0x03B9;
2917                     break;
2918 
2919                 case 0x1F9D:
2920                     target[limit++] = 0x1F25;
2921                     target[limit++] = 0x03B9;
2922                     break;
2923 
2924                 case 0x1F9E:
2925                     target[limit++] = 0x1F26;
2926                     target[limit++] = 0x03B9;
2927                     break;
2928 
2929                 case 0x1F9F:
2930                     target[limit++] = 0x1F27;
2931                     target[limit++] = 0x03B9;
2932                     break;
2933 
2934                 case 0x1FA0:
2935                     target[limit++] = 0x1F60;
2936                     target[limit++] = 0x03B9;
2937                     break;
2938 
2939                 case 0x1FA1:
2940                     target[limit++] = 0x1F61;
2941                     target[limit++] = 0x03B9;
2942                     break;
2943 
2944                 case 0x1FA2:
2945                     target[limit++] = 0x1F62;
2946                     target[limit++] = 0x03B9;
2947                     break;
2948 
2949                 case 0x1FA3:
2950                     target[limit++] = 0x1F63;
2951                     target[limit++] = 0x03B9;
2952                     break;
2953 
2954                 case 0x1FA4:
2955                     target[limit++] = 0x1F64;
2956                     target[limit++] = 0x03B9;
2957                     break;
2958 
2959                 case 0x1FA5:
2960                     target[limit++] = 0x1F65;
2961                     target[limit++] = 0x03B9;
2962                     break;
2963 
2964                 case 0x1FA6:
2965                     target[limit++] = 0x1F66;
2966                     target[limit++] = 0x03B9;
2967                     break;
2968 
2969                 case 0x1FA7:
2970                     target[limit++] = 0x1F67;
2971                     target[limit++] = 0x03B9;
2972                     break;
2973 
2974                 case 0x1FA8:
2975                     target[limit++] = 0x1F60;
2976                     target[limit++] = 0x03B9;
2977                     break;
2978 
2979                 case 0x1FA9:
2980                     target[limit++] = 0x1F61;
2981                     target[limit++] = 0x03B9;
2982                     break;
2983 
2984                 case 0x1FAA:
2985                     target[limit++] = 0x1F62;
2986                     target[limit++] = 0x03B9;
2987                     break;
2988 
2989                 case 0x1FAB:
2990                     target[limit++] = 0x1F63;
2991                     target[limit++] = 0x03B9;
2992                     break;
2993 
2994                 case 0x1FAC:
2995                     target[limit++] = 0x1F64;
2996                     target[limit++] = 0x03B9;
2997                     break;
2998 
2999                 case 0x1FAD:
3000                     target[limit++] = 0x1F65;
3001                     target[limit++] = 0x03B9;
3002                     break;
3003 
3004                 case 0x1FAE:
3005                     target[limit++] = 0x1F66;
3006                     target[limit++] = 0x03B9;
3007                     break;
3008 
3009                 case 0x1FAF:
3010                     target[limit++] = 0x1F67;
3011                     target[limit++] = 0x03B9;
3012                     break;
3013 
3014                 case 0x1FB2:
3015                     target[limit++] = 0x1F70;
3016                     target[limit++] = 0x03B9;
3017                     break;
3018 
3019                 case 0x1FB3:
3020                     target[limit++] = 0x03B1;
3021                     target[limit++] = 0x03B9;
3022                     break;
3023 
3024                 case 0x1FB4:
3025                     target[limit++] = 0x03AC;
3026                     target[limit++] = 0x03B9;
3027                     break;
3028 
3029                 case 0x1FB6:
3030                     target[limit++] = 0x03B1;
3031                     target[limit++] = 0x0342;
3032                     break;
3033 
3034                 case 0x1FB7:
3035                     target[limit++] = 0x03B1;
3036                     target[limit++] = 0x0342;
3037                     target[limit++] = 0x03B9;
3038                     break;
3039 
3040                 case 0x1FB8:
3041                     target[limit++] = 0x1FB0;
3042                     break;
3043 
3044                 case 0x1FB9:
3045                     target[limit++] = 0x1FB1;
3046                     break;
3047 
3048                 case 0x1FBA:
3049                     target[limit++] = 0x1F70;
3050                     break;
3051 
3052                 case 0x1FBB:
3053                     target[limit++] = 0x1F71;
3054                     break;
3055 
3056                 case 0x1FBC:
3057                     target[limit++] = 0x03B1;
3058                     target[limit++] = 0x03B9;
3059                     break;
3060 
3061                 case 0x1FBE:
3062                     target[limit++] = 0x03B9;
3063                     break;
3064 
3065                 case 0x1FC2:
3066                     target[limit++] = 0x1F74;
3067                     target[limit++] = 0x03B9;
3068                     break;
3069 
3070                 case 0x1FC3:
3071                     target[limit++] = 0x03B7;
3072                     target[limit++] = 0x03B9;
3073                     break;
3074 
3075                 case 0x1FC4:
3076                     target[limit++] = 0x03AE;
3077                     target[limit++] = 0x03B9;
3078                     break;
3079 
3080                 case 0x1FC6:
3081                     target[limit++] = 0x03B7;
3082                     target[limit++] = 0x0342;
3083                     break;
3084 
3085                 case 0x1FC7:
3086                     target[limit++] = 0x03B7;
3087                     target[limit++] = 0x0342;
3088                     target[limit++] = 0x03B9;
3089                     break;
3090 
3091                 case 0x1FC8:
3092                     target[limit++] = 0x1F72;
3093                     break;
3094 
3095                 case 0x1FC9:
3096                     target[limit++] = 0x1F73;
3097                     break;
3098 
3099                 case 0x1FCA:
3100                     target[limit++] = 0x1F74;
3101                     break;
3102 
3103                 case 0x1FCB:
3104                     target[limit++] = 0x1F75;
3105                     break;
3106 
3107                 case 0x1FCC:
3108                     target[limit++] = 0x03B7;
3109                     target[limit++] = 0x03B9;
3110                     break;
3111 
3112                 case 0x1FD2:
3113                     target[limit++] = 0x03B9;
3114                     target[limit++] = 0x0308;
3115                     target[limit++] = 0x0300;
3116                     break;
3117 
3118                 case 0x1FD3:
3119                     target[limit++] = 0x03B9;
3120                     target[limit++] = 0x0308;
3121                     target[limit++] = 0x0301;
3122                     break;
3123 
3124                 case 0x1FD6:
3125                     target[limit++] = 0x03B9;
3126                     target[limit++] = 0x0342;
3127                     break;
3128 
3129                 case 0x1FD7:
3130                     target[limit++] = 0x03B9;
3131                     target[limit++] = 0x0308;
3132                     target[limit++] = 0x0342;
3133                     break;
3134 
3135                 case 0x1FD8:
3136                     target[limit++] = 0x1FD0;
3137                     break;
3138 
3139                 case 0x1FD9:
3140                     target[limit++] = 0x1FD1;
3141                     break;
3142 
3143                 case 0x1FDA:
3144                     target[limit++] = 0x1F76;
3145                     break;
3146 
3147                 case 0x1FDB:
3148                     target[limit++] = 0x1F77;
3149                     break;
3150 
3151                 case 0x1FE2:
3152                     target[limit++] = 0x03C5;
3153                     target[limit++] = 0x0308;
3154                     target[limit++] = 0x0300;
3155                     break;
3156 
3157                 case 0x1FE3:
3158                     target[limit++] = 0x03C5;
3159                     target[limit++] = 0x0308;
3160                     target[limit++] = 0x0301;
3161                     break;
3162 
3163                 case 0x1FE4:
3164                     target[limit++] = 0x03C1;
3165                     target[limit++] = 0x0313;
3166                     break;
3167 
3168                 case 0x1FE6:
3169                     target[limit++] = 0x03C5;
3170                     target[limit++] = 0x0342;
3171                     break;
3172 
3173                 case 0x1FE7:
3174                     target[limit++] = 0x03C5;
3175                     target[limit++] = 0x0308;
3176                     target[limit++] = 0x0342;
3177                     break;
3178 
3179                 case 0x1FE8:
3180                     target[limit++] = 0x1FE0;
3181                     break;
3182 
3183                 case 0x1FE9:
3184                     target[limit++] = 0x1FE1;
3185                     break;
3186 
3187                 case 0x1FEA:
3188                     target[limit++] = 0x1F7A;
3189                     break;
3190 
3191                 case 0x1FEB:
3192                     target[limit++] = 0x1F7B;
3193                     break;
3194 
3195                 case 0x1FEC:
3196                     target[limit++] = 0x1FE5;
3197                     break;
3198 
3199                 case 0x1FF2:
3200                     target[limit++] = 0x1F7C;
3201                     target[limit++] = 0x03B9;
3202                     break;
3203 
3204                 case 0x1FF3:
3205                     target[limit++] = 0x03C9;
3206                     target[limit++] = 0x03B9;
3207                     break;
3208 
3209                 case 0x1FF4:
3210                     target[limit++] = 0x03CE;
3211                     target[limit++] = 0x03B9;
3212                     break;
3213 
3214                 case 0x1FF6:
3215                     target[limit++] = 0x03C9;
3216                     target[limit++] = 0x0342;
3217                     break;
3218 
3219                 case 0x1FF7:
3220                     target[limit++] = 0x03C9;
3221                     target[limit++] = 0x0342;
3222                     target[limit++] = 0x03B9;
3223                     break;
3224 
3225                 case 0x1FF8:
3226                     target[limit++] = 0x1F78;
3227                     break;
3228 
3229                 case 0x1FF9:
3230                     target[limit++] = 0x1F79;
3231                     break;
3232 
3233                 case 0x1FFA:
3234                     target[limit++] = 0x1F7C;
3235                     break;
3236 
3237                 case 0x1FFB:
3238                     target[limit++] = 0x1F7D;
3239                     break;
3240 
3241                 case 0x1FFC:
3242                     target[limit++] = 0x03C9;
3243                     target[limit++] = 0x03B9;
3244                     break;
3245 
3246                 case 0x2000:
3247                 case 0x2001:
3248                 case 0x2002:
3249                 case 0x2003:
3250                 case 0x2004:
3251                 case 0x2005:
3252                 case 0x2006:
3253                 case 0x2007:
3254                 case 0x2008:
3255                 case 0x2009:
3256                 case 0x200A:
3257                     target[limit++] = 0x0020;
3258                     break;
3259 
3260                 case 0x200B:
3261                 case 0x200C:
3262                 case 0x200D:
3263                 case 0x200E:
3264                 case 0x200F:
3265                     break;
3266 
3267                 case 0x2028:
3268                 case 0x2029:
3269                     target[limit++] = 0x0020;
3270                     break;
3271 
3272                 case 0x202A:
3273                 case 0x202B:
3274                 case 0x202C:
3275                 case 0x202D:
3276                 case 0x202E:
3277                     break;
3278 
3279                 case 0x202F:
3280                     target[limit++] = 0x0020;
3281                     break;
3282 
3283                 case 0x205F:
3284                     target[limit++] = 0x0020;
3285                     break;
3286 
3287                 case 0x2060:
3288                 case 0x2061:
3289                 case 0x2062:
3290                 case 0x2063:
3291                     break;
3292 
3293                 case 0x206A:
3294                 case 0x206B:
3295                 case 0x206C:
3296                 case 0x206D:
3297                 case 0x206E:
3298                 case 0x206F:
3299                     break;
3300 
3301                 case 0x20A8:
3302                     target[limit++] = 0x0072;
3303                     target[limit++] = 0x0073;
3304                     break;
3305 
3306                 case 0x2102:
3307                     target[limit++] = 0x0063;
3308                     break;
3309 
3310                 case 0x2103:
3311                     target[limit++] = 0x00B0;
3312                     target[limit++] = 0x0063;
3313                     break;
3314 
3315                 case 0x2107:
3316                     target[limit++] = 0x025B;
3317                     break;
3318 
3319                 case 0x2109:
3320                     target[limit++] = 0x00B0;
3321                     target[limit++] = 0x0066;
3322                     break;
3323 
3324                 case 0x210B:
3325                     target[limit++] = 0x0068;
3326                     break;
3327 
3328                 case 0x210C:
3329                     target[limit++] = 0x0068;
3330                     break;
3331 
3332                 case 0x210D:
3333                     target[limit++] = 0x0068;
3334                     break;
3335 
3336                 case 0x2110:
3337                     target[limit++] = 0x0069;
3338                     break;
3339 
3340                 case 0x2111:
3341                     target[limit++] = 0x0069;
3342                     break;
3343 
3344                 case 0x2112:
3345                     target[limit++] = 0x006C;
3346                     break;
3347 
3348                 case 0x2115:
3349                     target[limit++] = 0x006E;
3350                     break;
3351 
3352                 case 0x2116:
3353                     target[limit++] = 0x006E;
3354                     target[limit++] = 0x006F;
3355                     break;
3356 
3357                 case 0x2119:
3358                     target[limit++] = 0x0070;
3359                     break;
3360 
3361                 case 0x211A:
3362                     target[limit++] = 0x0071;
3363                     break;
3364 
3365                 case 0x211B:
3366                     target[limit++] = 0x0072;
3367                     break;
3368 
3369                 case 0x211C:
3370                     target[limit++] = 0x0072;
3371                     break;
3372 
3373                 case 0x211D:
3374                     target[limit++] = 0x0072;
3375                     break;
3376 
3377                 case 0x2120:
3378                     target[limit++] = 0x0073;
3379                     target[limit++] = 0x006D;
3380                     break;
3381 
3382                 case 0x2121:
3383                     target[limit++] = 0x0074;
3384                     target[limit++] = 0x0065;
3385                     target[limit++] = 0x006C;
3386                     break;
3387 
3388                 case 0x2122:
3389                     target[limit++] = 0x0074;
3390                     target[limit++] = 0x006D;
3391                     break;
3392 
3393                 case 0x2124:
3394                     target[limit++] = 0x007A;
3395                     break;
3396 
3397                 case 0x2126:
3398                     target[limit++] = 0x03C9;
3399                     break;
3400 
3401                 case 0x2128:
3402                     target[limit++] = 0x007A;
3403                     break;
3404 
3405                 case 0x212A:
3406                     target[limit++] = 0x006B;
3407                     break;
3408 
3409                 case 0x212B:
3410                     target[limit++] = 0x00E5;
3411                     break;
3412 
3413                 case 0x212C:
3414                     target[limit++] = 0x0062;
3415                     break;
3416 
3417                 case 0x212D:
3418                     target[limit++] = 0x0063;
3419                     break;
3420 
3421                 case 0x2130:
3422                     target[limit++] = 0x0065;
3423                     break;
3424 
3425                 case 0x2131:
3426                     target[limit++] = 0x0066;
3427                     break;
3428 
3429                 case 0x2133:
3430                     target[limit++] = 0x006D;
3431                     break;
3432 
3433                 case 0x213E:
3434                     target[limit++] = 0x03B3;
3435                     break;
3436 
3437                 case 0x213F:
3438                     target[limit++] = 0x03C0;
3439                     break;
3440 
3441                 case 0x2145:
3442                     target[limit++] = 0x0064;
3443                     break;
3444 
3445                 case 0x2160:
3446                     target[limit++] = 0x2170;
3447                     break;
3448 
3449                 case 0x2161:
3450                     target[limit++] = 0x2171;
3451                     break;
3452 
3453                 case 0x2162:
3454                     target[limit++] = 0x2172;
3455                     break;
3456 
3457                 case 0x2163:
3458                     target[limit++] = 0x2173;
3459                     break;
3460 
3461                 case 0x2164:
3462                     target[limit++] = 0x2174;
3463                     break;
3464 
3465                 case 0x2165:
3466                     target[limit++] = 0x2175;
3467                     break;
3468 
3469                 case 0x2166:
3470                     target[limit++] = 0x2176;
3471                     break;
3472 
3473                 case 0x2167:
3474                     target[limit++] = 0x2177;
3475                     break;
3476 
3477                 case 0x2168:
3478                     target[limit++] = 0x2178;
3479                     break;
3480 
3481                 case 0x2169:
3482                     target[limit++] = 0x2179;
3483                     break;
3484 
3485                 case 0x216A:
3486                     target[limit++] = 0x217A;
3487                     break;
3488 
3489                 case 0x216B:
3490                     target[limit++] = 0x217B;
3491                     break;
3492 
3493                 case 0x216C:
3494                     target[limit++] = 0x217C;
3495                     break;
3496 
3497                 case 0x216D:
3498                     target[limit++] = 0x217D;
3499                     break;
3500 
3501                 case 0x216E:
3502                     target[limit++] = 0x217E;
3503                     break;
3504 
3505                 case 0x216F:
3506                     target[limit++] = 0x217F;
3507                     break;
3508 
3509                 case 0x24B6:
3510                     target[limit++] = 0x24D0;
3511                     break;
3512 
3513                 case 0x24B7:
3514                     target[limit++] = 0x24D1;
3515                     break;
3516 
3517                 case 0x24B8:
3518                     target[limit++] = 0x24D2;
3519                     break;
3520 
3521                 case 0x24B9:
3522                     target[limit++] = 0x24D3;
3523                     break;
3524 
3525                 case 0x24BA:
3526                     target[limit++] = 0x24D4;
3527                     break;
3528 
3529                 case 0x24BB:
3530                     target[limit++] = 0x24D5;
3531                     break;
3532 
3533                 case 0x24BC:
3534                     target[limit++] = 0x24D6;
3535                     break;
3536 
3537                 case 0x24BD:
3538                     target[limit++] = 0x24D7;
3539                     break;
3540 
3541                 case 0x24BE:
3542                     target[limit++] = 0x24D8;
3543                     break;
3544 
3545                 case 0x24BF:
3546                     target[limit++] = 0x24D9;
3547                     break;
3548 
3549                 case 0x24C0:
3550                     target[limit++] = 0x24DA;
3551                     break;
3552 
3553                 case 0x24C1:
3554                     target[limit++] = 0x24DB;
3555                     break;
3556 
3557                 case 0x24C2:
3558                     target[limit++] = 0x24DC;
3559                     break;
3560 
3561                 case 0x24C3:
3562                     target[limit++] = 0x24DD;
3563                     break;
3564 
3565                 case 0x24C4:
3566                     target[limit++] = 0x24DE;
3567                     break;
3568 
3569                 case 0x24C5:
3570                     target[limit++] = 0x24DF;
3571                     break;
3572 
3573                 case 0x24C6:
3574                     target[limit++] = 0x24E0;
3575                     break;
3576 
3577                 case 0x24C7:
3578                     target[limit++] = 0x24E1;
3579                     break;
3580 
3581                 case 0x24C8:
3582                     target[limit++] = 0x24E2;
3583                     break;
3584 
3585                 case 0x24C9:
3586                     target[limit++] = 0x24E3;
3587                     break;
3588 
3589                 case 0x24CA:
3590                     target[limit++] = 0x24E4;
3591                     break;
3592 
3593                 case 0x24CB:
3594                     target[limit++] = 0x24E5;
3595                     break;
3596 
3597                 case 0x24CC:
3598                     target[limit++] = 0x24E6;
3599                     break;
3600 
3601                 case 0x24CD:
3602                     target[limit++] = 0x24E7;
3603                     break;
3604 
3605                 case 0x24CE:
3606                     target[limit++] = 0x24E8;
3607                     break;
3608 
3609                 case 0x24CF:
3610                     target[limit++] = 0x24E9;
3611                     break;
3612 
3613                 case 0x3000:
3614                     target[limit++] = 0x0020;
3615                     break;
3616 
3617                 case 0x3371:
3618                     target[limit++] = 0x0068;
3619                     target[limit++] = 0x0070;
3620                     target[limit++] = 0x0061;
3621                     break;
3622 
3623                 case 0x3373:
3624                     target[limit++] = 0x0061;
3625                     target[limit++] = 0x0075;
3626                     break;
3627 
3628                 case 0x3375:
3629                     target[limit++] = 0x006F;
3630                     target[limit++] = 0x0076;
3631                     break;
3632 
3633                 case 0x3380:
3634                     target[limit++] = 0x0070;
3635                     target[limit++] = 0x0061;
3636                     break;
3637 
3638                 case 0x3381:
3639                     target[limit++] = 0x006E;
3640                     target[limit++] = 0x0061;
3641                     break;
3642 
3643                 case 0x3382:
3644                     target[limit++] = 0x03BC;
3645                     target[limit++] = 0x0061;
3646                     break;
3647 
3648                 case 0x3383:
3649                     target[limit++] = 0x006D;
3650                     target[limit++] = 0x0061;
3651                     break;
3652 
3653                 case 0x3384:
3654                     target[limit++] = 0x006B;
3655                     target[limit++] = 0x0061;
3656                     break;
3657 
3658                 case 0x3385:
3659                     target[limit++] = 0x006B;
3660                     target[limit++] = 0x0062;
3661                     break;
3662 
3663                 case 0x3386:
3664                     target[limit++] = 0x006D;
3665                     target[limit++] = 0x0062;
3666                     break;
3667 
3668                 case 0x3387:
3669                     target[limit++] = 0x0067;
3670                     target[limit++] = 0x0062;
3671                     break;
3672 
3673                 case 0x338A:
3674                     target[limit++] = 0x0070;
3675                     target[limit++] = 0x0066;
3676                     break;
3677 
3678                 case 0x338B:
3679                     target[limit++] = 0x006E;
3680                     target[limit++] = 0x0066;
3681                     break;
3682 
3683                 case 0x338C:
3684                     target[limit++] = 0x03BC;
3685                     target[limit++] = 0x0066;
3686                     break;
3687 
3688                 case 0x3390:
3689                     target[limit++] = 0x0068;
3690                     target[limit++] = 0x007A;
3691                     break;
3692 
3693                 case 0x3391:
3694                     target[limit++] = 0x006B;
3695                     target[limit++] = 0x0068;
3696                     target[limit++] = 0x007A;
3697                     break;
3698 
3699                 case 0x3392:
3700                     target[limit++] = 0x006D;
3701                     target[limit++] = 0x0068;
3702                     target[limit++] = 0x007A;
3703                     break;
3704 
3705                 case 0x3393:
3706                     target[limit++] = 0x0067;
3707                     target[limit++] = 0x0068;
3708                     target[limit++] = 0x007A;
3709                     break;
3710 
3711                 case 0x3394:
3712                     target[limit++] = 0x0074;
3713                     target[limit++] = 0x0068;
3714                     target[limit++] = 0x007A;
3715                     break;
3716 
3717                 case 0x33A9:
3718                     target[limit++] = 0x0070;
3719                     target[limit++] = 0x0061;
3720                     break;
3721 
3722                 case 0x33AA:
3723                     target[limit++] = 0x006B;
3724                     target[limit++] = 0x0070;
3725                     target[limit++] = 0x0061;
3726                     break;
3727 
3728                 case 0x33AB:
3729                     target[limit++] = 0x006D;
3730                     target[limit++] = 0x0070;
3731                     target[limit++] = 0x0061;
3732                     break;
3733 
3734                 case 0x33AC:
3735                     target[limit++] = 0x0067;
3736                     target[limit++] = 0x0070;
3737                     target[limit++] = 0x0061;
3738                     break;
3739 
3740                 case 0x33B4:
3741                     target[limit++] = 0x0070;
3742                     target[limit++] = 0x0076;
3743                     break;
3744 
3745                 case 0x33B5:
3746                     target[limit++] = 0x006E;
3747                     target[limit++] = 0x0076;
3748                     break;
3749 
3750                 case 0x33B6:
3751                     target[limit++] = 0x03BC;
3752                     target[limit++] = 0x0076;
3753                     break;
3754 
3755                 case 0x33B7:
3756                     target[limit++] = 0x006D;
3757                     target[limit++] = 0x0076;
3758                     break;
3759 
3760                 case 0x33B8:
3761                     target[limit++] = 0x006B;
3762                     target[limit++] = 0x0076;
3763                     break;
3764 
3765                 case 0x33B9:
3766                     target[limit++] = 0x006D;
3767                     target[limit++] = 0x0076;
3768                     break;
3769 
3770                 case 0x33BA:
3771                     target[limit++] = 0x0070;
3772                     target[limit++] = 0x0077;
3773                     break;
3774 
3775                 case 0x33BB:
3776                     target[limit++] = 0x006E;
3777                     target[limit++] = 0x0077;
3778                     break;
3779 
3780                 case 0x33BC:
3781                     target[limit++] = 0x03BC;
3782                     target[limit++] = 0x0077;
3783                     break;
3784 
3785                 case 0x33BD:
3786                     target[limit++] = 0x006D;
3787                     target[limit++] = 0x0077;
3788                     break;
3789 
3790                 case 0x33BE:
3791                     target[limit++] = 0x006B;
3792                     target[limit++] = 0x0077;
3793                     break;
3794 
3795                 case 0x33BF:
3796                     target[limit++] = 0x006D;
3797                     target[limit++] = 0x0077;
3798                     break;
3799 
3800                 case 0x33C0:
3801                     target[limit++] = 0x006B;
3802                     target[limit++] = 0x03C9;
3803                     break;
3804 
3805                 case 0x33C1:
3806                     target[limit++] = 0x006D;
3807                     target[limit++] = 0x03C9;
3808                     break;
3809 
3810                 case 0x33C3:
3811                     target[limit++] = 0x0062;
3812                     target[limit++] = 0x0071;
3813                     break;
3814 
3815                 case 0x33C6:
3816                     target[limit++] = 0x0063;
3817                     target[limit++] = 0x2215;
3818                     target[limit++] = 0x006B;
3819                     target[limit++] = 0x0067;
3820                     break;
3821 
3822                 case 0x33C7:
3823                     target[limit++] = 0x0063;
3824                     target[limit++] = 0x006F;
3825                     target[limit++] = 0x002E;
3826                     break;
3827 
3828                 case 0x33C8:
3829                     target[limit++] = 0x0064;
3830                     target[limit++] = 0x0062;
3831                     break;
3832 
3833                 case 0x33C9:
3834                     target[limit++] = 0x0067;
3835                     target[limit++] = 0x0079;
3836                     break;
3837 
3838                 case 0x33CB:
3839                     target[limit++] = 0x0068;
3840                     target[limit++] = 0x0070;
3841                     break;
3842 
3843                 case 0x33CD:
3844                     target[limit++] = 0x006B;
3845                     target[limit++] = 0x006B;
3846                     break;
3847 
3848                 case 0x33CE:
3849                     target[limit++] = 0x006B;
3850                     target[limit++] = 0x006D;
3851                     break;
3852 
3853                 case 0x33D7:
3854                     target[limit++] = 0x0070;
3855                     target[limit++] = 0x0068;
3856                     break;
3857 
3858                 case 0x33D9:
3859                     target[limit++] = 0x0070;
3860                     target[limit++] = 0x0070;
3861                     target[limit++] = 0x006D;
3862                     break;
3863 
3864                 case 0x33DA:
3865                     target[limit++] = 0x0070;
3866                     target[limit++] = 0x0072;
3867                     break;
3868 
3869                 case 0x33DC:
3870                     target[limit++] = 0x0073;
3871                     target[limit++] = 0x0076;
3872                     break;
3873 
3874                 case 0x33DD:
3875                     target[limit++] = 0x0077;
3876                     target[limit++] = 0x0062;
3877                     break;
3878 
3879                 case 0xFB00:
3880                     target[limit++] = 0x0066;
3881                     target[limit++] = 0x0066;
3882                     break;
3883 
3884                 case 0xFB01:
3885                     target[limit++] = 0x0066;
3886                     target[limit++] = 0x0069;
3887                     break;
3888 
3889                 case 0xFB02:
3890                     target[limit++] = 0x0066;
3891                     target[limit++] = 0x006C;
3892                     break;
3893 
3894                 case 0xFB03:
3895                     target[limit++] = 0x0066;
3896                     target[limit++] = 0x0066;
3897                     target[limit++] = 0x0069;
3898                     break;
3899 
3900                 case 0xFB04:
3901                     target[limit++] = 0x0066;
3902                     target[limit++] = 0x0066;
3903                     target[limit++] = 0x006C;
3904                     break;
3905 
3906                 case 0xFB05:
3907                     target[limit++] = 0x0073;
3908                     target[limit++] = 0x0074;
3909                     break;
3910 
3911                 case 0xFB06:
3912                     target[limit++] = 0x0073;
3913                     target[limit++] = 0x0074;
3914                     break;
3915 
3916                 case 0xFB13:
3917                     target[limit++] = 0x0574;
3918                     target[limit++] = 0x0576;
3919                     break;
3920 
3921                 case 0xFB14:
3922                     target[limit++] = 0x0574;
3923                     target[limit++] = 0x0565;
3924                     break;
3925 
3926                 case 0xFB15:
3927                     target[limit++] = 0x0574;
3928                     target[limit++] = 0x056B;
3929                     break;
3930 
3931                 case 0xFB16:
3932                     target[limit++] = 0x057E;
3933                     target[limit++] = 0x0576;
3934                     break;
3935 
3936                 case 0xFB17:
3937                     target[limit++] = 0x0574;
3938                     target[limit++] = 0x056D;
3939                     break;
3940 
3941                 case 0xFE00:
3942                 case 0xFE01:
3943                 case 0xFE02:
3944                 case 0xFE03:
3945                 case 0xFE04:
3946                 case 0xFE05:
3947                 case 0xFE06:
3948                 case 0xFE07:
3949                 case 0xFE08:
3950                 case 0xFE09:
3951                 case 0xFE0A:
3952                 case 0xFE0B:
3953                 case 0xFE0C:
3954                 case 0xFE0D:
3955                 case 0xFE0E:
3956                 case 0xFE0F:
3957                     break;
3958 
3959                 case 0xFEFF:
3960                     break;
3961 
3962                 case 0xFF21:
3963                     target[limit++] = 0xFF41;
3964                     break;
3965 
3966                 case 0xFF22:
3967                     target[limit++] = 0xFF42;
3968                     break;
3969 
3970                 case 0xFF23:
3971                     target[limit++] = 0xFF43;
3972                     break;
3973 
3974                 case 0xFF24:
3975                     target[limit++] = 0xFF44;
3976                     break;
3977 
3978                 case 0xFF25:
3979                     target[limit++] = 0xFF45;
3980                     break;
3981 
3982                 case 0xFF26:
3983                     target[limit++] = 0xFF46;
3984                     break;
3985 
3986                 case 0xFF27:
3987                     target[limit++] = 0xFF47;
3988                     break;
3989 
3990                 case 0xFF28:
3991                     target[limit++] = 0xFF48;
3992                     break;
3993 
3994                 case 0xFF29:
3995                     target[limit++] = 0xFF49;
3996                     break;
3997 
3998                 case 0xFF2A:
3999                     target[limit++] = 0xFF4A;
4000                     break;
4001 
4002                 case 0xFF2B:
4003                     target[limit++] = 0xFF4B;
4004                     break;
4005 
4006                 case 0xFF2C:
4007                     target[limit++] = 0xFF4C;
4008                     break;
4009 
4010                 case 0xFF2D:
4011                     target[limit++] = 0xFF4D;
4012                     break;
4013 
4014                 case 0xFF2E:
4015                     target[limit++] = 0xFF4E;
4016                     break;
4017 
4018                 case 0xFF2F:
4019                     target[limit++] = 0xFF4F;
4020                     break;
4021 
4022                 case 0xFF30:
4023                     target[limit++] = 0xFF50;
4024                     break;
4025 
4026                 case 0xFF31:
4027                     target[limit++] = 0xFF51;
4028                     break;
4029 
4030                 case 0xFF32:
4031                     target[limit++] = 0xFF52;
4032                     break;
4033 
4034                 case 0xFF33:
4035                     target[limit++] = 0xFF53;
4036                     break;
4037 
4038                 case 0xFF34:
4039                     target[limit++] = 0xFF54;
4040                     break;
4041 
4042                 case 0xFF35:
4043                     target[limit++] = 0xFF55;
4044                     break;
4045 
4046                 case 0xFF36:
4047                     target[limit++] = 0xFF56;
4048                     break;
4049 
4050                 case 0xFF37:
4051                     target[limit++] = 0xFF57;
4052                     break;
4053 
4054                 case 0xFF38:
4055                     target[limit++] = 0xFF58;
4056                     break;
4057 
4058                 case 0xFF39:
4059                     target[limit++] = 0xFF59;
4060                     break;
4061 
4062                 case 0xFF3A:
4063                     target[limit++] = 0xFF5A;
4064                     break;
4065 
4066                 case 0xFFF9:
4067                 case 0xFFFA:
4068                 case 0xFFFB:
4069                 case 0xFFFC:
4070                     break;
4071 
4072                 default:
4073                     // First, eliminate surrogates, and replace them by FFFD char
4074                     if ( ( c >= 0xD800 ) && ( c <= 0xDFFF ) )
4075                     {
4076                         target[limit++] = ( char ) 0xFFFD;
4077                         break;
4078                     }
4079 
4080                     target[limit++] = c;
4081                     break;
4082             }
4083         }
4084 
4085         return limit;
4086     }
4087 
4088 
4089     /**
4090      * 
4091      * Prohibit characters described in RFC 4518 :
4092      *  - Table A.1 of RFC 3454
4093      *  - Table C.3 of RFC 3454
4094      *  - Table C.4 of RFC 3454
4095      *  - Table C.5 of RFC 3454
4096      *  - Table C.8 of RFC 3454
4097      *  - character U-FFFD
4098      *
4099      * @param c The char to analyze
4100      * @throws InvalidCharacterException If any character is prohibited
4101      */
4102     private static void checkProhibited( char c ) throws InvalidCharacterException
4103     {
4104         // Shortcut chars above 0x0221
4105         if ( c < 0x221 )
4106         {
4107             return;
4108         }
4109 
4110         // RFC 3454, Table A.1
4111         switch ( c )
4112         {
4113             case 0x0221:
4114             case 0x038B:
4115             case 0x038D:
4116             case 0x03A2:
4117             case 0x03CF:
4118             case 0x0487:
4119             case 0x04CF:
4120             case 0x0560:
4121             case 0x0588:
4122             case 0x05A2:
4123             case 0x05BA:
4124             case 0x0620:
4125             case 0x06FF:
4126             case 0x070E:
4127             case 0x0904:
4128             case 0x0984:
4129             case 0x09A9:
4130             case 0x09B1:
4131             case 0x09BD:
4132             case 0x09DE:
4133             case 0x0A29:
4134             case 0x0A31:
4135             case 0x0A34:
4136             case 0x0A37:
4137             case 0x0A3D:
4138             case 0x0A5D:
4139             case 0x0A84:
4140             case 0x0A8C:
4141             case 0x0A8E:
4142             case 0x0A92:
4143             case 0x0AA9:
4144             case 0x0AB1:
4145             case 0x0AB4:
4146             case 0x0AC6:
4147             case 0x0ACA:
4148             case 0x0B04:
4149             case 0x0B29:
4150             case 0x0B31:
4151             case 0x0B5E:
4152             case 0x0B84:
4153             case 0x0B91:
4154             case 0x0B9B:
4155             case 0x0B9D:
4156             case 0x0BB6:
4157             case 0x0BC9:
4158             case 0x0C04:
4159             case 0x0C0D:
4160             case 0x0C11:
4161             case 0x0C29:
4162             case 0x0C34:
4163             case 0x0C45:
4164             case 0x0C49:
4165             case 0x0C84:
4166             case 0x0C8D:
4167             case 0x0C91:
4168             case 0x0CA9:
4169             case 0x0CB4:
4170             case 0x0CC5:
4171             case 0x0CC9:
4172             case 0x0CDF:
4173             case 0x0D04:
4174             case 0x0D0D:
4175             case 0x0D11:
4176             case 0x0D29:
4177             case 0x0D49:
4178             case 0x0D84:
4179             case 0x0DB2:
4180             case 0x0DBC:
4181             case 0x0DD5:
4182             case 0x0DD7:
4183             case 0x0E83:
4184             case 0x0E89:
4185             case 0x0E98:
4186             case 0x0EA0:
4187             case 0x0EA4:
4188             case 0x0EA6:
4189             case 0x0EAC:
4190             case 0x0EBA:
4191             case 0x0EC5:
4192             case 0x0EC7:
4193             case 0x0F48:
4194             case 0x0F98:
4195             case 0x0FBD:
4196             case 0x1022:
4197             case 0x1028:
4198             case 0x102B:
4199             case 0x1207:
4200             case 0x1247:
4201             case 0x1249:
4202             case 0x1257:
4203             case 0x1259:
4204             case 0x1287:
4205             case 0x1289:
4206             case 0x12AF:
4207             case 0x12B1:
4208             case 0x12BF:
4209             case 0x12C1:
4210             case 0x12CF:
4211             case 0x12D7:
4212             case 0x12EF:
4213             case 0x130F:
4214             case 0x1311:
4215             case 0x131F:
4216             case 0x1347:
4217             case 0x170D:
4218             case 0x176D:
4219             case 0x1771:
4220             case 0x180F:
4221             case 0x1F58:
4222             case 0x1F5A:
4223             case 0x1F5C:
4224             case 0x1F5E:
4225             case 0x1FB5:
4226             case 0x1FC5:
4227             case 0x1FDC:
4228             case 0x1FF5:
4229             case 0x1FFF:
4230             case 0x24FF:
4231             case 0x2618:
4232             case 0x2705:
4233             case 0x2728:
4234             case 0x274C:
4235             case 0x274E:
4236             case 0x2757:
4237             case 0x27B0:
4238             case 0x2E9A:
4239             case 0x3040:
4240             case 0x318F:
4241             case 0x32FF:
4242             case 0x33FF:
4243             case 0xFB37:
4244             case 0xFB3D:
4245             case 0xFB3F:
4246             case 0xFB42:
4247             case 0xFB45:
4248             case 0xFE53:
4249             case 0xFE67:
4250             case 0xFE75:
4251             case 0xFF00:
4252             case 0xFFE7:
4253                 throw new InvalidCharacterException( c );
4254             default:
4255                 break;
4256         }
4257 
4258         // RFC 3454, Table A.1, intervals
4259         if ( ( c >= 0x0234 ) && ( c <= 0x024F ) )
4260         {
4261             throw new InvalidCharacterException( c );
4262         }
4263 
4264         if ( ( c >= 0x02AE ) && ( c <= 0x02AF ) )
4265         {
4266             throw new InvalidCharacterException( c );
4267         }
4268 
4269         if ( ( c >= 0x02EF ) && ( c <= 0x02FF ) )
4270         {
4271             throw new InvalidCharacterException( c );
4272         }
4273 
4274         if ( ( c >= 0x0350 ) && ( c <= 0x035F ) )
4275         {
4276             throw new InvalidCharacterException( c );
4277         }
4278 
4279         if ( ( c >= 0x0370 ) && ( c <= 0x0373 ) )
4280         {
4281             throw new InvalidCharacterException( c );
4282         }
4283 
4284         if ( ( c >= 0x0376 ) && ( c <= 0x0379 ) )
4285         {
4286             throw new InvalidCharacterException( c );
4287         }
4288 
4289         if ( ( c >= 0x037B ) && ( c <= 0x037D ) )
4290         {
4291             throw new InvalidCharacterException( c );
4292         }
4293 
4294         if ( ( c >= 0x037F ) && ( c <= 0x0383 ) )
4295         {
4296             throw new InvalidCharacterException( c );
4297         }
4298 
4299         if ( ( c >= 0x03F7 ) && ( c <= 0x03FF ) )
4300         {
4301             throw new InvalidCharacterException( c );
4302         }
4303 
4304         if ( ( c >= 0x04F6 ) && ( c <= 0x04F7 ) )
4305         {
4306             throw new InvalidCharacterException( c );
4307         }
4308 
4309         if ( ( c >= 0x04FA ) && ( c <= 0x04FF ) )
4310         {
4311             throw new InvalidCharacterException( c );
4312         }
4313 
4314         if ( ( c >= 0x0510 ) && ( c <= 0x0530 ) )
4315         {
4316             throw new InvalidCharacterException( c );
4317         }
4318 
4319         if ( ( c >= 0x0557 ) && ( c <= 0x0558 ) )
4320         {
4321             throw new InvalidCharacterException( c );
4322         }
4323 
4324         if ( ( c >= 0x058B ) && ( c <= 0x0590 ) )
4325         {
4326             throw new InvalidCharacterException( c );
4327         }
4328 
4329         if ( ( c >= 0x05C5 ) && ( c <= 0x05CF ) )
4330         {
4331             throw new InvalidCharacterException( c );
4332         }
4333 
4334         if ( ( c >= 0x05EB ) && ( c <= 0x05EF ) )
4335         {
4336             throw new InvalidCharacterException( c );
4337         }
4338 
4339         if ( ( c >= 0x05F5 ) && ( c <= 0x060B ) )
4340         {
4341             throw new InvalidCharacterException( c );
4342         }
4343 
4344         if ( ( c >= 0x060D ) && ( c <= 0x061A ) )
4345         {
4346             throw new InvalidCharacterException( c );
4347         }
4348 
4349         if ( ( c >= 0x061C ) && ( c <= 0x061E ) )
4350         {
4351             throw new InvalidCharacterException( c );
4352         }
4353 
4354         if ( ( c >= 0x063B ) && ( c <= 0x063F ) )
4355         {
4356             throw new InvalidCharacterException( c );
4357         }
4358 
4359         if ( ( c >= 0x0656 ) && ( c <= 0x065F ) )
4360         {
4361             throw new InvalidCharacterException( c );
4362         }
4363 
4364         if ( ( c >= 0x06EE ) && ( c <= 0x06EF ) )
4365         {
4366             throw new InvalidCharacterException( c );
4367         }
4368 
4369         if ( ( c >= 0x072D ) && ( c <= 0x072F ) )
4370         {
4371             throw new InvalidCharacterException( c );
4372         }
4373 
4374         if ( ( c >= 0x074B ) && ( c <= 0x077F ) )
4375         {
4376             throw new InvalidCharacterException( c );
4377         }
4378 
4379         if ( ( c >= 0x07B2 ) && ( c <= 0x0900 ) )
4380         {
4381             throw new InvalidCharacterException( c );
4382         }
4383 
4384         if ( ( c >= 0x093A ) && ( c <= 0x093B ) )
4385         {
4386             throw new InvalidCharacterException( c );
4387         }
4388 
4389         if ( ( c >= 0x094E ) && ( c <= 0x094F ) )
4390         {
4391             throw new InvalidCharacterException( c );
4392         }
4393 
4394         if ( ( c >= 0x0955 ) && ( c <= 0x0957 ) )
4395         {
4396             throw new InvalidCharacterException( c );
4397         }
4398 
4399         if ( ( c >= 0x0971 ) && ( c <= 0x0980 ) )
4400         {
4401             throw new InvalidCharacterException( c );
4402         }
4403 
4404         if ( ( c >= 0x098D ) && ( c <= 0x098E ) )
4405         {
4406             throw new InvalidCharacterException( c );
4407         }
4408 
4409         if ( ( c >= 0x0991 ) && ( c <= 0x0992 ) )
4410         {
4411             throw new InvalidCharacterException( c );
4412         }
4413 
4414         if ( ( c >= 0x09B3 ) && ( c <= 0x09B5 ) )
4415         {
4416             throw new InvalidCharacterException( c );
4417         }
4418 
4419         if ( ( c >= 0x09BA ) && ( c <= 0x09BB ) )
4420         {
4421             throw new InvalidCharacterException( c );
4422         }
4423 
4424         if ( ( c >= 0x09C5 ) && ( c <= 0x09C6 ) )
4425         {
4426             throw new InvalidCharacterException( c );
4427         }
4428 
4429         if ( ( c >= 0x09C9 ) && ( c <= 0x09CA ) )
4430         {
4431             throw new InvalidCharacterException( c );
4432         }
4433 
4434         if ( ( c >= 0x09CE ) && ( c <= 0x09D6 ) )
4435         {
4436             throw new InvalidCharacterException( c );
4437         }
4438 
4439         if ( ( c >= 0x09D8 ) && ( c <= 0x09DB ) )
4440         {
4441             throw new InvalidCharacterException( c );
4442         }
4443 
4444         if ( ( c >= 0x09E4 ) && ( c <= 0x09E5 ) )
4445         {
4446             throw new InvalidCharacterException( c );
4447         }
4448 
4449         if ( ( c >= 0x09FB ) && ( c <= 0x0A01 ) )
4450         {
4451             throw new InvalidCharacterException( c );
4452         }
4453 
4454         if ( ( c >= 0x0A03 ) && ( c <= 0x0A04 ) )
4455         {
4456             throw new InvalidCharacterException( c );
4457         }
4458 
4459         if ( ( c >= 0x0A0B ) && ( c <= 0x0A0E ) )
4460         {
4461             throw new InvalidCharacterException( c );
4462         }
4463 
4464         if ( ( c >= 0x0A11 ) && ( c <= 0x0A12 ) )
4465         {
4466             throw new InvalidCharacterException( c );
4467         }
4468 
4469         if ( ( c >= 0x0A3A ) && ( c <= 0x0A3B ) )
4470         {
4471             throw new InvalidCharacterException( c );
4472         }
4473 
4474         if ( ( c >= 0x0A43 ) && ( c <= 0x0A46 ) )
4475         {
4476             throw new InvalidCharacterException( c );
4477         }
4478 
4479         if ( ( c >= 0x0A49 ) && ( c <= 0x0A4A ) )
4480         {
4481             throw new InvalidCharacterException( c );
4482         }
4483 
4484         if ( ( c >= 0x0A4E ) && ( c <= 0x0A58 ) )
4485         {
4486             throw new InvalidCharacterException( c );
4487         }
4488 
4489         if ( ( c >= 0x0A5F ) && ( c <= 0x0A65 ) )
4490         {
4491             throw new InvalidCharacterException( c );
4492         }
4493 
4494         if ( ( c >= 0x0A75 ) && ( c <= 0x0A80 ) )
4495         {
4496             throw new InvalidCharacterException( c );
4497         }
4498 
4499         if ( ( c >= 0x0ABA ) && ( c <= 0x0ABB ) )
4500         {
4501             throw new InvalidCharacterException( c );
4502         }
4503 
4504         if ( ( c >= 0x0ACE ) && ( c <= 0x0ACF ) )
4505         {
4506             throw new InvalidCharacterException( c );
4507         }
4508 
4509         if ( ( c >= 0x0AD1 ) && ( c <= 0x0ADF ) )
4510         {
4511             throw new InvalidCharacterException( c );
4512         }
4513 
4514         if ( ( c >= 0x0AE1 ) && ( c <= 0x0AE5 ) )
4515         {
4516             throw new InvalidCharacterException( c );
4517         }
4518 
4519         if ( ( c >= 0x0AF0 ) && ( c <= 0x0B00 ) )
4520         {
4521             throw new InvalidCharacterException( c );
4522         }
4523 
4524         if ( ( c >= 0x0B0D ) && ( c <= 0x0B0E ) )
4525         {
4526             throw new InvalidCharacterException( c );
4527         }
4528 
4529         if ( ( c >= 0x0B11 ) && ( c <= 0x0B12 ) )
4530         {
4531             throw new InvalidCharacterException( c );
4532         }
4533 
4534         if ( ( c >= 0x0B34 ) && ( c <= 0x0B35 ) )
4535         {
4536             throw new InvalidCharacterException( c );
4537         }
4538 
4539         if ( ( c >= 0x0B3A ) && ( c <= 0x0B3B ) )
4540         {
4541             throw new InvalidCharacterException( c );
4542         }
4543 
4544         if ( ( c >= 0x0B44 ) && ( c <= 0x0B46 ) )
4545         {
4546             throw new InvalidCharacterException( c );
4547         }
4548 
4549         if ( ( c >= 0x0B49 ) && ( c <= 0x0B4A ) )
4550         {
4551             throw new InvalidCharacterException( c );
4552         }
4553 
4554         if ( ( c >= 0x0B4E ) && ( c <= 0x0B55 ) )
4555         {
4556             throw new InvalidCharacterException( c );
4557         }
4558 
4559         if ( ( c >= 0x0B58 ) && ( c <= 0x0B5B ) )
4560         {
4561             throw new InvalidCharacterException( c );
4562         }
4563 
4564         if ( ( c >= 0x0B62 ) && ( c <= 0x0B65 ) )
4565         {
4566             throw new InvalidCharacterException( c );
4567         }
4568 
4569         if ( ( c >= 0x0B71 ) && ( c <= 0x0B81 ) )
4570         {
4571             throw new InvalidCharacterException( c );
4572         }
4573 
4574         if ( ( c >= 0x0B8B ) && ( c <= 0x0B8D ) )
4575         {
4576             throw new InvalidCharacterException( c );
4577         }
4578 
4579         if ( ( c >= 0x0B96 ) && ( c <= 0x0B98 ) )
4580         {
4581             throw new InvalidCharacterException( c );
4582         }
4583 
4584         if ( ( c >= 0x0BA0 ) && ( c <= 0x0BA2 ) )
4585         {
4586             throw new InvalidCharacterException( c );
4587         }
4588 
4589         if ( ( c >= 0x0BA5 ) && ( c <= 0x0BA7 ) )
4590         {
4591             throw new InvalidCharacterException( c );
4592         }
4593 
4594         if ( ( c >= 0x0BAB ) && ( c <= 0x0BAD ) )
4595         {
4596             throw new InvalidCharacterException( c );
4597         }
4598 
4599         if ( ( c >= 0x0BBA ) && ( c <= 0x0BBD ) )
4600         {
4601             throw new InvalidCharacterException( c );
4602         }
4603 
4604         if ( ( c >= 0x0BC3 ) && ( c <= 0x0BC5 ) )
4605         {
4606             throw new InvalidCharacterException( c );
4607         }
4608 
4609         if ( ( c >= 0x0BCE ) && ( c <= 0x0BD6 ) )
4610         {
4611             throw new InvalidCharacterException( c );
4612         }
4613 
4614         if ( ( c >= 0x0BD8 ) && ( c <= 0x0BE6 ) )
4615         {
4616             throw new InvalidCharacterException( c );
4617         }
4618 
4619         if ( ( c >= 0x0BF3 ) && ( c <= 0x0C00 ) )
4620         {
4621             throw new InvalidCharacterException( c );
4622         }
4623 
4624         // RFC 3454, Table C.3
4625         if ( ( c >= 0xE000 ) && ( c <= 0xF8FF ) )
4626         {
4627             throw new InvalidCharacterException( c );
4628         }
4629 
4630         // RFC 3454, Table C.4
4631         if ( ( c >= 0xFDD0 ) && ( c <= 0xFDEF ) )
4632         {
4633             throw new InvalidCharacterException( c );
4634         }
4635 
4636         if ( ( c == 0xFFFE ) || ( c == 0xFFFF ) )
4637         {
4638             throw new InvalidCharacterException( c );
4639         }
4640 
4641         // RFC 3454, Table C.5 (Surrogates)
4642         if ( ( c >= 0xD800 ) && ( c <= 0xDFFF ) )
4643         {
4644             throw new InvalidCharacterException( c );
4645         }
4646 
4647         // RFC 3454, Table C.8 
4648         switch ( c )
4649         {
4650             case 0x0340: // COMBINING GRAVE TONE MARK
4651             case 0x0341: // COMBINING ACUTE TONE MARK
4652             case 0x200E: // LEFT-TO-RIGHT MARK
4653             case 0x200F: // RIGHT-TO-LEFT MARK
4654             case 0x202A: // LEFT-TO-RIGHT EMBEDDING
4655             case 0x202B: // RIGHT-TO-LEFT EMBEDDING
4656             case 0x202C: // POP DIRECTIONAL FORMATTING
4657             case 0x202D: // LEFT-TO-RIGHT OVERRIDE
4658             case 0x202E: // RIGHT-TO-LEFT OVERRIDE
4659             case 0x206A: // INHIBIT SYMMETRIC SWAPPING
4660             case 0x206B: // ACTIVATE SYMMETRIC SWAPPING
4661             case 0x206C: // INHIBIT ARABIC FORM SHAPING
4662             case 0x206D: // ACTIVATE ARABIC FORM SHAPING
4663             case 0x206E: // NATIONAL DIGIT SHAPES
4664             case 0x206F: // NOMINAL DIGIT SHAPES
4665                 throw new InvalidCharacterException( c );
4666             default:
4667                 break;
4668         }
4669 
4670         if ( c == 0xFFFD )
4671         {
4672             throw new InvalidCharacterException( c );
4673         }
4674     }
4675 
4676 
4677     /**
4678      * 
4679      * Remove all bidirectionnal chars. This is not really clear in RFC 4518
4680      * what we should do with bidi chars :
4681      * "Bidirectional characters are ignored."
4682      * 
4683      * But it's not explained what is a bidi chars...
4684      * 
4685      * So this method just do nothing atm.
4686      *
4687      * @param str The string where bidi chars are to be removed
4688      * @return The cleaned string
4689      */
4690     public static String bidi( String str )
4691     {
4692         return str;
4693     }
4694 
4695 
4696     /**
4697      * 
4698      * Remove all bidirectionnal chars. This is not really clear in RFC 4518
4699      * what we should do with bidi chars :
4700      * "Bidirectional characters are ignored."
4701      * 
4702      * But it's not explained what is a bidi chars...
4703      * 
4704      * So this method just do nothing atm.
4705      *
4706      * @param array The char array where bidi chars are to be removed
4707      * @return The cleaned StringBuilder
4708      */
4709     public static StringBuilder bidi( char[] array )
4710     {
4711         StringBuilder sb = new StringBuilder( array == null ? 0 : array.length );
4712 
4713         if ( array != null )
4714         {
4715             sb.append( array );
4716         }
4717 
4718         return sb;
4719     }
4720 
4721 
4722     /**
4723      * 
4724      * Remove all insignifiant chars in a Telephone Number :
4725      * Hyphen and spaces. 
4726      * 
4727      * For instance, the following telephone number :
4728      * "+ (33) 1-123--456  789"
4729      * will be trasnformed to :
4730      * "+(33)1123456789"
4731      *
4732      * @param str The telephone number
4733      * @return The modified telephone number String
4734      */
4735     private static String insignifiantCharTelephoneNumber( String str )
4736     {
4737         if ( Strings.isEmpty( str ) )
4738         {
4739             return "";
4740         }
4741 
4742         char[] array = str.toCharArray();
4743 
4744         boolean isSpaceOrHyphen = false;
4745         char soh = '\0';
4746         int pos = 0;
4747 
4748         for ( char c : array )
4749         {
4750             switch ( c )
4751             {
4752                 case 0x0020: // SPACE
4753                 case 0x002D: // HYPHEN-MINUS
4754                 case 0x058A: // ARMENIAN HYPHEN
4755                 case 0x2010: // HYPHEN
4756                 case 0x2011: // NON-BREAKING HYPHEN
4757                 case 0x2212: // MINUS SIGN
4758                 case 0xFE63: // SMALL HYPHEN-MINUS
4759                 case 0xFF0D: // FULLWIDTH HYPHEN-MINUS
4760                     soh = c;
4761                     isSpaceOrHyphen = true;
4762                     break;
4763 
4764                 default:
4765                     if ( isSpaceOrHyphen && isCombiningMark( c ) )
4766                     {
4767                         array[pos++] = soh;
4768                         isSpaceOrHyphen = false;
4769                     }
4770                     else
4771                     {
4772                         isSpaceOrHyphen = false;
4773                     }
4774 
4775                     array[pos++] = c;
4776                     break;
4777             }
4778         }
4779 
4780         return new String( array, 0, pos );
4781     }
4782 
4783 
4784     /**
4785      * 
4786      * Remove all insignifiant spaces in a numeric string. For
4787      * instance, the following numeric string :
4788      * "  123  456  789  "
4789      * will be transformed to :
4790      * "123456789"
4791      *
4792      * @param str The numeric String
4793      * @return The modified numeric StringBuilder
4794      */
4795     private static String insignifiantCharNumericString( String str )
4796     {
4797         if ( Strings.isEmpty( str ) )
4798         {
4799             return "";
4800         }
4801 
4802         char[] array = str.toCharArray();
4803 
4804         boolean isSpace = false;
4805         int pos = 0;
4806 
4807         for ( char c : array )
4808         {
4809             if ( c != 0x20 )
4810             {
4811                 if ( isSpace && isCombiningMark( c ) )
4812                 {
4813                     array[pos++] = ' ';
4814                     isSpace = false;
4815                 }
4816 
4817                 array[pos++] = c;
4818             }
4819             else
4820             {
4821                 isSpace = true;
4822             }
4823         }
4824 
4825         return new String( array, 0, pos );
4826     }
4827 
4828 
4829     /**
4830      * Remove all insignificant spaces in a string.
4831      * 
4832      * This method use a finite state machine to parse
4833      * the text.
4834      * 
4835      * @param str The String to modify
4836      * @param caseSensitive A flag telling if the chars must be lower cased
4837      * @return The modified StringBuilder
4838      * @throws InvalidCharacterException If an invalid character is found in the String
4839      */
4840     private static String insignifiantSpacesString( String str, boolean caseSensitive )
4841         throws InvalidCharacterException
4842     {
4843         if ( Strings.isEmpty( str ) )
4844         {
4845             // Special case : an empty strings is replaced by 2 spaces
4846             return "";
4847         }
4848 
4849         char[] array = str.toCharArray();
4850 
4851         // Create a target char array which is 3 times bigger than the original size. 
4852         // We have to do that because the map phase may transform a char to
4853         // three chars.
4854         // TODO : we have to find a way to prevent this waste of space.
4855         char[] target = new char[str.length() * 3 + 2];
4856         
4857         int pos;
4858         char lowerCase = ( char ) ( caseSensitive ? 0x00 : 0x20 );
4859 
4860         // First pass to map the chars. This will copy the array into the target
4861         int limit = map( array, target, lowerCase );
4862         pos = 0;
4863 
4864         // Second pass to remove spaces. We work on the target
4865         int start = 0;
4866         char c = '\0';
4867 
4868         // First remove starting spaces
4869         for ( int i = 0; i < limit; i++ )
4870         {
4871             c = target[i];
4872 
4873             if ( c != ' ' )
4874             {
4875                 checkProhibited( c );
4876                 break;
4877             }
4878             
4879             start++;
4880         }
4881 
4882         // We will just handle the special case of a combining character
4883         if ( start == limit )
4884         {
4885             // we only have spaces, we keep only one
4886             return " ";
4887         }
4888         else if ( isCombiningMark( c ) )
4889         {
4890             if ( start == 0 )
4891             {
4892                 // The first char can't be a combining char
4893                 throw new InvalidCharacterException( c );
4894             }
4895             else
4896             {
4897                 target[pos++] = ' ';
4898                 target[pos++] = c;
4899                 start++;
4900             }
4901         }
4902         else
4903         {
4904             target[pos++] = c;
4905             start++;
4906         }
4907 
4908         // Now remove the spaces at the end
4909         int i;
4910         
4911         for ( i = limit - 1; i >= start; i-- )
4912         {
4913             if ( target[i] == ' ' )
4914             {
4915                 // Check if we have a preceding '\' 
4916                 if ( i - 1 >= start )
4917                 {
4918                     // Break only if the space is preceded by a single ESC
4919                     if ( i - 2 >= start )
4920                     {
4921                         if ( ( target[i - 1] == '\\' ) && ( target[i - 2] != '\\' ) )
4922                         {
4923                             target[i - 1] = ' ';
4924                             i--;
4925                             break;
4926                         }
4927                     }
4928                     else
4929                     {
4930                         if ( target[i - 1] == '\\' )
4931                         {
4932                             target[i - 1] = ' ';
4933                             i--;
4934                             break;
4935                         }
4936                     }
4937                 }
4938             }
4939             else
4940             {
4941                 break;
4942             }
4943         }
4944 
4945         limit = i + 1;
4946 
4947         // Remove the " around the string if any
4948         if ( target[start] == '"' )
4949         {
4950             start++;
4951             limit--;
4952         }
4953 
4954         boolean spaceSeen = false;
4955         boolean escapeSeen = false;
4956 
4957         for ( i = start; i < limit; i++ )
4958         {
4959             c = target[i];
4960 
4961             checkProhibited( c );
4962 
4963             if ( c == ' ' )
4964             {
4965                 if ( escapeSeen )
4966                 {
4967                     target[pos++] = ' ';
4968                 }
4969                 else
4970                 {
4971                     spaceSeen = true;
4972                 }
4973 
4974                 escapeSeen = false;
4975             }
4976             else if ( c == '\\' )
4977             {
4978                 if ( escapeSeen )
4979                 {
4980                     target[pos++] = '\\';
4981                     target[pos++] = '\\';
4982                 }
4983                 else if ( spaceSeen )
4984                 {
4985                     target[pos++] = ' ';
4986                 }
4987                 
4988                 escapeSeen = !escapeSeen;
4989                 spaceSeen = false;
4990             }
4991             else
4992             {
4993                 if ( spaceSeen )
4994                 {
4995                     target[pos++] = ' ';
4996                     spaceSeen = false;
4997                 }
4998                 else if ( escapeSeen )
4999                 {
5000                     target[pos++] = '\\';
5001                 }
5002                 
5003                 target[pos++] = c;
5004                 escapeSeen = false;
5005             }
5006         }
5007 
5008         // A special case : we have seen a space at the end of the array : it must be added back
5009         // because it's an escaped space, otherwise it would have been discarded by the previous 
5010         // end of String's space removal
5011         if ( spaceSeen )
5012         {
5013             target[pos++] = ' ';
5014         }
5015         // Same for the escape
5016         else if ( escapeSeen )
5017         {
5018             target[pos++] = '\\';
5019         }
5020         
5021         // Ends by unescaping the escaped elements
5022         return unescape( target, pos );
5023     }
5024 
5025 
5026     /**
5027      * Remove all insignificant spaces in a Ascii string. We don't remove escaped spaces.
5028      * 
5029      * This method use a finite state machine to parse
5030      * the text.
5031      * 
5032      * @param str The String to modify
5033      * @param caseSensitive A flag telling if the chars must be lower cased
5034      * @return The modified StringBuilder
5035      * @throws InvalidCharacterException If an invalid character is found in the String
5036      */
5037     private static String insignifiantSpacesStringAscii( String str, boolean caseSensitive )
5038         throws InvalidCharacterException
5039     {
5040         if ( Strings.isEmpty( str ) )
5041         {
5042             // Special case : an empty strings is replaced by 2 spaces
5043             return "";
5044         }
5045         
5046         char[] array = str.toCharArray();
5047 
5048         int pos;
5049         char lowerCase = ( char ) ( caseSensitive ? 0x00 : 0x20 );
5050 
5051         // First pass to map the chars
5052         int limit = map( array, array, lowerCase );
5053         pos = 0;
5054 
5055         // Second pass to remove spaces (except the escaped ones). We work on the target
5056         int start = 0;
5057         char c = '\0';
5058 
5059         // First remove starting spaces
5060         for ( int i = 0; i < limit; i++ )
5061         {
5062             c = array[i];
5063 
5064             if ( c != ' ' )
5065             {
5066                 checkProhibited( c );
5067                 break;
5068             }
5069             
5070             start++;
5071         }
5072 
5073         // We will just handle the special case of a combining character
5074         if ( start == limit )
5075         {
5076             // we only have spaces, we keep only one
5077             return " ";
5078         }
5079         else if ( isCombiningMark( c ) )
5080         {
5081             if ( start == 0 )
5082             {
5083                 // The first char can't be a combining char
5084                 throw new InvalidCharacterException( c );
5085             }
5086             else
5087             {
5088                 throw new InvalidCharacterException( c );
5089             }
5090         }
5091 
5092         // Now remove the spaces at the end
5093         int i;
5094         
5095         for ( i = limit - 1; i >= start; i-- )
5096         {
5097             if ( array[i] == ' ' )
5098             {
5099                 // Check if we have a preceding '\' 
5100                 if ( i - 1 >= start )
5101                 {
5102                     // Break only if the space is preceded by a single ESC
5103                     if ( i - 2 >= start )
5104                     {
5105                         if ( ( array[i - 1] == '\\' ) && ( array[i - 2] != '\\' ) )
5106                         {
5107                             array[i - 1] = ' ';
5108                             i--;
5109                             break;
5110                         }
5111                     }
5112                     else
5113                     {
5114                         if ( array[i - 1] == '\\' )
5115                         {
5116                             array[i - 1] = ' ';
5117                             i--;
5118                             break;
5119                         }
5120                     }
5121                 }
5122             }
5123             else
5124             {
5125                 break;
5126             }
5127         }
5128 
5129         limit = i + 1;
5130 
5131         // Remove the " around the string if any
5132         if ( array[start] == '"' )
5133         {
5134             start++;
5135             limit--;
5136         }
5137         
5138         boolean spaceSeen = false;
5139         boolean escapeSeen = false;
5140 
5141         for ( i = start; i < limit; i++ )
5142         {
5143             c = array[i];
5144 
5145             checkProhibited( c );
5146 
5147             if ( c == ' ' )
5148             {
5149                 if ( escapeSeen )
5150                 {
5151                     array[pos++] = ' ';
5152                 }
5153                 else
5154                 {
5155                     spaceSeen = true;
5156                 }
5157 
5158                 escapeSeen = false;
5159             }
5160             else if ( c == '\\' )
5161             {
5162                 if ( escapeSeen )
5163                 {
5164                     array[pos++] = '\\';
5165                     array[pos++] = '\\';
5166                 }
5167                 else if ( spaceSeen )
5168                 {
5169                     array[pos++] = ' ';
5170                 }
5171                 
5172                 escapeSeen = !escapeSeen;
5173                 spaceSeen = false;
5174             }
5175             else
5176             {
5177                 if ( spaceSeen )
5178                 {
5179                     array[pos++] = ' ';
5180                     spaceSeen = false;
5181                 }
5182                 else if ( escapeSeen )
5183                 {
5184                     array[pos++] = '\\';
5185                 }
5186                 
5187                 array[pos++] = c;
5188                 escapeSeen = false;
5189             }
5190         }
5191 
5192         // A special case : we have seen a space at the end of the array : it must be added back
5193         // because it's an escaped space, otherwise it would have been discarded by the previous 
5194         // end of String's space removal
5195         if ( spaceSeen )
5196         {
5197             array[pos++] = ' ';
5198         }
5199         // Same for the escape
5200         else if ( escapeSeen )
5201         {
5202             array[pos++] = '\\';
5203         }
5204         
5205         // Ends by unescaping the escaped elements
5206         return unescape( array, pos );
5207     }
5208     
5209     
5210     private static String unescape( char[] array, int end )
5211     {
5212         byte[] bytes = new byte[end * 3];
5213         boolean escapeSeen = false;
5214         int pos = 0;
5215             
5216         for ( int i = 0; i < end; i++ )
5217         {
5218             char c = array[i];
5219             
5220             if ( c == '\\' )
5221             {
5222                 if ( escapeSeen )
5223                 {
5224                     bytes[pos++] = '\\';
5225                 }
5226                 
5227                 escapeSeen = !escapeSeen;
5228             }
5229             else
5230             {
5231                 if ( escapeSeen )
5232                 {
5233                     switch ( c )
5234                     {
5235                         // Various form of space
5236                         case 0x0A :
5237                         case 0x0B :
5238                         case 0x0C :
5239                         case 0x0D :
5240                         case 0x85 :
5241                         case 0xA0 :
5242                         case ' ' :
5243                             bytes[pos++] = ' ';
5244                             break;
5245                         
5246                         // Special chars
5247                         case '#' :
5248                         case '=' :
5249                         case '+' :
5250                         case '"' :
5251                         case ',' :
5252                         case ';' :
5253                         case '<' :
5254                         case '>' : 
5255                             bytes[pos++] = ( byte ) c;
5256                             break;
5257                         
5258                         // Hexpair
5259                         case '0' :
5260                         case '1' :
5261                         case '2' :
5262                         case '3' :
5263                         case '4' :
5264                         case '5' :
5265                         case '6' :
5266                         case '7' :
5267                         case '8' :
5268                         case '9' :
5269                             bytes[pos++] = ( byte ) ( ( ( byte ) ( array[i] - '0' ) << 4 ) 
5270                                 + ( toByte( array[i + 1] ) & 0xff ) );
5271                             i++;
5272                             break;
5273                             
5274                         case 'a' :
5275                         case 'b' :
5276                         case 'c' :
5277                         case 'd' :
5278                         case 'e' :
5279                         case 'f' :
5280                             bytes[pos++] = ( byte ) ( ( ( byte ) ( array[i] - 'a' + 10 ) << 4 ) 
5281                                 + ( toByte( array[i + 1] ) & 0xFF ) );
5282                             i++;
5283                             break;
5284                             
5285                         case 'A' :
5286                         case 'B' :
5287                         case 'C' :
5288                         case 'D' :
5289                         case 'E' :
5290                         case 'F' :
5291                             bytes[pos++] = ( byte ) ( ( ( byte ) ( array[i] - 'A' + 10 ) << 4 ) 
5292                                 + ( toByte( array[i + 1] ) & 0xff ) );
5293                             i++;
5294                             break;
5295                             
5296                         default :
5297                             break;
5298                     }
5299                     
5300                     escapeSeen = false;
5301                 }
5302                 else
5303                 {
5304                     // We might have a UTF-8 char
5305                     if ( ( c & 0x007F ) == c )
5306                     {
5307                         // Single byte char
5308                         bytes[pos++] = ( byte ) c;
5309                     }
5310                     else if ( ( c & 0x07FF ) == c )
5311                     {
5312                         bytes[pos++] = ( byte ) ( 0x00C0 | ( c >> 6 ) );
5313                         bytes[pos++] = ( byte ) ( 0x0080 | ( c & 0x003F ) );
5314                     }
5315                     else
5316                     {
5317                         bytes[pos++] = ( byte ) ( 0x00E0 | ( c >> 12 ) );
5318                         bytes[pos++] = ( byte ) ( 0x0080 | ( ( c >> 6 ) & 0x3F ) );
5319                         bytes[pos++] = ( byte ) ( 0x0080 | ( c & 0x003F ) );
5320                     }
5321                 }
5322             }
5323         }
5324         
5325         // Deal with the special case where we have one single escape
5326         if ( escapeSeen )
5327         {
5328             bytes[pos++] = '\\';
5329         }
5330         
5331         return Strings.utf8ToString( bytes, pos );
5332     }
5333     
5334     
5335     private static byte toByte( char c )
5336     {
5337         switch ( c )
5338         {
5339             case '0' :
5340             case '1' :
5341             case '2' :
5342             case '3' :
5343             case '4' :
5344             case '5' :
5345             case '6' :
5346             case '7' :
5347             case '8' :
5348             case '9' :
5349                 return ( byte ) ( c - '0' );
5350                 
5351             case 'a' :
5352             case 'b' :
5353             case 'c' :
5354             case 'd' :
5355             case 'e' :
5356             case 'f' :
5357                 return ( byte ) ( c - 'a' + 10 );
5358                 
5359             case 'A' :
5360             case 'B' :
5361             case 'C' :
5362             case 'D' :
5363             case 'E' :
5364             case 'F' :
5365                 return ( byte ) ( c - 'A' + 10 );
5366                 
5367             default :
5368                 break;
5369         }
5370         
5371         return 0;
5372     }
5373 }