Remove GOBIN in PATH dependency; don't assume cwd is $G...

src/Make.pkg

 # Copyright 2009 The Go Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style
 # license that can be found in the LICENSE file.
 
 all: package
 package: _obj/$(TARG).a
 testpackage: _test/$(TARG).a
 
+# GNU Make syntax:

[rsc, 2009/12/11 21:51:17]

should be quoted home like in make.conf

+ifndef GOBIN
+GOBIN=$(HOME)/bin
+endif
+
+# ugly hack to deal with whitespaces in $GOBIN
+nullstring :=
+space := $(nullstring) # a space at the end
+QUOTED_GOBIN=$(subst $(space),\ ,$(GOBIN))
+
 # GNU Make 3.80 has a bug in lastword
 # elem=$(lastword $(subst /, ,$(TARG)))
 TARG_words=$(subst /, ,$(TARG))
 elem=$(word $(words $(TARG_words)),$(TARG_words))
 
 dir=$(patsubst %/$(elem),%,./$(TARG))
 
 # ugly hack to deal with whitespaces in $GOROOT
 nullstring :=
 space := $(nullstring) # a space at the end
 QUOTED_GOROOT=$(subst $(space),\ ,$(GOROOT))
 
 pkgdir=$(QUOTED_GOROOT)/pkg/$(GOOS)_$(GOARCH)
 
 INSTALLFILES=$(pkgdir)/$(TARG).a
 
 # The rest of the cgo rules are below, but these variable updates
 # must be done here so they apply to the main rules.
 GOFILES+=$(patsubst %.go,%.cgo1.go,$(CGOFILES))
 GOFILES+=$(patsubst %.go,%.cgo2.go,$(CGOFILES))
 OFILES+=$(patsubst %.go,%.cgo3.$O,$(CGOFILES))
 INSTALLFILES+=$(patsubst %.go,$(pkgdir)/$(dir)/$(elem)_%.so,$(CGOFILES))
 PREREQ+=$(patsubst %,%.make,$(DEPS))
 
 coverage:
-        gotest
-        6cov -g $(shell pwd) $O.out | grep -v '_test\.go:'
+        $(QUOTED_GOBIN)/gotest
+        $(QUOTED_GOBIN)/6cov -g $(shell pwd) $O.out | grep -v '_test\.go:'
 
 clean:
         rm -rf *.[$(OS)o] *.a [$(OS)].out *.cgo[12].go *.cgo[34].c *.so _obj _test _testmain.go $(CLEANFILES)
 
 test:
-        gotest
+        $(QUOTED_GOBIN)/gotest
 
 nuke: clean
         rm -f $(pkgdir)/$(TARG).a
 
 testpackage-clean:
         rm -f _test/$(TARG).a _gotest_.$O
 
 install: $(INSTALLFILES)
 
 $(pkgdir)/$(TARG).a: package
         @test -d $(QUOTED_GOROOT)/pkg && mkdir -p $(pkgdir)/$(dir)
         cp _obj/$(TARG).a "$@"
 
 _go_.$O: $(GOFILES) $(PREREQ)
-        $(GC) -o $@ $(GOFILES)
+        $(QUOTED_GOBIN)/$(GC) -o $@ $(GOFILES)
 
 _gotest_.$O: $(GOFILES) $(GOTESTFILES) $(PREREQ)
-        $(GC) -o $@ $(GOFILES) $(GOTESTFILES)
+        $(QUOTED_GOBIN)/$(GC) -o $@ $(GOFILES) $(GOTESTFILES)
 
 _obj/$(TARG).a: _go_.$O $(OFILES)
         @mkdir -p _obj/$(dir)
         rm -f _obj/$(TARG).a
-        gopack grc $@ _go_.$O $(OFILES)
+        $(QUOTED_GOBIN)/gopack grc $@ _go_.$O $(OFILES)
 
 _test/$(TARG).a: _gotest_.$O $(OFILES)
         @mkdir -p _test/$(dir)
         rm -f _test/$(TARG).a
