← Back to branch summary

~john-koepi/ubuntu/trusty/golang/default

« back to all changes in this revision

Viewing changes to .pc/009-goinstall_can_install_to_GOPATH.patch/src/cmd/goinstall/main.go

  • Committer: Bazaar Package Importer
  • Author(s): Ondřej Surý
  • Date: 2011-08-03 17:04:59 UTC
  • mfrom: (14.1.2 sid)
  • Revision ID: james.westby@ubuntu.com-20110803170459-wzd99m3567y80ila
Tags: 1:59-1
http://bugs.debian.org/634270
* Imported Upstream version 59
* Refresh patches to a new release
* Fix FTBFS on ARM (Closes: #634270)
* Update version.bash to work with Debian packaging and not hg
  repository

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/009-goinstall_can_install_to_GOPATH.patch/src/cmd/goinstall/main.go
2
2
// Use of this source code is governed by a BSD-style
3
3
// license that can be found in the LICENSE file.
4
4
 
5
 
// Experimental Go package installer; see doc.go.
6
 
 
7
5
package main
8
6
 
9
7
import (
11
9
        "exec"
12
10
        "flag"
13
11
        "fmt"
 
12
        "go/build"
14
13
        "go/token"
15
14
        "io/ioutil"
16
15
        "os"
39
38
        reportToDashboard = flag.Bool("dashboard", false, "report public packages at "+dashboardURL)
40
39
        logPkgs           = flag.Bool("log", true, "log installed packages to $GOROOT/goinstall.log for use by -a")
41
40
        update            = flag.Bool("u", false, "update already-downloaded packages")
 
41
        doInstall         = flag.Bool("install", true, "build and install")
42
42
        clean             = flag.Bool("clean", false, "clean the package directory before installing")
 
43
        nuke              = flag.Bool("nuke", false, "clean the package directory and target before installing")
 
44
        useMake           = flag.Bool("make", true, "use make to build and install")
43
45
        verbose           = flag.Bool("v", false, "verbose")
44
46
)
45
47
 
56
58
        fmt.Fprintf(os.Stderr, format, args...)
57
59
}
58
60
 
59
 
