func main1(in string) (err error) { var out io.Writer if nm := *oOut; nm != "" { var f *os.File var e error if f, err = os.Create(nm); err != nil { return err } defer func() { if e := f.Close(); e != nil && err == nil { err = e } }() w := bufio.NewWriter(f) defer func() { if e := w.Flush(); e != nil && err == nil { err = e } }() buf := bytes.NewBuffer(nil) out = buf defer func() { var dest []byte if dest, e = format.Source(buf.Bytes()); e != nil { dest = buf.Bytes() } if _, e = w.Write(dest); e != nil && err == nil { err = e } }() } var rep io.Writer if nm := *oReport; nm != "" { f, err := os.Create(nm) if err != nil { return err } defer func() { if e := f.Close(); e != nil && err == nil { err = e } }() w := bufio.NewWriter(f) defer func() { if e := w.Flush(); e != nil && err == nil { err = e } }() rep = w } var xerrors []byte if nm := *oXErrors; nm != "" { b, err := ioutil.ReadFile(nm) if err != nil { return err } xerrors = b } p, err := y.ProcessFile(token.NewFileSet(), in, &y.Options{ //NoDefault: *oNoDefault, AllowConflicts: true, Closures: *oClosures, LA: *oLA, Reducible: *oReducible, Report: rep, Resolved: *oResolved, XErrorsName: *oXErrors, XErrorsSrc: xerrors, }) if err != nil { return err } if fn := *oXErrorsGen; fn != "" { f, err := os.OpenFile(fn, os.O_RDWR|os.O_CREATE, 0666) if err != nil { return err } b := bufio.NewWriter(f) if err := p.SkeletonXErrors(b); err != nil { return err } if err := b.Flush(); err != nil { return err } if err := f.Close(); err != nil { return err } } msu := make(map[*y.Symbol]int, len(p.Syms)) // sym -> usage for nm, sym := range p.Syms { if nm == "" || nm == "ε" || nm == "$accept" || nm == "#" { continue } msu[sym] = 0 } var minArg, maxArg int for _, state := range p.Table { for _, act := range state { msu[act.Sym]++ k, arg := act.Kind() if k == 'a' { continue } if k == 'r' { arg = -arg } minArg, maxArg = mathutil.Min(minArg, arg), mathutil.Max(maxArg, arg) } } su := make(symsUsed, 0, len(msu)) for sym, used := range msu { su = append(su, symUsed{sym, used}) } sort.Sort(su) // ----------------------------------------------------------- Prologue f := strutil.IndentFormatter(out, "\t") f.Format("// CAUTION: Generated file - DO NOT EDIT.\n\n") f.Format("%s", injectImport(p.Prologue)) f.Format(` type %[1]sSymType %i%s%u type %[1]sXError struct { state, xsym int } `, *oPref, p.UnionSrc) // ---------------------------------------------------------- Constants nsyms := map[string]*y.Symbol{} a := make([]string, 0, len(msu)) maxTokName := 0 for sym := range msu { nm := sym.Name if nm == "$default" || nm == "$end" || sym.IsTerminal && nm[0] != '\'' && sym.Value > 0 { maxTokName = mathutil.Max(maxTokName, len(nm)) a = append(a, nm) } nsyms[nm] = sym } sort.Strings(a) f.Format("\nconst (%i\n") for _, v := range a { nm := v switch nm { case "error": nm = *oPref + "ErrCode" case "$default": nm = *oPref + "Default" case "$end": nm = *oPref + "EofCode" } f.Format("%s%s = %d\n", nm, strings.Repeat(" ", maxTokName-len(nm)+1), nsyms[v].Value) } minArg-- // eg: [-13, 42], minArg -14 maps -13 to 1 so zero cell values -> empty. f.Format("\n%sMaxDepth = 200\n", *oPref) f.Format("%sTabOfs = %d\n", *oPref, minArg) f.Format("%u)") // ---------------------------------------------------------- Variables f.Format("\n\nvar (%i\n") // Lex translation table f.Format("%sXLAT = map[int]int{%i\n", *oPref) xlat := make(map[int]int, len(su)) var errSym int for i, v := range su { if v.sym.Name == "error" { errSym = i } xlat[v.sym.Value] = i f.Format("%6d: %3d, // %s (%dx)\n", v.sym.Value, i, v.sym.Name, msu[v.sym]) } f.Format("%u}\n") // Symbol names f.Format("\n%sSymNames = []string{%i\n", *oPref) for _, v := range su { f.Format("%q,\n", v.sym.Name) } f.Format("%u}\n") // Reduction table f.Format("\n%sReductions = map[int]struct{xsym, components int}{%i\n", *oPref) for r, rule := range p.Rules { f.Format("%d: {%d, %d},\n", r, xlat[rule.Sym.Value], len(rule.Components)) } f.Format("%u}\n") // XError table f.Format("\n%[1]sXErrors = map[%[1]sXError]string{%i\n", *oPref) for _, xerr := range p.XErrors { state := xerr.Stack[len(xerr.Stack)-1] xsym := -1 if xerr.Lookahead != nil { xsym = xlat[xerr.Lookahead.Value] } f.Format("%[1]sXError{%d, %d}: \"%s\",\n", *oPref, state, xsym, xerr.Msg) } f.Format("%u}\n\n") // Parse table tbits := 32 switch n := mathutil.BitLen(maxArg - minArg + 1); { case n < 8: tbits = 8 case n < 16: tbits = 16 } f.Format("%sParseTab = [%d][]uint%d{%i\n", *oPref, len(p.Table), tbits) nCells := 0 var tabRow sortutil.Uint64Slice for si, state := range p.Table { tabRow = tabRow[:0] max := 0 for _, act := range state { sym := act.Sym xsym, ok := xlat[sym.Value] if !ok { panic("internal error 001") } max = mathutil.Max(max, xsym) kind, arg := act.Kind() switch kind { case 'a': arg = 0 case 'r': arg *= -1 } tabRow = append(tabRow, uint64(xsym)<<32|uint64(arg-minArg)) } nCells += max tabRow.Sort() col := -1 if si%5 == 0 { f.Format("// %d\n", si) } f.Format("{") for i, v := range tabRow { xsym := int(uint32(v >> 32)) arg := int(uint32(v)) if col+1 != xsym { f.Format("%d: ", xsym) } switch { case i == len(tabRow)-1: f.Format("%d", arg) default: f.Format("%d, ", arg) } col = xsym } f.Format("},\n") } f.Format("%u}\n") fmt.Fprintf(os.Stderr, "Parse table entries: %d of %d, x %d bits == %d bytes\n", nCells, len(p.Table)*len(msu), tbits, nCells*tbits/8) if n := p.ConflictsSR; n != 0 { fmt.Fprintf(os.Stderr, "conflicts: %d shift/reduce\n", n) } if n := p.ConflictsRR; n != 0 { fmt.Fprintf(os.Stderr, "conflicts: %d reduce/reduce\n", n) } f.Format(`%u) var %[1]sDebug = 0 type %[1]sLexer interface { Lex(lval *%[1]sSymType) int Error(s string) } type %[1]sLexerEx interface { %[1]sLexer Reduced(rule, state int, lval *%[1]sSymType) bool } func %[1]sSymName(c int) (s string) { x, ok := %[1]sXLAT[c] if ok { return %[1]sSymNames[x] } return __yyfmt__.Sprintf("%%d", c) } func %[1]slex1(yylex %[1]sLexer, lval *%[1]sSymType) (n int) { n = yylex.Lex(lval) if n <= 0 { n = %[1]sEofCode } if %[1]sDebug >= 3 { __yyfmt__.Printf("\nlex %%s(%%#x %%d), %[4]s: %[3]s\n", %[1]sSymName(n), n, n, %[4]s) } return n } func %[1]sParse(yylex %[1]sLexer, cache *[]%[1]sSymType) int { const yyError = %[2]d yyEx, _ := yylex.(%[1]sLexerEx) var yyn int var yylval %[1]sSymType var yyVAL %[1]sSymType yyS := *cache Nerrs := 0 /* number of errors */ Errflag := 0 /* error recovery flag */ yyerrok := func() { if %[1]sDebug >= 2 { __yyfmt__.Printf("yyerrok()\n") } Errflag = 0 } _ = yyerrok yystate := 0 yychar := -1 var yyxchar int var yyshift int yyp := -1 goto yystack ret0: return 0 ret1: return 1 yystack: /* put a state and value onto the stack */ yyp++ if yyp >= len(yyS) { nyys := make([]%[1]sSymType, len(yyS)*2) copy(nyys, yyS) yyS = nyys *cache = yyS } yyS[yyp] = yyVAL yyS[yyp].yys = yystate yynewstate: if yychar < 0 { yychar = %[1]slex1(yylex, &yylval) var ok bool if yyxchar, ok = %[1]sXLAT[yychar]; !ok { yyxchar = len(%[1]sSymNames) // > tab width } } if %[1]sDebug >= 4 { var a []int for _, v := range yyS[:yyp+1] { a = append(a, v.yys) } __yyfmt__.Printf("state stack %%v\n", a) } row := %[1]sParseTab[yystate] yyn = 0 if yyxchar < len(row) { if yyn = int(row[yyxchar]); yyn != 0 { yyn += %[1]sTabOfs } } switch { case yyn > 0: // shift yychar = -1 yyVAL = yylval yystate = yyn yyshift = yyn if %[1]sDebug >= 2 { __yyfmt__.Printf("shift, and goto state %%d\n", yystate) } if Errflag > 0 { Errflag-- } goto yystack case yyn < 0: // reduce case yystate == 1: // accept if %[1]sDebug >= 2 { __yyfmt__.Println("accept") } goto ret0 } if yyn == 0 { /* error ... attempt to resume parsing */ switch Errflag { case 0: /* brand new error */ if %[1]sDebug >= 1 { __yyfmt__.Printf("no action for %%s in state %%d\n", %[1]sSymName(yychar), yystate) } msg, ok := %[1]sXErrors[%[1]sXError{yystate, yyxchar}] if !ok { msg, ok = %[1]sXErrors[%[1]sXError{yystate, -1}] } if !ok && yyshift != 0 { msg, ok = %[1]sXErrors[%[1]sXError{yyshift, yyxchar}] } if !ok { msg, ok = %[1]sXErrors[%[1]sXError{yyshift, -1}] } if !ok || msg == "" { msg = "syntax error" } yylex.Error(msg) Nerrs++ fallthrough case 1, 2: /* incompletely recovered error ... try again */ Errflag = 3 /* find a state where "error" is a legal shift action */ for yyp >= 0 { row := %[1]sParseTab[yyS[yyp].yys] if yyError < len(row) { yyn = int(row[yyError])+%[1]sTabOfs if yyn > 0 { // hit if %[1]sDebug >= 2 { __yyfmt__.Printf("error recovery found error shift in state %%d\n", yyS[yyp].yys) } yystate = yyn /* simulate a shift of "error" */ goto yystack } } /* the current p has no shift on "error", pop stack */ if %[1]sDebug >= 2 { __yyfmt__.Printf("error recovery pops state %%d\n", yyS[yyp].yys) } yyp-- } /* there is no state on the stack with an error shift ... abort */ if %[1]sDebug >= 2 { __yyfmt__.Printf("error recovery failed\n") } goto ret1 case 3: /* no shift yet; clobber input char */ if %[1]sDebug >= 2 { __yyfmt__.Printf("error recovery discards %%s\n", %[1]sSymName(yychar)) } if yychar == %[1]sEofCode { goto ret1 } yychar = -1 goto yynewstate /* try again in the same state */ } } r := -yyn x0 := %[1]sReductions[r] x, n := x0.xsym, x0.components yypt := yyp _ = yypt // guard against "declared and not used" yyp -= n if yyp+1 >= len(yyS) { nyys := make([]%[1]sSymType, len(yyS)*2) copy(nyys, yyS) yyS = nyys *cache = yyS } yyVAL = yyS[yyp+1] /* consult goto table to find next state */ exState := yystate yystate = int(%[1]sParseTab[yyS[yyp].yys][x])+%[1]sTabOfs /* reduction by production r */ if %[1]sDebug >= 2 { __yyfmt__.Printf("reduce using rule %%v (%%s), and goto state %%d\n", r, %[1]sSymNames[x], yystate) } switch r {%i `, *oPref, errSym, *oDlvalf, *oDlval) for r, rule := range p.Rules { if rule.Action == nil { continue } action := rule.Action.Values if len(action) == 0 { continue } if len(action) == 1 { part := action[0] if part.Type == parser.ActionValueGo { src := part.Src src = src[1 : len(src)-1] // Remove lead '{' and trail '}' if strings.TrimSpace(src) == "" { continue } } } components := rule.Components typ := rule.Sym.Type max := len(components) if p := rule.Parent; p != nil { max = rule.MaxParentDlr components = p.Components } f.Format("case %d: ", r) for _, part := range action { num := part.Num switch part.Type { case parser.ActionValueGo: f.Format("%s", part.Src) case parser.ActionValueDlrDlr: f.Format("yyVAL.%s", typ) if typ == "" { panic("internal error 002") } case parser.ActionValueDlrNum: typ := p.Syms[components[num-1]].Type if typ == "" { panic("internal error 003") } f.Format("yyS[yypt-%d].%s", max-num, typ) case parser.ActionValueDlrTagDlr: f.Format("yyVAL.%s", part.Tag) case parser.ActionValueDlrTagNum: f.Format("yyS[yypt-%d].%s", max-num, part.Tag) } } f.Format("\n") } f.Format(`%u } if yyEx != nil && yyEx.Reduced(r, exState, &yyVAL) { return -1 } goto yystack /* stack new state and value */ } %[2]s `, *oPref, p.Tail) _ = oNoLines //TODO Ignored for now return nil }
func (y *y) report(w io.Writer) { f := strutil.IndentFormatter(w, " ") if y.opts.debugSyms { var a []string max := 0 for _, v := range y.syms { max = mathutil.Max(max, len(v.Name)) } for _, v := range y.syms { a = append(a, fmt.Sprintf("%[2]*[1]s val %6[3]d, id %3[5]d, type %[4]q", v.Name, -max-1, v.Value, v.Type, v.id), ) } sort.Strings(a) for _, v := range a { f.Format("%s\n", v) } } for si, state := range y.States { f.Format("state %d //", si) syms, la := state.Syms0() for _, s := range syms { switch { case s == nil: f.Format(" <?>") case !s.IsTerminal: f.Format(" <%s>", s) default: f.Format(" %s", s) } } if la != nil { f.Format(" [%s]", la) } f.Format("%i\n\n") switch { case y.opts.Closures: for _, item := range state.kernel.closure(y) { rule := y.Rules[item.rule()] f.Format("%v", item.dump(y)) if y.opts.LA || item.next(y) == nil { switch i, ok := state.kernel.find(item); { case ok: f.Format(" [%s]", state.lookahead[i].dump(y)) default: if i, ok := state.xitems.find(item); ok { f.Format(" [%s]", state.xla[i].dump(y)) } } } if as := assocStr[rule.Associativity]; as != "" || rule.Precedence >= 0 { f.Format(" // assoc %s, prec %d", as, rule.Precedence) } f.Format("\n") } default: for i, item := range state.kernel { rule := y.Rules[item.rule()] f.Format("%v", item.dump(y)) if y.opts.LA || item.dot() == len(rule.Components) { f.Format(" [%s]", state.lookahead[i].dump(y)) } if as := assocStr[rule.Associativity]; as != "" || rule.Precedence >= 0 { f.Format(" // assoc %s, prec %d", as, rule.Precedence) } f.Format("\n") } for i, item := range state.xitems { rule := y.Rules[item.rule()] f.Format("%v [%s]", item.dump(y), state.xla[i].dump(y)) if as := assocStr[rule.Associativity]; as != "" || rule.Precedence >= 0 { f.Format(" // assoc %s, prec %d", as, rule.Precedence) } f.Format("\n") } } f.Format("%i\n") a := []string{} var w int for sym := range state.actions { w = mathutil.Max(w, len(sym.Name)) a = append(a, sym.Name) } sort.Strings(a) type conflict struct { sym *Symbol acts []action } var conflicts []conflict for _, nm := range a { sym := y.Syms[nm] acts := state.actions[sym] act := acts[0] f.Format("%-*s %v", w, nm, act) if act.kind == 'r' { f.Format(" (%s)", y.Rules[act.arg].Sym.Name) } if len(acts) > 1 { conflicts = append(conflicts, conflict{sym, acts}) } f.Format("\n") } a = a[:0] w = 0 for sym := range state.gotos { w = mathutil.Max(w, len(sym.Name)) a = append(a, sym.Name) } sort.Strings(a) for i, nm := range a { if i == 0 { f.Format("\n") } f.Format("%-*s %v\n", w, nm, state.gotos[y.Syms[nm]]) } for i, conflict := range conflicts { if i == 0 { if len(state.gotos) != 0 { f.Format("\n") } } sym := conflict.sym nm := sym.Name f.Format("conflict on %v", nm) for _, act := range conflict.acts { f.Format(", %s", act.String()) } if as := assocStr[sym.Associativity]; as != "" || sym.Precedence >= 0 { f.Format(" // %v: assoc %s, prec %d", nm, assocStr[sym.Associativity], sym.Precedence) } f.Format("\n") } if len(state.resolved) != 0 { f.Format("\n") } for _, v := range state.resolved { f.Format("%s\n", v) } f.Format("%u%u\n") } }