-        gopack grc $@ _gotest_.$O $(OFILES)
+        $(QUOTED_GOBIN)/gopack grc $@ _gotest_.$O $(OFILES)
 
 importpath:
         @echo $(TARG)
 
 dir:
         @echo $(dir)
 
 %.make:
-        (cd $* && gomake)
+        (cd $* && $(QUOTED_GOBIN)/gomake)
 
 # To use cgo in a Go package, add a line
 #
 #       CGOFILES=x.go
 #
 # to the main Makefile.  This signals that cgo should process x.go.
 # There are two optional variables to set, CGO_CFLAGS and CGO_LDFLAGS,
 # which specify compiler and linker flags to use when compiling
 # (using gcc) the C support for x.go.
 
 # Cgo translates each x.go file listed in $(CGOFILES) into
 #
 #       x.cgo1.go - basic translation of x.go
 #       x.cgo2.go - declarations needed for x.cgo1.go; imports "unsafe"
 #       x.cgo3.c - C trampoline code to be compiled with 6c and linked into the package
 #       x.cgo4.c - C implementations compiled with gcc to create dynamic library
 #
 %.cgo1.go %.cgo2.go %.cgo3.c %.cgo4.c: %.go
-        CGOPKGPATH=$(dir) cgo $(CGO_CFLAGS) $*.go
+        CGOPKGPATH=$(dir) $(QUOTED_GOBIN)/cgo $(CGO_CFLAGS) $*.go
 
 # The rules above added x.cgo1.go and x.cgo2.go to $(GOFILES),
 # added x.cgo3.$O to $OFILES, and added the installed copy of
 # package_x.so (built from x.cgo4.c) to $(INSTALLFILES).
 
 # Compile x.cgo3.c with 6c; needs access to the runtime headers.
 RUNTIME_CFLAGS_amd64=-D_64BIT
 RUNTIME_CFLAGS=-I"$(GOROOT)/src/pkg/runtime" $(RUNTIME_CFLAGS_$(GOARCH))
 %.cgo3.$O: %.cgo3.c
-        $(CC) $(CFLAGS) $(RUNTIME_CFLAGS) $*.cgo3.c
+        $(QUOTED_GOBIN)/$(CC) $(CFLAGS) $(RUNTIME_CFLAGS) $*.cgo3.c
 
 # Have to run gcc with the right size argument on hybrid 32/64 machines.
 _CGO_CFLAGS_386=-m32
 _CGO_CFLAGS_amd64=-m64
 _CGO_LDFLAGS_freebsd=-shared -lpthread -lm
 _CGO_LDFLAGS_linux=-shared -lpthread -lm
 _CGO_LDFLAGS_darwin=-dynamiclib -Wl,-undefined,dynamic_lookup
 
 
 # Compile x.cgo4.c with gcc to make package_x.so.
 %.cgo4.o: %.cgo4.c
         gcc $(_CGO_CFLAGS_$(GOARCH)) -fPIC -O2 -o $@ -c $(CGO_CFLAGS) $*.cgo4.c
 
 $(elem)_%.so: %.cgo4.o
         gcc $(_CGO_CFLAGS_$(GOARCH)) -o $@ $*.cgo4.o $(CGO_LDFLAGS)  $(_CGO_LDFLAGS_$(GOOS))
 
 $(pkgdir)/$(dir)/$(elem)_%.so: $(elem)_%.so
         @test -d $(QUOTED_GOROOT/pkg && mkdir -p $(pkgdir)/$(dir)
         cp $(elem)_$*.so "$@"
 
 # Generic build rules.
 # These come last so that the rules above can override them
 # for more specific file names.
 %.$O: %.c
-        $(CC) $(CFLAGS) $*.c
+        $(QUOTED_GOBIN)/$(CC) $(CFLAGS) $*.c
 
 %.$O: %.s
-        $(AS) $*.s
+        $(QUOTED_GOBIN)/$(AS) $*.s
 
 %.$O: $(HFILES)