func vlogf(format string, args ...interface{}) {
 
61
func printf(format string, args ...interface{}) {
60
62
        if *verbose {
61
63
                logf(format, args...)
62
64
        }
160
162
                fmt.Fprintf(os.Stderr, "\t%s\n", pkg)
161
163
                os.Exit(2)
162
164
        }
 
165
        parents[pkg] = parent
163
166
        visit[pkg] = visiting
164
 
        parents[pkg] = parent
165
 
 
166
 
        vlogf("%s: visit\n", pkg)
 
167
        defer func() {
 
168
                visit[pkg] = done
 
169
        }()
167
170
 
168
171
        // Check whether package is local or remote.
169
172
        // If remote, download or update it.
170
 
        proot, pkg, err := findPackageRoot(pkg)
 
173
        tree, pkg, err := build.FindTree(pkg)
171
174
        // Don't build the standard library.
172
 
        if err == nil && proot.goroot && isStandardPath(pkg) {
 
175
        if err == nil && tree.Goroot && isStandardPath(pkg) {
173
176
                if parent == "" {
174
177
                        errorf("%s: can not goinstall the standard library\n", pkg)
175
178
                } else {
176
 
                        vlogf("%s: skipping standard library\n", pkg)
 
179
                        printf("%s: skipping standard library\n", pkg)
177
180
                }
178
 
                visit[pkg] = done
179
181
                return
180
182
        }
181
183
        // Download remote packages if not found or forced with -u flag.
182
184
        remote := isRemote(pkg)
183
 
        if remote && (err == ErrPackageNotFound || (err == nil && *update)) {
184
 
                vlogf("%s: download\n", pkg)
185
 
                err = download(pkg, proot.srcDir())
 
185
        dashReport := false
 
186
        if remote && (err == build.ErrNotFound || (err == nil && *update)) {
 
187
                printf("%s: download\n", pkg)
 
188
                dashReport, err = download(pkg, tree.SrcDir())
186
189
        }
187
190
        if err != nil {
188
191
                errorf("%s: %v\n", pkg, err)
189
 
                visit[pkg] = done
190
192
                return
191
193
        }
192
 
        dir := filepath.Join(proot.srcDir(), pkg)
 
194
        dir := filepath.Join(tree.SrcDir(), pkg)
193
195
 
194
196
        // Install prerequisites.
195
 
        dirInfo, err := scanDir(dir, parent == "")
 
197
        dirInfo, err := build.ScanDir(dir, parent == "")
196
198
        if err != nil {
197
199
                errorf("%s: %v\n", pkg, err)
198
 
                visit[pkg] = done
199
200
                return
200
201
        }
201
 
        if len(dirInfo.goFiles) == 0 {
 
202
        if len(dirInfo.GoFiles)+len(dirInfo.CgoFiles) == 0 {
202
203
                errorf("%s: package has no files\n", pkg)
203
 
                visit[pkg] = done
204
204
                return
205
205
        }
206
 
        for _, p := range dirInfo.imports {
 
206
        for _, p := range dirInfo.Imports {
207
207
                if p != "C" {
208
208
                        install(p, pkg)
209
209
                }
210
210
        }
 
211
        if errors {
 
212
                return
 
213
        }
211
214
 
212
215
        // Install this package.
213
 
        if !errors {
214
 
                isCmd := dirInfo.pkgName == "main"
215
 
                if err := domake(dir, pkg, proot, isCmd); err != nil {
216
 
                        errorf("installing: %v\n", err)
217
 
                } else if remote && *logPkgs {
218
 
                        // mark package as installed in $GOROOT/goinstall.log
219
 
                        logPackage(pkg)
220
 
                }
221
 
        }
222
 
        visit[pkg] = done
 
216
        if *useMake {
 
217
                err := domake(dir, pkg, tree, dirInfo.IsCommand())
 
218
                if err != nil {
 
219
                        errorf("%s: install: %v\n", pkg, err)
 
220
                        return
 
221
                }
 
222
        } else {
 
223
                script, err := build.Build(tree, pkg, dirInfo)
 
224
                if err != nil {
 
225
                        errorf("%s: install: %v\n", pkg, err)
 
226
                        return
 
227
                }
 
228
                if *nuke {
 
229
                        printf("%s: nuke\n", pkg)
 
230
                        script.Nuke()
 
231
                } else if *clean {
 
232
                        printf("%s: clean\n", pkg)
 
233
                        script.Clean()
 
234
                }
 
235
                if *doInstall {
 
236
                        if script.Stale() {
 
237
                                printf("%s: install\n", pkg)
 
238
                                if err := script.Run(); err != nil {
 
239
                                        errorf("%s: install: %v\n", pkg, err)
 
240
                                        return
 
241
                                }
 
242
                        } else {
 
243
                                printf("%s: up-to-date\n", pkg)
 
244
                        }
 
245
                }
 
246
        }
 
247
        if dashReport {
 
248
                maybeReportToDashboard(pkg)
 
249
        }
 
250
        if remote {
 
251
                // mark package as installed in $GOROOT/goinstall.log
 
252
                logPackage(pkg)
 
253
        }
 
254
        return
223
255
}
224
256
 
225
257
 
249
281
        cmd := exec.Command(arg[0], arg[1:]...)
250
282
        cmd.Stdin = bytes.NewBuffer(stdin)
251
283
        cmd.Dir = dir
252
 
        vlogf("%s: %s %s\n", dir, cmd.Path, strings.Join(arg[1:], " "))
 
284
        printf("%s: %s %s\n", dir, cmd.Path, strings.Join(arg[1:], " "))
253
285
        out, err := cmd.CombinedOutput()
254
286
        if err != nil {
255
287
                if !quiet || *verbose {
260
292
                        os.Stderr.Write(out)
261
293
                        fmt.Fprintf(os.Stderr, "--- %s\n", err)
262
294
                }
263
 
                return os.ErrorString("running " + arg[0] + ": " + err.String())
 
295
                return os.NewError("running " + arg[0] + ": " + err.String())
264
296
        }
265
297
        return nil
266
298
}