Inserted string validation as separate task in compiler.

frog/leg/scanner/parser.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.
 
 /**
  * An event generating parser of Dart programs. This parser expects
  * all tokens in a linked list.
  */
 class Parser {
   final Listener listener;
   bool mayParseFunctionExpressions = true;
 
   Parser(Listener this.listener);
 
   void parseUnit(Token token) {
     while (token.kind !== EOF_TOKEN) {
       final String value = token.stringValue;
       if (value === 'interface') {
         token = parseInterface(token);
       } else if ((value === 'abstract') || (value === 'class')) {
         token = parseClass(token);
       } else if (value === 'typedef') {
         token = parseNamedFunctionAlias(token);
       } else if (value === '#') {
         token = parseLibraryTags(token);

[Lasse Reichstein Nielsen, 2012/01/26 12:06:31]

changed LibraryTags to ScriptTags here and in listener.

       } else {
         token = parseTopLevelMember(token);
       }
     }
   }
 
   Token parseInterface(Token token) {
     Token interfaceKeyword = token;
     listener.beginInterface(token);
     token = parseIdentifier(token.next);
@@ skipping 190 matching lines @@
         ++interfacesCount;
       } while (optional(',', token));
     }
     token = parseClassBody(token);
     listener.endClassDeclaration(interfacesCount, begin, extendsKeyword,
                                  implementsKeyword, token);
     return token.next;
   }
 
 
-  Token parseString(Token token) {
+  Token parseStringPart(Token token) {
     if (token.kind === STRING_TOKEN) {
-      listener.handleLiteralString(token);
+      listener.handleStringPart(token);
       return token.next;
     } else {
       return listener.expected('string', token);
     }
   }
 
   Token parseIdentifier(Token token) {
     if (isIdentifier(token)) {
       listener.handleIdentifier(token);
     } else {
@@ skipping 182 matching lines @@
     mayParseFunctionExpressions = old;
     listener.endInitializers(count, begin, token);
     return token;
   }
 
   Token parseLibraryTags(Token token) {
     Token begin = token;
     listener.beginLibraryTag(token);
     token = parseIdentifier(token.next);
     token = expect('(', token);
-    token = parseString(token);
+    token = parseLiteralString(token);
     bool hasPrefix = false;
     if (optional(',', token)) {
       hasPrefix = true;
       token = parseIdentifier(token.next);
       token = expect(':', token);
-      token = parseString(token);
+      token = parseLiteralString(token);
     }
     token = expect(')', token);
     listener.endLibraryTag(hasPrefix, begin, token);
     return expectSemicolon(token);
   }
 
   Token expectSemicolon(Token token) {
     return expect(';', token);
   }
 
@@ skipping 730 matching lines @@
     listener.handleLiteralInt(token);
     return token.next;
   }
 
   Token parseLiteralDouble(Token token) {
     listener.handleLiteralDouble(token);
     return token.next;
   }
 
   Token parseLiteralString(Token token) {
-    listener.handleLiteralString(token);
+    listener.beginLiteralString(token);
     token = token.next;
     int interpolationCount = 0;
     while (optional('\${', token)) {
-      token = parseExpression(token.next);
+      token = token.next;
+      token = parseExpression(token);
       token = expect('}', token);
-      token = parseString(token);
+      token = parseStringPart(token);
       ++interpolationCount;
     }
-    listener.handleStringInterpolationParts(interpolationCount);
+    listener.endLiteralString(interpolationCount);
     return token;
   }
 
   Token parseLiteralBool(Token token) {
     listener.handleLiteralBool(token);
     return token.next;
   }
 
   Token parseLiteralNull(Token token) {
     listener.handleLiteralNull(token);
@@ skipping 373 matching lines @@
     }
     listener.handleContinueStatement(hasTarget, continueKeyword, token);
     return expectSemicolon(token);
   }
 
   Token parseEmptyStatement(Token token) {
     listener.handleEmptyStatement(token);
     return expectSemicolon(token);
   }
 }