Diagnose unterminated "grouping" characters.

dart/frog/leg/scanner/scanner.dart

 // Copyright (c) 2011, 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.
 
 interface Scanner {
   Token tokenize();
 }
 
 /**
  * Common base class for a Dart scanner.
@@ skipping 184 matching lines @@
     // TODO(ahe): Would a range check be faster?
     if (next === $1 || next === $2 || next === $3 || next === $4 ||  next === $5
         || next === $6 || next === $7 || next === $8 || next === $9) {
       return tokenizeNumber(next);
     }
 
     if (next === $EOF) {
       return $EOF;
     }
     if (next < 0x1f) {
-      throw new MalformedInputException(charOffset);
+      throw new MalformedInputException("illegal character $next", charOffset);
     }
     // Non-ascii identifier.
     return tokenizeIdentifier(next, byteOffset, true);
   }
 
   int tokenizeTag(int next) {
     // # or #!.*[\n\r]
     if (byteOffset === 0) {
       if (peek() === $BANG) {
         do {
@@ skipping 201 matching lines @@
     int start = byteOffset - 1;
     bool hasDigits = false;
     while (true) {
       next = advance();
       if (($0 <= next && next <= $9)
           || ($A <= next && next <= $F)
           || ($a <= next && next <= $f)) {
         hasDigits = true;
       } else {
         if (!hasDigits) {
-          throw new MalformedInputException(charOffset);
+          throw new MalformedInputException("hex digit expected", charOffset);
         }
         appendByteStringToken(HEXADECIMAL_INFO, asciiString(start, 0));
         return next;
       }
     }
   }
 
   int tokenizeDotOrNumber(int next) {
     int start = byteOffset;
     next = advance();
@@ skipping 40 matching lines @@
   int tokenizeExponent(int next) {
     if (next === $PLUS || next === $MINUS) {
       next = advance();
     }
     bool hasDigits = false;
     while (true) {
       if ($0 <= next && next <= $9) {
         hasDigits = true;
       } else {
         if (!hasDigits) {
-          throw new MalformedInputException(charOffset);
+          throw new MalformedInputException("digit expected", charOffset);
         }
         return next;
       }
       next = advance();
     }
   }
 
   int tokenizeSlashOrComment(int next) {
     next = advance();
     if ($STAR === next) {
@@ skipping 98 matching lines @@
       }
     }
   }
 
   int tokenizeRawString(int next) {
     int start = byteOffset;
     next = advance();
     if (next === $DQ || next === $SQ) {
       return tokenizeString(next, start, true);
     } else {
-      throw new MalformedInputException(charOffset);
+      throw new MalformedInputException("expected ' or \"", charOffset);
     }
   }
 
   int tokenizeString(int next, int start, bool raw) {
     int q = next;
     next = advance();
     if (q === next) {
       next = advance();
       if (q === next) {
         // Multiline string.
@@ skipping 18 matching lines @@
   }
 
   int tokenizeSingleLineString(int next, int q1, int start) {
     while (next !== $EOF) {
       if (next === q1) {
         appendByteStringToken(STRING_INFO, utf8String(start, 0));
         return advance();
       } else if (next === $BACKSLASH) {
         next = advance();
         if (next === $EOF) {
-          throw new MalformedInputException(charOffset);
+          throw new MalformedInputException("unterminated string literal",
+                                            charOffset);
         }
       } else if (next === $$) {
         beginToken();
         next = advance();
         if (next === $OPEN_CURLY_BRACKET) {
           next = tokenizeInterpolatedExpression(next, start);
         } else {
           next = tokenizeInterpolatedIdentifier(next, start);
         }
         start = byteOffset;
         continue;
       } else if (next === $LF || next === $CR) {
-        throw new MalformedInputException(charOffset);
+        throw new MalformedInputException("unterminated string literal",
+                                          charOffset);
       }
       next = advance();
     }
-    throw new MalformedInputException(charOffset);
+    throw new MalformedInputException("unterminated string literal",
+                                      charOffset);
   }
 
   int tokenizeInterpolatedExpression(int next, int start) {
     appendByteStringToken(STRING_INFO, utf8String(start, -2));
     appendBeginGroup(STRING_INTERPOLATION_INFO, "\${");
     next = advance();
     while (next !== $EOF && next !== $STX) {
       next = bigSwitch(next);
     }
     if (next === $EOF) return next;
     return advance();
   }
 
   int tokenizeInterpolatedIdentifier(int next, int start) {
     appendByteStringToken(STRING_INFO, utf8String(start, -2));
     appendBeginGroup(STRING_INTERPOLATION_INFO, "\${");
     next = tokenizeKeywordOrIdentifier(next, false);
     appendEndGroup(CLOSE_CURLY_BRACKET_INFO, "}", OPEN_CURLY_BRACKET_TOKEN);
     return next;
   }
 
   int tokenizeSingleLineRawString(int next, int q1, int start) {
     next = advance();
     while (next != $EOF) {
       if (next === q1) {
         appendByteStringToken(STRING_INFO, utf8String(start, 0));
         return advance();
       } else if (next === $LF || next === $CR) {
-        throw new MalformedInputException(charOffset);
+        throw new MalformedInputException("unterminated string literal",
+                                          charOffset);
       }
       next = advance();
     }
-    throw new MalformedInputException(charOffset);
+    throw new MalformedInputException("unterminated string literal",
+                                      charOffset);
   }
 
   int tokenizeMultiLineString(int q, int start, bool raw) {
     // TODO(ahe): Handle escapes.
     // TODO(ahe): Handle string interpolation.
     int next = advance();
     while (next != $EOF) {
       if (next === q) {
         next = advance();
         if (next === q) {
           next = advance();
           if (next === q) {
             appendByteStringToken(STRING_INFO, utf8String(start, 0));
             return advance();
           }
         }
       }
       next = advance();
     }
     return next;
   }
 }
 
 class MalformedInputException {
-  final message;
-  MalformedInputException(this.message);
-  toString() => message.toString();
+  final String message;
+  final position;
+  MalformedInputException(this.message, this.position);
+  toString() => message;
 }