Revert "Add some support for the code-point code-unit distinction."

runtime/lib/string_base.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 /**
  * [_StringBase] contains common methods used by concrete String
  * implementations, e.g., _OneByteString.
  */
 class _StringBase {
 
   factory _StringBase._uninstantiable() {
     throw new UnsupportedError(
         "_StringBase can't be instaniated");
   }
 
   int get hashCode native "String_getHashCode";
 
   /**
-   * Create the most efficient string representation for the specified UTF-16
-   * [codeUnits].
+   *  Create the most efficient string representation for specified
+   *  [codePoints].
    */
-  static String createFromUtf16(List<int> codeUnits) {
+  static String createFromCharCodes(List<int> charCodes) {
     _ObjectArray objectArray;
-    if (codeUnits is _ObjectArray) {
-      objectArray = codeUnits;
+    if (charCodes is _ObjectArray) {
+      objectArray = charCodes;
     } else {
-      int len = codeUnits.length;
+      int len = charCodes.length;
       objectArray = new _ObjectArray(len);
       for (int i = 0; i < len; i++) {
-        objectArray[i] = codeUnits[i];
+        objectArray[i] = charCodes[i];
       }
     }
-    return _createFromUtf16(objectArray);
+    return _createFromCodePoints(objectArray);
   }
 
-  static String _createFromUtf16(List<int> codeUnits)
-      native "StringBase_createFromUtf16";
+  static String _createFromCodePoints(List<int> codePoints)
+      native "StringBase_createFromCodePoints";
 
   String operator [](int index) native "String_charAt";
 
-  int codeUnitAt(int index) native "String_codeUnitAt";
+  int charCodeAt(int index) native "String_charCodeAt";
 
   int get length native "String_getLength";
 
   bool get isEmpty {
     return this.length == 0;
   }
 
   String concat(String other) native "String_concat";
 
   String toString() {
@@ skipping 10 matching lines @@
       return false;
     }
     return this.compareTo(other) == 0;
   }
 
   int compareTo(String other) {
     int thisLength = this.length;
     int otherLength = other.length;
     int len = (thisLength < otherLength) ? thisLength : otherLength;
     for (int i = 0; i < len; i++) {
-      int thisCodeUnit = this.codeUnitAt(i);
-      int otherCodeUnit = other.codeUnitAt(i);
-      if (thisCodeUnit < otherCodeUnit) {
+      int thisCodePoint = this.charCodeAt(i);
+      int otherCodePoint = other.charCodeAt(i);
+      if (thisCodePoint < otherCodePoint) {
         return -1;
       }
-      if (thisCodeUnit > otherCodeUnit) {
+      if (thisCodePoint > otherCodePoint) {
         return 1;
       }
     }
     if (thisLength < otherLength) return -1;
     if (thisLength > otherLength) return 1;
     return 0;
   }
 
   bool _substringMatches(int start, String other) {
     if (other.isEmpty) return true;
     if ((start < 0) || (start >= this.length)) {
       return false;
     }
     final int len = other.length;
     if ((start + len) > this.length) {
       return false;
     }
     for (int i = 0; i < len; i++) {
-      if (this.codeUnitAt(i + start) != other.codeUnitAt(i)) {
+      if (this.charCodeAt(i + start) != other.charCodeAt(i)) {
         return false;
       }
     }
     return true;
   }
 
   bool endsWith(String other) {
     return _substringMatches(this.length - other.length, other);
   }
 
@@ skipping 48 matching lines @@
     return _substringUnchecked(startIndex, endIndex);
   }
 
   String _substringUnchecked(int startIndex, int endIndex)
       native "StringBase_substringUnchecked";
 
   String trim() {
     final int len = this.length;
     int first = 0;
     for (; first < len; first++) {
-      // There are no whitespace characters that are outside the BMP so we
-      // can use code units here for efficiency.
-      if (!_isWhitespace(this.codeUnitAt(first))) {
+      if (!_isWhitespace(this.charCodeAt(first))) {
         break;
       }
     }
     if (len == first) {
       // String contains only whitespaces.
       return "";
     }
     int last = len - 1;
     for (; last >= first; last--) {
-      if (!_isWhitespace(this.codeUnitAt(last))) {
+      if (!_isWhitespace(this.charCodeAt(last))) {
         break;
       }
     }
     if ((first == 0) && (last == (len - 1))) {
       // Returns this string if it does not have leading or trailing
       // whitespaces.
       return this;
     } else {
       return _substringUnchecked(first, last + 1);
     }
@@ skipping 100 matching lines @@
       if (startIndex == endIndex && endIndex == previousIndex) {
         ++startIndex;  // empty match, advance and restart
         continue;
       }
       result.add(this.substring(previousIndex, match.start));
       startIndex = previousIndex = endIndex;
     }
     return result;
   }
 
-  // TODO(erikcorry): Fix this to use the new code point iterator when it is
-  // available.
   List<String> splitChars() {
     int len = this.length;
     final result = new List<String>(len);
-    bool supplementaryCharacterSeen = false;
-    int i, j;
-    for (i = j = 0; i < len; i++, j++) {
-      int c = charCodeAt(i);
-      // Check for non-basic plane character encoded as a UTF-16 surrogate pair.
-      if (c >= String.SUPPLEMENTARY_CODE_POINT_BASE) {
-        i++;
-        supplementaryCharacterSeen = true;
-      }
-      result[j] = new String.fromCharCodes([c]);
+    for (int i = 0; i < len; i++) {
+      result[i] = this[i];
     }
-    if (!supplementaryCharacterSeen) return result;
-    // If we saw some non-basic plane characters, then we have to return a
-    // slightly smaller array than expected (we can't trim the original one
-    // because it is non-extendable).  This rarely happens so this is preferable
-    // to having a separate pass over the string to count the code points.
-    return result.getRange(0, j);
+    return result;
   }
 
-  List<int> get codeUnits {
+  List<int> get charCodes {
     int len = this.length;
     final result = new List<int>(len);
     for (int i = 0; i < len; i++) {
-      result[i] = this.codeUnitAt(i);
+      result[i] = this.charCodeAt(i);
     }
     return result;
   }
 
   String toUpperCase() native "String_toUpperCase";
 
   String toLowerCase() native "String_toLowerCase";
 
   // Implementations of Strings methods follow below.
   static String join(List<String> strings, String separator) {
@@ skipping 33 matching lines @@
       native "Strings_concatAll";
 }
 
 
 class _OneByteString extends _StringBase implements String {
   factory _OneByteString._uninstantiable() {
     throw new UnsupportedError(
         "_OneByteString can only be allocated by the VM");
   }
 
+  // Checks for one-byte whitespaces only.
+  // TODO(srdjan): Investigate if 0x85 (NEL) and 0xA0 (NBSP) are valid
+  // whitespaces for one byte strings.
   bool _isWhitespace(int codePoint) {
     return
-      (codePoint == 32) ||  // Space.
-      (codePoint == 0xa0) ||  // No-break space.
+      (codePoint == 32) || // Space.
       ((9 <= codePoint) && (codePoint <= 13)); // CR, LF, TAB, etc.
   }
 
-  int charCodeAt(int index) => codeUnitAt(index);
-
-  List<int> get charCodes => codeUnits;
 }
 
 
-class _TwoByteStringBase extends _StringBase {
-  factory _TwoByteStringBase._uninstantiable() {
+class _TwoByteString extends _StringBase implements String {
+  factory _TwoByteString._uninstantiable() {
     throw new UnsupportedError(
-        "_TwoByteStringBase can't be instaniated");
+        "_TwoByteString can only be allocated by the VM");
   }
 
-  // Works for both code points and code units since all spaces are in the BMP.
+  // Checks for one-byte whitespaces only.
+  // TODO(srdjan): Investigate if 0x85 (NEL) and 0xA0 (NBSP) are valid
+  // whitespaces. Add checking for multi-byte whitespace codepoints.
   bool _isWhitespace(int codePoint) {
     return
-      (codePoint == 32) ||  // Space.
-      (codePoint == 0xa0) ||  // No-break space.
-      ((9 <= codePoint) && (codePoint <= 13)) ||  // CR, LF, TAB, etc.
-      (codePoint >= 0x1680 &&  // Optimization.
-       (codePoint == 0x1680 ||  // Ogham space mark.
-        codePoint == 0x180e ||  // Mongolian vowel separator.
-        (codePoint >= 0x2000 && codePoint <= 0x200a) ||  // Wide/narrow spaces.
-        codePoint == 0x2028 ||  // Line separator.
-        codePoint == 0x2029 ||  // Paragraph separator.
-        codePoint == 0x202f ||  // Narrow no-break space.
-        codePoint == 0x205f ||  // Medium mathematical space.
-        codePoint == 0x3000 ||  // Ideographic space.
-        codePoint == 0xfeff));  // BOM code.
-  }
-
-  int charCodeAt(int index) {
-    const int LEAD_SURROGATE_BASE = 0xd800;
-    const int LEAD_SURROGATE_END = 0xdbff;
-    const int TRAIL_SURROGATE_BASE = 0xdc00;
-    const int TRAIL_SURROGATE_END = 0xdfff;
-    const int MASK = 0x3ff;
-    int code = codeUnitAt(index);
-    if (code < LEAD_SURROGATE_BASE || code > LEAD_SURROGATE_END) return code;
-    if (index + 1 >= length) return code;
-    int trail = codeUnitAt(index + 1);
-    if (trail < TRAIL_SURROGATE_BASE || trail > TRAIL_SURROGATE_END) {
-      return code;
-    }
-    return String.SUPPLEMENTARY_CODE_POINT_BASE +
-        ((code & MASK) << 10) + (trail & MASK);
-  }
-
-  // TODO(erikcorry): Fix this to use the new code point iterator when it is
-  // available.
-  List<int> get charCodes {
-    int len = this.length;
-    final result = new List<int>(len);
-    bool supplementaryCharacterSeen = false;
-    int i, j;
-    for (i = j = 0; i < len; i++, j++) {
-      int c = this.charCodeAt(i);
-      // Check for supplementary plane character encoded as a UTF-16 surrogate
-      // pair.
-      if (c >= String.SUPPLEMENTARY_CODE_POINT_BASE) {
-        i++;
-        supplementaryCharacterSeen = true;
-      }
-      result[j] = c;
-    }
-    if (!supplementaryCharacterSeen) return result;
-    // If we saw some non-basic plane characters, then we have to return a
-    // slightly smaller array than expected (we can't trim the original one
-    // because it is non-extendable).  This rarely happens so this is preferable
-    // to having a separate pass over the string to count the code points.
-    return result.getRange(0, j);
+      (codePoint == 32) || // Space.
+      ((9 <= codePoint) && (codePoint <= 13)); // CR, LF, TAB, etc.
   }
 }
 
 
-class _TwoByteString extends _TwoByteStringBase implements String {
-  factory _TwoByteString._uninstantiable() {
+class _FourByteString extends _StringBase implements String {
+  factory _FourByteString._uninstantiable() {
     throw new UnsupportedError(
-        "_TwoByteString can only be allocated by the VM");
+        "_FourByteString can only be allocated by the VM");
+  }
+
+  // Checks for one-byte whitespaces only.
+  // TODO(srdjan): Investigate if 0x85 (NEL) and 0xA0 (NBSP) are valid
+  // whitespaces. Add checking for multi-byte whitespace codepoints.
+  bool _isWhitespace(int codePoint) {
+    return
+      (codePoint == 32) || // Space.
+      ((9 <= codePoint) && (codePoint <= 13)); // CR, LF, TAB, etc.
   }
 }
 
 
 class _ExternalOneByteString extends _StringBase implements String {
   factory _ExternalOneByteString._uninstantiable() {
     throw new UnsupportedError(
         "_ExternalOneByteString can only be allocated by the VM");
   }
 
+  // Checks for one-byte whitespaces only.
+  // TODO(srdjan): Investigate if 0x85 (NEL) and 0xA0 (NBSP) are valid
+  // whitespaces for one byte strings.
   bool _isWhitespace(int codePoint) {
     return
-      (codePoint == 32) ||  // Space.
-      (codePoint == 0xa0) ||  // No-break space.
+      (codePoint == 32) || // Space.
       ((9 <= codePoint) && (codePoint <= 13)); // CR, LF, TAB, etc.
   }
-
-  int charCodeAt(int index) => codeUnitAt(index);
-
-  List<int> get charCodes => codeUnits;
 }
 
 
-class _ExternalTwoByteString extends _TwoByteStringBase implements String {
+class _ExternalTwoByteString extends _StringBase implements String {
   factory _ExternalTwoByteString._uninstantiable() {
     throw new UnsupportedError(
         "_ExternalTwoByteString can only be allocated by the VM");
   }
+
+  // Checks for one-byte whitespaces only.
+  // TODO(srdjan): Investigate if 0x85 (NEL) and 0xA0 (NBSP) are valid
+  // whitespaces. Add checking for multi-byte whitespace codepoints.
+  bool _isWhitespace(int codePoint) {
+    return
+      (codePoint == 32) || // Space.
+      ((9 <= codePoint) && (codePoint <= 13)); // CR, LF, TAB, etc.
+  }
 }
 
 
+class _ExternalFourByteString extends _StringBase implements String {
+  factory _ExternalFourByteString._uninstantiable() {
+    throw new UnsupportedError(
+        "ExternalFourByteString can only be allocated by the VM");
+  }
+
+  // Checks for one-byte whitespaces only.
+  // TODO(srdjan): Investigate if 0x85 (NEL) and 0xA0 (NBSP) are valid
+  // whitespaces. Add checking for multi-byte whitespace codepoints.
+  bool _isWhitespace(int codePoint) {
+    return
+      (codePoint == 32) || // Space.
+      ((9 <= codePoint) && (codePoint <= 13)); // CR, LF, TAB, etc.
+  }
+}
+
+
 class _StringMatch implements Match {
   const _StringMatch(int this.start,
                      String this.str,
                      String this.pattern);
 
   int get end => start + pattern.length;
   String operator[](int g) => group(g);
   int get groupCount => 0;
 
   String group(int group) {
     if (group != 0) {
       throw new RangeError.value(group);
     }
     return pattern;
   }
 
   List<String> groups(List<int> groups) {
     List<String> result = new List<String>();
     for (int g in groups) {
       result.add(group(g));
     }
     return result;
   }
 
   final int start;
   final String str;
   final String pattern;
 }