Add start/end to Uri.parse, allowing you to parse a substring without creating a new String object.

sdk/lib/core/uri.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.
 
 part of dart.core;
 
 /**
  * A parsed URI, such as a URL.
  *
  * **See also:**
@@ skipping 128 matching lines @@
   List<String> _pathSegments;
 
   /**
    * Cache the computed return value of [queryParameters].
    */
   Map<String, String> _queryParameters;
 
   /**
    * Creates a new `Uri` object by parsing a URI string.
    *
+   * If [start] and [end] are provided, only the substring from `start`
+   * to `end` is parsed as a URI.
+   *
    * If the string is not valid as a URI or URI reference,
    * invalid characters will be percent escaped where possible.
    * The resulting `Uri` will represent a valid URI or URI reference.
    */
-  static Uri parse(String uri) {
+  static Uri parse(String uri, [int start = 0, int end]) {
     // This parsing will not validate percent-encoding, IPv6, etc. When done
     // it will call `new Uri(...)` which will perform these validations.
     // This is purely splitting up the URI string into components.
     //
     // Important parts of the RFC 3986 used here:
     // URI           = scheme ":" hier-part [ "?" query ] [ "#" fragment ]
     //
     // hier-part     = "//" authority path-abempty
     //               / path-absolute
     //               / path-rootless
@@ skipping 45 matching lines @@
     }
     const int EOI = -1;
 
     String scheme = "";
     String userinfo = "";
     String host = null;
     int port = null;
     String path = null;
     String query = null;
     String fragment = null;
+    if (end == null) end = uri.length;
 
-    int index = 0;
-    int pathStart = 0;
+    int index = start;
+    int pathStart = start;
     // End of input-marker.
     int char = EOI;
 
     void parseAuth() {
-      if (index == uri.length) {
+      if (index == end) {
         char = EOI;
         return;
       }
       int authStart = index;
       int lastColon = -1;
       int lastAt = -1;
       char = uri.codeUnitAt(index);
-      while (index < uri.length) {
+      while (index < end) {
         char = uri.codeUnitAt(index);
         if (char == _SLASH || char == _QUESTION || char == _NUMBER_SIGN) {
           break;
         }
         if (char == _AT_SIGN) {
           lastAt = index;
           lastColon = -1;
         } else if (char == _COLON) {
           lastColon = index;
         } else if (char == _LEFT_BRACKET) {
           lastColon = -1;
           int endBracket = uri.indexOf(']', index + 1);
           if (endBracket == -1) {
-            index = uri.length;
+            index = end;
             char = EOI;
             break;
           } else {
             index = endBracket;
           }
         }
         index++;
         char = EOI;
       }
       int hostStart = authStart;
@@ skipping 11 matching lines @@
             if (_ZERO > digit || _NINE < digit) {
               _fail(uri, i, "Invalid port number");
             }
             portNumber = portNumber * 10 + (digit - _ZERO);
           }
         }
         port = _makePort(portNumber, scheme);
         hostEnd = lastColon;
       }
       host = _makeHost(uri, hostStart, hostEnd, true);
-      if (index < uri.length) {
+      if (index < end) {
         char = uri.codeUnitAt(index);
       }
     }
 
     // When reaching path parsing, the current character is known to not
     // be part of the path.
     const int NOT_IN_PATH = 0;
     // When reaching path parsing, the current character is part
     // of the a non-empty path.
     const int IN_PATH = 1;
     // When reaching authority parsing, authority is possible.
     // This is only true at start or right after scheme.
     const int ALLOW_AUTH = 2;
 
     // Current state.
     // Initialized to the default value that is used when exiting the
     // scheme loop by reaching the end of input.
     // All other breaks set their own state.
     int state = NOT_IN_PATH;
     int i = index;  // Temporary alias for index to avoid bug 19550 in dart2js.
-    while (i < uri.length) {
+    while (i < end) {
       char = uri.codeUnitAt(i);
       if (char == _QUESTION || char == _NUMBER_SIGN) {
         state = NOT_IN_PATH;
         break;
       }
       if (char == _SLASH) {
-        state = (i == 0) ? ALLOW_AUTH : IN_PATH;
+        state = (i == start) ? ALLOW_AUTH : IN_PATH;
         break;
       }
       if (char == _COLON) {
-        if (i == 0) _fail(uri, 0, "Invalid empty scheme");
-        scheme = _makeScheme(uri, i);
+        if (i == start) _fail(uri, start, "Invalid empty scheme");
+        scheme = _makeScheme(uri, start, i);
         i++;
         pathStart = i;
-        if (i == uri.length) {
+        if (i == end) {
           char = EOI;
           state = NOT_IN_PATH;
         } else {
           char = uri.codeUnitAt(i);
           if (char == _QUESTION || char == _NUMBER_SIGN) {
             state = NOT_IN_PATH;
           } else if (char == _SLASH) {
             state = ALLOW_AUTH;
           } else {
             state = IN_PATH;
           }
         }
         break;
       }
       i++;
       char = EOI;
     }
     index = i;  // Remove alias when bug is fixed.
 
     if (state == ALLOW_AUTH) {
       assert(char == _SLASH);
       // Have seen one slash either at start or right after scheme.
       // If two slashes, it's an authority, otherwise it's just the path.
       index++;
-      if (index == uri.length) {
+      if (index == end) {
         char = EOI;
         state = NOT_IN_PATH;
       } else {
         char = uri.codeUnitAt(index);
         if (char == _SLASH) {
           index++;
           parseAuth();
           pathStart = index;
         }
         if (char == _QUESTION || char == _NUMBER_SIGN || char == EOI) {
           state = NOT_IN_PATH;
         } else {
           state = IN_PATH;
         }
       }
     }
 
     assert(state == IN_PATH || state == NOT_IN_PATH);
     if (state == IN_PATH) {
       // Characters from pathStart to index (inclusive) are known
       // to be part of the path.
-      while (++index < uri.length) {
+      while (++index < end) {
         char = uri.codeUnitAt(index);
         if (char == _QUESTION || char == _NUMBER_SIGN) {
           break;
         }
         char = EOI;
       }
       state = NOT_IN_PATH;
     }
 
     assert(state == NOT_IN_PATH);
     bool isFile = (scheme == "file");
     bool ensureLeadingSlash = host != null;
     path = _makePath(uri, pathStart, index, null, ensureLeadingSlash, isFile);
 
     if (char == _QUESTION) {
-      int numberSignIndex = uri.indexOf('#', index + 1);

[Søren Gjesse, 2015/04/09 07:04:42]

We could add an optional end to indexOf as well...

[Lasse Reichstein Nielsen, 2015/04/09 07:52:03]

I actually thought about that, but it doesn't work very well with the Pattern
class. The only method there is allMatches which only has a start, not an end. 

If we could add "end" to Pattern.allMatches, then it would be great then we can
also add "end" to String.indexOf (and probably more), but I guess that's one of
those "potentially future backwards incompatible changes".

+      int numberSignIndex = -1;
+      for (int i = index + 1; i < end; i++) {
+        if (uri.codeUnitAt(i) == _NUMBER_SIGN) {
+          numberSignIndex = i;
+          break;
+        }
+      }
       if (numberSignIndex < 0) {
-        query = _makeQuery(uri, index + 1, uri.length, null);
+        query = _makeQuery(uri, index + 1, end, null);
       } else {
         query = _makeQuery(uri, index + 1, numberSignIndex, null);
-        fragment = _makeFragment(uri, numberSignIndex + 1, uri.length);
+        fragment = _makeFragment(uri, numberSignIndex + 1, end);
       }
     } else if (char == _NUMBER_SIGN) {
-      fragment = _makeFragment(uri, index + 1, uri.length);
+      fragment = _makeFragment(uri, index + 1, end);
     }
     return new Uri._internal(scheme,
                              userinfo,
                              host,
                              port,
                              path,
                              query,
                              fragment);
   }
 
@@ skipping 77 matching lines @@
    */
   factory Uri({String scheme : "",
                String userInfo : "",
                String host,
                int port,
                String path,
                Iterable<String> pathSegments,
                String query,
                Map<String, String> queryParameters,
                String fragment}) {
-    scheme = _makeScheme(scheme, _stringOrNullLength(scheme));
+    scheme = _makeScheme(scheme, 0, _stringOrNullLength(scheme));
     userInfo = _makeUserInfo(userInfo, 0, _stringOrNullLength(userInfo));
     host = _makeHost(host, 0, _stringOrNullLength(host), false);
     // Special case this constructor for backwards compatibility.
     if (query == "") query = null;
     query = _makeQuery(query, 0, _stringOrNullLength(query), queryParameters);
     fragment = _makeFragment(fragment, 0, _stringOrNullLength(fragment));
     port = _makePort(port, scheme);
     bool isFile = (scheme == "file");
     if (host == null &&
         (userInfo.isNotEmpty || port != null || isFile)) {
@@ skipping 65 matching lines @@
     var host = null;
     var port = null;
 
     if (authority != null && authority.isNotEmpty) {
       var hostStart = 0;
       // Split off the user info.
       bool hasUserInfo = false;
       for (int i = 0; i < authority.length; i++) {
         if (authority.codeUnitAt(i) == _AT_SIGN) {
           hasUserInfo = true;
-          userInfo = authority.substring(0, i);
+          userInfo = authority.substring(start, i);
           hostStart = i + 1;
           break;
         }
       }
       var hostEnd = hostStart;
       if (hostStart < authority.length &&
           authority.codeUnitAt(hostStart) == _LEFT_BRACKET) {
         // IPv6 host.
         for (; hostEnd < authority.length; hostEnd++) {
           if (authority.codeUnitAt(hostEnd) == _RIGHT_BRACKET) break;
@@ skipping 283 matching lines @@
                String path,
                Iterable<String> pathSegments,
                String query,
                Map<String, String> queryParameters,
                String fragment}) {
     // Set to true if the scheme has (potentially) changed.
     // In that case, the default port may also have changed and we need
     // to check even the existing port.
     bool schemeChanged = false;
     if (scheme != null) {
-      scheme = _makeScheme(scheme, scheme.length);
+      scheme = _makeScheme(scheme, 0, scheme.length);
       schemeChanged = true;
     } else {
       scheme = this.scheme;
     }
     bool isFile = (scheme == "file");
     if (userInfo != null) {
       userInfo = _makeUserInfo(userInfo, 0, userInfo.length);
     } else {
       userInfo = this.userInfo;
     }
@@ skipping 207 matching lines @@
       buffer.write(slice);
     }
     return buffer.toString();
   }
 
   /**
    * Validates scheme characters and does case-normalization.
    *
    * Schemes are converted to lower case. They cannot contain escapes.
    */
-  static String _makeScheme(String scheme, int end) {
-    if (end == 0) return "";
-    final int firstCodeUnit = scheme.codeUnitAt(0);
+  static String _makeScheme(String scheme, int start, int end) {
+    if (start == end) return "";
+    final int firstCodeUnit = scheme.codeUnitAt(start);
     if (!_isAlphabeticCharacter(firstCodeUnit)) {
-      _fail(scheme, 0, "Scheme not starting with alphabetic character");
+      _fail(scheme, start, "Scheme not starting with alphabetic character");
     }
     bool allLowercase = firstCodeUnit >= _LOWER_CASE_A;
-    for (int i = 0; i < end; i++) {
+    for (int i = start; i < end; i++) {
       final int codeUnit = scheme.codeUnitAt(i);
       if (!_isSchemeCharacter(codeUnit)) {
         _fail(scheme, i, "Illegal scheme character");
       }
       if (codeUnit < _LOWER_CASE_A || codeUnit > _LOWER_CASE_Z) {
         allLowercase = false;
       }
     }
-    scheme = scheme.substring(0, end);
+    scheme = scheme.substring(start, end);
     if (!allLowercase) scheme = scheme.toLowerCase();
     return scheme;
   }
 
   static String _makeUserInfo(String userInfo, int start, int end) {
     if (userInfo == null) return "";
     return _normalize(userInfo, start, end, _userinfoTable);
   }
 
   static String _makePath(String path, int start, int end,
@@ skipping 1268 matching lines @@
       0xafff,   // 0x30 - 0x3f  1111111111110101
                 //              @ABCDEFGHIJKLMNO
       0xffff,   // 0x40 - 0x4f  1111111111111111
                 //              PQRSTUVWXYZ    _
       0x87ff,   // 0x50 - 0x5f  1111111111100001
                 //               abcdefghijklmno
       0xfffe,   // 0x60 - 0x6f  0111111111111111
                 //              pqrstuvwxyz   ~
       0x47ff];  // 0x70 - 0x7f  1111111111100010
 }