code review 879041: Change goyacc to be reentrant.

src/cmd/goyacc/units.y

 // Derived from Plan 9's /sys/src/cmd/units.y
 // http://plan9.bell-labs.com/sources/plan9/sys/src/cmd/units.y
 //
 // Copyright (C) 2003, Lucent Technologies Inc. and others. All Rights Reserved.
 // Portions Copyright 2009 The Go Authors.  All Rights Reserved.
 // Distributed under the terms of the Lucent Public License Version 1.02
 // See http://plan9.bell-labs.com/plan9/license.html
 
 %{
 
@@ skipping 197 matching lines @@
                 $$.vval = $1;
         }
 |       '(' expr ')'
         {
                 $$ = $2;
         }
 %%
 
 type UnitsLex int
 
-func (l UnitsLex) Lex(yylval *YYSTYPE) int {
+func (l UnitsLex) Lex(yylval *yySymType) int {
         var c, i int
 
         c = peekrune
         peekrune = ' '
 
 loop:
         if (c >= '0' && c <= '9') || c == '.' {
                 goto numb
         }
         if ralpha(c) {
@@ skipping 37 matching lines @@
         for i = 0; ; i++ {
                 sym += string(c)
                 c = getrune()
                 if !rdigit(c) {
                         break
                 }
         }
         peekrune = c
         f, err := strconv.Atof64(sym)
         if err != nil {
-                fmt.Printf("error converting %v", sym)
+                fmt.Printf("error converting %v\n", sym)
                 f = 0
         }
         yylval.vval = f
         return VAL
 }
 
 func main() {
         var file string
 
         flag.BoolVar(&vflag, "v", false, "verbose")
 
         flag.Parse()
 
         file = os.Getenv("GOROOT") + "/src/cmd/goyacc/units.txt"
         if flag.NArg() > 0 {
                 file = flag.Arg(0)
         }
 
         f, err := os.Open(file, os.O_RDONLY, 0)
         if err != nil {
-                fmt.Printf("error opening %v: %v", file, err)
+                fmt.Printf("error opening %v: %v\n", file, err)
                 os.Exit(1)
         }
         fi = bufio.NewReader(f)
 
         one.vval = 1
 
         /*
          * read the 'units' file to
          * develope a database
          */
         lineno = 0
         for {
                 lineno++
                 if readline() {
                         break
                 }
                 if len(line) == 0 || line[0] == '/' {
                         continue
                 }
                 peekrune = ':'
-                Parse(UnitsLex(0))
+                yyParse(UnitsLex(0))
         }
 
         /*
          * read the console to
          * print ratio of pairs
          */
         fi = bufio.NewReader(os.NewFile(0, "stdin"))
 
         lineno = 0
         for {
                 if (lineno & 1) != 0 {
                         fmt.Printf("you want: ")
                 } else {
                         fmt.Printf("you have: ")
                 }
                 if readline() {
                         break
                 }
                 peekrune = '?'
                 nerrors = 0
-                Parse(UnitsLex(0))
+                yyParse(UnitsLex(0))
                 if nerrors != 0 {
                         continue
                 }
                 if (lineno & 1) != 0 {
                         if specialcase(&retnode, &retnode2, &retnode1) {
                                 fmt.Printf("\tis %v\n", &retnode)
                         } else {
                                 div(&retnode, &retnode2, &retnode1)
                                 fmt.Printf("\t* %v\n", &retnode)
                                 div(&retnode, &retnode1, &retnode2)
@@ skipping 27 matching lines @@
  */
 func rdigit(c int) bool {
         switch c {
         case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
                 '.', 'e', '+', '-':
                 return true
         }
         return false
 }
 
+func yyError(s string) {
+        Error("syntax error, last name: %v", sym)
+}
+
 func Error(s string, v ...interface{}) {
-
-        /*
-         * hack to intercept message from yaccpar
-         */
-        if s == "syntax error" {
-                Error("syntax error, last name: %v", sym)
-                return
-        }
         fmt.Printf("%v: %v\n\t", lineno, line)
         fmt.Printf(s, v)
         fmt.Printf("\n")
 
         nerrors++
         if nerrors > 5 {
                 fmt.Printf("too many errors\n")
                 os.Exit(1)
         }
 }
@@ skipping 347 matching lines @@
         if l > Maxe {
                 Error("underflow in divide")
                 return 0
         }
         return a / b
 }
 
 func fadd(a, b float64) float64 {
         return a + b
 }