code review 5622058: cmd/dist: generate files for package runtime

src/cmd/dist/build.c

 // Copyright 2012 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.
 
 #include "a.h"
 #include "arg.h"
 
 /*
  * Initialization for any invocation.
  */
@@ skipping 81 matching lines @@
         goos = btake(&b);
         if(find(goos, okgoos, nelem(okgoos)) < 0)
                 fatal("unknown $GOOS %s", goos);
 
         p = bpathf(&b, "%s/include/u.h", goroot);
         if(!isfile(p)) {
                 fatal("$GOROOT is not set correctly or not exported\n"
                         "\tGOROOT=%s\n"
                         "\t%s does not exist", goroot, p);
         }
-        
+
         xgetenv(&b, "GOHOSTARCH");
         if(b.len > 0)
                 gohostarch = btake(&b);
 
         if(find(gohostarch, okgoarch, nelem(okgoarch)) < 0)
                 fatal("unknown $GOHOSTARCH %s", gohostarch);
 
         xgetenv(&b, "GOARCH");
         if(b.len == 0)
                 bwritestr(&b, gohostarch);
@@ skipping 362 matching lines @@
         {"zgoos_", mkzgoos},
         {"zruntime_defs_", mkzruntimedefs},
         {"zversion.go", mkzversion},
 };
 
 // install installs the library, package, or binary associated with dir,
 // which is relative to $GOROOT/src.
 static void
 install(char *dir)
 {
-        char *name, *p, *elem, *prefix;
+        char *name, *p, *elem, *prefix, *exe;
         bool islib, ispkg, isgo, stale;
         Buf b, b1, path;
         Vec compile, files, link, go, missing, clean, lib, extra;
         Time ttarg, t;
         int i, j, k, n;
 
         binit(&b);
         binit(&b1);
         binit(&path);
         vinit(&compile);
         vinit(&files);
         vinit(&link);
         vinit(&go);
         vinit(&missing);
         vinit(&clean);
         vinit(&lib);
         vinit(&extra);
 ········
         // path = full path to dir.
         bpathf(&path, "%s/src/%s", goroot, dir);
         name = lastelem(dir);
 
         islib = hasprefix(dir, "lib") || streq(dir, "cmd/cc") || streq(dir, "cmd/gc");
         ispkg = hasprefix(dir, "pkg");
         isgo = ispkg || streq(dir, "cmd/go");
 
+        exe = "";
+        if(streq(gohostos, "windows"))
+                exe = ".exe";
 ········
         // Start final link command line.
         // Note: code below knows that link.p[2] is the target.
         if(islib) {
                 // C library.
                 vadd(&link, "ar");
                 vadd(&link, "rsc");
                 prefix = "";
                 if(!hasprefix(name, "lib"))
                         prefix = "lib";
                 vadd(&link, bpathf(&b, "%s/pkg/obj/%s%s.a", goroot, prefix, name));
         } else if(ispkg) {
                 // Go library (package).
                 vadd(&link, bpathf(&b, "%s/bin/tool/pack", goroot));
                 vadd(&link, "grc");
                 p = bprintf(&b, "%s/pkg/%s_%s/%s", goroot, goos, goarch, dir+4);
                 *xstrrchr(p, '/') = '\0';
                 xmkdirall(p);
                 vadd(&link, bpathf(&b, "%s/pkg/%s_%s/%s.a", goroot, goos, goarch, dir+4));
         } else if(streq(dir, "cmd/go")) {
                 // Go command.
                 vadd(&link, bpathf(&b, "%s/bin/tool/%sl", goroot, gochar));
                 vadd(&link, "-o");
-                vadd(&link, bpathf(&b, "%s/bin/tool/go_bootstrap", goroot));
+                vadd(&link, bpathf(&b, "%s/bin/tool/go_bootstrap%s", goroot, exe));
         } else {
                 // C command.
                 vadd(&link, "gcc");
                 vadd(&link, "-o");
-                vadd(&link, bpathf(&b, "%s/bin/tool/%s", goroot, name));
+                vadd(&link, bpathf(&b, "%s/bin/tool/%s%s", goroot, name, exe));
         }
         ttarg = mtime(link.p[2]);
 
         // Gather files that are sources for this target.
         // Everything in that directory, and any target-specific
         // additions.
         xreaddir(&files, bstr(&path));
         for(i=0; i<nelem(deptab); i++) {
                 if(hasprefix(dir, deptab[i].prefix)) {
                         for(j=0; (p=deptab[i].dep[j])!=nil; j++) {
                                 breset(&b1);
                                 bwritestr(&b1, p);
                                 bsubst(&b1, "$GOROOT", goroot);
                                 bsubst(&b1, "$GOOS", goos);
                                 bsubst(&b1, "$GOARCH", goarch);
                                 p = bstr(&b1);
                                 if(hassuffix(p, ".a")) {
-                                        vadd(&lib, p);
+                                        vadd(&lib, bpathf(&b, "%s", p));
                                         continue;
                                 }
                                 if(hassuffix(p, "/*")) {
                                         bpathf(&b, "%s/%s", bstr(&path), p);
                                         b.len -= 2;
                                         xreaddir(&extra, bstr(&b));
                                         bprintf(&b, "%s", p);
                                         b.len -= 2;
                                         for(k=0; k<extra.len; k++)
                                                 vadd(&files, bpathf(&b1, "%s/%s", bstr(&b), extra.p[k]));
@@ skipping 73 matching lines @@
                 copy(bpathf(&b, "%s/signals_GOOS.h", workdir),
                         bpathf(&b1, "%s/signals_%s.h", bstr(&path), goos));
         }
 
         // Generate any missing files; regenerate existing ones.
         for(i=0; i<files.len; i++) {
                 p = files.p[i];
                 elem = lastelem(p);
                 for(j=0; j<nelem(gentab); j++) {
                         if(hasprefix(elem, gentab[j].nameprefix)) {
+                                if(vflag > 1)
+                                        xprintf("generate %s\n", p);
                                 gentab[j].gen(bstr(&path), p);
                                 // Do not add generated file to clean list.
                                 // In pkg/runtime, we want to be able to
                                 // build the package with the go tool,
                                 // and it assumes these generated files already
                                 // exist (it does not know how to build them).
                                 // The 'clean' command can remove
                                 // the generated files.
                                 goto built;
                         }
@@ skipping 48 matching lines @@
                         vadd(&compile, "-I");
                         vadd(&compile, bpathf(&b, "%s/include", goroot));
 ························
                         vadd(&compile, "-I");
                         vadd(&compile, bstr(&path));
 ········
                         // runtime/goos.c gets the default constants hard-coded.
                         if(streq(name, "goos.c")) {
                                 vadd(&compile, bprintf(&b, "-DGOOS=\"%s\"", goos));
                                 vadd(&compile, bprintf(&b, "-DGOARCH=\"%s\"", goarch));
-                                vadd(&compile, bprintf(&b, "-DGOROOT=\"%s\"", goroot));
+                                bprintf(&b1, "%s", goroot);
+                                bsubst(&b1, "\\", "\\\\");  // turn into C string
+                                vadd(&compile, bprintf(&b, "-DGOROOT=\"%s\"", bstr(&b1)));
                                 vadd(&compile, bprintf(&b, "-DGOVERSION=\"%s\"", goversion));
                         }
 ········
                         // gc/lex.c records the GOEXPERIMENT setting used during the build.
                         if(streq(name, "lex.c")) {
                                 xgetenv(&b, "GOEXPERIMENT");
                                 vadd(&compile, bprintf(&b1, "-DGOEXPERIMENT=\"%s\"", bstr(&b)));
                         }
                 } else {
                         // Supporting files for a Go package.
@@ skipping 375 matching lines @@
 /*
  * command implementations
  */
 
 void
 usage(void)
 {
         xprintf("usage: go tool dist [command]\n"
                 "Commands are:\n"
                 "\n"
-                "banner       print installation banner\n"
-                "bootstrap    rebuild everything\n"
-                "clean        deletes all built files\n"
-                "env [-p]     print environment (-p: include $PATH)\n"
-                "install      install individual directory\n"
-                "version      print Go version\n"
+                "banner         print installation banner\n"
+                "bootstrap      rebuild everything\n"
+                "clean          deletes all built files\n"
+                "env [-p]       print environment (-p: include $PATH)\n"
+                "install [dir]  install individual directory\n"
+                "version        print Go version\n"
                 "\n"
                 "All commands take -v flags to emit extra information.\n"
         );
         xexit(2);
 }
 
 // The env command prints the default environment.
 void
 cmdenv(int argc, char **argv)
 {
         bool pflag;
-        Buf b;
- ·······
+        char *sep;
+        Buf b, b1;
+        char *format;
+
         binit(&b);
-
+        binit(&b1);
+
+        format = "%s=\"%s\"";
         pflag = 0;
         ARGBEGIN{
         case 'p':
                 pflag = 1;
                 break;
         case 'v':
                 vflag++;
                 break;
+        case 'w':
+                format = "set %s=%s\n";
+                break;
         default:
                 usage();
         }ARGEND
 
         if(argc > 0)
                 usage();
 ········
-        xprintf("GOROOT=\"%s\"\n", goroot);
-        xprintf("GOARCH=%s\n", goarch);
-        xprintf("GOOS=%s\n", goos);
+        xprintf(format, "GOROOT", goroot);
+        xprintf(format, "GOARCH", goarch);
+        xprintf(format, "GOOS", goos);
         if(pflag) {
+                sep = ":";
+                if(streq(gohostos, "windows"))
+                        sep = ";";
                 xgetenv(&b, "PATH");
-                xprintf("PATH=%s:%s\n", gobin, bstr(&b));
+                bprintf(&b1, "%s%s%s", gobin, sep, bstr(&b));
+                xprintf(format, "PATH", bstr(&b1));
         }
 
         bfree(&b);
+        bfree(&b1);
 }
 
 // The bootstrap command runs a build from scratch,
 // stopping at having installed the go_bootstrap command.
 void
 cmdbootstrap(int argc, char **argv)
 {
         int i;
         Buf b;
         char *p;
@@ skipping 63 matching lines @@
 
         for(i=0; i<argc; i++)
                 install(argv[i]);
 }
 
 // Clean deletes temporary objects.
 // Clean -i deletes the installed objects too.
 void
 cmdclean(int argc, char **argv)
 {
-        bool iflag;
-········
-        iflag = 0;
         ARGBEGIN{
         case 'v':
                 vflag++;
                 break;
         default:
                 usage();
         }ARGEND
 
         if(argc > 0)
                 usage();
@@ skipping 65 matching lines @@
                 break;
         default:
                 usage();
         }ARGEND
 
         if(argc > 0)
                 usage();
 
         xprintf("%s\n", findgoversion());
 }