src/mscorlib/shared/System/Text/Latin1Encoding.cs

   1 // Licensed to the .NET Foundation under one or more agreements.
   2 // The .NET Foundation licenses this file to you under the MIT license.
   3 // See the LICENSE file in the project root for more information.
   4
   5 using System;
   6 using System.Diagnostics;
   7 using System.Diagnostics.Contracts;
   8 using System.Runtime.Serialization;
   9
  10 namespace System.Text
  11 {
  12     //
  13     // Latin1Encoding is a simple override to optimize the GetString version of Latin1Encoding.
  14     // because of the best fit cases we can't do this when encoding the string, only when decoding
  15     //
  16     internal class Latin1Encoding : EncodingNLS, ISerializable
  17     {
  18         // Used by Encoding.Latin1 for lazy initialization
  19         // The initialization code will not be run until a static member of the class is referenced
  20         internal static readonly Latin1Encoding s_default = new Latin1Encoding();
  21
  22         // We only use the best-fit table, of which ASCII is a superset for us.
  23         public Latin1Encoding() : base(Encoding.ISO_8859_1)
  24         {
  25         }
  26
  27         // ISerializable implementation
  28         void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
  29         {
  30             throw new PlatformNotSupportedException();
  31         }
  32
  33         // GetByteCount
  34         // Note: We start by assuming that the output will be the same as count.  Having
  35         // an encoder or fallback may change that assumption
  36         internal override unsafe int GetByteCount(char* chars, int charCount, EncoderNLS encoder)
  37         {
  38             // Just need to ASSERT, this is called by something else internal that checked parameters already
  39             Debug.Assert(charCount >= 0, "[Latin1Encoding.GetByteCount]count is negative");
  40             Debug.Assert(chars != null, "[Latin1Encoding.GetByteCount]chars is null");
  41
  42             // Assert because we shouldn't be able to have a null encoder.
  43             Debug.Assert(encoderFallback != null, "[Latin1Encoding.GetByteCount]Attempting to use null fallback encoder");
  44
  45             char charLeftOver = (char)0;
  46
  47             // If we have an encoder AND we aren't using default fallback,
  48             // then we may have a complicated count.
  49             EncoderReplacementFallback fallback;
  50             if (encoder != null)
  51             {
  52                 charLeftOver = encoder.charLeftOver;
  53                 Debug.Assert(charLeftOver == 0 || Char.IsHighSurrogate(charLeftOver),
  54                     "[Latin1Encoding.GetByteCount]leftover character should be high surrogate");
  55
  56                 fallback = encoder.Fallback as EncoderReplacementFallback;
  57
  58                 // Verify that we have no fallbackbuffer, for Latin1 its always empty, so just assert
  59                 Debug.Assert(!encoder.m_throwOnOverflow || !encoder.InternalHasFallbackBuffer ||
  60                     encoder.FallbackBuffer.Remaining == 0,
  61                     "[Latin1CodePageEncoding.GetByteCount]Expected empty fallback buffer");
  62             }
  63             else
  64                 fallback = this.EncoderFallback as EncoderReplacementFallback;
  65
  66             if ((fallback != null && fallback.MaxCharCount == 1)/* || bIsBestFit*/)
  67             {
  68                 // Replacement fallback encodes surrogate pairs as two ?? (or two whatever), so return size is always
  69                 // same as input size.
  70                 // Note that no existing SBCS code pages map code points to supplimentary characters, so this is easy.
  71
  72                 // We could however have 1 extra byte if the last call had an encoder and a funky fallback and
  73                 // if we don't use the funky fallback this time.
  74
  75                 // Do we have an extra char left over from last time?
  76                 if (charLeftOver > 0)
  77                     charCount++;
  78
  79                 return (charCount);
  80             }
  81
  82             // Count is more complicated if you have a funky fallback
  83             // For fallback we may need a fallback buffer, we know we're not default fallback
  84             int byteCount = 0;
  85
  86             // Start by assuming default count, then +/- for fallback characters
  87             char* charEnd = chars + charCount;
  88
  89             // For fallback we may need a fallback buffer, we know we aren't default fallback.
  90             EncoderFallbackBuffer fallbackBuffer = null;
  91             char* charsForFallback;
  92
  93             // We may have a left over character from last time, try and process it.
  94             if (charLeftOver > 0)
  95             {
  96                 // Initialize the buffer
  97                 Debug.Assert(encoder != null,
  98                     "[Latin1Encoding.GetByteCount]Expected encoder if we have charLeftOver");
  99                 fallbackBuffer = encoder.FallbackBuffer;
 100                 fallbackBuffer.InternalInitialize(chars, charEnd, encoder, false);
 101
 102                 // Since left over char was a surrogate, it'll have to be fallen back.
 103                 // Get Fallback
 104                 // This will fallback a pair if *chars is a low surrogate
 105                 charsForFallback = chars;
 106                 fallbackBuffer.InternalFallback(charLeftOver, ref charsForFallback);
 107                 chars = charsForFallback;
 108             }
 109
 110             // Now we may have fallback char[] already from the encoder
 111
 112             // Go ahead and do it, including the fallback.
 113             char ch;
 114             while ((ch = (fallbackBuffer == null) ? '\0' : fallbackBuffer.InternalGetNextChar()) != 0 ||
 115                     chars < charEnd)
 116             {
 117                 // First unwind any fallback
 118                 if (ch == 0)
 119                 {
 120                     // No fallback, just get next char
 121                     ch = *chars;
 122                     chars++;
 123                 }
 124
 125                 // Check for fallback, this'll catch surrogate pairs too.
 126                 // no chars >= 0x100 are allowed.
 127                 if (ch > 0xff)
 128                 {
 129                     // Initialize the buffer
 130                     if (fallbackBuffer == null)
 131                     {
 132                         if (encoder == null)
 133                             fallbackBuffer = this.encoderFallback.CreateFallbackBuffer();
 134                         else
 135                             fallbackBuffer = encoder.FallbackBuffer;
 136                         fallbackBuffer.InternalInitialize(charEnd - charCount, charEnd, encoder, false);
 137                     }
 138
 139                     // Get Fallback
 140                     charsForFallback = chars;
 141                     fallbackBuffer.InternalFallback(ch, ref charsForFallback);
 142                     chars = charsForFallback;
 143                     continue;
 144                 }
 145
 146                 // We'll use this one
 147                 byteCount++;
 148             }
 149
 150             Debug.Assert(fallbackBuffer == null || fallbackBuffer.Remaining == 0,
 151                 "[Latin1Encoding.GetByteCount]Expected Empty fallback buffer");
 152
 153             return byteCount;
 154         }
 155
 156         internal override unsafe int GetBytes(char* chars, int charCount,
 157                                                 byte* bytes, int byteCount, EncoderNLS encoder)
 158         {
 159             // Just need to ASSERT, this is called by something else internal that checked parameters already
 160             Debug.Assert(bytes != null, "[Latin1Encoding.GetBytes]bytes is null");
 161             Debug.Assert(byteCount >= 0, "[Latin1Encoding.GetBytes]byteCount is negative");
 162             Debug.Assert(chars != null, "[Latin1Encoding.GetBytes]chars is null");
 163             Debug.Assert(charCount >= 0, "[Latin1Encoding.GetBytes]charCount is negative");
 164
 165             // Assert because we shouldn't be able to have a null encoder.
 166             Debug.Assert(encoderFallback != null, "[Latin1Encoding.GetBytes]Attempting to use null encoder fallback");
 167
 168             // Get any left over characters & check fast or slower fallback type
 169             char charLeftOver = (char)0;
 170             EncoderReplacementFallback fallback = null;
 171             if (encoder != null)
 172             {
 173                 charLeftOver = encoder.charLeftOver;
 174                 fallback = encoder.Fallback as EncoderReplacementFallback;
 175                 Debug.Assert(charLeftOver == 0 || Char.IsHighSurrogate(charLeftOver),
 176                     "[Latin1Encoding.GetBytes]leftover character should be high surrogate");
 177
 178                 // Verify that we have no fallbackbuffer, for ASCII its always empty, so just assert
 179                 Debug.Assert(!encoder.m_throwOnOverflow || !encoder.InternalHasFallbackBuffer ||
 180                     encoder.FallbackBuffer.Remaining == 0,
 181                     "[Latin1CodePageEncoding.GetBytes]Expected empty fallback buffer");
 182             }
 183             else
 184             {
 185                 fallback = this.EncoderFallback as EncoderReplacementFallback;
 186             }
 187
 188             // prepare our end
 189             char* charEnd = chars + charCount;
 190             byte* byteStart = bytes;
 191             char* charStart = chars;
 192
 193             // See if we do the fast default or slightly slower fallback
 194             if (fallback != null && fallback.MaxCharCount == 1)
 195             {
 196                 // Fast version
 197                 char cReplacement = fallback.DefaultString[0];
 198
 199                 // Check for replacements in range, otherwise fall back to slow version.
 200                 if (cReplacement <= (char)0xff)
 201                 {
 202                     // We should have exactly as many output bytes as input bytes, unless there's a left
 203                     // over character, in which case we may need one more.
 204
 205                     // If we had a left over character will have to add a ?  (This happens if they had a funky
 206                     // fallback last time, but not this time.) (We can't spit any out though
 207                     // because with fallback encoder each surrogate is treated as a seperate code point)
 208                     if (charLeftOver > 0)
 209                     {
 210                         // Have to have room
 211                         // Throw even if doing no throw version because this is just 1 char,
 212                         // so buffer will never be big enough
 213                         if (byteCount == 0)
 214                             ThrowBytesOverflow(encoder, true);
 215
 216                         // This'll make sure we still have more room and also make sure our return value is correct.
 217                         *(bytes++) = (byte)cReplacement;
 218                         byteCount--;                // We used one of the ones we were counting.
 219                     }
 220
 221                     // This keeps us from overrunning our output buffer
 222                     if (byteCount < charCount)
 223                     {
 224                         // Throw or make buffer smaller?
 225                         ThrowBytesOverflow(encoder, byteCount < 1);
 226
 227                         // Just use what we can
 228                         charEnd = chars + byteCount;
 229                     }
 230
 231                     // We just do a quick copy
 232                     while (chars < charEnd)
 233                     {
 234                         char ch2 = *(chars++);
 235                         if (ch2 > 0x00ff) *(bytes++) = (byte)cReplacement;
 236                         else *(bytes++) = (byte)ch2;
 237                     }
 238
 239                     // Clear encoder
 240                     if (encoder != null)
 241                     {
 242                         encoder.charLeftOver = (char)0;
 243                         encoder.m_charsUsed = (int)(chars - charStart);
 244                     }
 245                     return (int)(bytes - byteStart);
 246                 }
 247             }
 248
 249             // Slower version, have to do real fallback.
 250
 251             // prepare our end
 252             byte* byteEnd = bytes + byteCount;
 253
 254             // For fallback we may need a fallback buffer, we know we aren't default fallback, create & init it
 255             EncoderFallbackBuffer fallbackBuffer = null;
 256             char* charsForFallback;
 257
 258             // We may have a left over character from last time, try and process it.
 259             if (charLeftOver > 0)
 260             {
 261                 // Since left over char was a surrogate, it'll have to be fallen back.
 262                 // Get Fallback
 263                 Debug.Assert(encoder != null,
 264                     "[Latin1Encoding.GetBytes]Expected encoder if we have charLeftOver");
 265                 fallbackBuffer = encoder.FallbackBuffer;
 266                 fallbackBuffer.InternalInitialize(chars, charEnd, encoder, true);
 267
 268                 // Since left over char was a surrogate, it'll have to be fallen back.
 269                 // Get Fallback
 270                 // This will fallback a pair if *chars is a low surrogate
 271                 charsForFallback = chars;
 272                 fallbackBuffer.InternalFallback(charLeftOver, ref charsForFallback);
 273                 chars = charsForFallback;
 274
 275                 if (fallbackBuffer.Remaining > byteEnd - bytes)
 276                 {
 277                     // Throw it, if we don't have enough for this we never will
 278                     ThrowBytesOverflow(encoder, true);
 279                 }
 280             }
 281
 282             // Now we may have fallback char[] already from the encoder fallback above
 283
 284             // Go ahead and do it, including the fallback.
 285             char ch;
 286             while ((ch = (fallbackBuffer == null) ? '\0' : fallbackBuffer.InternalGetNextChar()) != 0 ||
 287                     chars < charEnd)
 288             {
 289                 // First unwind any fallback
 290                 if (ch == 0)
 291                 {
 292                     // No fallback, just get next char
 293                     ch = *chars;
 294                     chars++;
 295                 }
 296
 297                 // Check for fallback, this'll catch surrogate pairs too.
 298                 // All characters >= 0x100 must fall back.
 299                 if (ch > 0xff)
 300                 {
 301                     // Initialize the buffer
 302                     if (fallbackBuffer == null)
 303                     {
 304                         if (encoder == null)
 305                             fallbackBuffer = this.encoderFallback.CreateFallbackBuffer();
 306                         else
 307                             fallbackBuffer = encoder.FallbackBuffer;
 308                         fallbackBuffer.InternalInitialize(charEnd - charCount, charEnd, encoder, true);
 309                     }
 310
 311                     // Get Fallback
 312                     charsForFallback = chars;
 313                     fallbackBuffer.InternalFallback(ch, ref charsForFallback);
 314                     chars = charsForFallback;
 315
 316                     // Make sure we have enough room.  Each fallback char will be 1 output char
 317                     // (or else cause a recursion exception)
 318                     if (fallbackBuffer.Remaining > byteEnd - bytes)
 319                     {
 320                         // Didn't use this char, throw it.  Chars should've advanced by now
 321                         // If we had encoder fallback data it would've thrown before the loop
 322                         Debug.Assert(chars > charStart,
 323                             "[Latin1Encoding.GetBytes]Expected chars to have advanced (fallback case)");
 324                         chars--;
 325                         fallbackBuffer.InternalReset();
 326
 327                         // Throw it
 328                         ThrowBytesOverflow(encoder, chars == charStart);
 329                         break;
 330                     }
 331
 332                     continue;
 333                 }
 334
 335                 // We'll use this one
 336                 // Bounds check
 337                 if (bytes >= byteEnd)
 338                 {
 339                     // didn't use this char, we'll throw or use buffer
 340                     Debug.Assert(fallbackBuffer == null || fallbackBuffer.bFallingBack == false,
 341                         "[Latin1Encoding.GetBytes]Expected fallback to have throw initially if insufficient space");
 342                     if (fallbackBuffer == null || fallbackBuffer.bFallingBack == false)
 343                     {
 344                         Debug.Assert(chars > charStart,
 345                             "[Latin1Encoding.GetBytes]Expected chars to have advanced (fallback case)");
 346                         chars--;                                        // don't use last char
 347                     }
 348                     ThrowBytesOverflow(encoder, chars == charStart);    // throw ?
 349                     break;                                              // don't throw, stop
 350                 }
 351
 352                 // Go ahead and add it
 353                 *bytes = unchecked((byte)ch);
 354                 bytes++;
 355             }
 356
 357             // Need to do encoder stuff
 358             if (encoder != null)
 359             {
 360                 // Fallback stuck it in encoder if necessary, but we have to clear MustFlush cases
 361                 if (fallbackBuffer != null && !fallbackBuffer.bUsedEncoder)
 362                     // Clear it in case of MustFlush
 363                     encoder.charLeftOver = (char)0;
 364
 365                 // Set our chars used count
 366                 encoder.m_charsUsed = (int)(chars - charStart);
 367             }
 368
 369             Debug.Assert(fallbackBuffer == null || fallbackBuffer.Remaining == 0,
 370                 "[Latin1Encoding.GetBytes]Expected Empty fallback buffer");
 371
 372             return (int)(bytes - byteStart);
 373         }
 374
 375         // This is internal and called by something else,
 376         internal override unsafe int GetCharCount(byte* bytes, int count, DecoderNLS decoder)
 377         {
 378             // Just assert, we're called internally so these should be safe, checked already
 379             Debug.Assert(bytes != null, "[Latin1Encoding.GetCharCount]bytes is null");
 380             Debug.Assert(count >= 0, "[Latin1Encoding.GetCharCount]byteCount is negative");
 381
 382             // Just return length, SBCS stay the same length because they don't map to surrogate
 383             // pairs and we don't have to fallback because all latin1Encoding code points are unicode
 384             return count;
 385         }
 386
 387         internal override unsafe int GetChars(byte* bytes, int byteCount,
 388                                                 char* chars, int charCount, DecoderNLS decoder)
 389         {
 390             // Just need to ASSERT, this is called by something else internal that checked parameters already
 391             Debug.Assert(bytes != null, "[Latin1Encoding.GetChars]bytes is null");
 392             Debug.Assert(byteCount >= 0, "[Latin1Encoding.GetChars]byteCount is negative");
 393             Debug.Assert(chars != null, "[Latin1Encoding.GetChars]chars is null");
 394             Debug.Assert(charCount >= 0, "[Latin1Encoding.GetChars]charCount is negative");
 395
 396             // Need byteCount chars, otherwise too small buffer
 397             if (charCount < byteCount)
 398             {
 399                 // Buffer too small.  Do we throw?
 400                 ThrowCharsOverflow(decoder, charCount < 1);
 401
 402                 // Don't throw, correct buffer size
 403                 byteCount = charCount;
 404             }
 405
 406             // Do it our fast way
 407             byte* byteEnd = bytes + byteCount;
 408
 409             // Quick loop, all bytes are the same as chars, so no fallbacks for latin1
 410             while (bytes < byteEnd)
 411             {
 412                 *(chars) = unchecked((char)*(bytes));
 413                 chars++;
 414                 bytes++;
 415             }
 416
 417             // Might need to know input bytes used
 418             if (decoder != null)
 419                 decoder.m_bytesUsed = byteCount;
 420
 421             // Converted sequence is same length as input, so output charsUsed is same as byteCount;
 422             return byteCount;
 423         }
 424
 425         public override int GetMaxByteCount(int charCount)
 426         {
 427             if (charCount < 0)
 428                 throw new ArgumentOutOfRangeException(nameof(charCount),
 429                      SR.ArgumentOutOfRange_NeedNonNegNum);
 430             Contract.EndContractBlock();
 431
 432             // Characters would be # of characters + 1 in case high surrogate is ? * max fallback
 433             long byteCount = (long)charCount + 1;
 434
 435             if (EncoderFallback.MaxCharCount > 1)
 436                 byteCount *= EncoderFallback.MaxCharCount;
 437
 438             // 1 to 1 for most characters.  Only surrogates with fallbacks have less.
 439
 440             if (byteCount > 0x7fffffff)
 441                 throw new ArgumentOutOfRangeException(nameof(charCount), SR.ArgumentOutOfRange_GetByteCountOverflow);
 442             return (int)byteCount;
 443         }
 444
 445         public override int GetMaxCharCount(int byteCount)
 446         {
 447             if (byteCount < 0)
 448                 throw new ArgumentOutOfRangeException(nameof(byteCount),
 449                      SR.ArgumentOutOfRange_NeedNonNegNum);
 450             Contract.EndContractBlock();
 451
 452             // Just return length, SBCS stay the same length because they don't map to surrogate
 453             long charCount = (long)byteCount;
 454
 455             // 1 to 1 for most characters.  Only surrogates with fallbacks have less, unknown fallbacks could be longer.
 456             if (DecoderFallback.MaxCharCount > 1)
 457                 charCount *= DecoderFallback.MaxCharCount;
 458
 459             if (charCount > 0x7fffffff)
 460                 throw new ArgumentOutOfRangeException(nameof(byteCount), SR.ArgumentOutOfRange_GetCharCountOverflow);
 461
 462             return (int)charCount;
 463         }
 464
 465         // True if and only if the encoding only uses single byte code points.  (Ie, ASCII, 1252, etc)
 466         public override bool IsSingleByte
 467         {
 468             get
 469             {
 470                 return true;
 471             }
 472         }
 473
 474         public override bool IsAlwaysNormalized(NormalizationForm form)
 475         {
 476             // Latin-1 contains precomposed characters, so normal for Form C.
 477             // Since some are composed, not normal for D & KD.
 478             // Also some letters like 0x00A8 (spacing diarisis) have compatibility decompositions, so false for KD & KC.
 479
 480             // Only true for form C.
 481             return (form == NormalizationForm.FormC);
 482         }
 483         // Since our best fit table is small we'll hard code it
 484         internal override char[] GetBestFitUnicodeToBytesData()
 485         {
 486             // Get our best fit data
 487             return Latin1Encoding.arrayCharBestFit;
 488         }
 489
 490         // Best fit for ASCII, and since it works for ASCII, we use it for latin1 as well.
 491         private static readonly char[] arrayCharBestFit =
 492         {
 493 // The first many are in case you wanted to use this for ASCIIEncoding, which we don't need to do any more.
 494 //          (char)0x00a0, (char)0x0020,    // No-Break Space -> Space
 495 //          (char)0x00a1, (char)0x0021,    // Inverted Exclamation Mark -> !
 496 //          (char)0x00a2, (char)0x0063,    // Cent Sign -> c
 497 //          (char)0x00a3, (char)0x003f,    // Pound Sign
 498 //          (char)0x00a4, (char)0x0024,    // Currency Sign -> $
 499 //          (char)0x00a5, (char)0x0059,    // Yen Sign -> Y
 500 //          (char)0x00a6, (char)0x007c,    // Broken Bar -> |
 501 //          (char)0x00a7, (char)0x003f,    // Section Sign
 502 //          (char)0x00a8, (char)0x003f,    // Diaeresis
 503 //          (char)0x00a9, (char)0x0043,    // Copyright Sign -> C
 504 //          (char)0x00aa, (char)0x0061,    // Feminine Ordinal Indicator -> a
 505 //          (char)0x00ab, (char)0x003c,    // Left-Pointing Double Angle Quotation Mark -> <
 506 //          (char)0x00ac, (char)0x003f,    // Not Sign
 507 //          (char)0x00ad, (char)0x002d,    // Soft Hyphen -> -
 508 //          (char)0x00ae, (char)0x0052,    // Registered Sign -> R
 509 //          (char)0x00af, (char)0x003f,    // Macron
 510 //          (char)0x00b0, (char)0x003f,    // Degree Sign
 511 //          (char)0x00b1, (char)0x003f,    // Plus-Minus Sign
 512 //          (char)0x00b2, (char)0x0032,    // Superscript Two -> 2
 513 //          (char)0x00b3, (char)0x0033,    // Superscript Three -> 3
 514 //          (char)0x00b4, (char)0x003f,    // Acute Accent
 515 //          (char)0x00b5, (char)0x003f,    // Micro Sign
 516 //          (char)0x00b6, (char)0x003f,    // Pilcrow Sign
 517 //          (char)0x00b7, (char)0x002e,    // Middle Dot -> .
 518 //          (char)0x00b8, (char)0x002c,    // Cedilla -> ,
 519 //          (char)0x00b9, (char)0x0031,    // Superscript One -> 1
 520 //          (char)0x00ba, (char)0x006f,    // Masculine Ordinal Indicator -> o
 521 //          (char)0x00bb, (char)0x003e,    // Right-Pointing Double Angle Quotation Mark -> >
 522 //          (char)0x00bc, (char)0x003f,    // Vulgar Fraction One Quarter
 523 //          (char)0x00bd, (char)0x003f,    // Vulgar Fraction One Half
 524 //          (char)0x00be, (char)0x003f,    // Vulgar Fraction Three Quarters
 525 //          (char)0x00bf, (char)0x003f,    // Inverted Question Mark
 526 //          (char)0x00c0, (char)0x0041,    // Latin Capital Letter A With Grave -> A
 527 //          (char)0x00c1, (char)0x0041,    // Latin Capital Letter A With Acute -> A
 528 //          (char)0x00c2, (char)0x0041,    // Latin Capital Letter A With Circumflex -> A
 529 //          (char)0x00c3, (char)0x0041,    // Latin Capital Letter A With Tilde -> A
 530 //          (char)0x00c4, (char)0x0041,    // Latin Capital Letter A With Diaeresis -> A
 531 //          (char)0x00c5, (char)0x0041,    // Latin Capital Letter A With Ring Above -> A
 532 //          (char)0x00c6, (char)0x0041,    // Latin Capital Ligature Ae -> A
 533 //          (char)0x00c7, (char)0x0043,    // Latin Capital Letter C With Cedilla -> C
 534 //          (char)0x00c8, (char)0x0045,    // Latin Capital Letter E With Grave -> E
 535 //          (char)0x00c9, (char)0x0045,    // Latin Capital Letter E With Acute -> E
 536 //          (char)0x00ca, (char)0x0045,    // Latin Capital Letter E With Circumflex -> E
 537 //          (char)0x00cb, (char)0x0045,    // Latin Capital Letter E With Diaeresis -> E
 538 //          (char)0x00cc, (char)0x0049,    // Latin Capital Letter I With Grave -> I
 539 //          (char)0x00cd, (char)0x0049,    // Latin Capital Letter I With Acute -> I
 540 //          (char)0x00ce, (char)0x0049,    // Latin Capital Letter I With Circumflex -> I
 541 //          (char)0x00cf, (char)0x0049,    // Latin Capital Letter I With Diaeresis -> I
 542 //          (char)0x00d0, (char)0x0044,    // Latin Capital Letter Eth -> D
 543 //          (char)0x00d1, (char)0x004e,    // Latin Capital Letter N With Tilde -> N
 544 //          (char)0x00d2, (char)0x004f,    // Latin Capital Letter O With Grave -> O
 545 //          (char)0x00d3, (char)0x004f,    // Latin Capital Letter O With Acute -> O
 546 //          (char)0x00d4, (char)0x004f,    // Latin Capital Letter O With Circumflex -> O
 547 //          (char)0x00d5, (char)0x004f,    // Latin Capital Letter O With Tilde -> O
 548 //          (char)0x00d6, (char)0x004f,    // Latin Capital Letter O With Diaeresis -> O
 549 //          (char)0x00d7, (char)0x003f,    // Multiplication Sign
 550 //          (char)0x00d8, (char)0x004f,    // Latin Capital Letter O With Stroke -> O
 551 //          (char)0x00d9, (char)0x0055,    // Latin Capital Letter U With Grave -> U
 552 //          (char)0x00da, (char)0x0055,    // Latin Capital Letter U With Acute -> U
 553 //          (char)0x00db, (char)0x0055,    // Latin Capital Letter U With Circumflex -> U
 554 //          (char)0x00dc, (char)0x0055,    // Latin Capital Letter U With Diaeresis -> U
 555 //          (char)0x00dd, (char)0x0059,    // Latin Capital Letter Y With Acute -> Y
 556 //          (char)0x00de, (char)0x003f,    // Latin Capital Letter Thorn
 557 //          (char)0x00df, (char)0x003f,    // Latin Small Letter Sharp S
 558 //          (char)0x00e0, (char)0x0061,    // Latin Small Letter A With Grave -> a
 559 //          (char)0x00e1, (char)0x0061,    // Latin Small Letter A With Acute -> a
 560 //          (char)0x00e2, (char)0x0061,    // Latin Small Letter A With Circumflex -> a
 561 //          (char)0x00e3, (char)0x0061,    // Latin Small Letter A With Tilde -> a
 562 //          (char)0x00e4, (char)0x0061,    // Latin Small Letter A With Diaeresis -> a
 563 //          (char)0x00e5, (char)0x0061,    // Latin Small Letter A With Ring Above -> a
 564 //          (char)0x00e6, (char)0x0061,    // Latin Small Ligature Ae -> a
 565 //          (char)0x00e7, (char)0x0063,    // Latin Small Letter C With Cedilla -> c
 566 //          (char)0x00e8, (char)0x0065,    // Latin Small Letter E With Grave -> e
 567 //          (char)0x00e9, (char)0x0065,    // Latin Small Letter E With Acute -> e
 568 //          (char)0x00ea, (char)0x0065,    // Latin Small Letter E With Circumflex -> e
 569 //          (char)0x00eb, (char)0x0065,    // Latin Small Letter E With Diaeresis -> e
 570 //          (char)0x00ec, (char)0x0069,    // Latin Small Letter I With Grave -> i
 571 //          (char)0x00ed, (char)0x0069,    // Latin Small Letter I With Acute -> i
 572 //          (char)0x00ee, (char)0x0069,    // Latin Small Letter I With Circumflex -> i
 573 //          (char)0x00ef, (char)0x0069,    // Latin Small Letter I With Diaeresis -> i
 574 //          (char)0x00f0, (char)0x003f,    // Latin Small Letter Eth
 575 //          (char)0x00f1, (char)0x006e,    // Latin Small Letter N With Tilde -> n
 576 //          (char)0x00f2, (char)0x006f,    // Latin Small Letter O With Grave -> o
 577 //          (char)0x00f3, (char)0x006f,    // Latin Small Letter O With Acute -> o
 578 //          (char)0x00f4, (char)0x006f,    // Latin Small Letter O With Circumflex -> o
 579 //          (char)0x00f5, (char)0x006f,    // Latin Small Letter O With Tilde -> o
 580 //          (char)0x00f6, (char)0x006f,    // Latin Small Letter O With Diaeresis -> o
 581 //          (char)0x00f7, (char)0x003f,    // Division Sign
 582 //          (char)0x00f8, (char)0x006f,    // Latin Small Letter O With Stroke -> o
 583 //          (char)0x00f9, (char)0x0075,    // Latin Small Letter U With Grave -> u
 584 //          (char)0x00fa, (char)0x0075,    // Latin Small Letter U With Acute -> u
 585 //          (char)0x00fb, (char)0x0075,    // Latin Small Letter U With Circumflex -> u
 586 //          (char)0x00fc, (char)0x0075,    // Latin Small Letter U With Diaeresis -> u
 587 //          (char)0x00fd, (char)0x0079,    // Latin Small Letter Y With Acute -> y
 588 //          (char)0x00fe, (char)0x003f,    // Latin Small Letter Thorn
 589 //          (char)0x00ff, (char)0x0079,    // Latin Small Letter Y With Diaeresis -> y
 590             (char)0x0100, (char)0x0041,    // Latin Capital Letter A With Macron -> A
 591             (char)0x0101, (char)0x0061,    // Latin Small Letter A With Macron -> a
 592             (char)0x0102, (char)0x0041,    // Latin Capital Letter A With Breve -> A
 593             (char)0x0103, (char)0x0061,    // Latin Small Letter A With Breve -> a
 594             (char)0x0104, (char)0x0041,    // Latin Capital Letter A With Ogonek -> A
 595             (char)0x0105, (char)0x0061,    // Latin Small Letter A With Ogonek -> a
 596             (char)0x0106, (char)0x0043,    // Latin Capital Letter C With Acute -> C
 597             (char)0x0107, (char)0x0063,    // Latin Small Letter C With Acute -> c
 598             (char)0x0108, (char)0x0043,    // Latin Capital Letter C With Circumflex -> C
 599             (char)0x0109, (char)0x0063,    // Latin Small Letter C With Circumflex -> c
 600             (char)0x010a, (char)0x0043,    // Latin Capital Letter C With Dot Above -> C
 601             (char)0x010b, (char)0x0063,    // Latin Small Letter C With Dot Above -> c
 602             (char)0x010c, (char)0x0043,    // Latin Capital Letter C With Caron -> C
 603             (char)0x010d, (char)0x0063,    // Latin Small Letter C With Caron -> c
 604             (char)0x010e, (char)0x0044,    // Latin Capital Letter D With Caron -> D
 605             (char)0x010f, (char)0x0064,    // Latin Small Letter D With Caron -> d
 606             (char)0x0110, (char)0x0044,    // Latin Capital Letter D With Stroke -> D
 607             (char)0x0111, (char)0x0064,    // Latin Small Letter D With Stroke -> d
 608             (char)0x0112, (char)0x0045,    // Latin Capital Letter E With Macron -> E
 609             (char)0x0113, (char)0x0065,    // Latin Small Letter E With Macron -> e
 610             (char)0x0114, (char)0x0045,    // Latin Capital Letter E With Breve -> E
 611             (char)0x0115, (char)0x0065,    // Latin Small Letter E With Breve -> e
 612             (char)0x0116, (char)0x0045,    // Latin Capital Letter E With Dot Above -> E
 613             (char)0x0117, (char)0x0065,    // Latin Small Letter E With Dot Above -> e
 614             (char)0x0118, (char)0x0045,    // Latin Capital Letter E With Ogonek -> E
 615             (char)0x0119, (char)0x0065,    // Latin Small Letter E With Ogonek -> e
 616             (char)0x011a, (char)0x0045,    // Latin Capital Letter E With Caron -> E
 617             (char)0x011b, (char)0x0065,    // Latin Small Letter E With Caron -> e
 618             (char)0x011c, (char)0x0047,    // Latin Capital Letter G With Circumflex -> G
 619             (char)0x011d, (char)0x0067,    // Latin Small Letter G With Circumflex -> g
 620             (char)0x011e, (char)0x0047,    // Latin Capital Letter G With Breve -> G
 621             (char)0x011f, (char)0x0067,    // Latin Small Letter G With Breve -> g
 622             (char)0x0120, (char)0x0047,    // Latin Capital Letter G With Dot Above -> G
 623             (char)0x0121, (char)0x0067,    // Latin Small Letter G With Dot Above -> g
 624             (char)0x0122, (char)0x0047,    // Latin Capital Letter G With Cedilla -> G
 625             (char)0x0123, (char)0x0067,    // Latin Small Letter G With Cedilla -> g
 626             (char)0x0124, (char)0x0048,    // Latin Capital Letter H With Circumflex -> H
 627             (char)0x0125, (char)0x0068,    // Latin Small Letter H With Circumflex -> h
 628             (char)0x0126, (char)0x0048,    // Latin Capital Letter H With Stroke -> H
 629             (char)0x0127, (char)0x0068,    // Latin Small Letter H With Stroke -> h
 630             (char)0x0128, (char)0x0049,    // Latin Capital Letter I With Tilde -> I
 631             (char)0x0129, (char)0x0069,    // Latin Small Letter I With Tilde -> i
 632             (char)0x012a, (char)0x0049,    // Latin Capital Letter I With Macron -> I
 633             (char)0x012b, (char)0x0069,    // Latin Small Letter I With Macron -> i
 634             (char)0x012c, (char)0x0049,    // Latin Capital Letter I With Breve -> I
 635             (char)0x012d, (char)0x0069,    // Latin Small Letter I With Breve -> i
 636             (char)0x012e, (char)0x0049,    // Latin Capital Letter I With Ogonek -> I
 637             (char)0x012f, (char)0x0069,    // Latin Small Letter I With Ogonek -> i
 638             (char)0x0130, (char)0x0049,    // Latin Capital Letter I With Dot Above -> I
 639             (char)0x0131, (char)0x0069,    // Latin Small Letter Dotless I -> i
 640             (char)0x0134, (char)0x004a,    // Latin Capital Letter J With Circumflex -> J
 641             (char)0x0135, (char)0x006a,    // Latin Small Letter J With Circumflex -> j
 642             (char)0x0136, (char)0x004b,    // Latin Capital Letter K With Cedilla -> K
 643             (char)0x0137, (char)0x006b,    // Latin Small Letter K With Cedilla -> k
 644             (char)0x0139, (char)0x004c,    // Latin Capital Letter L With Acute -> L
 645             (char)0x013a, (char)0x006c,    // Latin Small Letter L With Acute -> l
 646             (char)0x013b, (char)0x004c,    // Latin Capital Letter L With Cedilla -> L
 647             (char)0x013c, (char)0x006c,    // Latin Small Letter L With Cedilla -> l
 648             (char)0x013d, (char)0x004c,    // Latin Capital Letter L With Caron -> L
 649             (char)0x013e, (char)0x006c,    // Latin Small Letter L With Caron -> l
 650             (char)0x0141, (char)0x004c,    // Latin Capital Letter L With Stroke -> L
 651             (char)0x0142, (char)0x006c,    // Latin Small Letter L With Stroke -> l
 652             (char)0x0143, (char)0x004e,    // Latin Capital Letter N With Acute -> N
 653             (char)0x0144, (char)0x006e,    // Latin Small Letter N With Acute -> n
 654             (char)0x0145, (char)0x004e,    // Latin Capital Letter N With Cedilla -> N
 655             (char)0x0146, (char)0x006e,    // Latin Small Letter N With Cedilla -> n
 656             (char)0x0147, (char)0x004e,    // Latin Capital Letter N With Caron -> N
 657             (char)0x0148, (char)0x006e,    // Latin Small Letter N With Caron -> n
 658             (char)0x014c, (char)0x004f,    // Latin Capital Letter O With Macron -> O
 659             (char)0x014d, (char)0x006f,    // Latin Small Letter O With Macron -> o
 660             (char)0x014e, (char)0x004f,    // Latin Capital Letter O With Breve -> O
 661             (char)0x014f, (char)0x006f,    // Latin Small Letter O With Breve -> o
 662             (char)0x0150, (char)0x004f,    // Latin Capital Letter O With Double Acute -> O
 663             (char)0x0151, (char)0x006f,    // Latin Small Letter O With Double Acute -> o
 664             (char)0x0152, (char)0x004f,    // Latin Capital Ligature Oe -> O
 665             (char)0x0153, (char)0x006f,    // Latin Small Ligature Oe -> o
 666             (char)0x0154, (char)0x0052,    // Latin Capital Letter R With Acute -> R
 667             (char)0x0155, (char)0x0072,    // Latin Small Letter R With Acute -> r
 668             (char)0x0156, (char)0x0052,    // Latin Capital Letter R With Cedilla -> R
 669             (char)0x0157, (char)0x0072,    // Latin Small Letter R With Cedilla -> r
 670             (char)0x0158, (char)0x0052,    // Latin Capital Letter R With Caron -> R
 671             (char)0x0159, (char)0x0072,    // Latin Small Letter R With Caron -> r
 672             (char)0x015a, (char)0x0053,    // Latin Capital Letter S With Acute -> S
 673             (char)0x015b, (char)0x0073,    // Latin Small Letter S With Acute -> s
 674             (char)0x015c, (char)0x0053,    // Latin Capital Letter S With Circumflex -> S
 675             (char)0x015d, (char)0x0073,    // Latin Small Letter S With Circumflex -> s
 676             (char)0x015e, (char)0x0053,    // Latin Capital Letter S With Cedilla -> S
 677             (char)0x015f, (char)0x0073,    // Latin Small Letter S With Cedilla -> s
 678             (char)0x0160, (char)0x0053,    // Latin Capital Letter S With Caron -> S
 679             (char)0x0161, (char)0x0073,    // Latin Small Letter S With Caron -> s
 680             (char)0x0162, (char)0x0054,    // Latin Capital Letter T With Cedilla -> T
 681             (char)0x0163, (char)0x0074,    // Latin Small Letter T With Cedilla -> t
 682             (char)0x0164, (char)0x0054,    // Latin Capital Letter T With Caron -> T
 683             (char)0x0165, (char)0x0074,    // Latin Small Letter T With Caron -> t
 684             (char)0x0166, (char)0x0054,    // Latin Capital Letter T With Stroke -> T
 685             (char)0x0167, (char)0x0074,    // Latin Small Letter T With Stroke -> t
 686             (char)0x0168, (char)0x0055,    // Latin Capital Letter U With Tilde -> U
 687             (char)0x0169, (char)0x0075,    // Latin Small Letter U With Tilde -> u
 688             (char)0x016a, (char)0x0055,    // Latin Capital Letter U With Macron -> U
 689             (char)0x016b, (char)0x0075,    // Latin Small Letter U With Macron -> u
 690             (char)0x016c, (char)0x0055,    // Latin Capital Letter U With Breve -> U
 691             (char)0x016d, (char)0x0075,    // Latin Small Letter U With Breve -> u
 692             (char)0x016e, (char)0x0055,    // Latin Capital Letter U With Ring Above -> U
 693             (char)0x016f, (char)0x0075,    // Latin Small Letter U With Ring Above -> u
 694             (char)0x0170, (char)0x0055,    // Latin Capital Letter U With Double Acute -> U
 695             (char)0x0171, (char)0x0075,    // Latin Small Letter U With Double Acute -> u
 696             (char)0x0172, (char)0x0055,    // Latin Capital Letter U With Ogonek -> U
 697             (char)0x0173, (char)0x0075,    // Latin Small Letter U With Ogonek -> u
 698             (char)0x0174, (char)0x0057,    // Latin Capital Letter W With Circumflex -> W
 699             (char)0x0175, (char)0x0077,    // Latin Small Letter W With Circumflex -> w
 700             (char)0x0176, (char)0x0059,    // Latin Capital Letter Y With Circumflex -> Y
 701             (char)0x0177, (char)0x0079,    // Latin Small Letter Y With Circumflex -> y
 702             (char)0x0178, (char)0x0059,    // Latin Capital Letter Y With Diaeresis -> Y
 703             (char)0x0179, (char)0x005a,    // Latin Capital Letter Z With Acute -> Z
 704             (char)0x017a, (char)0x007a,    // Latin Small Letter Z With Acute -> z
 705             (char)0x017b, (char)0x005a,    // Latin Capital Letter Z With Dot Above -> Z
 706             (char)0x017c, (char)0x007a,    // Latin Small Letter Z With Dot Above -> z
 707             (char)0x017d, (char)0x005a,    // Latin Capital Letter Z With Caron -> Z
 708             (char)0x017e, (char)0x007a,    // Latin Small Letter Z With Caron -> z
 709             (char)0x0180, (char)0x0062,    // Latin Small Letter B With Stroke -> b
 710             (char)0x0189, (char)0x0044,    // Latin Capital Letter African D -> D
 711             (char)0x0191, (char)0x0046,    // Latin Capital Letter F With Hook -> F
 712             (char)0x0192, (char)0x0066,    // Latin Small Letter F With Hook -> f
 713             (char)0x0197, (char)0x0049,    // Latin Capital Letter I With Stroke -> I
 714             (char)0x019a, (char)0x006c,    // Latin Small Letter L With Bar -> l
 715             (char)0x019f, (char)0x004f,    // Latin Capital Letter O With Middle Tilde -> O
 716             (char)0x01a0, (char)0x004f,    // Latin Capital Letter O With Horn -> O
 717             (char)0x01a1, (char)0x006f,    // Latin Small Letter O With Horn -> o
 718             (char)0x01ab, (char)0x0074,    // Latin Small Letter T With Palatal Hook -> t
 719             (char)0x01ae, (char)0x0054,    // Latin Capital Letter T With Retroflex Hook -> T
 720             (char)0x01af, (char)0x0055,    // Latin Capital Letter U With Horn -> U
 721             (char)0x01b0, (char)0x0075,    // Latin Small Letter U With Horn -> u
 722             (char)0x01b6, (char)0x007a,    // Latin Small Letter Z With Stroke -> z
 723             (char)0x01cd, (char)0x0041,    // Latin Capital Letter A With Caron -> A
 724             (char)0x01ce, (char)0x0061,    // Latin Small Letter A With Caron -> a
 725             (char)0x01cf, (char)0x0049,    // Latin Capital Letter I With Caron -> I
 726             (char)0x01d0, (char)0x0069,    // Latin Small Letter I With Caron -> i
 727             (char)0x01d1, (char)0x004f,    // Latin Capital Letter O With Caron -> O
 728             (char)0x01d2, (char)0x006f,    // Latin Small Letter O With Caron -> o
 729             (char)0x01d3, (char)0x0055,    // Latin Capital Letter U With Caron -> U
 730             (char)0x01d4, (char)0x0075,    // Latin Small Letter U With Caron -> u
 731             (char)0x01d5, (char)0x0055,    // Latin Capital Letter U With Diaeresis And Macron -> U
 732             (char)0x01d6, (char)0x0075,    // Latin Small Letter U With Diaeresis And Macron -> u
 733             (char)0x01d7, (char)0x0055,    // Latin Capital Letter U With Diaeresis And Acute -> U
 734             (char)0x01d8, (char)0x0075,    // Latin Small Letter U With Diaeresis And Acute -> u
 735             (char)0x01d9, (char)0x0055,    // Latin Capital Letter U With Diaeresis And Caron -> U
 736             (char)0x01da, (char)0x0075,    // Latin Small Letter U With Diaeresis And Caron -> u
 737             (char)0x01db, (char)0x0055,    // Latin Capital Letter U With Diaeresis And Grave -> U
 738             (char)0x01dc, (char)0x0075,    // Latin Small Letter U With Diaeresis And Grave -> u
 739             (char)0x01de, (char)0x0041,    // Latin Capital Letter A With Diaeresis And Macron -> A
 740             (char)0x01df, (char)0x0061,    // Latin Small Letter A With Diaeresis And Macron -> a
 741             (char)0x01e4, (char)0x0047,    // Latin Capital Letter G With Stroke -> G
 742             (char)0x01e5, (char)0x0067,    // Latin Small Letter G With Stroke -> g
 743             (char)0x01e6, (char)0x0047,    // Latin Capital Letter G With Caron -> G
 744             (char)0x01e7, (char)0x0067,    // Latin Small Letter G With Caron -> g
 745             (char)0x01e8, (char)0x004b,    // Latin Capital Letter K With Caron -> K
 746             (char)0x01e9, (char)0x006b,    // Latin Small Letter K With Caron -> k
 747             (char)0x01ea, (char)0x004f,    // Latin Capital Letter O With Ogonek -> O
 748             (char)0x01eb, (char)0x006f,    // Latin Small Letter O With Ogonek -> o
 749             (char)0x01ec, (char)0x004f,    // Latin Capital Letter O With Ogonek And Macron -> O
 750             (char)0x01ed, (char)0x006f,    // Latin Small Letter O With Ogonek And Macron -> o
 751             (char)0x01f0, (char)0x006a,    // Latin Small Letter J With Caron -> j
 752             (char)0x0261, (char)0x0067,    // Latin Small Letter Script G -> g
 753             (char)0x02b9, (char)0x0027,    // Modifier Letter Prime -> '
 754             (char)0x02ba, (char)0x0022,    // Modifier Letter Double Prime -> "
 755             (char)0x02bc, (char)0x0027,    // Modifier Letter Apostrophe -> '
 756             (char)0x02c4, (char)0x005e,    // Modifier Letter Up Arrowhead -> ^
 757             (char)0x02c6, (char)0x005e,    // Modifier Letter Circumflex Accent -> ^
 758             (char)0x02c8, (char)0x0027,    // Modifier Letter Vertical Line -> '
 759             (char)0x02c9, (char)0x003f,    // Modifier Letter Macron
 760             (char)0x02ca, (char)0x003f,    // Modifier Letter Acute Accent
 761             (char)0x02cb, (char)0x0060,    // Modifier Letter Grave Accent -> `
 762             (char)0x02cd, (char)0x005f,    // Modifier Letter Low Macron -> _
 763             (char)0x02da, (char)0x003f,    // Ring Above
 764             (char)0x02dc, (char)0x007e,    // Small Tilde -> ~
 765             (char)0x0300, (char)0x0060,    // Combining Grave Accent -> `
 766             (char)0x0302, (char)0x005e,    // Combining Circumflex Accent -> ^
 767             (char)0x0303, (char)0x007e,    // Combining Tilde -> ~
 768             (char)0x030e, (char)0x0022,    // Combining Double Vertical Line Above -> "
 769             (char)0x0331, (char)0x005f,    // Combining Macron Below -> _
 770             (char)0x0332, (char)0x005f,    // Combining Low Line -> _
 771             (char)0x2000, (char)0x0020,    // En Quad
 772             (char)0x2001, (char)0x0020,    // Em Quad
 773             (char)0x2002, (char)0x0020,    // En Space
 774             (char)0x2003, (char)0x0020,    // Em Space
 775             (char)0x2004, (char)0x0020,    // Three-Per-Em Space
 776             (char)0x2005, (char)0x0020,    // Four-Per-Em Space
 777             (char)0x2006, (char)0x0020,    // Six-Per-Em Space
 778             (char)0x2010, (char)0x002d,    // Hyphen -> -
 779             (char)0x2011, (char)0x002d,    // Non-Breaking Hyphen -> -
 780             (char)0x2013, (char)0x002d,    // En Dash -> -
 781             (char)0x2014, (char)0x002d,    // Em Dash -> -
 782             (char)0x2018, (char)0x0027,    // Left Single Quotation Mark -> '
 783             (char)0x2019, (char)0x0027,    // Right Single Quotation Mark -> '
 784             (char)0x201a, (char)0x002c,    // Single Low-9 Quotation Mark -> ,
 785             (char)0x201c, (char)0x0022,    // Left Double Quotation Mark -> "
 786             (char)0x201d, (char)0x0022,    // Right Double Quotation Mark -> "
 787             (char)0x201e, (char)0x0022,    // Double Low-9 Quotation Mark -> "
 788             (char)0x2020, (char)0x003f,    // Dagger
 789             (char)0x2021, (char)0x003f,    // Double Dagger
 790             (char)0x2022, (char)0x002e,    // Bullet -> .
 791             (char)0x2026, (char)0x002e,    // Horizontal Ellipsis -> .
 792             (char)0x2030, (char)0x003f,    // Per Mille Sign
 793             (char)0x2032, (char)0x0027,    // Prime -> '
 794             (char)0x2035, (char)0x0060,    // Reversed Prime -> `
 795             (char)0x2039, (char)0x003c,    // Single Left-Pointing Angle Quotation Mark -> <
 796             (char)0x203a, (char)0x003e,    // Single Right-Pointing Angle Quotation Mark -> >
 797             (char)0x2122, (char)0x0054,    // Trade Mark Sign -> T
 798             (char)0xff01, (char)0x0021,    // Fullwidth Exclamation Mark -> !
 799             (char)0xff02, (char)0x0022,    // Fullwidth Quotation Mark -> "
 800             (char)0xff03, (char)0x0023,    // Fullwidth Number Sign -> #
 801             (char)0xff04, (char)0x0024,    // Fullwidth Dollar Sign -> $
 802             (char)0xff05, (char)0x0025,    // Fullwidth Percent Sign -> %
 803             (char)0xff06, (char)0x0026,    // Fullwidth Ampersand -> &
 804             (char)0xff07, (char)0x0027,    // Fullwidth Apostrophe -> '
 805             (char)0xff08, (char)0x0028,    // Fullwidth Left Parenthesis -> (
 806             (char)0xff09, (char)0x0029,    // Fullwidth Right Parenthesis -> )
 807             (char)0xff0a, (char)0x002a,    // Fullwidth Asterisk -> *
 808             (char)0xff0b, (char)0x002b,    // Fullwidth Plus Sign -> +
 809             (char)0xff0c, (char)0x002c,    // Fullwidth Comma -> ,
 810             (char)0xff0d, (char)0x002d,    // Fullwidth Hyphen-Minus -> -
 811             (char)0xff0e, (char)0x002e,    // Fullwidth Full Stop -> .
 812             (char)0xff0f, (char)0x002f,    // Fullwidth Solidus -> /
 813             (char)0xff10, (char)0x0030,    // Fullwidth Digit Zero -> 0
 814             (char)0xff11, (char)0x0031,    // Fullwidth Digit One -> 1
 815             (char)0xff12, (char)0x0032,    // Fullwidth Digit Two -> 2
 816             (char)0xff13, (char)0x0033,    // Fullwidth Digit Three -> 3
 817             (char)0xff14, (char)0x0034,    // Fullwidth Digit Four -> 4
 818             (char)0xff15, (char)0x0035,    // Fullwidth Digit Five -> 5
 819             (char)0xff16, (char)0x0036,    // Fullwidth Digit Six -> 6
 820             (char)0xff17, (char)0x0037,    // Fullwidth Digit Seven -> 7
 821             (char)0xff18, (char)0x0038,    // Fullwidth Digit Eight -> 8
 822             (char)0xff19, (char)0x0039,    // Fullwidth Digit Nine -> 9
 823             (char)0xff1a, (char)0x003a,    // Fullwidth Colon -> :
 824             (char)0xff1b, (char)0x003b,    // Fullwidth Semicolon -> ;
 825             (char)0xff1c, (char)0x003c,    // Fullwidth Less-Than Sign -> <
 826             (char)0xff1d, (char)0x003d,    // Fullwidth Equals Sign -> =
 827             (char)0xff1e, (char)0x003e,    // Fullwidth Greater-Than Sign -> >
 828             (char)0xff1f, (char)0x003f,    // Fullwidth Question Mark
 829             (char)0xff20, (char)0x0040,    // Fullwidth Commercial At -> @
 830             (char)0xff21, (char)0x0041,    // Fullwidth Latin Capital Letter A -> A
 831             (char)0xff22, (char)0x0042,    // Fullwidth Latin Capital Letter B -> B
 832             (char)0xff23, (char)0x0043,    // Fullwidth Latin Capital Letter C -> C
 833             (char)0xff24, (char)0x0044,    // Fullwidth Latin Capital Letter D -> D
 834             (char)0xff25, (char)0x0045,    // Fullwidth Latin Capital Letter E -> E
 835             (char)0xff26, (char)0x0046,    // Fullwidth Latin Capital Letter F -> F
 836             (char)0xff27, (char)0x0047,    // Fullwidth Latin Capital Letter G -> G
 837             (char)0xff28, (char)0x0048,    // Fullwidth Latin Capital Letter H -> H
 838             (char)0xff29, (char)0x0049,    // Fullwidth Latin Capital Letter I -> I
 839             (char)0xff2a, (char)0x004a,    // Fullwidth Latin Capital Letter J -> J
 840             (char)0xff2b, (char)0x004b,    // Fullwidth Latin Capital Letter K -> K
 841             (char)0xff2c, (char)0x004c,    // Fullwidth Latin Capital Letter L -> L
 842             (char)0xff2d, (char)0x004d,    // Fullwidth Latin Capital Letter M -> M
 843             (char)0xff2e, (char)0x004e,    // Fullwidth Latin Capital Letter N -> N
 844             (char)0xff2f, (char)0x004f,    // Fullwidth Latin Capital Letter O -> O
 845             (char)0xff30, (char)0x0050,    // Fullwidth Latin Capital Letter P -> P
 846             (char)0xff31, (char)0x0051,    // Fullwidth Latin Capital Letter Q -> Q
 847             (char)0xff32, (char)0x0052,    // Fullwidth Latin Capital Letter R -> R
 848             (char)0xff33, (char)0x0053,    // Fullwidth Latin Capital Letter S -> S
 849             (char)0xff34, (char)0x0054,    // Fullwidth Latin Capital Letter T -> T
 850             (char)0xff35, (char)0x0055,    // Fullwidth Latin Capital Letter U -> U
 851             (char)0xff36, (char)0x0056,    // Fullwidth Latin Capital Letter V -> V
 852             (char)0xff37, (char)0x0057,    // Fullwidth Latin Capital Letter W -> W
 853             (char)0xff38, (char)0x0058,    // Fullwidth Latin Capital Letter X -> X
 854             (char)0xff39, (char)0x0059,    // Fullwidth Latin Capital Letter Y -> Y
 855             (char)0xff3a, (char)0x005a,    // Fullwidth Latin Capital Letter Z -> Z
 856             (char)0xff3b, (char)0x005b,    // Fullwidth Left Square Bracket -> [
 857             (char)0xff3c, (char)0x005c,    // Fullwidth Reverse Solidus -> \
 858             (char)0xff3d, (char)0x005d,    // Fullwidth Right Square Bracket -> ]
 859             (char)0xff3e, (char)0x005e,    // Fullwidth Circumflex Accent -> ^
 860             (char)0xff3f, (char)0x005f,    // Fullwidth Low Line -> _
 861             (char)0xff40, (char)0x0060,    // Fullwidth Grave Accent -> `
 862             (char)0xff41, (char)0x0061,    // Fullwidth Latin Small Letter A -> a
 863             (char)0xff42, (char)0x0062,    // Fullwidth Latin Small Letter B -> b
 864             (char)0xff43, (char)0x0063,    // Fullwidth Latin Small Letter C -> c
 865             (char)0xff44, (char)0x0064,    // Fullwidth Latin Small Letter D -> d
 866             (char)0xff45, (char)0x0065,    // Fullwidth Latin Small Letter E -> e
 867             (char)0xff46, (char)0x0066,    // Fullwidth Latin Small Letter F -> f
 868             (char)0xff47, (char)0x0067,    // Fullwidth Latin Small Letter G -> g
 869             (char)0xff48, (char)0x0068,    // Fullwidth Latin Small Letter H -> h
 870             (char)0xff49, (char)0x0069,    // Fullwidth Latin Small Letter I -> i
 871             (char)0xff4a, (char)0x006a,    // Fullwidth Latin Small Letter J -> j
 872             (char)0xff4b, (char)0x006b,    // Fullwidth Latin Small Letter K -> k
 873             (char)0xff4c, (char)0x006c,    // Fullwidth Latin Small Letter L -> l
 874             (char)0xff4d, (char)0x006d,    // Fullwidth Latin Small Letter M -> m
 875             (char)0xff4e, (char)0x006e,    // Fullwidth Latin Small Letter N -> n
 876             (char)0xff4f, (char)0x006f,    // Fullwidth Latin Small Letter O -> o
 877             (char)0xff50, (char)0x0070,    // Fullwidth Latin Small Letter P -> p
 878             (char)0xff51, (char)0x0071,    // Fullwidth Latin Small Letter Q -> q
 879             (char)0xff52, (char)0x0072,    // Fullwidth Latin Small Letter R -> r
 880             (char)0xff53, (char)0x0073,    // Fullwidth Latin Small Letter S -> s
 881             (char)0xff54, (char)0x0074,    // Fullwidth Latin Small Letter T -> t
 882             (char)0xff55, (char)0x0075,    // Fullwidth Latin Small Letter U -> u
 883             (char)0xff56, (char)0x0076,    // Fullwidth Latin Small Letter V -> v
 884             (char)0xff57, (char)0x0077,    // Fullwidth Latin Small Letter W -> w
 885             (char)0xff58, (char)0x0078,    // Fullwidth Latin Small Letter X -> x
 886             (char)0xff59, (char)0x0079,    // Fullwidth Latin Small Letter Y -> y
 887             (char)0xff5a, (char)0x007a,    // Fullwidth Latin Small Letter Z -> z
 888             (char)0xff5b, (char)0x007b,    // Fullwidth Left Curly Bracket -> {
 889             (char)0xff5c, (char)0x007c,    // Fullwidth Vertical Line -> |
 890             (char)0xff5d, (char)0x007d,    // Fullwidth Right Curly Bracket -> }
 891             (char)0xff5e, (char)0x007e     // Fullwidth Tilde -> ~
 892         };
 893     }
 894 }