| // Copyright (c) 2014, 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. |
| |
| // This code was auto-generated, is not intended to be edited, and is subject to |
| // significant change. Please see the README file for more information. |
| |
| library engine.sdk.io; |
| |
| import 'dart:io'; |
| |
| import 'package:analyzer/src/generated/java_engine.dart'; |
| |
| import 'ast.dart'; |
| import 'engine.dart'; |
| import 'error.dart'; |
| import 'java_core.dart'; |
| import 'java_engine_io.dart'; |
| import 'java_io.dart'; |
| import 'parser.dart'; |
| import 'scanner.dart'; |
| import 'sdk.dart'; |
| import 'source_io.dart'; |
| |
| /** |
| * A Dart SDK installed in a specified directory. Typical Dart SDK layout is |
| * something like... |
| * |
| * dart-sdk/ |
| * bin/ |
| * dart[.exe] <-- VM |
| * lib/ |
| * core/ |
| * core.dart |
| * ... other core library files ... |
| * ... other libraries ... |
| * util/ |
| * ... Dart utilities ... |
| * Chromium/ <-- Dartium typically exists in a sibling directory |
| */ |
| class DirectoryBasedDartSdk implements DartSdk { |
| /** |
| * The default SDK, or `null` if the default SDK either has not yet been |
| * created or cannot be created for some reason. |
| */ |
| static DirectoryBasedDartSdk _DEFAULT_SDK; |
| |
| /** |
| * The name of the directory within the SDK directory that contains |
| * executables. |
| */ |
| static String _BIN_DIRECTORY_NAME = "bin"; |
| |
| /** |
| * The name of the directory on non-Mac that contains dartium. |
| */ |
| static String _DARTIUM_DIRECTORY_NAME = "chromium"; |
| |
| /** |
| * The name of the dart2js executable on non-windows operating systems. |
| */ |
| static String _DART2JS_EXECUTABLE_NAME = "dart2js"; |
| |
| /** |
| * The name of the file containing the dart2js executable on Windows. |
| */ |
| static String _DART2JS_EXECUTABLE_NAME_WIN = "dart2js.bat"; |
| |
| /** |
| * The name of the file containing the Dartium executable on Linux. |
| */ |
| static String _DARTIUM_EXECUTABLE_NAME_LINUX = "chrome"; |
| |
| /** |
| * The name of the file containing the Dartium executable on Macintosh. |
| */ |
| static String _DARTIUM_EXECUTABLE_NAME_MAC = |
| "Chromium.app/Contents/MacOS/Chromium"; |
| |
| /** |
| * The name of the file containing the Dartium executable on Windows. |
| */ |
| static String _DARTIUM_EXECUTABLE_NAME_WIN = "Chrome.exe"; |
| |
| /** |
| * The name of the [System] property whose value is the path to the default |
| * Dart SDK directory. |
| */ |
| static String _DEFAULT_DIRECTORY_PROPERTY_NAME = "com.google.dart.sdk"; |
| |
| /** |
| * The name of the directory within the SDK directory that contains |
| * documentation for the libraries. |
| */ |
| static String _DOCS_DIRECTORY_NAME = "docs"; |
| |
| /** |
| * The suffix added to the name of a library to derive the name of the file |
| * containing the documentation for that library. |
| */ |
| static String _DOC_FILE_SUFFIX = "_api.json"; |
| |
| /** |
| * The name of the directory within the SDK directory that contains the |
| * libraries file. |
| */ |
| static String _INTERNAL_DIR = "_internal"; |
| |
| /** |
| * The name of the directory within the SDK directory that contains the |
| * libraries. |
| */ |
| static String _LIB_DIRECTORY_NAME = "lib"; |
| |
| /** |
| * The name of the libraries file. |
| */ |
| static String _LIBRARIES_FILE = "libraries.dart"; |
| |
| /** |
| * The name of the pub executable on windows. |
| */ |
| static String _PUB_EXECUTABLE_NAME_WIN = "pub.bat"; |
| |
| /** |
| * The name of the pub executable on non-windows operating systems. |
| */ |
| static String _PUB_EXECUTABLE_NAME = "pub"; |
| |
| /** |
| * The name of the file within the SDK directory that contains the version |
| * number of the SDK. |
| */ |
| static String _VERSION_FILE_NAME = "version"; |
| |
| /** |
| * The name of the file containing the VM executable on the Windows operating |
| * system. |
| */ |
| static String _VM_EXECUTABLE_NAME_WIN = "dart.exe"; |
| |
| /** |
| * The name of the file containing the VM executable on non-Windows operating |
| * systems. |
| */ |
| static String _VM_EXECUTABLE_NAME = "dart"; |
| |
| /** |
| * Return the default Dart SDK, or `null` if the directory containing the |
| * default SDK cannot be determined (or does not exist). |
| */ |
| static DirectoryBasedDartSdk get defaultSdk { |
| if (_DEFAULT_SDK == null) { |
| JavaFile sdkDirectory = defaultSdkDirectory; |
| if (sdkDirectory == null) { |
| return null; |
| } |
| _DEFAULT_SDK = new DirectoryBasedDartSdk(sdkDirectory); |
| } |
| return _DEFAULT_SDK; |
| } |
| |
| /** |
| * Return the default directory for the Dart SDK, or `null` if the directory |
| * cannot be determined (or does not exist). The default directory is provided |
| * by a system property named `com.google.dart.sdk`. |
| */ |
| static JavaFile get defaultSdkDirectory { |
| String sdkProperty = |
| JavaSystemIO.getProperty(_DEFAULT_DIRECTORY_PROPERTY_NAME); |
| if (sdkProperty == null) { |
| return null; |
| } |
| JavaFile sdkDirectory = new JavaFile(sdkProperty); |
| if (!sdkDirectory.exists()) { |
| return null; |
| } |
| return sdkDirectory; |
| } |
| |
| /** |
| * The [AnalysisContext] which is used for all of the sources in this sdk. |
| */ |
| InternalAnalysisContext _analysisContext; |
| |
| /** |
| * The directory containing the SDK. |
| */ |
| JavaFile _sdkDirectory; |
| |
| /** |
| * The revision number of this SDK, or `"0"` if the revision number cannot be |
| * discovered. |
| */ |
| String _sdkVersion; |
| |
| /** |
| * The file containing the dart2js executable. |
| */ |
| JavaFile _dart2jsExecutable; |
| |
| /** |
| * The file containing the Dartium executable. |
| */ |
| JavaFile _dartiumExecutable; |
| |
| /** |
| * The file containing the pub executable. |
| */ |
| JavaFile _pubExecutable; |
| |
| /** |
| * The file containing the VM executable. |
| */ |
| JavaFile _vmExecutable; |
| |
| /** |
| * A mapping from Dart library URI's to the library represented by that URI. |
| */ |
| LibraryMap _libraryMap; |
| |
| /** |
| * Initialize a newly created SDK to represent the Dart SDK installed in the |
| * [sdkDirectory]. The flag [useDart2jsPaths] is `true` if the dart2js path |
| * should be used when it is available |
| */ |
| DirectoryBasedDartSdk(JavaFile sdkDirectory, [bool useDart2jsPaths = false]) { |
| this._sdkDirectory = sdkDirectory.getAbsoluteFile(); |
| _libraryMap = initialLibraryMap(useDart2jsPaths); |
| } |
| |
| @override |
| AnalysisContext get context { |
| if (_analysisContext == null) { |
| _analysisContext = new SdkAnalysisContext(); |
| SourceFactory factory = new SourceFactory([new DartUriResolver(this)]); |
| _analysisContext.sourceFactory = factory; |
| List<String> uris = this.uris; |
| ChangeSet changeSet = new ChangeSet(); |
| for (String uri in uris) { |
| changeSet.addedSource(factory.forUri(uri)); |
| } |
| _analysisContext.applyChanges(changeSet); |
| } |
| return _analysisContext; |
| } |
| |
| /** |
| * Return the file containing the dart2js executable, or `null` if it does not |
| * exist. |
| */ |
| JavaFile get dart2JsExecutable { |
| if (_dart2jsExecutable == null) { |
| _dart2jsExecutable = _verifyExecutable(new JavaFile.relative( |
| new JavaFile.relative(_sdkDirectory, _BIN_DIRECTORY_NAME), |
| OSUtilities.isWindows() |
| ? _DART2JS_EXECUTABLE_NAME_WIN |
| : _DART2JS_EXECUTABLE_NAME)); |
| } |
| return _dart2jsExecutable; |
| } |
| |
| /** |
| * Return the name of the file containing the Dartium executable. |
| */ |
| String get dartiumBinaryName { |
| if (OSUtilities.isWindows()) { |
| return _DARTIUM_EXECUTABLE_NAME_WIN; |
| } else if (OSUtilities.isMac()) { |
| return _DARTIUM_EXECUTABLE_NAME_MAC; |
| } else { |
| return _DARTIUM_EXECUTABLE_NAME_LINUX; |
| } |
| } |
| |
| /** |
| * Return the file containing the Dartium executable, or `null` if it does not |
| * exist. |
| */ |
| JavaFile get dartiumExecutable { |
| if (_dartiumExecutable == null) { |
| _dartiumExecutable = _verifyExecutable( |
| new JavaFile.relative(dartiumWorkingDirectory, dartiumBinaryName)); |
| } |
| return _dartiumExecutable; |
| } |
| |
| /** |
| * Return the directory where dartium can be found (the directory that will be |
| * the working directory is Dartium is invoked without changing the default). |
| */ |
| JavaFile get dartiumWorkingDirectory => |
| getDartiumWorkingDirectory(_sdkDirectory.getParentFile()); |
| |
| /** |
| * Return the directory containing the SDK. |
| */ |
| JavaFile get directory => _sdkDirectory; |
| |
| /** |
| * Return the directory containing documentation for the SDK. |
| */ |
| JavaFile get docDirectory => |
| new JavaFile.relative(_sdkDirectory, _DOCS_DIRECTORY_NAME); |
| |
| /** |
| * Return `true` if this SDK includes documentation. |
| */ |
| bool get hasDocumentation => docDirectory.exists(); |
| |
| /** |
| * Return `true` if the Dartium binary is available. |
| */ |
| bool get isDartiumInstalled => dartiumExecutable != null; |
| |
| /** |
| * Return the directory within the SDK directory that contains the libraries. |
| */ |
| JavaFile get libraryDirectory => |
| new JavaFile.relative(_sdkDirectory, _LIB_DIRECTORY_NAME); |
| |
| /** |
| * Return the file containing the Pub executable, or `null` if it does not exist. |
| */ |
| JavaFile get pubExecutable { |
| if (_pubExecutable == null) { |
| _pubExecutable = _verifyExecutable(new JavaFile.relative( |
| new JavaFile.relative(_sdkDirectory, _BIN_DIRECTORY_NAME), OSUtilities |
| .isWindows() ? _PUB_EXECUTABLE_NAME_WIN : _PUB_EXECUTABLE_NAME)); |
| } |
| return _pubExecutable; |
| } |
| |
| @override |
| List<SdkLibrary> get sdkLibraries => _libraryMap.sdkLibraries; |
| |
| /** |
| * Return the revision number of this SDK, or `"0"` if the revision number |
| * cannot be discovered. |
| */ |
| @override |
| String get sdkVersion { |
| if (_sdkVersion == null) { |
| _sdkVersion = DartSdk.DEFAULT_VERSION; |
| JavaFile revisionFile = |
| new JavaFile.relative(_sdkDirectory, _VERSION_FILE_NAME); |
| try { |
| String revision = revisionFile.readAsStringSync(); |
| if (revision != null) { |
| _sdkVersion = revision.trim(); |
| } |
| } on FileSystemException { |
| // Fall through to return the default. |
| } |
| } |
| return _sdkVersion; |
| } |
| |
| @override |
| List<String> get uris => _libraryMap.uris; |
| |
| /** |
| * Return the name of the file containing the VM executable. |
| */ |
| String get vmBinaryName { |
| if (OSUtilities.isWindows()) { |
| return _VM_EXECUTABLE_NAME_WIN; |
| } else { |
| return _VM_EXECUTABLE_NAME; |
| } |
| } |
| |
| /** |
| * Return the file containing the VM executable, or `null` if it does not |
| * exist. |
| */ |
| JavaFile get vmExecutable { |
| if (_vmExecutable == null) { |
| _vmExecutable = _verifyExecutable(new JavaFile.relative( |
| new JavaFile.relative(_sdkDirectory, _BIN_DIRECTORY_NAME), |
| vmBinaryName)); |
| } |
| return _vmExecutable; |
| } |
| |
| @override |
| Source fromFileUri(Uri uri) { |
| JavaFile file = new JavaFile.fromUri(uri); |
| String filePath = file.getAbsolutePath(); |
| String libPath = libraryDirectory.getAbsolutePath(); |
| if (!filePath.startsWith("$libPath${JavaFile.separator}")) { |
| return null; |
| } |
| filePath = filePath.substring(libPath.length + 1); |
| for (SdkLibrary library in _libraryMap.sdkLibraries) { |
| String libraryPath = library.path; |
| if (filePath.replaceAll('\\', '/') == libraryPath) { |
| String path = library.shortName; |
| try { |
| return new FileBasedSource.con2(parseUriWithException(path), file); |
| } on URISyntaxException catch (exception, stackTrace) { |
| AnalysisEngine.instance.logger.logInformation( |
| "Failed to create URI: $path", |
| new CaughtException(exception, stackTrace)); |
| return null; |
| } |
| } |
| libraryPath = new JavaFile(libraryPath).getParent(); |
| if (filePath.startsWith("$libraryPath${JavaFile.separator}")) { |
| String path = |
| "${library.shortName}/${filePath.substring(libraryPath.length + 1)}"; |
| try { |
| return new FileBasedSource.con2(parseUriWithException(path), file); |
| } on URISyntaxException catch (exception, stackTrace) { |
| AnalysisEngine.instance.logger.logInformation( |
| "Failed to create URI: $path", |
| new CaughtException(exception, stackTrace)); |
| return null; |
| } |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Return the directory where dartium can be found (the directory that will be |
| * the working directory if Dartium is invoked without changing the default), |
| * assuming that the Editor was installed in the [installDir]. |
| */ |
| JavaFile getDartiumWorkingDirectory(JavaFile installDir) => |
| new JavaFile.relative(installDir, _DARTIUM_DIRECTORY_NAME); |
| |
| /** |
| * Return the auxiliary documentation file for the library with the given |
| * [libraryName], or `null` if no such file exists. |
| */ |
| JavaFile getDocFileFor(String libraryName) { |
| JavaFile dir = docDirectory; |
| if (!dir.exists()) { |
| return null; |
| } |
| JavaFile libDir = new JavaFile.relative(dir, libraryName); |
| JavaFile docFile = |
| new JavaFile.relative(libDir, "$libraryName$_DOC_FILE_SUFFIX"); |
| if (docFile.exists()) { |
| return docFile; |
| } |
| return null; |
| } |
| |
| @override |
| SdkLibrary getSdkLibrary(String dartUri) => _libraryMap.getLibrary(dartUri); |
| |
| /** |
| * Read all of the configuration files to initialize the library maps. The |
| * flag [useDart2jsPaths] is `true` if the dart2js path should be used when it |
| * is available. Return the initialized library map. |
| */ |
| LibraryMap initialLibraryMap(bool useDart2jsPaths) { |
| JavaFile librariesFile = new JavaFile.relative( |
| new JavaFile.relative(libraryDirectory, _INTERNAL_DIR), |
| _LIBRARIES_FILE); |
| try { |
| String contents = librariesFile.readAsStringSync(); |
| return new SdkLibrariesReader(useDart2jsPaths).readFromFile( |
| librariesFile, contents); |
| } catch (exception, stackTrace) { |
| AnalysisEngine.instance.logger.logError( |
| "Could not initialize the library map from ${librariesFile.getAbsolutePath()}", |
| new CaughtException(exception, stackTrace)); |
| return new LibraryMap(); |
| } |
| } |
| |
| @override |
| Source mapDartUri(String dartUri) { |
| String libraryName; |
| String relativePath; |
| int index = dartUri.indexOf('/'); |
| if (index >= 0) { |
| libraryName = dartUri.substring(0, index); |
| relativePath = dartUri.substring(index + 1); |
| } else { |
| libraryName = dartUri; |
| relativePath = ""; |
| } |
| SdkLibrary library = getSdkLibrary(libraryName); |
| if (library == null) { |
| return null; |
| } |
| try { |
| JavaFile file = new JavaFile.relative(libraryDirectory, library.path); |
| if (!relativePath.isEmpty) { |
| file = file.getParentFile(); |
| file = new JavaFile.relative(file, relativePath); |
| } |
| return new FileBasedSource.con2(parseUriWithException(dartUri), file); |
| } on URISyntaxException { |
| return null; |
| } |
| } |
| |
| /** |
| * Return the given [file] if it exists and is executable, or `null` if it |
| * does not exist or is not executable. |
| */ |
| JavaFile _verifyExecutable(JavaFile file) => |
| file.isExecutable() ? file : null; |
| } |
| |
| /** |
| * An object used to read and parse the libraries file |
| * (dart-sdk/lib/_internal/libraries.dart) for information about the libraries |
| * in an SDK. The library information is represented as a Dart file containing a |
| * single top-level variable whose value is a const map. The keys of the map are |
| * the names of libraries defined in the SDK and the values in the map are info |
| * objects defining the library. For example, a subset of a typical SDK might |
| * have a libraries file that looks like the following: |
| * |
| * final Map<String, LibraryInfo> LIBRARIES = const <LibraryInfo> { |
| * // Used by VM applications |
| * "builtin" : const LibraryInfo( |
| * "builtin/builtin_runtime.dart", |
| * category: "Server", |
| * platforms: VM_PLATFORM), |
| * |
| * "compiler" : const LibraryInfo( |
| * "compiler/compiler.dart", |
| * category: "Tools", |
| * platforms: 0), |
| * }; |
| */ |
| class SdkLibrariesReader { |
| /** |
| * A flag indicating whether the dart2js path should be used when it is |
| * available. |
| */ |
| final bool _useDart2jsPaths; |
| |
| /** |
| * Initialize a newly created library reader to use the dart2js path if |
| * [_useDart2jsPaths] is `true`. |
| */ |
| SdkLibrariesReader(this._useDart2jsPaths); |
| |
| /** |
| * Return the library map read from the given [file], given that the content |
| * of the file is already known to be [libraryFileContents]. |
| */ |
| LibraryMap readFromFile(JavaFile file, String libraryFileContents) => |
| readFromSource(new FileBasedSource.con1(file), libraryFileContents); |
| |
| /** |
| * Return the library map read from the given [source], given that the content |
| * of the file is already known to be [libraryFileContents]. |
| */ |
| LibraryMap readFromSource(Source source, String libraryFileContents) { |
| BooleanErrorListener errorListener = new BooleanErrorListener(); |
| Scanner scanner = new Scanner( |
| source, new CharSequenceReader(libraryFileContents), errorListener); |
| Parser parser = new Parser(source, errorListener); |
| CompilationUnit unit = parser.parseCompilationUnit(scanner.tokenize()); |
| SdkLibrariesReader_LibraryBuilder libraryBuilder = |
| new SdkLibrariesReader_LibraryBuilder(_useDart2jsPaths); |
| // If any syntactic errors were found then don't try to visit the AST |
| // structure. |
| if (!errorListener.errorReported) { |
| unit.accept(libraryBuilder); |
| } |
| return libraryBuilder.librariesMap; |
| } |
| } |