code review 5316043: gc: clean up printing.

src/cmd/gc/lex.c

 // 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.
 
 #include        <u.h>
 #include        <libc.h>
 #include        "go.h"
 #include        "y.tab.h"
 #include        <ar.h>
 
@@ skipping 11 matching lines @@
 static void     lexinit1(void);
 static void     lexfini(void);
 static void     yytinit(void);
 static int      getc(void);
 static void     ungetc(int);
 static int32    getr(void);
 static int      escchar(int, int*, vlong*);
 static void     addidir(char*);
 static int      getlinepragma(void);
 static char *goos, *goarch, *goroot;
+
+// Compiler experiments.
+// These are controlled by the GCEXPERIMENT environment
+// variable recorded when the compiler is built.
+static struct {
+        char *name;
+        int *val;
+} exper[] = {
+        {"rune32", &rune32},
+};
+
+static void
+addexp(char *s)
+{
+        int i;
+········
+        for(i=0; i<nelem(exper); i++) {
+                if(strcmp(exper[i].name, s) == 0) {
+                        *exper[i].val = 1;
+                        return;
+                }
+        }
+········
+        print("unknown experiment %s\n", s);
+        exits("unknown experiment");
+}
+
+static void
+setexp(void)
+{
+        char *f[20];
+        int i, nf;
+········
+        // The makefile #defines GOEXPERIMENT for us.
+        nf = getfields(GOEXPERIMENT, f, nelem(f), 1, ",");
+        for(i=0; i<nf; i++)
+                addexp(f[i]);
+}
+
+char*
+expstring(void)
+{
+        int i;
+        static char buf[512];
+
+        strcpy(buf, "X");
+        for(i=0; i<nelem(exper); i++)
+                if(*exper[i].val)
+                        seprint(buf+strlen(buf), buf+sizeof buf, ",%s", exper[i].name);
+        if(strlen(buf) == 1)
+                strcpy(buf, "X,none");
+        buf[1] = ':';
+        return buf;
+}
 
 // Our own isdigit, isspace, isalpha, isalnum that take care·
 // of EOF and other out of range arguments.
 static int
 yy_isdigit(int c)
 {
         return c >= 0 && c <= 0xFF && isdigit(c);
 }
 
 static int
@@ skipping 45 matching lines @@
         print("  -e no limit on number of errors printed\n");
         print("  -f print stack frame structure\n");
         print("  -h panic on an error\n");
         print("  -m print about moves to heap\n");
         print("  -o file specify output file\n");
         print("  -p assumed import path for this code\n");
         print("  -s disable escape analysis\n");
         print("  -u disable package unsafe\n");
         print("  -w print the parse tree after typing\n");
         print("  -x print lex tokens\n");
