Source code

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