Example #1
0
func GcToolchain(opts ...func(*gcoption)) func(c *Context) error {
	defaults := []func(*gcoption){
		func(opt *gcoption) {
			opt.goos = runtime.GOOS
		},
		func(opt *gcoption) {
			opt.goarch = runtime.GOARCH
		},
	}
	var options gcoption
	for _, opt := range append(defaults, opts...) {
		opt(&options)
	}

	return func(c *Context) error {
		goroot := runtime.GOROOT()
		goos := options.goos
		goarch := options.goarch
		archchar, err := build.ArchChar(goarch)
		if err != nil {
			return err
		}
		tooldir := filepath.Join(goroot, "pkg", "tool", goos+"_"+goarch)
		c.tc = &gcToolchain{
			goos:   goos,
			goarch: goarch,
			gc:     filepath.Join(tooldir, archchar+"g"),
			ld:     filepath.Join(tooldir, archchar+"l"),
			as:     filepath.Join(tooldir, archchar+"a"),
			cc:     filepath.Join(tooldir, archchar+"c"),
			pack:   filepath.Join(tooldir, "pack"),
		}
		return nil
	}
}
Example #2
0
func main() {
	gochar, err := build.ArchChar(runtime.GOARCH)
	if err != nil {
		log.Fatal(err)
	}

	f, err := os.Create("builtin.go")
	if err != nil {
		log.Fatal(err)
	}
	defer f.Close()
	w := bufio.NewWriter(f)

	fmt.Fprintln(w, "// AUTO-GENERATED by mkbuiltin.go; DO NOT EDIT")
	fmt.Fprintln(w, "")
	fmt.Fprintln(w, "package gc")

	for _, name := range os.Args[1:] {
		mkbuiltin(w, gochar, name)
	}

	if err := w.Flush(); err != nil {
		log.Fatal(err)
	}
}
Example #3
0
func (b *builder) init() {
	var err error
	b.actionCache = make(map[cacheKey]*action)
	b.mkdirCache = make(map[string]bool)
	b.goarch = buildContext.GOARCH
	b.goos = buildContext.GOOS
	b.goroot = build.Path[0].Path
	b.gobin = build.Path[0].BinDir()
	if b.goos == "windows" {
		b.exe = ".exe"
	}
	b.gcflags = strings.Fields(os.Getenv("GCFLAGS"))

	b.arch, err = build.ArchChar(b.goarch)
	if err != nil {
		fatalf("%s", err)
	}

	if buildN {
		b.work = "$WORK"
	} else {
		b.work, err = ioutil.TempDir("", "go-build")
		if err != nil {
			fatalf("%s", err)
		}
		if buildX {
			fmt.Printf("WORK=%s\n", b.work)
		}
		atexit(func() { os.RemoveAll(b.work) })
	}
}
Example #4
0
func main() {
	if runtime.Compiler != "gc" || runtime.GOOS == "nacl" {
		return
	}
	a, err := build.ArchChar(runtime.GOARCH)
	check(err)

	err = os.Chdir(filepath.Join("fixedbugs", "issue9355.dir"))
	check(err)

	out := run("go", "tool", a+"g", "-S", "a.go")
	os.Remove("a." + a)

	// 6g/8g print the offset as dec, but 5g/9g print the offset as hex.
	patterns := []string{
		`rel 0\+\d t=1 \"\"\.x\+8\r?\n`,       // y = &x.b
		`rel 0\+\d t=1 \"\"\.x\+(28|1c)\r?\n`, // z = &x.d.q
		`rel 0\+\d t=1 \"\"\.b\+5\r?\n`,       // c = &b[5]
		`rel 0\+\d t=1 \"\"\.x\+(88|58)\r?\n`, // w = &x.f[3].r
	}
	for _, p := range patterns {
		if ok, err := regexp.Match(p, out); !ok || err != nil {
			println(string(out))
			panic("can't find pattern " + p)
		}
	}
}
Example #5
0
// setEnvironment assembles the configuration for gotest and its subcommands.
func setEnvironment() {
	// Basic environment.
	GOROOT = runtime.GOROOT()
	addEnv("GOROOT", GOROOT)
	GOARCH = build.DefaultContext.GOARCH
	addEnv("GOARCH", GOARCH)
	var err error
	O, err = build.ArchChar(GOARCH)
	if err != nil {
		Fatalf("unknown architecture: %s", err)
	}

	// Commands and their flags.
	gc := os.Getenv("GC")
	if gc == "" {
		gc = O + "g"
	}
	var gcflags []string
	if gf := strings.TrimSpace(os.Getenv("GCFLAGS")); gf != "" {
		gcflags = strings.Fields(gf)
	}
	XGC = append([]string{gc, "-I", "_test", "-o", "_xtest_." + O}, gcflags...)
	GC = append(append([]string{gc, "-I", "_test"}, gcflags...), "_testmain.go")
	gl := os.Getenv("GL")
	if gl == "" {
		gl = O + "l"
	}
	GL = []string{gl, "-L", "_test", "_testmain." + O}

	// Silence make on Linux
	addEnv("MAKEFLAGS", "")
	addEnv("MAKELEVEL", "")
}
Example #6
0
func init() {
	if char, err := build.ArchChar(runtime.GOARCH); err == nil {
		gcPath = filepath.Join(build.ToolDir, char+"g")
		return
	}
	gcPath = "unknown-GOARCH-compiler"
}
Example #7
0
File: gc14.go Project: srid/vessel
func GcToolchain(opts ...func(*gcoption)) func(c *Context) error {
	return func(c *Context) error {
		// TODO(dfc) this should come from the context, not the runtime.
		goroot := runtime.GOROOT()

		// cross-compliation is not supported yet #31
		if c.gohostos != c.gotargetos || c.gohostarch != c.gotargetarch {
			return fmt.Errorf("cross compilation from host %s/%s to target %s/%s not supported with Go 1.4", c.gohostos, c.gohostarch, c.gotargetos, c.gotargetarch)
		}

		archchar, err := build.ArchChar(c.gotargetarch)
		if err != nil {
			return err
		}
		tooldir := filepath.Join(goroot, "pkg", "tool", c.gohostos+"_"+c.gohostarch)
		c.tc = &gcToolchain{
			gc:   filepath.Join(tooldir, archchar+"g"),
			ld:   filepath.Join(tooldir, archchar+"l"),
			as:   filepath.Join(tooldir, archchar+"a"),
			cc:   filepath.Join(tooldir, archchar+"c"),
			pack: filepath.Join(tooldir, "pack"),
		}
		return nil
	}
}
Example #8
0
func compile(t *testing.T, dirname, filename string) string {
	cmd := exec.Command(gcPath, filename)
	cmd.Dir = dirname
	out, err := cmd.CombinedOutput()
	if err != nil {
		t.Logf("%s", out)
		t.Fatalf("%s %s failed: %s", gcPath, filename, err)
	}
	archCh, _ := build.ArchChar(runtime.GOARCH)
	// filename should end with ".go"
	return filepath.Join(dirname, filename[:len(filename)-2]+archCh)
}
Example #9
0
func init() {
	goarch = buildContext.GOARCH
	goos = buildContext.GOOS
	if goos == "windows" {
		exeSuffix = ".exe"
	}
	var err error
	archChar, err = build.ArchChar(goarch)
	if err != nil {
		fatalf("%s", err)
	}
}
Example #10
0
File: gc14.go Project: nakalsio/gb
func GcToolchain(opts ...func(*gcoption)) func(c *Context) error {
	envor := func(key, def string) string {
		if v := os.Getenv(key); v != "" {
			return v
		} else {
			return def
		}
	}

	defaults := []func(*gcoption){
		func(opt *gcoption) {
			opt.goos = envor("GOOS", runtime.GOOS)
		},
		func(opt *gcoption) {
			opt.goarch = envor("GOARCH", runtime.GOARCH)
		},
	}

	var options gcoption
	for _, opt := range append(defaults, opts...) {
		opt(&options)
	}

	return func(c *Context) error {
		goroot := runtime.GOROOT()
		goos := options.goos
		goarch := options.goarch

		// cross-compliation is not supported yet #31
		if goos != runtime.GOOS || goarch != runtime.GOARCH {
			return fmt.Errorf("cross compilation from host %s/%s to target %s/%s not supported. See issue #31", runtime.GOOS, runtime.GOARCH, goos, goarch)
		}

		archchar, err := build.ArchChar(goarch)
		if err != nil {
			return err
		}
		tooldir := filepath.Join(goroot, "pkg", "tool", goos+"_"+goarch)
		c.tc = &gcToolchain{
			goos:   goos,
			goarch: goarch,
			gc:     filepath.Join(tooldir, archchar+"g"),
			ld:     filepath.Join(tooldir, archchar+"l"),
			as:     filepath.Join(tooldir, archchar+"a"),
			cc:     filepath.Join(tooldir, archchar+"c"),
			pack:   filepath.Join(tooldir, "pack"),
		}
		return nil
	}
}
Example #11
0
func main() {
	a, err := build.ArchChar(runtime.GOARCH)
	if err != nil {
		fmt.Println("BUG:", err)
		os.Exit(1)
	}

	run("go", "tool", a+"g", filepath.Join("fixedbugs", "bug302.dir", "p.go"))
	run("go", "tool", "pack", "grc", "pp.a", "p."+a)
	run("go", "tool", a+"g", "-I", ".", filepath.Join("fixedbugs", "bug302.dir", "main.go"))
	os.Remove("p." + a)
	os.Remove("pp.a")
	os.Remove("main." + a)
}
func main() {
	flag.Parse()

	// source of unique numbers
	go func() {
		for i := 0; ; i++ {
			uniq <- i
		}
	}()

	// set archChar
	var err os.Error
	archChar, err = build.ArchChar(runtime.GOARCH)
	if err != nil {
		log.Fatal(err)
	}

	// find and serve the go tour files
	t, _, err := build.FindTree(basePkg)
	if err != nil {
		log.Fatalf("Couldn't find tour files: %v", err)
	}
	root := filepath.Join(t.SrcDir(), basePkg)
	root := basePkg
	log.Println("Serving content from", root)
	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		if r.URL.Path == "/favicon.ico" || r.URL.Path == "/" {
			fn := filepath.Join(root, "static", r.URL.Path[1:])
			http.ServeFile(w, r, fn)
			return
		}
		http.Error(w, "not found", 404)
	})
	http.Handle("/static/", http.FileServer(http.Dir(root)))
	http.HandleFunc("/kill", kill)

	// set include path for ld and gc
	pkgDir = t.PkgDir()

	if !strings.HasPrefix(*httpListen, "127.0.0.1") &&
		!strings.HasPrefix(*httpListen, "localhost") {
		log.Print(localhostWarning)
	}

	log.Printf("Serving at http://%s/", *httpListen)
	log.Fatal(http.ListenAndServe(*httpListen, nil))
}
Example #13
0
func main() {
	a, err := build.ArchChar(build.Default.GOARCH)
	check(err)

	err = os.Chdir(filepath.Join(".", "fixedbugs", "bug369.dir"))
	check(err)

	run("go", "tool", a+"g", "-N", "-o", "slow."+a, "pkg.go")
	run("go", "tool", a+"g", "-o", "fast."+a, "pkg.go")
	run("go", "tool", a+"g", "-o", "main."+a, "main.go")
	run("go", "tool", a+"l", "-o", "a.exe", "main."+a)
	run("." + string(filepath.Separator) + "a.exe")

	os.Remove("slow." + a)
	os.Remove("fast." + a)
	os.Remove("main." + a)
	os.Remove("a.exe")
}
Example #14
0
File: gc.go Project: dradtke/gb
func GcToolchain() func(c *Context) error {
	return func(c *Context) error {
		// TODO(dfc) this should come from the context, not the runtime.
		goroot := runtime.GOROOT()

		if gc14 && (c.gohostos != c.gotargetos || c.gohostarch != c.gotargetarch) {
			// cross-compliation is not supported yet #31
			return fmt.Errorf("cross compilation from host %s/%s to target %s/%s not supported with Go 1.4", c.gohostos, c.gohostarch, c.gotargetos, c.gotargetarch)
		}

		tooldir := filepath.Join(goroot, "pkg", "tool", c.gohostos+"_"+c.gohostarch)
		exe := ""
		if c.gohostos == "windows" {
			exe += ".exe"
		}
		switch {
		case gc14:
			archchar, err := build.ArchChar(c.gotargetarch)
			if err != nil {
				return err
			}
			c.tc = &gcToolchain{
				gc:   filepath.Join(tooldir, archchar+"g"+exe),
				ld:   filepath.Join(tooldir, archchar+"l"+exe),
				as:   filepath.Join(tooldir, archchar+"a"+exe),
				cc:   filepath.Join(tooldir, archchar+"c"+exe),
				pack: filepath.Join(tooldir, "pack"+exe),
			}
		case gc15:
			c.tc = &gcToolchain{
				gc:   filepath.Join(tooldir, "compile"+exe),
				ld:   filepath.Join(tooldir, "link"+exe),
				as:   filepath.Join(tooldir, "asm"+exe),
				pack: filepath.Join(tooldir, "pack"+exe),
			}
		default:
			return fmt.Errorf("unsupported Go version: %v", runtime.Version)
		}
		return nil
	}
}
Example #15
0
func main() {
	letter, err := build.ArchChar(build.Default.GOARCH)
	if err != nil {
		fmt.Println(err)
		os.Exit(1)
	}

	cmd := exec.Command("go", "tool", letter+"g", "-S", "sinit.go")
	out, err := cmd.CombinedOutput()
	if err != nil {
		fmt.Println(string(out))
		fmt.Println(err)
		os.Exit(1)
	}
	os.Remove("sinit." + letter)

	if bytes.Contains(out, []byte("initdone")) {
		fmt.Println("sinit generated an init function")
		os.Exit(1)
	}
}
Example #16
0
func main() {
	a, err := build.ArchChar(build.Default.GOARCH)
	check(err)

	// TODO: If we get rid of errchk, re-enable this test on Windows.
	errchk, err := filepath.Abs("errchk")
	check(err)

	err = os.Chdir(filepath.Join("fixedbugs", "bug248.dir"))
	check(err)

	run("go", "tool", a+"g", "bug0.go")
	run("go", "tool", a+"g", "bug1.go")
	run("go", "tool", a+"g", "bug2.go")
	run(errchk, "go", "tool", a+"g", "-e", "bug3.go")
	run("go", "tool", a+"l", "bug2."+a)
	run(fmt.Sprintf(".%c%s.out", filepath.Separator, a))

	os.Remove("bug0." + a)
	os.Remove("bug1." + a)
	os.Remove("bug2." + a)
	os.Remove(a + ".out")
}
Example #17
0
func main() {
	flag.Parse()

	goos = getenv("GOOS", runtime.GOOS)
	goarch = getenv("GOARCH", runtime.GOARCH)

	findExecCmd()

	// Disable parallelism if printing or if using a simulator.
	if *verbose || len(findExecCmd()) > 0 {
		*numParallel = 1
	}

	ratec = make(chan bool, *numParallel)
	rungatec = make(chan bool, *runoutputLimit)
	var err error
	letter, err = build.ArchChar(build.Default.GOARCH)
	check(err)
	gc = letter + "g"
	ld = letter + "l"

	var tests []*test
	if flag.NArg() > 0 {
		for _, arg := range flag.Args() {
			if arg == "-" || arg == "--" {
				// Permit running:
				// $ go run run.go - env.go
				// $ go run run.go -- env.go
				// $ go run run.go - ./fixedbugs
				// $ go run run.go -- ./fixedbugs
				continue
			}
			if fi, err := os.Stat(arg); err == nil && fi.IsDir() {
				for _, baseGoFile := range goFiles(arg) {
					tests = append(tests, startTest(arg, baseGoFile))
				}
			} else if strings.HasSuffix(arg, ".go") {
				dir, file := filepath.Split(arg)
				tests = append(tests, startTest(dir, file))
			} else {
				log.Fatalf("can't yet deal with non-directory and non-go file %q", arg)
			}
		}
	} else {
		for _, dir := range dirs {
			for _, baseGoFile := range goFiles(dir) {
				tests = append(tests, startTest(dir, baseGoFile))
			}
		}
	}

	failed := false
	resCount := map[string]int{}
	for _, test := range tests {
		<-test.donec
		status := "ok  "
		errStr := ""
		if _, isSkip := test.err.(skipError); isSkip {
			test.err = nil
			errStr = "unexpected skip for " + path.Join(test.dir, test.gofile) + ": " + errStr
			status = "FAIL"
		}
		if test.err != nil {
			status = "FAIL"
			errStr = test.err.Error()
		}
		if status == "FAIL" {
			failed = true
		}
		resCount[status]++
		if status == "skip" && !*verbose && !*showSkips {
			continue
		}
		dt := fmt.Sprintf("%.3fs", test.dt.Seconds())
		if status == "FAIL" {
			fmt.Printf("# go run run.go -- %s\n%s\nFAIL\t%s\t%s\n",
				path.Join(test.dir, test.gofile),
				errStr, test.goFileName(), dt)
			continue
		}
		if !*verbose {
			continue
		}
		fmt.Printf("%s\t%s\t%s\n", status, test.goFileName(), dt)
	}

	if *summary {
		for k, v := range resCount {
			fmt.Printf("%5d %s\n", v, k)
		}
	}

	if failed {
		os.Exit(1)
	}
}
Example #18
0
func CompileBinary(scriptPath string, binaryPath string, goBuild bool) {
	scriptDir := filepath.Dir(scriptPath)
	binaryDir := filepath.Dir(binaryPath)

	// Open source file for modifications
	file, err := os.OpenFile(scriptPath, os.O_RDWR, 0)
	if err != nil {
		log.Fatalf("Could not open file: %s", err)
	}
	defer func() {
		if err := file.Close(); err != nil {
			log.Fatalf("Could not close file: %s", err)
		}
	}()

	// Comment hashbang line in source file
	hasHashbang := CheckForHashbang(file)
	if hasHashbang {
		CommentHashbang(file, "//")
	}
	defer func() {
		// Restore hashbang line in source file
		if hasHashbang {
			CommentHashbang(file, "#!")
		}
		// Recover build panic and use it for log.Fatal after hashbang has been restored
		if r := recover(); r != nil {
			log.Fatal(r)
		}
	}()

	// Use "go build"
	if goBuild {
		// Get current directory
		currentDir, err := os.Getwd()
		if err != nil {
			panic(err)
		}
		currentDir, err = filepath.Abs(currentDir)
		if err != nil {
			panic(err)
		}
		if currentDir != scriptDir {
			// Change into scripts directory
			if err := os.Chdir(scriptDir); err != nil {
				panic(err)
			}
			defer func() {
				// Go back to previous directory
				if err := os.Chdir(currentDir); err != nil {
					panic(err)
				}
			}()
		}

		// Build current/scripts directory
		out, err := exec.Command("go", "build", "-o", binaryPath).CombinedOutput()
		if err != nil {
			panic(fmt.Errorf("%s\n%s\n", err, out))
		}

	} else {
		// Set toolchain
		archChar, err := build.ArchChar(runtime.GOARCH)
		if err != nil {
			panic(err)
		}

		// Compile source file
		objectPath := filepath.Join(binaryDir, "_go_."+archChar)
		cmd := exec.Command(filepath.Join(build.ToolDir, archChar+"g"), "-o", objectPath, scriptPath)
		out, err := cmd.CombinedOutput()
		if err != nil {
			panic(fmt.Errorf("%s\n%s", cmd.Args, out))
		}

		// Link executable
		out, err = exec.Command(filepath.Join(build.ToolDir, archChar+"l"), "-o", binaryPath, objectPath).CombinedOutput()
		if err != nil {
			panic(fmt.Errorf("Linker failed: %s\n%s", err, out))
		}

		// Cleaning
		if err := os.Remove(objectPath); err != nil {
			panic(fmt.Errorf("Could not remove object file: %s", err))
		}
	}
}
Example #19
0
func main() {
	flag.Parse()

	// Disable parallelism if printing
	if *verbose {
		*numParallel = 1
	}

	ratec = make(chan bool, *numParallel)
	rungatec = make(chan bool, *runoutputLimit)
	var err error
	letter, err = build.ArchChar(build.Default.GOARCH)
	check(err)
	gc = letter + "g"
	ld = letter + "l"

	var tests []*test
	if flag.NArg() > 0 {
		for _, arg := range flag.Args() {
			if arg == "-" || arg == "--" {
				// Permit running:
				// $ go run run.go - env.go
				// $ go run run.go -- env.go
				// $ go run run.go - ./fixedbugs
				// $ go run run.go -- ./fixedbugs
				continue
			}
			if fi, err := os.Stat(arg); err == nil && fi.IsDir() {
				for _, baseGoFile := range goFiles(arg) {
					tests = append(tests, startTest(arg, baseGoFile))
				}
			} else if strings.HasSuffix(arg, ".go") {
				dir, file := filepath.Split(arg)
				tests = append(tests, startTest(dir, file))
			} else {
				log.Fatalf("can't yet deal with non-directory and non-go file %q", arg)
			}
		}
	} else {
		for _, dir := range dirs {
			for _, baseGoFile := range goFiles(dir) {
				tests = append(tests, startTest(dir, baseGoFile))
			}
		}
	}

	failed := false
	resCount := map[string]int{}
	for _, test := range tests {
		<-test.donec
		_, isSkip := test.err.(skipError)
		errStr := "pass"
		if test.err != nil {
			errStr = test.err.Error()
			if !isSkip {
				failed = true
			}
		}
		if isSkip && !skipOkay[path.Join(test.dir, test.gofile)] {
			errStr = "unexpected skip for " + path.Join(test.dir, test.gofile) + ": " + errStr
			isSkip = false
			failed = true
		}
		resCount[errStr]++
		if isSkip && !*verbose && !*showSkips {
			continue
		}
		if !*verbose && test.err == nil {
			continue
		}
		fmt.Printf("# go run run.go -- %s\n%-20s %-20s: %s\n", path.Join(test.dir, test.gofile), test.action, test.goFileName(), errStr)
	}

	if *summary {
		for k, v := range resCount {
			fmt.Printf("%5d %s\n", v, k)
		}
	}

	if failed {
		os.Exit(1)
	}
}
Example #20
0
File: run.go Project: joninvski/go
func main() {
	flag.Parse()
	if *verbose {
		*numParallel = 1
	}

	ratec = make(chan bool, *numParallel)
	var err error
	letter, err = build.ArchChar(build.DefaultContext.GOARCH)
	check(err)
	gc = letter + "g"
	ld = letter + "l"

	var tests []*test
	if flag.NArg() > 0 {
		for _, arg := range flag.Args() {
			if arg == "-" || arg == "--" {
				// Permit running either:
				// $ go run run.go - env.go
				// $ go run run.go -- env.go
				continue
			}
			if !strings.HasSuffix(arg, ".go") {
				log.Fatalf("can't yet deal with non-go file %q", arg)
			}
			dir, file := filepath.Split(arg)
			tests = append(tests, startTest(dir, file))
		}
	} else {
		for _, dir := range dirs {
			for _, baseGoFile := range goFiles(dir) {
				tests = append(tests, startTest(dir, baseGoFile))
			}
		}
	}

	failed := false
	resCount := map[string]int{}
	for _, test := range tests {
		<-test.donec
		_, isSkip := test.err.(skipError)
		errStr := "pass"
		if isSkip {
			errStr = "skip"
		}
		if test.err != nil {
			errStr = test.err.Error()
			if !isSkip {
				failed = true
			}
		}
		resCount[errStr]++
		if isSkip && !*verbose && !*showSkips {
			continue
		}
		if !*verbose && test.err == nil {
			continue
		}
		fmt.Printf("%-10s %-20s: %s\n", test.action, test.goFileName(), errStr)
	}

	if *summary {
		for k, v := range resCount {
			fmt.Printf("%5d %s\n", v, k)
		}
	}

	if failed {
		os.Exit(1)
	}
}
Example #21
0
func main() {
	var binaryDir, binaryPath string

	// == Flags
	force := flag.Bool("f", false, "force compilation")

	flag.Usage = usage
	flag.Parse()

	if flag.NArg() == 0 {
		usage()
	}

	log.SetFlags(0)
	log.SetPrefix("ERROR: ")

	// == Paths
	pkg, err := build.Import("", build.Default.GOROOT, build.FindOnly)
	if err != nil {
		log.Fatalf("GOROOT is not set: %s", err)
	}

	scriptPath := flag.Args()[0]
	scriptDir, scriptName := filepath.Split(scriptPath)
	ext := filepath.Ext(scriptName)

	// Global directory
	if exist(pkg.BinDir) { // "GOROOT" could be into a directory not mounted
		// Absolute path to calculate its hash.
		scriptDirAbs, err := filepath.Abs(scriptDir)
		if err != nil {
			log.Fatalf("Could not get absolute path: %s", err)
		}

		// generates a hash for the file
		crc := adler32.Checksum([]byte(scriptDirAbs))

		binaryDir = filepath.Join(pkg.PkgRoot, filepath.Base(build.ToolDir),
			SUBDIR, strconv.FormatUint(uint64(crc), 10))
	} else {
		// Local directory; ready to work in shared filesystems
		binaryDir = filepath.Join(SUBDIR, filepath.Base(build.ToolDir))
	}

	binaryPath = filepath.Join(binaryDir, strings.Replace(scriptName, ext, "", 1))
	// Windows does not like running binaries without the ".exe" extension
	if runtime.GOOS == "windows" {
		binaryPath += ".exe"
	}

	// Check directory
	if !exist(binaryDir) {
		if err := os.MkdirAll(binaryDir, 0750); err != nil {
			log.Fatalf("Could not make directory: %s", err)
		}
	}

	// == Run and exit
	if !*force && exist(binaryPath) {
		scriptMtime := getTime(scriptPath)
		binaryMtime := getTime(binaryPath)

		// If the script was not modified
		if scriptMtime.Equal(binaryMtime) || scriptMtime.Before(binaryMtime) {
			RunAndExit(binaryPath)
		}
	}

	// == Compile and link
	file, err := os.OpenFile(scriptPath, os.O_RDWR, 0)
	if err != nil {
		log.Fatalf("Could not open file: %s", err)
	}
	defer file.Close()

	hasInterpreter := checkInterpreter(file)
	if hasInterpreter { // comment interpreter line
		file.Seek(0, 0)
		if _, err = file.Write([]byte("//")); err != nil {
			log.Fatalf("could not comment the line interpreter: %s", err)
		}
	}

	// Set toolchain
	archChar, err := build.ArchChar(runtime.GOARCH)
	if err != nil {
		log.Fatal(err)
	}

	// == Compile source file
	objectPath := filepath.Join(binaryDir, "_go_."+archChar)
	cmd := exec.Command(filepath.Join(build.ToolDir, archChar+"g"),
		"-o", objectPath, scriptPath)
	out, err := cmd.CombinedOutput()

	if hasInterpreter { // comment out interpreter line
		file.Seek(0, 0)
		if _, err := file.Write([]byte("#!")); err != nil {
			log.Fatalf("could not comment out the line interpreter: %s", err)
		}
	}
	if err != nil {
		log.Fatalf("%s\n%s", cmd.Args, out)
	}

	// == Link executable
	out, err = exec.Command(filepath.Join(build.ToolDir, archChar+"l"),
		"-o", binaryPath, objectPath).CombinedOutput()
	if err != nil {
		log.Fatalf("Linker failed: %s\n%s", err, out)
	}

	// == Cleaning
	if err := os.Remove(objectPath); err != nil {
		log.Fatalf("Could not remove object file: %s", err)
	}

	RunAndExit(binaryPath)
}