code review 879041: Change goyacc to be reentrant.

src/cmd/goyacc/goyacc.go

 /*
 Derived from Inferno's utils/iyacc/yacc.c
 http://code.google.com/p/inferno-os/source/browse/utils/iyacc/yacc.c
 
 This copyright NOTICE applies to all files in this directory and
 subdirectories, unless another copyright notice appears in a given
 file or subdirectory.  If you take substantial code from this software to use in
 other programs, you must somehow include with it an appropriate
 copyright notice that includes the copyright notice and the other
 notices below.  It is fine (and often tidier) to do that in a separate
@@ skipping 88 matching lines @@
         MUSTLOOKAHEAD
 )
 
 // flags for a rule having an action, and being reduced
 const (
         ACTFLAG = 1 << (iota + 2)
         REDFLAG
 )
 
 // output parser flags
-const YYFLAG = -1000
+const yyFlag = -1000
 
 // parse tokens
 const (
         IDENTIFIER = PRIVATE + iota
         MARK
         TERM
         LEFT
         RIGHT
         BINARY
         PREC
@@ skipping 379 matching lines @@
         // put out non-literal terminals
         for i := TOKSTART; i <= ntokens; i++ {
                 // non-literals
                 c := tokset[i].name[0]
                 if c != ' ' && c != '$' {
                         fmt.Fprintf(ftable, "const\t%v\t= %v\n", tokset[i].name, tokset[i].value)
                 }
         }
 
         // put out names of token names
-        fmt.Fprintf(ftable, "var\tToknames\t =[]string {\n")
+        fmt.Fprintf(ftable, "var\tyyToknames\t =[]string {\n")
         for i := TOKSTART; i <= ntokens; i++ {
                 fmt.Fprintf(ftable, "\t\"%v\",\n", tokset[i].name)
         }
         fmt.Fprintf(ftable, "}\n")
 
         // put out names of state names
-        fmt.Fprintf(ftable, "var\tStatenames\t =[]string {\n")
+        fmt.Fprintf(ftable, "var\tyyStatenames\t =[]string {\n")
         //      for i:=TOKSTART; i<=ntokens; i++ {
         //              fmt.Fprintf(ftable, "\t\"%v\",\n", tokset[i].name);
         //      }
         fmt.Fprintf(ftable, "}\n")
 
         fmt.Fprintf(fcode, "switch yynt {\n")
 
         moreprod()
         prdptr[0] = []int{NTBASE, start, 1, 0}
 
@@ skipping 132 matching lines @@
                 levprd[nprod] = 0
         }
 
         //
         // end of all rules
         // dump out the prefix code
         //
 
         fmt.Fprintf(fcode, "\n\t}")
 
-        fmt.Fprintf(ftable, "const      YYEOFCODE       = 1\n")
-        fmt.Fprintf(ftable, "const      YYERRCODE       = 2\n")
-        fmt.Fprintf(ftable, "const      YYMAXDEPTH      = %v\n", stacksize)
+        fmt.Fprintf(ftable, "const      yyEofCode       = 1\n")
+        fmt.Fprintf(ftable, "const      yyErrCode       = 2\n")
+        fmt.Fprintf(ftable, "const      yyMaxDepth      = %v\n", stacksize)
 
         //
         // copy any postfix code
         //
         if t == MARK {
                 if !lflag {
                         fmt.Fprintf(ftable, "\n//line %v:%v\n", infile, lineno)
                 }
                 for {
                         c := getrune(finput)
@@ skipping 345 matching lines @@
 }
 
 //
 // copy the union declaration to the output, and the define file if present
 //
 func cpyunion() {
 
         if !lflag {
                 fmt.Fprintf(ftable, "\n//line %v %v\n", lineno, infile)
         }
-        fmt.Fprintf(ftable, "type\tYYSTYPE\tstruct")
+        fmt.Fprintf(ftable, "type\tyySymType\tstruct")
 
         level := 0
 
 out:
         for {
                 c := getrune(finput)
                 if c == EOF {
                         error("EOF encountered while processing %%union")
                 }
                 ftable.WriteRune(c)
                 switch c {
                 case '\n':
                         lineno++
                 case '{':
                         if level == 0 {
                                 fmt.Fprintf(ftable, "\n\tyys\tint;")
                         }
                         level++
                 case '}':
                         level--
                         if level == 0 {
                                 break out
                         }
                 }
         }
         fmt.Fprintf(ftable, "\n")
-        fmt.Fprintf(ftable, "const MaxStack = %v\n", stacksize)
 }
 
 //
 // saves code between %{ and %}
 //
 func cpycode() {
         lno := lineno
 
         c := getrune(finput)
         if c == '\n' {
@@ skipping 985 matching lines @@
         error("no space in action table")
         return 0
 }
 
 //
 // print the output for the states
 //
 func output() {
         var c, u, v int
 
-        fmt.Fprintf(ftable, "var\tYYEXCA = []int {\n")
+        fmt.Fprintf(ftable, "var\tyyExca = []int {\n")
 
         noset := mkset()
 
         // output the stuff for state i
         for i := 0; i < nstate; i++ {
                 nolook = 0
                 if tystate[i] != MUSTLOOKAHEAD {
                         nolook = 1
                 }
                 closure(i)
@@ skipping 52 matching lines @@
                                 } else {
                                         // potential shift/reduce conflict
                                         precftn(lastred, k, i)
                                 }
                         }
                 }
                 wract(i)
         }
 
         fmt.Fprintf(ftable, "}\n")
-        fmt.Fprintf(ftable, "const\tYYNPROD\t= %v\n", nprod)
-        fmt.Fprintf(ftable, "const\tYYPRIVATE\t= %v\n", PRIVATE)
-        fmt.Fprintf(ftable, "var\tYYTOKENNAMES []string\n")
-        fmt.Fprintf(ftable, "var\tYYSTATES []string\n")
+        fmt.Fprintf(ftable, "const\tyyNprod\t= %v\n", nprod)
+        fmt.Fprintf(ftable, "const\tyyPrivate\t= %v\n", PRIVATE)
+        fmt.Fprintf(ftable, "var\tyyTokenNames []string\n")
+        fmt.Fprintf(ftable, "var\tyyStates []string\n")
 }
 
 //
 // decide a shift/reduce conflict by precedence.
 // r is a rule number, t a token number
 // the conflict is in state s
 // temp1[t] is changed to reflect the action
 //
 func precftn(r, t, s int) {
         var action int
@@ skipping 382 matching lines @@
 
         // now, prepare to put the shift actions into the amem array
         for i = 0; i < ACTSIZE; i++ {
                 amem[i] = 0
         }
         maxa = 0
         for i = 0; i < nstate; i++ {
                 if tystate[i] == 0 && adb > 1 {
                         fmt.Fprintf(ftable, "State %v: null\n", i)
                 }
-                indgo[i] = YYFLAG
+                indgo[i] = yyFlag
         }
 
         i = nxti()
         for i != NOMORE {
                 if i >= 0 {
                         stin(i)
                 } else {
                         gin(-i)
                 }
                 i = nxti()
@@ skipping 151 matching lines @@
                 return
         }
         error("Error; failure to place state %v", i)
 }
 
 //
 // this version is for limbo
 // write out the optimized parser
 //
 func aoutput() {
-        fmt.Fprintf(ftable, "const\tYYLAST\t= %v\n", maxa+1)
-        arout("YYACT", amem, maxa+1)
-        arout("YYPACT", indgo, nstate)
-        arout("YYPGO", pgo, nnonter+1)
+        fmt.Fprintf(ftable, "const\tyyLast\t= %v\n", maxa+1)
+        arout("yyAct", amem, maxa+1)
+        arout("yyPact", indgo, nstate)
+        arout("yyPgo", pgo, nnonter+1)
 }
 
 //
 // put out other arrays, copy the parsers
 //
 func others() {
         var i, j int
 
-        arout("YYR1", levprd, nprod)
+        arout("yyR1", levprd, nprod)
         aryfil(temp1, nprod, 0)
 
         //
         //yyr2 is the number of rules for each production
         //
         for i = 1; i < nprod; i++ {
                 temp1[i] = len(prdptr[i]) - 2
         }
-        arout("YYR2", temp1, nprod)
+        arout("yyR2", temp1, nprod)
 
         aryfil(temp1, nstate, -1000)
         for i = 0; i <= ntokens; i++ {
                 for j := tstates[i]; j != 0; j = mstates[j] {
                         temp1[j] = i
                 }
         }
         for i = 0; i <= nnonter; i++ {
                 for j = ntstates[i]; j != 0; j = mstates[j] {
                         temp1[j] = -i
                 }
         }
-        arout("YYCHK", temp1, nstate)
-        arout("YYDEF", defact, nstate)
+        arout("yyChk", temp1, nstate)
+        arout("yyDef", defact, nstate)
 
         // put out token translation tables
         // table 1 has 0-256
         aryfil(temp1, 256, 0)
         c := 0
         for i = 1; i <= ntokens; i++ {
                 j = tokset[i].value
                 if j >= 0 && j < 256 {
                         if temp1[j] != 0 {
                                 print("yacc bug -- cant have 2 different Ts with same value\n")
                                 print(" %s and %s\n", tokset[i].name, tokset[temp1[j]].name)
                                 nerrors++
                         }
                         temp1[j] = i
                         if j > c {
                                 c = j
                         }
                 }
         }
         for i = 0; i <= c; i++ {
                 if temp1[i] == 0 {
                         temp1[i] = YYLEXUNK
                 }
         }
-        arout("YYTOK1", temp1, c+1)
+        arout("yyTok1", temp1, c+1)
 
         // table 2 has PRIVATE-PRIVATE+256
         aryfil(temp1, 256, 0)
         c = 0
         for i = 1; i <= ntokens; i++ {
                 j = tokset[i].value - PRIVATE
                 if j >= 0 && j < 256 {
                         if temp1[j] != 0 {
                                 print("yacc bug -- cant have 2 different Ts with same value\n")
                                 print(" %s and %s\n", tokset[i].name, tokset[temp1[j]].name)
                                 nerrors++
                         }
                         temp1[j] = i
                         if j > c {
                                 c = j
                         }
                 }
         }
-        arout("YYTOK2", temp1, c+1)
+        arout("yyTok2", temp1, c+1)
 
         // table 3 has everything else
-        fmt.Fprintf(ftable, "var\tYYTOK3\t= []int {\n")
+        fmt.Fprintf(ftable, "var\tyyTok3\t= []int {\n")
         c = 0
         for i = 1; i <= ntokens; i++ {
                 j = tokset[i].value
                 if j >= 0 && j < 256 {
                         continue
                 }
                 if j >= PRIVATE && j < 256+PRIVATE {
                         continue
                 }
 
@@ skipping 90 matching lines @@
         for i = 0; i < len(q); i++ {
                 if q[i] == '"' {
                         s += q[j:i] + "\\"
                         j = i
                 }
         }
         return s + q[j:i]
 }
 
 func usage() {
-        fmt.Fprintf(stderr, "usage: gacc [-o output] [-v parsetable] input\n")
+        fmt.Fprintf(stderr, "usage: goyacc [-o output] [-v parsetable] input\n")
         exit(1)
 }
 
 func bitset(set Lkset, bit int) int { return set[bit>>5] & (1 << uint(bit&31)) }
 
 func setbit(set Lkset, bit int) { set[bit>>5] |= (1 << uint(bit&31)) }
 
 func mkset() Lkset { return make([]int, tbitset) }
 
 //
@@ skipping 145 matching lines @@
         if stderr != nil {
                 stderr.Flush()
                 stderr = nil
         }
         os.Exit(status)
 }
 
 var yaccpar = `
 /*      parser for yacc output  */
 
