Support new library/import syntax

runtime/vm/parser.cc

 // 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.
 
 #include "vm/parser.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 4000 matching lines @@
   AddFormalParamsToFunction(&params, func);
   top_level->functions.Add(func);
   if (!is_patch) {
     library_.AddObject(func, accessor_name);
   } else {
     library_.ReplaceObject(func, accessor_name);
   }
 }
 
 
-void Parser::ParseLibraryName() {
-  TRACE_PARSER("ParseLibraryName");
+// TODO(hausner): Remove support for old library definition syntax.
+void Parser::ParseLibraryNameObsoleteSyntax() {
   if ((script_.kind() == RawScript::kLibraryTag) &&
       (CurrentToken() != Token::kLIBRARY)) {
     // Handle error case early to get consistent error message.
     ExpectToken(Token::kLIBRARY);
   }
   if (CurrentToken() == Token::kLIBRARY) {
     ConsumeToken();
     ExpectToken(Token::kLPAREN);
     if (CurrentToken() != Token::kSTRING) {
       ErrorMsg("library name expected");
@@ skipping 20 matching lines @@
                                Api::NewHandle(isolate, url.raw()));
   if (Dart_IsError(result)) {
     Error& prev_error = Error::Handle();
     prev_error ^= Api::UnwrapHandle(result);
     AppendErrorMsg(prev_error, token_pos, "library handler failed");
   }
   return result;
 }
 
 
-void Parser::ParseLibraryImport() {
-  TRACE_PARSER("ParseLibraryImport");
+// TODO(hausner): Remove support for old library definition syntax.
+void Parser::ParseLibraryImportObsoleteSyntax() {
   while (CurrentToken() == Token::kIMPORT) {
     const intptr_t import_pos = TokenPos();
     ConsumeToken();
     ExpectToken(Token::kLPAREN);
     if (CurrentToken() != Token::kSTRING) {
       ErrorMsg("library url expected");
     }
     const String& url = *CurrentLiteral();
     ConsumeToken();
     String& prefix = String::Handle();
@@ skipping 43 matching lines @@
         library_prefix.AddLibrary(library);
       } else {
         library_prefix = LibraryPrefix::New(prefix, library);
         library_.AddObject(library_prefix, prefix);
       }
     }
   }
 }
 
 
-void Parser::ParseLibraryInclude() {
-  TRACE_PARSER("ParseLibraryInclude");
+// TODO(hausner): Remove support for old library definition syntax.
+void Parser::ParseLibraryIncludeObsoleteSyntax() {
   while (CurrentToken() == Token::kSOURCE) {
     const intptr_t source_pos = TokenPos();
     ConsumeToken();
     ExpectToken(Token::kLPAREN);
     if (CurrentToken() != Token::kSTRING) {
       ErrorMsg("source url expected");
     }
     const String& url = *CurrentLiteral();
     ConsumeToken();
     ExpectToken(Token::kRPAREN);
     ExpectToken(Token::kSEMICOLON);
     Dart_Handle handle = CallLibraryTagHandler(kCanonicalizeUrl,
                                                source_pos,
                                                url);
     const String& canon_url = String::CheckedHandle(Api::UnwrapHandle(handle));
     CallLibraryTagHandler(kSourceTag, source_pos, canon_url);
   }
 }
 
 
-void Parser::ParseLibraryResource() {
-  TRACE_PARSER("ParseLibraryResource");
+// TODO(hausner): Remove support for old library definition syntax.
+void Parser::ParseLibraryResourceObsoleteSyntax() {
   while (CurrentToken() == Token::kRESOURCE) {
     // Currently the VM does ignore #resource library tags. They are only used
     // by the IDE.
     ConsumeToken();
     ExpectToken(Token::kLPAREN);
     if (CurrentToken() != Token::kSTRING) {
       ErrorMsg("resource url expected");
     }
     ConsumeToken();
     ExpectToken(Token::kRPAREN);
     ExpectToken(Token::kSEMICOLON);
   }
 }
 
 
+void Parser::ParseLibraryName() {
+  ASSERT(IsLiteral("library"));
+  ConsumeToken();
+  // TODO(hausner): Exact syntax of library name still unclear: identifier,
+  // qualified identifier or even multiple dots allowed? For now we just
+  // accept simple identifiers.
+  const String& lib_name = *ExpectIdentifier("library name expected");
+  library_.SetName(lib_name);
+  ExpectSemicolon();
+}
+
+
+void Parser::ParseLibraryImportExport() {
+  if (IsLiteral("import")) {
+    const intptr_t import_pos = TokenPos();
+    ConsumeToken();
+    if (CurrentToken() != Token::kSTRING) {
+      ErrorMsg("library url expected");
+    }
+    const String& url = *CurrentLiteral();
+    if (url.Length() == 0) {
+      ErrorMsg("library url expected");
+    }
+    ConsumeToken();
+    String& prefix = String::Handle();
+    if (IsLiteral("as")) {
+      ConsumeToken();
+      prefix = ExpectIdentifier("prefix expected")->raw();
+    }
+    if (IsLiteral("show")) {
+      ErrorMsg("show combinator not yet supported");
+    } else if (IsLiteral("hide")) {
+      ErrorMsg("hide combinator not yet supported");
+    }
+    ExpectSemicolon();
+
+    // Canonicalize library URL.
+    Dart_Handle handle =
+        CallLibraryTagHandler(kCanonicalizeUrl, import_pos, url);
+    const String& canon_url = String::CheckedHandle(Api::UnwrapHandle(handle));
+    // Lookup the library URL.
+    Library& library = Library::Handle(Library::LookupLibrary(canon_url));
+    if (library.IsNull()) {
+      // Call the library tag handler to load the library.
+      CallLibraryTagHandler(kImportTag, import_pos, canon_url);
+      // If the library tag handler succeded without registering the
+      // library we create an empty library to import.
+      library = Library::LookupLibrary(canon_url);
+      if (library.IsNull()) {
+        library = Library::New(canon_url);
+        library.Register();
+      }
+    }
+    // Add the import to the library.
+    if (prefix.IsNull() || (prefix.Length() == 0)) {
+      library_.AddImport(library);
+    } else {
+      LibraryPrefix& library_prefix = LibraryPrefix::Handle();
+      library_prefix = library_.LookupLocalLibraryPrefix(prefix);
+      if (!library_prefix.IsNull()) {
+        library_prefix.AddLibrary(library);
+      } else {
+        library_prefix = LibraryPrefix::New(prefix, library);
+        library_.AddObject(library_prefix, prefix);
+      }
+    }
+  } else if (IsLiteral("export")) {
+    ErrorMsg("export clause not yet supported");
+  } else {
+    ErrorMsg("unreachable");
+    UNREACHABLE();
+  }
+}
+
+
+void Parser::ParseLibraryPart() {
+  ErrorMsg("library part definitions not implemented");
+}
+
+
 void Parser::ParseLibraryDefinition() {
   TRACE_PARSER("ParseLibraryDefinition");
+
   // Handle the script tag.
   if (CurrentToken() == Token::kSCRIPTTAG) {
     // Nothing to do for script tags except to skip them.
     ConsumeToken();
   }
 
-  ParseLibraryName();
-  ParseLibraryImport();
-  ParseLibraryInclude();
-  ParseLibraryResource();
+  // TODO(hausner): Remove support for old library definition syntax.
+  if ((CurrentToken() == Token::kLIBRARY) ||
+      (CurrentToken() == Token::kIMPORT) ||
+      (CurrentToken() == Token::kSOURCE) ||
+      (CurrentToken() == Token::kRESOURCE)) {
+    ParseLibraryNameObsoleteSyntax();
+    ParseLibraryImportObsoleteSyntax();
+    ParseLibraryIncludeObsoleteSyntax();
+    ParseLibraryResourceObsoleteSyntax();
+    return;
+  }
+
+  // We may read metadata tokens that are part of the toplevel
+  // declaration that follows the library definitions. Therefore, we
+  // need to remember the position of the last token that was
+  // successfully consumed.
+  intptr_t metadata_pos = TokenPos();
+  SkipMetadata();
+  if (IsLiteral("library")) {
+    ParseLibraryName();
+    metadata_pos = TokenPos();
+    SkipMetadata();
+  } else if (script_.kind() == RawScript::kLibraryTag) {
+    ErrorMsg("library name definition expected");
+  }
+  while (IsLiteral("import") || IsLiteral("export")) {
+    ParseLibraryImportExport();
+    metadata_pos = TokenPos();
+    SkipMetadata();
+  }
+  while (IsLiteral("part")) {
+    ParseLibraryPart();
+    metadata_pos = TokenPos();
+    SkipMetadata();
+  }
+  if (IsLiteral("library") || IsLiteral("import") || IsLiteral("export")) {
+    ErrorMsg("unexpected token '%s'", CurrentLiteral()->ToCString());
+  }
+  SetPosition(metadata_pos);
 }
 
 
 void Parser::ParseTopLevel() {
   TRACE_PARSER("ParseTopLevel");
   // Collect the classes found at the top level in this growable array.
   // They need to be registered with class finalization after parsing
   // has been completed.
   Isolate* isolate = Isolate::Current();
   ObjectStore* object_store = isolate->object_store();
@@ skipping 5254 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart