func test(t *testing.T, src string, code []cpu.Word) {
	var ast parser.AST

	files, err := path.SourceFiles(src)
	if err != nil {
		t.Fatal(err)
	}

	for i := range files {
		err = ast.Parse(files[i], 0)
		if err != nil {
			t.Fatal(err)
		}
	}

	ar, err := Assemble(&ast, 0)
	if err != nil {
		t.Fatal(err)
	}

	if len(code) != len(ar.Code) {
		t.Fatalf("Code size mismatch. Expected %d, have %d\n%04x\n%04x",
			len(code), len(ar.Code), code, ar.Code)
	}

	for i := range code {
		if code[i] != cpu.Word(ar.Code[i]) {
			t.Fatalf("Code mismatch at instruction %d:\nWant: %04x\nHave: %04x", i, code, ar.Code)
		}
	}
}

// findDeps creates a tree of dependencies (import paths) for
// the given package. It parses the package source code for this purpose.
func findDeps(importpath string, list *[]string) bool {
	if containsDep(*list, importpath) {
		return true
	}

	// Find source files for the given package.
	sources, err := path.SourceFiles(importpath)
	if err != nil {
		return false
	}

	// Parse sources into a partial AST.
	// We are only interested in the import statements.
	var ast parser.AST
	for _, file := range sources {
		err = ast.Parse(file, parser.ImportsOnly)

		if err != nil {
			return false
		}
	}

	// Create a new dependency entry.
	*list = append(*list, importpath)

	for _, imp := range ast.Imports {
		if !findDeps(imp.Path.Value, list) {
			return false
		}
	}

	return true
}

func doTest(t *testing.T, src string, sbin ...cpu.Word) {
	var ast parser.AST
	var dbin []cpu.Word

	buf := bytes.NewBufferString(src)
	err := ast.Parse(buf, "")

	if err != nil {
		t.Fatal(err)
	}

	dbin, _, err = Assemble(&ast)
	if err != nil {
		t.Fatal(err)
	}

	if len(dbin) != len(sbin) {
		fmt.Printf("%04x\n", dbin)
		fmt.Printf("%04x\n", sbin)
		t.Fatalf("Size mismatch. Expect %d, got %d", len(sbin), len(dbin))
	}

	for i := range sbin {
		if dbin[i] != sbin[i] {
			fmt.Printf("%04x\n", dbin)
			fmt.Printf("%04x\n", sbin)
			t.Fatalf("Code mismatch at %d. Expect %04x, got %04x", i, sbin[i], dbin[i])
		}
	}
}

// readSource reads the given file and parses its contents
// into the given AST.
func readSource(ast *parser.AST, file string) error {
	fd, err := os.Open(file)
	if err != nil {
		return err
	}

	defer fd.Close()
	return ast.Parse(fd, file)
}

// parseFunctions resolves function constants and it injects the
// necessary function prolog and epilog code.
//
// What the latter means, is that we analyze the registers being
// used. If any of them are registers that are guaranteed to
// be preserved across function calls, then we explicitly inject stack
// push/pop instructions to save their state.
//
// If there are any `return` instructions, we replace them with `set pc, $$`.
// Where `$$` is a label we generate which points to the function epilog.
func parseFunctions(ast *parser.AST) (err error) {
	list := ast.Functions()

	for i := range list {
		if err = parseFuncConst(ast, list[i]); err != nil {
			return
		}

		fixFunctionReturns(ast, list[i])
		injectFunctionCode(ast, list[i])
	}

	return
}

func Format(in, out string) (err error) {
	var fout io.WriteCloser
	var fin io.ReadCloser
	var ast parser.AST

	// Open input stream.
	if in == Stdin {
		fin = _stdin
	} else {
		fin, err = os.Open(in)
		if err != nil {
			return
		}
	}

	// Parse source into AST.
	err = ast.Parse(fin, in)
	fin.Close()

	if err != nil {
		return
	}

	if *strip {
		StripComments(&ast)
	}

	// Open output stream.
	if out == Stdout {
		fout = _stdout
	} else {
		fout, err = os.Create(out)
		if err != nil {
			return
		}

		defer fout.Close()
	}

	// Write source.
	sw := util.NewSourceWriter(fout, &ast)
	sw.Tabs = *tabs
	sw.TabWidth = *tabwidth
	sw.Comments = !*strip
	sw.Write()
	return
}

// build builds the given package and its dependencies.
func build(importpath string, flags asm.AsmFlags) (err error) {
	files, _ := path.SourceFiles(importpath)
	if len(files) == 0 {
		return nil // No source files
	}

	var ast parser.AST
	for i := range files {
		err = ast.Parse(files[i], 0)
		if err != nil {
			return
		}
	}

	ar, err := asm.Assemble(&ast, flags)
	if err != nil {
		return
	}

	return writeArchive(ar, importpath)
}