function main(): void {
	'use strict';

	let pathToScript = process.argv[1];
	let args = process.argv.slice(2);
	let waiting = 2;
	let exit = 0;

	function childFinished(err: any, code: number = 0): void {
		if (err && !code)
			code = -1;
		waiting--;
		if (!waiting)
			process.exit(code);
	}

	pipe2((perr: any, rfd: number, wfd: number) => {
		if (perr)
			throw new Error('pipe2 failed: ' + perr);

		let echo = child_process.spawn('/usr/bin/echo', ['hello world'], { stdio: [0, wfd, 2] });
		echo.on('error', (err: any) => {
			process.stderr.write('error: ' + err, () => {
				exit = 1;
				childFinished(err);
			});
		});
		echo.on('exit', (code: number) => {
			childFinished(null, code);
		});

		// XXX: we don't need the wfd at this point, and
		// keeping it open seems to prevent cat from getting
		// an EOF on the pipe?
		fs.close(wfd, () => {
			let cat = child_process.spawn('/usr/bin/cat', [], { stdio: [rfd, 1, 2] });
			cat.on('error', (err: any) => {
				process.stderr.write('error: ' + err, () => {
					childFinished(err);
				});
			});
			cat.on('exit', (code: number) => {
				childFinished(null, code);
			});
			fs.close(rfd);
		});

	});
}

function main(): void {
	'use strict';
	///
	// Note: assumes the statement to be executed is a _string_ in argv[2]
	///
	// get statement
	let argv = process.argv;
	let pathToNode = argv[0];
	let pathToScript = argv[1];
	let args = argv.slice(2);
	if (args.length < 1) {
		let usage = 'usage: ' + path.basename(pathToScript) + ' CMD [ARGS...]\n';
		process.stderr.write(usage, (err: any) => {
			process.exit(1);
		});
		return;
	}
	let statement = args[0];
	//console.log(statement);

	// tokenize statement
	let tokens = tokenize(statement, "|");
	//console.log(tokens);

	// parse tokens into command sequence.
	// do path expansion for commands.
	// raise error if | is not surrounded by
	// commands.
	let parsetree: string[][] = [];
	try {
		parsetree = parse(tokens);
	} catch (e) {
		console.log(e);
		if (e instanceof SyntaxError) {
			process.stderr.write('SyntaxError: a pipe can only be between two commands.\n');
			process.exit(1);
		}
	}

	// check if parse tree is valid
	if (! parsetree_is_valid(parsetree)) {
		process.exit(1);
	}
	// iterate over commands, setup pipes, and execute commands
	let stderr = 2;
	let pids: number[] = [];
	let codes: number[] = [];
	let pipes: number[][] = [];
	let pin = 0;

	// called below
	function spawnChildren(): void {
		for (let i = 0; i < parsetree.length-1; i++) {
			let cmd = parsetree[i];
			let pout = pipes[i][1];
			let opts = {
				// pass our stdin, stdout, stderr to the child
				stdio: [pin, pout, stderr],
			};
			let child = execute_child(cmd, opts, pids, codes);
			fs.close(pipes[i][1]);
			pin = pipes[i][0];
		}
		// execute last command with our stdout
		let cmd = parsetree[parsetree.length-1];
		let opts = {
			// pass our stdin, stdout, stderr to the child
			stdio: [pin, 1, stderr],
		};
		let child = execute_child(cmd, opts, pids, codes);
		for (let i = 0; i < pipes.length; i++) {
			fs.close(pipes[i][0]);
		}
	}

	let outstanding = parsetree.length-1;
	if (!outstanding) {
		spawnChildren();
		return;
	}

	//setup pipes
	for (let i = 0; i < parsetree.length-1; i++) {
		pipe2((err: any, rfd: number, wfd: number) => {
			if (err)
				throw new Error('Pipe failed!');
			pipes.push([rfd, wfd]);
			outstanding--;
			if (!outstanding)
				spawnChildren();
		});
	}
}