-var Debug = 0
-
-type Lexer interface {
-        Lex(lval *YYSTYPE) int
-}
-
-const YYFLAG = -1000
-
-func Tokname(yyc int) string {
-        if yyc > 0 && yyc <= len(Toknames) {
-                if Toknames[yyc-1] != "" {
-                        return Toknames[yyc-1]
+var yyDebug = 0
+
+type yyLexer interface {
+        Lex(lval *yySymType) int
+}
+
+const yyFlag = -1000
+
+func yyTokname(yyc int) string {
+        if yyc > 0 && yyc <= len(yyToknames) {
+                if yyToknames[yyc-1] != "" {
+                        return yyToknames[yyc-1]
                 }
         }
         return fmt.Sprintf("tok-%v", yyc)
 }
 
-func Statname(yys int) string {
-        if yys >= 0 && yys < len(Statenames) {
-                if Statenames[yys] != "" {
-                        return Statenames[yys]
+func yyStatname(yys int) string {
+        if yys >= 0 && yys < len(yyStatenames) {
+                if yyStatenames[yys] != "" {
+                        return yyStatenames[yys]
                 }
         }
         return fmt.Sprintf("state-%v", yys)
 }
 
-func lex1(yylex Lexer, lval *YYSTYPE) int {
+func yylex1(yylex yyLexer, lval *yySymType) int {
         var yychar int
         var c int
 
         yychar = yylex.Lex(lval)
         if yychar <= 0 {
-                c = YYTOK1[0]
+                c = yyTok1[0]
                 goto out
         }
-        if yychar < len(YYTOK1) {
-                c = YYTOK1[yychar]
+        if yychar < len(yyTok1) {
+                c = yyTok1[yychar]
                 goto out
         }
-        if yychar >= YYPRIVATE {
-                if yychar < YYPRIVATE+len(YYTOK2) {
-                        c = YYTOK2[yychar-YYPRIVATE]
+        if yychar >= yyPrivate {
+                if yychar < yyPrivate+len(yyTok2) {
+                        c = yyTok2[yychar-yyPrivate]
                         goto out
                 }
         }
-        for i := 0; i < len(YYTOK3); i += 2 {
-                c = YYTOK3[i+0]
+        for i := 0; i < len(yyTok3); i += 2 {
+                c = yyTok3[i+0]
                 if c == yychar {
-                        c = YYTOK3[i+1]
+                        c = yyTok3[i+1]
                         goto out
                 }
         }
         c = 0
 
 out:
         if c == 0 {
-                c = YYTOK2[1] /* unknown char */
-        }
-        if Debug >= 3 {
-                fmt.Printf("lex %.4lux %s\n", yychar, Tokname(c))
+                c = yyTok2[1] /* unknown char */
+        }
+        if yyDebug >= 3 {
+                fmt.Printf("lex %.4x %s\n", uint(yychar), yyTokname(c))
         }
         return c
 }
 
-func Parse(yylex Lexer) int {
+func yyParse(yylex yyLexer) int {
         var yyn int
-        var yylval YYSTYPE
-        var YYVAL YYSTYPE
-        YYS := make([]YYSTYPE, MaxStack)
+        var yylval yySymType
+        var YYVAL yySymType
+        YYS := make([]yySymType, yyMaxDepth)
 
         Nerrs := 0   /* number of errors */
         Errflag := 0 /* error recovery flag */
         yystate := 0
         yychar := -1
         yyp := -1
         goto yystack
 
 ret0:
         return 0
 
 ret1:
         return 1
 
 yystack:
         /* put a state and value onto the stack */
-        if Debug >= 4 {
-                fmt.Printf("char %v in %v", Tokname(yychar), Statname(yystate))
+        if yyDebug >= 4 {
+                fmt.Printf("char %v in %v", yyTokname(yychar), yyStatname(yystate))
         }
 
         yyp++
         if yyp >= len(YYS) {
-                nyys := make([]YYSTYPE, len(YYS)*2)
+                nyys := make([]yySymType, len(YYS)*2)
                 copy(nyys, YYS)
                 YYS = nyys
         }
         YYS[yyp] = YYVAL
         YYS[yyp].yys = yystate
 
 yynewstate:
-        yyn = YYPACT[yystate]
-        if yyn <= YYFLAG {
+        yyn = yyPact[yystate]
+        if yyn <= yyFlag {
                 goto yydefault /* simple state */
         }
         if yychar < 0 {
-                yychar = lex1(yylex, &yylval)
+                yychar = yylex1(yylex, &yylval)
         }
         yyn += yychar
-        if yyn < 0 || yyn >= YYLAST {
+        if yyn < 0 || yyn >= yyLast {
                 goto yydefault
         }
-        yyn = YYACT[yyn]
-        if YYCHK[yyn] == yychar { /* valid shift */
+        yyn = yyAct[yyn]
+        if yyChk[yyn] == yychar { /* valid shift */
                 yychar = -1
                 YYVAL = yylval
                 yystate = yyn
                 if Errflag > 0 {
                         Errflag--
                 }
                 goto yystack
         }
 
 yydefault:
         /* default state action */
-        yyn = YYDEF[yystate]
+        yyn = yyDef[yystate]
         if yyn == -2 {
                 if yychar < 0 {
-                        yychar = lex1(yylex, &yylval)
+                        yychar = yylex1(yylex, &yylval)
                 }
 
                 /* look through exception table */
                 yyxi := 0
                 for {
-                        if YYEXCA[yyxi+0] == -1 && YYEXCA[yyxi+1] == yystate {
+                        if yyExca[yyxi+0] == -1 && yyExca[yyxi+1] == yystate {
                                 break
                         }
                         yyxi += 2
                 }
                 for yyxi += 2; ; yyxi += 2 {
-                        yyn = YYEXCA[yyxi+0]
+                        yyn = yyExca[yyxi+0]
                         if yyn < 0 || yyn == yychar {
                                 break
                         }
                 }
-                yyn = YYEXCA[yyxi+1]
+                yyn = yyExca[yyxi+1]
                 if yyn < 0 {
                         goto ret0
                 }
         }
         if yyn == 0 {
                 /* error ... attempt to resume parsing */
                 switch Errflag {
                 case 0: /* brand new error */
-                        Error("syntax error")
+                        yyError("syntax error")
                         Nerrs++
-                        if Debug >= 1 {
-                                fmt.Printf("%s", Statname(yystate))
-                                fmt.Printf("saw %s\n", Tokname(yychar))
+                        if yyDebug >= 1 {
+                                fmt.Printf("%s", yyStatname(yystate))
+                                fmt.Printf("saw %s\n", yyTokname(yychar))
                         }
                         fallthrough
 
                 case 1, 2: /* incompletely recovered error ... try again */
                         Errflag = 3
 
                         /* find a state where "error" is a legal shift action */
                         for yyp >= len(YYS) {
-                                yyn = YYPACT[YYS[yyp].yys] + YYERRCODE
-                                if yyn >= 0 && yyn < YYLAST {
-                                        yystate = YYACT[yyn] /* simulate a shift of "error" */
-                                        if YYCHK[yystate] == YYERRCODE {
+                                yyn = yyPact[YYS[yyp].yys] + yyErrCode
+                                if yyn >= 0 && yyn < yyLast {
+                                        yystate = yyAct[yyn] /* simulate a shift of "error" */
+                                        if yyChk[yystate] == yyErrCode {
                                                 goto yystack
                                         }
                                 }
 
                                 /* the current yyp has no shift onn "error", pop stack */
-                                if Debug >= 2 {
+                                if yyDebug >= 2 {
                                         fmt.Printf("error recovery pops state %d, uncovers %d\n",
                                                 YYS[yyp].yys, YYS[yyp-1].yys)
                                 }
                                 yyp--
                         }
                         /* there is no state on the stack with an error shift ... abort */
                         goto ret1
 
                 case 3: /* no shift yet; clobber input char */
-                        if Debug >= 2 {
-                                fmt.Printf("error recovery discards %s\n", Tokname(yychar))
-                        }
-                        if yychar == YYEOFCODE {
+                        if yyDebug >= 2 {
+                                fmt.Printf("error recovery discards %s\n", yyTokname(yychar))
+                        }
+                        if yychar == yyEofCode {
                                 goto ret1
                         }
                         yychar = -1
                         goto yynewstate /* try again in the same state */
                 }
         }
 
         /* reduction by production yyn */
-        if Debug >= 2 {
-                fmt.Printf("reduce %v in:\n\t%v", yyn, Statname(yystate))
+        if yyDebug >= 2 {
+                fmt.Printf("reduce %v in:\n\t%v", yyn, yyStatname(yystate))
         }
 
         yynt := yyn
         yypt := yyp
-
-        yyp -= YYR2[yyn]
+        _ = yypt                // guard against "declared and not used"
+
+        yyp -= yyR2[yyn]
         YYVAL = YYS[yyp+1]
 
         /* consult goto table to find next state */
-        yyn = YYR1[yyn]
-        yyg := YYPGO[yyn]
+        yyn = yyR1[yyn]
+        yyg := yyPgo[yyn]
         yyj := yyg + YYS[yyp].yys + 1
 
-        if yyj >= YYLAST {
-                yystate = YYACT[yyg]
+        if yyj >= yyLast {
+                yystate = yyAct[yyg]
         } else {
-                yystate = YYACT[yyj]
-                if YYCHK[yystate] != -yyn {
-                        yystate = YYACT[yyg]
+                yystate = yyAct[yyj]
+                if yyChk[yystate] != -yyn {
+                        yystate = yyAct[yyg]
                 }
         }
         // dummy call; replaced with literal code
         yyrun()
         goto yystack /* stack new state and value */
 }
 `