-        exits(0);
+        exits("usage");
 }
 
 void
 fault(int s)
 {
         USED(s);
 
         // If we've already complained about things
         // in the program, don't bother complaining
         // about the seg fault too; let the user clean up
@@ skipping 29 matching lines @@
 
         typepkg = mkpkg(strlit("type"));
         typepkg->name = "type";
 
         unsafepkg = mkpkg(strlit("unsafe"));
         unsafepkg->name = "unsafe";
 
         goroot = getgoroot();
         goos = getgoos();
         goarch = thestring;
+········
+        setexp();
 
         outfile = nil;
         ARGBEGIN {
         default:
                 c = ARGC();
                 if(c >= 0 && c < sizeof(debug))
                         debug[c]++;
                 break;
 
         case 'o':
                 outfile = EARGF(usage());
                 break;
 ········
         case 'p':
                 myimportpath = EARGF(usage());
                 break;
 
         case 'I':
                 addidir(EARGF(usage()));
                 break;
 ········
         case 'u':
                 safemode = 1;
                 break;
 
         case 'V':
-                print("%cg version %s\n", thechar, getgoversion());
+                p = expstring();
+                if(strcmp(p, "X:none") == 0)
+                        p = "";
+                print("%cg version %s%s%s\n", thechar, getgoversion(), *p ? " " : "", p);
                 exits(0);
         } ARGEND
 
         if(argc < 1)
                 usage();
 
         // special flag to detect compilation of package runtime
         compiling_runtime = debug['+'];
 
         pathname = mal(1000);
         if(getwd(pathname, 999) == 0)
                 strcpy(pathname, "/???");
 
         if(yy_isalpha(pathname[0]) && pathname[1] == ':') {
                 // On Windows.
                 windows = 1;
 
                 // Canonicalize path by converting \ to / (Windows accepts both).
                 for(p=pathname; *p; p++)
                         if(*p == '\\')
                                 *p = '/';
         }
 
         fmtinstallgo();
-        fmtinstall('B', Bconv); // big numbers
-        fmtinstall('F', Fconv); // big float numbers
-
         betypeinit();
         if(widthptr == 0)
                 fatal("betypeinit failed");
 
         lexinit();
         typeinit();
         lexinit1();
         yytinit();
 
         blockgen = 1;
@@ skipping 314 matching lines @@
                 }
         }
 ········
         // check object header
         p = Brdstr(imp, '\n', 1);
         if(strcmp(p, "empty archive") != 0) {
                 if(strncmp(p, "go object ", 10) != 0) {
                         yyerror("import %s: not a go object file", file);
                         errorexit();
                 }
-                q = smprint("%s %s %s", getgoos(), thestring, getgoversion());
+                q = smprint("%s %s %s %s", getgoos(), thestring, getgoversion(), expstring());
                 if(strcmp(p+10, q) != 0) {
                         yyerror("import %s: object is [%s] expected [%s]", file, p+10, q);
                         errorexit();
                 }
                 free(q);
         }
 
         // assume files move (get installed)
         // so don't record the full path.
         linehist(file + len - path->len - 2, -1, 1);    // acts as #pragma lib
@@ skipping 1159 matching lines @@
         Sym *s, *s1;
 
         // byte alias
         s = lookup("byte");
         s->lexical = LNAME;
         bytetype = typ(TUINT8);
         bytetype->sym = s;
         s1 = pkglookup("byte", builtinpkg);
         s1->lexical = LNAME;
         s1->def = typenod(bytetype);
+
+        // rune alias
+        s = lookup("rune");
+        s->lexical = LNAME;
+        if(rune32)
+                runetype = typ(TINT32);
+        else
+                runetype = typ(TINT);
+        runetype->sym = s;
+        s1 = pkglookup("rune", builtinpkg);
+        s1->lexical = LNAME;
+        s1->def = typenod(runetype);
 }
 
 static void
 lexfini(void)
 {
         Sym *s;
         int lex, etype, i;
         Val v;
 
         for(i=0; i<nelem(syms); i++) {
@@ skipping 20 matching lines @@
                 s = lookup(typedefs[i].name);
                 if(s->def == N)
                         s->def = typenod(types[typedefs[i].etype]);
         }
 
         // there's only so much table-driven we can handle.
         // these are special cases.
         s = lookup("byte");
         if(s->def == N)
                 s->def = typenod(bytetype);
+
+        s = lookup("rune");
+        if(s->def == N)
+                s->def = typenod(runetype);
 
         types[TNIL] = typ(TNIL);
         s = lookup("nil");
         if(s->def == N) {
                 v.ctype = CTNIL;
                 s->def = nodlit(v);
                 s->def->sym = s;
         }
 ········
         s = lookup("iota");
@@ skipping 221 matching lines @@
                         p = infile;
                 else
                         p = p+1;
                 snprint(namebuf, sizeof(namebuf), "%s", p);
                 p = strrchr(namebuf, '.');
                 if(p != nil)
                         *p = 0;
                 outfile = smprint("%s.%c", namebuf, thechar);
         }
 }