Making Unicode character names consistent

Source/wtf/unicode/UTF8.cpp

 /*
  * Copyright (C) 2007 Apple Inc.  All rights reserved.
  * Copyright (C) 2010 Patrick Gansterer <paroga@paroga.com>
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 135 matching lines @@
         if (ch < (UChar32)0x80) {
             bytesToWrite = 1;
         } else if (ch < (UChar32)0x800) {
             bytesToWrite = 2;
         } else if (ch < (UChar32)0x10000) {
             bytesToWrite = 3;
         } else if (ch < (UChar32)0x110000) {
             bytesToWrite = 4;
         } else {
             bytesToWrite = 3;
-            ch = replacementCharacter;
+            ch = characterReplacement;
         }
 
         target += bytesToWrite;
         if (target > targetEnd) {
             source = oldSource; // Back up source pointer!
             target -= bytesToWrite;
             result = targetExhausted;
             break;
         }
         switch (bytesToWrite) { // note: everything falls through.
@@ skipping 90 matching lines @@
         }
 
         if (U_IS_BMP(character)) {
             // UTF-16 surrogate values are illegal in UTF-32
             if (U_IS_SURROGATE(character)) {
                 if (strict) {
                     source -= utf8SequenceLength; // return to the illegal value itself
                     result = sourceIllegal;
                     break;
                 } else {
-                    *target++ = replacementCharacter;
-                    orAllData |= replacementCharacter;
+                    *target++ = characterReplacement;
+                    orAllData |= characterReplacement;
                 }
             } else {
                 *target++ = static_cast<UChar>(character); // normal case
                 orAllData |= character;
             }
         } else if (U_IS_SUPPLEMENTARY(character)) {
             // target is a character in range 0xFFFF - 0x10FFFF
             if (target + 1 >= targetEnd) {
                 source -= utf8SequenceLength; // Back up source pointer!
                 result = targetExhausted;
                 break;
             }
             *target++ = U16_LEAD(character);
             *target++ = U16_TRAIL(character);
             orAllData = 0xffff;
         } else {
             if (strict) {
                 source -= utf8SequenceLength; // return to the start
                 result = sourceIllegal;
                 break; // Bail out; shouldn't continue
             } else {
-                *target++ = replacementCharacter;
-                orAllData |= replacementCharacter;
+                *target++ = characterReplacement;
+                orAllData |= characterReplacement;
             }
         }
     }
     *sourceStart = source;
     *targetStart = target;
 
     if (sourceAllASCII)
         *sourceAllASCII = !(orAllData & ~0x7f);
 
     return result;
@@ skipping 94 matching lines @@
     return equalWithUTF8Internal(a, aEnd, b, bEnd);
 }
 
 bool equalLatin1WithUTF8(const LChar* a, const LChar* aEnd, const char* b, const char* bEnd)
 {
     return equalWithUTF8Internal(a, aEnd, b, bEnd);
 }
 
 } // namespace Unicode
 } // namespace WTF