Add extra information to FormatException.

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 378 matching lines @@
                              userinfo,
                              host,
                              port,
                              path,
                              query,
                              fragment);
   }
 
   // Report a parse failure.
   static void _fail(String uri, int index, String message) {
-    // TODO(lrn): Consider adding this to FormatException.
-    if (index == uri.length) {
-      message += " at end of input.";
-    } else {
-      message += " at position $index.\n";
-      // Pick a slice of uri containing index and, if
-      // necessary, truncate the ends to ensure the entire
-      // slice fits on one line.
-      int min = 0;
-      int max = uri.length;
-      String pre = "";
-      String post = "";
-      if (uri.length > 78) {
-        min = index - 10;
-        if (min < 0) min = 0;
-        int max = min + 72;
-        if (max > uri.length) {
-          max = uri.length;
-          min = max - 72;
-        }
-        if (min != 0) pre = "...";
-        if (max != uri.length) post = "...";
-      }
-      // Combine message, slice and a caret pointing to the error index.
-      message = "$message$pre${uri.substring(min, max)}$post\n"
-                "${' ' * (pre.length + index - min)}^";
-    }
-    throw new FormatException(message);
+    throw new FormatException(message, uri, index);
   }
 
   /// Internal non-verifying constructor. Only call with validated arguments.
   Uri._internal(this.scheme,
                 this._userInfo,
                 this._host,
                 this._port,
                 this._path,
                 this._query,
                 this._fragment);
@@ skipping 164 matching lines @@
         }
       }
       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;
         }
         if (hostEnd == authority.length) {
-          throw new FormatException("Invalid IPv6 host entry.");
+          throw new FormatException("Invalid IPv6 host entry.",
+                                    authority, hostStart);
         }
         parseIPv6Address(authority, hostStart + 1, hostEnd);
         hostEnd++;  // Skip the closing bracket.
         if (hostEnd != authority.length &&
             authority.codeUnitAt(hostEnd) != _COLON) {
-          throw new FormatException("Invalid end of authority");
+          throw new FormatException("Invalid end of authority",
+                                    authority, hostEnd);
         }
       }
       // Split host and port.
       bool hasPort = false;
       for (; hostEnd < authority.length; hostEnd++) {
         if (authority.codeUnitAt(hostEnd) == _COLON) {
           var portString = authority.substring(hostEnd + 1);
           // We allow the empty port - falling back to initial value.
           if (portString.isNotEmpty) port = int.parse(portString);
           break;
@@ skipping 1176 matching lines @@
    *  * 2010:836B:4179::836B:4179
    */
   static List<int> parseIPv6Address(String host, [int start = 0, int end]) {
     if (end == null) end = host.length;
     // An IPv6 address consists of exactly 8 parts of 1-4 hex digits, seperated
     // by `:`'s, with the following exceptions:
     //
     //  - One (and only one) wildcard (`::`) may be present, representing a fill
     //    of 0's. The IPv6 `::` is thus 16 bytes of `0`.
     //  - The last two parts may be replaced by an IPv4 address.
-    void error(String msg) {
-      throw new FormatException('Illegal IPv6 address, $msg');
+    void error(String msg, [position]) {
+      throw new FormatException('Illegal IPv6 address, $msg', host, position);
     }
     int parseHex(int start, int end) {
       if (end - start > 4) {
-        error('an IPv6 part can only contain a maximum of 4 hex digits');
+        error('an IPv6 part can only contain a maximum of 4 hex digits', start);
       }
       int value = int.parse(host.substring(start, end), radix: 16);
       if (value < 0 || value > (1 << 16) - 1) {
-        error('each part must be in the range of `0x0..0xFFFF`');
+        error('each part must be in the range of `0x0..0xFFFF`', start);
       }
       return value;
     }
     if (host.length < 2) error('address is too short');
     List<int> parts = [];
     bool wildcardSeen = false;
     int partStart = start;
     // Parse all parts, except a potential last one.
     for (int i = start; i < end; i++) {
       if (host.codeUnitAt(i) == _COLON) {
         if (i == start) {
           // If we see a `:` in the beginning, expect wildcard.
           i++;
           if (host.codeUnitAt(i) != _COLON) {
-            error('invalid start colon.');
+            error('invalid start colon.', i);
           }
           partStart = i;
         }
         if (i == partStart) {
           // Wildcard. We only allow one.
           if (wildcardSeen) {
-            error('only one wildcard `::` is allowed');
+            error('only one wildcard `::` is allowed', i);
           }
           wildcardSeen = true;
           parts.add(-1);
         } else {
           // Found a single colon. Parse [partStart..i] as a hex entry.
           parts.add(parseHex(partStart, i));
         }
         partStart = i + 1;
       }
     }
     if (parts.length == 0) error('too few parts');
     bool atEnd = (partStart == end);
     bool isLastWildcard = (parts.last == -1);
     if (atEnd && !isLastWildcard) {
-      error('expected a part after last `:`');
+      error('expected a part after last `:`', end);
     }
     if (!atEnd) {
       try {
         parts.add(parseHex(partStart, end));
       } catch (e) {
         // Failed to parse the last chunk as hex. Try IPv4.
         try {
           List<int> last = parseIPv4Address(host.substring(partStart, end));
           parts.add(last[0] << 8 | last[1]);
           parts.add(last[2] << 8 | last[3]);
         } catch (e) {
-          error('invalid end of IPv6 address.');
+          error('invalid end of IPv6 address.', partStart);
         }
       }
     }
     if (wildcardSeen) {
       if (parts.length > 7) {
         error('an address with a wildcard must have less than 7 parts');
       }
     } else if (parts.length != 8) {
       error('an address without a wildcard must contain exactly 8 parts');
     }
@@ skipping 396 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
 }