tools/full-coverage.dart - sdk.git - Git at Google

 // Copyright (c) 2013, 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.

 import "dart:async";
 import "dart:convert";
 import "dart:io";
 import "dart:isolate";
 import "dart:mirrors";

 import "package:args/args.dart";
 import "package:path/path.dart";

 /// [Environment] stores gathered arguments information.
 class Environment {
   String sdkRoot;
   String pkgRoot;
   var input;
   var output;
   int workers;
   bool prettyPrint;
   bool lcov;
   bool expectMarkers;
   bool verbose;
 }

 /// [Resolver] resolves imports with respect to a given environment.
 class Resolver {
   const DART_PREFIX = "dart:";
   const PACKAGE_PREFIX = "package:";
   const FILE_PREFIX = "file://";
   const HTTP_PREFIX = "http://";

   Map _env;
   List failed = [];

   Resolver(this._env);

   /// Returns the absolute path wrt. to the given environment or null, if the
   /// import could not be resolved.
   resolve(String import) {
     if (import.startsWith(DART_PREFIX)) {
       var slashPos = import.indexOf("/");
       var filePath;
       if (slashPos != -1) {
         var path = import.substring(DART_PREFIX.length, slashPos);
         // Drop patch files, since we don't have their source in the compiled
         // SDK.
         if (path.endsWith("-patch")) {
           failed.add(import);
           return null;
         }
         // Canonicalize path. For instance: _collection-dev => _collection_dev.
         path = path.replaceAll("-", "_");
         filePath = "${_env["sdkRoot"]}"
                    "/${path}${import.substring(slashPos, import.length)}";
       } else {
         // Resolve 'dart:something' to be something/something.dart in the SDK.
         var lib = import.substring(DART_PREFIX.length, import.length);
         filePath = "${_env["sdkRoot"]}/${lib}/${lib}.dart";
       }
       return filePath;
     }
     if (import.startsWith(PACKAGE_PREFIX)) {
       var filePath =
           "${_env["pkgRoot"]}"
           "/${import.substring(PACKAGE_PREFIX.length, import.length)}";
       return filePath;
     }
     if (import.startsWith(FILE_PREFIX)) {
       var filePath = fromUri(Uri.parse(import));
       return filePath;
     }
     if (import.startsWith(HTTP_PREFIX)) {
       return import;
     }
     // We cannot deal with anything else.
     failed.add(import);
     return null;
   }
 }

 /// Converts the given hitmap to lcov format and appends the result to
 /// env.output.
 ///
 /// Returns a [Future] that completes as soon as all map entries have been
 /// emitted.
 Future lcov(Map hitmap) {
   var emitOne = (key) {
     var v = hitmap[key];
     StringBuffer entry = new StringBuffer();
     entry.write("SF:${key}\n");
     v.keys.toList()
           ..sort()
           ..forEach((k) {
       entry.write("DA:${k},${v[k]}\n");
     });
     entry.write("end_of_record\n");
     env.output.write(entry.toString());
     return new Future.value(null);
   };

   return Future.forEach(hitmap.keys, emitOne);
 }

 /// Converts the given hitmap to a pretty-print format and appends the result
 /// to env.output.
 ///
 /// Returns a [Future] that completes as soon as all map entries have been
 /// emitted.
 Future prettyPrint(Map hitMap, List failedLoads) {
   var emitOne = (key) {
     var v = hitMap[key];
     var c = new Completer();
     loadResource(key).then((lines) {
       if (lines == null) {
         failedLoads.add(key);
         c.complete();
         return;
       }
       env.output.write("${key}\n");
       for (var line = 1; line <= lines.length; line++) {
         String prefix = "       ";
         if (v.containsKey(line)) {
           prefix = v[line].toString();
           StringBuffer b = new StringBuffer();
           for (int i = prefix.length; i < 7; i++) {
             b.write(" ");
           }
           b.write(prefix);
           prefix = b.toString();
         }
         env.output.write("${prefix}|${lines[line-1]}\n");
       }
       c.complete();
     });
     return c.future;
   };

   return Future.forEach(hitMap.keys, emitOne);
 }

 /// Load an import resource and return a [Future] with a [List] of its lines.
 /// Returns [null] instead of a list if the resource could not be loaded.
 Future<List> loadResource(String import) {
   if (import.startsWith("http")) {
     Completer c = new Completer();
     HttpClient client = new HttpClient();
     client.getUrl(Uri.parse(import))
         .then((HttpClientRequest request) {
           return request.close();
         })
         .then((HttpClientResponse response) {
           response.transform(new StringDecoder()).toList().then((data) {
             c.complete(data);
             httpClient.close();
           });
         })
         .catchError((e) {
           c.complete(null);
         });
     return c.future;
   } else {
     File f = new File(import);
     return f.readAsLines()
         .catchError((e) {
           return new Future.value(null);
         });
   }
 }

 /// Creates a single hitmap from a raw json object. Throws away all entries that
 /// are not resolvable.
 Map createHitmap(String rawJson, Resolver resolver) {
   Map<String, Map<int,int>> hitMap = {};

   addToMap(source, line, count) {
     if (!hitMap[source].containsKey(line)) {
       hitMap[source][line] = 0;
     }
     hitMap[source][line] += count;
   }

   JSON.decode(rawJson).forEach((Map e) {
     String source = resolver.resolve(e["source"]);
     if (source == null) {
       // Couldnt resolve import, so skip this entry.
       return;
     }
     if (!hitMap.containsKey(source)) {
       hitMap[source] = {};
     }
     var hits = e["hits"];
     // hits is a flat array of the following format:
     // [ <line|linerange>, <hitcount>,...]
     // line: number.
     // linerange: "<line>-<line>".
     for (var i = 0; i < hits.length; i += 2) {
       var k = hits[i];
       if (k is num) {
         // Single line.
         addToMap(source, k, hits[i+1]);
       }
       if (k is String) {
         // Linerange. We expand line ranges to actual lines at this point.
         var splitPos = k.indexOf("-");
         int start = int.parse(k.substring(0, splitPos));
         int end = int.parse(k.substring(splitPos + 1, k.length));
         for (var j = start; j <= end; j++) {
           addToMap(source, j, hits[i+1]);
         }
       }
     }
   });
   return hitMap;
 }

 /// Merges [newMap] into [result].
 mergeHitmaps(Map newMap, Map result) {
   newMap.forEach((String file, Map v) {
     if (result.containsKey(file)) {
       v.forEach((int line, int cnt) {
         if (result[file][line] == null) {
           result[file][line] = cnt;
         } else {
           result[file][line] += cnt;
         }
       });
     } else {
       result[file] = v;
     }
   });
 }

 /// Given an absolute path absPath, this function returns a [List] of files
 /// are contained by it if it is a directory, or a [List] containing the file if
 /// it is a file.
 List filesToProcess(String absPath) {
   if (FileSystemEntity.isDirectorySync(absPath)) {
     Directory d = new Directory(absPath);
     List files = [];
     d.listSync(recursive: true).forEach((FileSystemEntity entity) {
       if (entity is File) {
         files.add(entity as File);
       }
     });
     return files;
   } else if (FileSystemEntity.isFileSync(absPath)) {
     return [ new File(absPath) ];
   }
 }

 worker() {
   final start = new DateTime.now().millisecondsSinceEpoch;
   String me = currentMirrorSystem().isolate.debugName;

   port.receive((Message message, reply) {
     if (message.type == Message.SHUTDOWN) {
       port.close();
     }

     if (message.type == Message.WORK) {
       var env = message.payload[0];
       List files = message.payload[1];
       Resolver resolver = new Resolver(env);
       var workerHitmap = {};
       files.forEach((File fileEntry) {
         // Read file sync, as it only contains 1 object.
         String contents = fileEntry.readAsStringSync();
         if (contents.length > 0) {
           mergeHitmaps(createHitmap(contents, resolver), workerHitmap);
         }
       });
       if (env["verbose"]) {
         final end = new DateTime.now().millisecondsSinceEpoch;
         print("worker[${me}]: Finished processing files. "
               "Took ${end - start} ms.");
       }
       reply.send(new Message(Message.RESULT, [workerHitmap, resolver.failed]));
     }

   });
 }

 class Message {
   static const int SHUTDOWN = 1;
   static const int RESULT = 2;
   static const int WORK = 3;

   final int type;
   final payload;

   Message(this.type, this.payload);
 }

 final env = new Environment();

 main() {
   parseArgs();

   List files = filesToProcess(env.input);
   int filesPerWorker = files.length ~/ env.workers;
   List workerPorts = [];
   int doneCnt = 0;

   List failedResolves = [];
   List failedLoads = [];
   Map globalHitmap = {};
   int start = new DateTime.now().millisecondsSinceEpoch;

   if (env.verbose) {
     print("Environment:");
     print("  # files: ${files.length}");
     print("  # workers: ${env.workers}");
     print("  sdk-root: ${env.sdkRoot}");
     print("  package-root: ${env.pkgRoot}");
   }

   port.receive((Message message, reply) {
     if (message.type == Message.RESULT) {
       mergeHitmaps(message.payload[0], globalHitmap);
       failedResolves.addAll(message.payload[1]);
       doneCnt++;
     }

     // All workers are done. Process the data.
     if (doneCnt == env.workers) {
       workerPorts.forEach((p) => p.send(new Message(Message.SHUTDOWN, null)));
       if (env.verbose) {
         final end = new DateTime.now().millisecondsSinceEpoch;
         print("Done creating a global hitmap. Took ${end - start} ms.");
       }

       Future out;
       if (env.prettyPrint) {
         out = prettyPrint(globalHitmap, failedLoads);
       }
       if (env.lcov) {
         out = lcov(globalHitmap);
       }

       out.then((_) {
         env.output.close().then((_) {
           if (env.verbose) {
             final end = new DateTime.now().millisecondsSinceEpoch;
             print("Done flushing output. Took ${end - start} ms.");
           }
         });
         port.close();

         if (env.verbose) {
           if (failedResolves.length > 0) {
             print("Failed to resolve:");
             failedResolves.toSet().forEach((e) {
               print("  ${e}");
             });
           }
           if (failedLoads.length > 0) {
             print("Failed to load:");
             failedLoads.toSet().forEach((e) {
               print("  ${e}");
             });
           }
         }

       });
     }
   });

   Map sharedEnv = {
     "sdkRoot": env.sdkRoot,
     "pkgRoot": env.pkgRoot,
     "verbose": env.verbose,
   };

   // Create workers.
   for (var i = 1; i < env.workers; i++) {
     var p = spawnFunction(worker);
     workerPorts.add(p);
     var start = files.length - filesPerWorker;
     var end = files.length;
     var workerFiles = files.getRange(start, end).toList();
     files.removeRange(start, end);
     p.send(new Message(Message.WORK, [sharedEnv, workerFiles]), port);
   }
   // Let the last worker deal with the rest of the files (which should be only
   // off by at max (#workers - 1).
   var p = spawnFunction(worker);
   workerPorts.add(p);
   p.send(new Message(Message.WORK, [sharedEnv, files]), port);

   return 0;
 }

 /// Checks the validity of the provided arguments. Does not initialize actual
 /// processing.
 parseArgs() {
   var parser = new ArgParser();

   parser.addOption("sdk-root", abbr: "s",
                    help: "path to the SDK root");
   parser.addOption("package-root", abbr: "p",
                    help: "path to the package root",
                    defaultsTo: ".");
   parser.addOption("in", abbr: "i",
                    help: "input(s): may be file or directory",
                    defaultsTo: "stdin");
   parser.addOption("out", abbr: "o",
                    help: "output: may be file or stdout",
                    defaultsTo: "stdout");
   parser.addOption("workers", abbr: "j",
                    help: "number of workers",
                    defaultsTo: "1");
   parser.addFlag("pretty-print", abbr: "r",
                  help: "convert coverage data to pretty print format",
                  negatable: false);
   parser.addFlag("lcov", abbr :"l",
                  help: "convert coverage data to lcov format",
                  negatable: false);
   parser.addFlag("verbose", abbr :"v",
                  help: "verbose output",
                  negatable: false);
   parser.addFlag("help", abbr: "h",
                  help: "show this help",
                  negatable: false);

   var args = parser.parse(new Options().arguments);

   if (args["help"]) {
     print("Usage: coverage [OPTION...]\n");
     print(parser.getUsage());
     exit(0);
   }

   if (args["sdk-root"] == null) {
     if (Platform.environment.containsKey("SDK_ROOT")) {
       env.sdkRoot =
         join(absolute(normalize(Platform.environment["SDK_ROOT"])), "lib");
     } else {
       throw "No SDK root found, please specify one using --sdk-root.";
     }
   } else {
     env.sdkRoot = join(absolute(normalize(args["sdk-root"])), "lib");
   }
   if (!FileSystemEntity.isDirectorySync(env.sdkRoot)) {
     throw "Provided SDK root ${args["sdk-root"]} is not a valid SDK "
           "top-level directory";
   }

   if (args["package-root"] == null) {
     env.pkgRoot = absolute(normalize("./packages"));
   } else {
     env.pkgRoot = absolute(normalize(args["package-root"]));
     if (!FileSystemEntity.isDirectorySync(env.pkgRoot)) {
       throw "Provided package root ${args["package-root"]} is not directory.";
     }
   }

   if (args["in"] == "stdin") {
     env.input = "stdin";
   } else {
     env.input = absolute(normalize(args["in"]));
     if (!FileSystemEntity.isDirectorySync(env.input) &&
         !FileSystemEntity.isFileSync(env.input)) {
       throw "Provided input ${args["in"]} is neither a directory, nor a file.";
     }
   }

   if (args["out"] == "stdout") {
     env.output = stdout;
   } else {
     env.output = absolute(normalize(args["out"]));
     env.output = new File(env.output).openWrite();
   }

   if (args["pretty-print"] &&
       args["lcov"]) {
     throw "Choose either pretty-print or lcov output";
   }

   env.prettyPrint = args["pretty-print"];
   env.lcov = args["lcov"];
   env.verbose = args["verbose"];
   env.workers = int.parse("${args["workers"]}");
 }
	// Copyright (c) 2013, 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.

	import "dart:async";
	import "dart:convert";
	import "dart:io";
	import "dart:isolate";
	import "dart:mirrors";

	import "package:args/args.dart";
	import "package:path/path.dart";

	/// [Environment] stores gathered arguments information.
	class Environment {
	String sdkRoot;
	String pkgRoot;
	var input;
	var output;
	int workers;
	bool prettyPrint;
	bool lcov;
	bool expectMarkers;
	bool verbose;
	}

	/// [Resolver] resolves imports with respect to a given environment.
	class Resolver {
	const DART_PREFIX = "dart:";
	const PACKAGE_PREFIX = "package:";
	const FILE_PREFIX = "file://";
	const HTTP_PREFIX = "http://";

	Map _env;
	List failed = [];

	Resolver(this._env);

	/// Returns the absolute path wrt. to the given environment or null, if the
	/// import could not be resolved.
	resolve(String import) {
	if (import.startsWith(DART_PREFIX)) {
	var slashPos = import.indexOf("/");
	var filePath;
	if (slashPos != -1) {
	var path = import.substring(DART_PREFIX.length, slashPos);
	// Drop patch files, since we don't have their source in the compiled
	// SDK.
	if (path.endsWith("-patch")) {
	failed.add(import);
	return null;
	}
	// Canonicalize path. For instance: _collection-dev => _collection_dev.
	path = path.replaceAll("-", "_");
	filePath = "${_env["sdkRoot"]}"
	"/${path}${import.substring(slashPos, import.length)}";
	} else {
	// Resolve 'dart:something' to be something/something.dart in the SDK.
	var lib = import.substring(DART_PREFIX.length, import.length);
	filePath = "${_env["sdkRoot"]}/${lib}/${lib}.dart";
	}
	return filePath;
	}
	if (import.startsWith(PACKAGE_PREFIX)) {
	var filePath =
	"${_env["pkgRoot"]}"
	"/${import.substring(PACKAGE_PREFIX.length, import.length)}";
	return filePath;
	}
	if (import.startsWith(FILE_PREFIX)) {
	var filePath = fromUri(Uri.parse(import));
	return filePath;
	}
	if (import.startsWith(HTTP_PREFIX)) {
	return import;
	}
	// We cannot deal with anything else.
	failed.add(import);
	return null;
	}
	}

	/// Converts the given hitmap to lcov format and appends the result to
	/// env.output.
	///
	/// Returns a [Future] that completes as soon as all map entries have been
	/// emitted.
	Future lcov(Map hitmap) {
	var emitOne = (key) {
	var v = hitmap[key];
	StringBuffer entry = new StringBuffer();
	entry.write("SF:${key}\n");
	v.keys.toList()
	..sort()
	..forEach((k) {
	entry.write("DA:${k},${v[k]}\n");
	});
	entry.write("end_of_record\n");
	env.output.write(entry.toString());
	return new Future.value(null);
	};

	return Future.forEach(hitmap.keys, emitOne);
	}

	/// Converts the given hitmap to a pretty-print format and appends the result
	/// to env.output.
	///
	/// Returns a [Future] that completes as soon as all map entries have been
	/// emitted.
	Future prettyPrint(Map hitMap, List failedLoads) {
	var emitOne = (key) {
	var v = hitMap[key];
	var c = new Completer();
	loadResource(key).then((lines) {
	if (lines == null) {
	failedLoads.add(key);
	c.complete();
	return;
	}
	env.output.write("${key}\n");
	for (var line = 1; line <= lines.length; line++) {
	String prefix = " ";
	if (v.containsKey(line)) {
	prefix = v[line].toString();
	StringBuffer b = new StringBuffer();
	for (int i = prefix.length; i < 7; i++) {
	b.write(" ");
	}
	b.write(prefix);
	prefix = b.toString();
	}
	env.output.write("${prefix}\|${lines[line-1]}\n");
	}
	c.complete();
	});
	return c.future;
	};

	return Future.forEach(hitMap.keys, emitOne);
	}

	/// Load an import resource and return a [Future] with a [List] of its lines.
	/// Returns [null] instead of a list if the resource could not be loaded.
	Future<List> loadResource(String import) {
	if (import.startsWith("http")) {
	Completer c = new Completer();
	HttpClient client = new HttpClient();
	client.getUrl(Uri.parse(import))
	.then((HttpClientRequest request) {
	return request.close();
	})
	.then((HttpClientResponse response) {
	response.transform(new StringDecoder()).toList().then((data) {
	c.complete(data);
	httpClient.close();
	});
	})
	.catchError((e) {
	c.complete(null);
	});
	return c.future;
	} else {
	File f = new File(import);
	return f.readAsLines()
	.catchError((e) {
	return new Future.value(null);
	});
	}
	}

	/// Creates a single hitmap from a raw json object. Throws away all entries that
	/// are not resolvable.
	Map createHitmap(String rawJson, Resolver resolver) {
	Map<String, Map<int,int>> hitMap = {};

	addToMap(source, line, count) {
	if (!hitMap[source].containsKey(line)) {
	hitMap[source][line] = 0;
	}
	hitMap[source][line] += count;
	}

	JSON.decode(rawJson).forEach((Map e) {
	String source = resolver.resolve(e["source"]);
	if (source == null) {
	// Couldnt resolve import, so skip this entry.
	return;
	}
	if (!hitMap.containsKey(source)) {
	hitMap[source] = {};
	}
	var hits = e["hits"];
	// hits is a flat array of the following format:
	// [ <line\|linerange>, <hitcount>,...]
	// line: number.
	// linerange: "<line>-<line>".
	for (var i = 0; i < hits.length; i += 2) {
	var k = hits[i];
	if (k is num) {
	// Single line.
	addToMap(source, k, hits[i+1]);
	}
	if (k is String) {
	// Linerange. We expand line ranges to actual lines at this point.
	var splitPos = k.indexOf("-");
	int start = int.parse(k.substring(0, splitPos));
	int end = int.parse(k.substring(splitPos + 1, k.length));
	for (var j = start; j <= end; j++) {
	addToMap(source, j, hits[i+1]);
	}
	}
	}
	});
	return hitMap;
	}

	/// Merges [newMap] into [result].
	mergeHitmaps(Map newMap, Map result) {
	newMap.forEach((String file, Map v) {
	if (result.containsKey(file)) {
	v.forEach((int line, int cnt) {
	if (result[file][line] == null) {
	result[file][line] = cnt;
	} else {
	result[file][line] += cnt;
	}
	});
	} else {
	result[file] = v;
	}
	});
	}

	/// Given an absolute path absPath, this function returns a [List] of files
	/// are contained by it if it is a directory, or a [List] containing the file if
	/// it is a file.
	List filesToProcess(String absPath) {
	if (FileSystemEntity.isDirectorySync(absPath)) {
	Directory d = new Directory(absPath);
	List files = [];
	d.listSync(recursive: true).forEach((FileSystemEntity entity) {
	if (entity is File) {
	files.add(entity as File);
	}
	});
	return files;
	} else if (FileSystemEntity.isFileSync(absPath)) {
	return [ new File(absPath) ];
	}
	}

	worker() {
	final start = new DateTime.now().millisecondsSinceEpoch;
	String me = currentMirrorSystem().isolate.debugName;

	port.receive((Message message, reply) {
	if (message.type == Message.SHUTDOWN) {
	port.close();
	}

	if (message.type == Message.WORK) {
	var env = message.payload[0];
	List files = message.payload[1];
	Resolver resolver = new Resolver(env);
	var workerHitmap = {};
	files.forEach((File fileEntry) {
	// Read file sync, as it only contains 1 object.
	String contents = fileEntry.readAsStringSync();
	if (contents.length > 0) {
	mergeHitmaps(createHitmap(contents, resolver), workerHitmap);
	}
	});
	if (env["verbose"]) {
	final end = new DateTime.now().millisecondsSinceEpoch;
	print("worker[${me}]: Finished processing files. "
	"Took ${end - start} ms.");
	}
	reply.send(new Message(Message.RESULT, [workerHitmap, resolver.failed]));
	}

	});
	}

	class Message {
	static const int SHUTDOWN = 1;
	static const int RESULT = 2;
	static const int WORK = 3;

	final int type;
	final payload;

	Message(this.type, this.payload);
	}

	final env = new Environment();

	main() {
	parseArgs();

	List files = filesToProcess(env.input);
	int filesPerWorker = files.length ~/ env.workers;
	List workerPorts = [];
	int doneCnt = 0;

	List failedResolves = [];
	List failedLoads = [];
	Map globalHitmap = {};
	int start = new DateTime.now().millisecondsSinceEpoch;

	if (env.verbose) {
	print("Environment:");
	print(" # files: ${files.length}");
	print(" # workers: ${env.workers}");
	print(" sdk-root: ${env.sdkRoot}");
	print(" package-root: ${env.pkgRoot}");
	}

	port.receive((Message message, reply) {
	if (message.type == Message.RESULT) {
	mergeHitmaps(message.payload[0], globalHitmap);
	failedResolves.addAll(message.payload[1]);
	doneCnt++;
	}

	// All workers are done. Process the data.
	if (doneCnt == env.workers) {
	workerPorts.forEach((p) => p.send(new Message(Message.SHUTDOWN, null)));
	if (env.verbose) {
	final end = new DateTime.now().millisecondsSinceEpoch;
	print("Done creating a global hitmap. Took ${end - start} ms.");
	}

	Future out;
	if (env.prettyPrint) {
	out = prettyPrint(globalHitmap, failedLoads);
	}
	if (env.lcov) {
	out = lcov(globalHitmap);
	}

	out.then((_) {
	env.output.close().then((_) {
	if (env.verbose) {
	final end = new DateTime.now().millisecondsSinceEpoch;
	print("Done flushing output. Took ${end - start} ms.");
	}
	});
	port.close();

	if (env.verbose) {
	if (failedResolves.length > 0) {
	print("Failed to resolve:");
	failedResolves.toSet().forEach((e) {
	print(" ${e}");
	});
	}
	if (failedLoads.length > 0) {
	print("Failed to load:");
	failedLoads.toSet().forEach((e) {
	print(" ${e}");
	});
	}
	}

	});
	}
	});

	Map sharedEnv = {
	"sdkRoot": env.sdkRoot,
	"pkgRoot": env.pkgRoot,
	"verbose": env.verbose,
	};

	// Create workers.
	for (var i = 1; i < env.workers; i++) {
	var p = spawnFunction(worker);
	workerPorts.add(p);
	var start = files.length - filesPerWorker;
	var end = files.length;
	var workerFiles = files.getRange(start, end).toList();
	files.removeRange(start, end);
	p.send(new Message(Message.WORK, [sharedEnv, workerFiles]), port);
	}
	// Let the last worker deal with the rest of the files (which should be only
	// off by at max (#workers - 1).
	var p = spawnFunction(worker);
	workerPorts.add(p);
	p.send(new Message(Message.WORK, [sharedEnv, files]), port);

	return 0;
	}

	/// Checks the validity of the provided arguments. Does not initialize actual
	/// processing.
	parseArgs() {
	var parser = new ArgParser();

	parser.addOption("sdk-root", abbr: "s",
	help: "path to the SDK root");
	parser.addOption("package-root", abbr: "p",
	help: "path to the package root",
	defaultsTo: ".");
	parser.addOption("in", abbr: "i",
	help: "input(s): may be file or directory",
	defaultsTo: "stdin");
	parser.addOption("out", abbr: "o",
	help: "output: may be file or stdout",
	defaultsTo: "stdout");
	parser.addOption("workers", abbr: "j",
	help: "number of workers",
	defaultsTo: "1");
	parser.addFlag("pretty-print", abbr: "r",
	help: "convert coverage data to pretty print format",
	negatable: false);
	parser.addFlag("lcov", abbr :"l",
	help: "convert coverage data to lcov format",
	negatable: false);
	parser.addFlag("verbose", abbr :"v",
	help: "verbose output",
	negatable: false);
	parser.addFlag("help", abbr: "h",
	help: "show this help",
	negatable: false);

	var args = parser.parse(new Options().arguments);

	if (args["help"]) {
	print("Usage: coverage [OPTION...]\n");
	print(parser.getUsage());
	exit(0);
	}

	if (args["sdk-root"] == null) {
	if (Platform.environment.containsKey("SDK_ROOT")) {
	env.sdkRoot =
	join(absolute(normalize(Platform.environment["SDK_ROOT"])), "lib");
	} else {
	throw "No SDK root found, please specify one using --sdk-root.";
	}
	} else {
	env.sdkRoot = join(absolute(normalize(args["sdk-root"])), "lib");
	}
	if (!FileSystemEntity.isDirectorySync(env.sdkRoot)) {
	throw "Provided SDK root ${args["sdk-root"]} is not a valid SDK "
	"top-level directory";
	}

	if (args["package-root"] == null) {
	env.pkgRoot = absolute(normalize("./packages"));
	} else {
	env.pkgRoot = absolute(normalize(args["package-root"]));
	if (!FileSystemEntity.isDirectorySync(env.pkgRoot)) {
	throw "Provided package root ${args["package-root"]} is not directory.";
	}
	}

	if (args["in"] == "stdin") {
	env.input = "stdin";
	} else {
	env.input = absolute(normalize(args["in"]));
	if (!FileSystemEntity.isDirectorySync(env.input) &&
	!FileSystemEntity.isFileSync(env.input)) {
	throw "Provided input ${args["in"]} is neither a directory, nor a file.";
	}
	}

	if (args["out"] == "stdout") {
	env.output = stdout;
	} else {
	env.output = absolute(normalize(args["out"]));
	env.output = new File(env.output).openWrite();
	}

	if (args["pretty-print"] &&
	args["lcov"]) {
	throw "Choose either pretty-print or lcov output";
	}

	env.prettyPrint = args["pretty-print"];
	env.lcov = args["lcov"];
	env.verbose = args["verbose"];
	env.workers = int.parse("${args["workers"]}");
	}